CHAPTER – 4

USING PREDICATE LOGIC

Prepared By:
Subject : AI
Asst. Prof. Twinkal Panchal
Code : 2180703 (CSE Department, ACET)
Representing Simple Facts In Logic
First-Order Logic

• First-order logic is another way of knowledge representation in

artificial intelligence. It is an extension to propositional logic.
• FOL is sufficiently expressive to represent the natural
language statements in a concise way.
• First-order logic is also known as Predicate logic or First-
order predicate logic. First-order logic is a powerful language
that develops information about the objects in a more easy way
and can also express the relationship between those objects.
• First-order logic (like natural language) does not only assume
that the world contains facts like propositional logic but also
assumes the following things in the world:
 • Objects: A, B, people, numbers, colors, wars, theories,
squares, pits, ......
• Relations: It can be unary relation such as: red, round, is
adjacent, or n-any relation such as: the sister of, brother
of, has color, comes between
• Function: Father of, best friend, third inning of, end of,
......
• A quantifier is a language element which generates
quantification, and quantification specifies the quantity of
specimen in the universe of discourse.
• These are the symbols that permit to determine or identify the
range and scope of the variable in the logical expression.
1. Universal Quantifier, (for all, everyone, everything)
2. Existential quantifier, (for some, at least one).
1. Universal Quantifier
• Universal quantifier is a symbol of logical representation,
which specifies that the statement within its range is true for
everything or every instance of a particular thing.
• The Universal quantifier is represented by a symbol ∀, which
resembles an inverted A.
• Note: In universal quantifier we use implication "→".
• If x is a variable, then ∀x is read as:
• For all x
• For each x
• For every x.
Ex-
All man drink coffee.
∀x man(x) → drink (x, coffee).
2. Existential Quantifier
• Existential quantifiers are the type of quantifiers, which
express that the statement within its scope is true for at least
one instance of something.
• It is denoted by the logical operator ∃, which resembles as
inverted E. When it is used with a predicate variable then it is
called as an existential quantifier.
• If x is a variable, then existential quantifier will be ∃x or ∃(x).
And it will be read as:
• There exists a 'x.'
• For some 'x.'
• For at least one 'x.„
Ex-
Some boys are intelligent.
∃x: boys(x) ∧ intelligent(x)
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 Romans were either loyal to Caesar or hated him.

∀x :Roman(y) -> (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 aren't loyal to.

∀x:∀y: Person(x) ∧ Ruler(y) ∧ TryAssassinate(x,y)) ->
¬LoyalTo(x,y)

8. Marcus tried to assassinate Caesar .

TryAssassinate(Marcus, Caesar).
Representing Instance and Isa Relationships
• Logic statements, containing subject, predicate, and object,
were explained. Also stated, two important attributes
"instance" and "isa", in a hierarchical structure.

• Attributes “ IsA ” and “ Instance ” support property

inheritance and play important role in knowledge
representation.

• The ways these two attributes "instance" and "isa", are

logically expressed are shown in the example below :

Ex-
A simple sentence like "Joe is a musician"

• Here "is a" (called IsA) is a way of expressing what

logically is called a class-instance relationship between the
subjects represented by the terms "Joe" and "musician".

• "Joe" is an instance of the class of things called "musician".

"Joe" plays the role of instance,

• "musician" plays the role of class in that sentence.

Computable Functions and Predicates

• It may be necessary to compute functions as part of a fact. In

these cases a computable predicate is used.
• A computable predicate may include computable functions
such as +, -, *, etc.
• For example, gt(x-y,10) →bigger(x) contains the computable
predicate gt which performs the greater than function.

Ex-
1. Marcus was a man.
man(Marcus).

2. Marcus was 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 ∀t2: mortal(x) /\ born(x,t1) /\ gt(t2-t1,150) →
dead(x,t2)
7. It is now 1991.
now=1991.

8. Alive means not dead.

∀x ∀t: [alive(x,t) → ~dead(x,t)] /\ [~dead(x,t)
→alive(x,t)]

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

