Logische Programmierung mit PROLOG Klaus Becker 2007 2

Logische Programmierung mit PROLOG Klaus Becker 2007

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

3 Teil 1 Fakten und Regeln

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

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

Modellierungsansatz 7 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

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

Regeln 9 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 (Bedingungen) 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 darf im Regelrumpf vorkommen. Regeln: vorfahr(X, Y) : - kind(Y, X). vorfahr(X, Y) : - kind(Y, Z), vorfahr(X, Z). Regelkopf (Folgerung) Regelrumpf (Bedingungen) informelle Beschreibung: X ist Vorfahr von Y, wenn Y Kind von Z und X Vorfahr von Z ist.

11 Logische Herleitung der Modellwelt Die in der Modellwelt geltenden Sachverhalte ergeben sich aus der (in/direkten) Beschreibung der Miniwelt durch logische Herleitungen. 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 Logische Herleitung 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).

12 Modus Ponens 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. Alle Menschen sind sterblich. Sokrates ist ein Mensch. Sokrates ist sterblich. Für alle X: mensch(X) sterblich(X). mensch(sokrates). kind(zeus, cronus). vorfahr(X, Y) : kind(Y, X). vorfahr(cronus, zeus). sterblich(X) : - mensch(X). mensch(sokrates). kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) : kind(Y, Z), vorfahr(X, Z). sterblich(sokrates). vorfahr(cronus, hebe). sterblich(sokrates).

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

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-worldassumption).

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

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: Cronus = Rhea | maennlich(cronus). -----------. . | | | weiblich(rhea). . . Hestia | Poseidon | Demeter=Zeus kind(zeus, rhea). Hades Zeus = Hera. . 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, Y), X == Y. schwester(X, Y) : sohn(X, Y) : oma(X, Y) : -

17 Teil 2 Anfragen

18 Logik-Programme Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage. 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). Wissensbasis Anfrage

19 SWI-Prolog-Editor Wissensbasis Anfrage

20 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 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. Consultieren Wenn der PROLOGInterpreter keine Syntaxfehler gefunden hat, bestätigt er die erfolgreiche Erzeugung der Wissensbasis mit "Yes". Mit consult(<Datei>). werden aus der angegebenen Datei die Fakten und Regeln in die Wissensbasis eingelesen.

Anfrage stellen 22 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 PROLOGInterpreter keine weiteren Ergebnisse, so zeigt er dies mit "No" an. Anfrage Ergebnisse Anfrage Das trennende Semikolon kann als "oder" gedeutet werden.

Übung 23 Laden Sie die Datei "Familie 1. 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). vater(zeus, hades). weiblich(Frau). mutter(M, zeus). mutter(rhea, Kind). mutter(hera, Kind). mutter(M, K), weiblich(K). vater(V, _Kind). weiblich(T), mutter(_, T). % Ist Hera weiblich? % Wer ist weiblich? Was hat es mit dem "_" auf sich?

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 Ü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) Alba Anna Arthur Alfred Anke siehe: G. Röhner: Informatik mit Prolog. He. LP 2002. Anton

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

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

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). Yes. % Ist Zeus männlich? ? - maennlich(hera). No. % Ist Hera männlich? Ja-Nein-Anfrage

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). W = zeus; No. % Wer ist Vater von Hermes? ? - weiblich(Frau). Frau = hera; Frau = maia; No. % Wer ist weiblich? Ergänzungsanfrage

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

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

32

33 Teil 3 Das Berechnungskonzept

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

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

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

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

38 "Rückwärts"-Herleitung Programm Rückwärts-Deutung Rückwärts-Herleitung a. b. c : - a, d. c : - e. d : - b. 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! ? c. ? - c. Yes. ? a, d. ? b. ? a d c. a. b d. b.

39 Deutung als Widerspruchsbeweis Programm Rückwärts-Deutung Rückwärts-Herleitung a. b. c : - a, d. c : - e. d : - b. 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! ? c. ? - c. Yes. ? a, d. ? b. ? � a d c. a. b d. b.

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

