1. (9.1) COEN 171 - Logic Programming  Logic programming and predicate calculus  Prolog statements  Facts and rules  Matching  Subgoals and backtracking  List operations  Arithmetic  Controlling backtracking  Running Prolog  N queens hints

2. (9.2) Logic Programming  Logic programming – uses a form of symbolic (mathematical) logic as programming language » declarative language – imperative and functional languages allow programs that describe how to compute a solution – declarative languages allow programs that describe facts about the problem domain and the form of the result (what, not how) » how to achieve that result is left up to the system

3. (9.3) Predicate Calculus  Predicate calculus is one form of symbolic logic  Propositions consist of – atomic propositions consist of compound terms – compound terms have a functor (name or relation) and arguments » professor (ron) » nieces (heidi, sasha, anna) » professor (Z), where Z is a variable – compound propositions consist of 2 or more atomic propositions joined by logical connectors

4. (9.4) Predicate Calculus (continued)  A clausal form is a standard way of writing propositions

5. (9.5) Predicate Calculus (continued)  One wants to infer things from propositions  Can do so using resolution techniques

6. (9.6) Predicate Calculus (continued)  Unification is the process of selecting values for variables in clauses – “instantiating” variables  With resolution, can use a restricted kind of clause called Horn clauses – nothing on the left side (no implication, either) » niece (anna, ron)% state facts – single atomic proposition on the left side (“headed” Horn clause

7. (9.7) Prolog  Prolog is the most prominent example of a declarative language  Prolog uses resolution and unification on Horn clauses  Prolog statements consist of terms – constants » atom (any string of letters, digits, and _ starting with a lower case letter, or any printable string in single quotes) anna miss_JONES ‘South America’ » numbers(integers or reals, usually integers) – variables » any string of letters, digits, and _ starting with an upper case letter or an _ X List_2 _

8. (9.8) Prolog (continued)  Prolog statements (continued) – structures » functor and arguments, which may also be structures professor(ron) date(4, may, 1995) date (Day, may, 1995) » defined by a name (functor) and arity (number of arguments) » so date (4, may, 1995) and date (124, 1995) are different » think of these as trees date 4may1995

9. (9.9) Facts and Rules  Prolog programs consist of facts and rules – facts are always true. they are “unheaded” Horn clauses » they need not be actually true in real life, but are in the Prolog universe – big (bear).% NOTICE “.” – small (cat). – big (mouse). – mother (ron, eva). – rules are full (“headed”) Horn clauses » head is a single term » antecedent is a single term or a series of terms joined by and – brother (X, Y) :-male (X),% “,” means – parents (X, M, F),% and – parents (Y, M, F). » can also join with “;” meaning or

10. (9.10) Matching  One of the most important operations to do on terms is matching – two terms match if » they are identical » the variables in both terms can be instantiated to objects so that the terms become identical – so date (D, M, 1981) and date (D1, july, Y1) match with the instantiations » D = D1 » M = july » Y1 - 1981 – we say matching succeeds if two terms match, otherwise it fails

11. (9.11) Matching (continued)  The formal matching rules are – if S and T are constants, then they match only if they’re the same object – if S is a variable and T is anything, they match and S is instantiated to T. Conversely, if T is a variable, then T is instantiated to S. – if S and T are structures, they match only if » S and T have the same principal functor » all their corresponding components match – triangle(point(1,1), A, point(2,3)) – triangle(X, point(4,Y), point(2,Z)) triangle point 11 234Y2Z AX

12. (9.12) Subgoals and Backtracking  Prolog operates by starting with a database of facts and rules  Then the interpreter is given a goal – Prolog searches the database trying to match the goal against a fact or the LHS of a rule – if match fact » done – if match LHS of rule » RHS of rule becomes set of subgoals, try to match subgoals in turn – if fail, back up to immediately preceding match, try to satisfy the goal that matched with a different match – subgoals are always satisfied in left-to-right order – database is always searched beginning to end » physical layout of facts and rules determines order of processing

13. (9.13) Subgoals and Backtracking (continued)  Example

14. (9.14) Subgoals and Backtracking (continued)  Failure causes control to return to previous goal (redo)  Success causes invocation of next goal Goal 1 Goal 2 call fail redo succeed Control Flow model

15. (9.15) Backtracking Performance  Reordering the clauses and goals in the database can have a significant impact on the performance of a program – consider the following examples

16. (9.16) Backtracking Performance (continued) The same logical program, with 4 different orderings of statements

17. (9.17) Backtracking Performance (continued)

18. (9.18) Backtracking Performance (continued)

19. (9.19) Backtracking Performance (continued)

20. (9.20) Backtracking Performance (continued)

21. (9.21) List Operations  Lists are one of the basic data structures of Prolog – the other is structures, which are equivalent to records  Lists are represented in programs, and printed out, as a sequence of items in [ ] – [ ann, tom, tennis, skiing ] headtail ann tom tennis skiing [ ]

22. (9.22) List Operations (continued)  Prolog provides a notation to separate head and tail of a list – [ head | tail ] » [ ann | [ tom, tennis, skiing] ]  Some useful list operations » not built in, but some are in libraries distributed with various Prologs – member (X, L) succeeds if X is in L » member (X, [X | Tail] ). » member (X, [ Head | Tail ] ) :- member (X, Tail). – conc (L1, L2, L3) succeeds if L3 = L1 concatenated with L2 » and returns L3 = L1 cat L2 » conc ([], L, L). » conc ( [X | L1], L2, [X | L3] ) :- conc (L1, L2, L3). conc ( [a, b, c], [1, 2, 3], L). L = [a, b, c, 1, 2, 3]

23. (9.23) List Operations (continued)  Useful operations (continued) – add (X, L, [X | L] ).% or just [X | L] – del (X, L, L1) deletes one occurrence of X from L giving L1 » del (X, [X | Tail], Tail ). » del (X, [Y | Tail], [Y | Tail1] ) :- del (X, Tail, Tail1). ?- del (a, [a, b, a, a], L). L = [b, a, a] ; L = [a, b, a] ; no interpreter response input goal ; typed by user causes rematch as if goal had failed

24. (9.24) Arithmetic  In Prolog, arithmetic is performed by built-in predicates that take arithmetic expressions as arguments and evaluate them  arithmetic expressions (ae) consist of numbers, variables, and arithmetic functors – arithmetic functors are » X + Y, X - Y, X * Y, X / Y (real division), X // Y (integer division), X mod Y, -X » variable must be bound to a non-variable expression at evaluation time  To evaluate an ae, pass as argument to one of these predicates – Z is X (assignment statement), X =:= Y (numeric equality test), X =\= Y (not equal), X Y, X = = Y

25. (9.25) Arithmetic (continued)  Examples – suppose database with facts born (name, yearborn). Can retrieve anyone born between 1950 and 1960 by » ?- born (Name, Year), Year >= 1950, Year =< 1960. – find the length (number of top level nodes) of a list » length ( [], 0). » length ( [X | Tail], N ) :- length (Tail, N1), N is N1 + 1. » ?- length ( [a, b, [ c, d ], e ], N). » N = 4  It’s important to differentiate between X = Y (which tries to match X and Y) and X =:= Y, which tests numeric equality » ?- 1+2 =:= 2 + 1. » yes » ?- 1 + 2 = 2 + 1 » no » ?- 1 + A = B + 2%matches and A set to 2, B set to 1

26. (9.26) Controlling Backtracking  Another way to control efficiency in a Prolog program is to directly control the backtracking mechanism  Means to do this called the cut (denoted !) – cut is a subgoal that is always satisfied, but backtracking can’t pass through » freezes choices made to that point – C :- P, Q, R, !, S, T, U. – C :- V. – Suppose try to satisfy rule A :- B, C, D. » satisfy B, try to satisfy C, match first LHS, try to satisfy P, Q, R, S, T, U » backtracking works freely when trying to satisfy P, Q or R » once past !, backtracking works freely trying to satisfy S, T or U » if S eventually fails, won’t backtrack to try other alternatives for P, Q, R, which means C fails. Also won’t try rule C :- V.

27. (9.27) Controlling Backtracking (continued)  Example – max (first, second, larger) » max (X, Y, X) :- X >= Y. » max (X, Y, Y). – if first rule succeeds, never have to check second, so add cut » max (X, Y, X) :- X >= Y, !. » max (X, Y, Y). – important if max is one of several subgoals » foo (A, B) :- max (A, B, Large), » bar (Large). – if max is satisfied by A >= B and bar fails, no point in trying to satisfy max again.

28. (9.28) N Queens Hints  One way to start this is to pass in a list of the row positions, with variables for each of the columns – variables get instantiated while executing – add rule » board ([1/C1, 2/C2,..., 8/C8]). – then to invoke your program » |?- board(Soln), nqueens(Soln). » Soln = [1/4, 2/2,..., 8/1] » type ; to find more than one solution

29. (9.29) Running Prolog  Log onto workstation in design center and type Prolog at system prompt.  The interpreter provides a top level prompt |?- – load a file » |?- [‘filename’]. – allow clauses to be entered directly from terminal » |?- [user] » |%no way to save - for play only » | ^D%control D returns to top level » |?- – to interrupt execution » |?- foo (X). » ^C » Prolog interrupt - press h for help%gets menu of choices – to exit » |?- ^D

30. (9.30) Running Prolog (continued)  debugging – |?- trace. » starts extensive tracing mode » Enter key single steps » |?- notrace. turns off trace – |?- spy (rulename). » traces only rule » |?- spy (member). » |?- nospy. turns of spy  Use Unix script command to capture screen output to hand in