Von der Wissensbasis zum Expertensystem

Transcrição

Eine Einführung mit Prolog
INFORMATIK
a.hermes
Alfred Hermes
1
INFORMATIK
a.hermes
1. Vorbemerkungen....................................................................................................................3
1.1 Zum Thema ......................................................................................................................3
1.2 Lernziele...........................................................................................................................3
2. Lerneinheiten..........................................................................................................................4
2.1 Eine kleine Ahnentafel .....................................................................................................4
2.1.1 Zur Geschichte von Prolog........................................................................................4
2.1.2 Grundelemente von Prolog........................................................................................4
2.1.3 Backtracking als Methode zur Beantwortung von Fragen........................................8
2.2 Arithmetik - Rekursion...................................................................................................11
2.2.1 Die Türme von Hanoi..............................................................................................11
2.2.2 Weitere Beispiele ....................................................................................................12
2.2.3 Gewonnenes Wissen weiterverwenden...................................................................14
2.3 Musterorientierte Wissensrepräsentation (SII) ..............................................................15
2.3.1 Symbolisches Differenzieren ..................................................................................15
2.3.2 Konstanten und Operatoren.....................................................................................16
2.3.3 Termvereinfachung * ..............................................................................................17
2.4 Der Datentyp Liste .........................................................................................................19
2.4.1 Definition ................................................................................................................19
2.4.2 Grundoperationen....................................................................................................19
2.4.3 Sortieren ..................................................................................................................22
2.5 Erweiterte Verwendung von Listen ...............................................................................24
2.5.1 Listenoperationen - der funktionale Aspekt............................................................24
2.5.2 Listen als Fakten .....................................................................................................24
2.5.3 Terme als Listen, Operatoren als Argumente..........................................................25
2.6 Kontrollstrategien...........................................................................................................26
2.6.1 Rückwärtsverkettung...............................................................................................26
2.6.2 Vorwärtsverkettung.................................................................................................27
2.6.3 Schatzsuche .............................................................................................................29
2.6.4 Graph als Funktor* ..................................................................................................30
2.7 Ein einfacher Interpreter mustergesteuerter Programme* .............................................31
2.8 Expertensysteme.............................................................................................................34
2.8.1 Komponenten von Expertensystemen.....................................................................34
2.8.2 Diagnose von Fehlern am Auto...............................................................................36
2.9 Eine kleine Logelei* ......................................................................................................40
Glossar..................................................................................................................................42
Literaturverzeichnis..............................................................................................................43
2
INFORMATIK
a.hermes
1. Vorbemerkungen
1.1 Zum Thema
Expertensysteme und Künstliche Intelligenz sind Paradigmen „moderner“ Anwendungen von
Computern. In diesem Zusammenhang gilt Prolog als besonders praktisches und leicht handhabbares
Programmierwerkzeug. Während konventionelle Sprachen wie Pascal prozedural orientiert sind,
repräsentiert Prolog als sogenannte Sprache der fünften Generation eine deskriptive oder deklarative
Programmiersprache.
Obwohl es sich bei Prolog nicht um eine funktionale Programmiersprache handelt, sind funktionale
Aspekte doch indirekt präsent und z.B. bei Listenverarbeitung erkennbar. Gleichzeitig unterstützt
Prolog die Verwendung abstrakter Datentypen in generischer Form.
Aufgrund der genannten Aspekte, des prologeigenen Kontrollmechanismus der Rückverfolgung, des
äußerst leichten Zugangs zur Sprache und der einfachen Bedienung des Systems ist Prolog eine
interessante Alternative zu einer imperativen Sprache wie Pascal.
Das Heft behandelt Komponenten von Expertensystemen und führt gleichzeitig in die logische
Programmiersprache Prolog ein. Es wird ein Bogen von einer einfachen Datenbank am Beispiel einer
Ahnentafel bis zu Komponenten (Inferenzmaschine) eines kleinen Expertensystems gespannt.
Thematische Schwerpunkte der Reihe sind die Wissensdarstellung und logische Schlussfolgerungen
aus Wissen bei Verwendung von Prolog als Werkzeug. Als Leitgedanke spielt die Entwicklung von
Expertensystemen eine tragende Rolle.
Aspekte, wie die Behandlungen von Logeleien, die Verarbeitung natürlicher Sprache, Vertiefungen
von aussagenlogischen und prädikatenlogischen Problemen, sowie Tipps und Tricks in Prolog
werden nur aufgegriffen, wenn sie sich aus dem übergeordneten Thema ergeben.
Die Prolog-Beispiele aus der Unterrichtsreihe entsprechen dem „Quasi-Standard“ von DEC-Prolog,
das in „Programming in Prolog von Clocksin/Mellish, Springer-Verlag 1984“ verwandt wird.
1.2 Lernziele
Nach Bearbeitung des Materials sollt Ihr / sollten Sie
- Grundlagen der deklarativen Programmiersprache Prolog kennen,
- den Prozess der Rückverfolgung als Problemlösungsstrategie kennen,
- rekursive Prozesse in Prolog formulieren können,
- Wissen in musterorientierter Form formulieren und auswerten können,
- Kontrollstrategien wie Rückwärts- und Vorwärtsverkettung anwenden können,
- die Wissensbasis mit Hilfe des Arbeitsspeichers erweitern können,
- einen einfachen Interpreter für mustergesteuerte Programme kennen und verstehen,
- Probleme des Einsatzes von Expertensystemen kennen,
- Komponenten von Expertensystemen kennen und
- Teile einer Expertensystemschale in Prolog programmieren können.
3
INFORMATIK
a.hermes
2. Lerneinheiten
2.1 Eine kleine Ahnentafel
2.1.1 Zur Geschichte von Prolog
Prolog (Programming in Logic) wurde 1972 von Alain Colmerauer und einer Gruppe von
Wissenschaftlern (Groupe d`Intelligence Artificielle de Luminy) an der Universität Marseille konzipiert
und erstmals implementiert. Durch die Wahl von Prolog als Sprache der sog. 5. Generation in einem
breit angelegten japanischen Forschungsvorhaben erhielt Prolog Weltgeltung in der Familie der
Sprachen der KI (Künstlichen Intelligenz). Prolog basiert auf Prinzipien der logischen Programmierung
und gehört zu den deklarativen Sprachen. "Deklarativ" bedeutet, dass dem Computer logische
Beziehungen deklariert werden können, wobei die Beziehungen bereits das Programm definieren. Es
stellt sich die Frage, was zu lösen ist, im Gegensatz zu prozeduralen Sprachen wie Pascal, wo
gefragt wird, wie etwas zu lösen ist.
Stichworte (engl.)
- progamming in logic
- declarative language
- fifth generation computer language
- AI = artificial intelligence
2.1.2 Grundelemente von Prolog
Fakten
Die folgende Skizze ([5]) zeigt einen Ausschnitt aus einer Ahnentafel
wilhelmine
elfriede
maria
fritz
anton
hugo
brunhilde
theresia
heinz
wilhelm
alfons
(Entnommen aus [5], M. Hanus, Titelseite)
Die Beschreibung der Ahnentafel erfolgt in der Prolog-Wissensbasis, auch Datenbasis genannt. Man
wähle den Prolog-Editor durch Eingabe von:
?- edit(ahnentafel).
/* Punkt Return */
Vergessen Sie nicht den Punkt am Ende der Eingabe, und schließen Sie jede Eingabe durch Drücken
der Returntaste ab!
Die in der Ahnentafel dargestellten Objekte lassen sich durch Eigenschaften, wie das Geschlecht
oder Beziehungen, wie das Verheiratetsein oder Muttersein beschreiben.
4
INFORMATIK
a.hermes
Über Wilhelmine lässt sich z.B. sagen, dass sie weiblich ist und mit Fritz die Töchter Elfriede und
Theresia hat.
Zur Darstellungen solcher Informationen verwendet man in Prolog sog. Fakten, die aus Prädikaten
bzw. Relationsnamen (in Prolog: Funktoren) wie "weiblich" und verknüpften Objekten (in Prolog:
Argumente) wie den Namen bestehen:
Umgangssprache
Wilhelmine ist weiblich
Wilhelmine und Fritz sind
Eltern von Elfriede
Prolog - Fakten (in Form von Relationen)
weiblich(wilhelmine).
elternVon(fritz,wilhelmine,elfriede).
Man erkennt, dass die Namen der Prädikate (weiblich, elternVon) und der Objekte
(fritz,wilhelmine,elfriede) mit einem kleinen Buchstaben beginnen. Alle Fakten sind durch
einen Punkt abzuschließen:
weiblich(brunhilde).
weiblich(elfriede).
weiblich(theresia).
weiblich(maria).
maennlich(fritz).
maennlich(heinz).
maennlich(anton).
maennlich(wilhelm).
maennlich(hugo).
maennlich(alfons).
elternVon(wilhelmine,fritz,elfriede).
elternVon(wilhelmine,fritz,theresia).
elternVon(brunhilde,heinz,wilhelm).
elternVon(elfriede,anton,maria).
elternVon(elfriede,anton,hugo).
elternVon(theresia,wilhelm,alfons).
Übung
Starten Sie das Prologsystem, und edieren Sie die vorbereitete Wissensbasis namens „Ahnentafel“.
Speichern Sie die Ahnentafel ab (F2) und geben Sie ein:
?- consult(ahnentafel).
Die Datei "Ahnentafel" wird als Wissensbasis herangezogen.
Fragen / Wiedergewinnung von Wissen / Prüfen von Fakten
Nun kann die Wissensbasis befragt werden:
?- elternVon(wilhelmine,fritz,theresia).
yes
Hier wird festgestellt, dass Wilhelmine und Fritz Eltern von Theresia sind.
5
INFORMATIK
a.hermes
?- maennlich(elfriede).
no
Hier handelt es sich offensichtlich um eine falsche Aussage.
Variablen / Abrufen von Fakten
Um herauszufinden, welche Kinder z.B. Wilhelmine und Fritz haben, fasst man das 3. Argument
(Objekt) zum Funktor (Prädikat) elternVon als Variable auf:
?- elternVon(wilhelmine,fritz,Kind).
Kind=elfiede
more(j/n)? j
Kind = theresia
o
Variablennamen beginnen mit einem großen Buchstaben.
Konjunktion / Disjunktion / Logisches Verknüpfen von Abfragen
Die Anfrage, ob Theresia und Elfriede dieselbe Mutter haben, lässt sich auf folgende Weise
ausdrücken: "Die beiden Mädchen haben dieselbe Mutter, wenn die Mutter von Theresia auch die
Mutter von Elfriede ist. Der Name des Vaters spielt hier keine Rolle:
?- elternVon(Mutter,_,theresia), elternVon(Mutter,_,elfriede).
Mutter = wilhelmine
o
o
o
o
Das Komma entspricht dem logischen "Und".
Ein Semikolon entspricht dem logischen "Oder".
Ein Unterstrich ist eine anonyme Variable, deren Name und Inhalt nicht benötigt wird.
Nur wenn alle Teilaussagen wahr sind, ergibt die Konjunktion eine wahre Aussage. Bei der
Disjunktion reicht eine wahre Teilaussage aus, um eine wahre Aussage zu erhalten.
Regeln (rules) / Definition neuer Relationen
Regeln werden auf Gruppen von Fakten angewendet. Die Regel istSchwesterVon lässt sich auf
folgende Weise beschreiben:
X ist Schwester von Y, falls X weiblich ist und X und Y dieselben Eltern haben.
In ProLog:
istSchwesterVon(X,Y) :weiblich(X),
elternVon(M,V,X),
elternVon(M,V,Y).
Die Regel ist in die ProLog-Wissensbasis zur Ahnentafel einzutragen.
(edit(ahnentafel). ..... reconsult(ahnentafel).)
?- istSchwesterVon(X,hugo).
X = maria.
o
Eine Regel ist eine Beschreibung der Beziehungen zwischen Objekten. Sie besteht aus
einem Kopf (Folgerung) und einem Rumpf (Voraussetzung). Kopf und Rumpf trennen das
Symbol :-, das als "wenn" oder "falls" ausgesprochen wird.
6
INFORMATIK
a.hermes
o
Regeln und Fakten fallen unter den Oberbegriff Klauseln (clauses).
o
Falls die Voraussetzungen im Regelrumpf eine Konjunktion (und) bilden, muss jeder Voraussetzungsteil bestätigt sein, damit die Regel gilt. Bei der Disjunktion (oder) genügt dafür die
Bestätigung mindestens einer Klausel im Rumpf.
Kommentare
/* Dies ist ein Kommentar */
% Dies ist auch ein Kommentar
Verneinung
Zur Verneinung existiert in Prolog der Operator bzw. das Prädikat not. Bei seiner Anwendung wird
aus dem Misslingen einer Abfrage das Gegenteil gefordert (negation as failure). not deckt sich nicht
mit der logischen Verneinung, wie folgendes Beispiel zeigt:
maennlich(hans).
weiblich(X) :- not maennlich(X).
/*bzw.:weiblich(X):-not (maennlich(X)).*/
?- weiblich(erna).
?- weiblich(anton).
?- weiblich(hans).
yes
yes
no
Die ersten beiden Antworten lauten jeweils yes, da die Argumente nicht in der Wissenbasis vorkommen.
Vergleich von Objekten
Nach der Regel “istSchwesterVon“ ist jede weibliche Person Schwester von sich selbst. In Prolog
lassen sich Variableninhalte nicht ohne weiteres vergleichen, wenn sie keine Zahlen sind. Falls die
Variablen allerdings einen Wert haben, mit dem die entsprechende Aussage überprüft werden kann,
darf das Gleichheitszeichen auch in Verbindung mit not verwendet werden. Die Regel
istSchwesterVon kann (allerdings erst am Schluss, denn erst dort sind X und Y mit Werten belegt)
wie folgt ergänzt werden:
elternVon(M,V,X),
elternVon(M,V,Y),
not X=Y.
oder
elternVon(M,V,X),
elternVon(M,V,Y),
not gleich(X,Y).
gleich(A,A).
Aufgabe 1
Es sind weitere Regeln zu definieren:
7
a)
istVaterVon(V,K)
b)
istElternteilVon(E,K)
c)
istTanteVon(T,K)
d)
istVorfahrVon(Vor,X).
INFORMATIK
a.hermes
Die Regel bezüglich der Vorfahren führt auf Rekursion: Vor ist ein Vorfahr von X, wenn Vor Elternteil
von X ist, oder wenn es eine Person gibt, deren Elternteil Vorfahr von X ist. Statt Verwendung des
Zeichens “;“für “oder“ können auch beide Regelteile mit gleichem Kopf und durch einen Punkt
getrennt aufgeführt werden.
2.1.3 Backtracking als Methode zur Beantwortung von Fragen
Betrachten Sie die folgende bekannte Wissenbasis und die sich daran anschließende Frage bzw.
Ziel (goal), das erreicht werden soll:
weiblich(elfriede).
...
...
?- weiblich(X), elternVon(X,_,wilhelm); elternVon(_,X,wilhelm)).
Man entdeckt unschwer, daß hier nach der Mutter von Wilhelm gefragt ist. Wissensbasen sind
allgemein in Form von Fakten und Regeln deklarativ dargestellt. Wie Prolog allerdings neues Wissen
aus der Wissensbasis herleitet, ist prozedural zu beschreiben, denn bereits die Informationen über die
Reihenfolge der Klauseln innerhalb der Wissensbasis steuern den Herleitungsvorgang. Andere
prozedurale Elemente zeigten sich bereits bei der Negation, weitere, wie der CUT-Operator, werden
folgen.
Prolog durchforstet beim Beweisversuch eines Ziels die Wissensbasis nach der Strategie der
Tiefensuche von oben nach unten und innerhalb eines Regelrumpfes von links nach rechts. Der dafür
zuständige Interpreter geht von der gestellten Frage aus (rückwärtige Verkettungsrichtung) und sucht
in der Wissensbasis eine Klausel, in der die Frage als Kopf, d.h. eventuell als Folgerung erscheint
(weiblich, istSchwestervon :- .. ). Wenn die Voraussetzung erfüllt ist oder es sich lediglich
um einen Fakt handelt, wird die Frage bejaht und eine gegebene Variable zugeordnet bzw. an einen
Wert gebunden (hier z.B. wilhelmine). Der „Ort“ der Bindung, d.h. die entsprechende Klausel, ist
ein sogenannter „Backtrack-Punkt“, wenn zum gleichen Prädikat noch weitere Klauseln existieren,
die noch nicht abgearbeitet worden sind (hier z.B. weiblich(brunhilde)). Im Beispiel scheitern
die Versuche, die weiteren Voraussetzungen mit wilhemine zu beweisen. Nun beginnt eine
Rücksetzung (Backtracking) , die nach dem Misserfolg des Ziels alle Variablenbindungen bis zum
letzten Backtrack-Punkt löst und von da ab weitere Lösungsalternativen verfolgt.
Der Prologinterpreter verkettet rückwärts und sucht in die Tiefe. Rückwärtsverkettung bedeutet,
dass die Ableitung eines Ziels von der gestellten Frage bis zu den Fakten und Regeln der
8
INFORMATIK
a.hermes
Wissensbasis führt. Die Suchstrategie ist die Tiefensuche (von links nach rechts und von oben nach
unten) in Verbindung mit Backtracking (Rücksetzung). Backtracking ist die Suche einer
gleichnamigen Klausel, nachdem sich der bisherige Weg als falsch erwiesen hat.
In Kapitel 2.6 wird die Strategie der Vorwärtsverkettung beschrieben. Zu weiteren Strategien, z.B.
Rückwärtsverkettung mit Breitensuche sei auf die Literatur (z.B. [1],[8]) verwiesen.
Betrachten Sie folgende Frage, bzw. Ziel (goal), das erreicht werden soll:
?- weiblich(X), (elternVon(X,_,wilhelm); elternVon(_,X,wilhelm)).
Das Bild auf der nächsten Seite demonstriert, wie Prolog Ziele auf ihre Erfüllbarkeit hin überprüft.
Vorsicht, Endlosschleifen!
Die Art der Interpretation von Prolog kann zu Endlosschleifen führen, obwohl eine Lösung existiert,
wie folgendes Beispiel zeigt:
wetter(schoen) :- gehtSchwimmen(helga).
gehtSchwimmen(helga) :- wetter(schoen).
wetter(schoen).
?- gehtSchwimmen(helga).
Es liegt am Programmentwickler, solche Fälle, evtl. durch Veränderung der Reihenfolge von Klauseln,
zu vermeiden.
9
INFORMATIK
a.hermes
?- weiblich(x), (elternVon(X,_,wilhelm); elternVon(_,X,wilhelm)).
1
weiblich(elfriede).
......
......
1. Das erste Ziel ist erreicht (es paßt, engl. to match). X wird mit dem Wert "wilhelmine"
belegt.
2. Es wird versucht, das nächste Ziel zu erreichen (to satisfy the next goal).
?- weiblich(x), (elternVon(X,_,wilhelm);elternVon(_,X,wilhelm)).
1
2
3
weiblich(elfriede).
......
......
3. Das zweite Ziel wird nicht erreicht ( engl. fail).
4. Es wird versucht, das dritte Ziel zu erreichen, was ebenfalls scheitert.
5. Backtracking: Durch Anwendung der nächsten Regel erhält X einen neuen Wert
?- weiblich(x), (elternVon(X,_,wilhelm);elternVon(_,X,wilhelm)).
1
2
weiblich(elfriede).
......
......
6. Das erste Ziel ist erneut erreicht (es paßt, engl. to match). X wird mit dem Wert
"brunhilde" belegt.
7. Es wird erneut versucht, das zweite Ziel zu erreichen. Dies gelingt im 3. Fakt zum
Prädikat "elternVon".
Übung: Testen Sie die Klausel “istMutterVon“ , und prägen Sie sich die Begriffe wie Fakt, Regel,
Klausel, Backtracking, Tiefensuche und deren Bedeutungen ein!
10
INFORMATIK
a.hermes
2.2 Arithmetik - Rekursion
2.2.1 Die Türme von Hanoi
Das Problem der Türme von Hanoi wurde im 19. Jahrhundert auch unter dem Namen "Kaiser-Rätsel"
bekannt. Die Aufgabe wurde von einigen Priestern aus der asiatischen Stadt Hanoi erdacht. Um das
Rätsel rankt sich die Geschichte, dass mit seiner Lösung das Ende der Welt unmittelbar bevorstehe.
Das Problem:
Um drei Holzsäulen können goldene Scheiben wie Perlen aufgereiht werden. Zu Beginn sind 64
Scheiben mit absteigendem Durchmesser um Säule 1 gereiht, d.h., die größte Scheibe liegt unten.
Die Aufgabe besteht darin, den Scheibenturm von Säule1 zur 3. Säule unter Zuhilfenahme von Säule
2 zu transportieren. Die Transportbedingungen sind folgende:
- Es darf jeweils nur eine Scheibe zur gleichen Zeit transportiert werden.
- Eine Scheibe darf niemals auf eine kleinere gelegt werden.
Es lässt sich leicht nachweisen, dass zur Verlegung von n Scheiben 2n-1 Transporte einzelner
Scheiben erforderlich sind.
Säule 1
Säule 2
Säule 3
Die Lösung lässt sich umgangssprachlich auf folgende Weise formulieren:
- Das Problem ist gelöst, falls keine Scheibe umzusetzen ist.
- Andernfalls ist der Scheibenturm ohne die untere Scheibe auf den Hilfsplatz (Säule 2) zu verlegen,
die untere Scheibe ist zum Zielplatz zu transportieren und schließlich muss der auf dem Hilfsplatz
befindliche Turm zum Zielplatz gebracht werden.
Die Prolog-Version lautet:
hanoi(Anzahl) :- verlege(Anzahl, eins, zwei, drei).
verlege(0,A,H,Z) :- !.
verlege(K,A,H,Z) :K1 is K - 1,
verlege(K1,A,Z,H),
bewege(K,A,Z),
verlege(K1,H,A,Z).
/* Leerer Turm
--> fertig */
/* Wertzuweisung*/
bewege(N,Von,Nach) :nl, write('Bewege den Ring '), write(N),
11
INFORMATIK
a.hermes
write(' von Platz '), write(Von),
write(' nach Platz '), write(Nach).
Aufruf, z.B.: ?- hanoi(3).
Die erste Regel von verlege ist die Abbruchbedingung. Das Ausrufezeichen (!) unterstreicht den
Abbruch; man bezeichnet es als "CUT". Die Verwendung eines "Cuts" hat u .a. folgende Bedeutung:
Beim Erreichen von ! wird die Suche nach weiteren Alternativen unterbunden.
Die zweite Regel von verlege enthält K1 is K - 1. Das bedeutet: "Falls K1 den Wert von K - 1
hat, ...". Das Prädikat is ist partiell, d.h., dass bei seiner Verwendung das Argument rechts von is
einen Wert haben muss.
X is Ausdruck ist wahr, wenn X zum Wert des arithmetischen Ausdrucks passt (.. mit dem Wert
“matcht“).
In Verbindung mit ganzen Zahlen gelten u.a. folgende Operatoren:
Vergleichsoperatoren
X = Y
die Zahlen X und Y „matchen“
X \= Y
ungleich
X < Y
kleiner
X > Y
größer
X =< Y
kleiner oder gleich
X >= Y
größer oder gleich
Arithmetische Operatoren
X + Y
Summe
X - Y
Differenz
X * Y
Produkt
X / Y
Quotient, ganzzahlig
X mod Y
Modulo
is
wird belegt mit
(Bemerkung: Zur Überprüfung der Wertgleichheit bzw. -ungleichheit arithmetischer Ausdrücke
existieren die Operatoren =:= bzw. =\=)
2.2.2 Weitere Beispiele
Fakultät
faku(0,1) :- !.
/*
faku(N,Ergebnis) :/*
Nvor is N - 1,
/*
faku(Nvor,FakuVor),
/*
Ergebnis is N * FakuVor./*
0 Fakultät = 1, fertig */
Ergebnis gleich N-Fakultät, */
falls Nvor gleich N-1 ist und */
FakuVor gleich Nvor-Fakultät */
Ergebnis gleich N * FakuVor */
Quadratberechnung mit Eingabe (read)
quadrat :- write('Zahl (Ende = 0 ) : '),
read(Zahl), quadrat(Zahl).
quadrat(0) :- !.
quadrat(N) :Q is N * N,
write('Das Quadrat von '), write(N), write(' ist '),
write(Q), nl,
quadrat.
12
INFORMATIK
a.hermes
Bemerkenswert ist, dass das Prädikat quadrat unterschiedlich verwandt wird, einerseits ohne,
andererseits mit Parametern. Das Argument 0 kann auch eine Zeichenfolge, z.B. ende oder ein
Zeichen sein.
o
Die Eingabe nach read ist mit einem Punkt abzuschließen.
?- quadrat.
Zahl (Ende = 0 ) : 2.
Das Quadrat von 2 ist 4
Zahl (Ende = 0 ) : 0.
yes
Quadratzahltest (siehe [5])
Eine Zahl Q ist eine Quadratzahl, wenn eine natürliche Zahl n zwischen 1 und Q existiert, deren
Quadrat gleich Q ist.
quadratzahl(Q) :- square(1,Q).
/*es ex. eine Zahl zw. 1 und Q, deren Quadrat = Q */
square(N,Q) :H is N * N,
H > Q, !, fail.
/* Q ist keine Quadratzahl, falls ..
*/
/* Abruch mit FALSE */
square(N,Q) :- Q is N * N.
/* siehe quadrat */
square(N,Q) :N1 is N+1,
square(N1,Q).
/* Test von N+1 */
Cut (!) in Verbindung mit fail signalisiert einen endgültigen Fehlschlag bezüglich des zugehörigen
Prädikats. fail erzwingt Backtracking.
Zählen (siehe [5])
Beim Problem des Zählens wird ein Prädikat gesucht, das als Suchraum eine Teilmenge der natürlichen Zahlen hat. Beginnend mit 1 wird bei jedem neuen Beweis das Argument mit der nächst höheren natürlichen Zahl durchgeführt:
zahl(1).
/* Zählen*/ ?- zahl(N). zahl(N) :zahl(Vor), N is Vor + 1.
N = 1;
N = 2;
....
Aufgabe 2
a) Der Rechner soll von A bis Z aufwärts zählen: zaehle(A,Z)
b) Eine Zahl N ist zu quadrieren: quadrat(N,Q)
c) Es sind Wurzelnachbarn von 0 an aufwärts zu bestimmen.
Wurzelnachbarn sind benachbarte natürliche Zahlen, deren Quadratsummen wieder ein Quadrat
ergeben: n*n + (n+1)*(n+1) = Quadratzahl.
Orientieren Sie sich an den Beispielen Quadratzahltest und Zählen.
13
INFORMATIK
a.hermes
2.2.3 Gewonnenes Wissen weiterverwenden
Beispiel: Fibonacci
Die ersten Fibonacci-Zahlen lauten: 1 1 2 3 5 8 13 21 34 55 ...
Die ersten beiden Fibonacci-Zahlen sind 1. Die n-te Fibonacci-Zahl ist die Summe ihrer beiden
Vorgängerzahlen.
Eine zweimalige rekursive Bestimmung der Vorgänger führt laufend zur Berechnung von
Zwischenresultaten, die in einem früheren Durchgang bereits berechnet worden sind. Nichts liegt
näher, als die Zwischenergebnisse am Anfang der Wissensbasis als abgeleitete Fakten aufzunehmen, so dass eine erneute Berechnung überflüssig wird.
Das Programm versucht, zunächst die während des Durchgangs gespeicherte Fakten oder Regeln
über die Relation fib heranzuziehen, ehe es zu Klauseln der ursprünglichen Basis greift. Nach
Beendigung des Programms kann man sich mit dem Befehl listing die hinzugewonnenen Fakten
ansehen.
fib(1,1).
fib(2,1).
fib(N,Fib) :N > 2,
N1 is N - 1, fib(N1,Fib1),
N2 is N - 2, fib(N2,Fib2),
Fib is Fib1 + Fib2,
asserta(fib(N,Fib)).
/* besser: asserta(fib(N,Fib) :- !). warum? */
Befehle zur Wissensverwaltung
Mit Hilfe von asserta(Klausel) wird eine Klausel am Anfang der Datenbasis eingefügt,
assertz(Klausel) fügt am Ende ein. assert(Klausel) fügt irgendwo ein, retract(Klausel)
löscht eine Klausel.
Speichern einer Klausel
im Arbeitsspeicher
Auflisten des Programms
listing.
Löschen einer Klausel
retract(Name(Argumente)).
(z.B. retract(fib(_,_)).)
Löschen aller Klauseln zum Namen
retractall(Name(Variablennamen))
assert(Klausel).
Aufgabe 3
Bekanntlich ist 2 die kleinste Primzahl (prim(2)). Eine größere Zahl als zwei ist Primzahl, wenn sie
durch keine kleinere ohne Rest teilbar ist (Rest is Zahl mod Teiler). Entwickeln Sie
entsprechend dieser Definition ein Programm zur Ausgabe aller Primzahlen bis zu einer
vorgegebenen Zahl.
14
INFORMATIK
a.hermes
2.3 Musterorientierte Wissensrepräsentation (SII)
2.3.1 Symbolisches Differenzieren
Es soll ein Prädikat definiert werden, das genau dann wahr ist, wenn DF die Ableitung von F nach x
ist. In der Mathematik kennt man die Schreibweise dF/dx = f', in Worten: dF nach dx gleich f Strich.
So ist z.B. d(x2-2*x) / dx = 2*x - 2. Im Folgenden gelte die Vereinbarung, dass immer nach der
Variablen x abgeleitet werde. In Prolog müssen die Bezeichnungen von Termen ein wenig anders
gewählt werden als in der Mathematik:
Mathematischer Term
Konstante c
x
f+g
f-g
f*g
f/g
(f hoch Konstante)
fc
Prolog-Term
k(c)
x
F + G
F - G
F * G
F / G
ln(f)
hoch(F, k(c))
ln(F)
exp(f)
exp(f)
DF = df / dx (f nach x abgeleitet)
(DF = f')
dx(F, DF)
Konstanten müssen zur Unterscheidung von sonstigen Termen als Funktionen (k) gekennzeichnet
werden. Die mathematischen Ableitungsregeln werden in Prolog in folgender Weise als Klauseln
formuliert:
15
INFORMATIK
a.hermes
Mathematische Regeln
Prolog-Klauseln
c' = dc/dx = 0
dx(k(C),k(0)).
x' = dx/dx = 1
dx(x,k(1)).
(f+g)' = f'+g'
dx(F + G, DF + DG) :- dx(F,DF),dx(G,DG).
(f-g)' = f'-g'
dx(F - G, DF - DG) :- dx(F,DF),dx(G,DG).
(c*f)' = c * f'
dx(k(C) * F, k(C) * DF) :- dx(F,DF).
(f*g)' = f*g' + g*f'
dx(F * G,F * DG + G * DF) :- dx(F,DF),dx(G,DG).
(f/g)' = (f'*g-f*g')/g2
dx(F / G,(DF * G - F * DG) / hoch(G,k(2))) :dx(F,DF), dx(G,DG).
(fc)' = c*fc-1*f'
dx(hoch(F,k(C)),k(C) * hoch(F,k(C -1)) * DF)
:- dx(F,DF).
ln'(f) = (1/f)*f'
dx(ln(F), hoch(F,k(-1)) * DF) :- dx(F,DF).
exp'(f) = exp(f) * f'
dx(exp(F), exp(F) * DF) :- dx(F,DF).
Musterorientierung bedeutet in diesem Zusammenhang, dass die Köpfe der Klauseln bereits die
Muster enthalten, nach denen sie bearbeitet werden. Auf diese Weise wird hier wird „Backtracking“
vermieden.
Ein Aufruf zur Berechnung der Ableitung von z.B. 5x2 lautet:
?- dx(k(5) * hoch(x,k(2)), DF).
Prolog gibt das Ergebnis 10*x = 10 * (x*1) in folgender Form aus:
DF = k(5) * (k(2) * hoch(x,k(2 - 1)) * k(1))
2.3.2 Konstanten und Operatoren
Das Beispiel ist in mancher Hinsicht noch unbefriedigend und kann möglicherweise in der
Konstantennotation, der Notation bei Potenzen und in der Termvereinfachung verbessert werden
(siehe z.B. W.Hanus, Problemlösen mit Prolog, Teubner , Seite 198).
Konstanten - Das Prädikat integer
Die Aussage integer(C) ist wahr, wenn C eine ganze Zahl repräsentiert. Die Prolog-Klauseln zum
Differenzieren lassen sich auf folgende Art ändern:
dx(k(C),k(0)).
k(C-1)...
==>
==>
dx(C,0) :- integer(C).
C1 ....
:- integer(C), C1 is C-1.
Definition von Operatoren - op
Die prozedurale Schreibweise hoch(A,C) ist gewöhnungsbedürftig. Angenehmer erscheint die
alternative Verwendung eines dyadischen Operators, z.B. ^, dessen linker Operand die Basis und
dessen rechter den Exponenten darstellen: A^C für A hoch C. Die Festlegung erfolgt zu Beginn in
Form eines Ziels:
?- op(100,yfx,'^').
Die Zahl 100 gibt den Rang im Vergleich zu anderen Operatoren an. Der Rang von “+“ ist z.B. 500,
der von “*“ ist 400. Da das Potenzieren stärker bindet als die Multiplikation, ist der entsprechende
Operator mit einer niedrigeren Rangzahl zu belegen.
16
INFORMATIK
a.hermes
yfx steht für Linksassoziativität, d.h. a ^ b ^ c wird interpretiert als (a ^ b) ^ c.
Das Operatorzeichen bildet das dritte Argument von op.
Manche Prologversionen erlauben auch die Definition von Operationen in der Datenbasis, z.B.
:- op(100,yfx,'^').
Aufgabe 4
Führen Sie im Programm “Symbolisches Differenzieren“ die Operatornotation “^“ zur Kennzeichnung
von Exponenten ein, und testen Sie das Programm:
?- op(100,yfx,'^').
?- dx(x ^2,H).
H = 2 * x ^ 1 * 1
?- dx(-x,Dx).
no
(Für -x fehlt eine Regel, sie soll hier auch nicht formuliert zu werden.)
2.3.3 Termvereinfachung *
Die Vereinfachung von Termen kann nur sehr bescheiden ausfallen, wenn nicht die Termstruktur
samt Vorrangregeln, z.B. unter Verwendung eines Strukturbaumes, einfließt. Gewisse
Vereinfachungen, etwa durch Anwendung von Assoziativgesetzen, lassen sich allerdings auch ohne
Verwendung von Bäumen realisieren, wie folgender Ansatz zeigt:
vereinfache(F + G,E) :- vereinfache(F,Fneu),
wendeRegelan(Fneu +
vereinfache(F - G,E) :- vereinfache(F,Fneu),
wendeRegelan(Fneu vereinfache(F * G,E) :- vereinfache(F,Fneu),
wendeRegelan(Fneu *
vereinfache(F / G,E) :- vereinfache(F,Fneu),
wendeRegelan(Fneu /
vereinfache(F ^ G,E) :- vereinfache(F,Fneu),
wendeRegelan(Fneu ^
vereinfache(F,F).
vereinfache(G,Gneu),
Gneu,E).
Gneu,E).
Gneu,E).
Gneu,E).
Gneu,E).
wendeRegelan(F,E) :- regel(F,H), vereinfache(H,E).
wendeRegelan(F,F).
regel(C * (K * F), E) :- /* Assoziativgesetz für die Multiplikation */
integer(C), integer(K), H is C * K, wendeRegelan(H * F,E).
regel(F * 1,F) :- !. regel(F * 0,0) :- !. regel(F + 0,F) :- !.
regel(F - 0,F) :- !. regel(F / 1,F) :- !.
regel(F ^ 1,F). regel(F ^ 0,1).
regel(C1 + C2, C) :- integer(C1), integer(C2), C is C1 + C2.
regel(C1 - C2, C) :- integer(C1), integer(C2), C is C1 - C2.
regel(C1 * C2, C) :- integer(C1), integer(C2), C is C1 * C2.
regel(C1 / C2, C) :- integer(C1), integer(C2), C is C1 / C2.
?- vereinfache(3 * 5 * 10, E).
E = 150
17
INFORMATIK
a.hermes
?- dx(x ^ 1 + 2 * x ^ 2 + 3,H), vereinfache(H,E).
H = 1 * x ^ 0 * 1 + 2 * (2 * x ^ 1 * 1) + 0,
E = 1 + 4 * x
Schwächen und Grenzen der Lösung
Die Einbringung von Assoziativgesetzen (s. o.), Kommutativ- und Distributivgesetzen führt lediglich
unter günstigen Voraussetzungen zu verkürzten Termen. Die Vereinfachungen und Ableitungsregeln
funktionieren nicht, wenn Vorzeichen verwendet werden (z.B. dx(-x,T)), da für diesen Fall keine
Ableitungsregeln formuliert sind. Es wird nicht immer nur eine Lösung ausgegeben. Die
Vereinfachungsregeln können beliebig erweitert werden, erwarten Sie von dem Lösungsansatz aber
keine Wunder!
18
INFORMATIK
a.hermes
2.4 Der Datentyp Liste
a
[
b
head
c
d
e
f
g
| ---------------------------- tail --------------------------------- ]
2.4.1 Definition
Listen sind Datenstrukturen, die umgangssprachlich als Folgen von Objekten beschrieben werden
können. Listen spielen eine fundamentale Bedeutung im Bereich der abstrakten Datentypen. Eine
Möglichkeit der Definition einer Liste in Prolog ist folgende:
Eine Liste ist
- die leere Liste, dargestellt durch das Atom [] oder
- eine Struktur mit den zwei Komponenten „Head“ und „Tail“:
Head ist das erste Element der Liste (kann auch eine Liste sein),
Tail ist der Rest der Liste, muss eine Liste sein.
Äußere Erscheinungsbilder von Listen haben folgende Formen:
- [Element1, Element2, ...]
- [Element1 | Restliste]
- [Element1, Element2,....| Restliste]
Listenkopf und -rest werden durch einen senkrechten Strich (ASCII 124) getrennt, Listenelemente
durch ein Komma.
Beispiele: [a,b,c] = [a|[b,c]] = [a,b|[c]] = [a,b,c|[]]
2.4.2 Grundoperationen
1. Mitgliedschaft
Ein Element X ist in einer Liste L enthalten, wenn
(1) X der Kopf der Liste ist oder
(2) X im Rest der Liste vorkommt.
enthalten(X,[X|L]).
enthalten(X,[Y|R]) :enthalten(X,R).
/* enthalten(X,[X|_]).
/* enthalten(X,[_|R]) :/*
enthalten(X,R).
*/
*/
*/
?- enthalten(X,[a,b,c,d]).
X = a
more?
2. Ein Element anhängen
19
INFORMATIK
a.hermes
haengean(X,[],[X]).
haengean(X,[Y|Rest],[Y|Rest_mit_x]) :haengean(X,Rest,Rest_mit_x).
?- haengean(a,[d,c,b],Neu), haengean(x,Neu,L).
Neu = [d,c,b,a]
L = [d,c,b,a,x]
3. Zwei Listen verketten
(1) Falls die erste Liste leer ist, ist das Ergebnis der Verkettung die zweite Liste,
(2) andernfalls hat die erste Liste einen Kopf X und einen Rest R.
Das Ergebnis der Verkettung hat ebenfalls X als Kopf. Der Rest E besteht aus der Verkettung des
Restes der ersten Liste und der zweiten Liste.
verkette([],L,L).
verkette([X|Rest],L,[X|E] ):verkette(Rest,L,E).
?- verkette([a,b],[a,1,2],X).
?- verkette([a,b],[a,[auto],1,[],2],X).
X = [a,b,a,1,2]
X= [a,b,a,[auto],1,[],2]
4. Ein Element löschen
Das Prädikat loesche enthält die drei Argumente: das zu entfernende Element, die zu bearbeitende
Liste und die Ergebnisliste. Folgende Fälle sind zu unterscheiden:
(1) Aus einer leeren Liste ist nichts zu löschen
(2) Ist das Element der Kopf der Liste, bleibt der Rest
(3) Anderenfalls ist das Element im Rest zu löschen
loesche(X,[],[]).
/* loesche(_,[],[]). */
loesche(X,[X|Tail],Tail) :- !.
loesche(X,[Head|Tail],[Head|Result]):!,loesche(X,Tail,Result).
Aufgrund der Cuts wird nur das erste gefundene Exemplar des zu löschenden Elementes aus der
Liste entfernt. Bei fehlenden Ausrufezeichen wird „Backtracking“ nicht verhindert, man erhält
alternative Lösungen, z.B.:
?- loesche(a,[a,b,a],Z).
Z = [b,a];
Z = [a,b];
no
/* ohne ! */
?- loesche(a,L,[1,2]).
L = [a,1,2];
L = [1,a,2];
....
Auf diese Weise kann das Löschen zum Einfügen umdefiniert werden:
20
INFORMATIK
a.hermes
fuegeein(X,L,LmitX) :- loesche(X,LmitX,L).
Zur Vermeidung von Nebeneffekten empfiehlt sich allerdings folgende Definition:
fuegeein(X,[],[X].
fuegeein(X,L,[X|L]).
Aufgabe 5
a) Es sind Prädikate zu definieren
- zum Löschen aller Erscheinungen eines Elementes in einer Liste
- zur Bestimmung der Anzahl der Listenelemente
- zur Umkehrung der Reihenfolge der Listenelemente
- zur Erzeugung von Permutationen mit Hilfe von Backtracking:
?- permutation([a,b,c],P).
P = [a,b,c];
P = [a,c,b];
P = [b,a,c];
....
b) X ist Element einer Liste, wenn X gelöscht werden kann. Ma erstelle ein entsprechendes
alternatives Prädikat istElement.
c) Man implementiere die Menge mit folgenden Operationen:
- empty(M)
leere Menge, Erzeugung und Abfrage
- memb(X,Menge)
ist X in der Menge enthalten?
- insert(X,M,R)
R = M vereinigt {X}
- delete(X,M,R)
R = M \ {X}
- union(M,N,R)
R = M vereinigt N
- intersect(M,N,R)
R = M geschnitten N
Zu Aufgabe 5 c:
Die Eingabe einer Menge kann z.B. auf folgende Weise organisiert werden:
ein(N,M,S) :write(N),
write('. Element: '), read(A),
A \= 0,
insert(A,M,R),
N1 is N + 1,
ein(N1,R,S), !.
ein(_,M,M).
getset(S) :write('Mengeneingabe (0 = Ende)'),nl,
empty(X),
21
INFORMATIK
a.hermes
ein(1,X,S).
?- getset(Menge).
Mengeneingabe (0 = Ende)
1. Element: 1.
2. Element: a.
3. Element: 2.
4. Element: 0.
Menge = [2,a,1]
2.4.3 Sortieren
Beispiel: Sortieren durch Mischen
Von imperativen Programmiersprachen, wie Pascal, ist man gewohnt, zur Lösung eines Problems
diejenigen Operationen zu finden, die nacheinander auszuführen sind. Das folgende Bild demonstriert
das Lösungsverfahren an einem kleinen Beispiel :
7
5
3
1
2
Sortieren
Teilen
5
3
7
1
Sortieren
2
Sortieren
Teilen
Nicht
ausgeführt
7
2
Mischen
1
3
2
5
7
Mischen
1
2
3
5
7
Diesem Ansatz folgend lautet die Lösungsbeschreibung:
1) Teile die Liste L in zwei Teillisten etwa gleicher Größe
2) Sortiere die beiden Teillisten L1 und L2 mit den Ergebnissen S1 und S2
3) Mische S1 und S2 nach vorgegebenem Ordnungskriterium mit dem Ergebnis L
Im deklarativen Sinne (von Prolog) genügt folgende Aussage:
Eine Folge gilt als sortiert, wenn sie als eine nach einem Ordnungskriterium gemischte Liste zweier
sortierter Teilfolgen (am besten etwa gleicher Länge) aufgefasst werden kann. Leere und
einelementige Folgen gelten als sortiert.
22
INFORMATIK
a.hermes
Beim Teilen orientiere man sich an dem Verfahren kleiner Kinder zum Aufteilen z.B. von Murmeln: „
Eine für mich, eine für dich, eine für mich, eine für dich ...“ Der Lösungsansatz lautet in Prolog:
mischsort([],[]). /* Leere Listen gelten als sortiert */
mischsort([X],[X]).
/* Einelementige Listen sin sortiert */
mischsort(L,Sortiert) :geteilt(L1,L2,L),
mischsort(L1,S1),
mischsort(L2,S2),
gemischt(S1,S2,Sortiert).
/* Aufgabe 6a*/
geteilt([],[],[]).
geteilt([X],[],[X]).
geteilt([X|L1],[Y|L2],[X,Y|L]) :- geteilt(L1,L2,L).
Eingabebeispiel:
?- mischsort([3,9,6,1,4,5,3],M).
M = [1,3,3,4,5,6,9]
Aufgabe 6
a) Vervollständige die Beschreibung des Mischsortierens um das Prädikat gemischt!
Eingabebeispiel:
?- gemischt([1,5,5,6,8],[3,4],M).
M = [1,3,4,5,5,6,8]
b (SII)) Das folgende Programm sortiert entsprechend dem bekannten Quicksortverfahren
Zahlenfolgen in aufsteigender Form. Beschreiben Sie das Verfahren in Anlehnung an das
Prologprogramm in Worten, so dass es sich rekonstruieren läßt.
quicksort(Folge, Sortiert) :- quicksort(Folge, Sortiert,[]).
quicksort([V|Rest],Sortiert, Teil) :zerlege(V,Rest,F1,F2), quicksort(F2,R1,Teil),
quicksort(F1,Sortiert,[V|R1]).
quicksort([],F,F).
zerlege(V,[X|L],[X|L1],L2) :- X =< V, !, zerlege(V,L,L1,L2).
zerlege(V,[X|L],L1,[X|L2]) :- zerlege(V,L,L1,L2).
zerlege(_,[],[],[]).
sort(A)
:- quicksort([5,6,1,0,8,2,1,9,3,2,6,4],A),nl.
23
INFORMATIK
a.hermes
2.5 Erweiterte Verwendung von Listen
2.5.1 Listenoperationen - der funktionale Aspekt
Bei der Anwendung von Operationen auf Listen entstehen jeweils neue Listen mit neuen Namen, wie
z.B. fuegean(alpha,L1,L). Der Versuch eines Beweises der Form fuegean(alpha,X,X) führt
zur Antwort no, denn X kann nicht gleichzeitig mit verschiedenen Werten belegt sein.
Mit Blick auf die Programmiersprache Pascal findet man in der funktionalen Definition von
Datenstrukturen eine äquivalente Form zu fuegean(alpha,L1,L), etwa
L := fuegean ('alpha',L1) mit L, L1 vom Typ Liste.
Der Typ Liste ist beispielsweise als Zeiger auf einen Speicherbereich zu definieren.
2.5.2 Listen als Fakten
Listen können bereits in der Datenbasis in Form von Fakten vorliegen, z.B. mit den Prädikatsnamen
l1 und l2.
l1([2,23,45]).
l2([1,2,merkur]).
insert(X,[],[X]).
insert(X,L,[X|L]).
?- l1(X),insert(hermes,X,Liste),assert(l3(Liste)).
X = [2,23,45]
Liste = [hermes,2,23,45]
?- l3(Z).
Z = [hermes,2,23,45]
Die Wissensbasis ist um das Prädikat l3([hermes,2,23,45]) ergänzt worden, wie man sich
auch durch den Aufruf „listing“ überzeugen kann.
24
INFORMATIK
a.hermes
2.5.3 Terme als Listen, Operatoren als Argumente
Terme können mit Hilfe von read eingelesen und in eine Liste umgewandelt werden. Der
Hauptfunktor steht im Listenkopf, die beiden Argumente folgen in der richtigen Reihenfolge. Als
Vergleichszeichen dient =..
?- read(Term), Term =.. Liste.
2 + 3 * a.
Term = 2 + 3 * a
Liste = [+, 2, 3*a]
Ein in einer Liste abgelegter Ausdruck läßt sich beweisen. Der Aktivierung dient das Prädikat call.
?- Ausdruck =.. [is,Y,3*5], call(Ausdruck).
Ausdruck = 15 is 3 * 5
Y = 15
Übung (Selbsttest)
Die Anwendung eines beliebigen zweistelligen Operators auf alle Elemente einer Liste (engl.
mapping) führt zu einer zweiten Liste: wendean(Operator,Liste1,Liste2). Die zweite Liste
enthalte beispielsweise die Beträge (abs) oder Quadrate (quadrat) aller Zahlen der ersten Liste,
wenn es sich um Zahlen handelt, ansonsten unterscheide sie sich nicht von der ersten.
Im Falle der Liste liste([3,4,merkur,-2,0]) seien folgende Anfragen mit den entsprechenden
Antworten möglich:
?- liste(X), wendean(abs,X,A), wendean(quadrat,X,Q).
X = [3,-4,merkur,-2,0]
A = [3,4,merkur,2,0]
Q = [9,16,merkur,4,0]
Teillösung
liste([3,-4,merkur,-2,0]).
abs(X,Y) :- X < Y, Y is -X, !.
abs(X,X).
/* X < 0, Y is -X, !. */
quadrat(X,X) :- not integer(X).
quadrat(X,Y) :- Y is X * X.
wendean(Op,[],[]).
wendean(Op,[X|R1],[Y|R2]):T =.. [Op,X,Y],
......................
/*T = X Op Y */
Aufgabe 7
a) Vervollständigen Sie die Klausel wendean (s.o), und testen Sie das Programm!
25
INFORMATIK
a.hermes
b) Die Funktion filter entfernt alle Elemente einer Liste, die nicht einem bestimmten Prädikat P (z.B.
„ist eine Zahl“) genügen. Die rekursive Definition lautet in funktionaler Schreibweise:
filter(P,[])
= []
filter(P,[X|Xs] = [X| filter(P,Xs)], falls P(X) erfüllt ist
= filter[P,Xs], sonst.
Leiten Sie ein entsprechendes Prädikat filter in Prolog her!
2.6 Kontrollstrategien
Man versteht unter einer Inferenzmaschine ein Modell zur Simulation menschlichen Schließens bzw.
zur Darstellung des Prozesses des logischen Folgerns. Inferenz- (Schließ-) und Kontrollstrategien
basieren auf dem Ansatz der Trennung von Information und dem Mechanismus des Schließens.
Typische Kontrollstrategien sind die Rückwärts- und Vorwärtsverkettung. In Prolog ist die
Rückwärtsverkettung (backtracking) als Beweisstrategie bereits eingebaut, beginnend mit der
Behauptung arbeitet sich das System rückwärts durch die untergeordneten Ziele durch. Am Beispiel
“Wegesuche in Graphen“ lassen sich beide Verfahren gegenüberstellen:
D
F
C
B
E
A
kante(a,c).kante(a,b).kante(c,b).kante(b,d).kante(d,f).kante(d,e).
2.6.1 Rückwärtsverkettung
Die Strategie lautet:
Falls es keinen direkten Weg vom Start- zum Zielpunkt (A,Z) gibt, wähle man einen Zwischenpunkt
H, von dem aus ein Weg zum Ziel führt und suche einen Weg zum Zwischenpunkt.
Folgendes Bild verdeutlicht das Verfahren:
A
H
Z
Die entsprechende Strategie formuliert sich in Prolog auf folgende Weise:
weg(A,Z) :kante(A,Z),
write('Fahre von '), write(A),
write(' nach '), write(Z),nl.
weg(A,Z) :-
26
INFORMATIK
a.hermes
kante(H,Z), weg(A,H),
write( ' und von '), write(H),
write(' nach '), write(Z),nl.
Die vorliegende Lösung bietet grundsätzlich keinen Schutz vor unendlichen Zyklen. Im folgenden
Lösungsansatz wird dieser Nachteil durch Verwendung der Prolog-Datenbasis als „Merkzettel“
behoben.
2.6.2 Vorwärtsverkettung
Die Strategie lautet:
Man gehe zu einen geeigneten Nachbarn des Startpunktes, und suche das Ziel von dort aus!
Der Algorithmus schützt nicht vor Zyklen, also davor, immer im Kreis zu gehen.
Um Zyklen zu vermeiden, werden beim Suchvorgang alle beschrittenen Wege in der Wissensbasis
aufgenommen.
Die Suche beginnt mit dem Aufruf des Prädikats run(a,e). Nach erfolgreicher Suche lässt sich mit
Hilfe von listing lässt sich nachsehen, welche Routen in die Wissensbasis eingetragen worden sind.
Das folgende Bild veranschaulicht das Suchverfahren:
A
H
Z
Das entsprechende Prologprogramm lautet:
versucht(x,x).
/* Initialisierung */
weg(A,Z) :kante(A,Z),
asserta(route(A,Z)). /* Speichern des Wegstückes*/
weg(A,Z) :weg(A,H),
not versucht(A,H),
assertz(versucht(A,H)), /* Speichern des Versuchs */
weg(H,Z).
wegausgabe(A,Z) :route(A,Z),
write('Von '),write(A),
write(' nach '), write(Z), nl.
wegausgabe(A,Z) :route(A,H),
27
INFORMATIK
a.hermes
write('Von '), write(A),
write(' nach '), write(H),nl,
wegausgabe(H,Z).
run(A,Z) :weg(A,Z), wegausgabe(A,Z).
Übung
Analysieren und teste das Programm!
Bemerkung: Durch Erweiterung des Programms um das Prädikat loesche
Wissensbasis wieder in den Urzustand überführen:
lässt sich die
loesche :repeat, ((retract(versucht(_,_)),fail) ; !),
repeat, ((retract(route(_,_)), fail); !).
28
INFORMATIK
a.hermes
2.6.3 Schatzsuche
Circus
Garten
Eingang
Dom
Schlangengrube
Quelle
Drachen
Ausgang
Schatz
In einem Höhlensystem ist ein Schatz verborgen. Dieser ist vom Eingang aus zu suchen und zum
Ausgang zu transportieren. Es gibt zwei gefährliche Plätze namens „Drachen“ und „Schlangengrube“.
Diese müssen unter allen Umständen gemieden werden. Falls der Ausgang ohne erfolgreiche
Schatzsuche erreicht wird, ist von dort aus erneut zu suchen. Es sind a) ein b) alle möglichen Wege
zu bestimmen. Um Kreise zu vermeiden, sind bereits besuchte Höhlenräume im Gedächtnis zu
behalten, das mit Hilfe einer Liste zu realisieren ist.
Lösungsidee
Das Höhlensystem lässt sich durch die Angabe der Verbindungen und der zu vermeidenden Räume
charkterisieren. Man beachte, dass eine Verbindung keine Einbahnstraße ist.
(1) Verbindungen sind als Fakten mit dem Prädikatsnamen verbindung darzustellen.
(2) Plätze oder Hallen liegen benachbart (benachbart(X,Y)), wenn eine Verbindung zwischen
ihnen besteht.
(3) Drachen und Schlangengrube sind zu vermeiden:
meide([drachen, schlangengrube]).
(4) Bei der Wegesuche sind Kreise zu vermeiden. Zur Vorsorge wird eine Liste bereits besuchter
Plätze angelegt, dazu gehört auf alle Fälle der jeweilige Startpunkt. Die richtige “Route“ ist
diejenige, welche den Startpunkt nicht mehrmals enthält (gehe(Von,Nach)
:weg(Von,Nach,[Von]).).
Die Abfrage beginnt mit : ?- gehe(eingang,ausgang).
(5) Das Erreichen des Ausgangs ist erfolgreich, wenn die Schatzkammer auf der Liste der
besichtigten Räumen steht (weg(ausgang,ausgang,Raumliste) :- ...). Nun kann die
Liste der besuchten Plätze bzw. Räume ausgegeben werden.
29
INFORMATIK
a.hermes
(6) In allen anderen Fällen führt der Weg über einen Nachbarraum, der nicht zu den gefährlichen
Räumen gehört, die zu meiden sind und noch nicht besucht worden ist (weg(Platz, Ausgang,
Raumliste) :- ...).
(7) Ein Element ist in einer Liste enthalten, wenn es mit dem Listenkopf übereinstimmt oder im Rest
der Liste enthalten ist (enthalten).
(8) Bei der Ausgabe der Raumliste ist zu beachten, dass sie umgekehrt ausgegeben werden muss,
das Ziel steht am Anfang (zeigeliste(L) ...)!
Lösungsanfang
verbindung(eingang,dom).
verbindung(eingang,drachen). /*1 */
verbindung(dom,circus). verbindung(dom,garten).
verbindung(dom,quelle). verbindung(dom,schlangengrube).
verbindung(drachen,schatz). verbindung(quelle,schatz).
verbindung(schatz,ausgang). verbindung(garten,schlangengrube).
verbindung(garten,schatz).
verbindung(garten,ausgang).
verbindung(schlangengrube,ausgang).
benachbart(X,Y) :- verbindung(X,Y) ; verbindung(Y,X). /* 2 */
Aufgabe 8
Löse die Schatzsuche in Anlehnung an das beschriebene Verfahren.
2.6.4 Graph als Funktor*
Ein Graph kann als Paar von zwei Mengen beschrieben werden, der Menge von Knoten und der
Menge von Kanten. In gewichteten Graphen werden den Kanten Bewertungen (Kosten) zugeordnet.
Alternativ zur Definition durch Fakten besteht die Möglichkeit, den Graph mit Hilfe eines Funktors wie
z.B. graph zu spezifizieren.
Beispiel:
graph([a,b,c,d,e,f],[k(a,c,3),k(a,b,6),k(c,b,4),k(b,d,3),k(d,f,4,
k(d,e,5),k(e,f,3)]).
4
D
C
4
3
A
3
B
6
F
3
5
E
Es ergeben sich Aufgabenstellungen, wie die Suche nach Verbindungen mit minimalen Kosten
zwischen zwei Knoten oder kürzeste Wege in Graphen.
30
INFORMATIK
a.hermes
2.7 Ein einfacher Interpreter mustergesteuerter Programme*
Von Pascal her ist das Verfahren bekannt, dass sich Module oder Prozeduren gemäß einer explizit
festgelegten Vorschrift bzw. eines vordefinierten Schemas aufrufen. Jedes Modul entscheidet,
welches andere es aufruft. Der entsprechende Kontrollfluss ist deterministisch, d.h. zu jeder
Programm- und Speichersituation gibt es (höchstens) genau eine Folgesituation.
Mustergesteuerte Programme zeichnen sich einerseits durch einen möglichen Nichtdeterminismus
aus, die Besonderheit liegt aber vor allem im Mechanismus des Aufrufs von Programm-Modulen, die
nicht direkt, sondern aufgrund von Prädikatsmustern im aktuellen Datenraum (z.B. der Wissensbasis)
aktiviert werden. Das Beispiel “Symbolisches Differenzieren“ vermittelte einen Eindruck von
musterorientierter Wissensrepräsentation, ähnlich lassen sich Bedingungsmuster (Wenn-Dann-Bedingungen) definieren.
Die entsprechenden Regeln sind charakterisiert durch:
(1) ein Vorbedingungsmuster und
(2) eine Aktionsfolge, die ausgeführt wird, wenn das Muster passt bzw. die Vorbedingung erfüllt ist.
Beispiel GGT
(siehe auch [1], Bratro, Seiten 424 ff)
Der größte gemeinsame Teiler zweier Zahlen a und b ggt(a,b) ist nach Euklid gleich
ggt(a,b) =
ggt(b,a) , falls a < b,
ggt(a - b, b)
, falls a > b,
a
sonst.
Der entsprechende mustergesteuerte Ansatz lautet:
Regel 1
Bedingung:
Aktion:
Die Wissensbasis enthält zwei Zahlen a und b, mit a > b
Ersetze in der Wissensbasis a durch a-b
Regel 2
Bedingung:
Aktion:
Die Wissensbasis enthält eine Zahl
Gib die Zahl aus und beende alle Aktionen
Hier tritt aufgrund eines scheinbaren Nichtdeterminismus deutlich ein Konflikt zutage, denn jedes Mal,
wenn die Bedingung in Regel 1 erfüllt ist, trifft dies auch für Regel 2 zu. Für eine Konfliktlösung sorgt
die Kontrollregel, dass Regel 1 immer Regel 2 vorgezogen wird, d.h. in Prolog ist die Reihenfolge der
Definitionen entscheidend.
31
INFORMATIK
a.hermes
Die Kontrolle des Programmierers reduziert sich in diesem sehr einfachen Fall auf die Anordnung der
Regel. Das Prologsystem verwendet als Kontrollmechanismus die Rückwärtsverkettung, also die
Technik, die Behauptung durch rückwärtiges Beweisen der Teilziele (subgoals) zu beweisen.
Für die Auswahl des Kontrollmechanismus ist der sog. “Planer“ (Scheduler) zuständig. Er bildet
zusammen mit dem Regelinterpretierer das Kernstück einer Inferenzmaschine, einer Maschine zur
Simulation von menschlichen Denkprozessen bei der Lösung abstrakter Probleme.
Beispiel: Die Wissensbasis enthalte die Zahlen 18, 12 und 21.
18
6
6
6
6
3
12
12
6
6
6
6
21
21
21
3
3
Die Zahlen in Konturschrift weisen auf die jeweiligen Änderungen in der Wissensbasis hin. Die
Wissensbasis enthält am Schluss dreimal die gleiche Zahl, den ggT. Das Beispiel demonstriert wie
der Lösungsansatz nicht nur den größten gemeinsamen Teiler zweier Zahlen, sondern beliebig vieler
Zahlen bestimmt.
Am Anfang enthält die Wissensbasis die Fakten:
zahl(18).
zahl(12).
zahl(21).
Prolog bietet die Möglichkeit, Fakten oder Regeln in einer Liste zu sammeln und sie der Reihe nach
zu beweisen oder auch “aufzurufen“ (call(Klausel), s.u.). Man packe also die jeweiligen Bedingungen
in eine Liste, ebenso die resultierenden Aktionen. Eine Liste von Bedingungen impliziert eine
Aktionsliste und damit eine Menge von Zielen, die erfüllt werden, wenn die Vorbedingungen stimmen.
Als Folgerungszeichen verwende man “==>“.
Allgemein:
Bedingungsteil ==> Aktionsteil
wird überführt in:
[1.Bedingung, 2.Bedingung ...] ==> [1.Aktion, 2.Aktion,...]
In Worten: Falls alle in der Liste vermerkten Bedingungen erfüllt sind, werden sämtlichen Aktionen
ausgeführt.
Produktionsregeln zum Finden des ggT:
[zahl(A),zahl(B),A > B] ==>[C is A - B,ersetze(zahl(A),zahl(C))].
[zahl(A)]
==>[write('ggt = '),write(A), nl, ende].
Prädikate, wie ersetze oder das Atom ende seien dem Regelinterpretierer des mustergesteuerten
Programms vorbehalten. Seine Aufgabe ist der Prozess des Schließens (Inferierens) auf Basis der
formalen Logik. Durch Anwendung einfacher “Wenn-Dann-Regeln“ auf bekannte Fakten führt er die in
32
INFORMATIK
a.hermes
den Regeln festgelegten Aktionen aus. Dabei hat er die Möglichkeit des Zugriffs und der Manipulation
der Daten- und der Wissensbasis.
:- op(800, xfx, ==>).
/*In Fix-Prolog nur als Ziel eingeben: ?- op(800, xfx, ==>). */
interpretiere :Bedingung ==> Aktionsfolge,
pruefe( Bedingung),
veranlasse( Aktionsfolge).
pruefe([]).
/*die leere Bedingung ist immer erfüllt*/
pruefe([Bed1 | Weitere]) :/* konjunktive Bedingungen*/
call(Bed1),
/* prüfe Bed1 */
pruefe(Weitere).
veranlasse([ende]) :- !.
/* Ende der Ausführungen */
veranlasse([]) :interpretiere.
/* keine Aktion, nächste Regel */
veranlasse( [Aktion1 | Rest]) :call(Aktion1),
/* Aktiviere Aktion1 */
veranlasse( Rest).
/* Manipulationsmöglichkeit(en) der Datenbasis */
ersetze( A,B) :retract( A),
!,
/*! heißt: nur ein Element löschen */
assert(B).
Klauseln, die in Programmen aufgerufen werden, müssen in vielen Prolog-Implementationen mit Hilfe
des Prädikats call aktiviert werden: call(Klausel).
Analyse des Beispiels
Prinzipiell könnten auch mehrere Module aufgrund eines Vorbedingungsmusters gleichzeitig aktiviert
werden. Es handelt sich hier also um ein natürliches Modell paralleler Prozesse. Es ist sogar
grundsätzlich möglich, einige Module zu entfernen oder nachträglich hinzuzufügen, ohne dass das
System zusammenbricht, lediglich die Art des Problemlösens könnte sich ändern, denn die Module
ändern nicht die Steuerung, nicht die dafür zuständigen Muster.
Bei Systemen mit komplexen Wissensbasen lassen sich kaum von vornherein alle möglichen
Interaktionen zwischen den einzelnen Wissenteilen vorhersagen. Es erweist sich als günstiger,
“Wenn-Dann-Regeln“ selbst als mustergesteuerte Module zu betrachten.
Bei paralleler Verarbeitung ergibt sich folgender Zyklus:
33
INFORMATIK
a.hermes
(1) Suche in der Wissensbasis alle Fakten, welche ein Bedingungsmuster erfüllen. Die Menge aller
daraus resultierenden Aktionen bilden die Konfliktmenge. Man nennt den Vorgang “Pattern
Matching“ (Prüfen, ob das Muster passt).
(2) Alle Aktionen sind auszuführen, d.h. die entsprechenden Module sind zu aktivieren.
Bei Systemen mit traditionellen, sequentiell arbeitenden Prozessoren muss vor Ausführung der
Aktionen eine sog. Konfliktauflösung stattfinden. Die Zuständigkeit hat eine Steuerkomponente,
welche die Auswahl von Modulen übernimmt. Prolog löst den Konflikt durch jeweilige Wahl des zuerst
auftretenden Moduls. Der Nichtdeterminismus äußert sich darin, dass prinzipiell irgendein passender
Modul aufgerufen werden kann.
Man verwechsle Determinismus nicht mit Determinierung, bzw. dem selbständigen Abbruch einer
Anweisungsfolge nach endlich vielen Schritten.
Aufgabe 9
a) Füge im Beispiel ggT (siehe Seite 24) zwischen den Regeln 1 und 2 folgende Regel 1-2 ein,
erläutere die Bedeutung, und teste das entsprechende Prologprogramm:
Regel 1-2
Bedingung:
Aktion:
Die Wissensbasis enthält zwei gleichgroße Zahlen
Lösche eine der Zahlen aus der Wissensbasis
b) (zur Wiederholung von Rekursion)
Schreibe Klauseln zur Bestimmung des größten gemeinsamen Teilers zweier Zahlen, allerdings ohne
Verwendung eines Regelinterpreters.
2.8 Expertensysteme
2.8.1 Komponenten von Expertensystemen
Expertensysteme sind Programme, die in einem begrenzten Problembereich die Denkprozesse und
Schlussfolgerungen menschlicher Experten nachbilden können. Sie stellen Fragen (Interaktion mit
dem Benutzer) , folgern aufgrund von Wissensbasen (Inferenzkomponente) und durch Interpretation
von Regeln (Regelinterpreter), erklären Folgerungsprozesse (Erklärungskomponente, Wie und
34
INFORMATIK
a.hermes
Warum), erwerben neues Wissen und können mit Unsicherheiten und unvollständigem Wissen umgehen.
Die folgende Abbildung stellt die Komponenten eines Expertensystems dar:
Wissensbasis
- Fakten
Inferenzmaschine
- Regeln
Benutzerschnittstelle
Benutzer
- evtl. Ideen
Expertensystem-Shell
Die Komponenten von Expertensystemen sind
(1) eine Wissensbasis
- Fakten
- Regeln
(2) eine Inferenzmaschine
- Regelinterpreter
- Scheduler (Planer)
- Wie-Prozessor
(Wie wurde ein Ergebnis gefunden, anhand welcher Regeln und Fakten?)
- Warum-Prozessor (Warum wird eine bestimmte Frage an den Benutzer gestellt?)
- Unbestimmtheitsprozessor (Wie sicher sind die Schüsse?)
- Schnittstelle zur Wissensbasis
(3) eine Benutzerschnittstelle
Festlegung der Wissensbasis durch Fakten und Produktionsregeln
Eine einfache Technik zur Darstellung von Wissen sind bedingte Anweisungen, die auch Wenn-DannRegeln oder Produktionsregeln genannt werden. Die Technik erweist sich für kleine Expertensysteme
als durchaus leistungsfähig. Weitere Stichpunkte zur Wissensrepräsentation sind Frames, Scripts und
semantische Netzwerke, die hier allerdings nicht problematisiert werden. Produktionsregeln lassen
sich unterschiedlich interpretieren, z.B.
- wenn Vorbedingungen erfüllt sind, dann sind Folgerungen zu ziehen
- wenn eine Situation vorliegt, dann sind Aktionen auszuführen
- wenn bestimmte Bedingungen gelten, dann sind eventuell weitere erfüllt
Beispiel aus der Medizin
Wenn es sich bei einer erkrankten Person um ein Kind handelt, keine stark erhöhte Temperatur
vorliegt und der Körper schwachroten Ausschlag zeigt, können Röteln vorliegen.
Die allgemeine Struktur ist gegeben durch
Wenn Bedingung B, dann Folgerung F mit Sicherheit W.
Das Beispiel demonstriert einen äußerst sensiblen und gesellschaftsrelevanten Bereich. Wer möchte
sich schon alleine auf die Diagnose eines Computers verlassen? Die Ausdrucksweise, dass Röteln
35
INFORMATIK
a.hermes
vorliegen können, schließt kategorische Fragen, d.h. Fragen, die ausschließlich mit ja oder nein
beantwortet werden können, aus. Die medizinische Diagnose ist ein typisches nichtkategorisches
Expertengebiet.
Das folgende Beispiel entstammt den Bereichen der Diagnose und Reparatur. Die Wissensbasis ist
äußerst klein, nichtsdestoweniger eignet sie sich zur Demonstration der Schlussweise und des
Verhaltens von mächtigeren Expertensystemen. Solche Systeme ähneln in der Wissensstruktur den
Diagnosesystemen, sie bieten allerdings häufig die zusätzliche Fähigkeit, Entscheidungen zu planen
und zu koordinieren. Ein typisches Beispiel ist die Computerwartung.
2.8.2 Diagnose von Fehlern am Auto
Angenommen, Ihr Wagen springt nicht an. Sie rufen bei Ihrer Werkstatt an und schildern das
Problem. Sie werden mit einem Experten der Werkstatt verbunden, der durch gezielte Fragestellung
die Ursache des Defektes einzugrenzen versucht. Er versucht herauszufinden, ob er Treibstoff
mitbringen soll oder Überbrückungskabel für die Batterie, oder ob er z.B. beim Defekt der Glühkerzen
den Wagen zur Werkstatt schleppen muss.
Die wesentlichen Fragen und Antworten bei dem Gespräch könnten z.B. sein:
(K = Kunde, E = Experte)
K: „Mein Wagen springt nicht an, können Sie mir bitte helfen?“
E: „Funktioniert das Licht?“
K: „Ja, das Licht funktioniert.“ (Die Batterie ist also in Ordnung!)
E: „Ist kein Treibstoff vorhanden? Schauen Sie bei eingeschalteter Zündung auf die Tankanzeige!“
K: „Die Tankanzeige meldet genügend Treibstoff.“
E: „Ist der Wagen ein Dieselfahrzeug?“
K: „Ja.“
E: „Möglicherweise sind die Glühkerzen defekt.“
Der Experte rät, den Wagen zur Werkstatt abzuschleppen, um den Schaden dort zu beheben.
Von einem Expertensystem erwartet man ein ähnliches Frage- und Schlussfolgerungsverhalten wie
von einem menschlichen Experten. Im „Gespräch“ mit dem Computer erweitert das System aufgrund
Ihrer Antworten seine Wissensbasis. Die Antworten sind Fakten, die das System zur eventuellen
späteren Verwendung bei Schlussfolgerungen im Arbeitsspeicher zwischenlagert.
Lösungsansatz in Prolog
Die oben beschriebene Fragefolge und die Schlussfolgerung könnten aufgrund folgender Regel
entstanden sein:
regel(3,hat(defekteGluehkerzen,ja),
[ist(diesel,ja),
hat(defekteBatterie, nein), /* Hier steckt die Frage nach dem Licht */
hat(treibstoff, ja),
reagiert(springtan, nein)]).
36
INFORMATIK
a.hermes
Die Regel repräsentiert Wissen und steuert gleichzeitig durch einen Bedingungsteil ein Fragemuster
zur Überprüfung der Bedingungen.
Der folgende Ansatz versucht eine Trennung der Komponenten eines Expertensystems, soweit sie in
dem kleinen Rahmen möglich sind. Regeln erhalten ein einheitliches Format.
Den Kopf bildet das Prädikat namens regel. Es enthält u. a. als Argument die Regelnummer, die zur
Beantwortung von Wie-Fragen nützlich sein kann. Es folgt ein Prädikat zur Beschreibung eines
Defektgrundes und eine Liste von Folgerungen, die ein solcher Defekt hervorruft. Die Folgerungen
werden vom Kunden abgefragt und sind aufgrund der Antworten als Fakten mit dem Prädikatsnamen
fakt in die Wissensbasis im Arbeitsspeicher aufzunehmen. Der Behandlung von Verneinung dient
bei Fakten das Wort „nein“ während „ja“ das Gegenteil beschreibt.
hat(defekteBatterie,nein) bedeutet, dass die Batterie in Ordnung ist. Falls dies nicht bestätigt
werden kann, schließt das System auf das Gegenteil (negation as failure), also darauf, dass die
Batterie defekt ist.
Wie im Fragebeispiel demonstriert, fragt der Experte allerdings nicht, ob die Batterie defekt ist,
sondern, ob das Licht funktioniert und zieht daraus seinen Schluss auf die Qualität der Batterie. Er
stuft die direkte Frage nach der Beschaffenheit der Batterie offensichtlich als nicht zumutbar bzw.
nicht direkt entscheidbar für die Kundin oder den Kunden ein.
Die Wissensbasis des Expertensystems lautet:
fakt(f(a,a)).
/*Form von Fakten im Arbeitsspeicher, z.B. fakt(hat(licht,ja)).*/
regel(1, hat(treibstoff, nein),
[reagiert(springtan, nein),
hat(licht, ja),
zeigt(tankleer, ja)]).
regel(2,hat(defekteBatterie,ja),
[hat(licht, nein),
regel(3,hat(defekteGluehkerzen,ja),
[ist(diesel,ja),
hat(defekteBatterie, nein), /*alternativ: hat(licht, ja) */
regel(4,hat(defekteZuendkerzen,ja),
[ist(diesel, nein),
hat(defekteBatterie, nein),
Die Wissensbasis soll sich einerseits nach Gründen für das Auftreten von Defekten befragen lassen,
andererseits soll man sich vermutete Gründe bestätigen lassen können. Die Ziele nenneGrund und
beweise dienen der Befragung.
37
INFORMATIK
a.hermes
Mögliche Kommunikationsbeispiele
?- nenneGrund(reagiert(springtan,nein),Grund).
Funktioniert das Licht? (ja/nein.) ja.
Zeigt die Tankanzeige einen leeren Tank an? (ja/nein.) nein.
Ist der Wagen ein Diesel? (ja/nein.) ja.
Grund = hat(defekteGluehkerzen,ja)
Vor der nächsten Befragung ist die Wissensbasis neu zu initialisieren:
reconsult(meinFile).
?- beweise(hat(defekteZuendkerzen,ja)).
Ist der Wagen ein Diesel? (ja/nein.) nein.
Funktioniert das Licht? (ja/nein.) ja.
Springt der Wagen an? (ja/nein.) nein.
Zeigt die Tankanzeige einen leeren Tank an? (ja/nein.) nein.
bestätigt
yes
Die Ziele „nenneGrund“ und „beweise“ sind wie folgt charakterisiert:
nenneGrund(Fakt, Warum) :asserta(fakt(Fakt)),
/* Fakt speichern */
regel(RegelNr,Warum,Bedingungen), /* Regel aufrufen */
enthalten(Fakt,Bedingungen),
/* Falls der Fakt Teil der Bedingungen, */
pruefe(RegelNr,Bedingungen),
/* sind die Bedingungen zu testen */
!.
beweise(Defekt) :regel(Nr,Defekt,Bedingungen),
/* Suche entsprechende Regel */
pruefe(Nr,Bedingungen), write('bestätigt').
/* Überprüfe die Bedingungen */
Das Prädikat enthalten überprüft, ob ein Fakt in einer Liste von Bedingungen einer Regel enthalten
ist:
enthalten(Fakt,[]) :- !, fail.
enthalten(Fakt,[Fakt|R]) :-!.
enthalten(Fakt,[B|R]) :enthalten(Fakt,R).
/* enthalten(Fakt,[_,R] :- */
Das Ziel pruefe ist erfüllt, wenn alle Fakten oder auch Regeln im Bedingungsteil einer Regel
bestätigt werden können:
/* Prüfe, ob alle Bedingungen der Liste erfüllt sind */
pruefe(RegelNr,[]).
pruefe(RegelNr,[F1|Fakten]) :F1 =.. L,
38
INFORMATIK
a.hermes
bestaetige(RegelNr,L),!,
pruefe(RegelNr,Fakten).
Es existieren drei Arten von zu bestätigenden Bedingungen:
1) Fakten, die bereits im Arbeitsspeicher mit dem Prädikatsnamen fakt vermerkt sind,
2) Fakten, die vom Benutzer des Systems erfragt werden müssen,
3) Regeln, die selbst wieder zu bestätigen sind.
zu 1)
Falls eine Frage bereits beantwortet worden ist, befindet sich das Ergebnis im Arbeitsspeicher als
Fakt, z.B. fakt(hat(licht,nein)). Das System erkennt das Vorliegen eines Faktes, wenn
Prädikat (hat) und Objekt (licht) übereinstimmen. Bei Übereinstimmung der ja-nein-Komponente
mit der Antwort ist das Ziel erfüllt, sonst nicht. In jedem Fall ist zu verhindern, dass die nächste
Klausel gleichen Namens getestet wird. Der Klauselkopf hat die Form:
bestaetige(Nr,[P,Frage,B]) :....
/* liegt bereits als Fakt vor */
zu 2)
Die Schnittstelle zum Benutzer ist ein Katalog von Fragen zur Überprüfung gewisser Fakten:
fragbar(springtan, 'Springt der Wagen an').
fragbar(licht, 'Funktioniert das Licht').
fragbar(tankleer, 'Zeigt die Tankanzeige einen leeren Tank an').
fragbar(diesel, 'Ist der Wagen ein Diesel').
Die zweite Klausel zu bestätige stellt zu einem Objekt gegebenenfalls die entsprechende Frage
und trägt das Ergebnis in den Arbeitsspeicher ein. Das ursprüngliche Ziel gilt als erfüllt, wenn die
Antwort mit der jeweiligen Hypothese übereinstimmt:
bestaetige(RegelNr,[P,Frage,B]) :- /* es soll gefragt werden */
fragbar(Frage, Text),!,
.....
zu 3)
Den dritten Fall beschreiben folgende Klauseln:
/* Bestätige, dass eine Bedingung erfüllt ist oder auch nicht */
bestaetige(_,[P,Frage,B]) :/* Regelueberpruefung */
T1 =.. [P,Frage,Bool],
/* Bestätigung pos/neg*/
regel(Nr,T1,Liste),
asserta(fakt(T1)),
pruefe(Nr,Liste),!,
gleich(B,Bool).
bestaetige(_,[P,Frage,B]) :T1 =.. [P,Frage,Bool],
fakt(T1),
retract(fakt(T1)),
kontra(Bool,Bk),
T2 =.. [P,Frage,Bk],
/* Regelueberpruefung */
/* Fehlschlag */
39
INFORMATIK
a.hermes
asserta(fakt(T2)), gleich(Bk,B).
gleich(A,A).
kontra(ja,nein).
kontra(nein,ja).
/* Testaufrufe: */
go(X) :- nenneGrund(reagiert(springtan,nein),X).
do :- beweise(hat(defekteZuendkerzen,ja)).
Aufgabe 10
a) Vervollständige das Programm durch die Fälle 1) und 2), und testen Sie die Aufrufe go(Grund)
und do. Nach dem Aufruf von go(Grund) muss reconsult eingegeben werden.
b) Erweitere das Expertensystem um einen „Warum-Prozessor“, der bei Eingabe von wieso. angibt,
warum die jeweilige Frage an den Benutzer gestellt wird. Der Grund ergibt sich aus dem zweiten
Argument der jeweiligen Regel. Weisen Sie andere Benutzereingaben als ja, nein oder wieso
zurück!
c) Erweitere das Expertensystem um einen „Wie-Prozessor“, der begründet, warum ein
diagnostizierter Defektgrund gilt. Der Einfachheit halber soll lediglich der Bedingungsteil (das ist eine
Liste) der entsprechenden Regel ausgegeben werden.
2.9 Eine kleine Logelei*
„Meiers werden uns heute Abend besuchen“, kündigt Herr Müller an. „Die ganze Familie, also Herr
und Frau Meier nebst ihren drei Söhnen Rainer, Stefan und Thomas?“ fragt Frau Müller bestürzt.
Darauf Herr Müller: „ Nein, ich will es dir so erklären: Wenn Vater Meier kommt, dann bringt er auch
seine Frau mit. Mindestens einer der beiden Söhne Stefan und Thomas kommt. Entweder kommt
Frau Meier oder Rainer. Entweder kommen Rainer und Stefan oder beide nicht. Wenn Thomas
kommt, dann auch Stefan und Herr Meier. So, jetzt weißt du, wer uns heute Abend besuchen wird.“
(Entnommen aus [7], Jehle, Seite 106, Aufgabe 5)
Folgende Bedingungen sind zu erfüllen:
1) Falls Herr Meier kommt, kommt auch Frau Meier
falls(HerrMeierKommt, FrauMeierKommt)
2) Mindestens einer der beiden Söhne Stefan oder Thomas kommen
oder(StefanKommt, ThomasKommt)
3) Entweder kommt Frau Meier oder Rainer
entwederOder(FrauMeierKommt, RainerKommt)
4) Entweder kommen Rainer und Stefan oder beide nicht
RainerKommt = StefanKommt
5) Wenn Thomas kommt, dann auch Stefan und Herr Meier
falls(ThomasKommt, und(StefanKommt, HerrMeierKommt))
40
INFORMATIK
a.hermes
Lösung in Prolog:
und(wahr,wahr).
oder(wahr,wahr).
oder(wahr,falsch).
oder(falsch,wahr).
falls(wahr,wahr).
falls(falsch,_).
entwederOder(A,B) :oder(A,B),
not(und(A,B)).
zuBesuch(HerrMeierKommt,FrauMeierKommt,RainerKommt,
StefanKommt,ThomasKommt) :falls(HerrMeierKommt, FrauMeierKommt),
oder(StefanKommt, ThomasKommt),
entwederOder(FrauMeierKommt, RainerKommt),
RainerKommt = StefanKommt,
falls(ThomasKommt, und(StefanKommt, HerrMeierKommt)).
?- zuBesuch(V,M,R,S,T).
V = falsch, M = falsch, R = wahr, S = wahr, T = falsch
Es kommen demnach lediglich Rainer und Stefan.
41
INFORMATIK
a.hermes
Glossar
Anonyme Variable (_) eine =>Variable, deren Wert nicht zugreifbar ist
assert(K) fügt eine Klausel K in die Datenbasis ein (Prolog, asserta, assertz)
Aussagenlogik Formales logisches System zur Darstellung und Verknüpfung von Aussagen über
Objekte. Aussagenlogik verwendet keine Variablensymbole. Sie ist vor allem in der Schaltalgebra von
praktischer Bedeutung.
Backtracking Eine von Prolog verwandte Kontrollstrategie. Nach dem Misserfolg eines Ziels löst sie
alle Variablenbindungen bis zu dem Ziel, das als letztes abgearbeitet worden ist und für das noch
Klauseln existieren, die möglicherweise zu einer alternativen Lösung des Ziels führen.
Binden Zuweisung eines Wertes an eine Variable
call(P) Aufruf einer => Prozedur (Prolog)
CUT (!) Ein Operator zur Unterbindung von Rückverfolgung beim Beweis von Klauseln
consult(D) liest eine Datei D von Prozeduren in die Datenbasis ein
Datenbasis => Wissensbasis von Prolog
Deklarative Sprache Eine Programmiersprache, bei der durch Angabe von Fakten und Regeln
festgelegt wird, was zu lösen ist, nicht wie etwas zu lösen ist.
Diagnosesystem Ein Expertensystem zur Lösung diagnostischer Probleme
Expertensystem Computerprogramme, die in Schlussfolgerung und Wissensanwendung
menschliches Denkverhalten simulieren.
Expertensystemschale (auch Expertensystemshell) Ein Werkzeug zur Erzeugung von
Expertensystemen ohne Wissensbasis. Sie besteht aus einer Inferenzmaschine mitSchnittstellen zur
Wissensbasis und zum Benutzer.
fail Ein Standardoperator von Prolog zur Erzwingung von Rückverfolgung
Fakt Eine wahre Aussage über ein oder mehrere Objekte
Goal (Ziel) Ein in Prolog zu lösendes Problem
Inferenz Prozess des Schließens aus Fakten und Regeln
Inferenzmaschine Komponente (Folgerungsmechanismus) eines Expertensystems
integer(X) Ein Ziel, das wahr ist, wenn X eine ganze Zahl repräsentiert (Prolog)
X is A bestimmt den Wert des Ausdrucks a und => unifiziert ihn mit X (Zuweisung)
Klausel => Fakt oder => Regel, lexikalischer Geltungsbereich von Variablennamen
Prozedur in Prolog eine Menge von Klauseln mit gleichem Prädikatsnamen
read(T) liest einen Term T von der Eingabe ein. Der Term wird lexikalisch und syntaktisch analysiert.
Die Eingabe ist mit einem Punkt zu schließen.
reconsult(D) liest eine Datei D von Prozeduren in die Datenbasis ein und löscht vorher alle
Prozeduren mit gleichen Namen und Stelligkeiten
Regel Eine Klausel, die Beziehungen zwischen Fakten darstellt
42
INFORMATIK
a.hermes
retract(K) löscht die erste mit K identifizierbare( unifizierbare) Klausel K der Datenbasis
Rückwärtsverkettung Kontrollstrategie, die vom Zielzustand aus ein Ziel zu beweisen versucht
Unifizieren Ersetzen, Terme zur Übereinstimmung bringen bzw. identisch machen
Variable Ein Name, dem ein Wert zugeordnet werden kann
Vorwärtsverkettung Kontrollstrategie, die von einer Annahme beginnend ein Ziel zu beweisen
versucht
Wissensbasis in Prolog (Datenbasis) Zusammenfassung von Fakten und Regeln
write(T) gibt einen Term an der Ausgabeeinheit aus
Ziel => Goal
Literaturverzeichnis
[1] W.F.Clocksin C.S.Mellish
Programming in Prolog
Springer-Verlag
Berlin, Heidelberg, New York, Tokio 1984
[2] Fevzi Belli
Einführung in die logische Programmierung mit Prolog
BI-Hochschultaschenbücher
Mannheim,Wien,Zürich 1986
[3] Ivan Bratko
PROLOG
PROGRAMMIERUNG FÜR KÜNSTLICHE INTELLIGENZ
Addison-Wesley
Wokingham 1986
[4] F.Giannesini/H.Kanoui/R.Pasero/M.van Caneghem
Prolog
Addison-Wesley
Paris 1985
[5] M. Hanus
Problemlösen mit PROLOG
B.G.Teubner Stuttgart 1986
[6] Keith Weiskamp, Terry Hengl
KI-Programmierung mit Turbo Prolog
McGrawHill, Hamburg 1989
[7] Franz Jehle
43
INFORMATIK
a.hermes
Boolesche Algebra
BSV
München 1973
[8] Markus Lusti
Wissensbasierte Systeme
Algorithmen, Datenstrukturen und Werkzeuge
BI-Wissenschaftsverlag
Mannheim. Wien, Zürich 1990
Prolog-Version
Die Prolog-Version entspricht dem Standard von
[1] W.F.Clocksin C.S.Mellish
Die Unterrichtsreihe lehnt sich an die 1992 von Alfred Hermes in INORMATIK Betrifft Uns beim
Bergmoser Höller-Verlag veröffentlichte Arbeit an.
44
PROLOG-Arbeitsheft
Von der Datenbank zum Expertensystem
Index
Ahnentafel 3
Aktionsteil 26
Arithmetik 9
assert 12
Ausdruck 10
Backtracking 6,7
Bedingungsteil 26
Benutzerschnittstelle 28, 32
call 20, 26
cut 7,9, 11
deklarativ 3, 6,18
Determinismus 24
Diagnose 29
Disjunktion 5
Erklärungskomponente 28
Expertensysteme 28
Expertensystemshell 28
fail 8,11
Fakten 3, 19, 28
Fakultät 10
Fibonacci 11
filter 20
Fragen 4
Fragen, kategorische 29
funktional 19
Funktor 4, 24
GGT 25, 27
goal 6
Graph 24
imperativ 18
Inferenzmaschine 21, 28
integer 13
Interpreter 24
is 10
Klausel (clause) 5
Kommentare 5
INFORMATIK
BETRIFFT UNS
Konfliktlösung 25
Konfliktmenge 27
Konjunktion 5
Konstanten 13
Kontrollregel 25
Kontrollstrategien 21
Kopf 5
Künstliche Intelligenz 2,3
Liste 15, 19
Listenoperationen 15, 16, 19
listing 11, 19
Logelei 33
Logische Programmierung 3
mapping 20
match 8,10
Menge 17
mustergesteuert 24, 25
Musterorientierung 12,13
Nichtdeterminismus 25, 27
Objekt 4
op 13
Operatoren 10, 13, 20
Parallele Prozesse 27
passen 8,10
Permutation 17
Planer 25
Prädikat 4
Primzahlen 12
Produktionsregeln 28
Prolog 2,3
prozedural 2, 3,6
Quadrat 10, 11
Quicksort 19
read 10
Regelinterpretierer 25
Regeln 5
45
PROLOG-Arbeitsheft
Von der Datenbank zum Expertensystem
INFORMATIK
BETRIFFT UNS
Rekursion 9
retract 12
Rückwärtsverkettung 7,21
Rumpf 5
Schatzsuche 24
Scheduler 26
Sortieren durch Mischen 19
Symbolisches Differenzieren 11
Teilziele 26
Terme 21
Termvereinfachung 15
Tiefensuche 7
Türme von Hanoi 10
Variablen 4
Vergleich 6
Vorwärtsverkettung 23
Wenn-Dann-Regeln 26
Wissensbasis 3,4, 26, 28, 30
Wurzelnachbarn 11
Zählen 11
Ziel (goal) 6
46

Von der Wissensbasis zum Expertensystem

Transcrição

Documentos relacionados

7.Übung zur Vorlesung Künstliche Intelligenz

Skript zum Prolog-Tutorium, verfasst von Dipl.

Teil 4: Rekursion und Listen

ROTA-SORTER®-Systeme bei Hermes Versand Service

Merkur Jubiläumsbroschüre

2. Minnesang - Universität Freiburg

Model View Controller Pattern - users.etech.haw

Abschlussliste W-K

Die Kosmischen Gesetze

PDF herunterladen

Ergebnisse der Sportfeste

Portugal - Sammelverkehre, Teil- und Komplettladungen

ISO Zertifikat für Hermes Logistik Gruppe Deutschland

Forum - brettschichtholz.de

Forum - brettschichtholz.de

Maschinelles Lernen Skript zur Vorlesung