Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Logische Programmierung mit PROLOG Klaus Becker 2007.

Ähnliche Präsentationen


Präsentation zum Thema: "Logische Programmierung mit PROLOG Klaus Becker 2007."—  Präsentation transkript:

1 Logische Programmierung mit PROLOG Klaus Becker 2007

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

3 3 Teil 1 Fakten und Regeln

4 4 (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 Die Welt der griechischen Götter

5 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 6 Modellierungsansatz Objekte werden mit Konstanten (allg. mit Termen) beschrieben, Eigenschaften und Beziehungen mit Hilfe von Prädikaten. Fakten: weiblich(hera). maennlich(zeus). verheiratet(zeus, hera). ist verheiratet mit Hera (weiblich) Zeus (männlich) Konstante Prädikat

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

8 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). Miniwelt Zeus=Maia Zeus=Dione | | Hermes Aphrodite Regeln: vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). Fakten: vater(zeus, hermes). vater(zeus, aphrodite). indirekte Beschreibung direkte Beschreibung

9 9 Regeln Regeln sind Wenn-Dann-Aussagen. Regeln: vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). VariableImplikation 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. Und Regelrumpf (Bedingungen) Regelkopf (Folgerung)

10 10 Rekursive Regeln Das Prädikat im Regelkopf darf im Regelrumpf vorkommen. Regeln: vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). 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. Regelrumpf (Bedingungen) Regelkopf (Folgerung)

11 11 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). Modellwelt vorfahr(cronus, zeus). vorfahr(cronus, hebe).... Beschreibung der Miniwelt kind(zeus, cronus). vorfahr(X, Y) :- kind(Y, X). vorfahr(cronus, zeus). Logische Herleitung kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). vorfahr(cronus, hebe). Die in der Modellwelt geltenden Sachverhalte ergeben sich aus der (in/direkten) Beschreibung der Miniwelt durch logische Herleitungen.

12 12 Modus Ponens 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). Zur Herleitung der Sachverhalte 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. kind(zeus, cronus). vorfahr(X, Y) :- kind(Y, X). vorfahr(cronus, zeus). kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). vorfahr(cronus, hebe).

13 13 Von der Miniwelt zur Modellwelt MiniweltModellwelt Cronus | Zeus | Hebe... kind(hebe, zeus). kind(hebe, hera). kind(zeus, rhea). kind(zeus, cronus). kind(rhea, uranus).... vorfahr(cronus, zeus). vorfahr(cronus, hebe).... Beschreibung der Miniwelt 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). Mit Hilfe von Fakten und Regeln wird implizit eine Modellwelt konstruiert, die die Miniwelt (in Teilen) beschreiben soll.

14 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 hergeleitet werden können. Dies sind die direkt genannten Fakten und die mit Hilfe der logischen Schlussregel "modus ponens" herleitbaren Fakten (closed-world- assumption).

15 15 Übung Gegeben ist die folgende (unvollständige) Beschreibung der Miniwelt. Welche der angezeigten Sachverhalte gelten in der Modellwelt? Fakten und Regeln: maennlich(cronus). maennlich(zeus). maennlich(hades). maennlich(poseidon). weiblich(rhea). weiblich(hera). kind(zeus, rhea). kind(hera, rhea). kind(hades, rhea). kind(hestia, rhea). vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). bruder(X, Y) :- maennlich(X), vater(Z, X), vater(Z, Y). bruder(X, Y) :- maennlich(X), mutter(Z, X), mutter(Z, Y). Cronus = Rhea | | | | | | Hestia | Poseidon | Demeter=Zeus Hades Zeus = Hera bruder(zeus, hades). bruder(hades, zeus). bruder(zeus, poseidon). bruder(zeus, hestia). bruder(zeus, zeus). schwester(hera, hestia).

16 16 Übung Ergänzen Sie die Regeln zur Beschreibung der Miniwelt. Gehen Sie davon aus, dass alle Fakten zu den Prädikaten "maennlich", "weiblich" und "kind" in der Faktenbasis korrekt aufgelistet sind. Fakten und Regeln: maennlich(cronus)... weiblich(rhea)... kind(zeus, rhea)... vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). elternteil(X, Y) :- bruder(X, Y) :- maennlich(X), elternteil(E, X), elternteil(E, Y), X \== Y. schwester(X, Y):- sohn(X, Y):- oma(X, Y) :- Cronus = Rhea | | | | | | Hestia | Poseidon | Demeter=Zeus Hades Zeus = Hera

17 17 Teil 2 Anfragen

18 18 Logik-Programme maennlich(cronus). maennlich(zeus)... weiblich(rhea). weiblich(demeter)... kind(hestia, rhea). kind(hades, rhea)... vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). ?- weiblich(Frau). Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage. Wissensbasis Anfrage

19 19 SWI-Prolog-Editor Wissensbasis Anfrage

20 20 PROLOG PROLOG steht für 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 für den Unterricht geeignete Entwicklungsumgebung zur Erstellung von PROLOG-Programmen, die von G. Röhner entwickelt wurde. Installationshinweise: Installieren Sie zunächst SWI-PROLOG. Installieren Sie anschließend den SWI-PROLOG-Editor.

