Programmieren mit Prädikatenlogik

Präsentation zum Thema: "Programmieren mit Prädikatenlogik"—  Präsentation transkript:

1 Programmieren mit Prädikatenlogik
Klaus Becker 2004

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

3 Teil 1 Fakten und Regeln

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

5 Modellierungsansatz Eine (Mini)Welt besteht aus Objekten (Personen, Gegenstände, ...), die Eigenschaften haben und in Beziehung zueinander stehen. Hera (weiblich) Zeus (männlich) ist verheiratet mit

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

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

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

9 Regelkopf (Folgerung)
Regeln Regeln sind Wenn-Dann-Aussagen. Implikation Und Variable Regeln: vater(X, Y) :- kind(Y, X), maennlich(X). mutter(X, Y) :- kind(Y, X), weiblich(X). Regelkopf (Folgerung) Regelrumpf (Bedingung) informelle Beschreibung: X ist Vater von Y, wenn Y Kind von X ist und X männlich ist. X ist Mutter von Y, wenn Y Kind von X ist und X weiblich ist.

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

11 Von der Miniwelt zur Modellwelt
Uranus | Rhea | Zeus | Hebe ... Miniwelt Modellwelt vorfahr(zeus, hebe). vorfahr(rhea, hebe). vorfahr(uranus, hebe). ... Fakten und Regeln: kind(hebe, zeus). kind(hebe, hera). kind(zeus, rhea). kind(zeus, cronus). kind(rhea, uranus). ... vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Beschreibung der Miniwelt

12 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). Beschreibung der Miniwelt Logische Herleitung kind(hebe, zeus). vorfahr(X, Y) :- kind(Y, X). vorfahr(zeus, hebe). kind(zeus, rhea). vorfahr(zeus, hebe). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). vorfahr(rhea, hebe). vorfahr(zeus, hebe). vorfahr(rhea, hebe). ... Modellwelt

13 Modus Ponens Zur Festlegung der Modellwelt wird die logische Schlussregel „modus ponens“ benutzt. Regeln werden dabei als Wenn-Dann-Aussagen interpretiert. Die in der Regel vorkommenden Variablen sind Platzhalter für alle Objekte der Modellwelt. Alle Menschen sind sterblich. Sokrates ist ein Mensch. Sokrates ist sterblich. Für alle X: mensch(X)  sterblich(X). mensch(sokrates). sterblich(sokrates). sterblich(X) :- mensch(X). mensch(sokrates). sterblich(sokrates).

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 abgeleitet werden können. Dies sind die direkt genannten Fakten und die mit Hilfe der logischen Schlussregel abgeleiteten Fakten (closed-world-assumption).

15 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

16 Anfragen 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

17 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? ?- mutter(M) % Wer ist Mutter? Anonyme Variable Anonyme Variablen werden nicht instanziert.

18 Datenflussrichtung maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(maia, hermes). % Ist Maia der Vater von Hermes? ?- vater(V, hermes). % Wer ist der Vater von Hermes? ?- vater(zeus, K). % Von wem ist Zeus der Vater? ?- vater(V, K). % Wer ist Vater von wem?

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

20 Logik-Programm maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). Wissensbasis ?- weiblich(Frau). Anfrage Ein Logik-Programm besteht aus einer Wissensbasis und einer Anfrage.

21 Hinweise zur Syntax 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). 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.

22 PROLOG PROLOG („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 (unterrichtsgeeignete) Entwicklungsumgebung zur Erstellung von PROLOG-Programmen (Autor: G. Röhner).

23 SWI-Prolog-Editor Wissensbasis Anfrage

24 SWI-Prolog-Editor Consultieren
Mit consult(<Datei>) werden aus der angegebenen Datei die Fakten und Regeln in die Wissensbasis eingelesen.

25 Übungen Aufgabe 1: Familie
Entwickeln Sie eine Wissensbasis zu einer Familien-Welt. Folgende Prädikate können festgelegt werden: maennlich, weiblich, kind, vater, mutter, vorfahr, sohn, tochter, grossvater, grossmutter, enkel, geschwister, bruder, schwester, onkel, tante, ... Testen Sie ihre Wissensbasis mit Hilfe geeigneter Anfragen.

26 Übungen Aufgabe 2: Wir betrachten die unten abgebildete Blockwelt. Wie könnte man die Strukrur dieser Blockwelt mit Hilfe von Fakten und Regeln beschreiben? d g c f a e b p1 p2 p3

27 Das Berechnungskonzept
Teil 2 Das Berechnungskonzept

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

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

30 Auswertung von Anfragen
/*1*/ maennlich(zeus) /*2*/ weiblich(hera) /*3*/ weiblich(maia). /*4*/ kind(apollo, zeus) /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 Substitution X = V, Y = hermes. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). Unifikation: Suche einen Fakt / Regelkopf, der mit dem ersten Term des Ziels unifiziert (d. h. durch eine Substitution gleichgemacht werden kann). Resolution (bei Regel): Ersetze den ersten Term des Ziels durch den Regelrumpf und wende auf alle Terme des Ziels die Substitution an.

