Prolog. the structure Ref: Learn Prolog Now! On line Prolog Documentation. Blackburn, Bos, Striegnitz.

Transcription

1 Prolog the structure Ref: Learn Prolog Now! On line Prolog Documentation. Blackburn, Bos, Striegnitz.

2 Prolog Summary (1 page) Prolog programs consist of Facts Rules Queries a rule with no right hand side (RHS) LHS : RHS. fact/rule with value(s) / variable(s) Variables Begin with upper case letters May be instantiated on the LHS & RHS of rules Rules Composed of sub goals (other facts/rules) May be recursively defined Result returned in the last variable (or variables) Queries Facts/rules with uninstantiated variables / values, = and ; = or. = end Lists [ ] [ H T ] 2

3 Prolog important! Prolog programs consist of Facts Rules Queries Examples a rule with no right hand side (RHS) LHS : RHS. fact/rule with value(s) / variable(s) bigger(elephant, horse). // fact is_bigger(x, Y) : bigger(x, Y). // rule check facts is_bigger(x, Y) : bigger(x, Z), is_bigger(z, Y). // rule (1) is_bigger(elephant, horse). // query is_bigger(x, Y). // query // (2) (1) does there exists X bigger than Z for some Z bigger than Y? (2) what Xs are bigger than Ys? for all X and Y 3

4 Prolog Database + Query bigger(elephant, horse). bigger(horse, donkey). bigger(donkey, dog). bigger(donkey, monkey). bigger(x,y). X = elephant, X = horse, X = donkey, X = donkey, Y = horse; Y = donkey; Y = dog; Y = monkey. is_bigger(x, Y) : bigger(x, Y). is_bigger(x, Y) : bigger(x, Z), is_bigger(z, Y). is_bigger(x,y). X = elephant, X = horse, X = donkey, X = donkey, X = elephant; X = elephant, X = elephant, X = horse, X = horse, false. Y = horse; Y = donkey; Y = dog; Y = monkey; Y = donkey; Y = dog; Y = monkey; Y = dog; Y = monkey; 4

5 Prolog important! Prolog variables begin with an upper case letter Variables are only instantiated within a given fact or rule E.g. is_bigger(x, Y) : bigger(x, Z), is_bigger(z, Y). X, Y, Z only refer to values within this rule NOT between rules Variables may be instantiated in the LHS & RHS of rules A Prolog rule is a goal often composed of sub goals task(a,d) : sub_goal_a(a,b), sub_goal_b(b,c), sub_goal_c(c,d). The final variable (or variables) on the LHS is often the result For sub goals this provides the input to the next sub goal The RHS of rules are evaluated sequentially Sub goals may (often) be recursive 5

6 Review of Prolog 1 What are the main features of Prolog? bigger(elephant, horse). % facts bigger(donkey, monkey). is_bigger(x, Y) : bigger(x, Y). % rules is_bigger(x, Y) : bigger(x, Z), is_bigger(z, Y). facts + rules = knowledge base rule = head + body / fact = rule with head only facts and rules are tested sequentially if the first fails, the next one is tested variable names begin with an upper case letter or _ The last argument in a predicate is often the result 6

7 Review of Prolog 1 task(a,d) : sub_goal_a(a,b), sub_goal_b(b,c), sub_goal_c(c,d). name instantiations apply only within one rule variables are either INSTANTIATED or UNINSTANTIATED variables may be instantiated in the head OR body of a rule i.e. information passing can be left to right or right to left! lists are either empty [ ] or non empty [H T] testall : tell('library.out'), showall, told, halt. % I/O? findall(x, is_bigger(x, monkey), L). L = [donkey, elephant, horse]. (sorted) findall collects information in a list >prolog % start system? [ abc.pl ]. % load a file (quick version) 7

8 Thinking in Prolog This is not obvious! Recall in the family program, many of the lists had duplicates For multiple answers, the ; had to be used repeatedly What would be more useful would be a list! Here is ONE solution (there are no doubt many others) sbrother(x, Y, [X, Y]) : parent(z, X), parent(z, Y), malediff(x, Y). siblings(q) : findall(z, sbrother(_,_,z), L), sort(l,q). How may we reason about this solution? Where would you begin? 8