21 21 Wissensbasis erzeugen Geben Sie die Fakten und Regeln zur Beschreibung der Miniwelt ein oder laden Sie die entsprechende Quelldatei. Bevor Sie Anfragen an die Wissensbasis stellen können, muss diese Wissensbasis erst erzeugt werden. Rufen Sie hierzu das Systemprädikat "consult" auf. Mit consult( ). werden aus der angegebenen Datei die Fakten und Regeln in die Wissensbasis eingelesen. Consultieren Wenn der PROLOG- Interpreter keine Syntaxfehler gefunden hat, bestätigt er die erfolgreiche Erzeugung der Wissensbasis mit "Yes".

22 22 Anfrage stellen Geben Sie die jetzt die Anfrage im unteren Fenster (hinter "?-") ein. Mit der "Return"-Taste erhält man das erste Ergebnis (falls es eines gibt), mit jedem weiteren "Return" ggf. weitere Ergebnisse. Findet der PROLOG- Interpreter keine weiteren Ergebnisse, so zeigt er dies mit "No" an. Das trennende Semikolon kann als "oder" gedeutet werden. Anfrage Ergebnisse

23 23 Übung Laden Sie die Datei "Familie1.pl" und erzeugen Sie mit "Consultieren" die zugehörige Wissensbasis. Lassen Sie PROLOG die folgenden Anfragen auswerten. Formulieren Sie die Anfragen auch umgangssprachlich. ?- weiblich(hera).% Ist Hera weiblich? ?- vater(zeus, hades). ?- weiblich(Frau).% Wer ist weiblich? ?- mutter(M, zeus). ?- mutter(rhea, Kind). ?- mutter(hera, Kind). ?- mutter(M, K). ?- mutter(M, K), weiblich(K). ?- vater(V, _Kind). ?- weiblich(T), mutter(_, T). Was hat es mit dem "_" auf sich?

24 24 Übung Entwickeln Sie eine Wissensbasis zu einer eigenen Familien-Welt (Sie können auch die Götter-Welt erweitern). Folgende Prädikate können Sie dabei festgelegen: maennlich, weiblich, kind, vater, mutter, vorfahr, sohn, tochter, grossvater, grossmutter, enkel, geschwister, bruder, schwester, onkel, tante,... Testen Sie ihre Wissensbasis mit Hilfe geeigneter Anfragen. Hinweise zur PROLOG-Syntax: 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.

25 25 Übung An einem runden Tisch sitzen sechs Personen. Erstellen Sie eine Wissensbasis mit dem Prädikat "rechtsneben(X, Y)". Ermitteln Sie soweit möglich Antworten auf folgende Anfragen: Wer sitzt rechts neben Anna? Von wem ist Anke der linke Nachbar? Wer sind die Nachbarn von Alfred? Geben Sie Regeln an für: - linksneben(X, Y) - nachbarvon(Mitte, Links, Rechts) - gegenueber(Hier, Dort) Anna Anton Alfred Anke Arthur Alba siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

26 26 Übung Wir betrachten die unten abgebildete Blockwelt. Wie könnte man die Struktur dieser Blockwelt mit Hilfe von Fakten und Regeln beschreiben? p1 a p2 e c p3 b f g d siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

27 27 Anfragen 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). Der Programm-Interpreter erzeugt die Ergebnisse der Anfrage. Wissensbasis Anfrage Frau = hera; Frau = maia; No. Ergebnisse Der Programm-Interpreter sucht hierzu alle Instanzen der Anfrage, die in der Modellwelt gelten bzw. aus der Wissensbasis herleitbar sind.

28 28 Ja-Nein-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

29 29 Ergänzungsanfragen 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

30 30 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 (von einem Kind)? V = zeus; V = zeus; No. Anonyme Variablen werden nicht instanziert. Anonyme Variable

31 31 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). ?- vater(maia, hermes). % vater(+Vater, +Kind) ?- vater(V, hermes). % vater(-Vater, +Kind) ?- vater(zeus, K). % vater(+Vater, -Kind) ?- vater(V, K). % vater(-Vater, -Kind) instanziert offen Kann in beiden Rollen (+ / -) verwendet werden Die Datenflussrichtung kann flexibel gestaltet werden.

32 32

33 33 Teil 3 Das Berechnungskonzept

34 34 Gegeben: Logik-Programm (Wissensbasis + Anfrage) Suche nach Anfrageergebnissen 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). maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(zeus, apollo). vater(zeus, hermes).... Problem: Wie erzeugt man systematisch Anfrageergebnisse? V = zeus. Gesucht: Instanzen der Anfrage, die zur Modellwelt gehören induzierte Modellwelt

35 35 Gegeben: Logik-Programm (Wissensbasis + Anfrage) Ein einfaches Beispiel a. b. c :- a, d. c :- e. d :- b. ?- c. Beachte: Wir betrachten zunächst den Fall, dass keine Variablen im Logik-Programm vorkommen. Yes. Gesucht: Verfahren zur Bestimmung der Anfrageergebnisse

36 36 Logik-Programm Herleitung mit "modus ponens" a. b. c :- a, d. c :- e. d :- b. ?- c. Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel modus ponens: Herleitung b b d d Yes. a -- a d a d c c b -- b a 1,..., a n a 1... a n b b Wenn die Implikation a 1... a n b gilt und alle Teilbedingungen a 1,..., a n nachgewiesen sind, dann kann hieraus die Konklusion b hergeleitet werden.

