COSC3306:%20Programming%20Paradigms%20Lecture%209:%20Declarative%20Programming%20with%20Prolog

1
COSC3306Programming ParadigmsLecture 9
DeclarativeProgramming with Prolog

• Haibin Zhu, Ph.D.
• Computer Science
• Nipissing University (C) 2003

2
Contents

• Prolog
• Program structure
• Logical variable
• Syntax structure
• Prolog facilities
• Control structure
• Resolution and unification
• DFS
• Backtracking
• Deficiencies of Prolog
• Cut Operator
• Recursive Rules

3
Prolog

• At the heart of the Prolog is a stored base of
  information usually called a knowledge base or
  database, which consists of facts and rules. The
  system is interactive in which the user interacts
  with the system on a question and answer basis.
  Answering a question involves processing the data
  held in the knowledge base. A general structure
  of Prolog is

4
Prolog

• The basic features of Prolog include a powerful
  pattern-matching facility, a backtracking
  strategy that searches for proofs, uniform data
  structures from which programs are built, and the
  general interchangeability of input and output.
  Owing to the lack of a standard definition,
  several dialects of Prolog evolved, differing
  even in their basic syntax. Fortunately, the
  Edinburg version in now widely accepted as a
  standard.

5
Program Structure

• A prolog program consists of three major
  components stated as
• Series of rules that define the problem domain,
  which is the relation between objects
• Series of facts that define the
  interrelationships among the known objects and
• Logical statement known as goal or query that is
  a question from the Prolog system to either prove
  or disprove.

6
Program Structure

• In general, the set of facts and rules is called
  assertions or axioms and describes logical
  relationships among objects and is the basis for
  the theorem-proving model of Prolog system.
  Prolog programming language restricts us to the
  logical statements (Horn clauses) of the form
• A - A1, A2, , An.
• The symbol - means if and the symbol , means
  and. A is the head (goal) of the logical
  statement, A1, A2, , An forms the body
  (subgoals), and a period terminates every Prolog
  axiom. Ai is called a literal, which is a
  relationship between objects or the negation of a
  relationship between objects.

7
Example

• The following literals can express the
  relationship between two objects, seyed and mary.
• likes(seyed, mary).
• father_of(seyed, mary).

?x pet(x) ? small(x) ? apartment(x) ?x cat(x) ?
dog(x) ? pet(x) ?x poodle(x) ? dog(x) ?
small(x) poodle(fluffy) (Logic)
apartment(X) - pet(X), small(X). pet(X)-
cat(X). pet(X)- dog(X). dog(X)-
poodle(X). small(X) - poodle(X).
poodle(fluffy) (Prolog)
8
Query

• Query is the given input to a program, which is
  treated as a goal to be proved. In other words,
  the query is a question asking about objects and
  their relationships. In prolog, a query is just
  like a fact or rule, except that it is started
  with a special symbol ?-, a question mark and
  a -, hyphen.
• For example, in a query as the form
• ?- A1, A2, , An.
• In this case, we proceed by satisfying A1, and
  A2, and , An separately as subgoals.
• If all subgoals succeed, then we conclude that
  the goal succeeds.
• We use the convention that the names of all
  objects and relationships start with a lowercase
  character and variables start with an uppercase
  letter.

9
Logical Variable

• The variable in imperative language is not the
  same concept as a variable in logic programs
• A program variable refers to a memory location
  that may have changes in its contents consider
  an assignment N?N?1.
• A variable in logic program simply stands for a
  value that, once determined, will not change. For
  example, the equation X?3Y?11 and 2X?3Y?4 specify
  value for X and Y namely X?5 and Y?2, which will
  not be changed in this context. A variable in
  Prolog is called a logical variable and acts in a
  manner differently. Variables are strings of
  characters beginning with an uppercase letter or
  an underscore.
• Once a logical variable is bound to a particular
  value, called an instantiation of the variable,
  that binding cannot be altered unless the pattern
  matching that caused the binding is undone
  because of backtracking.

10
Logical Variable

• The destructive assignment of imperative
  languages, where a variable with a value binding
  is changed, cannot be performed in logic
  programming.
• Terms in a query change only by having variables
  filled in for the first time, never by having a
  new value replace an existing value.
