A Die Syntax von PROLOG - link.springer.com978-3-322-92747-7/1.pdf · Löscht den Term mit der...

Die Syntax von PROLOG 273

A Die Syntax von PROLOG

upper case letter ::= AlB 1 eiD 1 ElF 1 G 1 H 1 I 1 J 1 K 1 L 1 M I N\OIPIQIRISITIUIVIWIXIYI z

lower case letter .. - alb 1 c 1 die 1 f 1 g 1 h 1 i 1 j 1 k 1 1 1 m 1 n\o\p\q\r\s\t\u\v\w\xlyl z

digit .. - 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 19

symbol .. - ! I # I $ I % I A I & I * I ( I ) I - I + I - I { I }1:1"1<1>171-1=1'1 [111;1'1 , I I I· 1/

letter ::= <upper case letter>l<lower case letter>

atom ::= <textual atom> I <symbol atom> I (:-) I (7-) I

textual atom ::= <lower case letter> { <letter>I_I<digit> }ül '{ <letter>l<digit>l<symbol>}~ ,

symbol atom ::= {<symbol> lr

unsigned integer ::= {<digit>}t

integer ::= {+I- }ö <unsigned integer>

real ::= {+I- }ö <unsigned integer>.<unsigned integer> {E<integer> }ö

number ::= <real> I <integer>

primitive ::= <number>l<db..reLnr>

atomic ::= <atom>l<integer>l<real>l<db..ref..nr>

variable ::= <anonymeous variable> I <upper case letter>{ <letter>I_I<digit>}ü I -{ <letter>I_I<digit>}i

anonymeos variable ::= _

274 Die Syntax von PROLOG

structure ::= <functor>1 <functor>( {<argument>}, i )

argument ::= <structure>1 <atomic> 1 <variable> 1 <operation> 1 <list>

functor ::= <textual atom> 1 <symbol atom> 1 <operator>

operation ::= <predefined operation>1 <user defined operation>

operator ::= <predefined operator> 1 <user defined operator>

predefined operator ::= + 1

» 1 1\ cos 1 tan

loglO 1-- >

1 * 1 mod 1 1 1 \1 1 \ i abs 1 asin 1 acos 1 atan 1 ?- 1:-

user defined operator ::= <textual atom> I <symbol atom>

fact ::= <user defined structure>

1/1 I« 1 1 sqrt 1 sin 1 1 exp 1 log 1

user defined structure ::= <structure> so daß der Funktor und die Stellenzahl der Struktur mit keinem Built-in-Prädikat bzgl. Funktor und Stellenzahl übereinstimmen.

rule ::= <rule head>:- <rule body>

rule head ::= <user defined structure>

rule body ::= {<structure> 1 <variable>l( <rule body>)} {.j;};

quest ion ::=?- {<structure>I<O-structure>}{.j;};

O-structure ::= ({ <structure>I<O-structure>} {.j;};)

program ::= {<fact>.ul<rule>.u}i

q-program ::= {<fact>. u 1 <rule>. u 1 <question>. u}i

term ::= «rule> )1<fact>l( <question> )1 <variable> 1 < atomic> 1 <list>1 <structure> 1 <operation> 1 «program> )1 «q-program> )1 ({ <term>}, i )1 ({<term>}; i )

list ::= [ ] 1 [{ <term>}, i ]

list ::= .( <head>, <tail»

head ::= <term>

tail ::= <list>

ASCII-list ::= "{ <letter> 1 <digit> 1 <symbol> }i "

Die Syntax von PROLOG 275

276 Built-in-Prädikate

B Built-in-Prädikate

Prädikat

X<y X=:= Y X=< Y X =\= Y x>=y x>y x==y x=y x@<y x@=<y x@>=y x@>y X \== Y abolish(F, N) abort append(F)

append(Ll, L2, L3)

argeN, S, A) assert(C) asserta(C)

assertz(C)

atom(T) atomic(T) bagof(X, G, L)

break call(G) clause(K, R)

close(F) compare(C, X, Y) consult(F)

Beschreibung

