Title: COSC3306:%20Programming%20Paradigms%20Lecture%209:%20Declarative%20Programming%20with%20Prolog
1COSC3306Programming ParadigmsLecture 9
DeclarativeProgramming with Prolog
- Haibin Zhu, Ph.D.
- Computer Science
- Nipissing University (C) 2003
2Contents
- Prolog
- Program structure
- Logical variable
- Syntax structure
- Prolog facilities
- Control structure
- Resolution and unification
- DFS
- Backtracking
- Deficiencies of Prolog
- Cut Operator
- Recursive Rules
3Prolog
- 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
4Prolog
- 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.
5Program 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.
6Program 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.
7Example
- 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)
8Query
- 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.
9Logical 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.
10Logical 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.
11Example
- 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.
12Prolog 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 , -, , /,
13Variables
- 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.
14Compound 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
15BNF Specification
16Prolog Facilities-Arithmetic
- ?- X is 34.
- ?- X is 5-4.
- ?- X is 34.
- ?- X is 8/2.
- ?- X is 5 mode 2.
17Comparisons
- XltY.
- XgtY.
- XltY.
- XgtY.
- X\Y.
- XY.
18List 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
19Examples
- 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.
20Examples
- 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(.)
21Input 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
22To be Continued
- Control Structure
- Resolution
- Unification
- DFS
23Control 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.
24Control 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.
25Top-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.
26Example
- 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.
27Bottom-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.
28Example
- 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.
29Resolution 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.
30Unification
- 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.
31Example
- 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
32The 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.
33Resolution 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).
34Resolution 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.
35A 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.
36Producing 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
37Producing 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 )
38Example
- 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).
39Example 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
40Figure 11.10 Resolution proof for Poddy will die
41Example 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
42Error!!, P374 Fig. 11.11
Figure 11.11 Resolution proof for ? likes
(john, Somebody)
43Example 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).
44Figure 11.12 Resolution proof for ? - above (b,
table)
45Depth-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
46Family.pl
Figure 11.13 Portion of the Prolog depth-first
search tree leading to success
47To be continued
- Backtracking
- Deficiencies of Prolog
- Cut Operator
- Recursive Rules
48Backtracking
- 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.
49Backtracking
- 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).
50Backtracking
- 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.
51Deficiencies of Prolog
- Resolution order control
- Semantics of Prolog
- The closed world assumption
52Resolution 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)
53Semantics 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.
54The 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.
55Resorder.pl Resorder1.pl Resorder2.pl
Figure 11.15 Tree structure of facts
56Cut 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.
57Figure 11.16 The effect of Cut in the first rule
Orcut.pl
58Figure 11.17 The effect of a Cut in the second
rule
59Figure 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. -
62Negation 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.
63The 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.
64Recursive 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.
65Recursive 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.
66Recursive 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
.
67Figure 11.19 A train route between five cities
Travel.pl
68Figure 11.20 The first stage of the journey
69Figure 11.21 The program that corresponds to ?
travel (boiling-springs, columbia)
70Figure 11.22 The program that corresponds to ? -
travel (boiling-springs, columbia) query
71Summary
- Prolog
- Program structure
- Logical variable
- Syntax structure
- Control structure
- Resolution and unification
- DFS
- Backtracking
- Deficiencies of Prolog
- Cut Operator
- Recursive Rules
- Prolog facilities