37 37 Programm "Rückwärts"-Herleitung a. b. c :- a, d. c :- e. d :- b. ?- c. b b d d Yes. a -- a d a d c c b -- b ? c. a d c. ? a, d. a. ? d. b d. ? b. b. ? Rückwärts-HerleitungVorwärts-Herleitung

38 38 "Rückwärts"-Herleitung Zeige c Da a d c, reicht es: Zeige a, d. Da a, reicht es: Zeige d. Da b d, reicht es: Zeige b. Da b, Fertig! Rückwärts-Deutung Programm a. b. c :- a, d. c :- e. d :- b. ?- c. Yes. ? c. a d c. ? a, d. a. ? d. b d. ? b. b. ? Rückwärts-Herleitung

39 39 Deutung als Widerspruchsbeweis Ang., c gilt nicht, Da a d c, gilt dann a nicht oder d nicht. Da a, gilt dann d nicht. Da b d, gilt dann b nicht. Da b, Widerspruch! Rückwärts-Deutung Programm a. b. c :- a, d. c :- e. d :- b. ?- c. Yes. ? c. a d c. ? a, d. a. ? d. b d. ? b. b. ?  Rückwärts-Herleitung

40 40 Resolution Resolutionsschritte Programm a. b. c :- a, d. c :- e. d :- b. ?- c. Yes. ? c. a d c. ? a, d. a. ? d. b d. ? b. b. ?  Rückwärts-Herleitung -c -a -d c. -a -d. a. -d. -b d. -b. b.  Für Herleitungen mit Implikationen gilt: Rückwärts mit modus ponens entspricht vorwärts mit Resolution. a 1... a n c, b 1... b m -c a 1... a n b 1... b m a 1,..., a n, a 1... a n b b

41 41 Sackgassen Es ergeben sich oft verschiedene Möglichkeiten, wie eine Herleitung weitergeführt werden kann. Nicht alle diese Herleitungen sind aber erfolgreich. Eine passende Herleitung muss man daher in der Regel suchen. ? c. a d c. ? a, d. a. ? d. b d. ? b. b. ? Herleitung mit Sackgasse ? c. e c. ? e. Programm a. b. c :- a, d. c :- e. d :- b. ?- c. Yes. erfolgreiche Herleitung

42 42 Backtracking Backtracking: Wenn der erste Term des Ziels mit keinem Regelkopf übereinstimmt, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl. Herleitung mit Sackgasse ? c.e c. ? e.zurücksetzen ? c.a d c. ? a, d.a. ? d.b d. ? b.b. ? Programm a. b. c :- e. c :- a, d. d :- b. ?- c. Yes. erfolgreiche Herleitung

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