41 Sackgassen Programm Herleitung mit Sackgasse erfolgreiche Herleitung a. b. c : - a, d. c : - e. d : - b. ? c. ? - c. Yes. ? e. e c. ? a, d. ? b. ? a d c. a. b d. b. 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.

42 Backtracking Programm Herleitung mit Sackgasse a. b. c : - e. c : - a, d. d : - b. ? c. ? e. ? c. ? a, d. ? b. ? ? - c. erfolgreiche Herleitung e c. a d c. a. b d. b. zurücksetzen Yes. 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.

43 Der allgemeine Fall 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 */ Problem: Wie erzeugt man systematisch logische Herleitungen?

Auswertung von Anfragen 44 /*1*/ /*4*/ /*5*/ /*6*/ /*7*/ maennlich(zeus). /*2*/ weiblich(hera). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) : - kind(Y, X), maennlich(X). Regel 7 Substitution X = V, Y = hermes. /*3*/ weiblich(maia). Ziel ? - vater(V, hermes). ? - kind(hermes, V), maennlich(V). 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.

Auswertung von Anfragen 45 /*1*/ /*4*/ /*5*/ /*6*/ /*7*/ maennlich(zeus). /*2*/ weiblich(hera). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) : - kind(Y, X), maennlich(X). Regel Substitution 7 X = V, Y = hermes. 5 V = maia. /*3*/ weiblich(maia). Ziel ? - vater(V, hermes). ? - kind(hermes, V), maennlich(V). ? - maennlich(maia). 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.

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

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

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

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

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

51 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)

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

53 Übung Wir betrachten das folgende Logik-Programm zur Blockwelt: auf(a, p 1). auf(c, a). auf(e, p 2). auf(b, p 3). auf(f, b). auf(g, f). auf(d, g). ueber(X, Y) : - auf(X, Y). ueber(X, Y) : - auf(X, Z), ueber(Z, Y). a e b ? - ueber(X, g). p 1 p 2 p 3 d g c f 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?

Übung 54 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?

Grenzen der Logik 55 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 Logik-Programme sind logisch äquivalent. Aus beiden Programmen lassen sich dieselben Herleitungen erzeugen.

Grenzen der Logik 56 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). Substitution X = A, Y = B B = hermes, A = maia. Ziel Substitution ? - vorfahr(A, B). X = A, Y = B ? - kind(B, A). X = A, Y = Z. . Ziel ? - vorfahr(A, B). ? - vorfahr(A, Z), kind(B, Z). ? - vorfahr(A, U), kind(Z, U), . . . 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.

57 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 Anfrage, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel „modus ponens“ hergeleitet werden können.

58 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 eines Logik-Programms Menge der Instanzen der Anfrage, die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

59 Teil 4 Listenverarbeitung

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

Listen 61 Walter Ralph Anja Claudius Klaus Gaby. . . 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.

62 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. Beispiele: [ walter, ralph, anja, claudius, gaby ] [a, b, c, d, e] [1, 2], [[1], [2], [3]]] []

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

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.

Unifikation bei Listen 65 Jede Liste lässt sich in der Form [Kopfelement | Restliste] darstellen. 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]] [E 1, E 2 | R] = [a, b, c] E 1 = a, E 2 = b, R = [c] [E 1, E 2 | R] = [a] Unifikation nicht möglich . . .

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 Hinzufügen Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann. Spezifikation: add 1/3 Semantik: add 1(E, Alte. Liste, Neue. Liste) gilt in der Modellwelt, wenn Neue. Liste = [E | Alte. Liste]. Beispiel: add 1(a, [b, c, d], [a, b, c, d]). Programm (Version 1: mit Regel): add 1(E, Alte. Liste, Neue. Liste) : - Neue. Liste = [E | Alte. Liste]. Programm (Version 2: mit Faktum): add 1(E, Alte. Liste, [E | Alte. Liste]).

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

