Programming Languages 2e Tucker and Noonan

1. Programming Languages2e Tucker and Noonan Chapter 15 – part 2 Logic Programming “Q: How many legs does a dog have if you call its tail a leg? A: Four. Calling a tail a leg doesn’t make it one.” Abraham Lincoln

2. Review • Prolog is a logic-based language • Its syntax is based on Horn clauses, a predicate form derived from the predicate calculus. • It is also a declarative language • Prolog programs describe goals and provide facts and rules for the Prolog system to use in searching for a goal solution. • Compare to imperative languages, which describe algorithms and specify the exact steps required to achieve a goal.

3. Review • Propositions: statements which are either true or false; e.g., “my dog is black” • Propositions can be represented by symbols, combined with logical operators, and have truth values based on the individual propositions; e.g. p Λ q is true only if both p and q are true. • Predicates: Propositions with variables, and/or quantifiers: (for all) (there exists) • x(dog(x) Λ black(x)); (x)(dog(x) → black(x))

4. Review: Basic Program Elements • A Prolog program consists of terms: • Atoms: literal strings or numbers • Variables: consist of letters and underscores, must start with an upper-case letter • Atoms are distinguished from variables because atoms start with a lower-case letter • Prolog variables aren’t the same as variables in imperative languages; they don’t represent values. They are temporarily bound to objects/values during resolution. • Structures: functor(parameters) • Structures are predicates

5. Review: Facts and Rules • Prolog facts are headless Horn clauses: • student(jack, cs424). • sweet(sugar). • Prolog rules are headed Horn clauses: • fattening(X) :- sweet(X). • driversLicense(X) :- sixteen(X), passTest(X).

6. Review: Queries • Prolog programs consist of facts and rules. • Users describe goal states by posing queries. • Goals are described by assertions that state the characteristics of the desired goal. • Using the facts and rules in the program, the Prolog system attempts to find a solution to the query.

7. Review • Prolog uses resolution theorem proving, instantiation, and unification to find goal states. • The search process is a backtracking approach: in case one goal cannot be satisfied, back up to the nearest previous goal state and try another approach.

8. Example • Suppose a program has these facts & rules: • mother(sue). mother(jane).female(X) :- mother(X). • To prove/disprove the goal female(jane). • First find the fact mother(sue). Reject. • Next find mother(jane). Matches on jane • “Unify” mother(X) in the rule and mother(jane) in the fact (by instantiating X with jane) to infer female(jane).

9. Breadth-first v Depth-first Search • Suppose a query has compound goals (several propositions must be satisfied) • Depth-first searches prove the first goal before looking at the others. • Breadth-first works on goals in parallel. • Prolog uses the depth-first approach.

10. Backtracking • When a compound goal is being proved, it may be that a subgoal cannot be shown true. • In that case, Prolog will back up and try to find another solution to a previous subgoal.*

11. A Partial Family Tree Figure 15.3

12. A Small Family “Tree” Figure 15.4

13. Processing Queries • ?- father(X, sue)The query is satisfied with the first comparison. X is instantiated with john. • ?- mother(sue, X)Satisfied with X = nancy, X = jeff • ?- mother(alice, ron)Fails

14. ?- grandparent(Who, ron). • Instantiating grandparent rule from query: Grandparent(Who,ron):- parent(Who,X),parent(X,ron). • First, find a fact that satisfies parent (Who,X) • This entails finding a fact to satisfy eitherfather (Who, X) or mother(Who, X)First try: father(john, sue) - “father” rule is first • Next, find a fact that satisfies parent(sue, ron) • This does not succeed,

15. ?- grandparent(Who, ron). • Must satisfy both subgoals with same values Grandparent(Who,ron):- parent(Who,X),parent(X,ron). • The first attempt, instantiating parent(Who, X) as parent(john,sue), failed because the second subgoal, parent(sue,ron), could not be proved. • Backtrack to parent(Who, X) and use father(john, bill) fact next. • Instantiate Who=john, X=bill, and try to satisfy second subgoal, parent(bill, ron). • Success; because father(bill, ron) is a fact. • Who = john, so grandparent(john, ron)

16. Prolog Lists • The list is Prolog’s basic data structure • Lists are a series of Prolog terms, separated by commas • Each list element can be a(n) • atom • variable • sublist • etc.

