Chapter 4 (final)

Representing Simple Facts in Logic
Representing Instance and is a Relationships
Modus Pones
Resolution
Natural Deduction
Dependency-Directed Backtracking

Unit 4
Predicate Logic

Learning Objectives
After reading this unit you should appreciate the following:

• Representing Simple Facts in Logic

• Representing Instance and is a Relationships

• Modus Pones

• Resolutions (Skolemizing Queries)

• Unification

• Dependency Directed Backtracking
Top

Representing Simple Facts in Logic

AI system might need to represent knowledge. Propositional logic is one of the fairly good forms
of representing the same because it is simple to deal with and a decision procedure for it exists.
Real-world facts are represented as logical propositions and are written as well-formedformulas (wff's)
in propositional logic, as shown in Figure 4.1 Using these propositions, we may easily conclude it

88 ARTIFICIAL INTELLIGENCE

is not sunny from the fact that its raining. But contrary to the ease of using the propositional logic
there are its limitations. This is well demonstrated using a few simple sentence like:
Figure 4.1: Some Simple Facts in Propositional Logic

Tom is a cat. The representation in proposition logic will probably be:

TOMCAT

Now, consider a similar sentence as:

Jerry is a cat.

And now the representation will be something as:

JERRYCAT

Clearly we can see that using the above two examples we possibly can not differentiate between
the similarities of Tom and Jerry. It would be much better to represent these facts as:
CAT(TOM)

CAT(JERRY)

And now, the structure of the representation reflects the structure of the knowledge itself. But to
do that, we need to be able to use predicates applied to arguments.

Much a difficult situation will be if we try to represent the equally classic sentence

All cats have tails.

We could represent this as:

TAILEDCATS

But doing so fails to capture the relationship between the two cats and cats in general having
tails. To do that, we really need variables and quantification unless we are willing to write
separate statements about the mortality of every known man.

First-order predicate logic (or just predicate logic), provides us to use the variables and
quantification. It is a way of representing knowledge because it permits representations of things
that cannot reasonably be represented in propositional logic. In predicate logic, we can represent
real-world facts as statements written as wff's.

PREDICATE LOGIC 89

Selection of logical statements as a way of representing knowledge provides us a good way of
reasoning with the knowledge. Determining the validity of a proposition in prepositional logic is
straightforward, although it may be computationally hard. So before we adopt predicate logic as a
good medium for representing knowledge, we need to ask whether it also provides a good way of
reasoning with the knowledge. At first glance, the answer is yes. It provides a way of deducing
new statements from old ones. Unfortunately, however, unlike propositional logic, it does not
possess a decision procedure, even an exponential one. There do exist procedures that will find a
proof of a proposed theorem if indeed it is a theorem. But these procedures are not guaranteed to
halt if the proposed statement is not a theorem. In other words, although first-order predicate logic
is not decidable, it is semidecidable. A simple such procedure is to use the rules of inference to
generate theorems from the axioms in some orderly fashion, testing each to see if it is the one for
which a proof is sought. We still try to aim for a better method as this method is not particularly as
efficient.

The science of AI, which seeks positive methods for doing things, the negative result that there
can exist no decision procedure, for predicate logic, generally have little direct effect since it tells
us that in our search for an efficient proof procedure, we should be content if we find one that will
prove theorems, even if it is not guaranteed to halt if given a nontheorem. And the fact that there
cannot exist a decision procedure that halts on all possible inputs does not mean that there
cannot exist one that will halt on almost all the inputs it would see in the process of trying to solve
real problems. So despite the theoretical undecidability of predicate logic, it can still serve as a
useful way of representing and manipulating some of the kinds of knowledge that an AI system
might need.

Leaving all this discussion on the negative and positive aspects of using Predicate logic we now
explore the use of predicate logic as a way of representing knowledge. Consider the following set
of sentences:

1. Marcus was a man.

2. Marcus was a Pompeian.

3. All Pompeians were Romans.

4. Caesar was a ruler.

5. All Romans were either loyal to Caesar or hated him.


6. Everyone is loyal to someone.

7. People only try to assassinate rulers they are not loyal to.

8. Marcus tried to assassinate Caesar.

The facts described by these sentences can be represented as a set of wff's in predicate logic as
follows:


man(Marcus)

Although this representation fails to represent the notion of past tense (which is clear in the
English sentence), it captures the critical fact of Marcus being a man. Whether this omission is
acceptable or not depends on the use to which we intend to put the knowledge.


Pompeian(Marcus)

3. All Pompeians were Romans.

∀x : Pompeian(x) Roman(x)

4. Caesar was a ruler.
ruler(Caesar)

Since many people share the same name, the fact that proper names are often not references to
unique individuals, overlooked here. Occasionally deciding which of several people of the same
name is being referred to in a particular statement may require a somewhat more amount of
knowledge and logic.

5. All Romans were either loyal to Caesar or hated him.

∀x: Roman(x) loyalto(x, Caesar) V hate(Caesar)

Here we have used the inclusive-or interpretation of the two types of Or supported by
English language. Some people will argue, however, that this English sentence is really
stating an exclusive-or. To express that. we would have to write:

∀x: Roman(x)  [(loyalto(x, Caesar) V hate(x, Caesar))∧

PREDICATE LOGIC 91

Not (loyalto(x, Caesar) ∧hate(x, Caesar))]

6. Everyone is loyal to someone.

∀x:∃y : loyalto(x,y)

The scope of quantifiers is a major problem that arises when trying to convert English
sentences into logical statements. Does this sentence say, as we have assumed in writing
the logical formula above, that for each person there exists someone to whom he or she is

loyal, possibly a different someone for everyone? Or does it say that there is someone to
whom everyone is loyal?
Figure 4.2: An Attempt to Prove not loyal to(Marcus,Caesar)

7. People only try to assassinate rulers they are not loyal to.

∀x : ∀y : person(x) ∧ ruler(y) ∧ tryassasinate(x,y) → ¬loyalto(x,y)

8. Like the previous one this sentence too is ambiguous which may lead to more than one
conclusion. The usage of “try to assassinate” as a single predicate gives us a fairly simple
representation with which we can reason about trying to assassinate. But there might be
connections as try to assassinate and not actually assassinate could not be made easily.

9. Marcus tried to assassinate Caesar.

tryassasinate (Marcus,Caesar)

now, say suppose we wish to answer the following question:

Was Marcus loyal to Caesar?


What we do is start reasoning backward from the desired goal which is represented in
predicate logic as:

¬loyalto(Marcus, Caesar)

Figure 4.2 shows an attempt to produce a proof of the goal by reducing the set of necessary
but as yet unattained goals to the empty sets. The attempts fail as we do not have any
statement to prove person(Marcus). But the problem is solved just by adding an additional
statement i.e.

10. All men are people.

∀x : man(x) → person(x)

Now we can satisfy the last goal and produce a proof that Marcus was not loyal to Caesar.

Let’s take another example to make things more clear. Consider the following sentences.

1. John likes all kinds of food.

2. Apples are food.

3. Anything anyone eats and is not killed by is food.

4. Bill eats peanuts and is alive.

5. Sue eats every thing Bill eats.

Now we prove that “John likes peanuts” using backward chaining.

1. John like all kinds of food.

∀x: food (x) → likes (Johns ,x)

2. Apples are food.

food (apple)


∀x: ∀y: eats (x, y) ∧ ¬ killedby (x, y) → food (y).


eats (Bill, peanuts) ∧ ¬ killedby (Bill peanuts)

PREDICATE LOGIC 93

here we assume that alive is same as not killed by.

5. Sue eats everything Bill eats.

∀x: food(x) ∧ eats (Bill, x) → eats (Sue, x)

Now our goal is to prove “John likes peanuts”. We need to convert in Coff’s then it becomes

like (John, peanuts)

The proof is as follows:

likes (John, peanuts)
↑ (1, substitution)
food (peanuts)
↑ (3, substitution)
eats (Bill, peanuts) ∧ ¬ killed by (Bill, peanuts)

The problem with this approach is that, the branching factor going forward from the axioms is so
great that it would probably not get to either answer in any reducible amount of time. And
secondly it may use some sort of heuristic rules for deciding which answer is more likely and then
try to prove that one first.

Top

Representing Instance and is a Relationships

We are aware of the importance of the class and instance relationships they play in a particularly
useful form of reasoning, property inheritance, but we have not used these in predicate logic. The
reason being that although we have not used the predicates instance and isa explicitly, we have
captured the relationships they are used to express, namely class membership and class
inclusion. Figure 4.3 shows the first five sentences of the last section represented in logic in three
different ways. The first part of the figure contains the representations we have already
discussed. In these representations, class membership is represented with unary predicates


(such as Roman), each of which corresponds to a class. Asserting that P(x) is true is equivalent to
asserting that x is an instance (or element) of P. The second part of the figure contains
representations that use the instance predicate explicitly. The predicate instance is a binary one,
whose first argument is an object and whose second argument is a class to which the object
belongs. But these representations do not use an explicit isa predicate. Instead, subclass
relationships, such as that between Pompeians and Romans, are described as shown in
sentence 3. The implication rule there states that if an object is an instance of the subclass
Pompeian then it is an instance of the superclass Roman. Note that this rule is equivalent to the
standard set-theoretic definition of the subclass-superclass relationship. The third part contains
representations that use both the instance and isa predicates explicitly. The use of the isa predicate
simplifies the representation of sentence 3, but it requires that one additional axiom (shown here
as number 6) be provided. This additional axiom describes how an instance relation and an isa
relation can be combined to derive a new instance relation. This one additional axiom is general,
though, and does not need to be provided separately for additional isa relations.

Figure 4.3: Three Ways of Representing Class Membership

These examples illustrate two points. The first is fairly specific. It is that, although class and
superclass memberships are important facts that need to be represented those memberships
need not be represented with predicates labelled instance and isa. In fact, in a logical framework it

PREDICATE LOGIC 95

is usually unwieldy to do that, and instead unary predicates corresponding to the classes are
often used. The second point is more general. There are usually several different ways of
representing a given fact within a particular representational framework, be it logic or anything
else. The choice depends partly on which deductions need to be supported most efficiently and
partly on taste. The only important thing is that within a particular knowledge base consistency of
representation is critical. Since any particular inference rule is designed to work on one particular
form of representation, it is necessary that all the knowledge to which that rule is intended to
apply be in the form that the rule demands. Many errors in the reasoning performed by
knowledge-based programs are the result of inconsistent representation decisions. The moral is
simply to be careful.

There is one additional point that needs to be made here on the subject of the use of isa
hierarchies in logic-based systems. The reason that these hierarchies are so important is not that
they permit the inference of superclass membership. It is that by permitting the inference of
superclass membership, they permit the inference of other properties associated with
membership in that superclass. So for example in our sample knowledge base it is important to
be able to conclude that Marcus is Roman because we have some relevant knowledge about
Romans. Namely that they either hate Caesar or are loyal to him. We were able to associate
knowledge with superclasses that could then be overridden by more specific knowledge
associated either with individual instances or with subclasses. In other words, we recorded default
values that could be accessed whenever necessary. For example, there was a height associated
with adult males and a different height associated with baseball players. Our procedure for
manipulating the isa hierarchy guaranteed that we always found the correct (i.e., most specific)
value for any attribute. Unfortunately, reproducing this result in logic is difficult.

Suppose, for example, that, in addition to the facts we already have, we add the following:

Pompeian(Paulus)

¬ [loyalto(Paulus, Caesar) ∨ hate(Paulus, Caesar)]

In other words, suppose we want to make Paulus an exception to the general rule about Romans
and their feelings toward Caesar. Unfortunately, we cannot simply add these facts to our existing
knowledge base the way we could just add new nodes into a semantic net. The difficulty is that if
the old assertions are left unchanged, then the addition of the new assertions makes the
knowledge base inconsistent. In order to restore consistency, it is necessary to modify the original
assertion to which an exception is being made. So our original sentence 5 must become:


∀x : Roman(x) ∧ ¬eq(x, Paulus) loyalto(x, Caesar) ∨ hate(x, Caesar)

In this framework, every exception to a general rule must be stated twice, once in a particular
statement and once in an exception list that forms part of the general rule. This makes the use of
general rules in this framework less convenient and less efficient when there are exceptions than
is the use of general rules in a semantic net.

Student Activity 4.1

Before reading next section, answer the following questions.

1. Represent the following sentences in predicate logic:

a. John, Elem, Jame and Tom are members of St. John’s Club.

b. John and Tom are brothers.

c. The last meeting of the club was held at Jane’s home.

2. Why is it appropriate to use predicate logic rather than prepositional logic?

If your answers are correct, then proceed to the next section.

Computable Functions and Predicates

Till now all the examples we have discussed all the facts were expressed as combinations of
individual predicates, such as:

tryassassinate(Marcus, Caesar)

This is fine if the number of facts is not very large or if the facts themselves are sufficiently
unstructured that there is little alternative. But suppose we want to express simple facts, such as
the following greater-than and less-than relationships:

gt(1,0) lt(0,1)
gt(2,1) lt(1,2)
gt(3,2) lt(2,3)
: :
: :
: :

There was no need to write out the representation of each of these facts individually. For one
thing, there are infinitely many of them. But even if we only consider the finite number of them that
can be represented, say, using a single machine word per number, it would be extremely

PREDICATE LOGIC 97

inefficient to store explicitly a large set of statements when we could, instead, so easily compute
each one as we need it. Thus it becomes useful to augment our representation by these
computable predicates. Whatever proof procedure we use, when it comes-upon one of these
predicates, instead of searching for it explicitly in the database or attempting to deduce it by
further reasoning, we can simply invoke a procedure, which we will specify in addition to our
regular rules, that will evaluate it and return true or false.

It is often also useful to have computable functions as well as computable predicates. Thus we
might want to be able to evaluate the truth of
gt(2+3,1)

To do so requires that we first compute the value of the plus function given the arguments 2 and
3, and then send the arguments 5 and 1 to gt.

The next example shows how these ideas of computable functions and predicates can be useful.
It also makes use of the notion of equality and allows equal objects to be substituted for each
other whenever it appears helpful to do so during a proof.

To explain it better we once again return to example of Marcus:


man(Marcus)

here once again the presence of past tense in the representation is not clear.


Pompeian(Marcus)

3. Marcus was born in 40 A.D.

born(Marcus, 40)

For simplicity, we will not represent A.D. explicitly, just as we normally omit it in everyday
discussions. If we ever need to represent dates B.C., then we will have to decide on a way to
do that, such as by using negative numbers. Notice, that the representation of a sentence
does not have to look like the sentence itself as long as there is a way to convert back and
forth between them. This allows us to choose a representation, such as positive and
negative numbers, that is easy for a program to work with.


4. All men are mortal.

∀x : man(x)→ mortal(x)

5. All Pompeians died when the volcano erupted in 79 A.D.

erupted(volcano, 79) ∧ ∀x : [Pompeian(x) → died(x, 79)]

This sentence clearly asserts the two facts represented above. It may also assert another
that we have not shown, namely that the eruption of the volcano caused the death of the
Pompeians. People often assume causality between concurrent events if such causality
seems plausible.

Another problem that arises in interpreting this sentence is that of determining the referent of
the phrase "the volcano." There is more than one volcano in the world. Clearly the one
referred to here is Vesuvius, which is near Pompeii and erupted in 79 A.D. In general,
resolving references such as these can require both a lot of reasoning and a lot of additional
knowledge.

6. No mortal lives longer than 150 years.

∀x: ∀t1 : ∀t2 : mortal(x) ∧ born(x, t1) ∧ gt(t2-t1,150) → dead(x, t2)

There are several ways that the content of this sentence could be expressed. For example,
we could introduce a function age and assert that its value is never greater than 150. The
representation shown above is simpler, though, and it will suffice for this example.

7. It is now 1991.

now = 1991

Equal quantities that can be substituted for each other.

We now want to answer the question "Is Marcus alive?" There may be two ways of deducing
an answer. Either we can show that Marcus is dead because he was killed by the volcano or
we can show that he must be dead because he would otherwise be more than 150 years old,
which we know is not possible. As soon as we attempt to follow either of those paths
rigorously, however, we discover, just as we did in the last example, that we need some
additional knowledge. So we add the following facts:

8. Alive means not dead.

PREDICATE LOGIC 99

∀x : ∀t : [alive(x, t) → ¬ dead(x, t)] ∧ [¬ dead(x, t)→ alive(x, t)]

This is not strictly correct, since ¬dead implies alive only for animate objects. (Chairs can be
neither dead nor alive.) Again, we will ignore this for now.

9. If someone dies, then he is dead at all later times.

∀x : ∀t1 : ∀t2 : died(x, t1) ∧ gt(t2,t1)→ dead(x, t2)

This representation says that one is dead in all years after the one in which one died. It

ignores the question of whether one is dead in the year in which one died.
Figure 4.4: A Set of Facts about Marcus

To answer that requires breaking time up into smaller units than years. If we do that, we can then
add rules that say such things as “one is dead at time(year1, month1) if one died during (year1, month2)
and month2 precedes month1. We can extend this to days, hours, etc., as necessary. But we do not
want to reduce all time statements to that level of detail, which is unnecessary and often not
available.

A summary of all the facts we have now represented is given in Figure 4.4. (The numbering is
changed slightly because sentence 5 has been split into two parts.) Now let's attempt to answer
the question "Is Marcus alive?" by proving:

¬alive(Marcus, now)

Two such proofs are shown in Figures 4.5 and 4.6. The term nil at the end of each proof indicates
that the list of conditions remaining to be proved is empty and so the proof has succeeded. Notice
in those proofs that whenever a statement of the form:


a∧b→c

Figure 4.5: One Way of Proving That Marcus Is Dead

was used, a and b were set up as independent subgoals. In one sense they are, but in another
sense they are not if they share the same bound variables, since, in that case, consistent
substitutions must be made in each of them. For example, in Figure 4.6 look at the step justified
by statement 3. We can satisfy the goal

born(Marcus, t1)

PREDICATE LOGIC 101

Figure 4.6: Another Way of Proving That Marcus Is Dead

using statement 3 by binding t1 to 40, but then we must also bind t1 to 40 in

gt(now – t1,150)

since the two t1's were the same variable in statement 4, from which the two goals came. A good
computational proof procedure has to include both a way of determining that a match exists and a
way of guaranteeing uniform substitutions throughout a proof. Mechanisms for doing both those
things are as follows. Two things should be clear from the proofs we have just shown:

• Even very simple conclusions can require many steps to prove.

• A variety of processes, such as matching, substitution, and application of modus ponens are
involved in the production of a proof, This is true even for the simple statements we are


using, It would be worse if we had implications with more than a single term on the right or
with complicated expressions involving ands and ors on the left.

The first of these observations suggests that if we want to be able to do nontrivial reasoning, we
are going to need some statements that allow us to take bigger steps along the way. These
should represent the facts that people gradually acquire, as they become experts. How to get
computers to acquire them is a hard problem for which no very good answer is known.

The second observation suggests that actually building a program to do what people do in
producing proofs such as these may not be easy. In the next section, we introduce, a proof
procedure called resolution that reduces some of the complexity because it operates on
statements that have first been converted to a single canonical form.

Top

Modus Pones

Modus Pones is a property of propositions that is useful in resolution. It can be represented as
follows:
P and P → ⇒
Q Q

where P and Q are two clauses.

Top

Resolution

Resolution is such a procedure, which gains its efficiency from the fact that it operates on
statements that have been converted to a very convenient standard form. Resolution produces
proofs by refutation. In other words, to prove a statement (i.e. show that it is valid), resolution
attempts to show that the negation of the statement produces a contradiction with the known
statements (i.e., that it is unsatisfiable). This approach contrasts with the technique that we have
been using to generate proofs by chaining backward from the theorem to be proved to the
axioms. Further discussion of how resolution operates will be much more straightforward after we
have discussed the standard form in which statements will be represented, so we defer it until
then.

Conversion to Clause Form

PREDICATE LOGIC 103

Suppose we know that all Romans who know Marcus either hate Caesar or think that anyone
who hates anyone is crazy. We could represent that in the following wff:

∀x : [Roman(x) ∧ know(x, Marcus)]→

[hate(x,Caesar) ∨ (∀y: ∃z: hate(y,z)→ thinkcrazy(x,y))]

To use this formula in a proof requires a complex matching process. Then, having matched one
piece of it, such as thinkcrazy(x,y), it is necessary to do the right thing with the rest of the formula
including the pieces in which the matched part is embedded and those in which it is not. If the
formula were in a simpler form, this process would be much easier. The formula would be easier
to work with if

• It were flatter, i.e., there was less embedding of components.

• The quantifiers were separated from the rest of the formula so that they did not need to be
considered.

Conjunctive normal form has both of these properties. For example, the formula given above for the
feelings of Romans who know Marcus would be represented in conjunctive normal form as

¬Roman(x) ∨ ¬know(x, Marcus) ∨

hate(x, Caesar) ∨ ¬hate(y, z) ∨ thinkcrazy(x, z)

Since there exists an algorithm for converting any wff into conjunctive normal form, we lose no
generality if we employ a proof procedure (such as resolution) that operates only on wff's in this
form. In fact, for resolution to work, we need to go one step further. We need to reduce a set of
wff's to a set of clauses, where a clause is defined to be a wff in conjunctive normal form but with no
instances of the connector ∧. We can do this by first converting each wff into conjunctive normal
form and then breaking apart each such expression into clauses, one for each conjunct. All the
conjuncts will be considered to be conjoined together as the proof procedure operates. To convert
a wff into clause form, perform the following sequence of steps.

Algorithm: Convert to Clause Form


1. Eliminate , using the fact that a  b is equivalent to ¬ a ∨ b. Performing this transformation
on the wff given above yields

∀x: ¬[Roman(x) ∧ know(x, Marcus)] ∨

[hate(x, Caesar) ∨ (∀y : ¬(∃z : hate(y, z)) ∨ thinkcrazy(x, y))]

2. Reduce the scope of each ¬ to a single term, using the fact that ¬ (¬ p) = p, deMorgan's laws
[which say that ¬(a ∧ b) = ¬ a ∨ ¬b and ¬ (a ∨ b) = ¬ a ∧¬ b], and the standard
correspondences between quantifiers [¬∀ x : P(x) = ∃x : ¬P(x) and ¬∃x : P(x) = ∀x : ¬P(x)].
Performing this transformation on the wff from step 1 yields

∀x: [¬Roman(x) ∨ ¬know(x, Marcus)] ∨

[hate(x, Caesar) ∨ (∀y : ∀z : ¬ hate(y, z) ∨ thinkcrazy(x, y))]

3. Standardize variables so that each quantifier binds a unique variable. Since variables are
just dummy names, this process cannot affect the truth-value of the wff. For example, the
formula

∀x : P(x) ∨ ∀x : Q(x)

would be converted to

∀x: P(x) ∨ ∀y : Q(y)

This step is in preparation for the next.

4. Move all quantifiers to the left of the formula without changing their relative order. This is
possible since there is no conflict among variable names. Performing this operation on the
formula of step 2, we get

∀x: ∀y : ∀z : [¬ Roman(x) ∨ ¬ know(x,Marcus)] ∨

[hate(x, Caesar) ∨ (¬ hate(y, z) ∨ thinkcrazy(x,y))]

At this point, the formula is in what is known as prenex normal form. It consists of a prefix of
quantifiers followed by a matrix, which is quantifier free.

5. Eliminate existential quantifiers. A formula that contains an existentially quantified variable
asserts that there is a value that can be substituted for the variable that makes the formula
true. We can eliminate the quantifier by substituting for the variable a reference to a function

PREDICATE LOGIC 105

that produces the desired value. Since we do not necessarily know how to produce the
value, we must create a new function name for every such replacement. We make no
assertions about these functions except that they must exist. So, for example, the formula

∃y : President(y)

can be transformed into the formula

President(S1)

where S1 is a function with no arguments that somehow produces a value that satisfies
President.

If existential quantifiers occur within the scope of universal quantifiers, then the value that
satisfies the predicate may depend on the values of the universally quantified variables. For
example, in the formula

∀x: ∃y: father-of(y,x)

the value of y that satisfies father-of depends on the particular value of x. Thus we must
generate functions with the same number of arguments as the number of universal
quantifiers in whose scope the expression occurs. So this example would be transformed
into

∀x :father-of(S2(x),x))
These generated functions are called Skolem functions. Sometimes ones with no
arguments are called Skolem constants.