X ist kleiner als Y (X, Y vom Typ number). X ist gleich Y (X, Y vom Typ number). X ist kleiner oder gleich Y (X, Y vom Typ number). X und Y sind ungleich (X, Y vom Typ number). X ist größer oder gleich Y (X, Y vom Typ number). X ist größer als Y (X, Y vom Typ number). X und Y sind identisch (X, Y vom Typ term). X und Y sind unifizierbar (X, Y vom Typ term). X ist kleiner als Y (X, Y vom Typ term). X ist kleiner oder gleich Y (X, Y vom Typ term). X ist größer oder gleich Y (X, Y vom Typ term). X ist größer als Y (X, Y vom Typ term). X und Y sind nicht identisch (X, Y vom Typ term). Löscht das Prädikat mit Funktor Fund Stelligkeit N. Abbruch der Programmausführung. Das File F wird zum aktuellen Ausgabekanal und der neue Output zum alten Inhalt hinzugefügt. Die Liste L3 entsteht durch Aneinanderhängen von LI und L2. Das N-te Argument der Struktur S ist A. Fügt die Klausel C in die Datensammlung ein. Fügt die Klausel C vor alle Klauseln gleichen Namens und gleicher Stelligkeit in die Datensammlung ein. Fügt die Klausel C hinter alle Klauseln gleichen Namens und gleicher Stelligkeit ein. Der Term T ist vom Typ atom. Der Term T ist vom Typ atomic. Die Sammlung aller Belegungen von X, so daß das Ziel G erfolgreich ist, ist L. Unterbrechung der Programmausführung. Aufruf von Ziel G. Eine Klausel mit Kopf K und Rumpf R ist in der Datensammlung enthalten. Schließt das File F. C ist das Ergebnis des Vergleichs der Terme X und Y. Fügt die Klauseln aus File F zur Datensammlung hinzu (Abkürzung: [Fl, F2, ... J). (Cut) Friert die Entscheidungen einschließlich der Wahl der gerade zu prüfenden Regel ein.

Seite

120 120 120 120 120 120 117 117 117 117 117 117 117 180 164 171

129

150 176 176

176

146 146 192

163 163 183

173 119 175

163

dbJeference(T) debug debugging display(T)

erase(R)

exists(F) faH

freeze_predicates functor(S, F, N) get(C)

getO(C)

halt integer(T) Y is X

leash(M) length(L, N) listing

listing(P)

listing(P jN)

member(T, L) name(A, S) nl

nodebug nonvar(T) nospy P nospy PjN

not(G) number(T) op(V, T, A)

Built-in-Prädikate 277

Der Term T ist eine Database Reference Nummer. Schaltet den Debugger ein. Ausgabe des Debugger-Status. Schreibt den Term T in syntaktisch korrekter Form und Prefix-Notation auf den Ausgabekanal. Löscht den Term mit der Database Reference Nummer R aus der internen Datensammlung. Das File F ist vorhanden. Ist als Ziel immer falsch. (Initiierung eines Backtracking) Einfrieren des derzeitigen Inhalts der Datensammlung. Die Struktur S hat den Funktor F und die Stelligkeit N. Liest das nächste druck bare Zeichen vom Eingabekanal und unifiziert es mit C. Liest das nächste Zeichen vom Eingabekanal und unifiziert es mit C. Beendet den Interpreterlauf. Der Term T ist vom Typ integer. Wertet den arithmetischen Ausdruck X aus und unifiziert das Ergebnis mit Y. Setzt den Leashing-Modus auf M. Die Anzahl der Elemente der Liste List N. Gibt den Inhalt der Datensammlung auf dem Ausgabekanal aus. Gibt die Prädikate mit Namen P auf dem Ausgabekanal aus. Gibt das Prädikat mit Namen P und Stelligkeit N auf dem Ausgabekanal aus. Der Term T ist ein Element der Liste L. Das Atom oder die Zahl A entspricht dem String S. Schreibt das Steuerzeichen für einen Zeilenvorschub auf den Ausgabekanal. Schaltet den Debugger ab. Der Term T ist keine freie Variable. Löscht den Spy-Point der Prädikate mit Namen P. Löscht den Spy-Point vom Prädikat mit Namen P und Stelligkeit N. Das Ziel G ist nicht erfolgreich. Der Term T ist vom Typ number. Macht das Atom A zu einem Operator mit Vorrang V und der durch T spezifizierten Assoziativität und Position.

146 167 168 104

187

173 163

182 148 107

107

164 146 112

168 132 181

182

182

127 142 104

168 146 168 168

163 146 155

278 Built-in-Prädikate

primitive(T) put(C)

read(T)

reconsult(F)

recorda(S, T, R)

recorded(S, T, R)

recordz(S, T, R)

repeat

retract(C)

save(F) see(F) seeing(F) seen setof(T, G, L)

skip(C)

sort(L, S) spy P spy P/N

succ(N, M) system(S)

tab(N) tell(F) telling(F) told trace

Der Term T ist vom Typ number oder db_re/_nr. Schreibt das Zeichen mit ASCII-Code C auf den Ausgabekanal. Liest den nächsten Term vom Eingabekanal und unifiziert ihn mit T. Fügt die Klauseln von File F in die Datensammlung ein, löscht dabei alle schon vorhandenen Klauseln gleichen Namens und gleicher Stelligkeit (Abkürzung: [-F1, -F2, ... J). Fügt den Term T als erstes Element unter dem Schlüssel S in die interne Datensammlung ein, R wird dabei mit der Database Reference Nummer unifiziert. Der Term T ist unter dem Schlüssel S mit der Database Reference Nummer R in der internen Datensammlung gespeichert. Fügt den Term T als letztes Element unter dem Schlüssel S in die interne Datensammlung ein, R wird dabei mit der Database Reference Nummer unifiziert. Ist als Ziel immer wahr und ermöglicht unendlich viele Lösungswege. Entfernt die erste Klausel aus der Datensammlung, die mit C unifizierbar ist. Sichert den Interpreterstatus auf das File F. Macht das File F zum aktuellen Eingabekanal. Das File F ist der aktuelle Eingabekanal. Schließt den aktuellen Eingabekanal. Alle Belegungen des Terms T, so daß das Ziel G erfolgreich ist, ergeben sortiert die Liste L. Liest alle Zeichen vom aktuellen Eingabekanal einschließlich des nächsten Zeichens mit ASCII-Code C. Die Liste L ergibt sortiert S. Setzt einen Spy-Point auf alle Prädikate mit Namen P. Setzt einen Spy-Point auf das Prädikat mit Namen P und Stelligkeit N. Mist N + 1, N und M sind natürliche Zahlen. Führt das durch den String S spezifizierte Betriebssystemkommando aus. Schreibt N Blanks auf den Ausgabekanal. Macht File F zum aktuellen Ausgabekanal. Das File F ist der aktuelle Ausgabekanal. Schließt den aktuellen Ausgabekanal. Bewirkt, daß Debugging-Meldungen ausgegeben werden.

146 105

105

175

185

186

186

162

179

189 171 172 172 196

109

139 168 168

115 198

104 169 170 170 168

true S = .. L

var(T) write(T) writeq(T)

Built-in-Prädikate 279

Ist als Ziel wahr. (univ) Der Kopf der Liste L ist mit dem Funktor der Struktur S unifizierbar, der Rest der Liste L enthält die Argumente der Struktur. Der Term T ist eine ungebundene Variable. Gibt den Term T in vereinbarter Notation aus. Gibt den Term T in vereinbarter Notation und in syntaktisch korrekter Weise aus.

162 152

146 103

103

280 Realisierung eines Expertensystems

C Realisierung eines Expertensystems

Im Kapitel 8 haben wir den Lösungsansatz zur Implementierung eines Expertensystems dargestellt. Dieser Teil des Anhangs enthält nun alle Programmteile nochmals im Zusammenhang.

C.! Die Schale des Expertensystems

% Auf dieser Datei ist die Schale zur Regelabarbeitung eines Expertensystems % abgelegt. Diese Praedikate werden also unabhaengig vom jeweiligen Regel% system benoetigt und sind vor dem Start des Expertensystems in die Daten% sammlung zu laden. Anschliessend kann das System durch Aufruf von % ?- es..start«regeLda tei> ). gestartet werden. % % Mit diesem Praedikat wird das System gestartet. System muss dabei an einen % Da tein amen gebunden sein, unter dem das Regelsystem und alle sonstigen % Informationen ueber das behandelte Problem in der geforderten Form abgelegt % sind. Die Regel enthaelt eine Schleife (repeat - es_ende), die ein mehr-% faches Ablaufen des Systems ermoeglicht.

es..start(System) ;- exists(System),consult(System), es...erkLdat(Erkldat ), exists(Erkldat ), repeat, es_bildfrei, es_vor Jnit, es...m.ain, esJoeschen, es...ende, halt.

es..start(_) ;- write('ERROR ; Eine der zum System gehoerenden Dateien '), write('existiert nicht 1'), halt.

% Mit es_ende/O wird abgetestet, ob der Benutzer einen weiteren Ablauf des % Systems wuenscht, falls nicht ist das Praedikat wahr.

es_ende ;- nl, nl, nl, write('Nochmal ? '), es_einlesestring(A), ( (member(A, [ja, j, yes, y)), 1, fail);

(true)).

% In der folgenden Regel ist das Kernstueck des Systems realisiert; % - die Suche nach allen moeglichen Loesungen % - die Weiterverarbeitung

Die Schale des Expertensystems 281

% - die Erklaerungskomponente zur Erlaeuterung des Ergebnisses % Die Regel enthaelt eine Schleife zur Realisierung der Zurueckkomponente. % 1m Falle eines zurueck, wird die Suche nach einer Loesung falsch, % es erfolgt ein Backtracking bis zu repeat. Dann beginnt die Suche noch% mal, wobei allerdings alle Antworten, bis auf die letzte, noch vorhanden % sind.

eSJlJain :- repeat, esJnit, setof(E, rules(E), Zwilist), not es..zuruecktest, es_bildfrei, es_wege default, Zwilist, Erglist), ac tion (Erglist ), nl, nl, write('Weiter mit< return> '), geto(_), es_erkl(Erglist), I.

% es_bildfrei loescht den Bildschirm (die jeweiligen ASCll-Codes haengen % vorn verwendeten Terminal ab und gelten hier z.B. fuer ein Beehive AT20)

es_bildfrei :- put(27), put(69).

% Mit dem folgenden Programmstueck werden die in der internen Datensammlung % gehaltenen 'gJobalen Variablen' vor dem Aufruf des Kernstuecks % initialisiert. Die Variablen haben folgende Bedeutung: % - key...antworten - - > Merken der Antworten % - key Joesung - - > Merken des Loesungswegs % - key..zurueck - - > Merken, ob zurueck-Status gesetzt oder nicht % - key Jegel - - > Merken der aufrufenden Regeln

es_vorJnit :- recorda(key...antworten, [ ], _), recorda(key..zur, nein, _), recorda(keyJoesung, [ ], _), recorda(keYJegel, [ ], _).

% esJnit belegt diese Variablen dagegen mit den richtigen Werten innerhalb % des Kernstuecks im Falle eines Neubeginns der Suche infolge eines % zurueck-Aufrufs.