17. Examples of Lists • The empty list: [ ] • List with embedded list: [girls, [like, boys]] • List with variables: [x, V1, y, V2, [A, B]] • V1, V2, A, and B are variables that may be instantiated with data at a later time. • Multi-type lists: [boy, [1, 2, 3], ran] • [A, _, Z] • The _ means “don’t care” – sometimes referred to as an unbound variable.

18. Working with Lists • [Head|Tail] notation simplifies processing: • Head represents the first list element, Tail represents everything else. • Head can be any Prolog term (list, variable, atom, predicate, etc.) • If L = [a, b, c] then Head = a and Tail = [b,c] • Tail is always another list. • What is the head of [a]? The tail?

19. The append Function • append is a built-in Prolog function that concatenates two lists. • append(A, B, L)concatenates the lists A and B and returns them as L. • append([my, cat], [is, fat], L). yieldsL = [my, cat, is, fat]

20. The Append Function • append(L1, L2, L3): append([], X, X). %base case append([Head|Tail], Y, [Head|Z]) :- append(Tail, Y, Z). • This definition says: • The empty list concatenated with any list (X) returns an unchanged list (X again). • If Tail is concatenated with Y to get Z, then a list one element larger [Head | Tail] can be concatenated with Y to get [Head | Z].

21. ?- Append([english, russian], [spanish], L). H=english, T=[russian], Y=[spanish], L=[english,Z] 1 and Z = [russian, spanish] Append([russian],[spanish], [Z]). H = russian, T=[ ], Y=[spanish], Z=[russian|Z1] 2 Append([ ], [spanish], [Z1]). So Z1= [spanish] X=[spanish], Z1=[spanish] 3 Append([ ], [spanish], [spanish]).

22. Recursion/ member • The function returns ‘yes’ if x is a member of a given list.member(X, [X | _ ]).member(X, [ _ | Y]) :- member(X, Y).

23. Member(X,Y) • The test for membership succeeds if either: • X is the head of the list [X |_] • X is not the head of the list [_| Y] , but X is a member of the list Y. • Notes: pattern matching governs tests for equality. • Don’t care entries (_) mark parts of a list that aren’t important to the rule.

24. Using append prefix(X, Z) :- append(X, Y, Z). (finds all prefixes of a list Z) suffix(Y, Z) :- append(X, Y, Z). (finds all suffixes of Z)

25. Naming Lists • Defining a set of lists: a([single]). a([a, b, c]). a([cat, dog, sheep]). • When a query such as a(L), prefix(X, L). Is posed, all three lists will be processed. • Other lists, such as b([red, yellow, green]), would be ignored.

26. A Sample List Program a([single]). a([a, b, c]). a([cat, dog, sheep]). prefix(X, Z) :- append(X, _, Z). suffix(Y, Z) :- append(_, Y, Z). % To make queries about lists in the database: % suffix(X, [the, cat, is, fat]). % a(L), prefix(X, L).

27. Sample Output ?- a(L), prefix(X, L). L = [single] X = [] ; L = [single] X = [single] ; L = [a, b, c] X = [] ; L = [a, b, c] X = [a] ; L = [a, b, c] X = [a, b] ; L = [a, b, c] X = [a, b, c] ; L = [cat, dog, sheep] X = [] Based on the program on the previous slide: a([single]). a([a, b, c]). a([cat, dog, sheep]). prefix(X, Z) :- append(X, _, Z). suffix(Y, Z) :- append(_, Y, Z).

28. Sample Output 35 ?- a(L), append([cat], L, M). L = [single] M = [cat, single] ; L = [a, b, c] M = [cat, a, b, c] ; L = [cat, dog, sheep] M = [cat, cat, dog, sheep] ;

29. The Trace Function To see the dynamics of a function call, use the trace function. For example,given the following function: factorial(0, 1). factorial(N, Result):- N > 0, M is N-1, factorial(M, SubRes), Result is N * SubRes. %is ~ assignment ?- trace(factorial/2).

30. Tracing Output These are temporary variables • ?- factorial(4, X). • Call: ( 7) factorial(4, _G173) • Call: ( 8) factorial(3, _L131) • Call: ( 9) factorial(2, _L144) • Call: ( 10) factorial(1, _L157) • Call: ( 11) factorial(0, _L170) • Exit: ( 11) factorial(0, 1) • Exit: ( 10) factorial(1, 1) • Exit: ( 9) factorial(2, 2) • Exit: ( 8) factorial(3, 6) • Exit: ( 7) factorial(4, 24) • X = 24 These are levels in the search tree