31 Auswertung von Anfragen
/*1*/ maennlich(zeus) /*2*/ weiblich(hera) /*3*/ weiblich(maia). /*4*/ kind(apollo, zeus) /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 Substitution X = V, Y = hermes. V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). Unifikation: Suche einen Fakt / Regelkopf, der mit dem ersten Term des Ziels unifiziert (d. h. durch eine Substitution gleichgemacht werden kann). Resolution (bei Regel): Ersetze den ersten Term des Ziels durch den Regelrumpf und wende auf alle Terme des Ziels die Substitution an.

32 Auswertung von Anfragen
/*1*/ maennlich(zeus) /*2*/ weiblich(hera) /*3*/ weiblich(maia). /*4*/ kind(apollo, zeus) /*5*/ kind(hermes, maia). /*6*/ kind(hermes, zeus). /*7*/ vater(X, Y) :- kind(Y, X), maennlich(X). Regel 7 5 No Substitution V = maia. Ziel ?- vater(V, hermes). ?- kind(hermes, V), maennlich(V). ?- maennlich(maia). Backtracking: Wenn der erste Term des Ziels mit keinem Fakt / Regelkopf unifiziert, dann geh zurück zu dem Ziel, bei dem als letztes eine Auswahlmöglichkeit bestand und treffe eine neue Auswahl.

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

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

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

36 Trace einer Beweissuche
vater(V, hermes) kind(hermes, V) maennlich(V) kind(hermes, maia) kind(hermes, zeus) maennlich(zeus) UND-Knoten ODER-Knoten ?- vater(V, hermes). CALL: vater(V, hermes) CALL: kind(hermes, V) CALL: kind(hermes, maia) EXIT: kind(hermes, maia) CALL: maennlich(maia) FAIL: maennlich(maia) CALL: Teilziel aufrufen EXIT: Zeilziel erfolgr. b. REDO: Teilziel nochmal b. FAIL: Teilziel erfolglos b. REDO: kind(hermes, V) CALL: kind(hermes, zeus) EXIT: kind(hermes, zeus) CALL: maennlich(zeus) EXIT: maennlich(zeus) EXIT: vater(V, hermes) V = zeus.

37 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 (führt Resolution durch) Suchalgorithmus (benutzt Backtracking)

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

39 Deklarative Semantik Logisches Programm (Wissensbasis + Anfrage)
maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(V, hermes). Deklarative Semantik eines Logik-Programms Menge der Instanzen der Anfrageklausel, die zur Modellwelt gehören bzw. die aus der Wissensbasis mit Hilfe der Schlussregel „modus ponens“ hergeleitet werden können.

40 Prozedurale Semantik Logisches Programm (Wissensbasis + Anfrage)
maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) :- kind(Y, X), maennlich(X). ?- vater(V, hermes). Prozedurale Semantik des Programms Menge der Instanzen der Anfrageklausel, die die Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt.

41 Übungen Aufgabe 3: Berechnungskonzept
Wir betrachten das folgende Logik-Programm zur Blockwelt: auf(a, p1). auf(c, a). auf(e, p2). auf(b, p3). auf(f, b). auf(g, f). auf(d, g). ueber(X, Y) :- auf(X, Y). ueber(X, Y) :- auf(X, Z), ueber(Z, Y). d g c f a e b p1 p2 p3 ?- ueber(X, g). Schalten Sie den Trace-Modus ein und verfolgen Sie die Erzeugung der Berechnungsergebnisse. Erstellen Sie auch einen Beweisbaum.

42 Übungen Aufgabe 4: Berechnungskonzept
Wir betrachten die beiden folgenden Logik-Programme: Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). Welche Berechnungsergebnisse erwarten Sie? Bestimmen Sie die Ergebnisse mit Hilfe von PROLOG. Verfolgen Sie die Berechnung der Ergebnisse mit Hilfe einer Trace. Wie lässt sich das Verhalten von PROLOG erklären?

43 Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage)
Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(maia, hermes). Die Modellierungen sind logisch äquivalent – die Logik-Programme haben dieselbe deklarative Semantik.

44 Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage)
Wissensbasis - Version 1: /*1*/ kind(hermes, maia). /*2*/ vorfahr(X, Y) :- kind(Y, X). /*3*/ vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Regel 2 1 Substitution X = A, Y = B B = hermes, A = maia. Ziel ?- vorfahr(A, B). ?- kind(B, A).

45 Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage)
Wissensbasis - Version 2: /*1*/ kind(hermes, maia). /*2*/ vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). /*3*/ vorfahr(X, Y) :- kind(Y, X). Regel 2 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), kind... ... Die Inferenzmaschine liefert unterschiedliche Berechnungsergebnisse – die Logik-Programme haben eine unterschiedliche prozedurale Semantik.

46 Grenzen der Logik Logisches Programm (Wissensbasis + Anfrage)
Wissensbasis - Version 1: kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Wissensbasis - Version 2: kind(hermes, maia). vorfahr(X, Y) :- vorfahr(X, Z), kind(Y, Z). vorfahr(X, Y) :- kind(Y, X). ?- vorfahr(A, B). Beachte: Die prozedurale Semantik wird durch die Algorithmen der Inferenzmaschine festgelegt. Die Reihenfolge der Programmklauseln und Zielklauseln können hierbei eine entscheidende Rolle spielen.

