Logische Programmierung mit PROLOG Klaus Becker 2007.

transcript

Logische Programmierung mit PROLOG

Klaus Becker

2 Logische Programmierung

sterblich(X) :- mensch(X).mensch(sokrates).

?- sterblich(X).X = sokrates;No.

Alle Menschen sind sterblich.Sokrates ist ein Mensch.

Sokrates ist sterblich.

sterblich(X) :- mensch(X).mensch(sokrates).

sterblich(sokrates).

3 Teil 1

Fakten und Regeln

(Heaven) Uranus = Gaea (Earth)

---------------------------------------

| | | | |

Cronus = Rhea Coeus = Phoebe Oceanus = Tethys

---------------------- Leto = Zeus Iapetus

| | | | | | |

Hestia | Poseidon | Demeter=Zeus | ----------------

Athena | --------- | |

| | | Atlas Epimetheus

--------------- Apollo Artemis | |

| | | | |

Ares Hebe Hephaestus Zeus=Maia Zeus=Dione

From Edith Hamiltion's Mythology Hermes Aphrodite

Die Welt der griechischen Götter

5 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

Objekte werden mit Konstanten (allg. mit Termen) beschrieben, Eigenschaften und Beziehungen mit Hilfe von Prädikaten.Objekte werden mit Konstanten (allg. mit Termen) beschrieben, Eigenschaften und Beziehungen mit Hilfe von Prädikaten.

Fakten:

weiblich(hera). maennlich(zeus). verheiratet(zeus, hera).

ist verheiratet mit

Hera(weiblich)

Zeus(männlich)

Konstante

Prädikat

Sachverhalte der Miniwelt können direkt mit Hilfe von Fakten beschrieben werden.Sachverhalte der Miniwelt können direkt mit Hilfe von Fakten beschrieben werden.

Fakten:

weiblich(hera). maennlich(zeus). verheiratet(zeus, hera).

ist verheiratet mit

Hera(weiblich)

Zeus(männlich)

Miniwelt

Sachverhalte der Miniwelt können auch indirekt mit Hilfe von Regeln beschrieben werden.Sachverhalte der Miniwelt können auch indirekt mit Hilfe von Regeln beschrieben werden.

Fakten:

weiblich(maia).maennlich(zeus). kind(hermes, zeus).kind(hermes, maia).

Miniwelt

Zeus=Maia Zeus=Dione | | Hermes Aphrodite

Regeln:

vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X).

Fakten:

vater(zeus, hermes).vater(zeus, aphrodite).

indirekte Beschreibu

direkte Beschreibu

9 Regeln

Regeln sind Wenn-Dann-Aussagen.Regeln sind Wenn-Dann-Aussagen.

Regeln:

vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X).

Variable

Implikation

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.

Regelrumpf(Bedingungen)

Regelkopf(Folgerung)

10 Rekursive Regeln

Das Prädikat im Regelkopf darf im Regelrumpf vorkommen.Das Prädikat im Regelkopf darf im Regelrumpf vorkommen.

Regeln:

vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z).

informelle Beschreibung:

X ist Vorfahr von Y, wenn Y Kind von X ist. X ist Vorfahr von Y, wenn Y Kind von Z und X Vorfahr von Z ist.

Regelrumpf(Bedingungen)

Regelkopf(Folgerung)

11 Logische Herleitung der Modellwelt

kind(hebe, zeus).kind(hebe, hera).kind(zeus, rhea).kind(zeus, cronus).kind(rhea, uranus)....

vorfahr(X, Y) :- kind(Y, X).

vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Modellwe

ltvorfahr(cronus, zeus).vorfahr(cronus, hebe)....

Beschreibung der Miniwelt

kind(zeus, cronus). vorfahr(X, Y) :-

kind(Y, X).

vorfahr(cronus, zeus).

Logische Herleitung

kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) :-

kind(Y, Z), vorfahr(X, Z).

vorfahr(cronus, hebe).

Die in der Modellwelt geltenden Sachverhalte ergeben sich aus der (in/direkten) Beschreibung der Miniwelt durch logische Herleitungen.

12 Modus Ponens

Alle Menschen sind sterblich.Sokrates ist ein Mensch.

Sokrates ist sterblich.

Für alle X: mensch(X) sterblich(X).mensch(sokrates).

sterblich(sokrates).sterblich(X) :- mensch(X).mensch(sokrates).

sterblich(sokrates).

Zur Herleitung der Sachverhalte der Modellwelt wird die logische Schlussregel „modus ponens“ benutzt. Regeln werden dabei als Wenn-Dann-Aussagen interpretiert. Die in der Regel vorkommenden Variablen sind Platzhalter für alle Objekte der Modellwelt.

kind(zeus, cronus). vorfahr(X, Y) :-

kind(Y, X).

vorfahr(cronus, zeus).

kind(hebe, zeus). vorfahr(cronus, zeus). vorfahr(X, Y) :-

kind(Y, Z), vorfahr(X, Z).

vorfahr(cronus, hebe).

13 Von der Miniwelt zur Modellwelt

Miniwelt Modellwelt

Cronus|

Hebe...