44 44 /*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). Substitution X = V, Y = hermes. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). Regel 7 Auswertung von Anfragen Regelanwendung: Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung (Substitution) gleichgemacht werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.

45 45 /*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). Substitution X = V, Y = hermes. V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). Regel 7 5 Auswertung von Anfragen Regelanwendung: Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung gleichgemacht (unifiziert) werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.

46 46 /*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). Substitution X = V, Y = hermes. V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). Regel 7 5 No Auswertung von Anfragen Backtracking: Wenn die erste Zielbedingung mit keinem Fakt / Regelkopf gleichgemacht werden kann, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.

47 47 /*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). Substitution X = V, Y = hermes. V = maia. V = zeus. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). ?- maennlich(zeus). Regel 7 5 No 6 Auswertung von Anfragen

48 48 /*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). Substitution X = V, Y = hermes. V = maia. V = zeus. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). ?- kind(hermes, V), maennlich(V). ?- maennlich(zeus). Regel 7 5 No 6 1 Auswertung von Anfragen Ergebnis: Ist keine Zielbedingung mehr vorhanden, so liefert die Variablenbindung das gesuchte Ergebnis.

49 49 /*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). Beweisbaum Veranschaulichung: Die Herleitung eines Berechnungsergebnisses kann mit Hilfe eines Beweisbaumes verdeutlicht werden. vater(V, hermes) kind(hermes, V) maennlich(V) kind(hermes, maia) kind(hermes, zeus) maennlich(zeus) UND-Knoten ODER-Knoten X = V, Y = hermes. V = maia.V = zeus.

50 50 Trace einer Beweissuche vater(V, hermes) kind(hermes, V) maennlich(V) kind(hermes, maia) kind(hermes, zeus) maennlich(zeus) UND-Knoten ODER-Knoten ?- 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. CALL: Teilziel aufrufen EXIT: Zeilziel erfolgr. b. REDO: Teilziel nochmal b. FAIL: Teilziel erfolglos b.

51 51 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 (wendet die Schlussregel "modus ponens" an) Suchalgorithmus (benutzt Backtracking)

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

53 53 Übung 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). p1 a p2 e c p3 b f g d ?- ueber(X, g). Schalten Sie den Trace-Modus ein und verfolgen Sie die Erzeugung der Berechnungsergebnisse. Mit welcher Strategie werden die zu überprüfenden Zielbedingungen von der Inferenzmaschine ausgewählt?

54 54 Übung Wir betrachten die beiden folgenden Logik-Programme: 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? Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). ?- vorfahr(A, B). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B).

55 55 Grenzen der Logik kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(maia, hermes). Die Logik-Programme sind logisch äquivalent. Aus beiden Programmen lassen sich dieselben Herleitungen erzeugen. Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). ?- vorfahr(A, B). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B).

56 56 Grenzen der Logik Die Inferenzmaschine liefert unterschiedliche Berechnungsergebnisse. Diese werden durch die Algorithmen der Inferenzmaschine festgelegt. Die Reihenfolge der Regeln und der beteiligten Bedingungen spielen hierbei eine entscheidende Rolle. Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). ?- vorfahr(A, B). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). Substitution X = A, Y = B B = hermes, A = maia. Ziel ?- vorfahr(A, B). ?- kind(B, A). 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),......

57 57 Deklarative Semantik Deklarative Semantik eines Logik-Programms Menge der Instanzen der Anfrage, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel modus ponens hergeleitet werden können. 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).

58 58 Prozedurale Semantik 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 eines Logik-Programms Menge der Instanzen der Anfrage, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt. Logisches Programm (Wissensbasis + Anfrage):

59 59 Teil 4 Listenverarbeitung

60 60 Wer wird eingeladen? Walter Ralph Anja Claudius Klaus Gaby...

61 61 Listen Listen werden in vielen Anwendungen benötigt, um Datenelemente flexibel verwalten zu können. Insbesondere möchte man Datenelemente hinzufügen und auch wieder entfernen können. Walter Ralph Anja Claudius Klaus Gaby...

62 62 Beispiele: [ walter, ralph, anja, claudius, gaby ] [a, b, c, d, e] [1, [1, 2], [[1], [2], [3]]] [] Listen Eine Liste ist eine geordnete Folge von Elementen beliebiger Länge. Die Elemente der Liste können (in Prolog) beliebige Terme sein: Konstanten, Zahlen, Variablen, Strukturen und auch wieder Listen. Die Listenelemente können also unterschiedliche Datentypen aufweisen.

63 63 Beispiel:. (a,. (b,. (c, []))) [a, b, c]. (c, []) [c]. (b, [c]) [b, c]. (a, [b, c]) [a, b, c] Listenkonstruktoren Alle Listen können mit Hilfe der beiden folgenden Konstruktoren aufgebaut werden: [] leere Liste. hinzufügen Struktur:.(Element, Liste) NeueListe

64 64 Übung Geben Sie im Anfragefenster folgende Anfrage ein: ?- display([a, b, c]). Die Auswertung dieser Anfrage liefert die Struktur der Liste:.(a,.(b,.(c, []))) Yes Testen Sie auch weitere Listendarstellungen.

65 65 Beispiele: [K | R] = [a, b, c] K = a, R = [b, c] [K | R] = [5] K = 5, R = [] [K | R] = [[1], [3]] K = [1], R = [[3]] [E1, E2 | R] = [a, b, c] E1 = a, E2 = b, R = [c] [E1, E2 | R] = [a] Unifikation nicht möglich... Unifikation bei Listen Jede Liste lässt sich in der Form [Kopfelement | Restliste] darstellen.

66 66 Übung Geben Sie im Anfragefenster folgende Anfrage ein: ?- [K | R] = [a, b, c]. Die Auswertung dieser Anfrage liefert die Belegung der Variablen: K = a R = [b, c] ; No Testen Sie auch weitere Listenaufteilungen.

67 67 Spezifikation: add1/3 Semantik: add1(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe = [E | AlteListe]. Beispiel: add1(a, [b, c, d], [a, b, c, d]). Hinzufügen Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann. Programm (Version1: mit Regel): add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe]. Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]).

68 68 Programmtest: ?- add1(a, [b, c, d], L). L = [a, b, c, d] ; No ?- add1(b, [b, c, d], L). L = [b, b, c, d] ; No ?- add1(c, [b, c, d], L). L = [c, b, c, d] ; No Programm (Version1: mit Regel): add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe]. Hinzufügen Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]). Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.

69 69 Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann, die das Element eventuell bereits enthält. Spezifikation: add2/3 Semantik: add2(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn entweder AlteListe E bereits enthält und dann NeueListe = AlteListe gilt, oder wenn AlteListe E nicht enthält und NeueListe sowohl E als auch alle Elemente von AlteListe enthält. Beispiele für Sachverhalte der Modellwelt: add2(a, [b, c, d], [b, c, d, a]). add2(c, [b, c, d], [b, c, d]). Hinzufügen

70 70 % Einfügen in eine leere Liste: add2(E, [], [E]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden entspricht: add2(E, [E|X], [E|X]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht: add2(E, [A|X], L) :- ??? Hinzufügen Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:

71 71 % Einfügen in eine leere Liste: add2(E, [], [E]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden entspricht: add2(E, [E|X], [E|X]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht: add2(E, [A|X], [A|M]) :- E \== A, add2(E, X, M). Hinzufügen Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll: Rekursives Problemreduktion in der dritten Regel: E eingefügt in [A|X] ergibt [A|M], wenn E \== A und wenn E eingefügt in X die Liste M ergibt.

72 72 Anfrage: ?- add(a, [b, c], L). Wissensbasis (mit rekursiver Problemreduktion): /* 1 */ add2(E, [], [E]). /* 2 */ add2(E, [E|X], [E|X]). /* 3 */ add2(E, [A|X], [A|M]) :- E \== A, add2(E, X, M). Auswertung einer Anfrage Substitution E0 = a, A0 = b, X0 = [c], L = [A0|M0]. E1 = a, A1 = c, X1 = [], M0 = [A1|M1] E2 = a, M1 = [E2] Ziel ?- add2(a, [b, c], L). ?- add2(a, [c], M0). ?- add2(a, [], M1). Regel 3 1 Ergebnis: ?- L = [A0|M0] = [b|[A1|M1]] = [b|[c|[E2]]] = [b|[c|[a]]] = [b, c, a] Wird von der Inferenzmaschine geleistet Muss vom Entwickler geleistet werden