47 Deklarative Programmierung
Beschreiben, was in der Modellwelt gelten soll Anfrage ?- vorfahr(A, B). kind(hermes, maia). vorfahr(X, Y) :- kind(Y, X). vorfahr(X, Y) :- kind(Y, Z), vorfahr(X, Z). Inferenz-maschine Wissensbasis Ergebnis X = maia, Y = hermes. Deklarative Programmierung besteht darin, den Problemkontext (Miniwelt) mit gegebenen Mitteln (hier: Fakten und Regeln) zu beschreiben.

48 Imperative Programmierung
Beschreiben, wie die Ergebnisse berechnet werden sollen A.-Zustand {x: 3; y: 5} z := x; x := y; y := z; Register-maschine Anweisungen E.-Zustand {x: 5; y: 3; z: ...} Imperative Programmierung besteht darin, eine (mehr oder weniger abstrakte) Maschine mit Hilfe von Anweisungen zu steuern.

49 Anwendung: Datenbanken
Teil 3 Anwendung: Datenbanken

50 Eine einfache Bibliothekswelt

51 ER-Modellierung Leser Ausleihe Buch LNr Name ... Datum Sig Autor ...
LNr: 3 Name: Müller Vorname: Peter ... Sig: Rel1 Autor: Titel: Bibel ... LNr: 6 Name: Schmitt Vorname: Otto ... Sig: M1 Autor: Euklid Titel: Elemente ... LNr: 1 Name: Meier Vorname: Karla ... Sig: P1 Autor: Einstein Titel: Relativität ... Leser Ausleihe Buch LNr Name ... Datum Sig Autor ...

52 Relationales Datenmodell
Leser Buch Ausleihe

53 Beschreibung mit Fakten
% Leser ... leser(15, 'Wollenweber', 'Lisa', 84, tm). % Bücher buch('ph1', 'Garder', 'Sofies Welt', 1995, 'Philosophie'). % Ausleihen ausleihe(15, 'm3', datum(12,10,2001)).

54 Eine Anfrage % Welche Leser haben ein Buch ausgeliehen?
?- ausleihe(Nr, Sig, _Datum), leser(Nr, Name, Vorname, _GebJahr, _StK). Nr = 3 Sig = 'Ph1' Name = 'Frisch' Vorname = 'Johannes' ; Nr = 4 Sig = 'D2' Name = 'Frölich' Vorname = 'Daniel' ; Sig = 'P2' ...

55 Übungen Aufgabe 5: Bibliothek
Laden Sie die Fakten zur Beschreibung der Bibliothekswelt. Erstellen Sie zu den folgenden Aufgaben entsprechende Abfragen. - Welche Leser gibt es? - Welche Leser sind 84 geboren? - Welche Leser sind vor 84 geboren? - Welche Bücher von Goethe sind in der Bibliothek vorhanden? - Welche Bücher sind ausgeliehen? - Welche Bücher hat die Leserin Lisa Wollenweber ausgeliehen? - Welche Leser haben ein Buch ausgeliehen? ...

56 Eine Regel für Mahnungen
Ein Leser soll eine Mahnung erhalten, wenn er/sie ein Buch länger als einen Monat ausgeliehen hat. % Leser mahnung(Name, Vorname, Sig, datum(Takt, Makt, Jakt)) :- leser(LNr, Name, Vorname, _, _), ausleihe(LNr, Sig, datum(Taus, Maus, Jaus)), monatspaeter(datum(Taus, Maus, Jaus), datum(Takt, Makt, Jakt)).

57 Eine Regel für Mahnungen
Spezifikation: monatspaeter(datum(Taus, Maus, Jaus), datum(Takt, Makt, Jakt)) soll gelten, wenn das Datum „Takt.Makt.Jakt“ mehr als ein Monat später als das Datum „Taus.Maus.Jaus“ ist. Beispiele: monatspaeter(datum(11, 7, 2001), datum(20, 9, 2001)) monatspaeter(datum(17, 4, 2001), datum(1, 1, 2002)) ...

58 Eine Regel für Mahnungen
monatspaeter(datum(T1,M1,J1), datum(T2,M2,J2)) :- T2 >= T1, M2 >= M1+1, J2 >= J1. M2 >= M1+2, J2 >= J1. T2 >= T1, J2 >= J1+1. (12-M1)+M2 >= 2, J2 >= J1+1. J2 >= J1+2.

59 Ausleihen und Zurückgeben
Bücher können ausgeliehen und zurückgegeben werden. % Ausleihen ausleihe(3,'Ph1',datum(30,12,2001)). ausleihe(4,'D2',datum(16,9,2001)). ausleihe(4,'P2',datum(30,12,2001)). ausleihe(6,'D3',datum(30,12,2001)). ausleihe(8,'M1',datum(23,10,2001)). ausleihe(11,'P1',datum(14,12,2001)). % löschen ausleihe(12,'M2',datum(30,12,2001)). ausleihe(13,'D5',datum(30,8,2001)). ausleihe(13,'Ph2',datum(11,7,2001)). ausleihe(14,'D1',datum(13,12,2001)). ausleihe(15,'M3',datum(1,11,2001)). ausleihe(2,'P1',datum(10,1,2002)). % einfügen