vorfahr(cronus, zeus).vorfahr(cronus, hebe)....

Beschreibung der Miniwelt

Fakten und Regeln:

vorfahr(X, Y) :- kind(Y, X).

vorfahr(X, Y) :- kind(Y, Z), vorfahr(X,

Mit Hilfe von Fakten und Regeln wird implizit eine Modellwelt konstruiert, die 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-world-assumption).

Das gesamte Wissen über die Welt wird mit Fakten und Regeln modelliert.

In der Modellwelt gelten nur die „Sachverhalte“, die mit Hilfe der gegebenen Fakten und Regeln logisch hergeleitet werden können. Dies sind die direkt genannten Fakten und die mit Hilfe der logischen Schlussregel "modus ponens" herleitbaren Fakten (closed-world-assumption).

15 Übung

Gegeben ist die folgende (unvollständige) Beschreibung der Miniwelt. Welche der angezeigten Sachverhalte gelten in der Modellwelt?

Gegeben ist die folgende (unvollständige) Beschreibung der Miniwelt. Welche der angezeigten Sachverhalte gelten in der Modellwelt?Fakten und Regeln:

maennlich(cronus).maennlich(zeus).maennlich(hades).maennlich(poseidon).weiblich(rhea).weiblich(hera).kind(zeus, rhea).kind(hera, rhea).kind(hades, rhea).kind(hestia, rhea).vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). bruder(X, Y) :- maennlich(X), vater(Z, X), vater(Z, Y).bruder(X, Y) :- maennlich(X), mutter(Z, X), mutter(Z, Y).

Cronus = Rhea

----------------------

| | | | |

Hestia | Poseidon | Demeter=Zeus

Hades Zeus = Hera

bruder(zeus, hades).bruder(hades, zeus).bruder(zeus, poseidon).bruder(zeus, hestia).bruder(zeus, zeus).schwester(hera, hestia).

16 Übung

Ergänzen Sie die Regeln zur Beschreibung der Miniwelt. Gehen Sie davon aus, dass alle Fakten zu den Prädikaten "maennlich", "weiblich" und "kind" in der Faktenbasis korrekt aufgelistet sind.

Fakten und Regeln:

maennlich(cronus)...weiblich(rhea)...kind(zeus, rhea)...vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). elternteil(X, Y) :- bruder(X, Y) :- maennlich(X), elternteil(E, X), elternteil(E, Y), X \== Y.schwester(X, Y) :- sohn(X, Y) :-oma(X, Y) :-

Cronus = Rhea

----------------------

| | | | |

Hestia | Poseidon | Demeter=Zeus

Hades Zeus = Hera

17 Teil 2

Anfragen

18 Logik-Programme

maennlich(cronus).maennlich(zeus)...weiblich(rhea).weiblich(demeter)...kind(hestia, rhea).kind(hades, rhea)...vater(X, Y) :- kind(Y, X), maennlich(X).mutter(X, Y) :- kind(Y, X), weiblich(X).

?- weiblich(Frau).

Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage. Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage.

Wissensbasis

Anfrage

19 SWI-Prolog-Editor

Wissensbasis

Anfrage

20 PROLOG

PROLOG steht für „Programming in Logic“.

Die Programmiersprache PROLOG wurde Anfang der siebziger Jahre (des 20. Jahrhunderts) von Alain Colmerauer und Robert Kowalski konzipiert.

SWI-PROLOG ist ein freies und professionelles PROLOG-System, das seit 1987 an der Universität Amsterdam entwickelt und gepflegt wird.

Der SWI-PROLOG-Editor ist eine für den Unterricht geeignete Entwicklungsumgebung zur Erstellung von PROLOG-Programmen, die von G. Röhner entwickelt wurde.

Installationshinweise:Installieren Sie zunächst SWI-PROLOG.Installieren Sie anschließend den SWI-PROLOG-Editor.

21 Wissensbasis erzeugen

Geben Sie die Fakten und Regeln zur Beschreibung der Miniwelt ein oder laden Sie die entsprechende Quelldatei. Bevor Sie Anfragen an die Wissensbasis stellen können, muss diese Wissensbasis erst erzeugt werden. Rufen Sie hierzu das Systemprädikat "consult" auf.

Mit consult(<Datei>). werden aus der angegebenen Datei die Fakten und Regeln in die Wissensbasis

eingelesen.

Consultieren

Wenn der PROLOG-Interpreter keine Syntaxfehler gefunden hat, bestätigt er die erfolgreiche Erzeugung der Wissensbasis mit "Yes".

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

Findet der PROLOG-Interpreter keine weiteren Ergebnisse, so zeigt er dies mit "No" an.

Das trennende Semikolon kann als "oder" gedeutet werden.

Anfrage

AnfrageErgebnisse

23 Übung

Laden Sie die Datei "Familie1.pl" und erzeugen Sie mit "Consultieren" die zugehörige Wissensbasis.

Lassen Sie PROLOG die folgenden Anfragen auswerten. Formulieren Sie die Anfragen auch umgangssprachlich.