• An iterative accumulation of a value is obtained
  by having each instance of a recursive rule take
  the values passed to it and perform computations
  of values for new variables that are then passed
  to another call.
• Since a logical variable is bounded once, it is
  more like a constant identifier with a dynamic
  defining expression as in Ada than a variable in
  an imperative language.

11
Example

• parent(seyed, mary).
• parent(seyed, mahsa).
• parent(mary, leily).
• parent(mahsa, victoria).

Some queries ? parent(seyed, mary). yes ?
parent(X, leily). X?mary yes ? parent(seyed,
X). X?mary X?mahsa no ? parent(X,
Y). X?seyed Y?mary yes
? The user-typed semicolon asks the system for
more solutions

• System will list all of the parent pairs, one at
  a time if semicolons are typed.

12
Prolog Syntax-Constants

• A Constant is one of
• Atom
• Integer
• Real Number
• Atoms are made up of
• letters and digits AB...Zab...z01...9 and _
  (underscore)
• symbol any number of , -, , /,

13
Variables

•   Variables usually start with a capital letter.
  The only interesting exception is the special
  anonymous variable written _ and pronounced
  underscore''. In the rule process(X,Y)-
  generate(_,Z),
• test(_,Z),
• evaluate(Z,Y).
• the underscores refer to different unnamed
  variables. For example, here are two versions of
  member/2.

14
Compound Terms

• A Compound Term is a functor with a (fixed)
  number of arguments each of which may be a Prolog
  term.
• happy(fred)
• principal functor happy
• 1st argument a constant (atom)
• sum(5,X)
• principal functor sum
• 1st argument constant (integer)
• 2nd argument variable
• not(happy(woman))
• principal functor not
• 1st argument compound term

15
BNF Specification
16
Prolog Facilities-Arithmetic

• ?- X is 34.
• ?- X is 5-4.
• ?- X is 34.
• ?- X is 8/2.
• ?- X is 5 mode 2.

17
Comparisons

• XltY.
• XgtY.
• XltY.
• XgtY.
• X\Y.
• XY.

18
List Operations

• List is a sequence of elements that are separated
  commas, shown between brackets, and have any
  length.
• HT expresses a list
• H matches the head of the list
• T matches the tail

List Head Tail a, b, c, d a b, c, d
none none the, man, human the,
man human the, man, human the man,
human the, man, human, arm the man,
human, arm
19
Examples

• Last(X, X).
• Last(X, HT)-last(X,T)
• ?-Last(X, a,b,c,d).
• X d
• Member(X,XT).
• Member(X,HT)-member(X,T).
• ?- member(a, a,b,c,d)
• Yes.

20
Examples

• Concat(, L, L).
• Concat(HT, L, HM))-concat(T, L, M).
• ?-Concat(a,b,c,b,e,R).
• R a,b,c,d,e.
• ?-append(.)

21
Input and Output

• Read(X).
• Average-read(X), read(Y), Z is (XY)/2.
• Write (variable).
• ?-X is 210, write (x).
• Other examples
• http//www.cs.dartmouth.edu/jaa/CS118.99S/Samples
  /Prolog/
• http//www.csci.csusb.edu/dick/cs320/lab/10.html

22
To be Continued

• Control Structure
• Resolution
• Unification
• DFS

23
Control Structure

• Because Prolog has been implemented with a
  concern for efficiency, its control strategy acts
  with a deterministic approach for discovering
  proofs. The control system in Prolog can be
  characterized by two criteria
• Goal order, meaning that the control system
  chooses the first leftmost subgoal.
• Rule order, meaning that the control system
  selects the first logical statement.

24
Control Structure

• This indicates that, the response to a query is
  affected both by subgoal orders within the goal
  and by the logical statements order within the
  knowledge base of facts and rules.
• There are two opposite methods in which goal can
  be proved as top-down approach which is similar
  to recursion also called backward chaining and
  bottom-up approach which is similar to iteration
  also called forward chaining. There are various
  mixtures of top-down and bottom-up that work from
  both the goal and the hypotheses. It is worth
  noting that, bottom-up control approach is more
  efficient than top-down approach, since the
  bottom-up execution does not recompute the
  subgoals.