69 Hinzufügen 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: add 2/3 Semantik: add 2(E, Alte. Liste, Neue. Liste) gilt in der Modellwelt, wenn entweder Alte. Liste E bereits enthält und dann Neue. Liste = Alte. Liste gilt, oder wenn Alte. Liste E nicht enthält und Neue. Liste sowohl E als auch alle Elemente von Alte. Liste enthält. Beispiele für Sachverhalte der Modellwelt: add 2(a, [b, c, d], [b, c, d, a]). add 2(c, [b, c, d]).

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

71 Hinzufügen Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll: % Einfügen in eine leere Liste: add 2(E, [], [E]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden entspricht: add 2(E, [E|X]). % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht: add 2(E, [A|X], [A|M]) : - E == A, add 2(E, X, M). 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.

Auswertung einer Anfrage 72 Wissensbasis (mit rekursiver Problemreduktion): /* 1 */ add 2(E, [], [E]). /* 2 */ add 2(E, [E|X]). /* 3 */ add 2(E, [A|X], [A|M]) : - E == A, add 2(E, X, M). Anfrage: Muss vom Entwickler geleistet werden ? - add(a, [b, c], L). Regel Wird von der Inferenzmaschine geleistet Substitution 3 E 0 = a, A 0 = b, X 0 = [c], L = [A 0|M 0]. 3 E 1 = a, A 1 = c, X 1 = [], M 0 = [A 1|M 1] 1 E 2 = a, M 1 = [E 2] Ziel ? - add 2(a, [b, c], L). ? - add 2(a, [c], M 0). ? - add 2(a, [], M 1). Ergebnis: ? - L = [A 0|M 0] = [b|[A 1|M 1]] = [b|[c|[E 2]]] = [b|[c|[a]]] = [b, c, a]

73 Übung 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, Alte. Liste, Neue. Liste) gilt in der Modellwelt, wenn entweder Alte. Liste E nicht enthält und dann Neue. Liste = Alte. Liste gilt, oder wenn Alte. Liste E enthält und Neue. Liste aus Alte. Liste durch Entfernen von E entsteht. Beispiele für Sachverhalte der Modellwelt: del(c, [b, c, d], [b, d]). del(a, [b, c, d]).

74 Ü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. % 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, .

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 Ü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 Ü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]).

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 Ü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 Ü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 Ü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, L 1, L 2) gilt in der Modellwelt, wenn L 2 alle Elemente aus L 1 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

83 Teil 5 Verarbeitung von Graphen

Umfüllproblem 84 4 Liter Ochsenschwanzsuppe 3 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 Umfüllmöglichkeiten 4 -l-Eimer 3 -l-Eimer 2 Liter!

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

Graphenproblem 87 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. Start a b c d g e gerichtete Kante f i h Ziel Problem: Gibt es einen Weg von einem Startknoten (z. B. a) zu einem Zielknoten (z. B. h) entlang der vorgegebenen Kanten?

88 Modellierung eines gerichteten Graphen 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 b c d g e h f i Zur Beschreibung eines (gerichteten) Graphen werden sämtliche Kanten aufgelistet.

89 pfeil(a, b). pfeil(a, c). pfeil(b, d). pfeil(b, e). pfeil(c, f). pfeil(d, g). pfeil(d, e). pfeil(f, b). pfeil(f, i). pfeil(h, b). pfeil(h, e). pfeil(i, h). Übung a b c d g e h f i Graph 1. pl 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 "Graph 1. pl".

90 pfeil(a, b). pfeil(a, c). pfeil(b, d). pfeil(b, e). pfeil(c, f). pfeil(d, g). pfeil(d, e). . Übung a Graph 1. pl weg(X, X). 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). b c d g e h f i Die Fakten sollen um Regeln zur Festlegung eines Prädikats weg/2 ergänzt werden. Welcher Vorschlag ist hierzu geeignet? Testen Sie drei Vorschläge. Klären Sie auch die Unterschiede.

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