60 Veränderung der Wissensbasis
% Ausleihen :- dynamic ausleihe/3. % Achtung ausleihe(3,'Ph1',datum(30,12,2001)). ausleihe(4,'D2',datum(16,9,2001)). ausleihe(4,'P2',datum(30,12,2001)). ausleihe(6,'D3',datum(30,12,2001)). ausleihe(8,'M1',datum(23,10,2001)). ausleihe(11,'P1',datum(14,12,2001)). ausleihe(12,'M2',datum(30,12,2001)). ausleihe(13,'D5',datum(30,8,2001)). ausleihe(13,'Ph2',datum(11,7,2001)). ausleihe(14,'D1',datum(13,12,2001)). ausleihe(15,'M3',datum(1,11,2001)). Beachte: Damit die Prädikate verändert werden können, müssen sie als dynamisch deklariert werden.

61 Veränderung der Wissensbasis
Prädikate zur Manipulation der Wissensbasis: asserta(+Klausel) fügt die Klausel vor den bereits bestehenden Klauseln ein assertz(+Klausel) fügt die Klausel hinter die bereits bestehenden Klauseln ein retract(+Klausel) löscht die Klausel

62 Veränderung der Wissensbasis
% zurueckgeben zurueckgeben(Sig) :- retract(ausleihe(LNr, Sig, datum(T,M,J))). % ausleihen ausleihen(LNr, Sig, Tag, Monat, Jahr) :- assertz(ausleihe(LNr, Sig, datum(Tag,Monat,Jahr)))

63 Laden und Speichern Prädikate zur Verwaltung der Wissensbasis:
consult(+Dateiname) liest die Fakten und Regeln der Datei ein und ergänzt die aktuelle Wissensbasis listing listet alle Klauseln auf listing(+Prädikat) listet alle Fakten zum betreffenden Prädikat auf tell(+Dateiname) legt das Ausgabemedium fest told schließt das aktuelle Ausgabemedium

64 Laden und Speichern % Bibliotheksdaten laden
:- consult('BibliothekDaten.pl'). % Bibliotheksdaten speichern speichern :- tell('BibliothekDaten.pl'), listing(leser), listing(buch), listing(ausleihe), told.

65 Teil 4 Listenverarbeitung

66 email-Adressbuch Petra Schmitt pm@aol.com
Walter Meier Sandra Roth ...

67 Beschreibung der Miniwelt
-Adressbuch Miniwelt: Adressbuch Petra Schmitt Walter Meier Sandra Roth ... Beschreibung der Miniwelt (petraSchmitt, [ ] ). (walterMeier, [ ] ). (sandraRoth, [ ] ). ... % add (...). % del (...).

68 Listen Eine Liste ist eine geordnete Folge von Elementen beliebiger Länge. Die Elemente der Liste können beliebige Terme sein: Konstanten, Zahlen, Variablen, Strukturen und auch wieder Listen. Die Listenelemente können dabei unterschiedliche Datentypen aufweisen. Beispiele: [ ] ...

69 Listenkonstruktoren Alle Listen können mit Hilfe der beiden Konstruktoren [] („leere Liste“) und . („Einfügoperator“) aufgebaut werden. Beispiel: . (a, . (b, . (c, [])))  [a, b, c] . (c, [])  [c] . (b, [c])  [b, c] . (a, [b, c])  [a, b, c] Struktur: .(Element, Liste)  NeueListe

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

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

72 Hinzufügen Spezifikation: add1/3
Semantik: add1(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe = [E | AlteListe]. Beispiel: add1(a, [b, c, d], [a, b, c, d]) Programm (Version1: mit Regel): add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe]. Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]).

73 Hinzufügen Programm (Version1: mit Regel):
add1(E, AlteListe, NeueListe) :- NeueListe = [E | AlteListe]. Programmtest: ?- add1(a, [b, c, d], L). L = [a, b, c, d] ; No ?- add1(b, [b, c, d], L). L = [b, b, c, d] ; ?- add1(c, [b, c, d], L). L = [c, b, c, d] ; Programm (Version2: mit Faktum): add1(E, AlteListe, [E | AlteListe]).

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

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

76 Rekursive Problemreduktion
% Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht: add2(E, [A|X], L) :- ??? Rekursives Problemreduktion: E eingefügt in [A|X] ergibt [A|M], wenn E \= A und wenn E eingefügt in X die Liste M ergibt. % 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).

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

78 Deklaratives Denken Wissensbasis (mit rekursiver Problemreduktion):
/* 1 */ add2(E, [], [E]). /* 2 */ add2(E, [E|X], [E|X]). /* 3 */ add2(E, [A|X], [A|M]) :- E \= A, add2(E, X, M). Anfrage: ?- add(a, [b, c], L). Muss vom Entwickler geleistet werden Wird von der Inferenzmaschine geleistet Regel 3 1 Substitution E0 = a, A0 = b, X0 = [c], L = [A0|M0]. E1 = a, A1 = c, X1 = [], M0 = [A1|M1] E2 = a, M1 = [E2] Ziel ?- add2(a, [b, c], L). ?- add2(a, [c], M0). ?- add2(a, [], M1). Man beschreibt nicht Schritt für Schritt einen Einfügevorgang, sondern man beschreibt das Ergebnis eines Einfügevorgangs.

