CO 304 AI UNIT 3 KR

using Predicate Logic

HARSHITA SHARMA
Topics in Syllabus
Knowledge Representation
◦ Knowledge Representation issues
◦ Knowledge Representation using Predicate Logic
◦ Unification
◦ Resolution
◦ Rule Based Systems
◦ Forward versus backward reasoning

Structured Knowledge Representation

◦ Semantic Nets
◦ Frames
◦ Conceptual Dependency
◦ Scripts
Knowledge
Knowledge is the collection of facts, inference rules etc. which can be used for a particular
purpose.
Knowledge requires the use of data and information. It combines relationships, correlations,
dependencies with data and information.
Knowledge is different from data. Data is the collection of raw materials where as knowledge is
the collection of some well specified inference rules and facts.
Knowledge is also different from belief and hypothesis. Belief is any meaningful and coherent
expression that can be represented. Belief may be true or false.
A hypothesis is a justified belief that is not known to be true. A hypothesis is a belief which is
backed up with some supporting evidence but it may still be false. So knowledge can be defined
as true justified knowledge.
Knowledge Representation
For the purpose of solving complex problems c\encountered in AI, we need both a large amount
of knowledge and some mechanism for manipulating that knowledge to create solutions to new
problems.
Knowledge representation is probably, the most important ingredient for developing an AI. A
representation is a layer between information accessible from outside world and high level
thinking processes. Without knowledge representation it is impossible to identify what thinking
processes are, mainly because representation itself is a substratum for a thought.
KR using Logic
Logic is the study of correct reasoning.
It is a formal science investigating how conclusions follow from premises. It is a formal system
that articulates a proof system.
Logic studies arguments, which consist of a set of premises together with a conclusion.
Arguments can be either correct or incorrect. An argument is correct if its premises support its
conclusion.
Propositional Logic
A proposition is a declarative sentence (that is, a sentence that declares a fact) that is either
true or false, but not both.
We use letters to denote propositional variables (or statement variables), that is, variables that
represent propositions, just as letters are used to denote numerical variables.
conventional letters used for propositional variables are p, q, r, s, . . . . The truth value of a
proposition is true, denoted by T, if it is a true proposition, and the truth value of a proposition is
false, denoted by F, if it is a false proposition.
The area of logic that deals with propositions is called the propositional calculus or
propositional logic. It was first developed systematically by the Greek philosopher Aristotle
more than 2300 years ago.
Operators: negation, conjunction, disjunction, implication, biconditional
Drawbacks
Propositional logic is useful because it is simple to deal with and a decision procedure for it
exists.
Also, In order to draw conclusions, facts are represented in a more convenient way as
predicates:
1. Marcus is a man.
man(Marcus)
2. Plato is a man.
man(Plato)
3. All men are mortal.
mortal(men)
But propositional logic fails to capture the relationship between an individual being a man and
that individual being a mortal.
How can these sentences be represented so that we can infer the third sentence from the first
two?
Also, Propositional logic commits only to the existence of facts that may or may not be the case
in the world being represented.
Moreover, It has a simple syntax and simple semantics. It suffices to illustrate the process of
inference.
Propositional logic quickly becomes impractical, even for very small worlds.
Predicate Logic
First-order Predicate logic (FOPL) models the world in terms of
Objects, which are things with individual identities
Properties of objects that distinguish them from other objects
Relations that hold among sets of objects
Functions, which are a subset of relations where there is only one “value” for any given “input”
First-order Predicate logic (FOPL) provides
Constants: a, b, dog33. Name a specific object.
Variables: X, Y. Refer to an object without naming it.
Functions: Mapping from objects to objects.
Terms: Refer to objects
Atomic Sentences: in(dad-of(X), food6) Can be true or false, Correspond to propositional
symbols P, Q.
A well-formed formula (wff) is a sentence containing no “free” variables. So, That is, all
variables are “bound” by universal or existential quantifiers.
(∀x)P(x, y) has x bound as a universally quantified variable, but y is free.
Quantifiers
Universal quantification
(∀x)P(x) means that P holds for all values of x in the domain associated with that variable
E.g., (∀x) dolphin(x) → mammal(x)
Existential quantification
(∃ x)P(x) means that P holds for some value of x in the domain associated with that variable
E.g., (∃ x) mammal(x) ∧ lays-eggs(x)
Question: Represent as a set of wffs
1. Marcus was a man.
2. Marcus was a Pompeian.
3. All Pompeians were Romans.
4. Caesar was a ruler.
5. Also, All Pompeians 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.
1. Marcus was a man.
man(Marcus)
2. Marcus was a Pompeian.
Pompeian(Marcus)
3. All Pompeians were Romans.
∀x: Pompeian(x) → Roman(x)
4. Caesar was a ruler.
ruler(Caesar)
5. All Pompeians were either loyal to Caesar or hated him.
inclusive-or
∀x: Roman(x) → loyalto(x, Caesar) ∨ hate(x, Caesar)
exclusive-or
∀x: Roman(x) → (loyalto(x, Caesar) ∧¬ hate(x, Caesar)) ∨
(¬loyalto(x, Caesar) ∧ hate(x, Caesar))
6. Everyone is loyal to someone.
∀x: ∃y: loyalto(x, y)
7. People only try to assassinate rulers they are not loyal to.
∀x: ∀y: person(x) ∧ ruler(y) ∧ tryassassinate(x, y)
→¬loyalto(x, y)
8. Marcus tried to assassinate Caesar.
tryassassinate(Marcus, Caesar)
Using the above, try to prove Was Marcus loyal to Caesar?
let’s try to produce a formal proof, reasoning backward from the desired goal: ¬ Ioyalto(Marcus,
Caesar)
In order to prove the goal, we need to use the rules of inference to transform it into another
goal (or possibly a set of goals) that can, in turn, transformed, and so on, until there are no
unsatisfied goals remaining.
The problem is that, although we know that Marcus was a man, we do not have any way to
conclude from that that Marcus was a person.
Also, We need to add the representation of another fact to our system, namely: ∀ man(x) →
person(x)
Now we can satisfy the last goal and produce a proof that Marcus was not loyal to Caesar.
From this simple example, we see that three important issues must be addressed in the process
of converting English sentences into logical statements and then using those statements to
deduce new ones:
Issues
Many English sentences are ambiguous (for example, 5, 6, and 7 above). Choosing the correct
interpretation may be difficult.
2. Also, There is often a choice of how to represent the knowledge. Simple representations are
desirable, but they may exclude certain kinds of reasoning.
3. Similalry, Even in very simple situations, a set of sentences is unlikely to contain all the
information necessary to reason about the topic at hand. In order to be able to use a set of
statements effectively. Moreover, It is usually necessary to have access to another set of
statements that represent facts that people consider too obvious to mention.
Representing Instance and ISA
Relationships
Specific attributes instance and isa play an important role particularly in a useful form of
reasoning called property inheritance.
The predicates instance and isa explicitly captured the relationships they used to express,
namely class membership and class inclusion.
Fig on next slide 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 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, described as shown in
sentence 3.
The implication rule 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 subclasssuperclass
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.
Computable Functions and Predicates
To express simple facts, such as the following greater-than and less-than relationships:
gt(1,O) It(0,1) gt(2,1) It(1,2) gt(3,2) It( 2,3)
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.
So, the below 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.
Example continued
1) Marcus was a man.
man(Marcus)
2) Marcus was a Pompeian.
Pompeian(Marcus)
3) Marcus was born in 40 A.D.
born(Marcus, 40)
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)]
6) No mortal lives longer than 150 years.
x: t1: At2: mortal(x) born(x, t1) gt(t2 – t1,150) → died(x, t2)
7) It is now 1991.
now = 1991
Question: Is Marcus alive?
Is Marcus alive?
The statements suggested here, 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.
Also, 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. For example, our
statements talk about dying, but they say nothing that relates to being alive, which is what the
question is asking. So we add some facts.
 8) Alive means not dead.