92 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). . . Übung a Graph 2. pl weg(X, X). weg(X, Y) : - pfeil(X, Z), weg(Z, Y). ? - weg(a, h). b c d g e h f i Warum führt das gezeigte Programm bei Graphen mit Zyklen nicht zum gewünschten Ergebnis?

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

Tiefensuche in zyklenfreien Graphen 94 a a b c d g b e h f i 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". c d e e f g e b i d e e h g e

Übung 95 b a b c d g e h f i 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.

Übung 96 b a b c d g e h f i 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 Übung a pfeil(a, b). pfeil(a, c). . weg(X, Y, W) : weg 1(X, Y, [X], W). weg 1(X, X, B, W) : W = B. weg 1(X, Y, B, W) : pfeil(X, Z), weg 1(Z, Y, [Z|B], W). ? - weg(a, e, W). W = [e, d, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ; . . . No b c d g e h f i Testen Sie die gezeigten Regeln zur Festlegung eines erweiterten Prädikats weg/3 (auch mit anderen Variablenbelegungen). Deuten Sie die von der Inferenzmaschine erzeugten Ergebnisse.

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

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

100 Wegsuche mit Akkumulator a pfeil(a, b). pfeil(a, c). . weg(X, Y, W) : weg 1(X, Y, [X], W). weg 1(X, X, B, W) : W = B. weg 1(X, Y, B, W) : pfeil(X, Z), not(member(Z, B)), weg 1(Z, Y, [Z|B], W). ? - weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; . . . No b c d g e h f i Ü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.

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

102 Übung weg(X, Y, W) : weg 1(X, Y, [X], W). weg 1(X, X, B, W) : - W = B. weg 1(X, Y, B, W) : pfeil(X, Z), not(member(Z, B)), weg 1(Z, Y, [Z|B], W). ? - weg(a, e, W). W = [e, d, b, a] ; W = [e, c, a] ; W = [e, d, b, f, c, a] ; W = [e, i, f, c, a] ; W = [e, d, b, h, i, f, c, a] ; W = [e, h, i, f, c, a] ; No a b c d g e h f i 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.

103 Übung weg(Start, Ziel, Loesung) : Neue. Pfade = [[Start]], write(Neue. Pfade), nl, Neue. Pfade=[Pfad. N|Rest. Pfade], weg 1(Pfad. N, Ziel, Rest. Pfade, Loesung). weg 1(Aktueller. Pfad, Ziel, Pfade, Loesung) : Aktueller. Pfad = [Ziel|_], Loesung = Aktueller. Pfad. weg 1(Aktueller. Pfad, Ziel, Pfade, Loesung) : Aktueller. Pfad = [Knoten. A|_], findall( [Knoten. N|Aktueller. Pfad], ( pfeil(Knoten. A, Knoten. N), not(member(Knoten. N, Aktueller. Pfad)) ), Gefundene. Pfade), append(Pfade, Gefundene. Pfade, Neue. Pfade), write(Neue. Pfade), nl, Neue. Pfade=[Pfad. N|Rest. Pfade], weg 1(Pfad. N, Ziel, Rest. Pfade, Loesung). a b c d g e h f i Testen Sie das nebenstehende logische Programm (siehe Wegsuche 4 a. 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 Übung 1 2 a 3 b ? - weg(a, h, L). 6 [[a]] d 4 [[b, a], [c, a]] 4 [[c, a], [d, b, a], [e, b, a]] g h [[d, 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]]. . . 1 3 c 2 7 e 5 f 7 i L = [h, i, f, c, a] ; . . . 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 Breitensuche a b ? - weg(a, h, L). [[a]] d [[b, a], [c, a]] [[c, a], [d, b, a], [e, b, a]] g h [[d, 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]]. . . c e f i L = [h, i, f, c, a] ; . . . 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 Implementierung der Breitensuche weg(Start, Ziel, Loesung) : Neue. Pfade = [[Start]], write(Neue. Pfade), nl, Neue. Pfade=[Pfad. N|Rest. Pfade], weg 1(Pfad. N, Ziel, Rest. Pfade, Loesung). weg 1(Aktueller. Pfad, Ziel, Pfade, Loesung) : Aktueller. Pfad = [Ziel|_], Loesung = Aktueller. Pfad. weg 1(Aktueller. Pfad, Ziel, Pfade, Loesung) : Aktueller. Pfad = [Knoten. A|_], findall( [Knoten. N|Aktueller. Pfad], ( pfeil(Knoten. A, Knoten. N), not(member(Knoten. N, Aktueller. Pfad)) ), Gefundene. Pfade), append(Pfade, Gefundene. Pfade, Neue. Pfade), write(Neue. Pfade), nl, Neue. Pfade=[Pfad. N|Rest. Pfade], weg 1(Pfad. N, Ziel, Rest. Pfade, Loesung). a b c d g e h f i Aktueller. Pfad beginne mit Knoten. A. Füge alle Erweiterungen von Aktueller. Pfad um einen neuen Knoten. N, der von Knoten. A aus erreichbar ist und nicht bereits in Aktueller. Pfad vorkommt, in eine Liste Gefundene. Pfade. Hänge diese Liste Gefundene. Pfade an die Liste Pfade an und nenne die neue Liste Neue. Pfade. Der erste Pfad. N in Neue. Pfade ist der als nächstes zu bearbeitende Pfad.

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], [Vier 1, 0]) : Drei == 0, Drei + Vier =< 4, Vier 1 is Drei+Vier. zustandsuebergang([Vier, Drei], [0, Drei 1]) : Vier == 0, Drei + Vier =< 3, Drei 1 is Drei+Vier. zustandsuebergang([Vier, Drei], [Vier 1, 3]) : Drei == 3, Drei + Vier > 3, Vier 1 is Drei+Vier-3. zustandsuebergang([Vier, Drei], [4, Drei 1]) : Vier == 4, Drei + Vier >4, Drei 1 is Drei+Vier-4. % 3 -l-Eimer umfüllen in 4 -l-Eimer % 4 -l-Eimer umfüllen in 3 -l-Eimer % 4 -l-Eimer teilw. umfüllen in 3 -l-Eimer % 3 -l-Eimer teilw. umfüllen in 3 -l-Eimer weg(W) : - startzustand(X), ziel. Erreicht(Y), weg 1(X, Y, [X], W). .

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