6. Drop the prefix. At this point, all remaining variables are universally quantified, so the prefix
can just be dropped and any proof procedure we use can simply assume that any variable it
sees is universally quantified. Now the formula produced in step 4 appears as

[¬Roman(x) ¬ know(x, Marcus)] ∨

[hate(x, Caesar) ∨ (¬hate(y, z) ∨ thinkcrazy(x, y))

7. Convert the matrix into a conjunction of disjuncts. In the case of our example, since there are
no and's, it is only necessary to exploit the associative property of or [i.e., a ∨ (b ∨ c) = (a ∨ b) ∨
c] and simply remove the parentheses, giving

¬Roman(x) ∨¬ know(x, Marcus) ∨


hate(x, Caesar) ∨ ¬ hate(y, z) ∨ thinkcrazy(x, y)

However, it is also frequently necessary to exploit the distributive property [i.e., (a ∧ b) ∨ c =
(a ∨ c) ∧ (b∨ c)] For example, the formula

(winter ∧ wearingboots) ∨ (summer ∧ wearingsandals)

becomes, after one application of the rule

[winter ∨ (summer ∧ wearingsandals)]

∧ [wearingboots ∨ (summer ∧ wearingsandals)]

and then, after a second application.

(winter ∨ summer) ∧

(winter ∨ wearing sandals) ∧