x: t: [alive(x, t) → ¬ dead(x, t)] [¬ dead(x, t) → alive(x, t)]
9) If someone dies, then he is dead at all later times.
x: t1: At2: died(x, t1) gt(t2, t1) → dead(x, t2)
So, Now let’s attempt to answer the question “Is Marcus alive?” by proving: ¬ alive(Marcus,
now)
Resolution
Resolution is a theorem proving technique that proceeds by building refutation proofs, i.e.,
proofs by contradictions. It was invented by a Mathematician John Alan Robinson in the year
1965.
Resolution is used, if there are various statements are given, and we need to prove a conclusion
of those statements. Unification is a key concept in proofs by resolutions. Resolution is a single
inference rule which can efficiently operate on the conjunctive normal form or clausal form.
Clause: Disjunction of literals (an atomic sentence) is called a clause. It is also known as a unit
clause.
Conjunctive Normal Form: A sentence represented as a conjunction of clauses is said to
be conjunctive normal form or CNF.
Resolution is 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., to 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).
The resolution procedure is a simple iterative process: at each step, two clauses, called the
parent clauses, are compared (resolved), resulting in a new clause that has 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 V summer
¬ winter V cold
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 V cold
This is the deduction that the resolution procedure will make.
Resolution operates by taking two clauses that each contains the same literal, in this example, winter.
Moreover, The literal must occur in the positive form in one clause and in negative form in the other. The resolvent
obtained by combining all of the literals of the two parent clauses except the ones that cancel.
If the clause that produced is the empty clause, then a contradiction has found. For example, the two clauses winter and
¬ winter will produce an empty clause.
Steps for Resolution
Conversion of facts into first-order logic.
Convert FOL statements into CNF
Negate the statement which needs to prove (proof by contradiction)
Draw resolution graph (unification).
Conversion to clause form
Eliminate all implication (→) and rewrite
Move negation (¬)inwards and rewrite
Move negation (¬)inwards and rewrite
Eliminate existential instantiation quantifier by elimination.
In this step, we will eliminate existential quantifier ∃, and this process is known
as Skolemization.
Drop Universal quantifiers.
In this step we will drop all universal quantifier since all the statements are not implicitly
quantified so we don't need it.
Rewrite into Conjunctive form (Distribute ∧ over ∨)
Propositional Resolution
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:
1. Select two clauses. Call these the parent clauses.
2. 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.
3. If the resolvent is the empty clause, then a contradiction has been found. If it is not, then add it to
the set of classes available to the procedure.
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 the man(John) and
¬man(Spot) is not.
Thus, in order to determine contradictions, we need a matching procedure that compares two
literals and discovers whether there exists a set of substitutions that makes them identical.
There is a straightforward recursive procedure, called the unification algorithm, that does it.
 Algorithm: Unify(L1, L2)
