Programmieren mit Prdikatenlogik Klaus Becker 2004 2 Programmieren

Programmieren mit Prädikatenlogik Klaus Becker 2004

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

Logische Programmierung 3 KB Teil 1 Fakten und Regeln

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

5 Modellierungsansatz Logische Programmierung 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 KB

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

Modellierungsansatz 7 Logische Programmierung 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 KB Miniwelt

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

Regeln 9 Logische Programmierung 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. KB

10 Rekursive Regeln Logische Programmierung 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 Z und X Vorfahr von Z ist. KB

Logische Programmierung 11 KB Von der Miniwelt zur Modellwelt Uranus | Rhea | Zeus | Hebe. . . Miniwelt Modellwelt vorfahr(zeus, hebe). vorfahr(rhea, 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). vorfahr(uranus, hebe). . Beschreibung der Miniwelt

Logische Programmierung 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). vorfahr(zeus, hebe). vorfahr(rhea, hebe). KB . . . 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). Modellwelt

Logische Programmierung 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(X) : - mensch(X). mensch(sokrates). KB sterblich(sokrates).

14 Modellierungskonzept Logische Programmierung Das gesamte Wissen über die Welt wird mit Fakten und Regeln modelliert. KB 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-worldassumption).

Anfragen Logische Programmierung 15 KB maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) : - kind(Y, X), maennlich(X). ? - maennlich(zeus). Yes. % Ist Zeus männlich? ? - maennlich(hera). No. % Ist Hera männlich? Ja-Nein-Anfrage

Anfragen Logische Programmierung 16 KB maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(X, Y) : - kind(Y, X), maennlich(X). ? - vater(W, hermes). W = zeus; No. % Wer ist Vater von Hermes? ? - weiblich(Frau). Frau = hera; Frau = maia; No. % Wer ist weiblich? Ergänzungsanfrage

Logische Programmierung 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 Variablen werden nicht instanziert. KB

Datenflussrichtung Logische Programmierung 18 KB 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?

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

Logik-Programm Logische Programmierung 20 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. KB

Logische Programmierung 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. KB

22 PROLOG Logische Programmierung PROLOG („Programming in Logic“): KB 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).

Logische Programmierung 23 SWI-Prolog-Editor Wissensbasis Anfrage KB

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

Übungen 25 Logische Programmierung Aufgabe 1: Familie KB 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.

Übungen 26 Logische Programmierung Aufgabe 2: KB 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 p 1 p 2 p 3

Logische Programmierung 27 KB Teil 2 Das Berechnungskonzept

Berechnungsproblem 28 Logische Programmierung 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). ? - vater(V, hermes). maennlich(zeus). weiblich(hera). weiblich(maia). kind(apollo, zeus). kind(hermes, maia). kind(hermes, zeus). vater(zeus, apollo). vater(zeus, hermes). . Gesucht: Instanzen der Anfrage, die zur Modellwelt gehören V = zeus. KB Problem: Wie erzeugt man systematisch Anfrageergebnisse?

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

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

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

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

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

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

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

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

Logische Programmierung 37 KB 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)

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

39 Deklarative Semantik Logische Programmierung 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 KB 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 Logische Programmierung 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 Inferenzmaschine mittels Unifikations-, Inferenz- und Suchalgorithmus erzeugt. KB

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

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

Grenzen der Logik 43 Logische Programmierung Logisches Programm (Wissensbasis + Anfrage) KB 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.

Grenzen der Logik 44 Logische Programmierung Logisches Programm (Wissensbasis + Anfrage) KB 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 Substitution 2 X = A, Y = B 1 B = hermes, A = maia. Ziel ? - vorfahr(A, B). ? - kind(B, A).

Grenzen der Logik 45 Logische Programmierung 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 Substitution 2 X = A, Y = B 2 X = A, Y = Z. 2 . . . 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. KB

Grenzen der Logik 46 Logische Programmierung Logisches Programm (Wissensbasis + Anfrage) KB 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.

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

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

Logische Programmierung 49 KB Teil 3 Anwendung: Datenbanken

Logische Programmierung 50 KB Eine einfache Bibliothekswelt

