© 2001
François Bry
Dieses Lehrmaterial wird ausschließlich zur privaten Verwendung
angeboten. Eine nichtprivate Nutzung (z.B. im Unterricht oder eine
Veröffentlichung von Kopien oder Übersetzungen) dieses Lehrmaterials
bedarf der Erlaubnis des Autors.
:- var(X).
X = X
yes.
:- var(28).
no (more) solution.
:- var(a).
no (more) solution.
:- var(f(X)).
no (more) solution.
:- var([a, b]).
no (more) solution.
:- var([]).
no (more) solution.
:- integer(X).
no (more) solution.
:- integer(28).
yes.
:- integer(a).
no (more) solution.
:- integer(f(X)).
no (more) solution.
:- integer([a, b]).
no (more) solution.
:- integer([]).
no (more) solution.
:- atom(X).
no (more) solution.
:- atom(28).
no (more) solution.
:- atom(a).
yes.
:- atom(f(X)).
no (more) solution.
:- atom([a, b]).
no (more) solution.
:- atom([]).
yes.
:- compound(X).
no (more) solution.
:- compound(28).
no (more) solution.
:- compound(a).
no (more) solution.
:- compound(f(X)).
X = X
yes.
:- compound([a, b]).
yes.
:- compound([]).
no (more) solution.
:-
atomic einerseits und atom
und integer andererseits kann wie folgt erläutert werden:
atomic(X) :- atom(X).
atomic(X) :- integer(X).
nonvar kann wie folgt erläutert werden:
nonvar(X) :- \+ var(X).
:- als ein zweistelliges Funktionssymbol behandelt wird,
das in Infixform geschrieben werden kann.
:- Regel = (p(X) :- q(X,Y), r(Y)).
Regel = p(X) :- q(X,Y), r(Y)
X = X
Y = Y
yes.
:- Regel = :-(p(X), (q(X,Y), r(Y))).
Regel = p(X) :- q(X,Y), r(Y)
X = X
Y = Y
yes.
:- (Kopf :- Rumpf) = :-( p, (q, r) ).
Kopf = p
Rumpf = q, r
yes.
:- (Kopf :- Rumpf) = :-( p, q,r ).
no (more) solution.
=.. (sprich: univ)
dient zur Konvertierung zwischen Termen und Listen
und ist sehr nützlich für die Bearbeitung von Termen.
Es kann natürlich auch auf Terme angewandt werden,
die mit :- gebildet sind:
:- (p :- q, r, s) =.. [F | Argumente].
F = :-
Argumente = [p, (q, r, s)]
yes.
p getrennt werden.
Das zweite Element der Liste ist eine Konjunktion von drei Elementen.
dynamisch vereinbart
worden sind:
:- dynamic(p/1).
yes.
:- listing(p/1). %%% Ausgabe aller Klauseln fuer p/1
%%% Bisher gibt es keine solche Klausel
yes.
:- asserta( p(X) :- q(X,_) ).
X = X
yes.
:- listing(p/1).
p(_g230) :-
q(_g230, _g236).
yes.
:- asserta( p(a) ).
yes.
:- listing(p/1).
p(a).
p(_g230) :-
q(_g230, _g236).
yes.
:- assert( p(Y) :- r(Y) ).
Y = Y
yes.
:- listing(p/1).
p(a).
p(_g230) :-
q(_g230, _g236).
p(_g230) :-
r(_g230).
yes.
:- retract( p(Arg) :- Rumpf ).
Arg = a
Rumpf = true More? (;) ;
Arg = Arg
Rumpf = q(Arg, _) More? (;) ;
Arg = Arg
Rumpf = r(Arg)
yes.
:- listing(p/1).
yes.
:-
2 + 3 oder +(2,3)
steht in Prolog "für sich selbst",
da Funktionssymbole normalerweise nicht ausgewertet werden.
Einige wenige Systemprädikate werten ihre Argumente dagegen doch aus
und bilden insofern eine Ausnahme.
Voraussetzung ist, daß die Argumente zulässige arithmetische Terme sind.
:- X = +(2, 3). %%% Keine Seite wird ausgewertet
X = 2 + 3
yes.
:- X is 2 + 3. %%% rechte Seite wird ausgewertet
X = 5
yes.
:- X is +(2, 3).
X = 5
yes.
:- X is f(2, 3).
undefined arithmetic expression f(2, 3)
:- X = f(2, 3).
X = f(2, 3)
yes
:- 5 is 2 + 3.
yes.
:- 5 is 2 + Y.
instantiation fault in +(2, Y, 5)
:- Y = 3, 5 is 2 + Y.
Y = 3
yes.
:- 4 + 1 = 2 + 3. %%% Keine Seite wird ausgewertet
no (more) solution.
:- 4 + 1 is 2 + 3. %%% nur rechte Seite wird ausgewertet
no (more) solution.
:- 4 + 1 =:= 2 + 3. %%% Beide Seiten werden ausgewertet
yes.
:- X =:= 2 + 3.
instantiation fault in X =:= 2 + 3
:- 4 + 1 =\= 2 + 3. %%% Negation von =:=
no (more) solution.
:- 7 + 1 =\= 2 + 3.
yes.
< > >= =<
und
+ - * /
sind analog definiert.
tell und told leiten die
Ausgabe des PROLOG-Systemes in eine Datei um:
:- tell(sitzung).
yes.
:- [user].
p(X) :- q(X), r(X).
p(a).
p(b).
yes.
:- listing(p/1).
yes.
:- told.
:- listing(p/1).
p(_g678) :-
q(_g678),
r(_g678).
p(a).
p(b).
:- halt.
bye
tahiti(bry): % cat sitzung
p(_g678) :-
q(_g678),
r(_g678).
p(a).
p(b).
tahiti(bry): %
tahiti(bry): % cat testprogramm
member(M, [M|_]).
member(M, [_|R]) :- member(M, R).
list_of_integer([]).
list_of_integer([H|T]) :- integer(H), list_of_integer(T).
tahiti(bry):~ % eclipse
ECRC Common Logic Programming System [sepia opium megalog]
Version 3.4.5, Copyright ECRC GmbH, Thu Jun 16 11:08 1994
[eclipse 1]: compile(testprogramm).
testprogramm compiled traceable 436 bytes in 0.00 seconds
yes.
[eclipse 2]: member(X, [1, 2, 3, 4]).
X = 1 More? (;) ;
X = 2 More? (;)
yes.
[eclipse 3]: list_of_integer([1, 2, 3, 4]).
yes.
[eclipse 4]:
fib(0, 1).
fib(1, 1).
fib(N, F) :- N > 1,
N1 is N - 1, N2 is N - 2,
fib(N1, F1), fib(N2, F2),
F is F1 + F2.
?- dynamic(memo_fib/2).
memo_fib(0, 1).
memo_fib(1, 1).
memo_fib(N, F) :- N > 1,
N1 is N - 1, N2 is N - 2,
memo_fib(N1, F1), memo_fib(N2, F2),
F is F1 + F2,
asserta( (memo_fib(N, F) :- !) ).
fib(20, F) und memo_fib(20, F)
dauern. Nach dem Aufruf von memo_fib(20, F) enthält die Datenbank
das folgende memo_fib-Programm:
memo_fib(20, 10946) :- !.
memo_fib(19, 6765) :- !.
.
.
.
memo_fib(3, 3) :- !.
memo_fib(2, 2) :- !.
memo_fib(0, 1).
memo_fib(1, 1).
memo_fib(N, F) :- N > 1,
N1 is N - 1, N2 is N - 2,
memo_fib(N1, F1), memo_fib(N2, F2),
F is F1 + F2,
asserta( (memo_fib(N, F) :- !) ).
lemma(Anfrage) :- Anfrage, asserta( (Anfrage :- !) ).
p(a).
p(b).
p(c).
p(d).
p(e).
schreib_alle_p :- p(X), write(X), nl, fail.
schreib_alle_p.
:- schreib_alle_p.
a
b
c
d
e
yes.
:-
:- op(255, xfy, =>).
exists(X, P_X) :- not not P_X.
all(X, Q_X => P_X) :- not (Q_X, not P_X).
mitarbeiter(norbert).
mitarbeiter(marion).
mitarbeiter(slim).
mitarbeiter(tim).
spricht(norbert, deutsch).
spricht(norbert, franzoesisch).
spricht(marion, deutsch).
spricht(slim, deutsch).
spricht(slim, franzoesisch).
spricht(tim, deutsch).
:- mitarbeiter(M), not spricht(M, franzoesisch).
M = marion More? (;) ;
M = tim
yes.
:- exists(M, (mitarbeiter(M), not spricht(M, franzoesisch))).
M = M
yes.
:- all(M, mitarbeiter(M) => spricht(M, deutsch)).
M = M
yes.
:- all(M, mitarbeiter(M) => spricht(M, franzoesisch)).
no (more) solution.
:-
asserta und retract
verwendet, um die Zwischenergebnisse zu speichern:
?- dynamic(puffer/1).
alle(_, _, _) :- retract( puffer(_) ),
fail.
alle(X, Anfrage_X, _) :- Anfrage_X,
asserta( puffer(X) ),
fail.
alle(_, _, L) :- sammeln([], L).
sammeln(L1, L2) :- retract( puffer(X) ), !, sammeln([X|L1], L2).
sammeln(L, L).
member(M, [M|_]).
member(M, [_|R]) :- member(M, R).
sammeln vermeidet mehrfache Antworten mit
Teilergebnissen.
:- alle(X, member(X, [a,b,c,c,d]), L).
X = X
L = [a, b, c, c, d]
yes.
:- alle(X, member(X, []), L).
X = X
L = []
yes.
:-
:- dynamic(puffer/1).
menge(_, _, _) :- retract( puffer(_) ),
fail.
menge(X, Anfrage_X, _) :- Anfrage_X,
not puffer(X),
asserta( puffer(X) ),
fail.
menge(_, _, L) :- sammeln([], L).
sammeln(L1, L2) :- retract( puffer(X) ), !, sammeln([X|L1], L2).
sammeln(L, L).
member(M, [M|_]).
member(M, [_|R]) :- member(M, R).
:- menge(X, member(X, [a,b,c,c,c,d]), L).
X = X
L = [a, b, c, d]
yes.
:- menge(X, member(X, [5,5,2,2,6,3]), L).
X = X
L = [5, 2, 6, 3]
yes.
:-
:- [user].
mitarbeiter(norbert).
mitarbeiter(marion).
mitarbeiter(slim).
mitarbeiter(tim).
spricht(norbert, franzoesisch).
spricht(slim, franzoesisch).
spricht(X, deutsch).
yes.
:- alle(X, spricht(X, _), L).
X = X
L = [norbert, slim, X]
yes.
:- menge(X, spricht(X, _), L).
X = X
L = [norbert, slim]
yes.
:-
menge(X, spricht(X, _), L).
von der Reihenfolge der Definition für spricht ab, wie die
folgende Sitzung zeigt:
:- [user].
spricht(X, deutsch).
spricht(norbert, franzoesisch).
spricht(slim, franzoesisch).
yes.
:- alle(X, spricht(X, _), L).
X = X
L = [X, norbert, slim]
yes.
:- menge(X, spricht(X, _), L).
X = X
L = [X]
yes.
:-
alle.member als unzureichend.
[eclipse 1]: help(bagof/3).
bagof(?Term, +Goal, ?List)
Succeeds if List is the (non-empty) list of all
instances of Term such that Goal is provable.
...
[eclipse 2]: help(coverof/3).
coverof(?Term, +Goal, ?List)
Succeeds if List is the (non-empty) list of all
the most general instances of Term such that Goal
is provable.
...
[eclipse 3]: help(findall/3).
findall(?Term, +Goal, ?List)
List is the (possibly empty) list of all instances
of Term such that Goal is provable.
...
[eclipse 4]: help(setof/3).
setof(?Term, +Goal, ?List)
Succeeds if List is the (non-empty) ordered list of
all instances of Term such that Goal is provable.
...
% Listen
vereinigung([], M, M).
vereinigung([K|R], M, V) :- member(K, M), !, vereinigung(R, M, V).
vereinigung([K|R], M, [K|V]) :- vereinigung(R, M, V).
schnitt([], _, []).
schnitt([K|R], M, [K|S]) :- member(K, M), !, schnitt(R, M, S).
schnitt([K|R], M, S) :- schnitt(R, M, S).
schreib_liste([]).
schreib_liste([K|R]) :- write(K), schreib_liste(R).
% Logische Formeln, Konjunktions- und Disjunktionsglieder
conjunct(C, (C , _) ).
conjunct(C, (_ , R) ) :- !, conjunct(C, R).
conjunct(C, C ).
conjunct_rest(C, R, (C,R) ).
conjunct_rest(C, (X,R), (X,Y,Z)) :- !, conjunct_rest(C, R, (Y,Z)).
conjunct_rest(C, R, (R,C) ) :- !.
conjunct_rest(C, true, C ).
disjunct(D, (D ; _) ).
disjunct(D, (_ ; R) ) :- !, disjunct(D, R).
disjunct(D, D ).
disjunct_rest(D, R, (D;R) ).
disjunct_rest(D, (X;R), (X;Y;Z)) :- !, disjunct_rest(D, R, (Y;Z)).
disjunct_rest(D, R, (R;D) ) :- !.
disjunct_rest(D, false, D ).
% Kontrollpraedikate
once(X) :- X, !.
doall(X) :- X, fail.
doall(_).
retractall(X) :- retract(X), fail.
retractall(X) :- retract((X :- _)), fail.
retractall(_).
% Effiziente Generierung einer Variante eines Ausdrucks
% mit "frischen" Variablen.
term_copy(T, C) :-
asserta( term_copy_puffer(T) ),
retract( term_copy_puffer(C) ).
Letzte Änderung: 18. August 1998
:-und die unterschiedliche Bedeutung der Kommata::-( p(X), (q(X,Y), r(Y)) )ist ein PROLOG-Term mit zwei Argumenten, die durch das Komma nachp(X)getrennt werden. Das zweite Argument ist die Konjunktion vonq(X,Y)mitr(Y). Das Komma nachq(X,Y)ist der Operator für die Konjunktion. Die Konjunktionq(X,Y), r(Y)muß hier geklammert werden, weil andernfallsq(X,Y)als zweites undr(Y)als drittes Argument von:-behandelt würde.