1. If L1 or L2 are both variables or constants, then:
1. If L1 and L2 are identical, then return NIL.
2. Else if L1 is a variable, then if L1 occurs in L2 then return {FAIL}, else return (L2/L1).
3. Also, 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 and L2 are not identical, then return {FAIL}.
3. If LI 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 the number of arguments in L1 :
1. Call Unify with the ith argument of L1 and the ith argument of L2, putting the result in S.
2. If S contains FAIL then return {FAIL}.
3. If S is not equal to NIL then:
1. Apply S to the remainder of both L1 and L2.
2. SUBST: = APPEND(S, SUBST).

6. Return SUBST.
Resolution in Predicate Logic (given set F,
to prove P)
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.
3. Repeat until a contradiction found, no progress can make, or a predetermined amount of
effort has expanded.
1. Select two clauses. Call these the parent clauses.
2. Resolve them together. The resolvent will 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 T2 and the other contains T1 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 omit from the resolvent.
3. If the resolvent is an empty clause, then a contradiction has found. Moreover, If it is not, then add it
to the set of classes available to the procedure.
Properties of Resolution
Complete for FOL
Refutation-complete
◦ If a set of sentences is unsatisfiable, resolution will always be able to derive a contradiction.

However, resolution can produce nonconstructive proofs.

◦ A proof which indirectly shows a mathematical object exists without providing a specific example or
algorithm for producing an example.
◦ To avoid that, answer literal is added to the negated goal.
◦ CNF(KB ∧ ¬(a ∧ answerLiteral))
Resolution Strategies
Unit preference
Make use of “unit clause” : a sentence which has exactly one literal.
Idea : use unit clause to produce shorter sentence.
Since we want to reach empty clause as soon as possible, having a heuristic that could reduce the
sentence’s length is worth trying.
Set of support(SoS)
◦ A special set that in every step of resolution, the resolvent comes from a member of that set.

