Prolog-Kurs SomSem 2017 Daniel Beßler/Hagen Langer

Präsentation zum Thema: "Prolog-Kurs SomSem 2017 Daniel Beßler/Hagen Langer"—  Präsentation transkript:

1 Prolog-Kurs SomSem 2017 Daniel Beßler/Hagen Langer
Prolog – Weitere Grundlagen

2 Plan der Veranstaltung (1)
Grundlagen der Prädikatenlogik (optional und Umfang je nach vorhandenen Vorkenntnissen) Prolog-Einführung Fakten und Regeln Rekursive Definitionen ‚Pure Prolog‘ und prozedurale Erweiterungen Spezielle Programmiertechniken (Differenzlisten etc.) Warren Abstract Machine (WAM)

3 Rückblick: Notationskonventionen
Atome: a, b, a1, 'Hier ist alles erlaubt', ... Variablen: A, Abc, _, _3248, “anonyme Variable”: _ Fakten: a(b,c), a(b), - N.B.: a/2 ist verschieden von a/1! b, b(b(c)), ...

4 Rückblick: Verwandtschaftsbeziehungen:
/* Exemplarische Prolog-Wissensbasis */ kind_von(klaus, maria). % klaus ist kind von maria usw. kind_von(klaus, martin). weiblich(maria). männlich(klaus). männlich(martin).

5 Rückblick: Anfragen an eine Wissensbasis
kind_von(klaus, maria). kind_von(klaus, martin). weiblich(maria). männlich(klaus). männlich(martin). ?- kind_von(X, Y). X = klaus, Y = maria; X = klaus, Y = martin; no 5

6 ?- append([a],[b,c],[a,b,c,d]). no
Rückblick: append ?- append([a,b],[c,d],X). X = [a,b,c,d] ?- append([a],[b,c],[a,b,c,d]). no append([],X,X). append([X|R],Y,[X|R2]) :- append(R,Y,R2). 6

7 append([X|R],Y,[X|R2]) :- append(R,Y,R2).
Debugging mit trace append([],X,X). append([X|R],Y,[X|R2]) :- append(R,Y,R2). ?- trace, append([a,b],[c,d],X). Call: (7) append([a, b], [c, d], _G2284) Call: (8) append([b], [c, d], _G2419) Call: (9) append([], [c, d], _G2422) Exit: (9) append([], [c, d], [c, d]) Exit: (8) append([b], [c, d], [b, c, d]) Exit: (7) append([a, b], [c, d], [a, b, c, d]) X = [a, b, c, d]. 7

8 Debugging mit trace ?- trace, (X=a ; X=b), (Y=c ; Y=d).
Call: (7) _G2270=a Exit: (7) a=a Call: (7) _G2279=c Exit: (7) c=c X = a, Y = c ; Call: (7) _G2279=d Exit: (7) d=d Y = d ; Call: (7) _G2270=b Exit: (7) b=b Call: (7) _G2279=c Exit: (7) c=c X = b, Y = c ; Call: (7) _G2279=d Exit: (7) d=d Y = d. 8

9 Term-Typen Prolog Terme: Variablen, Atome, Zahlen, komplexe Terme
atom/1 Wahr für Atome integer/1 Wahr für ganze Zahlen float/1 Wahr für Fließkommazahlen number/1 Wahr für Zahlen atomic/1 Wahr für Konstanten (Atome und Zahlen) var/1 Wahr für ungebundene Variablen nonvar/1 Wahr für gebundene Variablen, Konstanten und komplexe Terme compound/1 Wahr für komplexe Terme ground/1 Wahr für Terme ohne ungebundene Variablen 9

10 ?- compound(4) ; compound(a).
Term-Typen ?- var(X) true. ?- var(a) ; var(7). false. ?- compound(4) ; compound(a). ?- compound(foo(bar)), compound(foo(A)). ?- nonvar(a(A)). ?- ground(a(A)). ?- atom(a), X = a, atom(X). true. ?- atom(7) ; atom(X). false. ?- atom(foo(bar,baz)). ?- atomic(a), atomic(8). ?- atomic(foo(bar,baz)). 10

11 Arithmetik ?- X = 3/2, compound(X), X = /(3,2), (X+3)*2 = *(+(X,3),2).
?- X is 3/2, is(X,/(3,2)), Y is (X+3)*2, number(Y). X = 1.5, Y = 9.0. ?- 6 is Y+3. ERROR: is/2: Arguments are not sufficiently instantiated 11

12 Vergleich von Termen = Wahr wenn Terme unifiziert werden können.
\= Wahr wenn Terme nicht unifiziert werden können. == Wahr wenn Terme identisch sind. \== Wahr wenn Terme nicht identisch sind. =:= Wahr wenn Zahlen gleich sind. =\= Wahr wenn Zahlen ungleich sind. 12