esJnit :- recorded(key..zur, _, Ref}, erase(Ref ), recorda(key..zur, nein, _), recorded(keyJoesung, -. Refl), erase(Refl}, recorda(keyJoesung, [ ], _).

% es_weg/3 entfernt das angebene Element X aus der Liste.(Dient zum Entfernen


% der default-Loesung aus der Ergebnisliste). es_weg(X, [XITlJ, Tl).

es_weg(X, [YITlJ, [YIT2l) :- es_weg(X, TI,T2).

% es Jrage stellt die zentrale Prozedur zur Abfrage der Bedingungen dar. Es % bewirkt, je nach Benutzerwunsch : % - den Aufruf der warum-Komponente % - den Aufruf der wie-Komponente % - den Aufruf der Zurueckkomponente % - das Einlesen einer Benutzer-Antwort, das Abspeichern dieser Antwort % in der Datensammlung, sowie Vermerke in den Listen fuer Antworten % und Loesungsweg.

esJrage(F, Ant, Ri, Zstatus) -repeat, es_eingabe(F, A), ( (A == warum,

es_warum(Ri), nl, fail}; (A == wie, es_erklaeren(F), nl, fail);

(A == zurueck, es...zurueck(Zstatus), I, fail);

(not member(A, [wie, warum, zurueckl))), asserta((esJrage(F, _, _, _) :-

eSJIlerke(keyJoesung, [Ri, F, Al),I, fail)), asserta( (esJrage(F, A, _, _) :-

eSJIlerke(keyJoesung, [Ri, F, Al),I)), eSJnerke(keY-ilntworten, [F, Al), eSJIlerke(keyJoesung, [Ri, F, Al), I, A = Ant.

% eSJIlerke/2 fuegt ein weiteres Element zu einer Liste, welche unter % dem angegebenen key X in der internen Datensammlung gespeichert ist, hinzu.

eSJIlerke(X, Newhead) :- recorded(X, Oldlist, Ref), erase(Ref), append([Newheadl, Oldlist, Newlist), recorda(X, Newlist, _), I.

% es_urJIlerke(Neu) wird beim Verlassen einer Unterregel aufgerufen, fuegt % Neu in den Loesungsweg ein und loescht den Kopf der Liste der aufrufenden % Regeln.

es_urJIlerke(Neu) :- recorded(keyJoesung, Oldlist, Refl}, erase(Refl), append([Neul, Oldlist, Newlist), recorda(keyJoesung, Newlist, _), recorded(keYJ"egel, [HI Tl, Ref2), erase(Ref2), recorda(keYJ"egel, T, _).


% eSJleuweg(Neu) wird zu Beginn eines neuen Loesungswegs aufgerufen, loescht % den alten Inhalt der Regelliste und fuegt Neu als neuen Inhalt dieser Liste % ein

eSJleuweg(Neu) :- recorded(key..regel, _, Ref), erase(Ref ), recorda(key..regel, [Neu], _).

% es_wahLtest(Ri) ist wahr,falls die angegebenen Regelnummer % im Loesungsweg schon als erfuellt vermerkt ist.

es_wahr_test(Ri) :- recorded(keyJoesung, List, _), member([Ri, w], List).

% Die folgenden fuenf Praedikate werden zur Realisierung der % Zurueckkomponente benoetigt. % Das naechste Praedikat testet, ob das System gerade den Status der Bearbei% tung eines zurueck-Befehls hat.

es...zuruecktest :- recorded(key...zur, ja, _).

% esJeertestjl wird benoetigt, um zu testen, ob in der Antwortliste ein % Element enthalten ist, also ein zurueck ueberhaupt moeglich ist.

esJeertest([ ]) write('zurueck nicht mehr moeglich I!'), nl, !, fail.

esJeertest(X).

% es...zurueck stellt das Kernstueck der Zurueckkomponente dar: Abtesten auf % Moeglichkeit des zurueck, Loescben der letzten Antwort, Setzen des zurueck -Status

es...zurueck ;- recorded(key.-antworten, Oldlist, Ref), esJeertest( Oldlist), erase(Ref ), es_antJoe(Oldlist ), recorded(key_zur, _, Refl), erase(Refl), recorda(key...zur, ja, _).

% Mit dem folgenden Programmstueck wird die letzte Antwort geloescht, die % unter den Antworten in der internen Datensammlung abgespeichert wurde, % und die Antwort aus der Datensammlung entfernt. Damit ist also % die letzte Antwort geloescbt.

es_antJoe([[Frage, Antwort] I TJ) :recorda(key.-antworten, T, _), retract((esJrage(Frage, _, _, _):- eSJllerke(.., _), !, fail)) , retract((esJrage(Frage, _, _, _):- eSJllerke(..., _), I)), write('Die letzte Frage war: '), nl, write(Frage), write(' ?'), nl, nl, write('Ihre Antwort war: '), write(Antwort), nl, nl.

% Mit es...zurueckjl wird die Zurueckkomponentein esJrage aufgerufen, dabei % wird getestet, ob das Argument eine Variable ist. Falls nicbt, wird


% zurueck als unzulaessig an dieser Stelle erkannt (z.B. nacb einem Daten-% bankzugriff mit Scbreiben, Programmausfuebrung mit Datenveraenderungen % o.ae.) und nicbt ausgefuebrt. Das Argument muss bei der Konstruktion % der Regeln entsprecbend angegeben werden.

eSJurueck(Zstatus) ;- (var(Zstatus), I, eSJurueck); (write('Hinter diese Stelle darf man nicbt zurueck !!'),

I, fail).

% es_warum(Ri) startet die Hilfefunktion, die Erklaerungen ueber den aktuellen % Stand der Regelabarbeitung liefert.

es_warum(Ri) ;- es_bildfrei, write{'Zugeboerige Regel ;'), nl, es_erklaeren(Ri), nl, nl, recorded(key Jegel, [HI TJ, _), es_vater ...regel(T).

% es_vater ...regel(List) ermoeglicbt, die aufrufende Regel der aktuellen Regel % zu seben, falls es eine solche gibt und es vom Benutzer gewuenscbt wird.

es_vater ...regel([HI T]) ;- write('Wollen Sie die aufrufende Regel dazu seben 7'), es_einlesestring( A), member( A, [j, ja, y, yesJ), nl, nl, es_erklaeren{H), nl, nl, es_vater...regel(T).

% Mit es_erklaeren wird auf der Erklaerungsdatei nacb den entsprechenden % Erlaeuterungen gesucht und diese ueber eS-Bcbreiben ausgegeben. Ent% sprechend dem Prototyp--Charakter dieser Schale kann dies in einer end% gueltigen Version ueber eine entsprechende Benutzerschnittstelle besser % und schneller geloest werden.

es_erklaeren(Ri) ;- es_erkLdat{ErkLdat), see(ErkLdat),

eS-Bchreiben([ J).

repeat, read (Fileelemen t), ( (Fileelement = end_ofJile,

write('Keine Erklaerungen gespeichert I'), seen, I); (Fileelement = [Ril TJ, nl, eS-Bchreiben(T), seen, I) ).

eS-Bchreiben([HITJ) ;- nl, write(H), eS-Bchreiben(T).

Die Schale des ExpertensysteIIU! 285

% Der folgende Programmabschnitt realisiert die Erklaerungen nach Auffinden % der Loesungen. Der Aufruf erfolgt aus dem Kernprogrammstueck eSJIlain % mit es_erkl(List), wobei List eine Liste der gefundenen Loesungen ist. % Ueber dieses Praedikat wird dann ein Menue an moeglichen Erklaerungen % angeboten. Innerhalb des gesamten Programmstuecks ist die Realisierung % des Input/Output durch den Benutzer wiederum als Improvisation anzusehen % und sollte ueber ein entsprechendes User-Interface in einer endgueltigen % Version geloest werden.

es_erkl(Erglist) :repeat, es_bildfrei, write('Sie haben nun die Moeglichkeit'), nl, nl, write(' - sich alle Fragen und Antworten nochmal anzusehen {l)'), nl, write(' - sich alle erfuellten Regeln anzusehen (2)'), nl, write(' - sich alle getesten und nicht erfuellten Regeln anzusehen (3) '), nl, write(' - sich anzusehen, warum etwas nicht Loesung ist (4)'), nl, write(' - keine weiteren Erlaeuterungen zu sehen (5)'), nl, nl, write('Ihre Auswahl :'), es_einlesestring(Weiter}, member(Weiter, [1, 2, 3, 4, 5]}, es_bildfrei, es_erkLkomp(Erglist, Weiter}, !.

% Das naechste Praedikat startet die gewaehlte Erklaerung : % 1 - - > ueber es_antworten..a.us werden alle Antworten ausgegeben % 2 - - > ueber eSJegeLaus(w)werden alle erfuellten Regeln ausgegeben % 3 - - > ueber eSJegeLaus(f ) werden alle getesteten und nicht erfuellten % Regeln ausgegeben % 4 - - > ueber eine weitere Menueauswahl kann eine Erklaerung verlangt % werden, warum etwas nicht Loesung ist. % Als Grundlage fuer diese Erklaerungen dienen die in der internen % Datensammlung unter den Schlüsseln key..a.ntworten bzw. keyJoesung gespeicherten % Vermerke ueber Antworten bzw. Regelerfuellung und Abfragen von Bedingungen.

es_erkLkomp(_, 1) :- nl, nl, es_an tworten..a.us, !, fail.

es_erkLkomp( .... 2) :- nl, nl, esJegeLaus(w), !, faH.


es_erkUwmp(_, 3) :- nl, nl, eSJegeLaus(f ), 1, fail.

es_erkLkomp(Erglist, 4) :- nl, nl, es..moegUoes( M oelist), es_entfernen(Erglist, Moelist, Nichtlist), es_anbiet(Nichtlist, Auswahl), ( ( Auswahl == 0 )i

( es_elem(Auswah/, Nichtlist, Elem), es_bildfrei, es_begruende(Elem} ) ),

1, fail.

% Komponente: Antworten ausgeben. es_an tworten...aus :- recorded(key...antworten, AntList, Ref),

eSJlchrei be...an tworten( An tList), nl, nl, write('Weiter mit< return> '), geto(_).

eSJlchreibe...antworten([ ]).

eSJlchreibe ..antworten([HI T]) :- eSJlchreibe...an tworten (T), H = [l''rage, Antwort], wri te (Frage) , write(' : '), write(Antwort), nl.

% Komponente: erfuellte Regeln ausgeben. eSJegeLaus(X) :- recorded(keyJoesung, AntList, _),

es_aus(X, AntList, L), esJceine...aus(L).

esJceine...aus([ ]) :- write('Bei diesem Durchlauf trifft dies auf kein Regel zu 1'), nl, nl, write('Weiter mit< return> '), getO(_).

esJceine...aus( _}.

es_aus(w, [ ], [ ]).

es_aus(w, [[Ri, Praedikat, Antwort] IT], L) :- es_aus(w, T, L).


es_aus(w, [[Ri, Boolsch] I T], L) :- es_aus(w, T, LI), nI, nI, ( (Boolsch == w,

not member([Ri, BooIsch] , LI), append([ [Ri, Boolsch] ], LI, L), write('Folgende Regel wurde erfuellt :'), nI, es_erkiaeren(Ri), nI, nI, write('Weiter mit< return> '), geto (_));

L = LI).

% Komponenete : getestete und nicht erfuellte Regeln ausgeben % (benutzt eSJegeLausjl aus erfuellte Regeln ausgeben)

es_aus(f, [ ], [ ]).

es_aus(f, [[Ri, Frage, Antwort] iT], L) :- es_aus(f, T, L).

es_aus(f, [[Ri, Boolsch] I T], L) es_aus(f, T, LI), nI, nI, ( (Boolsch == f,

not member([Ri, BooIsch] , LI), append([ [Ri, BooIsch]] , LI, L), write('Folgende Regel wurde nicht erfuellt :'), nI, es_erkiaeren(Ri), nI, nI, write('Grund :'), nI, es..grund(T), nI, nI, write('Weiter mit< return> '), geto (_));

L = LI).

es..grund([ [Ri, Frage, Antw] IT])

es...grund([ [Ri, Boolsch] I T])

es..grund([ ]).

write('Sie haben die Frage "'), write(Frage), write('" mit "'), write(Antw), write('" beantwortet. ').

write('Die folgende Regel war '), ( ( Boolsch == w, write('erfuellt :'));

( Boolsch == f, write('nicht erfuellt :')) ), nI, nI, es_erkiaeren(Ri), nI, nl, write('Grund : '), nI, es...grund(T).

% Komponente: warum bestimmte Loesung nicht. % (benutzt es...grund aus falsche Regeln ausgeben)

es_entfernen([ ], L, L).


es_entfernen([HIT], LI, L2) :- eSJaus(H, LI, Zl), es_entfernen(T, Zl, L2).

eSJaus(_, [ J, [ J).

eSJaus(X, [ [Ri, XJ ITJ, T).

eS_Iaus(X, [HI Tl], [HI T2J) :- eSJaus(X, Tl, T2).

es_anbiet([ J, 0) :- es_bildfrei, write('Alle moeglichen Loesungen sind Loesungen!'), ni, nl, write('Weiter mit< return> '), getO(_).

es_an biet(Nich tiist, Auswahl) :es_bildfrei,

eSJlilLaus(_, [ J).

write('Bitte geben Sie die entsprechende Nummer an :'), ni, ni, eSJlilLaus{1, Nichtlist), repeat, nl, nl, write('Ihre Antwort? '), es_einlesestring(X), integer(X), X> 0, length(Nichtlist, N), X=< N, Auswahl = X.

eSJlilLaus(N, [L, LoeJ I TJ) :- write(N), tab(lO), write(Loe), nl,

es_elem{1, [ElemIJ, Elem).

M is N + 1, eS~'lili_aus(M, T).

es_elem(N, [HI TJ, Elem) :- M is N - 1, es_elem(M, T, Elem).

es_begruende([Ri, J) :- recorded(keyJoesung, List, _), append(_, [[Ri, fJlT], List), write('Grund :'), nl, nl, es--.grund(T), nl, nl, write('Weiter mit< return> '), getOr-J.

% Mit esJoeschen werden die Antworten aus der Datensammlung geloescht % und die 'globalen Variablen' aus der internen Datensammlung entfernt. % Damit sind alle spezifischen Daten eines Durchlaufs des Systems


% geloescht und es kann erneut begonnen werden. es-.loeschen :- retract((esJrage(_, -, _, _):- (esJrlerke(-, _), Rest))),

fail.

es-.loeschen :- recorded(key~tworten, _, Refl), erase(Refl), recorded(key~ur, _, Ref2), erase(Ref2), recorded(keyJoesung, _, Re(3), erase(Ref3), recorded(keYJ'egel, _, Ref4), erase(Ref4).

% Die folgenden Programmstuecke dienen der Realisation der improvisierten % Benutzerschnittstelle. Dabei stellt es_eingabe/2 schon eine Schnittstelle % zu einem entsprechenden Programmpaket fuer den input fuer esJrage/4 % dar. Es fordert fuer eine bestimmte Frage eine Antwort an. % Die restlichen Praedikate dienen dem Einlesen von Eingaben sowie dem % Test auf Zulaessigkeit der Antworten.

es_eingabe(Frage, Antwort) :- nl, nl, write(Frage), write(' ? '), es_einlesen(Frage, Antwort).

es_einlesen (Frage, Antwort) :- es_einlesestring(Eingabe) , es--stdanttest(Frage, Eingabe, Antwort).

es_einlesestring(X) :- es-.lese_codes(List), !, name(X, List).

es-.lese_codes(List) :- ge tO(Next) , ( ( Next =:= 10, !, List = [ ]);

( List = [NextIRest] , es-.lese_codes(Rest) ) ).

% Test der Antwort auf zulaessige Standardantwort oder zulaessige Eingabe % auf die gestellte Frage.

es--stdanttest(_, Eingabe, Antwort) :-(member(Eingabe, [warum, 'warum ?', 'Warum ?', 'Warum']),

Antwort = warum); (member(Eingabe, ['wie bitte', 'wie bitte ?', wie, 'wie ?',

'Wie bitte', 'Wie bitte ?', 'Wie', 'Wie ?']), Antwort = wie);

(member(Eingabe, ['zurueck!', 'zurueck I', zurueck, 'Zurueck', 'Zurueck!', 'Zurueck !']),

Antwort = zurueck).

es--stdanttest(Frage, Eingabe, Antwort) :-es_antworttest(Frage, Eingabe, Antwort).


C.2 Beispiel "A u tos uche"

In Kapitel 8 wurden die problemspezifischen Programm teile an einem Expertensystem zur Autosuche erläutert. Diese Teile, die in zwei Dateien (Wissensdatei und Erklärungsdatei) gehalten werden, sind hier noch einmal im Zusammenhang angegeben.

Das zugehörige Regelsystem ist im Abschnitt 8.3.1 enthalten.

Die Datei mit dem allgemeinen Wissen

% Verweis auf die Datei mit den erklaerenden Texten; es_erkLdat( au to_erkl).

% Aufzaehlung der moeglichcn Laesungen ; eSJ110egU0es([ [rl, 'Golf Turbodiesel'] , [r2, 'Passat Turbodiesel'] ,

[r3, 'Mercedes 560 SEL'], [r4, 'Porsche 911 turbo']]).

% Regeln fuer die moeglichen Loesungen ; rules('Golf Turbodiesel') ;- eSJleuweg(rl),

preis(20000, rl), diesel, esJrage('Motor mit Turbolader', ja, rl, _), esJrage('Wieviele Tueren " X, rl, _), member(X, [3, 5]), eSJl1erke(keyJoesung, [d, w]).

rules('Golf Turbodiesel') .- (es...zuruecktest, 1, fail); (not es_wahctest(rl),

eSJl1erke(keyJoesung, [rl, fJ), fail).

rules('Passat Turbodiesel') ;- eSJleuweg(r2), preis(25000, r2), diesel, esJrage('Motor mit Turbolader', ja, r2, _), esJrage('Wieviele Tueren " 5, r2, _), esJrage('Geraeumiger Wagen', ja, r2, _), esJrage('Variant', ja, r2, _), eSJl1erke(key Joesung, [r2, w]).

rules('Passat Turbodiesel'} (es...zuruecktest, 1, fail); (not es_wahT-test(r2), esJl1erke(key Joesung, [r2, fJ), fail).

rules('Mercedes 560 SEL'} :- eSJleuweg(r3}, preis(lOOOOO, r3}, rules_typ(limousine} , not diesel,

Beispiel "Autosuche" 291

esJrage('Deutscbes Fabrikat', ja, r3, _}, esJrage('Motor mit Turbolader', nein, r3, _}, eSJIlerke(key Joesung, [r3, w l}.

rules('Mercedes 560 SEL'} - (es...zuruecktest, I, fail); (not es_wabdest(r3),

eSJIlerke(key Joesung, [r3, fl), fail}.

rules('Porsche 911 turbo'} :- eSJleuweg(r4}, preis(90000, r4}, rules_typ(sportwagen}, esJrage('Motor mit Turbolader', ja, r4, _}, eSJIlerke(key Joesung, [r4, w l}.

rules('Porscbe 911 turbo'} - (es...zuruecktest, I, fail); (not es_wahLtest( r4),

eSJIlerke(key Joesung, [r4, fl}, fail}.

% Defaultloesung rules( default).

% Unterregeln : preis (X, Ri} :- esJrage('Preisobergrenze', P, Ri, _},

P>= X.

diesel :- eSJIlerke(key.regel, rLl}, esJrage('Geringer Spritverbraucb', ja, rLl, _}, esJrage('Selbstzuender', ja, rLl, _}, es_urJIlerke([rL1, wl}, I.

diesel (es...zuruecktest, I, fail); (es_urJIlerke([rL1, fl), fail}.

rules_typ(1imousine} ;- eSJIlerke(key.regel, rL2}, esJrage('Wieviele Tueren " 4, r 1..2, _}, esJrage('Geraeumiger Wagen', ja, r 1..2, _}, es_urJIlerke([r1..2, wl}.

rules_typ(limousine} ;- (es...zuruecktest, I, fail); (not es_wabr_test(rl..2),

es_urJIlerke([rl..2, fl}, fail}.


rules_typ(sportwagen) :- es...merke(key...regel, rl...3), not diesel, esJrage('Wieviele Tueren', 2, rl...3, _), esJrage('Zweisitzer', ja, rl...3, _), esJrage('Schneller als 200 km/h', ja, rL3, _), es_ur...merke([rl...3, w]).

rules_typ(sportwagen) .- (esJuruecktest, 1, fail); (not es_wahr_test(rl...3),

es_ur...merke([rL3, f]), fail).

% Abtesten der gegebenen Antworten auf Zulaessigkeit es_antworttest(Frage, Eingabe, Antwort) :

es.jn_antw(Frage), ( (member(Eingabe, [ja, j, yes, y]), Antwort = ja);

(member(Eingabe, [nein, n, no]), Antwort = nein) ).

es_jn_antw(Frage) :- member(Frage, ['Motor mit Turbolader', 'Deutsches Fabrikat', 'Geringer Sprit verbrauch " 'Selbstzuender', 'Geraeumiger Wagen', 'Zweisitzer', 'Variant', 'Schneller als 200 km/h']).

es_antworttest('Wieviele Tueren', Eingabe, Eingabe) member(Eingabe, [2, 3, 4, 5]).

es_antworttest('Preisobergrenze', Eingabe, Eingabe) :- number(Eingabe), Eingabe> o.

% Verarbeiten der gefundenen Loesungen action([ ]) :- nl, nl,

write('Leider kenne ich kein entsprechendes Auto 1').

action(List) :- nl, nl, write('Folgende Fahrzeuge wuerden Ihnen gefallen :'), nl, nl, action...schreib(List).

action...schreib([ ]).

action...schreib([KIR]) :- nl, write(K), action...schreib(R).

Beispiel "Autosuche" 293

Die Datei mit den Erklärungen

[rl, 'Das gesuchte Fahrzeug ist ein Golf Turbodiesel, falls',

- der Preis maximal 20 000 DM betragen soll', - es ein Diesel sein soll', - der Motor einen Turbolader haben s011', -- es ein drei- oder ein fuenftueriges Fahrzeug sein soll. '] .

[r2, 'Das gesuchte Fahrzeug ist ein Passat Turbodiesel, falls', , , - der Preis maximal 25 000 DM betragen soll', - es ein Diesel sein s011', - der Motor einen Turbolader haben s011', - es ein fuenftueriges Fahrzeug sein soll', -- der Wagen geraeumig sein s011', - es ein Variant sein soll. '].

[r3, 'Das gesuchte Fahrzeug ist ein Mercedes 560 SEL, falls', , , - der Preis maximal 100 000 DM betragen soll', - es eine Limousine sein s011', - es kein Diesel sein 8011', _. es ein Fahrzeug eines deutschen Herstellers sein s011', - das Fahrzeug keinen Motor mit Turbolader haben soll. '] .

[r4, ' 'Das gesuchte Fahrzeug ist ein Porsche 911 turbo, falls', , , - der Preis maximal 90 000 DM betragen soll', - es ein Sportwagen sein s011', - das Fahrzeug einen Motor mit Turbolader haben soll. '] .

[rLl, 'Das Fahrzeug soll einen Dieselmotor haben, falls', , , - es wenig Sprit verbraucht', - es ein Motor mit SelbstJJuendung hat'] .

[rL2, 'Das Fahrzeug ist eine Limousine, falls', , , - es ein viertueriges FahrJJeug ist', - es geraeumig ist '] .

[rL3, 'das Fahrzeug ist ein Sportwagen, falls', , , - es ein JJweitueriges FahrJJeug ist', - es ein ZweisitJJer ist', - man damit schneller als 200 kmlh fahren kann'].


['Motor mit Turbolader', 'Unter einem Motor mit Turbolader versteht man einen Motor, bei dem der', 'Druck des Abgases zum Antrieb einer "Pumpe" (dem Turbolader) genutzt wird.', 'Auf diese Weise kann das Treibstoff-Luft-Gemisch unter Druck in die Brenn-', 'kammern geleitet werden. Dadurch werden diese besser ausgefuellt und die', 'Leistung des Motors erhoeht. Durch die Eingabe von ja oder nein koennen sie', 'entscheiden ob Ihr Fahrzeug eine solche Außadung haben s011'].

['Wieviele Tueren " 'Bei dieser Frage koennen sie eine Zahl zwischen 2 und 5 eingeben. Als Tueren " 'werden dabei die "normalen" Tueren und die Heckklappe bezeichnet. Ein Auto', 'mit vier Tueren und Heckklappe ist demnach z.B. ein Fahrzeug mit 5 Tueren. ']

['Geraeumiger Wagen', 'Darunter wird ein Fahrzeug verstanden, mit dem groessere Gegenstaende', 'transportiert werden koennen, bzw. bei dem das Platzangebot so reichlich', 'ist, dass fuenf Personen bequem Platz finden. Sie koennen mit ja oder nein', 'antworten. '].

[ 'Variant', 'Unter einem Variant versteht man ein Fahrzeug, bei dem der Kofferraum nicht', 'direkt vom Fahrgastraum getrennt ist. Solche Fahrzeuge haben ein Steilheck, ' 'wodurch sich die Zulademoeglichkeiten erheblich vergroessern. Sie koennen', 'mit ja oder nein antworten. '].

['Deutsches Fabrikat', 'Wenn Sie diese Frage mit ja beantworten, wird nach Fahrzeugen deutscher', 'Hersteller gesucht. '].

[ 'Preisobergrenze', 'Mit der Eingabe einer Zahl ( >0) geben Sie eine Grenze an, die der Preis', 'des Wagens in DM nicht uebersteigen darf. '].

['Geringer Spritverbrauch " 'Als gering wird ein Spritverbrauch unter 71/100 km im Drittelmix nach DIN', 'verstanden. Falls Ihr Wagen weniger verbrauchen soll, antworten Sie mit ja, " 'ansonsten mit nein. '].

[ 'Selbstzuender', 'Wenn Sie hier mit ja antworten, wollen sie ein Fahrzeug, dessen Motor schon', 'durch die hohe Kompression zuendet. Der Wagen benoetigt also keine Zuend-', 'kerzen. Dies ist bei Dieselmotoren der Fall. '] .

[ 'Zweisitzer', 'Unter einem Zweisitzer versteht man ein Fahrzeug mit nur zwei vollwertigen', 'Sitzplaetzen. Die uebrigen Sitzplaetze werden als Notsitze bezeichnet. Sie', 'koennen mit ja oder nein antworten. '].

Beispiel" Autosuche" 295

[ 'Schneller als 200 km/h', 'Wenn sie hier mit ja antworten, suche ich nach einem Fahrzeug, mit dem Sie', 'schneller als 200 km/h fahren koennen (falls es die VerkehrsverhaeItnisse', 'zulassen !!!). '].

296 Anpassung von Regeln an die Schale des Expertensystems

D Anpassung von Regeln an die Schale des Expertensystems

Hier wollen wir noch einmal an einem Beispiel zeigen, wie man vorgehen muß, um ein Regelsystem so aufzubereiten, daß die in Kapitel 8 erläuterte und im Anhang Teil C.1 komplett abgedruckte Schale für ein Expertensystem zur Implementierung des Systems verwendet werden kann.

Als Beispiel diene das folgende Regelsystem zur Bestimmung von Fabelwesen:

Regel 1 : Das zu bestimmende Fabelwesen ist ein Greif, falls - es vogelähnlich ist - es einen Vogelkopf besitzt - es einen Löwenkörper besitzt.

Regel 2 : Das zu bestimmende Fabelwesen ist ein Roch, falls - es vogelähnlich ist - es riesengroß ist.

Regel 3 : Das zu bestimmende Fabelwesen ist ein Mantichora., falls - es einen Löwenkörper besitzt - es einen Skorpionsschwanz besitzt.

Unterregel 1: Das Fabelwesen ist vogelähnlich, falls es Flügel hat.

Es müssen nun zwei Dateien erstellt werden, eine Datei mit den Regeln, die das allgemeine Wissen darstellen, und eine Datei mit den Erklärungen.

Die Regeldatei besteht aus:

a) Einem Verweis auf die Datei mit den Erklärungen. Dieser Verweis erfolgt mittels es_erlrLdat/l.

b) Der Aufzählung der möglichen Lösungen mit ihren Regelnummern. Dies erfolgt mittels es...mägl..1.oes/l.

c) Den Regeln für die möglichen Lösungen, wobei für jede Regel unseres Systems zwei Regeln für das Prädikat rules/l eingefügt werden, je eine für den erfolgreichen und eine für den nicht erfolgreichen Fall.

d) Der Defaultlösung : rules(default).

e) Den Unterregeln, die zwar von den Regeln aufgerufen werden, aber keine Lösungen des Expertensystems produzieren. In unserem Fall also nur die Regel für vogelähnlich. Wie schon unter c) beschrieben, werden auch hier ein Zweig für den positiven und einer für den negativen Fall benötigt.

f) Den Zulässigkeitstests für die Antworten auf die gestellten Fragen. Hierzu muß eS...llDtworttest/3 angepaßt werden. Da in unserem Beispiel nur ja/nein-Fragen vorkommen, ist dafür nur eine einzige Regel nötig, im allgemeinen Fall werden es mehrere sein.

Die Regeldatei 297

g) Den Anweisungen für die Verarbeitung der gefundenen Lösungen mittels action/1. Im einfachsten Fall ist das, wie in unserem Beispiel, das Ausgeben der gefundenen Lösungen.

Die Datei für die Erklärungen besteht aus:

a) Den Regelerklärungen, die bei warum-Fragen des Benutzers ausgegeben werden. Dies sind Listen deren Kopf die Regelnummer und deren Rumpf den auszugebenden Text darstellt.

b) Den Frageerklärungen, die bei wie-Fragen des Benutzers ausgegeben werden. Hier stellt der Fragetext den Kopf der Liste dar.

Das Expertensystem wird dann mit

?- eS..8tart«Name der Regeldatei».

gestartet, nachdem zuvor die Prädikate der Schale in die Datensammlung geladen worden sind.

D.l Die Regeldatei

% Verweis auf die Datei mit den erklaerenden Texten: es_erkLdat (fa beLerkl}.

% Aufzaehlung der moeglichen Loesungen : es..moegUoes([[r1,'Greif'l, [r2, 'Rocb'l, [ra, 'Manticbora'll}.

% Regeln fuer die moeglichen Loesungen : rules('Greif'} :- eS.Jleuweg(r 1},

vogelaebDlicb, esJrage('Vogelkopf', ja, J'l, _}, esJrage('LoeweDkoerper', ja, r1, _}, es..merke(keyJoesung, [r1, wl}.

rules('Greif'} :- (es..zuruecktest, !, fail) j

(not es_wahr_test(r1), es..merke(keyJoesung, [r1, fl}, fail}.

rules('Rocb'} :- es.Jleuweg(r2}, vogelaebDlicb, esJrage('rieseagrOBB', ja, r2, _}, es..merke(keyJoesung, [r2, wl).

rules('Rocb'} :- (es..zuruecktest, !, fail)j (not es_wahdest(r2), es..merke(keyJoesung, [r2, fl), fail).

298 Anpassung von Regeln an die Schale des Expertensystems

ruies('Mantichora ') :- es.-neuweg(r3), es frage('Loewenkoerper', ja, r3, _), es frage('Skorpionsschwanz',ja, rS, _), es..merke(keyJoesung, [r3, w)).

ruJes('Mantichora ') '- (es~uruecktest, !, laiJ); (not es_wahLtest(rS),

% Delaultloesung : ruJes(default).

% Unterregein:

es..merke(key Joesung, CrS, f]), fai)).

vogelaehnlich '- es..merke(key J'ege), r 1...1), esJrage('Fluegel', ja, rlJ., _}, es_urJ1lerke([rl.l, w)), !.

vogelaehnlich :- (es zuruecktest, I, fail); (es ur ..merke([rlJ., f)), faiJ).

% ZuJaessigkeitstest fuer die Antworten: es_antworttest(Frage, Eingabe, Antwort) :-

( (member(Eingabe, [ja, j, yes, y)), Antwort = ja); (member{Eingabe, [nein, n, no]), Antwort = nein) ).

% Verarbeiten der gefundenen Loesungen : action ([ ]) :- ni, ni,

write('Leider kann ich das Fabelwesen nicht bestimmen!').

action(List) :- nl, ni, write{'Es handelt sich um eines der folgenden '), write{'Fabelwesen :'), nI, nI, ac tion..schreib(Lis t ).

action...Bchreib([ J).

action...Bchreib([KIRJ} ;- ni, write(K}, action..schreib(R).

Die Datei mit den Erklärungen 299

D.2 Die Datei mit den Erklärungen

[rl, 'Das zu bestimmende Fabelwesen ist ein Greif, falls',

- es vogelaebnlicb ist', - es einen Vogelkopf besitzt', - es einen Loewenkoerper besitzt. '] .

[r2, 'Das zu bestimmende Fabelwesen ist ein Roch, falls', , , - es \"ogelaebnlicb ist', - es riesengross ist. 'J .

[r3, 'Das zu bestimmende Fabelwesen ist ein Manticbora, falls', , , - es einen Loewenkoerper besitzt', - es einen Skorpionsscbwanz besitzt. '] .

[rL1, 'Da..'" Fabelwesen ist vogelaebnlicb, falls es Fluegel bat.'].

[ 'Vogelkopf', 'Fallt; der Kopf und der Hals des Wesens gefiedert ist und es einen', 'Scbnabel hat, an tworten Sie bitte mit j", sonst mit nein.'].

[ 'Loewenkoerper', 'Falls das Wesen auf vier Beinen geht und ein gelbbraunes Fell', 'hat, an worten Sie bitte mit ja, sonst mit nein. 'J.

[ 'riesengrass " 'Als riesengross wollen wir ein Wesen bezeichen, das groesser', 'als ein Elefan t ist.'] .

[ 'Skorpionssch wanz', 'Falls das Wesen einen schwarzen, gegliederten Scbwanz mit', 'einem giftigen Stacbel am Ende besitzt, antworten Sie bitte', 'mit ja, sonst mit nein.'].

[ 'Fluegel', 'Falls das Wesen fIuegelartige Auswuecbse bat, wobei es egal ist, ' 'ob diese aus Federn oder aus Haut besteben, antworten Sie bitte', 'mit ja, sonst mit nein.'] .

300 Literaturverzeichnis

Literaturverzeichnis

[ 1 ) Börger, E., Berechenbarkeit, Komplexität, Logik, Vieweg-Verlag, Braunschweig, 1985

[ 2 ) Clark, K.L. / McCabe, F.G., Micro-PROLOG: Programming in Logic, Prentice-Hall International Series in Computer Science, 1984

[ 3 ) Clark, K.L. / Tärnlund, S.A., Logic Programming, Academic Press, London, 1982

[ 4 ] Clocksin, W.F. / Mellish, C.S., Programming in Prolog, Springer-Verlag, Berlin - Heidelberg - New York, 1984

[ 5 ] Kowalski, R., Logic for Problem Solving, North Holland, New York, 1979

[ 6 ] Lloyd, J. W., Foundations of Logic Programming, Springer-Verlag, Berlin - Heidelberg - New York, 1984

[ 7 ] Shoenfield, J.R., Mathematical Logic, Addison-Wesley, Reading, Mass., 1967

[ 8 ] The Arity /Prolog Prograrnming Language, Manual zu Arity-Prolog, Arity Corporation, Concord, Mass., 1986

[ 9 ) C-Prolog User's Manual, EdCAAD, University of Edinburgh, Edinburgh, 1984

Stichwortverzeichnis 301

Stichwortverzeichnis 162 Built- in-Prädikat 31, 70, 102

97, 163

-- > 205 caJ1 163 162 CALL 86 152 dause 182

dose 173

Ablaufsteuerung 162 compare 119

abolisb 180 consult 31, 175

abort 164 Cut 97

Algebra 56 Cu t / Fail-Kom bination 99

allgemeingültig 58

append 129, 171 Database Reference Nummer 73, 184 äquivalent 37 Datei 169 arg 150 Datensammlung 19 Argument 74 -interne 184 Aritbmetik 110 -Programm 175 Arithmetischer Ausdruck 110 Datentypen 71 ASCII -Liste 78, 142 db reference 146 assert 176 debug 167 asserta 176 Debugger 164 assertz 176 debugging 168 Assoziativität 155 Deduktionstbeorem 40, 55 atom 146 Depth-first-search 29, 65, 81 Atom 72 digit 71 Atom (Logik) 35 Disjunktion 162 atomic 146 display 104 atomic 73 Ausgabekanal 169 Eingabekanal 171 Aussagenlogik 35 Einheits-Klausel 62

end-of-input - Sequenz 171 Backtracking 23,81 end-of-input - Zeichen 171 Backus-N aur-Form 70, 204 end_oLfile 171 bagol 192 Entscheidungsbaum 47 Ben u tzerschnittstelle 239 erase 187 Betriebssystembefehle 198 erfüllbar 37, 58 Bewertung 36 Erfüllbarkeitsproblem 59 Boxenmodell 85, 165 Erklärungskomponente 239, 243, 259 break 163 Existenzquantor (bagof, setof) 194 Bubble-Sort 139 exists 173 Built-in-Operator EXIT 86

-arithmetischer 111 Expertensystem 236

802 Sticbwortverzeichnis

-Struktur 238 identisch 117 -dynamisches 240 Individuenkonstante 54 -statisches 240 Individuenvariable 54

Inferenzmechanismus 238, 243 fail 93, 163 Input 105 FAlL 86 Insert 229 Faktum 16,76 integer 146 Fehlersuche 164 integer 73 Fibonacci 88, 183 In terpretation 56 Folgerungsbegriff 38 Ül 112 folgt 38, 58 Formel 36,55 Kettenschluß 40

-geschlossene 55 Klausel 28 Frage 19,76 Klausel (Logik) 43,62 Frage (Logik) 63 Kongruenz Fragekomponente 239, 245 -quadratische 234

-Hilfefunktion 247 Konjunktion 162 free.e_predica tes 182, 231 kontradiktorisch 42 functor 148 Kopf einer Regel 27 Funktionssymbol 54 Kopf- Rest-Separator 125 Funktor 74 Korrektheitssatz 41, 59

get 107 leash 168 getO 107 length 132 Gleichheit (Logik) 61 Liste 77, 123 Grammatik 204 -Kopf 123

- kontextfreie 204 -leere 123 Graph 232 -Rest 123 größter gemeinsamer Teiler 113 listing 33, 181, 182 Grund-Aussage 68 Literal 43,62 Grund-Substitution 63 Logik 217 Grund-Term 68 Lösungen 83

Lösungsraum 243 halt 34, 164 Lösungsverfahren 79 Herbrand-Algebra 68 Lösungsweg 83 Herbrand-Modell 68 lower case letter 71 Herbrand- Universum 68 herleitbar 39 Mathematik 234 Herleitungsbegriff 39, 55 member 127 Horn-Form 44 Menge 201 Horn-Klausel 62 -Differenz 203 Horner-Schema 234 - Durchschnitt 203

Stichwortverzeichnis 303

-Gleichheit 202 Primformel 54

- Vereinigung 203 primitive 146

Mengenprädikat 201 primitive 73

Metasprache 70 Problemlösungskomponente 238

Modell 58 Programm 77 MODUS PONENS 39 Programm-Klausel 44, 62 monadisch 159 Programmstatus 189

Prolog-Form 223 name 142 Prolog-Interpreter 50 Negation by Failure 45 Prolog-Klausel 28 Nichtterminalsymbol 204 Prolog- Programm 76 Nimm 209 Prolog-Programm (Logik) 62

nl 104 Punkt-Operator 124 nodebug 167 put 105 nonvar 146 Normalform 43,60

Quantoren -disj unktive 44 -konj unktive 43, 223

-beschränkte 227

-pränexe 60, 221 Query 229

-Skolem 60, 221 Quick-Sort 140

-zweidisjunktive 208 -zweikonjunktive 158 read

nospy 168 real 90, 105

not 44,95, 163 reconsult 73

number 146 recorda 31,175

number 73 recorded 185 recordz 186

op 155 REDO 186

Operation 75 Regel 86

Operator 75, 154 Regelsystem 27,76

-user defined 154 -einstufig 253 Ordnung 116 -mehrstufig 255 Output 103 Registermaschine 217

Rekursion 88 Parser 204 Rekursionsanfang 90 Permutation 137 repeat 94, 162 Position 155 Resolution 45,63, 80 Prädikat 17 Resolvente 45, 80 Prädikatenlogik 54 retract 178 Prädikatsname 17 Rückgängigmachen einer Antwort 250 Prädikatssymbol 54 Rückwärtsverkettung 243 Pränex 60 Rumpf einer Regel 27

304 Stichwortverseichnis

save 189 univ 153 see 171 Unterregel 255 seeing 172 upper case letter 71 SEen 172 user 169 setof 196 Siebzehn und Vier 211 var 146 skip 109 Variable 20,74 Skolem 60 -anonyme 74 sort 139 -gebundene 21 Sortiert'n 139 -Gültigkeits bereich 20 Spiele 209 -ungebundene 21 spy 168 Vergleich 116 spy-point 166 -Terme 116 Stelligkeit 17 -Zahlen 120 String 142 Vergleichsprädikat Struktur 74 -Terme 117

-user defined 76 -Zahlen 120 Substitution 63 Vollständigkeitssatz 42,59 succ 115 Vorrang 155 Symbol 71 Syntax 70 Wahrheitswert 36 system 198 widerspruchsvoll 37, 58

Wissen tab 104 -allgemeines 238 Tautologie 37 -aufbereitetes 239 Teilmenge 202 -erfragtes 239 tell 169 -externes 239 telling 170 Wissenserwerbskomponente 239 Term 77 Wissensrepräsentation 238, 252, 259 Tenn (Logik) 54 write 91, 103 Terminalsymbol 204 writeq 103 Termklassifizierung 146 told l70 Zahlen 73 trace 168 Zeichensatz 71 true 94, 162 Ziel-Klausel 44 Türme von Hanoi 114 Zufallszahl 212

Zyklus 232 underline 74 Unifikation 80 Unifikationsalgorithmus 64 Unifikator 63

-allgemeinster 64

Leitfäden der angewandten Informatik

Bauknecht/Zehnder: Grundzüge der Datenverarbeitung Methoden und Konzepte für die Anwendungen 3. Aufl. 293 Seiten. DM 34,-

Beth ! Heß ! Wirl: Kryptographie 205 Seiten. Kart. DM 25,80

Bunke: Modellgesteuerte BIldanalyse 309 Seiten. Geb. DM 48,-

Craemer: Mathematisches Modellieren dynamischer Vorgänge 288 Seiten. Kart. DM 36,-

Frevert: Echtzelt-Praxls mit PEARL 216 Seiten. Kart. DM 28,-

GornyNiereck: Interaktive grafische Datenverarbeitung 256 Seiten. Geb. DM 52,-

Hofmann: Betriebssysteme: Grundkonzepte und MOdellvorstellungen 253 Seiten. Kar!. DM 34,-

Holtkamp: AngepaBte Rechnerarchitektur 233 Seiten. DM 38,-

Hultzsch: ProzeBdatenverarbeltung 216 Seiten. Kart. DM 25,80

Kästner: Architektur und Organisation digitaler Rechenanlagen 224 Seiten. Kart. DM 25,80

Kleine Büning!Schmitgen: PROLOG 304 Seiten. Kart. DM 34,-

Meier: Methoden der grafischen und geometrischen DatenverarbeItun! 224 Seiten. Kart. DM 34,-

Mresse: Information Retrleval - Eine Einführung 280 Seiten. Kar!. DM 36,-

Müller: Entscheidungsunterstützende Endbenutzersy.teme 253 Seiten. Kart. DM 26,80

Mußtopf ! Winter: Mlkroprozessor-Sy.teme Trends in Hardware und Software 302 Seiten. Kart. DM 32,-

Nebel: CAD-Entwurf.kontrolle In der Mikroelektronik 211 Seiten. Kar!. DM 32,-

Retti et al.: Artlflelal Intelligenee - Eine Einführung 2. Aufl. X, 228 Seiten. Kart. DM 34,-

Schicker: Datenübertragung und Rechnernetze 2. Aufl. 242 Seiten. Kart. DM 32,-

Schmidt et al.: DIgitalschaltungen mit Mlkroproze .. oren 2. Aufl. 208 Seiten. Kart. DM 25,80

Schmidt et al.: MIkroprogrammierbare Schnltt.tellen 223 Seiten. Kart. DM 34,-

Schneider: Problemorientierte Programmlereprachen 226 Seiten: Kart. DM 25,80

Fortsetzung auf der 3. Umschllgseite

A Die Syntax von PROLOG - link.springer.com978-3-322-92747-7/1.pdf · Löscht den Term mit der...

Documents

Transcript of A Die Syntax von PROLOG - link.springer.com978-3-322-92747-7/1.pdf · Löscht den Term mit der...