31. Logic Programming 15.2.2: Practical Aspects 15.3: Example Applications

32. Simple Arithmetic • Integer “variables” and integer operations are possible, but imperative language “assignment statements” don’t exist.

33. Sample Program • speed(fred, 60). • speed(carol, 75). • time(fred, 20). • time(carol, 21). • distance(X, Y) :- speed(X, Speed), time(X, Time), Y is Speed * Time. • area_square(S, A) :- A is S * S.

34. Prolog Operators • is can be used to cause a variable to be temporarily instantiated with a value. • Does not have the same effect as an assignment statement, because the effect isn’t permanent. • The not operator is used to indicate goal failure. For example not(P) is true when P is false.

35. Arithmetic • Originally, used prefix notation +(7, X) • Modern versions have infix notationX is Y * C + 3. • Qualification: Y and C must be instantiated, as in the Speed program, but X cannot be (It’s not a traditional assignment statement). • X = X + Y is illegal. • X is X + Y is illegal. “Arguments are not sufficiently instantiated”

36. More About Arithmetic • Example of simple arithmetic • ?- x is 3 + 7. • x = 10 • Yes • Arithmetic operators: +, -, *, /, ^ (exponentiation) • Relational operators: <, >, =, =<, >=, \=

37. Revisiting the Trace Function • At the prompt, type “trace.” • Then type the query. • Prolog will show the rules it uses and the instantiation of unbound constants.

38. Revisiting The Factorial Function Evaluation of clauses is from left to right. Note the use of is to temporarily assign values to M and Result

39. Trace of Factorial (4)

40. Other Features • cut (!) – controls backtracking • not( ) – negation • assert(C) – add to database • retract(C) – removes from database

41. The cut & not Operators • The cut (!) is used to control backtracking. • It tells Prolog to stop at this point (if the goals have succeeded once). • Reasons: Faster execution, saves memory • Not(P) will succeed when P fails. • In some places it can replace the ! Operator.

42. Example: Revised Factorial factorial(N, 1):- N < 1, !. factorial(N, Result):- M is N – 1, factorial(M, P), Result is N * P. factorial(N, 1):- N < 1. factorial(N, Result):- not(N < 1), M is N–1, factorial(M, P), Result is N * P.

43. When Cut Might Be Used(Clocksin & Mellish) • To tell Prolog that it has found the right rule: • “if you get this far, you have picked the correct rule for this goal.” • To tell Prolog to fail a particular goal without trying other solutions: • “if you get to here, you should stop trying to satisfy the goal.” • “if you get to here, you have found the only solution to this problem and there is no point in ever looking for alternatives.”

44. f(X, 0) :- X < 3, !. f(X, 2) :- 3 =< X, X < 6, !. f(X, 4) :- 6 =< X. 14 ?- consult('C:/Temp/prologProgs/cut_example.pl'). % C:/Temp/prologProgs/cut_example.pl compiled 0.00 sec, 8 bytes true 15 ?- f(1, Y), 2 < Y. false 16 ?- X = 4, f(X, Y), 2 < Y. false ?- X = 4, f(X, Y). X = 4, Y = 2. Since the three rules above are mutually exclusive, once one rule succeeds there is no need to try another. In the first example, rule 1 succeeds ( X < 3). If we try rules 2 and 3 they will fail. In the second case (X = 4) the second rule succeeds. The cut symbol prevents further attempts that will fail anyway.

45. Family Tree – Assert() 15 ?- child(jeff). ERROR: Undefined procedure: child/1 16 ?- assert(child(jeff)). Yes 17 ?- child(jeff). Yes

46. Assertand Retract • More sophisticated uses: assert can be embedded in a function definition so new facts and rules can be added to the database in real time. • Useful for learning programs, for example. • Retract(C) deletes a clause that matches C

47. Symbolic Differentiation Rules Figure 15.9

48. Prolog Symbolic Differentiator Figure 15.10

49. Search Tree for the Query d(x, 2*x+1, Ans) Figure 15.11

50. Executing a Prolog Program • Create a file containing facts and rules; e.g., familytree.pl or download the sample program from the class web page. • From the Start menu select SWI-Prolog/Prolog • Under the file drop-down menu select consult to load the file into the interpreter. • From the Start menu select consult and browse to the file you want to execute. Double click and it will compile and be ready to query. • Type queries and the interpreter will try to find answers • ?- owner(X, Y). • See the web page for more complete instructions.