?- weiblich(hera). % Ist Hera weiblich??- vater(zeus, hades). ?- weiblich(Frau). % Wer ist weiblich??- mutter(M, zeus).?- mutter(rhea, Kind).?- mutter(hera, Kind).?- mutter(M, K).?- mutter(M, K), weiblich(K).?- vater(V, _Kind).?- weiblich(T), mutter(_, T).

Was hat es mit dem "_" auf sich?

Laden Sie die Datei "Familie1.pl" und erzeugen Sie mit "Consultieren" die zugehörige Wissensbasis.

Lassen Sie PROLOG die folgenden Anfragen auswerten. Formulieren Sie die Anfragen auch umgangssprachlich.

?- weiblich(hera). % Ist Hera weiblich??- vater(zeus, hades). ?- weiblich(Frau). % Wer ist weiblich??- mutter(M, zeus).?- mutter(rhea, Kind).?- mutter(hera, Kind).?- mutter(M, K).?- mutter(M, K), weiblich(K).?- vater(V, _Kind).?- weiblich(T), mutter(_, T).

Was hat es mit dem "_" auf sich?

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

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.

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)

Alfred

Arthur

siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

26 Übung

Wir betrachten die unten abgebildete Blockwelt. Wie könnte man die Struktur dieser Blockwelt mit Hilfe von Fakten und Regeln beschreiben?

siehe: G. Röhner: Informatik mit Prolog. HeLP 2002.

27 Anfragen

maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X).

?- weiblich(Frau).

Der Programm-Interpreter erzeugt die Ergebnisse der Anfrage. Der Programm-Interpreter erzeugt die Ergebnisse der Anfrage.

Wissensbasis

Anfrage

Frau = hera;Frau = maia;No.

Ergebnisse

Der Programm-Interpreter sucht hierzu alle Instanzen der Anfrage, die in der Modellwelt gelten bzw. aus der Wissensbasis herleitbar sind.

28 Ja-Nein-Anfragen

?- maennlich(zeus). % Ist Zeus männlich?Yes.

?- maennlich(hera). % Ist Hera männlich?No.

Ja-Nein-Anfrage

29 Ergänzungsanfragen

?- vater(W, hermes). % Wer ist Vater von Hermes?W = zeus;No.

?- weiblich(Frau). % Wer ist weiblich?Frau = hera;Frau = maia;No.

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

Anonyme Variablen werden nicht instanziert.Anonyme Variablen werden nicht instanziert.

Anonyme Variable

31 Datenflussrichtung

maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- % vater(?Vater, ?Kind)

kind(Y, X), maennlich(X).

?- vater(maia, hermes). % vater(+Vater, +Kind)

?- vater(V, hermes). % vater(-Vater, +Kind)

?- vater(zeus, K). % vater(+Vater, -Kind)

?- vater(V, K). % vater(-Vater, -Kind)

instanziert

Kann in beiden Rollen (+ / -) verwendet

werden

Die Datenflussrichtung kann flexibel gestaltet werden. Die Datenflussrichtung kann flexibel gestaltet werden.

33 Teil 3

Das Berechnungskonzept

Gegeben: Logik-Programm (Wissensbasis + Anfrage)Gegeben: Logik-Programm (Wissensbasis + Anfrage)

Suche nach Anfrageergebnissen

maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(V, hermes).

maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus).vater(zeus, apollo).vater(zeus, hermes)....

Problem: Wie erzeugt man systematisch Anfrageergebnisse?Problem: Wie erzeugt man systematisch Anfrageergebnisse?

V = zeus.

Gesucht: Instanzen der Anfrage, die zur Modellwelt gehörenGesucht: Instanzen der Anfrage, die zur Modellwelt gehören

induzierte Modellwelt

Gegeben: Logik-Programm (Wissensbasis + Anfrage)Gegeben: Logik-Programm (Wissensbasis + Anfrage)

Ein einfaches Beispiel

a. b.c :- a, d.c :- e.d :- b.

Beachte: Wir betrachten zunächst den Fall, dass keine Variablen im Logik-Programm vorkommen.

Gesucht: Verfahren zur Bestimmung der Anfrageergebnisse Gesucht: Verfahren zur Bestimmung der Anfrageergebnisse

Logik-ProgrammLogik-Programm

Herleitung mit "modus ponens"

a. b.c :- a, d.c :- e.d :- b.

Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel „modus ponens“:Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel „modus ponens“:

HerleitungHerleitung

b b d--------d

ad ad c----------c

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.

ProgrammProgramm

"Rückwärts"-Herleitung

a. b.c :- a, d.c :- e.d :- b.

b b d--------d

ad ad c----------c

? c.ad c.

? a, d.a.

? d.b d.

? b.b.

Rückwärts-HerleitungRückwärts-Herleitung

Vorwärts-HerleitungVorwärts-Herleitung

38 "Rückwärts"-Herleitung

Zeige cDa ad c, reicht es:Zeige a, d.Da a, reicht es:Zeige d.Da b d, reicht es:Zeige b.Da b, Fertig!

Rückwärts-DeutungRückwärts-DeutungProgrammProgramm

a. b.c :- a, d.c :- e.d :- b.

? c.ad c.

? a, d.a.

? d.b d.

? b.b.

39 Deutung als Widerspruchsbeweis