79 Löschen Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe ein Element aus einer Liste gelöscht werden kann. Spezifikation: del/3 Semantik: del(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn entweder AlteListe E nicht enthält und dann NeueListe = AlteListe gilt, oder wenn AlteListe E enthält und NeueListe aus AlteListe durch Entfernen von E entsteht.

80 Übungen Aufgabe 6: Listenverarbeitung
Entwerfen Sie zunächst eine Fallunterscheidung gemäß der Struktur der Liste, aus der das Element gelöscht werden soll. Entwickeln Sie dann passende Fakten und Regeln zur Beschreibung des Ergebnisses eines Löschvorgangs.

81 Übungen Aufgabe 7: Listenverarbeitung
Ergänzen Sie die Fakten bzw. Regeln. Lösen Sie Fall 3 mit Hilfe einer rekursiven Problemreduktion % 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,

82 Lösung Wissensbasis (mit rekursiver Problemreduktion): del(E, [], []).
del(E, [E|X], X). del(E, [A|X], [A|M]) :- E \= A, del(E, X, M).

83 Sortieren Aufgabe: Es soll ein Prolog-Programm entwickelt werden, mit dessen Hilfe eine Liste (bestehend aus Konstanten) sortiert werden kann. Spezifikation: inssort/2 Semantik: inssort(AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe aus AlteListe durch Sortieren der Elemente entsteht.

84 Vorbereitung Bearbeitung von Atomen:
name(?Atom, ?ASCIIListe) wandelt ein Atom in eine Liste von ASCII-Codes um und umgekehrt Test: ?- name(hallo, L). L = [104, 97, 108, 108, 111] ; No ?- name(N, [104, 97, 108, 108, 111]). N = hallo ;

85 Übungen Aufgabe 8: Listenvergleich
Entwickeln Sie die Fakten bzw. Regeln, mit denen man zwei Listen mit ASCII-Codes (Zahlen) vergleichen kann. Überlegen Sie sich hierzu, in welchen Fällen eine Liste „kleiner“ ist als eine andere. % ASCII-Listen vergleichen kleiner([], L) :- kleiner([K|R], [K1|R1]) :- kleiner([K|R], [K1|R1]) :- % Atome vergleichen vor(A, B) :- name(A, LA), name(B, LB), kleiner(LA, LB).

86 Übungen Aufgabe 9: Einfügen in eine sortierte Liste
ins(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe aus einer sortierten Liste AlteListe entsteht, indem das Element E an der „richtigen“ Stelle einsortiert wird.

87 Lösung Aufgabe 8: Listenvergleich
Entwickeln Sie die Fakten bzw. Regeln, mit denen man zwei Listen mit ASCII-Codes (Zahlen) vergleichen kann. Überlegen Sie sich hierzu, in welchen Fällen eine Liste „kleiner“ ist als eine andere. % ASCII-Listen vergleichen kleiner([], L) :- L \= []. kleiner([K|R], [K1|R1]) :- K < K1. kleiner([K|R], [K1|R1]) :- K = K1, kleiner(R, R1). % Atome vergleichen vor(A, B) :- name(A, LA), name(B, LB), kleiner(LA, LB).

88 Lösung Aufgabe 9: Einfügen in eine sortierte Liste
ins(E, AlteListe, NeueListe) gilt in der Modellwelt, wenn NeueListe aus einer sortierten Liste AlteListe entsteht, indem das Element E an der „richtigen“ Stelle einsortiert wird. % Einfügen ins(E, [], [E]). ins(E, [E|R], [E | [E |R]]). ins(E, [K|R], [E | [K |R]]) :- vor(E, K). ins(E, [K|R], [K|M]) :- vor(K, E), ins(E, R, M).

89 Übungen Aufgabe 10: Sortieren durch Einfügen
Erklären Sie die aufgelisteten Fakten und Regeln. Erklären Sie insbesondere auch die rekursive Problemreduktion. % Sortieren durch Einfügen inssort([], []). inssort([K|R], L) :- inssort(R, M), ins(K, M, L). %Test ?- inssort([kain, abel, eva, adam], L). L = [abel, adam, eva, kain] ; No

90 Sortierprogramm % ASCII-Listen vergleichen kleiner([], L) :- L \= []. kleiner([K|R], [K1|R1]) :- K < K1. kleiner([K|R], [K1|R1]) :- K = K1, kleiner(R, R1). % Atome vergleichen vor(A, B) :- name(A, LA), name(B, LB), kleiner(LA, LB). % Einfügen ins(E, [], [E]). ins(E, [E|R], [E | [E |R]]). ins(E, [K|R], [E | [K |R]]) :- vor(E, K). ins(E, [K|R], [K|M]) :- vor(K, E), ins(E, R, M). % Sortieren durch Einfügen inssort([], []). inssort([K|R], L) :- inssort(R, M), ins(K, M, L).

91 Anwendung: Formale Sprachen
Teil 4 Anwendung: Formale Sprachen

92 Wortproblem Parser aabbcc S  aSBC S  aBC CB  BC aB  ab bB  bb
bC  bc cC  cc Parser yes

93 Worterzeugung aabbcc S  aSBC S  aBC CB  BC aB  ab bB  bb bC  bc
cC  cc S  aSBC  aaBCBC  aaBBCC  aabBCC  aabbCC  aabbcC  aabbcc yes

94 Repräsentation der Grammatik
S  aSBC S  aBC CB  BC aB  ab bB  bb bC  bc cC  cc startsymbol([vS]). produktion([vS], [a,vS,vB,vC]). produktion([vS], [a,vB,vC]). produktion([vC,vB], [vB,vC]). produktion([a,vB], [a,b]). produktion([b,vB], [b,b]). produktion([b,vC], [b,c]). produktion([c,vC], [c,c]).

95 Ableitungsschritt Spezifikation: ableitungsschritt/2
S  aSBC  aaB(CB)C  aaB(BC)C  aabBCC  aabbCC  aabbcC  aabbcc CB  BC Spezifikation: ableitungsschritt/2 ableitungsschritt(AltesWort, NeuesWort) gilt in der Modellwelt, wenn NeuesWort aus AltesWort entsteht, indem ein Teilwort mit Hilfe einer Produktion ersetzt wird. Z. B.: ableitungsschritt([a,a,vB,vC,vB,vC], [a,a,vB,vB,vC,vC])

96 Ableitungsschritt S  aSBC  aaB(CB)C  aaB(BC)C  aabBCC  aabbCC  aabbcC  aabbcc CB  BC ableitungsschritt(AltesWort, NeuesWort) :- produktion(L,R), append(L,RestWort,AltesWort), append(R,RestWort,NeuesWort). ableitungsschritt([B|AltesWort], [B|NeuesWort]) :- ableitungsschritt(AltesWort, NeuesWort).

97 Ableitungskette Spezifikation: ableitungskette/2
S  aSBC  aaBCBC  aaBBCC  aabBCC  aabbCC  aabbcC  aabbcc Spezifikation: ableitungskette/2 ableitungskette(NeuesWort, AltesWort) gilt in der Modellwelt, wenn NeuesWort sich aus AltesWort mit Hilfe von Ableitungsschritten erzeugen lässt. Z. B.: ableitungskette([a,a,b,b,c,c], [vS])

98 Suche im Ableitungsbaum
aabbcc aaBbcc aabBcc aabbCc aabbcC aaBbcc ... ... aabbCC aaBbCc aabBCC aaBBCC aaBCBC aSBC S

99 Ableitungskette S  aSBC  aaBCBC  aaBBCC  aabBCC  aabbCC  aabbcC  aabbcc ableitungskette(NeuesWort, AltesWort) :- NeuesWort = AltesWort. ableitungskette(NeuesWort, AltesWort) :- ableitungsschritt(ZwischenWort, NeuesWort), ableitungskette(ZwischenWort, AltesWort).

100 Ableitung ableitung(Wort) :- ableitungskette(Wort, S), startsymbol(S).
S  aSBC  aaBCBC  aaBBCC  aabBCC  aabbCC  aabbcC  aabbcc ableitung(Wort) :- ableitungskette(Wort, S), startsymbol(S).

101 Ausgabe der Ableitungskette
ableitungsschritt(AltesWort, L, R, NeuesWort) :- produktion(L,R), append(L,B,AltesWort), append(R,B,NeuesWort). ableitungsschritt([E|AltesWort], L, R, [E|NeuesWort]) :- ableitungsschritt(AltesWort, L, R, NeuesWort). ableitungskette(NeuesWort, AltesWort,[]) :- AltesWort = NeuesWort. ableitungskette(NeuesWort, AltesWort, [regel(L,R), ZwischenWort |A]) :- ableitungsschritt(ZwischenWort, L, R, NeuesWort), ableitungskette(ZwischenWort, AltesWort, A. ableitung(Wort) :- ableitungskette(Wort, S, A), startsymbol(S), write(A).

102 Ausgabe der Ableitungskette
?- ableitung([a, a,b, b, c, c]). [ regel([c, vC], [c, c]), [a, a, b, b, c, vC], regel([b, vC], [b, c]), [a, a, b, b, vC, vC], regel([b, vB], [b, b]), [a, a, b, vB, vC, vC], regel([a, vB], [a, b]), [a, a, vB, vB, vC, vC], regel([vC, vB], [vB, vC]), [a, a, vB, vC, vB, vC], regel([vS], [a, vB, vC]), [a, vS, vB, vC], regel([vS], [a, vS, vB, vC]), [vS] ] Yes

103 Ausgabe aller Ableitungsversuche
ableitungsschritt(AltesWort, L, R, NeuesWort) :- produktion(L,R), append(L,B,AltesWort), append(R,B,NeuesWort). ableitungsschritt([E|AltesWort], L, R, [E|NeuesWort]) :- ableitungsschritt(AltesWort, L, R, NeuesWort). ableitungskette(NeuesWort, AltesWort,[]) :- AltesWort = NeuesWort. ableitungskette(NeuesWort, AltesWort, [regel(L,R), ZwischenWort |A]) :- ableitungsschritt(ZwischenWort, L, R, NeuesWort), ableitungskette(ZwischenWort, AltesWort, A, write([regel(L,R), ZwischenWort |A]), nl. ableitung(Wort) :- ableitungskette(Wort, S, _), startsymbol(S).

104

105 Anwendung: While-Interpreter
Teil 5 Anwendung: While-Interpreter

106 While-Interpreter Interpreter {b: 2; u: 5}
BEGIN p := 1; WHILE u > 0 DO BEGIN IF u mod 2 = 1 THEN BEGIN u := u – 1; p := p * b; END; u := u div 2; b := b* b; END END Interpreter {b: 256; u: 0; p: 32}

107 While-Programme Wiederholung Fallunterscheidung Sequenzbildung
BEGIN p := 1; WHILE u > 0 DO BEGIN IF u mod 2 = 1 THEN BEGIN u := u – 1; p := p * b; END; u := u div 2; b := b* b; END END Wiederholung Fallunterscheidung Sequenzbildung Wertzuweisung

108 Interpreter-Prädikat
Ausgangs-zustand {b: 2; u: 5} BEGIN p := 1; WHILE u > 0 DO BEGIN IF u mod 2 = 1 THEN BEGIN u := u – 1; p := p * b; END; u := u div 2; b := b* b; END END While-Programm Interpreter End- zustand {b: 256; u: 0; p: 32} ausfuehren(+Programm, +Ausgangszustand, -Endzustand)

109 Problemvereinfachung
Ausgangs-zustand {x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Wir betrachten zunächst nur sehr einfache Programme: Sequenzen von Zuweisungen vom Typ <Var> := <Var>.

110 Variablenzustände Interpreter Ausgangs-zustand Zuweisungs-programm
{x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Repräsentation von Variablenzuständen: [wert(x, 2), wert(y, 5)] % Ausgangszustand [wert(x, 5), wert(y, 2), wert(z, 5)] % Endzustand Liste mit Termen

111 Variablenzustände Interpreter Ausgangs-zustand Zuweisungs-programm
{x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Spezifikation der Prädikate varWert(+Variable, +Zustand, -Variablenwert) ?- varWert(y, [wert(x, 2), wert(y, 5)], W). W = 5

112 Variablenzustände Interpreter Ausgangs-zustand Zuweisungs-programm
{x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Spezifikation der Prädikate neuerZustand(+Variable, +Wert, +ZAlt, -ZNeu) ?- neuerZustand(y, 4, [wert(x, 2), wert(y, 5)], Z). Z = [wert(x, 2), wert(y, 4)]

113 Variablenzustände Interpreter Ausgangs-zustand Zuweisungs-programm
{x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Spezifikation der Prädikate neuerZustand(+Variable, +Wert, +ZAlt, -ZNeu) ?- neuerZustand(z, 2, [wert(x, 2), wert(y, 5)], Z). Z = [wert(x, 2), wert(y, 5), wert(z, 2)]

114 Variablenzustände Problemreduktionen: varWert(u, [], 'undefiniert').
varWert(x, [wert(x, W) | _R], W). varWert(y, [wert(x, 2) | R], W) :- varWert(x, R, W). Fakten und Regeln: varWert(_, [], 'undefiniert'). varWert(V, [wert(V, W) | _R], W). varWert(V, [wert(X, _W) | R], W) :- V \= X, varWert(V, R, W).

115 Variablenzustände Problemreduktionen:
neuerZustand(z, 2, [], [wert(z, 2)]). neuerZustand(y, 4, [wert(y, 5) | R], [wert(y, 4) | R]). neuerZustand(y, 4, [wert(x, 2) | R], [wert(x, 2) | RNeu]) :- neuerZustand(y, 4, R, RNeu). Fakten und Regeln: neuerZustand(V, W, [], [wert(V, W)]). neuerZustand(V, W, [wert(V, _) | R], [wert(V, W) | R]). neuerZustand(V, W, [wert(X, WAlt) | R], [wert(X, WAlt) | RNeu]) :- V \= X, neuerZustand(V, W, R, RNeu).

116 Zuweisungsinterpreter
Ausgangs-zustand {x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Repräsentation von primitiven Zuweisungsprogrammen: [let(z, x), let(x, y), let(y, z)] % Zuweisungssequenz Liste mit Termen

117 Zuweisungsinterpreter
Ausgangs-zustand {x: 2; y: 5} BEGIN z := x; x := y; y := z END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2; z: 5} Spezifikation der Prädikate ausfuehren(+Programm, +ZAlt, -ZNeu) ?- ausfuehren([let(z,x), let(x,y), let(y,z)], [wert(x,2), wert(y,5)], Z). Z = [wert(x,5), wert(y,2), wert(z,2)]

118 Zuweisungsinterpreter
Fakten und Regeln: % Zuweisung ausführen ausfuehren(let(X, Y), ZAlt, ZNeu) :- varWert(Y, ZAlt, W), neuerZustand(X, W, ZAlt, ZNeu). % Sequenz ausführen ausfuehren([], ZAlt, ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) :- ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu).

119 Zuweisungsinterpreter
Testprogramm: testprogramm1 :- ausfuehren([let(z, x), let(x, y), let(y, z)], [wert(x,2), wert(y,5)], Z), write(Z). Programmtest: ?- testprogramm1. [wert(x, 5), wert(y, 2), wert(z, 2)]

120 Terminterpreter Interpreter Ausgangs-zustand Zuweisungs-programm
{x: 2; y: 5} BEGIN x := x-y; y := x+y; x := y-x END Zuweisungs-programm Interpreter End- zustand {x: 5; y: 2} Spezifikation der Prädikate termWert(+Term, +Zustand, -Wert) ?- termWert(x-y, [wert(x, 2), wert(y, 5)], W). W = -3

121 Terminterpreter Fakten und Regeln: termWert(V, _Z, V) :- integer(V).
termWert(V, Z, W) :- atom(V), varWert(V, Z, W). termWert(T1 + T2, Z, W) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W is W1+W2. ... termWert(-T, Z, W) :- termWert(T, Z, W1), W is -W1.

122 Terminterpreter Fakten und Regeln: % Zuweisung ausführen
ausfuehren(let(X, T), ZAlt, ZNeu) :- termWert(T, ZAlt, W), neuerZustand(X, W, ZAlt, ZNeu). % Sequenz ausführen ausfuehren([], ZAlt, ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) :- ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu).

123 Terminterpreter Testprogramm:
testprogramm2 :- ausfuehren([let(x, x-y), let(y, x+y), let(x, y-x)], [wert(x,2), wert(y,5)], Z), write(Z). Programmtest: ?- testprogramm2. [wert(x, 5), wert(y, 2)]

124 Anweisungsinterpreter
Ausgangs-zustand {x: 2; y: 5} IF x > y THEN betrag := x – y ELSE betrag := y – x Programm Interpreter End- zustand {x: 5; y: 2; betrag: 3} Spezifikation der Prädikate ausfuehren(+Programm, +ZAlt, -ZNeu) ?- ausfuehren( if(x > y, let(betrag, x-y), let(betrag, y-x)), [wert(x,2), wert(y,5)], Z ). Z = [wert(x, 2), wert(y, 5), wert(betrag, 3)]

125 Anweisungsinterpreter
Ausgangs-zustand {b: 2; n: 3, p: 1} WHILE n > 0 DO BEGIN p := p*b; n := n-1 END Programm Interpreter End- zustand {b: 2; n: 3, p: 8} Spezifikation der Prädikate ausfuehren(+Programm, +ZAlt, -ZNeu) ?- ausfuehren( while(n > 0, [let(p, p*b), let(n, n-1)]), [wert(b,2), wert(n,3), wert(p,1)], Z ). Z = [wert(b, 2), wert(n, 0), wert(p, 8)]

126 Anweisungsinterpreter
Ausgangs-zustand {x: 2; y: 5} IF x > y THEN betrag := x – y ELSE betrag := y – x Programm Interpreter End- zustand {x: 5; y: 2; betrag: 3} Spezifikation der Prädikate booleWert(+Term, +Zustand) ?- booleWert(x > y, [wert(x, 2), wert(y, 5)]). No

127 Anweisungsinterpreter
booleWert(T1 = T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 =:= W2. booleWert(T1 =\= T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 =\= W2. booleWert(T1 < T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 < W2. booleWert(T1 > T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 > W2. booleWert(T1 =< T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 =< W2. booleWert(T1 >= T2, Z) :- termWert(T1, Z, W1), termWert(T2, Z, W2), W1 >= W2.

128 Anweisungsinterpreter
ausfuehren(let(X, T), ZAlt, ZNeu) :- termWert(T, ZAlt, W), neuerZustand(X, W, ZAlt, ZNeu). ausfuehren([], ZAlt, ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) :- ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu). ausfuehren(if(Bed, Anw1, _Anw2), ZAlt, ZNeu) :- booleWert(Bed, ZAlt), ausfuehren(Anw1, ZAlt, ZNeu). ausfuehren(if(Bed, _Anw1, Anw2), ZAlt, ZNeu) :- not(booleWert(Bed, ZAlt)), ausfuehren(Anw2, ZAlt, ZNeu). ausfuehren(while(Bed, Anw), ZAlt, ZNeu) :- booleWert(Bed, ZAlt), ausfuehren(Anw, ZAlt, Z), ausfuehren(while(Bed, Anw), Z, ZNeu). ausfuehren(while(Bed, _Anw), ZAlt, ZAlt) :- not(booleWert(Bed, ZAlt)).

129 Anweisungsinterpreter
Testprogramm: testprogramm5 :- ausfuehren( [let(p,1), while(u > 0, [if(u:2 = 1, [let(u, u-1), % siehe oben [wert(b,2), wert(u,5)], Z), write(Z). Programmtest: ?- testprogramm5. [wert(b, 256), wert(u, 0), wert(p, 32)]

130 Literaturhinweise Uwe Schöning: Logik für Informatiker. BI-Wissenschaftsverlag 1987. Gerhard Röhner: Informatik mit Prolog. Hessisches Landesinstitut für Pädagogik (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. Herbert Drumm u. Hermann Stimm: Wissensverarbeitung mit PROLOG – Ein Einstieg in die Algorithmik. Handreichung zum Lehrplan Informatik 1995.