9 Thinking in Prolog sbrother(x, Y, [X, Y]) : parent(z, X), parent(z, Y), malediff(x, Y). siblings(q) : findall(z, sbrother(_,_,z), L), sort(l,q). Work up from the individual predicates parent(z, X) is true if Z is a parent of X malediff(x, Y) is true if X is male and X!= Y sbrother(x, Y, [X, Y]) is true if X and Y have the same parent, X is male and X is not Y the 3 rd argument gives a list of pairs [X,Y] findall(z, pred( Z ), L) collects the values of Z in a list L sort(l, Q) sorts a list L into Q and removes duplicates Q is a sorted list of pairs [X, Y] siblings(q) gives the list Q as a sorted list (no duplicates set) 9

10 Thinking in Prolog pbrother(x, Y) sbrother(x, Y, [X, Y]) : parent(z, X), parent(z, Y), malediff(x, Y). : parent(z, X), parent(z, Y), malediff(x, Y). Note the difference in these 2 definitions pbrother will simply list each X and Y (using ; ) sbrother will also construct a list containing [X, Y] This will give [dick, sandra], [paul, lisa], [paul, mary] sbrother + ; will still give us too much information hence we can repackage this using findall/3, as siblings(q) : findall(z, sbrother(_,_,z), L), sort(l,q). This will give us [ [dick, sandra], [paul, lisa], [paul, mary] ] How does this work? 10

11 Thinking in Prolog pbrother(x, Y) : parent(z, X), parent(z, Y), malediff(x, Y). sbrother(x, Y, [X, Y]) : parent(z, X), parent(z, Y), malediff(x, Y). BUT refactor! Can we say qbrother extends pbrother? OO think! pbrother(x, Y) : parent(z, X), parent(z, Y), malediff(x, Y). qbrother(x, Y, [X, Y]) : pbrother(x, Y). Which is more efficient / readable then define qsiblings qsiblings(q) : findall(z, qbrother(_,_,z), L), sort(l,q). 11

12 Thinking in Prolog In the library database program we had listauthor(x) : book(_,author(x),_), display(x). listlastname(x,y) : book(_,author(x),_), last(x,y), display(y). lastnames : findall(y, listlastname(_,y), _). listauthor(x) gives [patrick, henry, winston] for the first book listlastname(x, Y) gives winston for the first book (in Y) lastnames gives a list of the last names What did we do? Simply insert last(x, Y) in listlastname Then display the last names. 12

13 Thinking in Prolog What have we done so far? Defined facts, rules and queries Prolog works using relations Explored Prolog essentially as a DataBase system Abstract Programming Languages such as Prolog and Lisp are more abstract They often provide abstract data structures + operations e.g. list You require a knowledge of built in predicates e.g. last(x, Y) You need to learn more about programming paradigms Imperative, OO, relational (Prolog), functional (Lisp, Haskell) You can then start to combine these ideas in whichever language you are using e.g. a functional style in C (see DSA!) Multi paradigm programming and languages e.g. Leda, F# 13

14 Thinking in Prolog accumulators reverse(xs, Ys) : reverse(xs, [ ], Ys). reverse([x Xs], Acc, Ys) : reverse(xs, [X Acc], Ys). reverse([ ], Ys, Ys). NB: 2 reverse reverse/2 reverse/3 reverse([a,b,c], R). Call: (6) reverse([a,b,c], _G378). reverse/2 Call: (7) reverse([a,b,c], [ ], _G378). reverse/3 Call: (8) reverse([b,c], [a], _G378). reverse/3 Call: (9) reverse([c], [b,a], _G378). reverse/3 Call: (10) reverse([ ], [c,b,a], _G378). reverse/3 Exit: (10) reverse([ ], [c,b,a], [c,b,a]). reverse/3 Exit: (9) reverse([c], [b,a], [c,b,a]). reverse/3 Exit: (8) reverse([b,c], [a], [c,b,a]). reverse/3 Exit: (7) reverse([a,b,c], [], [c,b,a]). reverse/3 Exit: (6) reverse([a,b,c], [c,b,a]). reverse/2 R = [c,b,a] did you spot the stack? 14