13 Vergleich von Zahlen ?- accMax([3,4,2],0,Max). Max = 4 ; false.
accMax([H|T],A,Max) :- (H > A, accMax(T,H,Max)) ; (H =< A, accMax(T,A,Max)). accMax([],A,A). ?- accMax([3,4,2],0,Max). Max = 4 ; false. max([X|Xs],Max) :- accMax(Xs,X,Max). Prolog Notation x < y X   <   Y. x ≤ y X  =<  Y. x = y X  =:=  Y. x ≥ y X  >=   Y. x > y X   >   Y. 13

14 Vergleich von Termen ?- a \== a. no ?- a \== b. yes ?- X \== a.
?- a == a, a == ’a’. yes ?- a == b. no ?- X==Y. ?- X=Y, X==Y. X = _2808 Y = _2808 ?-  a  \==  a. no ?-  a  \==  b. yes ?- X \== a. X = _3719 ?- X = (a == a), X = ==(a,a). X = (a==a). 14

15 ?- .(a,.(b,.(f(d,e),[]))) == [a,b,f(d,e)].
Rückblick: Listen Prolog interne Repräsentation ?- [a,b,c,d] == [a|[b,c,d]]. yes ?- [a,b,c,d] == [a,b|[c,d]]. ?- [a,b,c,d] == [a,b,c|[d]]. ?- [a,b,c,d] == [a,b,c,d|[]]. ?- .(a,[]) == [a]. yes ?- .(f(d,e),[]) == [f(d,e)]. ?- .(a,.(b,[])) == [a,b]. ?- .(a,.(b,.(f(d,e),[]))) == [a,b,f(d,e)]. ?- .(.(a,[]),[]) == [[a]]. 15

16 Funktor und Stelligkeit von Termen
?- functor(f(a,b),F,A). A = 2 F = f ?- functor([a,b,c],X,Y). X = ’.’ Y = 2 ?- functor(a,F,A). A = 0 F = a Listen werden intern mit dem zweistelligen Funktor '.' (full stop) repräsentiert Konstanten sind Funktoren mit der Stelligkeit 0 compound(X):- nonvar(X), functor(X,_,A), A > 0. 16

17 Argumente von Termen arg(N,Term,Key):- Term =.. [_|Args],
?- arg(2,foo(bar,baz),X). X = baz ?- arg(2,foo(bar,X),baz). ?- arg(2,foo(bar),X). false. ?- foo(bar,baz) =.. X. (univ Operator) X = [foo, bar, baz] arg(N,Term,Key):- Term =.. [_|Args], member(Key,Args), nth1(N,Args,Key). 17

18 list([X|R]) :- list(R).
Strings Listen: [a,b,c], [], [a,X,c], [a|X] [[a],b] list([]). list([X|R]) :- list(R). ?- S = "Robot". S = [82, 111, 98, 111, 116]. ?- atom_codes(’Vicky’,X). X = [86, 105, 99, 107, 121] ?- atom_codes(abc,X), append(X,X,L), atom_codes(N,L). X = [97, 98, 99] L = [97, 98, 99, 97, 98, 99] N = abcabc Strings werden von Prolog mit ASCII codes repräsentiert Atome sind keine strings aber können in strings umgewandelt werden 18

19 Eigenschaften Operatoren
infix: Funktoren stehen zwischen den Argumenten (z.B. :-, -->, ;, =, =.., ==, ...) prefix: Funktoren stehen vor den Argumenten (z.B. ?-) postfix: Funktoren stehen hinter den Argumenten (z.B. ++) Präzendenz: Ausgedrückt durch Zahl zwischen 0 und 1200, eine größere Zahl steht für höhere Präzedenz (z.B. hat Unifikation eine höhere Präzedenz als arithmetische Operatoren) Operatoren mit gleicher Präzedenz → Klammerung von Termen (z.B. (2 =:= 3) == =:=(2,3)) Assoziativität: Richtung der Auswertung. Linksassoziativ: 'von links nach rechts'; Rechtsassoziativ: 'von rechts nach links'. 19

20 Operatoren syntaktisch definieren
infix xfx , xfy , yfx prefix fx , fy suffix xf , yf xfx nicht-assoziativ xfy rechtsassoziativ yfx linksassoziativ Operatoren syntaktisch definieren :- op(Precedence,Type,Name). :- op(500, xf, dreams). dreams(raphael). ?- raphael dreams. true. f ist der Funktor, x und y die Argumente des Operators x → niedrigere Präzedenz y → niedrigere oder gleiche Präzedenz op definiert den Operator nur syntaktisch 20