Ang., c gilt nicht,Da ad c, gilt danna nicht oder d nicht.Da a, gilt dannd nicht.Da b d, gilt dannb nicht.Da b, Widerspruch!

Rückwärts-DeutungRückwärts-DeutungProgrammProgramm

a. b.c :- a, d.c :- e.d :- b.

? c.ad c.

? a, d.a.

? d.b d.

? b.b.

40 Resolution

ResolutionsschritteResolutionsschritteProgrammProgramm

a. b.c :- a, d.c :- e.d :- b.

? c.ad c.

? a, d.a.

? d.b d.

? b.b.

-c-a -d c.

-a -d.a.

-d.-b d.

�Für Herleitungen mit Implikationen gilt:Rückwärts mit „modus ponens“ entspricht vorwärts mit Resolution.

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

41 Sackgassen

Es ergeben sich oft verschiedene Möglichkeiten, wie eine Herleitung weitergeführt werden kann. Nicht alle diese Herleitungen sind aber erfolgreich. Eine „passende“ Herleitung muss man daher in der Regel suchen.

? c.ad c.

? a, d.a.

? d.b d.

? b.b.

Herleitung mit SackgasseHerleitung mit Sackgasse

? c.e c.

ProgrammProgramm

a. b.c :- a, d.c :- e.d :- b.

erfolgreiche Herleitungerfolgreiche Herleitung

42 Backtracking

Backtracking: Wenn der erste Term des Ziels mit keinem Regelkopf übereinstimmt, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.

Herleitung mit SackgasseHerleitung mit Sackgasse

? c. e c. ? e. zurücksetzen? c. ad c. ? a, d. a. ? d. b d. ? b. b. ?

ProgrammProgramm

a. b.c :- e.c :- a, d.d :- b.

erfolgreiche Herleitungerfolgreiche Herleitung

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

ErgebnisV = zeus. /* Substitution */

Der allgemeine Fall

Problem: Wie erzeugt man systematisch logische Herleitungen?Problem: Wie erzeugt man systematisch logische Herleitungen?

/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution

X = V, Y = hermes.

?- vater(V, hermes).

?- kind(hermes, V), maennlich(V).

Auswertung von Anfragen

Regelanwendung:Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung (Substitution) gleichgemacht werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.

X = V, Y = hermes.

V = maia.

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

X = V, Y = hermes.

V = maia.

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

X = V, Y = hermes.

V = maia.

V = zeus.

?- maennlich(maia).

?- maennlich(zeus).

X = V, Y = hermes.

V = maia.

V = zeus.

?- maennlich(maia).

?- maennlich(zeus).

Ergebnis: Ist keine Zielbedingung mehr vorhanden, so liefert die Variablenbindung das gesuchte Ergebnis.

/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X).

Beweisbaum

Veranschaulichung: Die Herleitung eines Berechnungsergebnisses kann mit Hilfe eines Beweisbaumes verdeutlicht werden.

vater(V, hermes)

kind(hermes, V) maennlich(V)

kind(hermes, maia) kind(hermes, zeus) maennlich(zeus)

UND-Knoten

ODER-Knoten

X = V, Y = hermes.

V = maia. V = zeus. V = zeus.

50 Trace einer Beweissuche

vater(V, hermes)

kind(hermes, V) maennlich(V)

kind(hermes, maia) kind(hermes, zeus) maennlich(zeus)

UND-Knoten

ODER-Knoten

CALL: vater(V, hermes)

CALL: kind(hermes, V)

CALL: kind(hermes, maia)

EXIT: kind(hermes, maia)

CALL: maennlich(maia)

FAIL: maennlich(maia)

REDO: kind(hermes, V)

CALL: kind(hermes, zeus)

EXIT: kind(hermes, zeus)

CALL: maennlich(zeus)

EXIT: maennlich(zeus)

EXIT: vater(V, hermes)

V = zeus.

CALL: Teilziel aufrufen

EXIT: Zeilziel erfolgr. b.

REDO: Teilziel nochmal b.

FAIL: Teilziel erfolglos b.

51 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 bei der logischen Programmierung beruht auf „maschinellem“ logischen Schließen. Hierzu werden die folgenden Algorithmen von einer sog. Inferenzmaschine geeignet kombiniert:

Unifikationsalgorithmus (erzeugt Variablenbindung)

Inferenzalgorithmus (wendet die Schlussregel "modus ponens" an)

Suchalgorithmus (benutzt Backtracking)

52 Das Berechnungskonzept

Ergebnis

Inferenz-maschine

Anfrage

Wissensbasis

kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z),

vorfahr(X, Z).

?- vorfahr(A, B).

X = maia, Y = hermes.

Die Inferenzmaschine versucht, logische Ableitungen zur Anfrage aus der Wissensbasis zu erstellen. Die Inferenzmaschine versucht, logische Ableitungen zur Anfrage aus der Wissensbasis zu erstellen.

53 Übung

Wir betrachten das folgende Logik-Programm zur Blockwelt:

auf(a, p1).auf(c, a).auf(e, p2).auf(b, p3).auf(f, b).auf(g, f).auf(d, g).ueber(X, Y) :- auf(X, Y).ueber(X, Y) :- auf(X, Z), ueber(Z, Y).