ER-Modellierung 51 Logische Programmierung LNr: 3 Name: Müller Vorname: Peter. . . 8. 1. 2002 LNr: 1 Name: Meier Vorname: Karla. . . LNr Name Rel 1 Bibel Sig: M 1 Autor: Euklid Titel: Elemente. . . LNr: 6 Name: Schmitt Vorname: Otto. . . Sig: P 1 Autor: Einstein Titel: Relativität. . . 16. 2. 2002 Leser KB Sig: Autor: Titel: . . . Ausleihe . . . Datum Buch Sig Autor . . .

52 Relationales Datenmodell Logische Programmierung Leser KB Buch Ausleihe

Logische Programmierung 53 KB Beschreibung mit Fakten % Leser. . . leser(15, 'Wollenweber', 'Lisa', 84, tm). . % Bücher. . . buch('ph 1', 'Garder', 'Sofies Welt', 1995, 'Philosophie'). . % Ausleihen. . . ausleihe(15, 'm 3', datum(12, 10, 2001)). .

Eine Anfrage 54 % Welche Leser haben ein Buch ausgeliehen? Logische Programmierung ? - ausleihe(Nr, Sig, _Datum), leser(Nr, Name, Vorname, _Geb. Jahr, _St. K). KB Nr = 3 Sig = 'Ph 1' Name = 'Frisch' Vorname = 'Johannes' ; Nr = 4 Sig = 'D 2' Name = 'Frölich' Vorname = 'Daniel' ; Nr = 4 Sig = 'P 2' Name = 'Frölich' Vorname = 'Daniel' ; . . .

Übungen 55 Logische Programmierung Aufgabe 5: Bibliothek KB 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 Logische Programmierung Ein Leser soll eine Mahnung erhalten, wenn er/sie ein Buch länger als einen Monat ausgeliehen hat. KB % 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 Logische Programmierung Spezifikation: KB 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 Logische Programmierung monatspaeter(datum(T 1, M 1, J 1), datum(T 2, M 2, J 2)) : T 2 >= T 1, M 2 >= M 1+1, J 2 >= J 1. KB monatspaeter(datum(T 1, M 1, J 1), datum(T 2, M 2, J 2)) : M 2 >= M 1+2, J 2 >= J 1. monatspaeter(datum(T 1, M 1, J 1), datum(T 2, M 2, J 2)) : T 2 >= T 1, J 2 >= J 1+1. monatspaeter(datum(T 1, M 1, J 1), datum(T 2, M 2, J 2)) : (12 -M 1)+M 2 >= 2, J 2 >= J 1+1. monatspaeter(datum(T 1, M 1, J 1), datum(T 2, M 2, J 2)) : J 2 >= J 1+2.

59 Ausleihen und Zurückgeben Logische Programmierung Bücher können ausgeliehen und zurückgegeben werden. KB % Ausleihen ausleihe(3, 'Ph 1', datum(30, 12, 2001)). ausleihe(4, 'D 2', datum(16, 9, 2001)). ausleihe(4, 'P 2', datum(30, 12, 2001)). ausleihe(6, 'D 3', datum(30, 12, 2001)). ausleihe(8, 'M 1', datum(23, 10, 2001)). ausleihe(11, 'P 1', datum(14, 12, 2001)). ausleihe(12, 'M 2', datum(30, 12, 2001)). ausleihe(13, 'D 5', datum(30, 8, 2001)). ausleihe(13, 'Ph 2', datum(11, 7, 2001)). ausleihe(14, 'D 1', datum(13, 12, 2001)). ausleihe(15, 'M 3', datum(1, 11, 2001)). ausleihe(2, 'P 1', datum(10, 1, 2002)). % löschen % einfügen