15 Thinking in Prolog insert([], It, [It]). insert([h T], It, [It, H T]) insert([h T], It, [H NewT]) : It. : It, insert(t, It, NewT). Very often, the last argument to a predicate is the result. insert can be read as insert(list, Value, NewList) or in English: add a value to a list to produce a new list. Points to note: a Prolog list is often expressed as [H T] (head/tail) the empty list is written as [ ] names are instantiated within a rule on both the left & right The order of the rules is important if the first definition fails then the second is tried and so on 15

16 Thinking in Prolog 1. insert([], It, [It]). 2. insert([h T], It, [It, H T]) : It. 3. insert([h T], It, [H NewT]) : It, insert(t, It, NewT). 1 the empty case the result is a list with one element, It 2 the value is added at the head of the new list 3 the value is added to the tail of the list result NewT the old head is the head of the new list You have already done this in C (in DSA) the recursive version Apply this knowledge to understanding the Prolog code 16

17 insert([ ], It, [It]). (1) insert([h T], It, [It, H T]) : It. (2) insert([h T], It, [H NewT]) : It, insert(t, It, NewT). (3) [trace]? insert([1,2,3], 4, Z). Call: (6) insert([1,2,3], 4, _G379) Call: (7) 1@>4? Fail: (7) 1@>4? Redo: (6) insert([1,2,3], 4, _G379) Call: (7) 1@<4? Exit: (7) 1@<4? Call: (7) insert([2,3], 4, _G437) Call: (8) 2@>4? Fail: (8) 2@>4? Redo: (7) insert([2,3], 4, _G437) Call: (8) 2@<4? Exit: (8) 2@<4? Call: (8) insert([3], 4, _G440) Call: (9) 3@>4? Fail: (9) 3@>4? Redo: (8) insert([3], 4, _G440) Call: (9) 3@<4? Exit: (9) 3@<4? Call: (9) insert([ ], 4, _G443) Exit: (9) insert([ ], 4, [4]) Exit: (8) insert([3], 4, [3,4]) Exit: (7) insert([2,3], 4, [2,3,4]) Exit: (6) insert([1,2,3], 4, [1,2,3,4]) Z = [1, 2, 3, 4]. 17

18 Thinking in Prolog (+ Haskell + C) insert([], It, [It]). insert([h T], It, [It, H T]) insert([h T], It, [H NewT]) : It. : It, insert(t, It, NewT). badd v [ ] = v: [ ] badd v (x:xs) v < x = v : (x:xs) otherwise = x : badd v xs static listref b_add(int v, listref L) { return is_empty(l)? create_e(v) : v < get_value(head(l))? cons(create_e(v), L) : cons(head(l), b_add(v, tail(l))); } 18

19 Thinking in Prolog (+ Haskell + C) insert([], It, [It]). insert([h T], It, [It, H T]) insert([h T], It, [H NewT]) : It. : It, insert(t, It, NewT). badd v [ ] = v: [ ] badd v (x:xs) v < x = v : (x:xs) otherwise = x : badd v xs static listref b_add(int v, listref L) { return is_empty(l)? create_e(v) : v < get_value(head(l))? cons(create_e(v), L) : cons(head(l), b_add(v, tail(l))); } 19

20 Language overview: Prolog How is Prolog structured? Prolog Syntax. Terms: Atoms, Numbers, Variables, Complex Terms (Structures) Constants: Atoms, Numbers Simple Terms: Constants, Variables Character Set: A Z, a z, 0 9, symbols (+,, *, ) Atom: string of characters (including underscore) sequence of characters in single quotes a string of special characters Numbers: integers (real, floating point) 20

21 Language overview: Prolog Variables: Complex Term: Rules: Body: string of upper/lower case letters, digits starts with _ or an upper case letter functor + sequence of arguments (X,Y, ) the functor (name) must be an atom arity the number of arguments e.g. last(x, Y) is last/2 where 2 =arity abc/2 and abc/3 are distinct predicates may be nested and/or recursive Head : Body. conjunctions (,) & disjunctions (;) (and/or) Facts: Head. (rule with empty body) Clauses: rules & facts (describe relations) Execution: satisfying GOALS 21