(wearingboots ∨ summer) ∧

(wearingboots ∨ wearingsandals)

8. Create a separate clause corresponding to each conjunct. In order for a wff to be true, all the
clauses that are generated from it must be true. If we are going to be working with several
wff's, all the clauses generated by each of them can now be combined to represent the same
set of facts as were represented by the original wff's.

9. Standardize apart the variables in the set of clauses generated in step 8. By this we mean
rename the variables so that no two clauses make reference to the same variable. In making
this transformation, we rely on the fact that

(∀x : P(x) ∧ Q(x)) = ∀x : P(x) ∧ ∀x : Q(x)

Thus since each clause is a separate conjunct and since all the variables are universally
quantified, there need be no relationship between the variables of two clauses, even if they were
generated from the same wff.

Performing this final step of standardization is important because during the resolution procedure
it is sometimes necessary to instantiate a universally quantified variable (i.e., substitute for it a
particular value). But, in general, we want to keep clauses in their most general form as long as

PREDICATE LOGIC 107

possible. So when a variable is instantiated, we want to know the minimum number of
substitutions that must be made to preserve the truth value of the system.

After applying this entire procedure to a set of wff's, we will have a set of clauses, each of which
is a disjunction of literals. These clauses can now be exploited by the resolution procedure to
generate proofs.