25
Top-down Approach

• In this approach, we start with the goal and
  attempt to prove its correctness by finding a
  sequence of matching logical statements that lead
  to some set of original facts in the knowledge
  base, meaning that all possible resolution and
  unification could be performed until the goal is
  proved. The top-down approach execution of a
  logic program is similar to recursive execution
  of a procedure.
• The goal G is empty and True is reached.
• No logical statement applies to the leftmost
  subgoal of G.

26
Example

• Assume a knowledge base contains the following
  fact and rule.
• mother(mary).
• female(X) mother(X).
• To trace the query female(mary), in top-down
  approach the Prolog would be required to choose
  goal as starting logical statement and use it to
  infer the truth of the goal. In this example, a
  new logical statement mother(mary) can be deduced
  by matching the goal female(mary) and the second
  logical statement female(X) mother(X) in the
  knowledge base through instantiation of X to
  mary. The goal can be inferred, because the new
  generated logical statement mother(mary) is
  similar to the first logical statement of the
  knowledge base.

27
Bottom-up Approach

• In the bottom-up, we start with the hypotheses
  which is the assumption that the goal is correct
  and attempt to reach the goal. This indicates
  that we start with the facts and rules of the
  knowledge base and attempt to find a sequence of
  matches that lead to the goal. In general
  bottom-up approach works well when the number of
  possibly correct answers is large. The bottom-up
  control can stop in one of two cases
• The goal G is achieved and True is reached.
• No logical statements can satisfy each other in
  order to make a new logical statement.

28
Example

• Assume a knowledge base contains the following
  fact and rule.
• mother(mary).
• female(X) mother(X).
• To trace the query female(mary), in bottom-up
  approach the Prolog would be required to search
  through the knowledge base in order to make a
  logical statement correspond to the goal. In this
  example, the goal can be deduced by matching the
  first fact mother(mary) with the right side of
  the second rule female(X) mother(X) through
  instantiation of X to mary. A new generated
  logical statement as female(mary) indicates that
  the goal can be inferred, because it is similar
  to the goal.

29
Resolution and Unification

• As an important practical application, resolution
  theorem proving also known as the resolution
  refutation system has made the current generation
  of Prolog interpreter possible.
• Unification is the search process of finding the
  general substitution of variables that makes two
  literally identical.
• In general, when the interpreter tries to verify
  a goal it searches the database of facts and
  rules to find a matching fact or rules head.
  This is corresponding to pattern matching and
  variable binding.

30
Unification

• Selects a fact if
• The name is the same as that of the goal to be
  proven.
• The number of arguments is the same.
• For all corresponding arguments one of the
  following conditions holds
• They are exactly the same constant.
• They are an unbound variable and a constant. In
  this case the variable becomes bound to the
  constant.
• They are both variables. In this case, if one is
  bound then the other becomes bound to the same
  object. If both are bound, then both become bound
  to the same object.
• If no matching fact or rules head can be found
  by unification, then the goal fails.
• This indicates that, the resolution and
  unification works by canceling out matching
  literals that appear on different sides of the
  - sign. If we have two logical statements, any
  two matching (or unifiable) literals, which
  appear both on the right of one of them and on
  the left of the other, cancel each other out.

31
Example

• Consider the following facts and rules translated
  into Prolog clause form on the right.
• (1) - a. ? a
• (2) a - b, c, d. ? b ? ? c ? ? d ? a
• (3) b - e, f. ? e ? ? f ? b
• (4) c - c
• (5) d - d
• (6) e - e
• (7) f - f

32
The procedure of resolution for the above example

• The literal e in line 6 can be unified with the
  literal e in line 3.
• The literal f in line 7 cancels out the literal f
  in line 3.
• The literal b in line 3 cancels out the literal b
  in line 2.
• The literal c in line 4 can be resolved with the
  literal c in line 2.
• The literal d in line 5 cancels out the literal d
  in line 2.
• After all the above, we are left with the literal
  a in line 2, that can be canceled out with the
  original query, the literal a in line 1.

33
Resolution by unification

• However, two literals do not have to be identical
  to be resolved. For example, in the following