?- ueber(X, g).

Schalten Sie den Trace-Modus ein und verfolgen Sie die Erzeugung der Berechnungsergebnisse. Mit welcher Strategie werden die zu überprüfenden Zielbedingungen von der Inferenzmaschine ausgewählt?

54 Übung

Wir betrachten die beiden folgenden Logik-Programme:

Welche Berechnungsergebnisse erwarten Sie? Bestimmen Sie die Ergebnisse mit Hilfe von PROLOG.Verfolgen Sie die Berechnung der Ergebnisse mit Hilfe einer

Trace.Wie lässt sich das Verhalten von PROLOG erklären?

Wissensbasis - Version 1:kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z),

vorfahr(X, Z).

?- vorfahr(A, B).

Wissensbasis - Version 2:kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z),

kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B).

55 Grenzen der Logik

kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X).

vorfahr(maia, hermes).

Die Logik-Programme sind logisch äquivalent. Aus beiden Programmen lassen sich dieselben Herleitungen erzeugen.Die Logik-Programme sind logisch äquivalent. Aus beiden Programmen lassen sich dieselben Herleitungen erzeugen.

vorfahr(X, Z).

?- vorfahr(A, B).

56 Grenzen der Logik

Die Inferenzmaschine liefert unterschiedliche Berechnungsergebnisse. Diese werden durch die Algorithmen der Inferenzmaschine festgelegt. Die Reihenfolge der Regeln und der beteiligten Bedingungen spielen hierbei eine entscheidende Rolle.

vorfahr(X, Z).

?- vorfahr(A, B).

Substitution

X = A, Y = B

B = hermes, A = maia.

?- vorfahr(A, B).

?- kind(B, A).

Substitution

X = A, Y = B

X = A, Y = Z.

?- vorfahr(A, B).

?- vorfahr(A, Z), kind(B, Z).

?- vorfahr(A, U), kind(Z, U),...

57 Deklarative Semantik

Deklarative Semantik eines Logik-Programms

Menge der Instanzen der Anfrage, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel „modus ponens“ hergeleitet werden können.

Deklarative Semantik eines Logik-Programms

Menge der Instanzen der Anfrage, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel „modus ponens“ hergeleitet werden können.

Logisches Programm (Wissensbasis + Anfrage):Logisches Programm (Wissensbasis + Anfrage):

58 Prozedurale Semantik

Prozedurale Semantik eines Logik-Programms

Menge der Instanzen der Anfrage, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

Prozedurale Semantik eines Logik-Programms

Menge der Instanzen der Anfrage, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

Logisches Programm (Wissensbasis + Anfrage):Logisches Programm (Wissensbasis + Anfrage):

59 Teil 4

Listenverarbeitung

60 Wer wird eingeladen?

WalterRalphAnjaClaudiusKlausGaby...

61 Listen

Listen werden in vielen Anwendungen benötigt, um Datenelemente flexibel verwalten zu können.

Insbesondere möchte man Datenelemente hinzufügen und auch wieder entfernen können.

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.

WalterRalphAnjaClaudiusKlausGaby...

Beispiele:

[ walter, ralph, anja, claudius, gaby ]

[a, b, c, d, e]

[1, [1, 2], [[1], [2], [3]]]

Listen

Eine Liste ist eine geordnete Folge von Elementen beliebiger Länge. Die Elemente der Liste können (in Prolog) beliebige Terme sein: Konstanten, Zahlen, Variablen, Strukturen und auch wieder Listen. Die Listenelemente können also unterschiedliche Datentypen aufweisen.

Beispiel: . (a, . (b, . (c, []))) [a, b, c]

. (c, []) [c]

. (b, [c]) [b, c]

. (a, [b, c]) [a, b, c]

Listenkonstruktoren

Alle Listen können mit Hilfe der beiden folgenden Konstruktoren aufgebaut werden:

[] „leere Liste“

. „hinzufügen“

Alle Listen können mit Hilfe der beiden folgenden Konstruktoren aufgebaut werden:

[] „leere Liste“

. „hinzufügen“

Struktur: .(Element, Liste) NeueListeStruktur: .(Element, Liste) NeueListe

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, [])))

Testen Sie auch weitere Listendarstellungen.

?- display([a, b, c]).

Die Auswertung dieser Anfrage liefert die Struktur der Liste:

.(a, .(b, .(c, [])))

Testen Sie auch weitere Listendarstellungen.

Beispiele:

[K | R] = [a, b, c] K = a, R = [b, c]

[K | R] = [5] K = 5, R = []

[K | R] = [[1], [3]] K = [1], R = [[3]]

[E1, E2 | R] = [a, b, c] E1 = a, E2 = b, R = [c]

[E1, E2 | R] = [a] Unifikation nicht möglich

Unifikation bei Listen

Jede Liste lässt sich in der Form [Kopfelement | Restliste] darstellen. Jede Liste lässt sich in der Form [Kopfelement | Restliste] darstellen.

66 Übung

?- [K | R] = [a, b, c].

Die Auswertung dieser Anfrage liefert die Belegung der Variablen:

R = [b, c] ;

Testen Sie auch weitere Listenaufteilungen.

?- [K | R] = [a, b, c].

Die Auswertung dieser Anfrage liefert die Belegung der Variablen:

R = [b, c] ;

Testen Sie auch weitere Listenaufteilungen.

Spezifikation: add1/3

Semantik:add1(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe = [E | AlteListe].

Beispiel: add1(a, [b, c, d], [a, b, c, d]).

Hinzufügen

Aufgabe:Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.

Programm (Version1: mit Regel):

add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe].

Programm (Version2: mit Faktum):

add1(E, AlteListe, [E | AlteListe]).

Programmtest:

?- add1(a, [b, c, d], L).

L = [a, b, c, d] ;

?- add1(b, [b, c, d], L).

L = [b, b, c, d] ;

?- add1(c, [b, c, d], L).

L = [c, b, c, d] ;

Programm (Version1: mit Regel):

add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe].

Hinzufügen

Programm (Version2: mit Faktum):

add1(E, AlteListe, [E | AlteListe]).

Aufgabe:Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.

AufgabeEs 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

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

Hinzufügen

Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:

Rekursives Problemreduktion in der dritten Regel: E eingefügt in [A|X] ergibt [A|M], wenn E \== A und wenn E eingefügt in X die Liste M ergibt.

Anfrage:

?- add(a, [b, c], L).

Wissensbasis (mit rekursiver Problemreduktion):

/* 1 */ add2(E, [], [E])./* 2 */ add2(E, [E|X], [E|X]). /* 3 */ add2(E, [A|X], [A|M]) :- E \== A, add2(E, X, M).

Auswertung einer Anfrage

Substitution

E0 = a, A0 = b, X0 = [c], L = [A0|M0].

E1 = a, A1 = c, X1 = [], M0 = [A1|M1]

E2 = a, M1 = [E2]

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

Wird von der Inferenzmaschine geleistet

Muss vom Entwickler geleistet werden

AufgabeEs 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

% Löschen aus einer leeren Liste:del(E, [], ).

% Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden entspricht:del(E, [E|X], ).

% Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden nicht entspricht: del(E, [A|X], ) :- E \== A, .

Übung

Ergänzen Sie die Fakten bzw. Regeln. Lösen Sie Fall 3 mit Hilfe einer rekursiven Problemreduktion. Testen Sie anschließend das entwickelte Programm.

75 Übung

AufgabeEs 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

AufgabeFü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

AufgabeEs soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe die Elemente von zwei Listen zusammengefügt werden können.

Spezifikation: zusammenfuegen/3

Semantik:

zusammenfuegen(X, Y, Z) gilt in der Modellwelt, wenn Z aus allen Elementen der Listen X und Y besteht, wobei zuerst alle Elemente aus X und dann alle Elemente aus Y in der vorgegebenen Reihenfolge vorkommen.

Beispiele für Sachverhalte der Modellwelt: zusammenfuegen([a, b], [b, c, d], [a, b, b, c, d]). zusammenfuegen([], [b, c, d], [b, c, d]).

78 Übung

AufgabeFü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.

append(X, [a], [b, c, a]).

append(X, Y, [a, b, c]).

79 Übung

AufgabeEs 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

AufgabeEs 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

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

83 Teil 5

Verarbeitung von Graphen

84 Umfüllproblem

Ochsen-schwanz-suppe

3 Liter4 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.

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öglichkeiten3-l-Eimer4-l-Eimer

2 Liter!

86 Graphenproblem

Problem: Gibt es einen Weg von einem Startknoten zu einem Zielknoten entlang der vorgegebenen Kanten? Problem: Gibt es einen Weg von einem Startknoten zu einem Zielknoten entlang der vorgegebenen Kanten?

Gegeben ist ein "Beziehungsgeflecht" (ein sog. Graph), das mit Hilfe von Knoten beschrieben wird, die ggf. durch Kanten verbunden sind.

Startknoten

Zielknoten

87 Graphenproblem

Problem: Gibt es einen Weg von einem Startknoten (z. B. a) zu einem Zielknoten (z. B. h) entlang der vorgegebenen Kanten? Problem: Gibt es einen Weg von einem Startknoten (z. B. a) zu einem Zielknoten (z. B. h) entlang der vorgegebenen Kanten?

Ein Graph beschreibt ein "Beziehungsgeflecht". Dieses wird mit Hilfe von Knoten beschrieben, die ggf. durch Kanten verbunden sind. Haben die Kanten eine Richtung, so spricht man von einem gerichteten Graphen.

gerichtete Kante

Modellierung eines gerichteten Graphen

Zur Beschreibung eines (gerichteten) Graphen werden sämtliche Kanten aufgelistet.

pfeil(a, b).pfeil(a, c).pfeil(b, a).pfeil(b, d).pfeil(b, e).pfeil(c, a).pfeil(c, e).pfeil(c, f).pfeil(d, b).pfeil(d, g).pfeil(d, e).pfeil(e, b).pfeil(e, c).pfeil(f, b).pfeil(f, c).pfeil(f, i).pfeil(g, d)....

89 Übung

