AI2 Remedial Prolog Tutorial 2

Transcription

1 AI2 Remedial Prolog Tutorial 2 Rules The Prolog interpreter is able to make inferences (i.e. reasoning of the form If Alan drinks beer, then he must like it). This is done by way of using rules. There are three parts to a rule: a) The predicate (usually with at least one variable argument) we want to prove to be true b) :- (read as if) c) The factual conditions that need to succeed in order to prove the goal predicate to be true. If more than one, each condition is separated from the others by a,. These facts could also have variables as an argument. Write the following in terms of Prolog rules: If Alan drinks beer, then he likes it. likes(alan,beer) :- drinks(alan,beer). If a person is rich and famous, then they are happy. happy(person) :- rich(person), famous(person). A person is happy if they are healthy or wealthy or wise. happy(x) :- healthy(x). happy(x) :- wealthy(x). happy(x) :- wise(x). An item is fun if it is red and a car or blue and a bike. fun(x) :- red(x), car(x). fun(x) :- blue(x), bike(x). Two different people like the same drink if each of them drinks it. like(a,b,drink) :- likes(a,drink), likes(b,drink). Recursion A Prolog rule is recursive if the goal predicate calls itself among its condition predicates. This is useful if we want to repeatedly perform some operation over a whole data structure or until some stopping condition is reached. Write recursive rules to express the following: Given two people A and B, A likes B if both A and B like the same drink. (use likes/2) likes(a,b) :- likes(a,drink), likes(b,drink). An ancestor is a parent or a parent s ancestor. (use ancestor/2 and parent/2) 1

2 ancestor(a,b) :- parent(a,b). ancestor(a,b) :- parent(c,b), ancestor(a,c). It might be tempting to write this as: ancestor(a,b) :- ancestor(a,c), parent(c,b). but this would send prolog into a loop and produce an error such as: %%% Local stack overflow forced to apport %%% You talk about someone if you kw them or you kw someone who talks about them. (use talks_about/2 and kws/2) talks_about(a,b) :- kws(a,b). talks_about(a,b) :- kws(a,c), talks_about(c,b). Given the following program answer questions a, b, c and d and explain why you have reached your answer has_flu(x):- infected(x). 2. has_flu(x):- kisses(x,y), has_flu(y). 3. infected(john). 4. kisses(sue,john). 5. kisses(john,ann). 6. kisses(sally,ann). 7. kisses(fred,sue) a.?- has_flu(john).. b.?- has_flu(sue).. rule 2 succeeds using fact 4 c.?- has_flu(sally).. ne of the facts can satisfy the rules d.?- has_flu(fred).. rule 2 succeeds using fact 7 rule 2 succeeds using fact 4 How would we find out all the people with flu??- has_flu(x). And then back tracking using the semicolon ; key 2

3 Lists Lists allow us to manipulate a collection of data such as all the people with flu in the above example. a) A list is an ordered sequence of elements separated by commas e.g. [a,b,c,d,x,r,[2,g,t]]. b) [] depicts an empty list. c) A list can be split into its head and tail e.g. [H T]. This is useful to access elements of the list and is referred to as list destruction. d) The = predicate is used to unify two arguments and can be used to match a list with a variable or two lists to each other e.g. SomeList = [fred,jack,sally,lisa]. For each of the following determine the head and tail of the list. List Head Tail [a, b, c, d] a [b,c,d] [a] a [] [] fails fails [[the, cat], sat] [the,cat] [sat] [the, cat] the [cat] [the, [cat, sat]] the [[cat,sat]] [the, [cat, sat], down] the [[cat,sat],down] [X, Y, Z] X [Y,Z] Determine whether a match takes place between each of the following list pairs. If so write down the instantiations that take place.?- [john,june,a] = [X,Y,tom]. X=john Y=june A=tom (simple match of constants and variables)?- [H T] = [c,b,a]. H=c T=[b,a] (splits list into head and tail)?- [H T] = []. (the empty list can t be split by the list destructor ' ')?- [] = []. (empty lists always match)?- [A [B,C]] = [c,b,a]. A=c B=b C=a ([A [B,C]] is the same as [A,B,C]) 3

4 ?- [a,x] = [X,b]. (X can t unify with two different constants a and b)?- [sue,[dick,wendy],p] = [P,Q,R]. P=sue Q=[dick,wendy] R=sue (R and P share)?- [X Y] = [a(b,c),b,c]. X=a(b,c) Y=[b,c]?- [[X],Y] = [a,b]. (constant a can t match to list [X])?- [a X] = [A,B,y]. A=a X=[B,y]?- [fred []] = [X]. X=fred ([fred []] same as [fred])?- [a,b,x,c] = [a,b,y]. (different length lists can t unify)?- [H T] = [tom,dick,mary,fred]. H=tom T=[dick,mary,fred]?- [[sue,tom],[10,9]] = [names,ages]. (constants don't match lists) List Construction and Manipulation We can construct new lists by simply adding elements onto the head or tail of ather list. For example given: OldList = [happy,sad]; AtherList = [1,2,3]; We can add grumpy to the head of the list by: NewList = [grumpy OldList]; 4

5 Or to add more elements at once we could do this: NewList = [grumpy,elated OldList]; We can also add elements to the tail of a list: NewList = [OldList AtherList]; # this gives [[happy,sad],1,2,3] NewList = [OldList [grumpy,elated]]; # this gives [[happy,sad],grumpy,elated] Write a recursive predicate checklist/2 to check if two lists unify by checking if their heads unify and recursing on their tails. checklist([],[]). (base case) checklist([x T],[X Z]) :- checklist(t,z). (recursive) It is important to put the base case first as this signifies when we want to stop our search. In this case we want to stop checking once we hit the end of our lists. Lists can unify if their elements can unify so we want to check and see if their heads are the same (in the case of constants we are checking to see if the values are the same; if variables then we are checking if the variables can unify with the constants or variables of the other list). If the heads can unify then we call checklist/2 again to check if the tails also match. Write a recursive predicate member/2 to check if an item is a member of a list. (hint: you need to check if the item is the same as the head of the list or is in the tail.) member(x,[x _]). (base case) member(x,[h T]) :- member(x,t). (recursive) In this case we want to stop searching as soon as we find that our X is in the list. We put an '_' in the place of our tail whenever we don't care about its value. So in this case so long as X is found in the head of the list we don't care what the tail is and we can stop. If the base case fails we can assume that our X is t in the head of the list and so we can continue the search by recursing through the tail of our list. Therefore, we don't need to add the condition 'X\==H;' before our recursion in the second rule. Some pointers In a recursive rule the condition that is used to stop the recursion is called the base case. The base case is usually a one liner. E.g. foo([],[]). This means stop recursing once you reach the end of the list and return successfully. E.g. foo(x,[x T]). This means stop recursing once you find that the argument is the same as the head of the list and return successfully. Two predicates are only considered the same if they have the same name and the same number of arguments. E.g. foo/2 and foo/3 are t the same thing. E.g. foo/2 and foo/2 are the same thing. 5