73 73 Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element aus einer Liste gelöscht werden kann. Spezifikation: del/3 Semantik: del(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn entweder AlteListe E nicht enthält und dann NeueListe = AlteListe gilt, oder wenn AlteListe E enthält und NeueListe aus AlteListe durch Entfernen von E entsteht. Beispiele für Sachverhalte der Modellwelt: del(c, [b, c, d], [b, d]). del(a, [b, c, d], [b, c, d]). Übung

74 74 % Löschen aus einer leeren Liste: del(E, [], ). % Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden entspricht: del(E, [E|X], ). % Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden nicht entspricht: del(E, [A|X], ) :- E \== A,. Übung Ergänzen Sie die Fakten bzw. Regeln. Lösen Sie Fall 3 mit Hilfe einer rekursiven Problemreduktion. Testen Sie anschließend das entwickelte Programm.

75 75 Übung Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe überprüft werden kann, ob ein Objekt Element einer Liste ist. Spezifikation: element/2 Semantik: element(X, Liste) gilt in der Modellwelt, wenn X in der Liste vorkommt. Beispiele für Sachverhalte der Modellwelt: element(b, [b, c, d]). element(c, [b, c, d]).

76 76 Übung Aufgabe Für das Überprüfen der Zugehörigkeit zu einer Liste gibt es auch das vordefinierte Prädikat member/2. Testen Sie dieses Prädikat. Testen Sie auch folgende Anfrage: member(X, [a, b, c]).

77 77 Übung Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe die Elemente von zwei Listen zusammengefügt werden können. Spezifikation: zusammenfuegen/3 Semantik: zusammenfuegen(X, Y, Z) gilt in der Modellwelt, wenn Z aus allen Elementen der Listen X und Y besteht, wobei zuerst alle Elemente aus X und dann alle Elemente aus Y in der vorgegebenen Reihenfolge vorkommen. Beispiele für Sachverhalte der Modellwelt: zusammenfuegen([a, b], [b, c, d], [a, b, b, c, d]). zusammenfuegen([], [b, c, d], [b, c, d]).

78 78 Übung Aufgabe Für das Zusammenfügen von zwei Listen gibt es auch das vordefinierte Prädikat append/3. Testen Sie dieses Prädikat. Testen Sie auch die möglichen Datenflussrichtungen. z.B.: append(X, [a], [b, c, a]). append(X, Y, [a, b, c]).

79 79 Übung Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe eine Liste umgekehrt werden kann. Spezifikation: umkehren/2 Semantik: umkehren(X, Y) gilt in der Modellwelt, wenn in Y alle Elemente aus X in umgekehrter Reihenfolge vorkommen. Beispiele für Sachverhalte der Modellwelt: umkehren([], []). umkehren([a, b, c], [c, b, a]).

80 80 Übung Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe alle Elemente einer Liste verdoppelt werden können. Spezifikation: verdoppeln/2 Semantik: verdoppeln(X, Y) gilt in der Modellwelt, wenn in Y alle Elemente aus X jeweils doppelt vorkommen. Beispiele für Sachverhalte der Modellwelt: verdoppeln([], []). verdoppeln([a, b, c], [a, a, b, b, c, c]).

81 81 Übung Aufgabe Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe eine Element durch ein anderes ersetzt wird. Spezifikation: ersetzen/4 Semantik: ersetzen(X, Y, L1, L2) gilt in der Modellwelt, wenn L2 alle Elemente aus L1 enthält, wobei X jeweils durch Y ersetzt wurde. Beispiele für Sachverhalte der Modellwelt: ersetzen(a, b, [a, b, c], [b, b, c]). ersetzen(b, l, [a, b, b, a], [a, l, l, a]).

82 82

83 83 Teil 5 Verarbeitung von Graphen

84 84 Umfüllproblem Ochsen- schwanz- suppe 3 Liter 4 Liter Sie befinden sich auf einem Campingplatz und sollen als Vorspeise eine Suppe kochen. Laut Beschreibung auf der Dose benötigen Sie genau 2 Liter Wasser. Zum Abmessen haben Sie einen kleinen Eimer, der 3 Liter fasst, und einen etwas größeren, der 4 Liter fasst. nach: Lämmel, Cleve: Künstliche Intelligenz. München Wien 2004.

85 85 Umfüllmöglichkeiten 3-l-Eimer4-l-Eimer 2 Liter!

86 86 Graphenproblem Problem: Gibt es einen Weg von einem Startknoten zu einem Zielknoten entlang der vorgegebenen Kanten? Gegeben ist ein "Beziehungsgeflecht" (ein sog. Graph), das mit Hilfe von Knoten beschrieben wird, die ggf. durch Kanten verbunden sind. Startknoten Zielknoten Kante

87 87 Graphenproblem Problem: Gibt es einen Weg von einem Startknoten (z. B. a) zu einem Zielknoten (z. B. h) entlang der vorgegebenen Kanten? Start Ziel a g bc def i h Ein Graph beschreibt ein "Beziehungsgeflecht". Dieses wird mit Hilfe von Knoten beschrieben, die ggf. durch Kanten verbunden sind. Haben die Kanten eine Richtung, so spricht man von einem gerichteten Graphen. gerichtete Kante

88 88 Modellierung eines gerichteten Graphen Zur Beschreibung eines (gerichteten) Graphen werden sämtliche Kanten aufgelistet. pfeil(a, b). pfeil(a, c). pfeil(b, a). pfeil(b, d). pfeil(b, e). pfeil(c, a). pfeil(c, e). pfeil(c, f). pfeil(d, b). pfeil(d, g). pfeil(d, e). pfeil(e, b). pfeil(e, c). pfeil(f, b). pfeil(f, c). pfeil(f, i). pfeil(g, d).... a g bc def i h

89 89 Übung Im folgenden betrachten wir zunächst Graphen ohne Zyklen. Als Beispiel dient der oben dargestellte vereinfachte Graph. Geben Sie die Fakten zur Beschreibung des Graphen ein oder laden Sie die Datei "Graph1.pl". pfeil(a, b). pfeil(a, c). pfeil(b, d). pfeil(b, e). pfeil(c, e). pfeil(c, f). pfeil(d, g). pfeil(d, e). pfeil(f, b). pfeil(f, i). pfeil(h, b). pfeil(h, e). pfeil(i, e). pfeil(i, h). a g bc def i h Graph1.pl

90 90 Übung Die Fakten sollen um Regeln zur Festlegung eines Prädikats weg/2 ergänzt werden. Welcher Vorschlag ist hierzu geeignet? Testen Sie die drei Vorschläge. Klären Sie auch die Unterschiede. pfeil(a, b). pfeil(a, c). pfeil(b, d). pfeil(b, e). pfeil(c, e). pfeil(c, f). pfeil(d, g). pfeil(d, e).... a g bc def i h Graph1.pl weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). weg(X, X). weg(X, Y) :- pfeil(X, Y). weg(X, Y) :- pfeil(X, Z), weg(Z, Y).