Im folgenden betrachten wir zunächst Graphen ohne Zyklen. Als Beispiel dient der oben dargestellte vereinfachte Graph. Geben Sie die Fakten zur Beschreibung des Graphen ein oder laden Sie die Datei "Graph1.pl".

pfeil(a, b).pfeil(a, c).pfeil(b, d).pfeil(b, e).pfeil(c, e).pfeil(c, f).pfeil(d, g).pfeil(d, e).pfeil(f, b).pfeil(f, i).pfeil(h, b).pfeil(h, e).pfeil(i, e).pfeil(i, h).

Graph1.pl

90 Übung

Die Fakten sollen um Regeln zur Festlegung eines Prädikats weg/2 ergänzt werden.

Welcher Vorschlag ist hierzu geeignet? Testen Sie die drei Vorschläge. Klären Sie auch die Unterschiede.

Die Fakten sollen um Regeln zur Festlegung eines Prädikats weg/2 ergänzt werden.

Welcher Vorschlag ist hierzu geeignet? Testen Sie die drei Vorschläge. Klären Sie auch die Unterschiede.

pfeil(a, b).pfeil(a, c).pfeil(b, d).pfeil(b, e).pfeil(c, e).pfeil(c, f).pfeil(d, g).pfeil(d, e)....

Graph1.pl

weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). weg(X, Y) :- pfeil(X, Z), weg(Z, Y). weg(X, X). weg(X, Y) :- pfeil(X, Y). weg(X, Y) :- pfeil(X, Z), weg(Z, Y).

91 Übung

Ergänzen Sie wie gezeigt das Ausgabeprädikat "print" und erklären Sie die von PROLOG erzeugte Ausgabe.

pfeil(a, b).pfeil(a, c).pfeil(b, d).pfeil(b, e).pfeil(c, e).pfeil(c, f).pfeil(d, g).pfeil(d, e)....

Graph1.pl

?- weg(a, h).bdgeecefbdgeeieh

weg(X, X). weg(X, Y) :- pfeil(X, Z), print(Z), weg(Z, Y).

92 Übung

Warum führt das gezeigte Programm bei Graphen mit Zyklen nicht zum gewünschten Ergebnis?

pfeil(a, b).pfeil(a, c).pfeil(b, a).pfeil(b, d).pfeil(b, e).pfeil(c, a).pfeil(c, e).pfeil(c, f).pfeil(d, b).pfeil(d, g)...

Graph2.pl

?- weg(a, h).

weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y).

Tiefensuche in zyklenfreien Graphen

?- weg(a, h).bdgeecefbdgeeieh

weg(X, X). weg(X, Y) :- pfeil(X, Z), print(Z), weg(Z, Y).

a b d g e e c e f b d g e e i e h

Tiefensuche in zyklenfreien Graphen

a b d g e e c e f b d g e e i e h

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

95 Übung

Erzeugen Sie systematisch einen Weg von b nach d. Gehen Sie bei der Wahl der Nachbarknoten alphabetisch vor. Erstellen Sie auch den zugehörigen Tiefensuchbaum.

96 Übung

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

?- weg(a, e, W).W = [e, d, b, a] ;W = [e, b, a] ;W = [e, c, a] ;W = [e, d, b, f, c, a] ;...No

weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W).

pfeil(a, b).pfeil(a, c)....

Testen Sie die gezeigten Regeln zur Festlegung eines erweiterten Prädikats weg/3 (auch mit anderen Variablenbelegungen).

Deuten Sie die von der Inferenz-maschine erzeugten Ergebnisse.

Testen Sie die gezeigten Regeln zur Festlegung eines erweiterten Prädikats weg/3 (auch mit anderen Variablenbelegungen).

Deuten Sie die von der Inferenz-maschine erzeugten Ergebnisse.

98 Übunga

Machen Sie sich klar, wie die Ergebnisse hier zustande kommen. Welche Rolle spielt dabei die in der Festlegung von weg1/4 vorkommende Variable B

99 Wegsuche mit Akkumulatora

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

Ü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

weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).

101 Übung

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

102 Übung

Aus den ausgegebenen Listen lässt sich auch erschließen, in welcher Reihenfolge die Knoten des Graphen bearbeitet werden. Machen Sie sich diese Reihenfolge am Graphen klar.

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

103 Übung

weg(Start,Ziel,Loesung) :- NeuePfade = [[Start]], write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).

weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [Ziel|_], Loesung = AktuellerPfad.

weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).

Testen Sie das nebenstehende logische Programm (siehe Wegsuche4a.pl). Stellen Sie die Anfrage weg(a, h, L) sowie weitere analoge Anfragen. Versuchen Sie, mit Hilfe der nächsten Folie die Ausgaben zu deuten.

104 Ü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] ;...

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

?- 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] ;...

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) :- NeuePfade = [[Start]], write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).

weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [Ziel|_], Loesung = AktuellerPfad.

weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).