• parent_of(X, Y) - father_of(X, Y), male(X).
• father_of(john, mary).
• male(john).
• father_of(X, Y) literal appearing to the right of
  the first rule can be unified with
  father_of(john, mary) in the second fact. These
  two literals are unifiable when the variable X is
  instantiated to the constant john, and the
  variable Y to the constant mary. Thus,
• parent_of(X, Y) - father_of(X, Y), male(X).
• father_of(john, mary).
• can be resolved to
• parent_of(john, mary) - male(john).

34
Resolution by refutation proofs

• Resolution by refutation proofs requires that the
  axioms and the negation of the goal be placed in
  clause form notation.
• Clause form represents the logical statements as
  a set of disjunction of literals.
• The most common form of resolution is called
  binary resolution, the basis for Prolog
  interpreter that is applied to two clauses when
  one contains a literal and the other its
  negation.
• If these literals contain variables, the literals
  must be unified to make them equivalent. In this
  case, a new clause is produced consisting of the
  disjuncts of all the literals in the two clauses
  excluded the literal and its negative instance,
  which are said to have been resolved or cancelled
  out.

35
A Procedure of Refutation Proofs

• The resulting clause receives the unification
  substitution under which the literal and its
  negation are found as equivalent. In general, the
  resolution refutation proofs can be stated as the
  following steps
• Put the set of facts and rules into clause form
  notation.
• Add the negation of what is to be proved (goal or
  query), in clause form to the set of axioms.
• Perform the following steps until there is no
  resolvable clause if there is no resolvable
  clause go to Step 4.
• Unify (resolve) these clauses together, making
  new clauses that logically produced from them.
• Produce a contradiction by generating an empty
  clause. If there is an empty clause, stop and
  report the query is true.
• The substitution used to produce the empty clause
  are those under which the opposite of the negated
  goal is true.
• Stop and report that the query is false meaning
  that there is no solution associated with this
  query.
• It is worth noting that, the Step 3 is intended
  to produce an empty clause, indicating that there
  is a solution associated with the goal.

36
Producing the Clause Form

• In the following, we outline the process of
  conjunctive normal form reduction through
  examples and give a brief description for each
  step.
• We eliminate ? if by using the equivalent
  form as
• b ? a ? a ? b
• We eliminate ? implies by using the
  equivalent form as
• a ? b ? ? a ? b
• We reduce the scope of negation. This can be
  accomplished using a number of the transformation
  rules. These include
• ? a ( ? a ) ? a
• ? ( a ? b ) ? ? a ? ? b
• ? ( a ? b ) ? ? a ? ? b

37
Producing the Clause Form (Contd)

• We convert the expression to the conjunction of
  disjunction of literals. This requires using the
  associative and distributive properties of ? and
  ?. These include
• a ? ( b ? c ) ? ( a ? b ) ? c
• a ? ( b ? c ) ? ( a ? b ) ? c
• a ? ( b ? c ) ? ( a ? b ) ? ( a ? c )
• It is important to mention that, the following
  logical statement
• a ? ( b ? c )
• is already in clause form notation, because ? is
  not distributed. Hence, it consists of the
  following two clauses
• a
• ( b ? c )

38
Example

• Example We consider the following statements
  translated into logical statements on the right
  and we wish to prove that Poddy will die.
• Statement Logical Statement
• All dogs are animals. ? (X) dog(X) ?
  animal(X).
• Poddy is a dog. dog(poddy).
• All animals will die. ? (Y) animal(Y) ?
  die(Y).
• Poddy will die. die(poddy).

39
Example 1

• First, we convert the logical statements to the
  following clause form notation.
• Logical Statement Clause Form
• 1. ? (X) dog(X) ? animal(X) ? dog(X) ?
  animal(X)
• 2. dog(poddy) dog(poddy)
• 3. ? (Y) animal(Y) ? die(Y) ? animal(Y) ?
  die(Y)
• We negate the query that Poddy will die.
• 4. die(poddy) ? die(poddy)
• Next, we resolve the clauses having opposite
  literals, producing a new clause by resolution
  procedure and continue until the empty clause is
  found.

On.pl
40
Figure 11.10 Resolution proof for Poddy will die
41
Example 2