Logische Programmierung 60 Veränderung der Wissensbasis % Ausleihen : - dynamic ausleihe/3. ausleihe(3, 'Ph 1', datum(30, 12, 2001)). ausleihe(4, 'D 2', datum(16, 9, 2001)). ausleihe(4, 'P 2', datum(30, 12, 2001)). ausleihe(6, 'D 3', datum(30, 12, 2001)). ausleihe(8, 'M 1', datum(23, 10, 2001)). ausleihe(11, 'P 1', datum(14, 12, 2001)). ausleihe(12, 'M 2', datum(30, 12, 2001)). ausleihe(13, 'D 5', datum(30, 8, 2001)). ausleihe(13, 'Ph 2', datum(11, 7, 2001)). ausleihe(14, 'D 1', datum(13, 12, 2001)). ausleihe(15, 'M 3', datum(1, 11, 2001)). % Achtung Beachte: Damit die Prädikate verändert werden können, müssen sie als dynamisch deklariert werden. KB

61 Veränderung der Wissensbasis Logische Programmierung Prädikate zur Manipulation der Wissensbasis: KB 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 Logische Programmierung % zurueckgeben(Sig) : retract(ausleihe(LNr, Sig, datum(T, M, J))). KB % ausleihen(LNr, Sig, Tag, Monat, Jahr) : assertz(ausleihe(LNr, Sig, datum(Tag, Monat, Jahr)))

63 Laden und Speichern Logische Programmierung 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 KB

64 Laden und Speichern Logische Programmierung % Bibliotheksdaten laden : - consult('Bibliothek. Daten. pl'). KB % Bibliotheksdaten speichern : tell('Bibliothek. Daten. pl'), listing(leser), listing(buch), listing(ausleihe), told.

Logische Programmierung 65 KB Teil 4 Listenverarbeitung

email-Adressbuch Logische Programmierung 66 KB Petra Schmitt pm@aol. com Walter Meier meier@t-online. de, walter@gmx. de Sandra Roth sroth@gmx. de, sandra@roth. de, rosa@web. de . . .

Email-Adressbuch 67 Logische Programmierung Miniwelt: Adressbuch Petra Schmitt pm@aol. com Walter Meier meier@t-online. de, walter@gmx. de Sandra Roth sroth@gmx. de, sandra@roth. de, rosa@web. de . . . Beschreibung der Miniwelt email(petra. Schmitt, [ 'pm@aol. com' ] ). email(walter. Meier, [ 'meier@t-online. de', 'walter@gmx. de' ] ). email(sandra. Roth, [ 'sroth@gmx. de', 'sandra@roth', 'rosa@web. de' ] ). . % addemail(. . . ). % delemail(. . . ). KB . . .

Listen Logische Programmierung 68 KB 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: [ 'lisa@gmx. de', 'lisa@wollenweber. de', 'lw@web. de' ]. . .

Listenkonstruktoren 69 Logische Programmierung 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) Neue. Liste KB

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

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

Hinzufügen 72 Logische Programmierung Spezifikation: add 1/3 Semantik: add 1(E, Alte. Liste, Neue. Liste) gilt in der Modellwelt, wenn Neue. Liste = [E | Alte. Liste]. Beispiel: add 1(a, [b, c, d], [a, b, c, d]) Programm (Version 1: mit Regel): add 1(E, Alte. Liste, Neue. Liste) : - Neue. Liste = [E | Alte. Liste]. Programm (Version 2: mit Faktum): add 1(E, Alte. Liste, [E | Alte. Liste]). KB

Logische Programmierung 73 Hinzufügen Programm (Version 1: mit Regel): Programmtest: add 1(E, Alte. Liste, Neue. Liste) : - Neue. Liste = [E | Alte. Liste]. ? - add 1(a, [b, c, d], L). Programm (Version 2: mit Faktum): No add 1(E, Alte. Liste, [E | Alte. Liste]). ? - add 1(b, [b, c, d], L). L = [a, b, c, d] ; L = [b, b, c, d] ; No ? - add 1(c, [b, c, d], L). L = [c, b, c, d] ; No KB

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

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