21 Vordefinierte Operatoren
:- op( 1200, xfx, [ :-, --> ]). :- op( 1200, fx, [ :-, ?- ]). :- op( 1100, xfy, [ ; ]). :- op( 1000, xfy, [ ’,’ ]). :- op( , xfx, [ =, is, =.., ==, \==, =:=, =\=, <, >, =<, >= ]). :- op( , yfx, [ +, -]). :- op( , fx, [ +, - ]). :- op( , xfx, [ mod ]). :- op( , xfy, [ ^ ]). 21

22 Unnötig: H=<A, da komplementär zu dem Ausdruck H>A
accMax effizienz accMax([H|T],A,Max) :- (H > A, accMax(T,H,Max)) ; (H =< A, accMax(T,A,Max)). accMax([],A,A).. ?- accMax([3,4,2],0,Max). Max = 4 ; false. Unnötig: H=<A, da komplementär zu dem Ausdruck H>A Weiterer choicepoint durch logisches oder `;` Effizientere Inferenz durch “wegschneiden” des 2. Falls wenn H=<A gilt 22

23 Tracing accMax Max = 4 ; false. ?- trace, accMax([3,4,2],0,Max).
accMax([H|T],A,Max) :- (H > A, accMax(T,H,Max)) ; (H =< A, accMax(T,A,Max)). accMax([],A,A).. ?- trace, accMax([3,4,2],0,Max). Call: (7) accMax([3, 4, 2], 0, _G2281) Call: (8) 3>0 Exit: (8) 3>0 Call: (8) accMax([4, 2], 3, _G2281) Call: (9) 4>3 Exit: (9) 4>3 Call: (9) accMax([2], 4, _G2281) Call: (10) 2>4 Fail: (10) 2>4 Redo: (9) accMax([2], 4, _G2281) Call: (10) 2=<4 Exit: (10) 2=<4 Call: (10) accMax([], 4, _G2281) Exit: (10) accMax([], 4, 4) Exit: (9) accMax([2], 4, 4) Exit: (8) accMax([4, 2], 3, 4) Exit: (7) accMax([3, 4, 2], 0, 4) Max = 4 ; Redo: (8) accMax([4, 2], 3, _G2281) Call: (9) 4=<3 Fail: (9) 4=<3 Fail: (8) accMax([4, 2], 3, _G2281) Redo: (7) accMax([3, 4, 2], 0, _G2281) Call: (8) 3=<0 Fail: (8) 3=<0 Fail: (7) accMax([3, 4, 2], 0, _G2281) false. 23

24 Lösung: Choicepoint “wegschneiden” mit cut Operator `!`
Backtracking Cut Lösung: Choicepoint “wegschneiden” mit cut Operator `!` ?- trace, accMax2([3,4,2],0,Max). Call: (7) accMax2([3, 4, 2], 0, _G2281) Call: (8) 3>0 Exit: (8) 3>0 Call: (8) accMax2([4, 2], 3, _G2281) Call: (9) 4>3 Exit: (9) 4>3 Call: (9) accMax2([2], 4, _G2281) Call: (10) 2>4 Fail: (10) 2>4 Redo: (9) accMax2([2], 4, _G2281) Call: (10) accMax2([], 4, _G2281) Exit: (10) accMax2([], 4, 4) Exit: (9) accMax2([2], 4, 4) Exit: (8) accMax2([4, 2], 3, 4) Exit: (7) accMax2([3, 4, 2], 0, 4) Max = 4 . accMax2([H|T],A,Max) :- (H > A, !, accMax2(T,H,Max)) ; accMax2(T,A,Max). accMax2([],A,A). 24

25 Cut Operator schlägt nie fehl Kontrolle über Prolog backtracking
max(X,Y,Y) :- X =< Y. max(X,Y,X) :- X>Y. max(X,Y,Y) :- X =< Y, !. max(X,Y,X) :- X>Y. Cut Operator schlägt nie fehl Kontrolle über Prolog backtracking Vorsicht: Relevante Lösungen nicht “wegschneiden” → cut nur benutzen wenn sicher ist das es keine weiteren Lösungen gibt 25

26 Unnötig: X>Y, da komplementär zu X=<Y
Cut Operator Unnötig: X>Y, da komplementär zu X=<Y max(X,Y,Y) :- X =< Y, !. max(X,Y,X) :- X>Y. ?- max(2,3,2). false max(X,Y,Y) :- X =< Y, !. max(X,Y,X). ?- max(2,3,2). true Das war es noch nicht ganz, wegen Unifikation des 2. und 3. Arguments in der ersten Klausel matched nun die 2. Klausel 26

27 Lösung: Unifikation der Argumente nach cut Operator
max(X,Y,Y) :- X =< Y, !. max(X,Y,X) :- X>Y. ?- max(2,3,2). false max(X,Y,Z) :- X =< Y, !, Y=Z. max(X,Y,X). ?- max(2,3,2). false 27