• Consider the following logical statements
  translated into Prolog clause form on the right.
  We would like to know that who does John like?
  by issuing a query as
• ?- likes(john, Somebody).
• Logical Statement Clause Form
• 1. likes(david, bert). likes(david, bert)
• 2. likes(bert, john). likes(bert, john)
• 3. likes(john, X) - likes(X, bert). ?
  likes(X, bert) ? likes(john, X)
• 4. ?- likes(john, Somebody). ? likes(john,
  Somebody)
• It is worth noting that, we convert the rule
  likes(john, X) - likes(X, bert) to form likes(X,
  bert) ? likes(john, X) in order to be converted
  into clause form, meaning that if is changed to
  implies.
• The empty clause indicates that, the query is
  true when the variable Somebody is instantiated
  to the constant David.

Likes.pl
42
Error!!, P374 Fig. 11.11
Figure 11.11 Resolution proof for ? likes
(john, Somebody)
43
Example 3
On.pl

• Logical Statement
• on(b, a).
• on(a, table).
• above(X, Y)- on(X,Y).
• above(X, Z)- above(X, Y), above(Y, Z).
• ?-above(b,table).

• Clause Form
• on(b, a).
• on(a, table).
• ? on(X,Y) V above(X, Y).
• ? above(X, Y) ? ? above(Y, Z) ? above(X, Z).
• ? above(b,table).

44
Figure 11.12 Resolution proof for ? - above (b,
table)
45
Depth-First Search

• Matching the fact and rule with the first subgoal
• Try the facts and rules in order
• Adding the precondition of the rule at the
  beginning of the goal after a match

46
Family.pl
Figure 11.13 Portion of the Prolog depth-first
search tree leading to success
47
To be continued

• Backtracking
• Deficiencies of Prolog
• Cut Operator
• Recursive Rules

48
Backtracking

• Prolog uses unification to match a goal to the
  head of a clause, but if there are several
  candidate clauses, which does Prolog choose to
  try first? In most cases Prolog looks through the
  clauses in the order in which they are entered in
  the logic base. This is not the case for a
  'sorted' predicate, which is, as the name
  implies, stored in sorted order.

49
Backtracking

• Prolog's backtracking top-to-bottom,
  left-to-right search is simple and effective.
  Backtracking works as follows
• If Prolog cannot prove a sub-goal in the body of
  a clause, then it looks at the sub-goal
  immediately to its left. If there are any other
  clauses which can be used to re-prove this goal,
  then any variable bindings which resulted from
  the previous clause selection are discarded, and
  Prolog continues with the new proof.
• If the sub-goal which initially failed was the
  first goal in the body of the clause, then the
  whole goal fails, and the backtracking continues
  in the parent clause (the clause containing the
  reference to the goal whose proof just failed).

50
Backtracking

• Backtracking is a very powerful tool since it
  will try and generate a solution by automated
  search.
• Unfortunately it can sometimes be too powerful,
  generating solutions that were not wanted, and so
  we have to have some way of controlling it.

51
Deficiencies of Prolog

• Resolution order control
• Semantics of Prolog
• The closed world assumption

52
Resolution order control

• In Prolog, statement order is meaningful.
• The user can affect both efficiency and semantics
  by ordering the statements in a Prolog program.
• parent(bob, pat).
• parent(tom, bob).
• pred(X, Z) - parent(X, Z).
• pred(X, Z) - parent(X, Y), pred(Y, Z).
• ?- pred(tom, pat).
• Yes
• If the rules are
• pred(X, Z) - pred(Y, Z), parent(X, Y).
• pred(X, Z) - parent(X, Z).
• ?- pred(tom, pat)

53
Semantics of Prolog

• Procedural semantics
• how Prolog answers questions.
• Declarative semantics
• the logical meaning of Prolog program
• Programs with the same declarative semantics may
  have different Procedural xsemantics.
• Example
• P - R, S.
• P - S, R.
• Danger of indefinite looping
• Consider
• p - p.
• ?- p.

54
The closed world assumption

• Anything that cannot be proved to be true is
  assumed to be false.
• For Prolog, the only truths are those that can be
  proved using the given facts. Prolog cannot prove
  that a given goal is false. Prolog adopts the
  closed world assumption to assume that anything
  that cannot be proved to be true be false.

