Logic Programming

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 doesnt 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 arent the same as variables in
  imperative languages they dont 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),pare
  nt(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,ro
  n).
• 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 Whojohn, Xbill, 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 Prologs 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 dont care sometimes referred to
  as an unbound variable.

18
Working with Lists

• HeadTail 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(HeadTail, Y, HeadZ)
• - 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).
Henglish, Trussian, Yspanish,
Lenglish,Z 1
and Z russian, spanish Append(rus
sian,spanish, Z). H russian, T ,
Yspanish, ZrussianZ1 2 Append( ,
spanish, Z1). So Z1
spanish Xspanish, Z1spanish
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.
• Dont care entries (_) mark parts of a list that
  arent 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 gt 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 dont exist.
• 6 ?- X 3 6.
• X 36.
• 7 ?- X is 3 6.
• X 9.
• 8 ?- Y is X 4.
• ERROR is/2 Arguments are not sufficiently
  instantiated

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 isnt 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 (Its 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
• Arithmetic operators , -, , /,
  (exponentiation)
• Relational operators lt, gt, , lt, gt, \

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 lt 1, !. factorial(N,
Result)- M is N 1, factorial(M,
P), Result is N P.
factorial(N, 1)- N lt 1. factorial(N, Result)-
not(N lt 1), M is N1, 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 lt 3, !. f(X, 2) - 3 lt X, X lt 6,
!. f(X, 4) - 6 lt X. 14 ?- consult('C/Temp/prol
ogProgs/cut_example.pl'). C/Temp/prologProgs/cu
t_example.pl compiled 0.00 sec, 8 bytes Yes 15
?- f(1, Y), 2 lt Y. No 16 ?- X 4, f(X, Y), 2 lt
Y. No
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 lt 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
Assert and 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, 2x1, Ans) Figure
15.11
50
Executing a Prolog Program

• Create a file containing facts and rules e.g.,
  familytree.pl
• Under the file drop-down menu in SWiplEdit select
  open to load the file into the interpreter.
• From the Start menu select consult
• Type queries and the interpreter will try to find
  answers
• ?- talkswith(P1, P2).

51
SWIplEdit compile error

• If SWI-Prolog finds an error in the .pl file it
  will give a message such asERROR
  c/temp/prologprogs/remove.pl180 Syntax
  error Illegal start of term(18 is the line
  number)

52
Runtime Error Message

• The function samelength was called with one
  parameter when it needed 221 ?-
  samelength(X).ERRORUndefined procedure
  samelength/1ERRORHowever, there are
  definitions for samelength/2

53
Runtime Errors

• Here, the error is an error of omission22 ?-
  samelength(a, b, c,,a, b)
• Queries must end with a period. If you hit
  enter without typing a period SWIpl just thinks
  you arent through.

54
Using SWI Prolog

• If there is an error that you cant figure out
  (for example you dont get any answers, you dont
  get a prompt, typing a semicolon doesnt help)
  try cancel under the Start button.
• If changes are made to the program, dont forget
  to consult again.

55
Test Review

• Chapter 6.1 (Type Systems)
• Chapter 7.1-7.5 (Semantics)
• Chapter 12 (Imperative Programming)
• Chapter 13 (Object Oriented Programming)
• Chapter 15 (Logic Programming)
• Python Scripting Languages (from the notes).

56
Homework Questions I Might Have Assigned

• In C-like languages, when an expression consists
  of two or more sub-expressions , such as a f(a)
  or xy xy or x/3 y 4(xy), the
  sub-expressions are evaluated
• Left-to-right
• Right-to-left
• It depends on the precedence of the operators in
  the sub-expression
• It depends on the compiler.

57
Homework Questions I Might Have Assigned -
Functions

• int a 0
• ..
• 11 int newVal(int c)
• 12
• ..
• void main ( )
• ..
• return 0
• ------------------------------------------
• Show the stack of activation records as it would
  exist when line 8 has executed but before line 9
  executes. Your answer should follow the format in
  Figure 9.8
• Show the stack again after the execution of line
  23, but before the main function terminates.

58
Homework Questions I Might Have Assigned

• Consider the following Horn clauses
• parent(X, Y)- father(X, Y).
• grandparent(X,Z)- parent(X,Y), parent(Y,Z).
• Use resolution, as in Prolog, to deduce a new
  proposition from the two above

59
Homework Questions I Might Have Assigned

• Write a rule for the family tree data base that
  defines a sister relation
• For example the sister of X has the same father
  or mother.