The Basis of Resolution

The resolution procedure is a simple iterative process: at each step, two clauses, called the parent
clauses, are compared (resolved), yielding a new clause that has been inferred from them. The new
clause represents ways that the two parent clauses interact with each other. Suppose that there
are two clauses in the system:

winter ∨ summer

¬winter ∨ cold

This means that both clauses must be true (i.e., the clauses, although they look independent, are
really conjoined).

Now we observe that precisely one of winter and ¬winter will be true at any point. If winter is true,
then cold must be true to guarantee the truth of the second clause. If ¬winter is true, then summer
must be true to guarantee the truth of the first clause. Thus we see that from these two clauses
we can deduce

summer ∨ cold

This is the deduction that the resolution procedure will make. Resolution operates by taking two
clauses that each contain the same literal, in this example, winter. The literal must occur in
positive form in one clause and in negative form in the other. The resolvent is obtained by
combining all of the literals of the two parent clauses except the ones that cancel.

If the clause that is produced is the empty clause, then a contradiction has been found. For
example, the two clauses

winter

¬winter


will produce the empty clause. If a contradiction exists, then eventually it will be found. Of course,
if no contradiction exists, it is possible that the procedure will never terminate, although as we will
see, there are often ways of detecting that no contradiction exists.

The theoretical basis of the resolution procedure in predicate logic is Herbrand's theorem, which
tells us the following:

• To show that a set of clauses S is unsatisfiable, it is necessary to consider only interpretations
over a particular set, called the Herbrand universe of S.

• A set of clauses S is unsatisfiable if and only if a finite subset of ground instances (in which all
bound variables have had a value substituted for them) of S is unsatisfiable.

The second part of the theorem is important if there is to exist any computational procedure for
proving unsatisfiability, since in a finite amount of time no procedure will be able to examine an
infinite set. The first part suggests that one way to go about finding a contradiction is to try
systematically the possible substitutions and see if each produces a contradiction. But that is
highly inefficient. The resolution principle, first introduced by Robinson, provides a way of finding
contradictions by trying a minimum number of substitutions. The idea isoto keep clauses in their
general form as long as possible and only introduce specific substitutions when they are required.

Resolution in Propositional Logic

In order to make it clear how resolution works, we first present the resolution procedure for
propositional logic. We then expand it to include predicate logic. In propositional logic, the
procedure for producing a proof by resolution of proposition P with respect to a set of axioms F is
the following.

Algorithm: Propositional Resolution

1. Convert all the propositions of F to clause form.

2. Negate P and convert the result to clause form. Add it to the set of clauses obtained in
step 1.

3. Repeat until either a contradiction is found or no progress can be made:

a. Select two clauses. Call these the parent clauses.

PREDICATE LOGIC 109

b. Resolve them together. The resulting clause, called the resolvent, will be the disjunction
of all of the literals of both of the parent clauses with the following exception: If there are
any pairs of literals L and ¬L such that one of the parent clauses contains L and the
other contains ¬L, then select one such pair and eliminate both L and ¬L from the
resolvent.

c. If the resolvent is the empty clause, then a contradiction has been found. If it is not, then
add it to the set of clauses available to the procedure.