91 91 Übung Ergänzen Sie wie gezeigt das Ausgabeprädikat "print" und erklären Sie die von PROLOG erzeugte Ausgabe. pfeil(a, b). pfeil(a, c). pfeil(b, d). pfeil(b, e). pfeil(c, e). pfeil(c, f). pfeil(d, g). pfeil(d, e).... a g bc def i h Graph1.pl ?- weg(a, h). bdgeecefbdgeeieh Yes weg(X, X). weg(X, Y) :- pfeil(X, Z), print(Z), weg(Z, Y).

92 92 Übung Warum führt das gezeigte Programm bei Graphen mit Zyklen nicht zum gewünschten Ergebnis? pfeil(a, b). pfeil(a, c). pfeil(b, a). pfeil(b, d). pfeil(b, e). pfeil(c, a). pfeil(c, e). pfeil(c, f). pfeil(d, b). pfeil(d, g)... Graph2.pl ?- weg(a, h). weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). a g bc def i h

93 93 Tiefensuche in zyklenfreien Graphen ?- weg(a, h). bdgeecefbdgeeieh Yes weg(X, X). weg(X, Y) :- pfeil(X, Z), print(Z), weg(Z, Y). a b d g e c e f b d g e i e h a g bc def i h

94 94 Tiefensuche in zyklenfreien Graphen a b d g e c e f b d g e i e h a g bc def i h Vom Startknoten a aus wird zunächst ein Nachbar von a (hier b) besucht. Anschließend wird von b aus ein Nachbar von b (hier d) besucht u. s. w.. Erst wenn auf diese Weise kein weiterer Weg zum Zielknoten erzeugt werden kann, muss man Rücksetzen und einen anderen Knoten besuchen. Bei dieser Strategie gelangt man also zunächst in die "Tiefe" und erst, wenn man hierdurch nicht weiterkommt, in die "Breite".

95 95 Übung b a g bc def i h Erzeugen Sie systematisch einen Weg von b nach d. Gehen Sie bei der Wahl der Nachbarknoten alphabetisch vor. Erstellen Sie auch den zugehörigen Tiefensuchbaum.

96 96 Übung b a g bc def i h Im Graphen wurde eine zusätzliche Kante von e nach f eingefügt. Erzeugen Sie genau wie auf der voherigen Folie systematisch einen Weg von b nach d. Welche Schwierigkeit tritt jetzt auf? Wie könnte man sie beheben?

97 97 Übung ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ;... No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W). a g bc def i h pfeil(a, b). pfeil(a, c).... Testen Sie die gezeigten Regeln zur Festlegung eines erweiterten Prädikats weg/3 (auch mit anderen Variablenbelegungen). Deuten Sie die von der Inferenz- maschine erzeugten Ergebnisse.

98 98 Übung a g bc def i h pfeil(a, b). pfeil(a, c).... Machen Sie sich klar, wie die Ergebnisse hier zustande kommen. Welche Rolle spielt dabei die in der Festlegung von weg1/4 vorkommende Variable B ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ;... No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W).

