Logische Programmierung mit PROLOG Klaus Becker 2007

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

Teil 1 Fakten und Regeln

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

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 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 Konstante Konstante Hera (weiblich) Zeus (männlich) ist verheiratet mit

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

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

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

Regelkopf (Folgerung) 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 X ist. X ist Vorfahr von Y, wenn Y Kind von Z und X Vorfahr von Z ist.

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). 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). Modellwelt vorfahr(cronus, zeus). vorfahr(cronus, hebe). ...

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. kind(zeus, cronus). vorfahr(X, Y) :- kind(Y, X). vorfahr(cronus, zeus). Für alle X: mensch(X)  sterblich(X). mensch(sokrates). sterblich(sokrates). kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). vorfahr(cronus, hebe). sterblich(X) :- mensch(X). mensch(sokrates). sterblich(sokrates).

Von der Miniwelt zur Modellwelt Cronus| Zeus | Hebe ... Miniwelt Modellwelt kind(hebe, zeus). kind(hebe, hera). kind(zeus, rhea). kind(zeus, cronus). kind(rhea, uranus). ... vorfahr(cronus, zeus). vorfahr(cronus, hebe). ... Fakten und Regeln: kind(hebe, zeus). kind(hebe, hera). kind(zeus, rhea). kind(zeus, cronus). kind(rhea, uranus). ... vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Mit Hilfe von Fakten und Regeln wird implizit eine Modellwelt konstruiert, die die Miniwelt (in Teilen) beschreiben soll. Beschreibung der Miniwelt

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

Ü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). bruder(zeus, hades). bruder(hades, zeus). bruder(zeus, poseidon). bruder(zeus, hestia). bruder(zeus, zeus). schwester(hera, hestia). Cronus = Rhea | ---------------------- | | | | | Hestia | Poseidon | Demeter=Zeus Hades Zeus = Hera

Ü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

Teil 2 Anfragen

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). Wissensbasis ?- weiblich(Frau). Anfrage

SWI-Prolog-Editor Wissensbasis Anfrage

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.

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

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 Anfrage

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

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

Ü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 Anton Anke siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

Übung 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 p1 p2 p3 siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

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). Wissensbasis Anfrage ?- weiblich(Frau). 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.

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

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

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 Variable Anonyme Variablen werden nicht instanziert.

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

Das Berechnungskonzept Teil 3 Das Berechnungskonzept

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

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" Logik-Programm Herleitung a. b. c :- a, d. c :- e. d :- b. a d ad  c ---------- c b b  d -------- d b -- a -- ?- c. Yes. Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel „modus ponens“: a1, ... , an a1  ...  an b -------------------- b Wenn die Implikation a1  ...  an b gilt und alle Teilbedingungen a1, ... , an nachgewiesen sind, dann kann hieraus die Konklusion b hergeleitet werden.

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

"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. ad  c. ? a, d. a. ? d. b  d. ? b. b. ? ?- c. Yes.

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. ad  c. ? a, d. a. ? d. b  d. ? b. b. ?  ?- c. Yes.

Resolution Programm Resolutionsschritte Rückwärts-Herleitung a. b. c :- a, d. c :- e. d :- b. -c -a  -d  c. -a  -d. a. -d. -b  d. -b. b.  ? c. ad  c. ? a, d. a. ? d. b  d. ? b. b. ?  ?- c. Yes. Für Herleitungen mit Implikationen gilt: Rückwärts mit „modus ponens“ entspricht vorwärts mit Resolution. a1  ...  an  c, b1  ...  bm  -c ----------------------------------------- a1  ...  an  b1  ...  bm a1, ... , an , a1  ...  an b --------------------------------- b

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

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

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). ... Herleitung (Beweis) kind(hermes, zeus). maennlich(zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ------------------------------------ vater(zeus, hermes). Anfrage ?- vater(V, hermes). Ergebnis V = zeus. /* Substitution */ Problem: Wie erzeugt man systematisch logische Herleitungen?

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

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

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

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) CALL: Teilziel aufrufen EXIT: Zeilziel erfolgr. b. REDO: Teilziel nochmal b. FAIL: Teilziel erfolglos b. REDO: kind(hermes, V) CALL: kind(hermes, zeus) EXIT: kind(hermes, zeus) CALL: maennlich(zeus) EXIT: maennlich(zeus) EXIT: vater(V, hermes) V = zeus.

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)

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