Let's look at a simple example. Suppose we are given the axioms shown in the first column of
Figure 4.7 and we want to prove R. First we convert the axioms to clause form, as shown in the
second column of the figure. Then we negate R, producing ¬R, which is already in clause form.
Then we begin selecting pairs of clauses to resolve together. Although any pair of clauses can be
resolved, only those pairs that contain complementary literals will produce a resolvent that is likely
to lead to the goal of producing the empty clause (shown as a box). We might, for example,
generate the sequence of resolvents shown in Figure 4.8. We begin by resolving with the clause
¬R since that is one of the clauses that must be involved in the contradiction we are trying to find.

One way of viewing the resolution process is that it takes a set of clauses that are all assumed to
be true and, based on information provided by the others, it generates new clauses that represent
restrictions on the way each of those original clauses can be, made true. A contradiction occurs
when a clause becomes so restricted that there is no way it can be true. This is indicated by the
generation of the empty clause. To see how this works, let's look again at the example. In order
for proposition 2 to be true, one of three things must be true: ¬P, ¬Q, or R. But we are assuming
that ¬R is true. Given that, the only way for proposition 2 to be true is for one of two things to be
true: ¬P or ¬Q. That is what the first resolvent clause says. But proposition I says that P is true,
which means that ¬P cannot be true, which leaves only one way for proposition 2 to be true,
namely for ¬Q to be true (as shown in the second resolvent clause). Proposition 4 can be true if
either ¬T or Q is true. But since we now know that ¬Q must be true, (the only way for proposition
4 to be true is for ¬T to be true (the third resolvent). But proposition 5 says that T is true. Thus
there is no way for all of these clauses to be true in a single interpretation. This is indicated by the
empty clause (the last resolvent).

Given Axioms Converted to Clause Form
P P (1)

(P ∧ Q) → R ¬P ∧ ¬Q ∨ R (2)

(S ∨ T) → Q ¬S ∨ Q (3)

¬T ∨ Q (4)

T T (5)


Figure 4.7: A few facts in Propositional Logic

Figure 4.8: Resolution in Propositional Logic

The Unification Algorithm

In propositional logic, it is easy to determine that two literals cannot both be true at the, same
time. Simply look for L and ¬L. In predicate logic, this matching process is more complicated
since the arguments of the predicates must be considered. For example man (John) and ¬man
(John) is a contradiction, while man(John) and ¬man(Spot) is not. Thus, in order to determine
contradictions, we need a matching procedure that compares two literals are discovers whether
there exists a set of substitutions that makes, them identical. There is a straightforward recursive
procedure, called the unification algorithm that does just this.

The basic idea of unification is very simple. To attempt to unify two literals, we first check if their
initial predicate symbols are the same. If so, we can proceed. Otherwise, there is no way they can
be unified, regardless of their arguments. For example, the two literals

PREDICATE LOGIC 111

– tryassassinate(Marcus, Caesar)

– hate(Marcus, Caesar)

cannot be unified. If the predicate symbols match, then we must check the arguments, one pair at
a time. If the first matches, we can continue with the second, and so on. To test each argument
pair, we can simply call the unification procedure recursively. The matching rules are simple.
Different constants or predicates cannot match; identical ones can. A variable can match another
variable, any constant, or a predicate expression, with the restriction that the predicate expression
must not contain any instances of the variable being matched.

The only complication in this procedure is that we must find a single, consistent substitution for
the entire literal, not separate ones for each piece of it. To do this, we must take each substitution
that we find and apply it to the remainder of the literals before we continue trying to unify them.
For example, suppose we want to unify the expressions

P(x, x)
P(y, z)

The two instances of P match fine. Next we compare x and y, and decide that if we substitute y for
x, they could match. We will write that substitution as

y/x

But now, if we simply continue and match x and z, we produce the substitution z/ x.

But we cannot substitute both y and z for x, so we have not produced a consistent substitution.
What we need to do after finding the first substitution y/x is to make that substitution throughout
the literals, giving

P(y,y)

P(y, z)

Now we can attempt to unify arguments y and z, which succeeds with the substitution z/y. The
entire unification process has now succeeded with a substitution that is the composition of the
two substitutions we found. We write the composition as

(z/y)(y/x)


following standard notation for function composition. In general, the substitution (a1/a2, a3/a4,….)
(b1/b2, b3/b4,...)... means to apply all the substitutions of the right-most list, then take the result and
apply all the ones of the next list, and so forth, until all substitutions have been applied.

The object of the unification procedure is to discover at least one substitution that causes two
literals to match. Usually, if there is one such substitution there are many. For example, the
literals

hate(x,y)

hate(Marcus,z)

could be unified with any of the following substitutions:

(Marcus/x,z/y)

(Marcus/x,y/z)

(Marcus/x,Caesar/y,Caesar/z)

(Marcus/x,Polonius/y,Polonius/z)

The first two of these are equivalent except for lexical variation. But the second two, although they
produce a match, also produce a substitution that is more restrictive than absolutely necessary for
the match. Because the final substitution produced by the, unification process will be used by the
resolution procedure, it is useful to generate the most general unifier possible. The algorithm
shown below will do that.

Having explained the operation of the unification algorithm, we can now state it concisely. We
describe a procedure Unify(L1, L2), which returns as its value a list representing the composition
of the substitutions that were performed during the match. The empty list, NIL, indicates that a
match was found without any substitutions. The list consisting of the single value FAIL indicates
that the unification procedure failed.

Algorithm: Unify(L1, L2)

1. If L1 or L2 are both variables or constants, then:

a. If L1 and L2 are identical, then return NIL.

b. Else if L1 is a variable, then if L1 occurs in L2 then return {FAIL}, else return (L2/L1).

PREDICATE LOGIC 113

c. Else if L2 is a variable then if L2 occurs in L1 then return {FAIL}, else , return (L1/L2).

d. Else return {FAIL}.

2. If the initial predicate symbols in L1 andL2 are not identical, then return {FAIL}.

3. If L1 and L2 have a different number of arguments, then return {FAIL}.

4. Set SUBST to NIL. (At the end of this procedure, SUBST will contain all the substitutions
used to unify L1 and L2.)

5. For i  1 to number of arguments in L1:

a. Call Unify with the ith argument of L1 and the ith argument of L2, putting result in S.

b. If S contains FAIL then return {FAIL}.

c. If S is not equal to NIL then:

i. Apply S to the remainder of both L1 and L2.

ii. SUBST:= APPEND(S, SUBST)

6. Return SUBST.

The only part of this algorithm that we have not yet discussed is the check in steps 1(b) and l(c) to
make sure that an expression involving a given variable is not unified Y with that variable.
Suppose we were attempting to unify the expressions

f(x, x)

f(g(x), g(x))

If we accepted g(x) as a substitution for x, then we would have to substitute it for x in the remainder
of the expressions. But this leads to infinite recursion since it will never be possible to eliminate x.

Unification has deep mathematical roots and is a useful operation in many AI programs, or
example, theorem provers and natural language parsers. As a result, efficient data structures and
algorithms for unification have been developed.

Resolution in Predicate Logic


We now have an easy way of determining that two literals are contradictory-they are if one of
them can be unified with the negation of the other. So, for example, man (x) and ¬man(Spot) are
contradictory, since man(x) and man(Spot) can be unified. This corresponds to the intuition that says
that man(x) cannot be true for all x if there is known to be some x, say Spot, for which man(x) is
false. Thus in order to use resolution for expressions in the predicate logic, we use the unification
algorithm to locate pairs of literals that cancel out.

We also need to use the unifier produced by the unification algorithm to generate the resolvent
clause. For example, suppose we want to resolve two clauses:

man(Marcus)

¬man(x1) ∨ mortal(x1)

The literal man (Marcus) can be unified with the literal man(x1) with the substitution Marcus(x1),
telling us that for x1 = Marcus, ¬man(Marcus) is false. But we cannot simply cancel out the two man
literals as we did in propositional logic and generate the resolvent mortal(x1). Clause 2 says that
for a given x1, either ¬man(x1) or mortal(x1). So for it to be true, we can now conclude only that
mortal(Marcus) must be true. It is not necessary that mortal(x1) be true for all x1, since for some
values of x1, ¬man(x1) might be true, making mortal(x1) irrelevant to the truth of the complete
clause. So the resolvent generated by clauses 1 and 2 must be mortal(Marcus), which we get by
applying the result of the unification process to the resolvent. The resolution process can then
proceed from there to discover whether mortal(Marcus) leads to a contradiction with other
available clauses.

This example illustrates the importance of standardizing variables apart during the process of
converting expressions to clause form. Given that that standardization has been done, it is easy
to determine how the unifier must be used to perform substitutions to create the resolvent. If two
instances of the same variable occur, then they must be given identical substitutions.

We can now state the resolution algorithm for predicate logic as follows, assuming a set of given
statements F and a statement to be proved P:

Algorithm: Resolution

1. Convert all the statements of F to clause form.

2. Negate P and convert the result to clause form. Add it to the set of clauses obtained in 1.

PREDICATE LOGIC 115

3. Repeat until either a contradiction is found, no progress can be made, or a predetermined
amount of effort has been expended.

a. Select two clauses. Call these the parent clauses.

b. Resolve them together. The resolvent will be the disjunction of all the literals of both
parent clauses with appropriate substitutions performed and with the following
exception: If there is one pair of literals T1 and ¬T2 such that one of the parent clauses
contains T1 and the other contains T2 and if T1 and T2 are unifiable, then neither T1 nor
T2 should appear in the resolvent. We call T1 and T2 complementary literals. Use
the substitution produced by the unification to create the resolvent. If there is more
than one pair of complementary literals, only one pair should be omitted from the
resolvent.

c. If the resolvent is the empty clause, then a contradiction has been found. If it is not, then
add it to the set of clauses available to the procedure.

If the choice of clauses to resolve together at each step is made in certain systematic ways, then
the resolution procedure will find a contradiction if one exists. However, it may take a very long
time. There exist strategies for making the choice that can speed up the process considerably:

• Only resolve pairs of clauses that contain complementary literals, since only such resolutions
produce new clauses that are harder to satisfy than their parents. To facilitate this, index
clauses by the predicates they contain, combined with an indication of whether the
predicate is negated. Then, given a particular clause, possible resolvents that contain a
complementary occurrence of one of its predicates can be located directly.

• Eliminate certain clauses as soon as they are generated so that they cannot participate in
later resolutions. Two kinds of clauses should be eliminated: tautologies (which can never
be unsatisfied) and classes that are subsumed by other clauses (i.e., they are easier to
satisfy. For example, P ∨ Q is subsumed by P.)

• Whenever possible, resolve either with one of the clauses that is part of the statement we are
trying to refute or with a clause generated by a resolution with such a clause. This is called
the set-of-support strategy and corresponds to the intuition that the contradiction we are looking
for must involve the statement we are trying to prove. Any other contradiction would say that
the previously believed statements were inconsistent.


• Whenever possible, resolve with clauses that have a single literal. Such resolutions generate
new clauses with fewer literals than the larger of their parent clauses and thus are probably
closer to the goal of a resolvent with zero terms. This method is called the unit-preference
strategy.

Returning back to the example of Marcus. We begin with converting them into to clause form as
shown in Figure 4.9(a). Figure 4.9(b) shows a resolution proof of the statement

hate(Marcus, Caesar)

Figure 4.9: A Resolution Proof

PREDICATE LOGIC 117

Of course, many more resolvents could have been generated than we have shown, but we used
the heuristics described above to guide the search. Notice that what we have done here
essentially is to reason backward from the statement we want to show is a contradiction through a
set of intermediate conclusions to the final conclusion of inconsistency.

Suppose our actual goal in proving the assertion


was to answer the question "Did Marcus hate Caesar?" In that case, we might just as easily have
attempted to prove the statement

¬hate(Marcus, Caesar)

To do so, we would have added


to the set of available clauses and begun the resolution process. But immediately we notice that
there are no clauses that contain a literal involving ¬hate. Since the resolution process can only
generate new clauses that are composed of combinations of literals from already existing
clauses, we know that no such clause can be generated and thus, we conclude that hate(Marcus,
Caesar) will not produce a contradiction with the known statements. This is an example of the kind
of situation in which the resolution procedure can detect that no contradiction exists. Sometimes


this situation is detected not at the beginning of a proof, but part way through, as shown in the
example in Figure 4.10(a), based on the axioms given in Figure 4.9. But suppose our knowledge
base contained the two additional statements
Figure 4.10: An Unsuccessful Attempt at Resolution

9. persecute(x, y)  hate(y, x)

10. hate(x,y)  persecute(y, x)

Converting to clause form, we get

9. ¬ persecute(x5,y2) ∨ hate(y2,x5)

10. ¬hate(x6,y3) ∨ persecute(y3,x6)

These statements enable the proof of Figure 4.10(a) to continue as shown in Figure 4.10(b). Now
to detect that there is no contradiction we must discover that the only resolvents that can be
generated have been generated before. In other words, although we can generate resolvents, we

can generate no new ones.
Figure 4.11: The Need to Standardize Variables

Recall that the final step of the process of converting a set of formulas to clause form was to
standardize apart the variables that appear in the final clauses. Now that we have discussed the
resolution procedure, we can see clearly why this step is so important. Figure 4.11 shows an

PREDICATE LOGIC 119

example of the difficulty that may arise if standardization is not done. Because the variable y
occurs in both clause 1 and clause 2, the substitution at the second resolution step produces a
clause that is too restricted and so does not lead to the contradiction that is present in the
database. If, instead, the clause:

¬father(Chris, y)

had been produced, the contradiction with clause 4 would have emerged. This would have
happened if clause 2 had been rewritten as:

¬mother(a, b) ∨ woman(a)

In its pure form, resolution requires all the knowledge it uses to be represented in the form of
clauses. But it is often more efficient to represent certain kinds of information in the form of
computable functions, computable predicates, and equality relationships. It is not hard to augment
resolution to handle this sort of knowledge. Figure 4.12 shows a resolution proof of the statement:

¬ alive(Marcus, now)


Figure 4.12: Using Resolution with Equality and Reduce

We have added two ways of generating new clauses, in addition to the resolution rule:

• Substitution of one value for another to which it is equal.

• Reduction of computable predicates. If the predicate evaluates to FALSE, it can simply be
dropped, since adding ∨ FALSE to a disjunction cannot change its truth value. If the
predicate evaluates to TRUE, then the generated clause is a tautology and cannot lead to a
contradiction.

The Need to Try Several Substitutions

Resolution provides a very good way of finding a refutation proof without actually trying all the
substitutions that Herbrand's theorem suggests might be necessary. But it does not always
eliminate the necessity of trying more than one substitution. For example, suppose we know, in
addition to the statements that

hate(Marcus, Paulus)

hate(Marcus,Julian)

Now if we want to prove that Marcus hates some ruler, we would be likely to try each substitution
shown in Figure 4.13(a) and (b) before finding the contradiction shown in (c). Sometimes there is
no way short of very good luck to avoid trying several substitutions.

PREDICATE LOGIC 121

Figure 4.13: Trying Several Substitutions

As another example of proof by resolution consider the example discussed in previous section.

1. John likes all kinds of food.

2. Apples are food.




5. Sue eats every thing Bill eats.

And we have to prove that “John likes peanuts: To prove this by resolution we convert these
sentences first into Coff’s and then to clause form.

1. Coff: ∀x: food (x) → likes (John, x)

Clause: ¬ food (x) ∨ likes (John, x)

2. Coff: food (Apple)

Clause: food (Apple)

3. Coff: ∀x: ∀y: eats (x, y) ∧ ¬ killed by (x, y) → food (y).

Clause: ¬ [eats (x, y)] ∧ ¬ killed by (x, y) ∨ food (y)

or ¬ eats (x, y) ∧ ¬ killed by (x, y) ∨ food (y)

4. Coff: eats (Bill, peanuts) ∧ ¬ killed by (Bill peanuts)

Clause: 4 (a) eats (Bill, peanuts)

4 (b) ¬ killed by (Bill peanuts)

5. Coff: ∀x: eats (Bill, x) → eats (Sue, x)

Clause: ¬ eats (Bill, x) ∨ eats (Sue, x)

We add the negation of the Coff of the sentence “John likes peanuts” which we have to prove.

6. Coff: ¬ likes (John, peanuts)

Clause: ¬ likes (John, peanuts)

Now the proof is as follows:

(1) (6)
¬ food (x)∨ likes (John, x) ¬ likes (John, peanuts)

PREDICATE LOGIC 123

(peanuts/x)

(3)
¬ eats (x, y)∨ killed by (x, y) ¬ food (peanuts)
∨ food (y)

(peanuts/y)

4 (a)
eats (Bill, peanuts) ¬ eats (x, peanuts)∨ killed by (x,
peanuts) Bill/x

4 (b)
Killed by (Bill, peanuts)
¬ Killed by(Bill, peanuts)

Question Answering

Now we will focus on how resolution can be used to answer fill-in-the-blank questions, such as
"When did Marcus die?" or "Who tried to assassinate a ruler?" Answering these questions


involves finding a known statement that matches the terms given in the question and then
responding with another piece of that same statement that fills the slot demanded by the
question. For example, to answer the question "When did Marcus die?" we need a statement of
the form

died(Marcus,??)

with ?? actually filled in by some particular year. So, since we can prove the statement

died(Marcus,79)

we can respond with the answer 79.

It turns out that the resolution procedure provides an easy way of locating just the statement we
need and finding a proof for it. Let's continue with the example question.

When did Marcus die?" In order to be able to answer this question, it must first be true that
Marcus died. Thus it must be the case that

∃t : died(Marcus,t)

A reasonable first step then might be to try to prove this. To do so using resolution, we attempt to
show that

¬∃t: died(Marcus, t)

produces a contradiction. What does it mean for that statement to produce a contradiction?
Either it conflicts with a statement of the form

∀t: died(Marcus, t)

where t is a variable, in which case we can either answer the question by reporting that there are
many times at which Marcus died, or we can simply pick one such time and respond with it. The
other possibility is that we produce a contradiction with one or more specific statements of the
form

died(Marcus, date)

for some specific value of date. Whatever value of date we use in producing that contradiction is
the answer we want. The value that proves that there is a value (and thus the inconsistency of the
statement that there is no such value) is exactly the value we want.

PREDICATE LOGIC 125

Figure 4.14( a) shows how the resolution process finds the statement for which we are looking.
The answer to the question can then be derived from the chain of unifications that lead back to
the starting clause. We can eliminate the necessity for this final step by adding an additional
expression to the one we are going to use to try to find a contradiction. This new expression will
simply be the one we are trying to prove true (i.e., it will be the negation of the expression that is
actually use<) in the resolution). We can tag it with a special marker so that it will not interfere
with the resolution process. (In the figure, it is underlined.) It will just get carried along, but each
time unification is done, the variables in this dummy expression will be bound just as are the ones
in the clauses that are actively being used. Instead of terminating on reaching the nil clause, the
resolution procedure will terminate when all that is left is the dummy expression. The bindings of
its variables at that point provide the answer to the question. Figure 4.15(b) shows how this
process produces an answer to our question.