AktuellerPfad beginne mit KnotenA.Füge alle Erweiterungen von AktuellerPfad um einen neuen Knoten KnotenN, der von KnotenA aus erreichbar ist und nicht bereits in AktuellerPfad vorkommt, in eine Liste GefundenePfade. Hänge diese Liste GefundenePfade an die Liste Pfade an und nenne die neue Liste NeuePfade.Der erste Pfad PfadN in NeuePfade ist der als nächstes zu bearbeitende Pfad.

107 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-Eimerzustandsuebergang([Vier,Drei],[0,Drei1]) :- Vier \== 0, Drei + Vier =< 3,Drei1 is Drei+Vier. % 4-l-Eimer umfüllen in 3-l-Eimerzustandsuebergang([Vier,Drei],[Vier1,3]) :- Drei \== 3, Drei + Vier > 3,Vier1 is Drei+Vier-3. % 4-l-Eimer teilw. umfüllen in 3-l-Eimerzustandsuebergang([Vier,Drei],[4,Drei1]) :- Vier \== 4, Drei + Vier >4,Drei1 is Drei+Vier-4. % 3-l-Eimer teilw. umfüllen in 3-l-Eimer

weg(W) :- startzustand(X), zielErreicht(Y), weg1(X, Y, [X], W)....

108 Anwendung: Wasser umfüllen

pfeil(X, Y) :- zustandsuebergang(X, Y).

weg(W) :- startZustand(X), zielZustand(Y), weg1(X, Y, [X], W).

startZustand([0,0]).zielZustand([2,N]).zielZustand([M,2]).

% Tiefensuche:weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X,Z), not(member(Z,B)), weg1(Z,Y,[Z|B],W).

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

Wenn die erste Liste eine nichtleere Liste bestehend aus einem ersten Element E und einer evtl. leeren Restliste RX ist, dann soll für das Ergebnis folgendes gelten: Wenn die Restliste RX mit der zweiten Liste Y zusammengefügt RZ ergibt, dann ist das gesuchte Ergebnis eine Liste bestehend aus dem ersten Element E und RZ als Restliste. zusammenfuegen([E|RX], Y, [E|RZ]) :- fuegezusammen(RX, Y, RZ).

Lösung:

Stell eine neue Liste Z wie folgt zusammen:

Starte mit der einer leeren Liste.

Füge Schritt für Schritt alle Elemente der beiden Listen X und Y jeweils am Ende von Z ein.

Z := []solange X nicht leer ist: E := erstesElement(X) Z := mitLetztem(Z, E) X := ohneEstes(X)solange Y nicht leer ist: E := erstesElement(Y) Z := mitLetztem(Z, E) Y := ohneEstes(Y)

deklarativer Ansatz imperativer Ansatz

111 Ein Problem - zwei Lösungen

Problem:Wie fügt man die Elemente von zwei Listen zusammen?

Lösung:

Wenn die erste Liste eine leere Liste ist, dann ist die zweite Liste bereits das Ergebnis. Wenn die erste Liste eine nichtleere Liste bestehend aus einem ersten Element E und einer evtl. leeren Restliste RX ist, dann soll für das Ergebnis folgendes gelten: Wenn die Restliste RX mit der zweiten Liste Y zusammengefügt RZ ergibt, dann ist das gesuchte Ergebnis eine Liste bestehend aus dem ersten Element E und RZ als Restliste.

Lösung:

Stell eine neue Liste Z wie folgt zusammen:

Starte mit der einer leeren Liste.

Füge Schritt für Schritt alle Elemente der beiden Listen X und Y jeweils am Ende von Z ein.

deklarativer Ansatz imperativer Ansatz

Man beschreibt, welche Eigenschaften das Ergebnis haben soll, das man beim Zusammenfügen erhält.

Man beschreibt Schritt für Schritt den Vorgang, wie man zwei Listen zusammenfügt.

112 Deklarative Programmierung

Ansatz: Beschreiben, was in der Modellwelt gelten sollAnsatz: Beschreiben, was in der Modellwelt gelten soll

Deklarative Programmierung besteht darin, den Problemkontext (Miniwelt) mit gegebenen Mitteln (hier: Fakten und Regeln) zu beschreiben.

Inferenz-maschine

zusammenfuegen([], Y, Y). zusammenfuegen([E|RX], Y, [E|RZ]) :- fuegezusammen(RX, Y, RZ).

?- zusammenfuegen([a, b], [c, a, d], Z).

Z = [a, b, c, a, d]Ergebnis

Anfrage

Wissensbasis

113 Imperative ProgrammierungAnsatz: Beschreiben, wie die Ergebnisse berechnet werden sollenAnsatz: Beschreiben, wie die Ergebnisse berechnet werden sollen

E.-Zustand

Register-maschine

A.-Zustand

Anweisungen

Z := []solange X nicht leer ist: E := erstesElement(X) Z := mitLetztem(Z, E) X := ohneEstes(X)solange Y nicht leer ist: E := erstesElement(Y) Z := mitLetztem(Z, E) Y := ohneEstes(Y)

{X: [a, b]; Y: [c, a, d]}

{Z: [a, b, c, a, d]}

Imperative Programmierung besteht darin, eine (mehr oder weniger abstrakte) Maschine mit Hilfe von Anweisungen zu steuern.

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

Logische Programmierung mit PROLOG Klaus Becker 2007.

Documents