76 Rekursive Problemreduktion % Einfügen in eine nichtleere Liste, deren erstes Element dem einzufügenden nicht entspricht: Logische Programmierung add 2(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: add 2(E, [A|X], [A|M]) : - E = A, add 2(E, X, M). KB

Auswertung einer Anfrage 77 Logische Programmierung Wissensbasis (mit rekursiver Problemreduktion): /* 1 */ add 2(E, [], [E]). /* 2 */ add 2(E, [E|X]). /* 3 */ add 2(E, [A|X], [A|M]) : - E = A, add 2(E, X, M). Anfrage: ? - add(a, [b, c], L). Regel Substitution 3 E 0 = a, A 0 = b, X 0 = [c], L = [A 0|M 0]. 3 E 1 = a, A 1 = c, X 1 = [], M 0 = [A 1|M 1] 1 E 2 = a, M 1 = [E 2] Ziel ? - add 2(a, [b, c], L). ? - add 2(a, [c], M 0). ? - add 2(a, [], M 1). Ergebnis: KB ? - L = [A 0|M 0] = [b|[A 1|M 1]] = [b|[c|[E 2]]] = [b|[c|[a]]] = [b, c, a]

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

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

80 Übungen Logische Programmierung Aufgabe 6: Listenverarbeitung KB 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 Logische Programmierung Aufgabe 7: Listenverarbeitung KB 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, .

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

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

Vorbereitung 84 Logische Programmierung 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, 111] ; No ? - name(N, [104, 97, 108, 111]). N = hallo ; No KB

85 Übungen Logische Programmierung Aufgabe 8: Listenvergleich KB 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], [K 1|R 1]) : % Atome vergleichen vor(A, B) : - name(A, LA), name(B, LB), kleiner(LA, LB).

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

Lösung 87 Logische Programmierung Aufgabe 8: Listenvergleich KB 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], [K 1|R 1]) : - K < K 1. kleiner([K|R], [K 1|R 1]) : - K = K 1, kleiner(R, R 1). % Atome vergleichen vor(A, B) : - name(A, LA), name(B, LB), kleiner(LA, LB).