22 Language overview: Prolog Repetition: recursion Relations: work in both directions (more later) Design Patterns: clichés or common solutions Tail Recursion: often used cliché; optimised in Prolog Higher Order predicate which takes predicates as Programming: arguments e.g. findall(x, pred(..x..), L) Hashing: often implemented Modules: not always provided Restrictions: Negation: CWA Closed World Assumption mortal(aristotle). false see CWA 22

23 Language overview: Prolog Recursive Definitions (note Tail Recursion) is_bigger(x, Y) : bigger(x, Y). is_bigger(x, Y) : bigger(x, Z), is_bigger(z, Y). Lists: [a,b,c,d,e], [] (empty list), [H T] head/tail pattern member(x, [X _]). member(x, [_ T) : member(x, T). _ is the anonymous variable ( don t care ) append([], L, L). append([h T], L2, [H L3]) : append(t, L2, L3). this predicate requires thinking about! Try it! note how the predicate works in 2 directions 23

24 Language overview: Prolog Append example how does this work? append([], L, L). append([h T], L2, [H L3]) : append(t, L2, L3). append(l1, L2, L3) is best way to think about this predicate e.g. append([a,b,c], [d,e,f], X). will give X = [a,b,c,d,e,f]. Note that the second line definition 1. Splits L1 into its head and tail components (decomposition) 2. Leaves L2 unchanged 3. Adds the head of L1 to the List L3 (recomposition) 4. The recursive descent passes tail(l1); 5. The recursive ascent adds the heads in reverse 24

25 Language overview: Prolog append([], L, L). append([h T], L2, [H L3]) : append(t, L2, L3). 1. append([a,b,c], [d,e,f], L3) L1 not [] 2. append([b,c], [d,e,f], L3) L1 not [] 3. append([c], [d,e,f], L3) L1 not [] 4. append([], [d,e,f], L3) L1 is [], L3 = [d,e,f] 5. Return recursive calls! 6. append(_, _, c [d,e,f]) L3 is [c,d,e,f] 7. append(_, _, b [c,d,e,f]) L3 is [b,c,d,e,f] 8. append(_, _, a [b,c,d,e,f]) L3 is [a,b,c,d,e,f] 9. Finished! 25

26 Language overview: Prolog Rule (1): Rule (2): append( [], L, L). append( [H T], L2, [H L3]) : append(t, L2, L3). trace: append([a,b], [c,d], L3). Call: (6) append( [a,b], [c,d], _G382) ; Rule (2) Call: (7) append( [b], [c,d], _G443) ; Rule (2) Call: (8) append( [], [c,d], _G446) ; Rule (1) Exit: (8) append( [], [c,d], [c,d]) ; Rule (1) Exit: (7) append( [b], [c,d], [b,c,d]) ; Rule (2) Exit: (6) append( [a,b], [c,d], [a,b,c,d]) ; Rule (2) L3 = [a,b,c,d]. 26

27 Language overview: Prolog Rule (1): Rule (2): append([], L, L). append([h T], L2, [H L3]) : append(t, L2, L3). Deconstruction phase Rule(2) goes from Left to Right Rule (2): Call (1) append([ a b ], [ c, d ], [ a L3] ) : append( [ b ], [ c, d ], L3). Rule (2): Call (2) append([ b [ ] ], [ c, d ], [ b L3] ) : append([ ], [ c, d ], L3). Rule (1): Call (3) append([ ], [c,d], [c,d] ) i.e. List2 [c,d] is "copied" to L3 Reconstruction phase Rule(2) goes Right to Left i.e. L3 is "passed back" to the Left Hand Side Rule (1): Exit (3) returns append( [ ], [ c,d ], [ c,d ] ) i.e. List2 [c,d] is "copied back" to L3 Rule (2): Exit (2) returns append( [ b ], [ c, d ], [ b [ c, d ] ) i.e. append([ b ], [ c, d ], [ b, c, d ] ) List [ b, c, d] is "copied back" to L3 Rule (2): Exit (1) returns append[ a b ], [ c,d ], [ a [ b, c, d ] ) i.e. append( [ a,b ], [ c,d ], [a, b, c, d]) L3 is List [a, b, c, d] answer L3 is [a, b, c, d] 27

28 Language overview: Prolog Some list predicate examples (you would expect these!) length([a,b,c], X). X = 3. member(a, [a,b,c]). true. member(x, [a,b,c]). false. last([a,b,c], X). X = c. reverse([a,b,c], X). X = [c,b,a]. select(a, [a,b,c], X). X = [b,c]. append([a,b,c], [d,e,f], X). X = [a,b,c,d,e,f]. append(x, Y, [a,b,c,d]). X = [], Y = [a,b,c,d] ; X = [a], Y = [b,c,d] ; X = [a,b], Y = [c,d] ; X = [a,b,c], Y = [d] ; X = [a,b,c,d], Y = [] ; false. 28

29 Language overview: Prolog Some arithmetic predicate examples X is X is 4. X is +(2, 2). X is 4. Similarly for 2 2; 2*2; 2/2; mod(7,2); 3+2*4; (3+2)*4; etc. The usual arithmetic precedence rules apply Comparison: X op Y: op: <, =<, =:=, =/=, =>, > Notation: Prolog uses 2+2 as well as +(2, 2) The arithmetic operators are in fact predicates e.g. +/2, +/1 29

30 Language overview: Prolog Some predicates for terms NB: Prolog is a type free language as such these languages require predicates to test properties of constructs e.g. terms is the argument atom/1 an atom? integer/1 an integer? float/1 a floating point number? number/1 a number? atomic/1 a constant? var/1 nonvar/1 an uninstantiated variable? an instantiated variable OR another term not an uninstantiated variable 30

31 Language overview: Prolog More predicates for terms functor/3 name and arity of a predicate? functor(append(l1, L2, X), F, A). F = append. A = 3. arg/3 value of the nth argument? arg(2, append([a,b], [c,d],x), A). A = [c,d]. =.. /2 functor + args list? append([a,b], [c,d], X) =.. Z. Z = [append, [a,b],[c,d], X]. 31

32 Language overview: Prolog Some predicates for strings ( = list of ASCII codes)? atom_codes(donald, X). X = [100, 111, 110, 97, 108, 100].? atom_codes( Donald, X). X = [68, 111, 110, 97, 108, 100].? 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 Similarly for numbers? number_codes(123, X). X = [49, 50, 51]. 32

33 Language overview: Prolog Some simple I/O predicates From the library database example testall : tell('library.out'), showall, told, halt. tell change the standard output (screen) to a file showall process information told switch the standard output back to the screen display(x) : tab(3), write(x), nl. From the lab 2 code see(file), get0(c), readword(c,w,c1), restsent(w,c1,ws), seen. see(file) switch input to file input get0(c) read a character from the file seen switch standard input back to the keyboard 33

34 Language overview: Prolog Some simple I/O predicates display/ copy a file process(file) : open(file, read, In), get_char(in, Char1), process_stream(char1, In), close(in). process_stream(end_of_file, _) :!. // cut stops process process_stream(char, In) : print(char), get_char(in, Char2), process_stream(char2, In). p1 : process('iotest.in'). p2 : tell('iotest.out'), process('iotest.in'), told. 34

35 Language overview: Prolog Some simple I/O predicates formatting Ref: SICStus Prolog User's Manual format/2 and format/3 provide an interface to the C s <stdio.h> function printf Examples are given in the above reference for those interested See / seen & tell / told come from the DEC 10 Prolog file I/O Again see the above reference The SICStus Prolog User's Manual will also give you an idea of the level of sophistication Prolog has reached Link: 35

36 Language overview: Prolog Summary what to focus on Thinking in Prolog & writing programs Use the built in predicates Write short predicates which may be further combined Be aware that relations work in 2 directions Use patterns such as tail recursion & [H T] Try to program abstractly think first what you want to do! Learning Prolog Start with short programs (course/web examples) Use web sources to find examples e.g. Rosetta Code Experiment and make mistakes!!! 36