Figure 4.14: Answer Extraction Using Resolution

Unfortunately, given a particular representation of the facts in a system, there will usually be
some questions that cannot be answered using this mechanism. For example, suppose that we


want to answer the question "What happened in 79 A.D.?" In order to answer the question, we
need to prove that something happened in 79. We need to prove

∃x : event(x, 79)

and to discover a value for x. But we do not have any statements of the form event(x,y). We can,
however, answer the question if we change our representation. Instead of saying

erupted(volcono, 79)

we can say

event(erupted(volcano),79)

Then the simple proof shown in Figure 4.15 enables us to answer the question.

This new representation has the drawback that it is more complex than the old one. And it still
does not make it possible to answer all conceivable questions. In general, it is necessary to

decide on the kinds of questions that will be asked and to design a representation appropriate for
those questions.
Figure 4.15: Using the New Representation

Of course, yes-no and fill-in-the-blank questions are not the only kinds one could ask. For
example, we might ask how to do something. So we have not yet completely solved the problem
of question answering. In later chapters, we discuss some other methods for answering a variety
of questions. Some of them exploit resolution; others do not.

Top

PREDICATE LOGIC 127

Natural Deduction

We introduced resolution as an easily implementable proof procedure that relies for its simplicity
on a uniform representation of the statements it uses. Unfortunately, uniformity has its price-
everything looks the same. Since everything looks the same, there is no easy way to select those
statements that are the most likely to be useful in solving a particular problem. In converting
everything to clause form, we often lose valuable heuristic information that is contained in the
original representation of the facts. For example, suppose we believe that all judges who are not
crooked are well educated, which can be represented as