88 Lösung Logische Programmierung Aufgabe 9: Einfügen in eine sortierte Liste KB ins(E, Alte. Liste, Neue. Liste) gilt in der Modellwelt, wenn Neue. Liste aus einer sortierten Liste Alte. Liste entsteht, indem das Element E an der „richtigen“ Stelle einsortiert wird. % Einfügen ins(E, [], [E]). ins(E, [E|R], [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).

Übungen 89 Logische Programmierung 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 KB

Logische Programmierung 90 KB Sortierprogramm % ASCII-Listen vergleichen kleiner([], L) : - L = []. kleiner([K|R], [K 1|R 1]) : - K < K 1. kleiner([K|R], [K 1|R 1]) : - K = K 1, kleiner(R, R 1). % Atome vergleichen vor(A, B) : - name(A, LA), name(B, LB), kleiner(LA, LB). % Einfügen ins(E, [], [E]). ins(E, [E|R], [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).

Logische Programmierung 91 KB Teil 4 Anwendung: Formale Sprachen

92 Wortproblem Logische Programmierung aabbcc S a. SBC S a. BC CB BC a. B ab Parser b. B bb b. C bc c. C cc yes KB

93 Worterzeugung Logische Programmierung aabbcc S a. SBC S a. BC CB BC a. B ab b. B bb b. C bc c. C cc S a. SBC aa. BCBC aa. BBCC aabb. CC aabbcc yes KB

94 Repräsentation der Grammatik S a. SBC Logische Programmierung S a. BC KB CB BC a. B ab b. B bb b. C bc c. C cc startsymbol([v. S]). produktion([v. S], [a, v. S, v. B, v. C]). produktion([v. S], [a, v. B, v. C]). produktion([v. C, v. B], [v. B, v. C]). produktion([a, v. B], [a, b]). produktion([b, v. B], [b, b]). produktion([b, v. C], [b, c]). produktion([c, v. C], [c, c]).

Logische Programmierung 95 Ableitungsschritt S a. SBC aa. B(CB)C aa. B(BC)C aab. BCC aabbc. C aabbcc CB BC Spezifikation: ableitungsschritt/2 ableitungsschritt(Altes. Wort, Neues. Wort) gilt in der Modellwelt, wenn Neues. Wort aus Altes. Wort entsteht, indem ein Teilwort mit Hilfe einer Produktion ersetzt wird. Z. B. : ableitungsschritt([a, a, v. B, v. C], [a, a, v. B, v. C]) KB

Logische Programmierung 96 Ableitungsschritt S a. SBC aa. B(CB)C aa. B(BC)C aab. BCC aabbc. C aabbcc CB BC ableitungsschritt(Altes. Wort, Neues. Wort) : produktion(L, R), append(L, Rest. Wort, Altes. Wort), append(R, Rest. Wort, Neues. Wort). ableitungsschritt([B|Altes. Wort], [B|Neues. Wort]) : ableitungsschritt(Altes. Wort, Neues. Wort). KB

Logische Programmierung 97 Ableitungskette S a. SBC aa. BCBC aa. BBCC aabb. CC aabbcc Spezifikation: ableitungskette/2 ableitungskette(Neues. Wort, Altes. Wort) gilt in der Modellwelt, wenn Neues. Wort sich aus Altes. Wort mit Hilfe von Ableitungsschritten erzeugen lässt. Z. B. : ableitungskette([a, a, b, b, c, c], [v. S]) KB

98 Suche im Ableitungsbaum Logische Programmierung aabbcc aa. Bbcc aab. Bcc aabb. Cc aa. Bbcc . . . aa. Bb. Cc aabbc. C aabb. CC aab. BCC aa. BCBC a. SBC KB S

Logische Programmierung 99 Ableitungskette S a. SBC aa. BCBC aa. BBCC aabb. CC aabbcc ableitungskette(Neues. Wort, Altes. Wort) : Neues. Wort = Altes. Wort. ableitungskette(Neues. Wort, Altes. Wort) : ableitungsschritt(Zwischen. Wort, Neues. Wort), ableitungskette(Zwischen. Wort, Altes. Wort). KB

Logische Programmierung 100 KB Ableitung S ableitung(Wort) : ableitungskette(Wort, S), startsymbol(S). a. SBC aa. BCBC aa. BBCC aabb. CC aabbcc

Logische Programmierung 101 KB Ausgabe der Ableitungskette ableitungsschritt(Altes. Wort, L, R, Neues. Wort) : produktion(L, R), append(L, B, Altes. Wort), append(R, B, Neues. Wort). ableitungsschritt([E|Altes. Wort], L, R, [E|Neues. Wort]) : ableitungsschritt(Altes. Wort, L, R, Neues. Wort). ableitungskette(Neues. Wort, Altes. Wort, []) : Altes. Wort = Neues. Wort. ableitungskette(Neues. Wort, Altes. Wort, [regel(L, R), Zwischen. Wort |A]) : ableitungsschritt(Zwischen. Wort, L, R, Neues. Wort), ableitungskette(Zwischen. Wort, Altes. Wort, A. ableitung(Wort) : ableitungskette(Wort, S, A), startsymbol(S), write(A).

Ausgabe der Ableitungskette 102 ? - ableitung([a, a, b, b, c, c]). Logische Programmierung [ regel([c, v. C], [c, c]), [a, a, b, b, c, v. C], regel([b, v. C], [b, c]), [a, a, b, b, v. C], regel([b, v. B], [b, b]), [a, a, b, v. B, v. C], regel([a, v. B], [a, b]), [a, a, v. B, v. C], regel([v. C, v. B], [v. B, v. C]), [a, a, v. B, v. C], regel([v. S], [a, v. B, v. C]), [a, v. S, v. B, v. C], regel([v. S], [a, v. S, v. B, v. C]), [v. S] ] Yes KB

Logische Programmierung 103 KB Ausgabe aller Ableitungsversuche ableitungsschritt(Altes. Wort, L, R, Neues. Wort) : produktion(L, R), append(L, B, Altes. Wort), append(R, B, Neues. Wort). ableitungsschritt([E|Altes. Wort], L, R, [E|Neues. Wort]) : ableitungsschritt(Altes. Wort, L, R, Neues. Wort). ableitungskette(Neues. Wort, Altes. Wort, []) : Altes. Wort = Neues. Wort. ableitungskette(Neues. Wort, Altes. Wort, [regel(L, R), Zwischen. Wort |A]) : ableitungsschritt(Zwischen. Wort, L, R, Neues. Wort), ableitungskette(Zwischen. Wort, Altes. Wort, A, write([regel(L, R), Zwischen. Wort |A]), nl. ableitung(Wort) : ableitungskette(Wort, S, _), startsymbol(S).

Logische Programmierung 104 KB

Logische Programmierung 105 KB Teil 5 Anwendung: While-Interpreter

106 While-Interpreter Logische Programmierung {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 {b: 256; u: 0; p: 32} KB Interpreter

While-Programme Logische Programmierung 107 KB 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 Wertzuweisung

Interpreter-Prädikat Logische Programmierung 108 Ausgangszustand {b: 2; u: 5} While. Programm 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 Endzustand Interpreter {b: 256; u: 0; p: 32} ausfuehren(+Programm, +Ausgangszustand, -Endzustand) KB

Problemvereinfachung 109 Logische Programmierung Ausgangszustand KB Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END Interpreter {x: 5; y: 2; z: 5} Wir betrachten zunächst nur sehr einfache Programme: Sequenzen von Zuweisungen vom Typ <Var> : = <Var>.

Variablenzustände 110 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END {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 KB Interpreter

Variablenzustände 111 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END {x: 5; y: 2; z: 5} Spezifikation der Prädikate var. Wert(+Variable, +Zustand, -Variablenwert) ? - var. Wert(y, [wert(x, 2), wert(y, 5)], W). W=5 KB Interpreter

Variablenzustände 112 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END {x: 5; y: 2; z: 5} Spezifikation der Prädikate neuer. Zustand(+Variable, +Wert, +ZAlt, -ZNeu) ? - neuer. Zustand(y, 4, [wert(x, 2), wert(y, 5)], Z). Z = [wert(x, 2), wert(y, 4)] KB Interpreter

Variablenzustände 113 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END {x: 5; y: 2; z: 5} Spezifikation der Prädikate neuer. Zustand(+Variable, +Wert, +ZAlt, -ZNeu) ? - neuer. Zustand(z, 2, [wert(x, 2), wert(y, 5)], Z). Z = [wert(x, 2), wert(y, 5), wert(z, 2)] KB Interpreter

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

115 Variablenzustände Problemreduktionen: Logische Programmierung neuer. Zustand(z, 2, [], [wert(z, 2)]). neuer. Zustand(y, 4, [wert(y, 5) | R], [wert(y, 4) | R]). neuer. Zustand(y, 4, [wert(x, 2) | R], [wert(x, 2) | RNeu]) : neuer. Zustand(y, 4, R, RNeu). Fakten und Regeln: neuer. Zustand(V, W, [], [wert(V, W)]). neuer. Zustand(V, W, [wert(V, _) | R], [wert(V, W) | R]). neuer. Zustand(V, W, [wert(X, WAlt) | R], [wert(X, WAlt) | RNeu]) : V = X, neuer. Zustand(V, W, R, RNeu). KB

Zuweisungsinterpreter 116 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END {x: 5; y: 2; z: 5} Repräsentation von primitiven Zuweisungsprogrammen: [let(z, x), let(x, y), let(y, z)] Liste mit Termen KB Interpreter % Zuweisungssequenz

Zuweisungsinterpreter 117 Logische Programmierung Ausgangszustand Zuweisungsprogramm Endzustand {x: 2; y: 5} BEGIN z : = x; x : = y; y : = z END Interpreter {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)] KB

118 Zuweisungsinterpreter Fakten und Regeln: Logische Programmierung % Zuweisung ausführen KB ausfuehren(let(X, Y), ZAlt, ZNeu) : var. Wert(Y, ZAlt, W), neuer. Zustand(X, W, ZAlt, ZNeu). % Sequenz ausführen ausfuehren([], ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) : ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu).

Zuweisungsinterpreter 119 Logische Programmierung Testprogramm: KB testprogramm 1 : ausfuehren([let(z, x), let(x, y), let(y, z)], [wert(x, 2), wert(y, 5)], Z), write(Z). Programmtest: ? - testprogramm 1. [wert(x, 5), wert(y, 2), wert(z, 2)]

Terminterpreter Logische Programmierung 120 Ausgangszustand {x: 2; y: 5} Zuweisungsprogramm BEGIN x : = x-y; y : = x+y; x : = y-x END Endzustand {x: 5; y: 2} Spezifikation der Prädikate term. Wert(+Term, +Zustand, -Wert) ? - term. Wert(x-y, [wert(x, 2), wert(y, 5)], W). W = -3 KB Interpreter

Terminterpreter 121 Fakten und Regeln: Logische Programmierung term. Wert(V, _Z, V) : - integer(V). KB term. Wert(V, Z, W) : - atom(V), var. Wert(V, Z, W). term. Wert(T 1 + T 2, Z, W) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W is W 1+W 2. . term. Wert(-T, Z, W) : term. Wert(T, Z, W 1), W is -W 1.

122 Terminterpreter Fakten und Regeln: Logische Programmierung % Zuweisung ausführen KB ausfuehren(let(X, T), ZAlt, ZNeu) : term. Wert(T, ZAlt, W), neuer. Zustand(X, W, ZAlt, ZNeu). % Sequenz ausführen ausfuehren([], ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) : ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu).

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

Anweisungsinterpreter Logische Programmierung 124 Ausgangszustand {x: 2; y: 5} Programm IF x > y THEN betrag : = x – y ELSE betrag : = y – x Endzustand {x: 5; y: 2; betrag: 3} Interpreter 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)] KB

Anweisungsinterpreter 125 Logische Programmierung Ausgangszustand {b: 2; n: 3, p: 1} Programm WHILE n > 0 DO BEGIN p : = p*b; n : = n-1 END Endzustand {b: 2; n: 3, p: 8} Interpreter 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)] KB

