Post on 05-Apr-2015
Logische Programmierung mit PROLOG
Klaus Becker
2007
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
4
(Heaven) Uranus = Gaea (Earth)
|
---------------------------------------
| | | | |
Cronus = Rhea Coeus = Phoebe Oceanus = Tethys
| | |
---------------------- Leto = Zeus Iapetus
| | | | | | |
Hestia | Poseidon | Demeter=Zeus | ----------------
Hades Zeus = Hera | | | | |
| | Persephone | | Prometheus |
Athena | --------- | |
| | | Atlas Epimetheus
--------------- Apollo Artemis | |
| | | | |
Ares Hebe Hephaestus Zeus=Maia Zeus=Dione
| |
From Edith Hamiltion's Mythology Hermes Aphrodite
Die Welt der griechischen Götter
5 Modellierungsansatz
Eine (Mini-) Welt besteht aus Objekten (Personen, Gegenstände, ...), die Eigenschaften haben und in Beziehung zueinander stehen.
Eine (Mini-) Welt besteht aus Objekten (Personen, Gegenstände, ...), die Eigenschaften haben und in Beziehung zueinander stehen.
Hera(weiblich)
Zeus(männlich)
ist verheiratet mit
6 Modellierungsansatz
Objekte werden mit Konstanten (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
Konstante
Prädikat
7 Modellierungsansatz
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
8 Modellierungsansatz
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
ng
direkte Beschreibu
ng
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.
Und
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.
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.
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|
Zeus|
Hebe...
kind(hebe, zeus).kind(hebe, hera).kind(zeus, rhea).kind(zeus, cronus).kind(rhea, uranus)....
vorfahr(cronus, zeus).vorfahr(cronus, hebe)....
Beschreibung der Miniwelt
Fakten und Regeln:
kind(hebe, zeus).kind(hebe, hera).kind(zeus, rhea).kind(zeus, cronus).kind(rhea, uranus)....
vorfahr(X, Y) :- kind(Y, X).
vorfahr(X, Y) :- kind(Y, Z), vorfahr(X,
Z).
Mit Hilfe von Fakten und Regeln wird implizit eine Modellwelt konstruiert, die die Miniwelt (in Teilen) beschreiben soll.
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.
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.
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".
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.
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)
Anna
Anton
Alfred
Anke
Arthur
Alba
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?
p1
a
p2
e
c
p3
b
f
g
d
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.
Der Programm-Interpreter sucht hierzu alle Instanzen der Anfrage, die in der Modellwelt gelten bzw. aus der Wissensbasis herleitbar sind.
28 Ja-Nein-Anfragen
maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X).
?- maennlich(zeus). % Ist Zeus männlich?Yes.
?- maennlich(hera). % Ist Hera männlich?No.
Ja-Nein-Anfrage
29 Ergänzungsanfragen
maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X).
?- vater(W, hermes). % 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
offen
Kann in beiden Rollen (+ / -) verwendet
werden
Die Datenflussrichtung kann flexibel gestaltet werden. Die Datenflussrichtung kann flexibel gestaltet werden.
32
33 Teil 3
Das Berechnungskonzept
34
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
35
Gegeben: Logik-Programm (Wissensbasis + Anfrage)Gegeben: Logik-Programm (Wissensbasis + Anfrage)
Ein einfaches Beispiel
a. b.c :- a, d.c :- e.d :- b.
?- c.
Beachte: Wir betrachten zunächst den Fall, dass keine Variablen im Logik-Programm vorkommen.
Beachte: Wir betrachten zunächst den Fall, dass keine Variablen im Logik-Programm vorkommen.
Yes.
Gesucht: Verfahren zur Bestimmung der Anfrageergebnisse Gesucht: Verfahren zur Bestimmung der Anfrageergebnisse
36
Logik-ProgrammLogik-Programm
Herleitung mit "modus ponens"
a. b.c :- a, d.c :- e.d :- b.
?- c.
Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel „modus ponens“:Die Grundlage einer Herleitung des Anfrageergebnisses ist die Schlussregel „modus ponens“:
HerleitungHerleitung
b b d--------d
Yes.
a--a
ad ad c----------c
b--b
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.
37
ProgrammProgramm
"Rückwärts"-Herleitung
a. b.c :- a, d.c :- e.d :- b.
?- c.
b b d--------d
Yes.
a--a
ad ad c----------c
b--b
? 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.
Yes.
? c.ad c.
? a, d.a.
? d.b d.
? b.b.
?
Rückwärts-HerleitungRückwärts-Herleitung
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.
Yes.
? c.ad c.
? a, d.a.
? d.b d.
? b.b.
? �
Rückwärts-HerleitungRückwärts-Herleitung
40 Resolution
ResolutionsschritteResolutionsschritteProgrammProgramm
a. b.c :- a, d.c :- e.d :- b.
?- c.
Yes.
? c.ad c.
? a, d.a.
? d.b d.
? b.b.
? �
Rückwärts-HerleitungRückwärts-Herleitung
-c-a -d c.
-a -d.a.
-d.-b d.
-b.b.
�Für Herleitungen mit Implikationen gilt:Rückwärts mit „modus ponens“ entspricht vorwärts mit Resolution.
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.
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.
? e.
ProgrammProgramm
a. b.c :- a, d.c :- e.d :- b.
?- c.
Yes.
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.
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.
?- c.
Yes.
erfolgreiche Herleitungerfolgreiche Herleitung
43
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?
44
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution
X = V, Y = hermes.
Ziel
?- vater(V, hermes).
?- kind(hermes, V), maennlich(V).
Regel
7
Auswertung von Anfragen
Regelanwendung:Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung (Substitution) gleichgemacht werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.
Regelanwendung:Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung (Substitution) gleichgemacht werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.
45
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution
X = V, Y = hermes.
V = maia.
Ziel
?- vater(V, hermes).
?- kind(hermes, V), maennlich(V).
?- maennlich(maia).
Regel
7
5
Auswertung von Anfragen
Regelanwendung:Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung gleichgemacht (unifiziert) werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.
Regelanwendung:Suche einen Fakt / Regelkopf, der mit der ersten Zielbedingung mit Hilfe einer geeigneten Variablenbindung gleichgemacht (unifiziert) werden kann. Ersetze die erste Zielbedingung durch den Regelrumpf und wende auf alle Terme des Ziels die Variablenbindung an.
46
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution
X = V, Y = hermes.
V = maia.
Ziel
?- vater(V, hermes).
?- kind(hermes, V), maennlich(V).
?- maennlich(maia).
?- kind(hermes, V), maennlich(V).
Regel
7
5
No
Auswertung von Anfragen
Backtracking: Wenn die erste Zielbedingung mit keinem Fakt / Regelkopf gleichgemacht werden kann, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.
Backtracking: Wenn die erste Zielbedingung mit keinem Fakt / Regelkopf gleichgemacht werden kann, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.
47
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution
X = V, Y = hermes.
V = maia.
V = zeus.
Ziel
?- vater(V, hermes).
?- kind(hermes, V), maennlich(V).
?- maennlich(maia).
?- kind(hermes, V), maennlich(V).
?- maennlich(zeus).
Regel
7
5
No
6
Auswertung von Anfragen
48
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Substitution
X = V, Y = hermes.
V = maia.
V = zeus.
V = zeus.
Ziel
?- vater(V, hermes).
?- kind(hermes, V), maennlich(V).
?- maennlich(maia).
?- kind(hermes, V), maennlich(V).
?- maennlich(zeus).
Regel
7
5
No
6
1
Auswertung von Anfragen
Ergebnis: Ist keine Zielbedingung mehr vorhanden, so liefert die Variablenbindung das gesuchte Ergebnis.
Ergebnis: Ist keine Zielbedingung mehr vorhanden, so liefert die Variablenbindung das gesuchte Ergebnis.
49
/*1*/ maennlich(zeus). /*2*/ weiblich(hera). /*3*/ weiblich(maia)./*4*/ kind(apollo, zeus). /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X).
Beweisbaum
Veranschaulichung: Die Herleitung eines Berechnungsergebnisses kann mit Hilfe eines Beweisbaumes verdeutlicht werden.
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
?- vater(V, hermes).
CALL: vater(V, hermes)
CALL: kind(hermes, V)
CALL: kind(hermes, maia)
EXIT: kind(hermes, maia)
CALL: maennlich(maia)
FAIL: maennlich(maia)
REDO: kind(hermes, V)
CALL: kind(hermes, zeus)
EXIT: kind(hermes, zeus)
CALL: maennlich(zeus)
EXIT: maennlich(zeus)
EXIT: vater(V, hermes)
V = zeus.
CALL: Teilziel aufrufen
EXIT: Zeilziel erfolgr. b.
REDO: Teilziel nochmal b.
FAIL: Teilziel erfolglos b.
51 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).
p1
a
p2
e
c
p3
b
f
g
d
?- ueber(X, g).
Schalten Sie den Trace-Modus ein und verfolgen Sie die Erzeugung der Berechnungsergebnisse. Mit welcher Strategie werden die zu überprüfenden Zielbedingungen von der Inferenzmaschine ausgewählt?
54 Ü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.
Wissensbasis - Version 1:kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z),
vorfahr(X, Z).
?- vorfahr(A, B).
Wissensbasis - Version 2:kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z),
kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B).
56 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.
Die Inferenzmaschine liefert unterschiedliche Berechnungsergebnisse. Diese werden durch die Algorithmen der Inferenzmaschine festgelegt. Die Reihenfolge der Regeln und der beteiligten Bedingungen spielen hierbei eine entscheidende Rolle.
Wissensbasis - Version 1:kind(hermes, maia).vorfahr(X, Y) :- kind(Y, X).vorfahr(X, Y) :- kind(Y, Z),
vorfahr(X, Z).
?- vorfahr(A, B).
Wissensbasis - Version 2:kind(hermes, maia).vorfahr(X, Y) :- vorfahr(X, Z),
kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B).
Substitution
X = A, Y = B
B = hermes, A = maia.
Ziel
?- vorfahr(A, B).
?- kind(B, A).
Substitution
X = A, Y = B
X = A, Y = Z.
...
Ziel
?- vorfahr(A, B).
?- vorfahr(A, Z), kind(B, Z).
?- vorfahr(A, U), kind(Z, U),...
...
57 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):
maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X).
?- vater(V, hermes).
58 Prozedurale Semantik
maennlich(zeus). weiblich(hera).weiblich(maia).kind(apollo, zeus).kind(hermes, maia).kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X).
?- vater(V, hermes).
Prozedurale Semantik eines Logik-Programms
Menge der Instanzen der Anfrage, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.
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...
62
Beispiele:
[ walter, ralph, anja, claudius, gaby ]
[a, b, c, d, e]
[1, [1, 2], [[1], [2], [3]]]
[]
Listen
Eine Liste ist eine geordnete Folge von Elementen beliebiger Länge. Die Elemente der Liste können (in Prolog) beliebige Terme sein: Konstanten, Zahlen, Variablen, Strukturen und auch wieder Listen. Die Listenelemente können also unterschiedliche Datentypen aufweisen.
Eine Liste ist eine geordnete Folge von Elementen beliebiger Länge. Die Elemente der Liste können (in Prolog) beliebige Terme sein: Konstanten, Zahlen, Variablen, Strukturen und auch wieder Listen. Die Listenelemente können also unterschiedliche Datentypen aufweisen.
63
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, [])))
Yes
Testen Sie auch weitere Listendarstellungen.
Geben Sie im Anfragefenster folgende Anfrage ein:
?- display([a, b, c]).
Die Auswertung dieser Anfrage liefert die Struktur der Liste:
.(a, .(b, .(c, [])))
Yes
Testen Sie auch weitere Listendarstellungen.
65
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
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.
Geben Sie im Anfragefenster folgende Anfrage ein:
?- [K | R] = [a, b, c].
Die Auswertung dieser Anfrage liefert die Belegung der Variablen:
K = a
R = [b, c] ;
No
Testen Sie auch weitere Listenaufteilungen.
67
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.
Aufgabe:Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.
Programm (Version1: mit Regel):
add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe].
Programm (Version2: mit Faktum):
add1(E, AlteListe, [E | AlteListe]).
68
Programmtest:
?- add1(a, [b, c, d], L).
L = [a, b, c, d] ;
No
?- add1(b, [b, c, d], L).
L = [b, b, c, d] ;
No
?- add1(c, [b, c, d], L).
L = [c, b, c, d] ;
No
Programm (Version1: mit Regel):
add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe].
Hinzufügen
Programm (Version2: mit Faktum):
add1(E, AlteListe, [E | AlteListe]).
Aufgabe:Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.
Aufgabe:Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element in eine Liste eingefügt werden kann.
69
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
70
% Einfügen in eine leere Liste:add2(E, [], [E]).
% Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden entspricht:add2(E, [E|X], [E|X]).
% Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht:add2(E, [A|X], L) :- ???
Hinzufügen
Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:
71
% Einfügen in eine leere Liste:add2(E, [], [E]).
% Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden entspricht:add2(E, [E|X], [E|X]).
% Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht:add2(E, [A|X], [A|M]) :- E \== A, add2(E, X, M).
Hinzufügen
Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:Fallunterscheidung gemäß der Struktur der Liste, in die das neue Element eingefügt werden soll:
Rekursives Problemreduktion in der dritten Regel: E eingefügt in [A|X] ergibt [A|M], wenn E \== A und wenn E eingefügt in X die Liste M ergibt.
72
Anfrage:
?- add(a, [b, c], L).
Wissensbasis (mit rekursiver Problemreduktion):
/* 1 */ add2(E, [], [E])./* 2 */ add2(E, [E|X], [E|X]). /* 3 */ add2(E, [A|X], [A|M]) :- E \== A, add2(E, X, M).
Auswertung einer Anfrage
Substitution
E0 = a, A0 = b, X0 = [c], L = [A0|M0].
E1 = a, A1 = c, X1 = [], M0 = [A1|M1]
E2 = a, M1 = [E2]
Ziel
?- add2(a, [b, c], L).
?- add2(a, [c], M0).
?- add2(a, [], M1).
Regel
3
3
1
Ergebnis:
?- L = [A0|M0] = [b|[A1|M1]] = [b|[c|[E2]]] = [b|[c|[a]]] = [b, c, a]
Wird von der Inferenzmaschine geleistet
Muss vom Entwickler geleistet werden
73
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
74
% Löschen aus einer leeren Liste:del(E, [], ).
% Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden entspricht:del(E, [E|X], ).
% Löschen aus einer (nichtleeren) Liste, deren erstes Element dem zu löschenden nicht entspricht: del(E, [A|X], ) :- E \== A, .
Übung
Ergänzen Sie die Fakten bzw. Regeln. Lösen Sie Fall 3 mit Hilfe einer rekursiven Problemreduktion. Testen Sie anschließend das entwickelte Programm.
75 Ü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.
z.B.:
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]).
82
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.
Gegeben ist ein "Beziehungsgeflecht" (ein sog. Graph), das mit Hilfe von Knoten beschrieben wird, die ggf. durch Kanten verbunden sind.
Startknoten
Zielknoten
Kante
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?
Start
Ziel
a
g
b c
d e f
ih
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.
Ein Graph beschreibt ein "Beziehungsgeflecht". Dieses wird mit Hilfe von Knoten beschrieben, die ggf. durch Kanten verbunden sind. Haben die Kanten eine Richtung, so spricht man von einem gerichteten Graphen.
gerichtete Kante
88
Modellierung eines gerichteten Graphen
Zur Beschreibung eines (gerichteten) Graphen werden sämtliche Kanten aufgelistet.
Zur Beschreibung eines (gerichteten) Graphen werden sämtliche Kanten aufgelistet.
pfeil(a, b).pfeil(a, c).pfeil(b, a).pfeil(b, d).pfeil(b, e).pfeil(c, a).pfeil(c, e).pfeil(c, f).pfeil(d, b).pfeil(d, g).pfeil(d, e).pfeil(e, b).pfeil(e, c).pfeil(f, b).pfeil(f, c).pfeil(f, i).pfeil(g, d)....
a
g
b c
d e f
ih
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".
Im folgenden betrachten wir zunächst Graphen ohne Zyklen. Als Beispiel dient der oben dargestellte vereinfachte Graph. Geben Sie die Fakten zur Beschreibung des Graphen ein oder laden Sie die Datei "Graph1.pl".
pfeil(a, b).pfeil(a, c).pfeil(b, d).pfeil(b, e).pfeil(c, e).pfeil(c, f).pfeil(d, g).pfeil(d, e).pfeil(f, b).pfeil(f, i).pfeil(h, b).pfeil(h, e).pfeil(i, e).pfeil(i, h).
a
g
b c
d e f
ih
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)....
a
g
b c
d e f
ih
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.
Ergänzen Sie wie gezeigt das Ausgabeprädikat "print" und erklären Sie die von PROLOG erzeugte Ausgabe.
pfeil(a, b).pfeil(a, c).pfeil(b, d).pfeil(b, e).pfeil(c, e).pfeil(c, f).pfeil(d, g).pfeil(d, e)....
a
g
b c
d e f
ih
Graph1.pl
?- weg(a, h).bdgeecefbdgeeieh
Yes
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?
Warum führt das gezeigte Programm bei Graphen mit Zyklen nicht zum gewünschten Ergebnis?
pfeil(a, b).pfeil(a, c).pfeil(b, a).pfeil(b, d).pfeil(b, e).pfeil(c, a).pfeil(c, e).pfeil(c, f).pfeil(d, b).pfeil(d, g)...
Graph2.pl
?- weg(a, h).
weg(X, X). weg(X, Y) :- pfeil(X, Z), weg(Z, Y).
a
g
b c
d e f
ih
93
Tiefensuche in zyklenfreien Graphen
?- weg(a, h).bdgeecefbdgeeieh
Yes
weg(X, X). weg(X, Y) :- pfeil(X, Z), print(Z), weg(Z, Y).
a b d g e e c e f b d g e e i e h
a
g
b c
d e f
ih
94
Tiefensuche in zyklenfreien Graphen
a b d g e e c e f b d g e e i e h
a
g
b c
d e f
ih
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".
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
b
a
g
b c
d e f
ih
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.
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
b
a
g
b c
d e f
ih
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?
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).
a
g
b c
d e f
ih
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
g
b c
d e f
ih
pfeil(a, b).pfeil(a, c)....
Machen Sie sich klar, wie die Ergebnisse hier zustande kommen. Welche Rolle spielt dabei die in der Festlegung von weg1/4 vorkommende Variable B
Machen Sie sich klar, wie die Ergebnisse hier zustande kommen. Welche Rolle spielt dabei die in der Festlegung von weg1/4 vorkommende Variable B
?- weg(a, e, W).W = [e, d, b, a] ;W = [e, b, a] ;W = [e, c, a] ;W = [e, d, b, f, c, a] ;...No
weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W).
99 Wegsuche mit Akkumulatora
g
b c
d e f
ih
pfeil(a, b).pfeil(a, c)....
Die Variable B dient hier als sog. Akkumulator. Mit Hilfe dieser Variablen werden die bisher besuchten Knoten in einer Liste zwischengespeichert.
Die Variable B dient hier als sog. Akkumulator. Mit Hilfe dieser Variablen werden die bisher besuchten Knoten in einer Liste zwischengespeichert.
?- weg(a, e, W).W = [e, d, b, a] ;W = [e, b, a] ;W = [e, c, a] ;W = [e, d, b, f, c, a] ;...No
weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), weg1(Z, Y, [Z|B], W).
100 Wegsuche mit Akkumulator
pfeil(a, b).pfeil(a, c)....
Überprüft man, ob der neue Knoten Z nicht unter den bereits besuchten Knoten in B vorkommt, so kann man das Prädikat weg/3 auch in Graphen mit Zyklen benutzen.
Überprüft man, ob der neue Knoten Z nicht unter den bereits besuchten Knoten in B vorkommt, so kann man das Prädikat weg/3 auch in Graphen mit Zyklen benutzen.
a
g
b c
d e f
ih
?- 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
pfeil(a, b).pfeil(a, c)....
Testen Sie das erweiterte logische Programm mit verschiedenen Testdaten. Benutzen Sie einen Graphen mit Zyklen (wie in Graph2.pl).
Testen Sie das erweiterte logische Programm mit verschiedenen Testdaten. Benutzen Sie einen Graphen mit Zyklen (wie in Graph2.pl).
a
g
b c
d e f
ih
?- weg(a, e, W).W = [e, d, b, a] ;W = [e, b, a] ;...No
weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).
102 Ü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.
Aus den ausgegebenen Listen lässt sich auch erschließen, in welcher Reihenfolge die Knoten des Graphen bearbeitet werden. Machen Sie sich diese Reihenfolge am Graphen klar.
a
g
b c
d e f
ih
?- weg(a, e, W).W = [e, d, b, a] ;W = [e, b, a] ;W = [e, c, a] ;W = [e, d, b, f, c, a] ;W = [e, b, f, c, a] ;W = [e, i, f, c, a] ;W = [e, d, b, h, i, f, c, a] ;W = [e, b, h, i, f, c, a] ;W = [e, h, i, f, c, a] ;No
weg(X, Y, W) :- weg1(X, Y, [X], W).weg1(X, X, B, W) :- W = B.weg1(X, Y, B, W) :- pfeil(X, Z), not(member(Z, B)), weg1(Z, Y, [Z|B], W).
103 Übung
weg(Start,Ziel,Loesung) :- NeuePfade = [[Start]], write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).
weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [Ziel|_], Loesung = AktuellerPfad.
weg1(AktuellerPfad,Ziel,Pfade,Loesung) :- AktuellerPfad = [KnotenA|_], findall( [KnotenN|AktuellerPfad], ( pfeil(KnotenA,KnotenN), not(member(KnotenN,AktuellerPfad)) ), GefundenePfade), append(Pfade,GefundenePfade,NeuePfade), write(NeuePfade), nl, NeuePfade=[PfadN|RestPfade], weg1(PfadN,Ziel,RestPfade,Loesung).
a
g
b c
d e f
ih
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.
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] ;...
a
g
b c
d e f
ih
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?
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?
1 1
22
3 3
4 4
567
7
105 Breitensuche
?- weg(a,h,L).[[a]][[b, a], [c, a]][[c, a], [d, b, a], [e, b, a]][[d, b, a], [e, b, a], [e, c, a], [f, c, a]][[e, b, a], [e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a]][[e, c, a], [f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a]][[f, c, a], [g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a]][[g, d, b, a], [e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]][[e, d, b, a], [c, e, b, a], [b, e, c, a], [b, f, c, a], [i, f, c, a]]...
L = [h, i, f, c, a] ;...
a
g
b c
d e f
ih
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.
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).
a
g
b c
d e f
ih
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.
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.
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.
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.