∀x : judge(x) ∧ ¬ crooked(x)  educated(x)

In this form, the statement suggests a way of deducing that someone is educated. But when the
same statement is converted to clause form

¬judge(x) ∨ crooked(x) ∨ educated(x)

it appears also to be a way of deducing that someone is not a judge by showing that he is not
crooked and not educated. Of course, in a logical sense, it is. But it is almost certainly not the
best way, or even a very good way, to go about showing that someone is not a judge. The
heuristic information contained in the original statement has been lost in the transformation.

Another problem with the use of resolution as the basis of a theorem-proving system is that
people do not think in resolution. Thus it is very difficult for a person to interact with a resolution
theorem prover, either to give it advice or to be given advice by it. Since proving very hard things
is something that computers still do poorly, it is important from a practical standpoint that such
interaction be possible. To facilitate it, we are forced to look for a way of doing machine theorem
proving that corresponds more closely to the processes used in human theorem proving. We are
thus led to what we call, mostly by .I definition, natural deduction.

Natural deduction is not a precise term. Rather it describes a melange of techniques, used in
combination to solve problems that are not tractable by anyone method alone.

One common technique is to arrange knowledge, not by predicates, as we have been doing, but
rather by the objects involved in the predicates. Another technique is to use a set of rewrite rules
that not only describe logical implications but also suggest the way that those implications can be
exploited in proofs.

Top


Dependency-Directed Backtracking

If we take a depth-first approach to nonmonotonic reasoning, then the following scenario is likely
to occur often: We need to know a fact, F, which cannot be derived monotonically from what we
already know, but which can be derived by making some assumption A which seems plausible.
So we make assumption A, derive F, and then derive some additional facts G and H from F. We
later derive some other facts M and N, but they are completely independent of A and F. A little
while later, a new fact comes in that invalidates A. We need to rescind our proof of F, and also
our proofs of G and H since they depended on F. But what about M and N? They didn’t depend
on F, so there is no logical need to invalidate them. But if we use a conventional backtracking
scheme, we have to back up past conclusions in the other in which we derived them. So we have
to backup past M and N, thus undoing them, in order to get back to F, G, H and A. To get around
this problem, we need a slightly different notion of backtracking, one that is based on logical
dependencies rather than the chronological order in which decisions were made. We call this new
method dependency-directed backtracking in contrast to chronological backtracking, which we have
been using up until now.