Idea :
◦ We get a problem with a set of conditions.
◦ To solve the problem, we have to use every condition indicated in the problem.
◦ If we could solve without using every condition????
◦ Something must be off!
◦ That set of conditions is an analogy to the set of support.

Drawback
If we define bad SoS, problem becomes unsolvable.
Strategies for speeding up the resolution
process
Resolve clauses containing only complimentary literals
Eliminated tautologies and clauses subsumed by other clauses. PV Q is subsumed by P.
Set of support strategy
Unit preference strategy
Example
John likes all kind of food.
Apple and vegetable are food
Anything anyone eats and not killed is food.
Anil eats peanuts and still alive
Harry eats everything that Anil eats.
Prove by resolution that:
John likes peanuts.
Step-1: Conversion of Facts into FOL
Step-2: Conversion of FOL into CNF
Eliminate implication
∀x ¬ food(x) V likes(John, x)
food(Apple) Λ food(vegetables)
∀x ∀y ¬ [eats(x, y) Λ ¬ killed(x)] V food(y)
eats (Anil, Peanuts) Λ alive(Anil)
∀x ¬ eats(Anil, x) V eats(Harry, x)
∀x¬ [¬ killed(x) ] V alive(x)
∀x ¬ alive(x) V ¬ killed(x)
likes(John, Peanuts).
Move negation inwards
∀x ¬ food(x) V likes(John, x)
food(Apple) Λ food(vegetables)
∀x ∀y ¬ eats(x, y) V killed(x) V food(y)
eats (Anil, Peanuts) Λ alive(Anil)
∀x ¬ eats(Anil, x) V eats(Harry, x)
∀x ¬killed(x) ] V alive(x)
∀x ¬ alive(x) V ¬ killed(x)
likes(John, Peanuts).
Rename or standardize variables
∀x ¬ food(x) V likes(John, x)
food(Apple) Λ food(vegetables)
∀y ∀z ¬ eats(y, z) V killed(y) V food(z)
eats (Anil, Peanuts) Λ alive(Anil)
∀w¬ eats(Anil, w) V eats(Harry, w)
∀g ¬killed(g) ] V alive(g)
∀k ¬ alive(k) V ¬ killed(k)
likes(John, Peanuts).
Eliminate existential quantifier and skolemization: not required in this example.
Drop universal quantifiers.
¬ food(x) V likes(John, x)
food(Apple)
food(vegetables)
¬ eats(y, z) V killed(y) V food(z)
eats (Anil, Peanuts)
alive(Anil)
¬ eats(Anil, w) V eats(Harry, w)
killed(g) V alive(g)
¬ alive(k) V ¬ killed(k)
likes(John, Peanuts).
Distribute conjunction over disjunction: no change in this example
Step-3: Negate the statement to be
proved
In this statement, we will apply negation to the conclusion statements, which will be written as
¬likes(John, Peanuts)
Step 4: Draw Resolution Graph
Explanation of the Resolution Graph
In the first step of resolution graph, ¬likes(John, Peanuts) , and likes(John, x) get
resolved(canceled) by substitution of {Peanuts/x}, and we are left with ¬ food(Peanuts)
In the second step of the resolution graph, ¬ food(Peanuts) , and food(z) get resolved (canceled)
by substitution of { Peanuts/z}, and we are left with ¬ eats(y, Peanuts) V killed(y) .
In the third step of the resolution graph, ¬ eats(y, Peanuts) and eats (Anil, Peanuts) get resolved
by substitution {Anil/y}, and we are left with Killed(Anil) .
In the fourth step of the resolution graph, Killed(Anil) and ¬ killed(k) get resolve by
substitution {Anil/k}, and we are left with ¬ alive(Anil) .
In the last step of the resolution graph ¬ alive(Anil) and alive(Anil) get resolved.
Natural Deduction
Testing whether a proposition is a tautology by testing every possible truth assignment is
expensive—there are exponentially many. We need a deductive system, which will allow us to
construct proofs of tautologies in a step-by-step fashion.
The system we will use is known as natural deduction. The system consists of a set of rules of
inference for deriving consequences from premises. One builds a proof tree whose root is the
proposition to be proved and whose leaves are the initial assumptions or axioms (for proof
trees, we usually draw the root at the bottom and the leaves at the top).
Example: Modus ponens.