55
Resorder.pl Resorder1.pl Resorder2.pl
Figure 11.15 Tree structure of facts
56
Cut Operator

• Denoted with a "!". !/0 is always true, so if a
  clause containing a cut is read as a statement of
  truth, it behaves as if there were no cut there.
  But cut affects the way backtracking is performed
  as follows
• Once a cut is executed, the choice of the clause
  which contains it is frozen as a proof step. Also
  any choices made during the proof of the goals
  between the head of the clause and the cut are
  frozen. Thus cut acts like a fence. When
  backtracking passes over the cut (heading left in
  a clause), then proof reconsideration continues
  not with the goal to the left of the !, but the
  goal to the left of the goal which chose the
  clause containing the cut.

57
Figure 11.16 The effect of Cut in the first rule
Orcut.pl
58
Figure 11.17 The effect of a Cut in the second
rule
59
Figure 11.18 The effect of Cut in conjunction
with fail
60
"cut" problem

• "cut" (!) is a goal that always succeeds
  immediately.
• cut is used to avoid unnecessary backtracking.
• Example
• member(X, XL).
• member(X, YL) - member(X, L).
• This is 'non-deterministic' if X occurs serveral
  times then any occurrence can be found.
• A deterministic member use a cut to prevent
  backtracking as soon as X is found.
• member(X, XL)-!.
• member(X, YL) - member(X, L).

61
"cut" problem

• This will generate just one solution.
• ?- member(X, a, b, c).
• Xa
• no
• The use of cut is not recommended because it
  destroys one of the important advantages of logic
  programming, i.e., programs do not specify how
  solutions are to be found.
•  

62
Negation as failure

• Example
• sibling(X, Y) - parent(M, X), parent(M, Y),
  not(X Y).
• Definition of negation in Prolog
• not(P) - P, !, fail true.
• Which can be read
• If P succeeds, then not(P) fails, otherwise
  not(P) succeeds.

63
The negation problem

• The Prolog not operator is not equivalent to a
  logical NOT operator.
• not(not(some_goal)).
• is not always equivalent to some_goal.
• ?. not human(mary).
• Yes
• This means only that there is not enough
  information in the program to prove that Mary is
  human. Prolog's reasoning is based on the closed
  world assumption.

64
Recursive Rules

• Let's look at a more interesting extension to the
  directed graph program.
• Suppose we aren't satisfied with a predicate
  which distinguishes pairs of nodes linked by
  paths of length two.
• Suppose we want a general predicate which is
  satisfied by a pair of nodes just in case they
  are linked by a path in the graph - a path of any
  (positive) length.
• Thinking recursively, we can see that there is a
  path from one node to another if there is an edge
  between them (a base case), or if there is an
  edge to an intermediate node from which there is
  a path to the final node.
• The following two rules define the path relation
  for our program.

65
Recursive Rules

• path(Node1,Node2) - edge(Node1,Node2).
• path(Node1,Node2) - edge(Node1,SomeNode),
  path(SomeNode,Node2).
• There are two important characteristics in this
  example. First, the use of two rules (with the
  same head) to define a predicate reflects the use
  of the logical OR'' in a Prolog program.

66
Recursive Rules

• We would read these two rules as
• path(Node1,Node2) is true if edge(Node1,Node2) is
  true or if there is a node SomeNode for which
  both edge(Node1,SomeNode) and path(SomeNode,Node2)
  are true. Second, the predicate used in the head
  of the second rule also appears in the body of
  that rule. The two rules together show how a
  recursive definition can be implemented in Prolog
  .

67
Figure 11.19 A train route between five cities
Travel.pl
68
Figure 11.20 The first stage of the journey
69
Figure 11.21 The program that corresponds to ?
travel (boiling-springs, columbia)
70
Figure 11.22 The program that corresponds to ? -
travel (boiling-springs, columbia) query
71
Summary

• Prolog
• Program structure
• Logical variable
• Syntax structure
• Control structure
• Resolution and unification
• DFS
• Backtracking
• Deficiencies of Prolog
• Cut Operator
• Recursive Rules
• Prolog facilities