Before we go into detail on how dependency-directed backtracking works, it is worth pointing out
that although one of the big motivations for it is in handling nonmonotonic reasoning, it turns out
to be useful for conventional search programs as well. This is not too surprising when you
consider, what any depth-first search program does is to “make a guess” at something, thus
creating a branch in the search space. If that branch eventually dies out, then we know that at
least one guess that led to it must be wrong. It could be any guess along the branch. In
chronological backtracking we have to assume it was the most recent guess ad back up there to
try an alternative. Sometimes, though, we have additional information that tells us which guess
caused the problem. We’d like to retract only that guess and the work that explicitly depended on
it, leaving everything else that has happened in the meantime intact. This is exactly what
dependency-directed backtracking does.

As an example, suppose we want to build a program that generates a solution to a fairly simple
problem, such as finding a time at which three busy people can all attend a meeting. One way to
solve such a problem is first to make an assumption that the meeting will be held on some
particular day, say Wednesday, add to the database an assertion to that effect, suitably tagged as
an assumption, and then proceed to find a time, checking along the way for any inconsistencies in
people’s schedules. If a conflict arises, the statement representing the assumption must be

PREDICATE LOGIC 129

discarded and replaced by another, hopefully noncontradictory, one. But, of course, any
statements that have been generated along the way that depend on the now-discarded
assumption must also be discarded.

Of course, this kind of situation can be handled by a straightforward tree search with
chronological backtracking. All assumptions, as well as the inferences drawn from them, are
recorded at the search node that created them. When a node is determined to represent a
contradiction, simply backtrack to the next node from which there remain unexplored paths. The
assumptions and their inferences will disappear automatically. The drawback to this approach is
illustrated in Figure 4.16, which shows part of the search tree of a program that is trying to
schedule a meeting. To do so, the program must solve a constraints satisfaction problem to find a
day and time at which none of the participants is busy and at which there is a sufficiently large
room available.

In order to solve the problem, the system must try to satisfy one constraint at a time. Initially,
there is little reason to choose one alternative over another, so it decides to schedule the meeting
on Wednesday. That creates a new constraint that must be met by the rest of the solution. The
assumption that the meeting will be held on Wednesday is stored at the node it generated. Next
the program tries to select a time at which all participants are available. Among them, they have
regularly scheduled daily meetings at all times except 2:00. So 2:00 is chosen as the meeting
time. But it would not have mattered which day was chosen. Then the program discovers that on
Wednesday there have no rooms available. So it backtracks past the assumption that the day
would be Wednesday and tries another day, Tuesday. Now it must duplicate the chain of
reasoning that led it to choose 2:00 as the time because that reasoning was lost when it
backtracked to reduce the choice of day. This occurred even though that reasoning did not
depend in any way on the assumption that the day would be Wednesday. By withdrawing
statements based on the order which they were generated by the search process rather than on
the basis of responsibility for inconsistency, we may waste a great deal of effort.


Figure 4.16: Nondependency-Directed Backtracking

If we want to use dependency-directed backtracking instead, so that we do not waste this effort,
then we need to do the following things:

Associate with each node one or more justifications. Each justification corresponds to a derivation
process that led to the node. (Since it is possible to derive the same node in several different
ways, we want to allow for the possibility of multiple justifications). Each justification must contain
a list of all the nodes (facts, rules, assumptions) on which its derivation depended.

Provide a mechanism that, when given a contradiction node and its justification, computes the
“no-good” set of assumptions that underline the justification. The no-good set is defined to be the
minimal set of assumptions such that if you remove any element from the set, the justification will
no longer be valid and the inconsistent node will no longer be believed.

Provide a mechanism for considering a no-good set and choosing an assumption to retract.

Provide a mechanism for propagating the result of retracting as assumption. This mechanism
must cause all of the justifications that depended, however indirectly, on the retracted assumption
to become invalid.

Student Activity 4.2

Answer the following questions.

1. Trace the operation of the unification algorithm on each of the following pairs of laterals.

a. f(Marcus) and f(Caesar)

PREDICATE LOGIC 131

b. f(x) and f(g(y))

c. f(Marcus, g(x,y)) and f(x, g (Caesar, Marcus)

2. Consider the following sentences

a. John likes all kinds of food.

b. Apples are food.

c. Chicken is food.

d. Anything anyone eats and is not killed by is food.

e. Bill eats peanuts and is still alive.

f. She eats everything Bill eats.

i. Translate these sentences into predicate logic.

ii. Prove that John likes peanuts using backward chaining.

iii. Prove that John likes peanuts using resolution.

iv. Use resolution to answer the question “What food does she eat”?

3. Explain how natural deduction is useful in resolution.

4. What is dependency directed backtracking?

Summary

• Modus Pones is a property of prepositions that is useful in resolution and can be
represented as P and P → ⇒ where P and Q are two clauses.
Q Q

• Resolution produces proofs by refutation.

• The legitimate expressions of the predicate logic are called well form formula (wff).

• A formula built by connecting two formulas with a ⇒ is called an implication.

• There are two types of quantifiers – universal and existential.

Self assessment Questions

Fill in the blanks (Solved)


1. Unification is a ___________ procedure.

2. Modus Pones is a property of ________.

Answers

1. recursive

2. propositions

True or False (Solved)

1. Q→P ⇒ Q is also known as Modus Ponens.

2. All hen are cups can be expressed as ∀x : hen(x)→ cups(x).

Answers

1. False

2. True

Fill in the blanks (Unsolved)

1. Resolution produces proof by ___________.

2. The resolution process is a simple _____________ process.

3. ____________ is a clause obtained by resolving two clauses.

True or False (Unsolved)

1. The theoretical basis of the resolution procedure in predicate logic is Herbrand's theorem.

2. The intuition that the contradiction being looked for must involve the statement being proved
is known as set-of-support strategy.

3. The formula f ( x ) →∀ ( x ) is always true.
xP

Detailed Questions

1. Using facts, answer the question, "Did Marcus hate Caesar?"

2. Trace the operation of the unification algorithm on each of the following pairs of , literals:
(a) f(Marcus) and f (Caesar)/ (b) f(x) and f (g(y)) (c) f(Marcus, g(x, y)) and f (x, g(Caesar, Marcus))

PREDICATE LOGIC 133

3. Consider the following sentences:

John likes all kinds of food.

Apples are food.

Chicken is food.

Anything anyone eats and isn't killed by is food. Bill eats peanuts and is still alive. Sue eats
everything Bill eats.

a. Translate these sentences into formulas in predicate logic.

b. Prove that John likes peanuts using backward chaining.

c. Convert the formulas of part a into clause form.

d. Prove that John likes peanuts using resolution.

e. Use resolution to answer the question, "What food does Sue eat?"

4. Given the following information for a database:

a. If x is on top of y, y supports x.

b. If x is above y and they are touching each other x is on top of y.

c. A cup is above a book

d. A cup is touching a book

i. Translates statements (a) through (b) into clause.

ii. Show that the predicate supports (book, cup) is true using resolution.

5. Prove that the formula f ( x ) →∀ ( x ) is always true if the domain D contains only one
xP

element.

6. Convert the following facts into clause form:

a. Bill is clever.

b. If Bill is clever then Bill succeed.

c. She is married to Joe.

Chapter 4 (final)

More Related Content

What's hot (20)

Similar to Chapter 4 (final) (20)

More from Nateshwar Kamlesh (10)

Chapter 4 (final)