∀x ∀t1 ∀t2:died(x,t1) /\ gt(t2,t1) →dead(x,t2).
Ex - “Is Marcus alive now?”.
~alive(Marcus,now)
↓8
~[~dead(Marcus,now)]
↓ negation operation
dead(Marcus,now)
↓9
died(Marcus,t1) /\ gt(now,t1)
↓5
erupted(volcano,79) /\ Pompeian(Marcus) /\ gt(now,79)
↓fact, 2
gt(now,79)
↓
gt(1991,79)
↓ compute gt
nil
Resolution
• Resolution proves facts and answers queries by refutation. This
involves assuming the fact/query is untrue and reaching a
contradiction which indicates that the opposite must be true. The
wffs must firstly be firstly converted to clause form before using
resolution.

Algorithm: Converting wffs to Clause Form

1. Remove all implies, i.e. → by applying the following: a → b is
equivalent to ~a \/ b.

2. Use the following rules to reduce the scope of each negation

operator to a single term:
• ~(~a) = a
• ~(a /\ b) = ~a \/ ~b
• ~(a \/ b) = ~a /\ ~b
 ~∀x: p(x) = ∃x: ~p(x)
~∃x: p(x) = ∀x: ~p(x)

3. Each quantifier must be linked to a unique variable. For

example, consider ∀x: p(x) \/ ∀x: q(x). In this both quantifiers
are using the same variable and one must changed to another
variable: ∀x: p(x) \/ ∀y: q(y).

4. Move all quantifiers, in order, to the left of each wff.

5. Remove existential quantifiers by using Skolem constants or

functions. For example, ∃x: p(x) becomes p(s1) and ∀x ∃y:
q(x,y) is replaced with ∀x: q(s2(x), x).

6. Drop the quantifier prefix.

7. Apply the associative property of disjunctions: a \/ (b \/ c) =
(a \/ b) \/ c and remove brackets giving a \/ b \/ c.

8. Remove all disjunctions of conjunctions from predicates, i.e.

create conjunctions of disjunctions instead, by applying the
following rule iteratively: (a /\ b) \/ c = (a \/ c) /\ (b \/ c).

9. Create a separate clause for each conjunction.

10. Rename variables in the clauses resulting from step 9. to

ensure that no two clauses refer to the same variable.
Algorithm: Resolution

1. Convert the wffs to clause form.

2. Add the fact (or query) P to be proved to the set of clauses:

i. Negate P.
ii. Convert negated P to clause form.
iii. Add the result of ii to the set of clauses.

3. Repeat
i. Select two clauses.
ii. Resolve the clauses using unification.
iii. If the resolvent clause is the empty clause, then a
contradiction has been reached. If not add the resolvent to
the set of clauses.
Consider the following wffs:
1. man(Marcus).
man(Marcus).

2. Pompeian(Marcus).
Pompeian(Marcus).

3. ∀x: Pompeian(x) → Roman(x).

~Pompeian(x) \/ Roman(x).

4. ruler(Caesar).
ruler(Caesar).

5. ∀x: Roman(x) → loyalto(x,Caesar) \/ hate(x,Caesar).

~Roman(x1) \/ loyalto(x1,Caesar) \/ hate(x1,Caesar).
6. ∀x ∃y: loyalto(x,y)
loyalto(x2,s1(x2))

7. ∀x ∀y: person(x) /\ ruler(y) /\ tryassassinate(x,y) →

~loyalto(x,y)
~person(x3) \/ ~ruler(y) \/ ~tryassassinate(x3,y) \/
~loyalto(x3,y)

8. tryassassinate(Marcus,Caesar).
tryassassinate(Marcus, Caesar).

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

~man(x4) \/ person(x4)
• we want to prove that Marcus hates Caesar.

• We firstly convert this to a wff: hate(Marcus,Caesar).

• The wff is then negated and converted to clause form:

~hate(Marcus,Caesar).

• This clause is added to the set of clauses and the resolution is

algorithm is applied:
 ~hate(Marcus,Caesar)
↓5
~Roman(Marcus) \/ loyalto(x1,Caesar)
↓3
~Pompeian(Marcus) \/ loyalto(Marcus,Caesar)
↓2
loyalto(Marcus,Caesar)
↓7
~person(Marcus) \/ ~ruler(Caesar) \/ ~tryassassinate(Marcus,Caesar)
↓4
~person(Marcus) \/ ~tryassassinate(Marcus,Caesar)
↓8
~person(Marcus)
↓9
~man(Marcus)
↓1