109 Teil 6 Deklarative Programmierung

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). Stell eine neue Liste Z wie folgt zusammen: 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). deklarativer Ansatz 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 : = erstes. Element(X) Z : = mit. Letztem(Z, E) X : = ohne. Estes(X) solange Y nicht leer ist: E : = erstes. Element(Y) Z : = mit. Letztem(Z, E) Y : = ohne. Estes(Y) imperativer Ansatz

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. Stell eine neue Liste Z wie folgt zusammen: 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. deklarativer Ansatz 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. imperativer Ansatz

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

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

114 Literaturhinweise Gerhard Röhner: Informatik mit Prolog. Hessisches Landesinstitut für Pädagogik 2002. (He. LP Best. -Nr. : 06000). Rüdeger Baumann: PROLOG Einführungskurs. Klett-Verlag 1991. H. M. Otto: Pro. Log-Puzzles. Dümmler-Verlag 1991. Gregor Noll: PROLOG – eine Einführung in deklaratives Programmieren. http: //informatikag. bildung-rp. de/assets/download/Prolog. pps Herbert Drumm u. Hermann Stimm: Wissensverarbeitung mit PROLOG – Einstieg in die Algorithmik. Handreichung zum Lehrplan Informatik 1995. Klaus Merkert: Prolog. siehe http: //www. hsg-kl. de/faecher/inf/prolog/index. php Uwe Schöning: Logik für Informatiker. BI-Wissenschaftsverlag 1987.