99 99 Wegsuche mit Akkumulator a g bc def i h pfeil(a, b). pfeil(a, c).... Die Variable B dient hier als sog. Akkumulator. Mit Hilfe dieser Variablen werden die bisher besuchten Knoten in einer Liste zwischengespeichert. ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ;... No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W).

100 100 Wegsuche mit Akkumulator pfeil(a, b). pfeil(a, c).... Überprüft man, ob der neue Knoten Z nicht unter den bereits besuchten Knoten in B vorkommt, so kann man das Prädikat weg/3 auch in Graphen mit Zyklen benutzen. a g bc def i h ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ;... No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).

101 101 Übung pfeil(a, b). pfeil(a, c).... Testen Sie das erweiterte logische Programm mit verschiedenen Testdaten. Benutzen Sie einen Graphen mit Zyklen (wie in Graph2.pl). a g bc def i h ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ;... No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).

102 102 Übung Aus den ausgegebenen Listen lässt sich auch erschließen, in welcher Reihenfolge die Knoten des Graphen bearbeitet werden. Machen Sie sich diese Reihenfolge am Graphen klar. a g bc def i h ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ; W = [e, b, f, c, a] ; W = [e, i, f, c, a] ; W = [e, d, b, h, i, f, c, a] ; W = [e, b, h, i, f, c, a] ; W = [e, h, i, f, c, a] ; No weg(X, Y, W) :- weg1(X, Y, [X], W). weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).

103 103 Übung weg(Start,Ziel,Loesung) :- NeuePfade = [[Start]], write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung). weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [Ziel|_], Loesung = AktuellerPfad. weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung). a g bc def i h Testen Sie das nebenstehende logische Programm (siehe Wegsuche4a.pl). Stellen Sie die Anfrage weg(a, h, L) sowie weitere analoge Anfragen. Versuchen Sie, mit Hilfe der nächsten Folie die Ausgaben zu deuten.

104 104 Übung ?- weg(a,h,L). [[a]] [[b, a], [c, a]] [[c, a], [d, b, a], [e, b, a]] [[d, b, a], [e, b, a], [e, c, a], [f, c, a]] [[e, b, a], [e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a]] [[e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a]] [[f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a]] [[g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]] [[e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]]... L = [h, i, f, c, a] ;... a g bc def i h Anhand des Graphen wird hier verdeutlicht, wie die ausgegebenen Listen zustande kommen. Die Reihenfolge der verarbeiteten Knoten wird hier mit farbigen gestrichelten Pfeilen und einer zusätzlichen Nummerierung gekennzeichnet. Was wird in den Listen hier zwischengespeichert?

105 105 Breitensuche ?- weg(a,h,L). [[a]] [[b, a], [c, a]] [[c, a], [d, b, a], [e, b, a]] [[d, b, a], [e, b, a], [e, c, a], [f, c, a]] [[e, b, a], [e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a]] [[e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a]] [[f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a]] [[g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]] [[e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]]... L = [h, i, f, c, a] ;... a g bc def i h Bei der Suche nach einem Weg werden hier alle Nachbarknoten der Reihe nach (in der Breite) bearbeitet. Alle angefangenen Wege werden hier (in der Breite) weiterverfolgt.

106 106 Implementierung der Breitensuche weg(Start,Ziel,Loesung) :- NeuePfade = [[Start]], write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung). weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [Ziel|_], Loesung = AktuellerPfad. weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung). a g bc def i h AktuellerPfad beginne mit KnotenA. Füge alle Erweiterungen von AktuellerPfad um einen neuen Knoten KnotenN, der von KnotenA aus erreichbar ist und nicht bereits in AktuellerPfad vorkommt, in eine Liste GefundenePfade. Hänge diese Liste GefundenePfade an die Liste Pfade an und nenne die neue Liste NeuePfade. Der erste Pfad PfadN in NeuePfade ist der als nächstes zu bearbeitende Pfad.

107 107 Anwendung: Wasser umfüllen pfeil(X, Y) :- zustandsuebergang(X, Y). zustandsuebergang([Vier, Drei],[Vier, 3]) :- Drei \== 3. % 3-l-Eimer füllen zustandsuebergang([Vier, Drei],[4, Drei]) :- Vier \== 4. % 4-l-Eimer füllen zustandsuebergang([Vier, Drei],[Vier, 0]) :- Drei \== 0. % 3-l-Eimer füllen zustandsuebergang([Vier, Drei],[0, Drei]) :- Vier \== 0. % 4-l-Eimer füllen zustandsuebergang([Vier,Drei],[Vier1,0]) :- Drei \== 0, Drei + Vier =< 4,Vier1 is Drei+Vier. % 3-l-Eimer umfüllen in 4-l-Eimer zustandsuebergang([Vier,Drei],[0,Drei1]) :- Vier \== 0, Drei + Vier =< 3,Drei1 is Drei+Vier. % 4-l-Eimer umfüllen in 3-l-Eimer zustandsuebergang([Vier,Drei],[Vier1,3]) :- Drei \== 3, Drei + Vier > 3,Vier1 is Drei+Vier-3. % 4-l-Eimer teilw. umfüllen in 3-l-Eimer zustandsuebergang([Vier,Drei],[4,Drei1]) :- Vier \== 4, Drei + Vier >4,Drei1 is Drei+Vier-4. % 3-l-Eimer teilw. umfüllen in 3-l-Eimer weg(W) :- startzustand(X), zielErreicht(Y), weg1(X, Y, [X], W)....