Anweisungsinterpreter Logische Programmierung 126 Ausgangszustand {x: 2; y: 5} Programm IF x > y THEN betrag : = x – y ELSE betrag : = y – x Endzustand {x: 5; y: 2; betrag: 3} Spezifikation der Prädikate boole. Wert(+Term, +Zustand) ? - boole. Wert(x > y, [wert(x, 2), wert(y, 5)]). No KB Interpreter

127 Anweisungsinterpreter Logische Programmierung boole. Wert(T 1 = T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 =: = W 2. KB boole. Wert(T 1 == T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 == W 2. boole. Wert(T 1 < T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 < W 2. boole. Wert(T 1 > T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 > W 2. boole. Wert(T 1 =< T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 =< W 2. boole. Wert(T 1 >= T 2, Z) : term. Wert(T 1, Z, W 1), term. Wert(T 2, Z, W 2), W 1 >= W 2.

128 Anweisungsinterpreter Logische Programmierung ausfuehren(let(X, T), ZAlt, ZNeu) : term. Wert(T, ZAlt, W), neuer. Zustand(X, W, ZAlt, ZNeu). KB ausfuehren([], ZAlt). ausfuehren([Anw | R], ZAlt, ZNeu) : ausfuehren(Anw, ZAlt, Z), ausfuehren(R, Z, ZNeu). ausfuehren(if(Bed, Anw 1, _Anw 2), ZAlt, ZNeu) : boole. Wert(Bed, ZAlt), ausfuehren(Anw 1, ZAlt, ZNeu). ausfuehren(if(Bed, _Anw 1, Anw 2), ZAlt, ZNeu) : not(boole. Wert(Bed, ZAlt)), ausfuehren(Anw 2, ZAlt, ZNeu). ausfuehren(while(Bed, Anw), ZAlt, ZNeu) : boole. Wert(Bed, ZAlt), ausfuehren(Anw, ZAlt, Z), ausfuehren(while(Bed, Anw), Z, ZNeu). ausfuehren(while(Bed, _Anw), ZAlt) : not(boole. Wert(Bed, ZAlt)).

129 Anweisungsinterpreter Logische Programmierung Testprogramm: testprogramm 5 : 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: ? - testprogramm 5. [wert(b, 256), wert(u, 0), wert(p, 32)] KB

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