Ü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). d g c f a e b ?- ueber(X, g). p1 p2 p3 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 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). ?- 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 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). ?- 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 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). ?- 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),... ... 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.

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.

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 die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

Teil 4 Listenverarbeitung

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

Listen 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.

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, [1, 2], [[1], [2], [3]]] []

Listenkonstruktoren 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)  NeueListe

Ü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 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]] [E1, E2 | R] = [a, b, c]  E1 = a, E2 = b, R = [c] [E1, E2 | R] = [a]  Unifikation nicht möglich ...

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

Hinzufügen Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann. 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]). Programm (Version1: mit Regel): add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe]. Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]).

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]. Programmtest: ?- add1(a, [b, c, d], L). L = [a, b, c, d] ; No ?- add1(b, [b, c, d], L). L = [b, b, c, d] ; ?- add1(c, [b, c, d], L). L = [c, b, c, d] ; Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]).

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: 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 Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll: % 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: % 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). 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 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). Anfrage: ?- add(a, [b, c], L). Muss vom Entwickler geleistet werden Wird von der Inferenzmaschine geleistet Regel 3 1 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). Ergebnis: ?- L = [A0|M0] = [b|[A1|M1]] = [b|[c|[E2]]] = [b|[c|[a]]] = [b, c, a]

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

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

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

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

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

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

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

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

Verarbeitung von Graphen Teil 5 Verarbeitung von Graphen

Ochsen-schwanz-suppe Umfüllproblem Ochsen-schwanz-suppe 4 Liter 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.

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

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

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

Übung 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 b c d e f i h Graph1.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 "Graph1.pl".

Übung 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 b c d e f i h Graph1.pl weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). 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. 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).

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

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

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

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

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

Übung pfeil(a, b). pfeil(a, c). ... d e f i h pfeil(a, b). pfeil(a, c). ... 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). ?- 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 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.

Übung pfeil(a, b). pfeil(a, c). ... d e f i h pfeil(a, b). pfeil(a, c). ... 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). ?- 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 Machen Sie sich klar, wie die Ergebnisse hier zustande kommen. Welche Rolle spielt dabei die in der Festlegung von weg1/4 vorkommende Variable B

Wegsuche mit Akkumulator b c d e f i h pfeil(a, b). pfeil(a, c). ... 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). ?- 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 Die Variable B dient hier als sog. Akkumulator. Mit Hilfe dieser Variablen werden die bisher besuchten Knoten in einer Liste zwischengespeichert.

Wegsuche mit Akkumulator b c d e f i h pfeil(a, b). pfeil(a, c). ... 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). Ü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. ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; ... No

Übung pfeil(a, b). pfeil(a, c). ... d e f i h pfeil(a, b). pfeil(a, c). ... 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). Testen Sie das erweiterte logische Programm mit verschiedenen Testdaten. Benutzen Sie einen Graphen mit Zyklen (wie in Graph2.pl). ?- weg(a, e, W). W = [e, d, b, a] ; W = [e, b, a] ; ... No

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

Ü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. AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), a g b c d e f 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.

Ü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 b c d e f i h 1 1 3 2 3 2 7 6 5 4 4 7 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?

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 b c d e f 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.

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. AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), a g b c d e f 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.

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

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

Deklarative Programmierung Teil 6 Deklarative Programmierung

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

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. 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 imperativer Ansatz

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

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 := erstesElement(X) Z := mitLetztem(Z, E) X := ohneEstes(X) solange Y nicht leer ist: E := erstesElement(Y) Z := mitLetztem(Z, E) Y := ohneEstes(Y) Anweisungen Register-maschine E.-Zustand {Z: [a, b, c, a, d]} Imperative Programmierung besteht darin, eine (mehr oder weniger abstrakte) Maschine mit Hilfe von Anweisungen zu steuern.

Literaturhinweise Gerhard Röhner: Informatik mit Prolog. Hessisches Landesinstitut für Pädagogik 2002. (HeLP Best.-Nr.: 06000). Rüdeger Baumann: PROLOG Einführungskurs. Klett-Verlag 1991. H. M. Otto: ProLog-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 – Ein 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.