108 108 Anwendung: Wasser umfüllen pfeil(X, Y) :- zustandsuebergang(X, Y).... weg(W) :- startZustand(X), zielZustand(Y), weg1(X, Y, [X], W). startZustand([0,0]). zielZustand([2,N]). zielZustand([M,2]). % Tiefensuche: weg1(X, X, B, W) :- W = B. weg1(X, Y, B, W) :- pfeil(X,Z), not(member(Z,B)), weg1(Z,Y,[Z|B],W).

109 109 Teil 6 Deklarative Programmierung

110 110 Ein Problem - zwei Lösungen Problem: Wie fügt man die Elemente von zwei Listen zusammen? Lösung: Wenn die erste Liste eine leere Liste ist, dann ist die zweite Liste bereits das Ergebnis: zusammenfuegen([], Y, Y). Wenn die erste Liste eine nichtleere Liste bestehend aus einem ersten Element E und einer evtl. leeren Restliste RX ist, dann soll für das Ergebnis folgendes gelten: Wenn die Restliste RX mit der zweiten Liste Y zusammengefügt RZ ergibt, dann ist das gesuchte Ergebnis eine Liste bestehend aus dem ersten Element E und RZ als Restliste. zusammenfuegen([E|RX], Y, [E|RZ]) :- fuegezusammen(RX, Y, RZ). Lösung: Stell eine neue Liste Z wie folgt zusammen: Starte mit der einer leeren Liste. Füge Schritt für Schritt alle Elemente der beiden Listen X und Y jeweils am Ende von Z ein. Z := [] solange X nicht leer ist: E := erstesElement(X) Z := mitLetztem(Z, E) X := ohneEstes(X) solange Y nicht leer ist: E := erstesElement(Y) Z := mitLetztem(Z, E) Y := ohneEstes(Y) deklarativer Ansatz imperativer Ansatz

111 111 Ein Problem - zwei Lösungen Problem: Wie fügt man die Elemente von zwei Listen zusammen? Lösung: Wenn die erste Liste eine leere Liste ist, dann ist die zweite Liste bereits das Ergebnis. Wenn die erste Liste eine nichtleere Liste bestehend aus einem ersten Element E und einer evtl. leeren Restliste RX ist, dann soll für das Ergebnis folgendes gelten: Wenn die Restliste RX mit der zweiten Liste Y zusammengefügt RZ ergibt, dann ist das gesuchte Ergebnis eine Liste bestehend aus dem ersten Element E und RZ als Restliste. Lösung: Stell eine neue Liste Z wie folgt zusammen: Starte mit der einer leeren Liste. Füge Schritt für Schritt alle Elemente der beiden Listen X und Y jeweils am Ende von Z ein. deklarativer Ansatz imperativer Ansatz Man beschreibt, welche Eigenschaften das Ergebnis haben soll, das man beim Zusammenfügen erhält. Man beschreibt Schritt für Schritt den Vorgang, wie man zwei Listen zusammenfügt.

112 112 Deklarative Programmierung Ansatz: Beschreiben, was in der Modellwelt gelten soll Deklarative Programmierung besteht darin, den Problemkontext (Miniwelt) mit gegebenen Mitteln (hier: Fakten und Regeln) zu beschreiben. Inferenz- maschine zusammenfuegen([], Y, Y). zusammenfuegen([E|RX], Y, [E|RZ]) :- fuegezusammen(RX, Y, RZ). ?- zusammenfuegen([a, b], [c, a, d], Z). Z = [a, b, c, a, d] Ergebnis Anfrage Wissensbasis

113 113 Imperative Programmierung Ansatz: Beschreiben, wie die Ergebnisse berechnet werden sollen E.-Zustand Register- maschine A.-Zustand Anweisungen Z := [] solange X nicht leer ist: E := erstesElement(X) Z := mitLetztem(Z, E) X := ohneEstes(X) solange Y nicht leer ist: E := erstesElement(Y) Z := mitLetztem(Z, E) Y := ohneEstes(Y) {X: [a, b]; Y: [c, a, d]} {Z: [a, b, c, a, d]} Imperative Programmierung besteht darin, eine (mehr oder weniger abstrakte) Maschine mit Hilfe von Anweisungen zu steuern.

114 114 Literaturhinweise Gerhard Röhner: Informatik mit Prolog. Hessisches Landesinstitut für Pädagogik (HeLP Best.-Nr.: 06000). Rüdeger Baumann: PROLOG Einführungskurs. Klett-Verlag H. M. Otto: ProLog-Puzzles. Dümmler-Verlag Gregor Noll: PROLOG – eine Einführung in deklaratives Programmieren. Herbert Drumm u. Hermann Stimm: Wissensverarbeitung mit PROLOG – Ein Einstieg in die Algorithmik. Handreichung zum Lehrplan Informatik Klaus Merkert: Prolog. siehe Uwe Schöning: Logik für Informatiker. BI-Wissenschaftsverlag 1987.


Herunterladen ppt "Logische Programmierung mit PROLOG Klaus Becker 2007."

Ähnliche Präsentationen


Google-Anzeigen