Knowledge

representation First-order
predicate logic

Dr. Rudra Kalyan Nayak

Senior Assistant Professor
School of Computing Science & Engineering

What is knowledge-engineering?
• The process of constructing a knowledge-base
in first-order logic is called as knowledge
engineering.
• In knowledge-engineering, someone who
investigates a particular domain, learns
important concept of that domain, and
generates a formal representation of the
objects, is known as knowledge engineer.
What is knowledge acquisition?
• Often, the knowledge engineer is trained in
 representation but is not an expert in the
domain at hand, be it circuit design, space
station mission scheduling, or whatever.
• The knowledge engineer will usually interview
the real experts to become educated about
the domain and to elicit the required
knowledge, in a process called knowledge
acquisition.
The knowledge-engineering process:

• Following are some main steps of the

knowledge-engineering process.
• Using these steps, we will develop a
knowledge base which will allow us to reason
about digital circuit (One-bit full adder) which
is given below
The knowledge-engineering

process:
 The knowledge-engineering process:
• 1. Identify the task
• 2. Assemble the relevant knowledge
• 3. Decide on vocabulary
• 4. Encode general knowledge about the domain • 5.
Encode a description of the problem instance • 6.
Pose queries to the inference procedure and get
answers
• 7 Debug the knowledge base
KNOWLEDGE ENGINEERING vs.
PROGRAMMING
• A useful analogy can be made between
knowledge engineering and programming.
 Both activities can be seen as consisting of
four steps:

KNOWLEDGE ENGINEERING vs.

PROGRAMMING
• In both activities, one writes down a
description of a problem or state of affairs, and
then uses the definition of the language to
 derive new consequences.
• In the case of a program, the output is derived
from the input and the program; in the case of
a knowledge base, answers are derived from
descriptions of problems and the knowledge
base.
KNOWLEDGE ENGINEERING vs.
PROGRAMMING
• The main advantage of knowledge engineering
is that it requires less commitment, and thus
less work.
• A knowledge engineer only has to decide what
objects and relations are worth representing,
and which relations hold among which objects.
• A programmer has to do all that, and in
addition must decide how to compute the
relations between objects, given some initial
input.
KNOWLEDGE ENGINEERING vs.
PROGRAMMING
• The knowledge engineer specifies what is true,
and the inference procedure figures out how
 to turn the facts into a solution to the
problem.
• Furthermore, because a fact is true regardless
of what task one is trying to solve, knowledge
bases can, in principle, be reused for a variety
of different tasks without modification.
KNOWLEDGE ENGINEERING vs.
PROGRAMMING
• Finally, debugging a knowledge base is made
easier by the fact that any given sentence is
true or false by itself, whereas the correctness
of a program statement depends very strongly
 on its context
Inference in First-Order Logic
• Inference in First-Order Logic is used to deduce
new facts or sentences from existing
sentences.
• Before understanding the FOL inference rule,
let's understand some basic terminologies
used in FOL.
Inference in First-Order Logic
• Substitution:
 – Substitution is a fundamental operation performed
on terms and formulas. It occurs in all inference
systems in first-order logic. The substitution is
complex in the presence of quantifiers in FOL. If we
write F[a/x], so it refers to substitute a constant
"a" in place of variable "x".
• Note: First-order logic is capable of expressing
facts about some or all objects in the universe.
Inference in First-Order Logic
• Equality:
– First-Order logic does not only use predicate and terms
for making atomic sentences but also uses another
 way, which is equality in FOL. For this, we can use
equality symbols which specify that the two terms
refer to the same object.
– Example: Brother (John) = Smith.
– As in the above example, the object referred by the
Brother (John) is similar to the object referred by
Smith. The equality symbol can also be used with
negation to represent that two terms are not the same
objects.
– Example: ￢(x=y) which is equivalent to x ≠y.
FOL inference rules for quantifier:
• As propositional logic we also have inference
rules in first-order logic, so following are some
 basic inference rules in FOL:
• Universal Generalization
• Universal Instantiation
• Existential Instantiation
• Existential introduction
FOL inference rules for quantifier:
• 1. Universal Generalization:
– Universal generalization is a valid inference rule
which states that if premise P(c) is true for any
arbitrary element c in the universe of discourse,
 then we can have a conclusion as ∀ x P(x). – It can
be represented as: .
– This rule can be used if we want to show that
every element has a similar property.
– In this rule, x must not appear as a free variable.
FOL inference rules for quantifier:
• 1. Universal Generalization:
– Example: Let's represent, P(c): "A byte contains 8
bits", so for ∀ x P(x) "All bytes contain 8 bits.", it
will also be true.
FOL inference rules for quantifier:
• 2 Universal Instantiation::
– Universal instantiation is also called as universal
elimination or UI is a valid inference rule. It can be
applied multiple times to add new sentences.
– The new KB is logically equivalent to the previous KB. –
As per UI, we can infer any sentence obtained by
substituting a ground term for the variable.
– The UI rule state that we can infer any sentence P(c) by
substituting a ground term c (a constant within
domain x) from ∀ x P(x) for any object in the universe
of discourse.
FOL inference rules for quantifier:
• 2 Universal
Instantiation::
– It can be represented as:.
– Example:1.
– IF "Every person like ice-cream"=> ∀x P(x) so we can
infer that
"John likes ice-cream" => P(c)
– Example: 2.
– Let's take a famous example,
– "All kings who are greedy are Evil." So let our
knowledge base contains this detail as in the form of
FOL:
FOL inference rules for quantifier:
• 2 Universal Instantiation:
– "All kings who are greedy are Evil." So let our
knowledge base contains this detail as in the form of
FOL:
– ∀x king(x) ∧ greedy (x) → Evil (x),
– So from this information, we can infer any of the
following statements using Universal Instantiation: –
King(John) ∧ Greedy (John) → Evil (John),
– King(Richard) ∧ Greedy (Richard) → Evil (Richard), –
King(Father(John)) ∧ Greedy (Father(John)) → Evil
(Father(John)),
FOL inference rules for quantifier:
• 3 Existential Instantiation:
– Existential instantiation is also called as Existential
Elimination, which is a valid inference rule in first
order logic.
– It can be applied only once to replace the
existential sentence.
– The new KB is not logically equivalent to old KB,
but it will be satisfiable if old KB was satisfiable.
FOL inference rules for quantifier:
• 3 Existential Instantiation:
 – This rule states that one can infer P(c) from the
formula given in the form of ∃x P(x) for a new
constant symbol c.
– The restriction with this rule is that c used in the
rule must be a new term for which P(c ) is true. –

It can be represented as:

FOL inference rules for quantifier:
• 3 Existential Instantiation- Example: • From
the given sentence: ∃x Crown(x) ∧ OnHead(x,
John),
• So we can infer: Crown(K) ∧ OnHead( K, John),
 as long as K does not appear in the knowledge
base.
– The above used K is a constant symbol, which is
called Skolem constant.
– The Existential instantiation is a special case of
Skolemization process.
FOL inference rules for quantifier:
• 4 Existential introduction:
• An existential introduction is also known as an
existential generalization, which is a valid
inference rule in first-order logic.
• This rule states that if there is some element c
in the universe of discourse which has a
property P, then we can infer that there exists
something in the universe which has the
property P.

• It can be represented as:

FOL inference rules for quantifier:
• 4 Existential introduction: Example: Let's say
that,
– "Priyanka got good marks in English."
 "Therefore, someone got good marks in English."
What is Unification?
• Unification is a process of making two different
logical atomic expressions identical by finding
a substitution. Unification depends on the
substitution process.
• It takes two literals as input and makes them
identical using substitution.
• Let Ψ1and Ψ2 be two atomic sentences and
�� be a unifier such that, Ψ1�� = Ψ2��,
then it can be expressed as UNIFY(Ψ1, Ψ2).
What is Unification?
• Example: Find the MGU (Most General Unifier) for
Unify{King(x), King(John)}
• Let Ψ1 = King(x), Ψ2 = King(John),
• Substitution θ = {John/x} is a unifier for these atoms and
applying this substitution, and both expressions will be
identical.
• The UNIFY algorithm is used for unification, which takes two
atomic sentences and returns a unifier for those sentences
(If any exist).
• Unification is a key component of all first-order inference
algorithms.
• It returns fail if the expressions do not match with each other. • The
substitution variables are called Most General Unifier or MGU.
What is Unification?
• E.g. Let's say there are two different
expressions, P(x, y), and P(a, f(z)).
• In this example, we need to make both above
statements identical to each other. For this, we
will perform the substitution.
P(x, y)......... (i)
P(a, f(z))......... (ii)
• Substitute x with a, and y with f(z) in the first expression,
and it will be represented as a/x and f(z)/y.
• With both the substitutions, the first expression will be
identical to the second expression and the substitution set
will be: [a/x, f(z)/y].
Conditions for Unification:
• Following are some basic conditions for
unification:
• Predicate symbol must be same, atoms or
expression with different predicate symbol
can never be unified.
• Number of Arguments in both expressions
must be identical.
• Unification will fail if there are two similar
variables present in the same expression.
Conditions for Unification:
Unification Algorithm:
Algorithm: Unify(Ψ1, Ψ2)
Step. 1: If Ψ1 or Ψ2is a variable or constant, then:
• a) If Ψ1 or Ψ2are identical, then return NIL. • b)
Else if Ψ1is a variable,
– a. then if Ψ1 occurs in Ψ2, then return FAILURE
– b. Else return { (Ψ2/ Ψ1)}.
• c) Else if Ψ2is a variable,
– a. If Ψ2 occurs in Ψ1then return FAILURE,
– b. Else return {( Ψ1/ Ψ2)}.
• d) Else return FAILURE.

Conditions for Unification:

Unification Algorithm:
Algorithm: Unify(Ψ1, Ψ2)
Step.2: If the initial Predicate symbol in Ψ1and Ψ2are not same, then
return FAILURE.
Step. 3: IF Ψ1and Ψ2 have a different number of arguments, then
return FAILURE.
Step. 4: Set Substitution set(SUBST) to NIL.
Step. 5: For i=1 to the number of elements in Ψ1.
a) Call Unify function with the ith element of Ψ1and ith element of Ψ2,
and put the result into S.
b) If S = failure then returns Failure
c) If S ≠ NIL then do,
a. Apply S to the remainder of both L1 and L2.
b. b. SUBST= APPEND(S, SUBST).
Step.6: Return SUBST.

Implementation of the Algorithm

• Step.1: Initialize the substitution set to be empty.
• Step.2: Recursively unify atomic sentences: a)
Check for Identical expression match. b) If one
expression is a variable vi, and the other is
a term ti which does not contain variable vi, then:
a) Substitute ti/ viin the existing substitutions b) Add
ti/vito the substitution setlist.
c) If both the expressions are functions, then function
name must be similar, and the number of arguments
must be the same in both the expression.
• For each pair of the following atomic sentences
find the most general unifier (If exist).
Example
Find the MGU of {p(b, X, f(g(Z))) and p(Z, f(Y),
f(Y))} • Here, Ψ1 = p(b, X, f(g(Z))) , and Ψ2 = p(Z, f(Y),
f(Y)) S0 => { p(b, X, f(g(Z))); p(Z, f(Y), f(Y))}
SUBST θ={b/Z}
• S1 => { p(b, X, f(g(b))); p(b, f(Y), f(Y))}
SUBST θ={f(Y) /X}
• S2 => { p(b, f(Y), f(g(b))); p(b, f(Y), f(Y))}
SUBST θ= {g(b) /Y}
• S2 => { p(b, f(g(b)), f(g(b)); p(b, f(g(b)),
f(g(b))} Unified Successfully.
Example
Find the MGU of {p (X, X), and p (Z,
f(Z))} • Here, Ψ1 = {p (X, X), and Ψ2 = p (Z,
f(Z)) S0 => {p (X, X), p (Z, f(Z))}
SUBST θ= {X/Z}
S1 => {p (Z, Z), p (Z, f(Z))}
SUBST θ= {f(Z) / Z}, Unification Failed.
Example
Find the MGU of UNIFY(prime (11),
prime(y)) • Here, Ψ1 = {prime(11) , and Ψ2 =
prime(y)} S0 => {prime(11) , prime(y)}
 SUBST θ= {11/y}
• S1 => {prime(11) , prime(11)} , Successfully
unified.
Unifier: {11/y}.
Example
Find the MGU of Q(a, g(x, a), f(y)), Q(a, g(f(b), a),
x)}
• Here, Ψ1 = Q(a, g(x, a), f(y)), and Ψ2 = Q(a, g(f(b),
a), x)
S0 => {Q(a, g(x, a), f(y)); Q(a, g(f(b), a), x)}
SUBST θ= {f(b)/x}
 S1 => {Q(a, g(f(b), a), f(y)); Q(a, g(f(b), a), f(b))}
• SUBST θ= {b/y}
S1 => {Q(a, g(f(b), a), f(b)); Q(a, g(f(b), a),
f(b))}, Successfully Unified.
• Unifier: [a/a, f(b)/x, b/y].
Resolution in FOL
• 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.
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).
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.
Example:
• Step-1: Conversion of Facts into FOL
• In the first step we will convert all the given statements
into its first order logic.
 Example:
Step-2: Conversion of FOL into CNF
• In First order logic resolution, it is required to convert the FOL
into CNF as CNF form makes easier for resolution proofs. •
Eliminate all implication (→) and rewrite a. ∀x ¬
food(x) V likes(John, x)
b. food(Apple) Λ food(vegetables)
c. ∀x ∀y ¬ [eats(x, y) Λ ¬ killed(x)] V food(y)
d. eats (Anil, Peanuts) Λ alive(Anil)
e. ∀x ¬ eats(Anil, x) V eats(Harry, x)
f. ∀x¬ [¬ killed(x) ] V alive(x)
g. ∀x ¬ alive(x) V ¬ killed(x)
h. likes(John, Peanuts).
Example:
• Move negation (¬)inwards and rewrite
a. ∀x ¬ food(x) V likes(John, x)
b. food(Apple) Λ food(vegetables)
c. ∀x ∀y ¬ eats(x, y) V killed(x) V food(y)
d. eats (Anil, Peanuts) Λ alive(Anil)
e. ∀x ¬ eats(Anil, x) V eats(Harry, x)
f. ∀x ¬killed(x) ] V alive(x)
g. ∀x ¬ alive(x) V ¬ killed(x)
h. likes(John, Peanuts).
Example:
• Rename variables or standardize variables
 a. ∀x ¬ food(x) V likes(John, x)
b. food(Apple) Λ food(vegetables)
c. ∀y ∀z ¬ eats(y, z) V killed(y) V food(z)
d. eats (Anil, Peanuts) Λ alive(Anil)
e. ∀w¬ eats(Anil, w) V eats(Harry, w)
f. ∀g ¬killed(g) ] V alive(g)
g. ∀k ¬ alive(k) V ¬ killed(k)
h. likes(John, Peanuts).
Example:
Eliminate existential instantiation quantifier by
elimination.
 In this step, we will eliminate existential
quantifier ∃, and this process is known as
Skolemization. But in this example problem
since there is no existential quantifier so all the
statements will remain same in this step.
Skolemization –
Example 1
Every philosopher writes at least one book.
∀x*Philo(x) → ∃y[Book(y) ∧ Write(x, y)]]

Eliminate Implication:
∀x[¬Philo(x) ∨ ∃y[Book(y) ∧ Write(x, y)]]

Eliminate Implication:
Skolemize:
substitute y by g(x) ∀x[¬Philo(x) ∨ [Book(g(x)) ∧ Write(x, g(x))]]

Example:
• 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.
– ¬ 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).
 Example:
– Distribute conjunction ∧ over disjunction ¬. This
step will not make any change in this problem. •
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: Now in this
step, we will solve the problem by resolution
tree using substitution. For the above problem,
it will be given as follows:
Example:
 Example:
• Explanation of 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.
 Practice Questions on Resolution
Practice Question-1
• All hounds howl at night.
• Anyone who has any cats will not have any mice.
• Light sleepers do not have anything which howls at night.
• John has either a cat or a hound.
Prove by resolution that
• (Conclusion) If John is a light sleeper, then John does not have any mice.
Practice Question-2
• Everyone who feels warm either is drunk, or every costume they have is warm. •
Every costume that is warm is furry.
• Every AI student is a CS student.
• Every AI student has some robot costume.
• No robot costume is furry.
Prove by resolution that
• (Conclusion) If every CS student feels warm, then every AI student is drunk.

Forward Chaining and backward

 chaining in AI
• In artificial intelligence, forward and backward chaining
is one of the important topics,
• lets first understand that from where these two terms
came.
Inference engine:
• The inference engine is the component of the intelligent
system in artificial intelligence, which applies logical rules
to the knowledge base to infer new information from
known facts. The first inference engine was part of the
expert system. Inference engine commonly proceeds in
two modes, which are: • Forward chaining
• Backward chaining
Forward Chaining and backward
 chaining in AI
• Horn Clause and Definite clause:
• Horn clause and definite clause are the forms of sentences,
which enables knowledge base to use a more restricted and
efficient inference algorithm. Logical inference algorithms use
forward and backward chaining approaches, which require KB
in the form of the first-order definite clause.
• Definite clause: A clause which is a disjunction of literals
with exactly one positive literal is known as a definite
clause or strict horn clause.
• Horn clause: A clause which is a disjunction of literals
with at most one positive literal is known as horn clause.
Hence all the definite clauses are horn clauses.
• Example: (¬ p V ¬ q V k). It has only one positive literal k.
• It is equivalent to p ∧ q → k.
 Forward Chaining and backward
chaining in AI
A. Forward Chaining
• Forward chaining is also known as a forward deduction
or forward reasoning method when using an inference
engine.
• Forward chaining is a form of reasoning which start with
atomic sentences in the knowledge base and applies
inference rules (Modus Ponens) in the forward
direction to extract more data until a goal is reached.
• The Forward-chaining algorithm starts from known
facts, triggers all rules whose premises are satisfied,
and add their conclusion to the known facts. This
 process repeats until the problem is solved.
Forward Chaining and backward
chaining in AI
A. Forward Chaining
• Properties of Forward-Chaining:
• It is a down-up approach, as it moves from bottom to
top.
• It is a process of making a conclusion based on known
facts or data, by starting from the initial state and
reaches the goal state.
• Forward-chaining approach is also called as data-driven
as we reach to the goal using available data. • Forward
-chaining approach is commonly used in the expert
system, such as CLIPS, business, and production rule
systems.
Forward Chaining and backward
chaining in AI
A. Forward Chaining
• Example:
• "As per the law, it is a crime for an American to
sell weapons to hostile nations. Country A, an
enemy of America, has some missiles, and all the
missiles were sold to it by Robert, who is an
American citizen."
• Prove that "Robert is criminal."
• To solve the above problem, first, we will convert
 all the above facts into first-order definite clauses,
and then we will use a forward-chaining algorithm
to reach the goal.
Facts Conversion into FOL:
• Facts Conversion into FOL:
• It is a crime for an American to sell weapons to hostile nations. (Let's say p, q, and r
are variables)
American (p) ∧ weapon(q) ∧ sells (p, q, r) ∧ hostile(r) → Criminal(p) ...(1) •
Country A has some missiles. ?p Owns(A, p) ∧ Missile(p). It can be written in two
definite clauses by using Existential Instantiation, introducing new Constant T1.
Owns(A, T1) ......(2)
Missile(T1) .......(3)
• All of the missiles were sold to country A by Robert.
U: p Missiles(p) ∧ Owns (A, p) → Sells (Robert, p, A) ......(4)
• Missiles are weapons.
Missile(p) → Weapons (p) .......(5)
• Enemy of America is known as hostile.
 Enemy(p, America) →Hostile(p) ........(6)
• Country A is an enemy of America.
Enemy (A, America) .........(7)
• Robert is American
American(Robert). ..........(8)

Forward chaining proof:

• Step-1:
• In the first step we will start with the known facts and will choose the sentences
which do not have implications, such as: American(Robert), Enemy(A, America),
Owns(A, T1), and Missile(T1). All these facts will be represented as below.

• Step-2
• At the second step, we will see those facts which infer from available facts and with
satisfied premises.
• Rule-(1) does not satisfy premises, so it will not be added in the first iteration. •
Rule-(2) and (3) are already added.

Forward chaining proof:

• Step-1:
• Rule-(4) satisfy with the substitution {p/T1}, so Sells (Robert, T1, A) is added, which
infers from the conjunction of Rule (2) and (3).
• Rule-(6) is satisfied with the substitution(p/A), so Hostile(A) is added and which
infers from Rule-(7).
 Forward chaining proof:
• Step-3:
• At step-3, as we can check Rule-(1) is satisfied with the substitution {p/Robert, q/T1,
r/A}, so we can add Criminal(Robert) which infers all the available facts. And
hence we reached our goal statement.

• Hence it
is proved that Robert is Criminal using forward chaining approach.
 B. Backward Chaining:
• Backward-chaining is also known as a backward deduction or
backward reasoning method when using an inference engine. • A
backward chaining algorithm is a form of reasoning, which starts
with the goal and works backward, chaining through rules to find
known facts that support the goal.
• Properties of backward chaining:
• It is known as a top-down approach.
• Backward-chaining is based on modus ponens inference rule.
• In backward chaining, the goal is broken into sub-goal or sub
goals to prove the facts true.

B. Backward Chaining:
• It is called a goal-driven approach, as a list of goals decides
which rules are selected and used.
• Backward -chaining algorithm is used in game theory,
automated theorem proving tools, inference engines, proof
assistants, and various AI applications.
• The backward-chaining method mostly used a depth-first
search strategy for proof.
B. Backward Chaining:
Example:
• In backward-chaining, we will use the same above example,
and will rewrite all the rules.
• American (p) ∧ weapon(q) ∧ sells (p, q, r) ∧ hostile(r) →
Criminal(p) ...(1)
• Owns(A, T1) ........(2)
• Missile(T1)
• ?p Missiles(p) ∧ Owns (A, p) → Sells (Robert, p,
A) ......(4)
• Missile(p) → Weapons (p) .......(5)
• Enemy(p, America) →Hostile(p) ........(6) • Enemy
(A, America) .........(7)
• American(Robert). ..........(8)

B. Backward Chaining:
Backward-Chaining proof:
• In Backward chaining, we will start with our goal predicate,
which is Criminal(Robert), and then infer further rules.
Step-1:
• At the first step, we will take the goal fact. And from the goal
fact, we will infer other facts, and at last, we will prove those
 facts true. So our goal fact is "Robert is Criminal," so following
is the predicate of it.

B. Backward Chaining:
Step-2:
• At the second step, we will infer other facts form goal fact
which satisfies the rules. So as we can see in Rule-1, the goal
predicate Criminal (Robert) is present with substitution
{Robert/P}. So we will add all the conjunctive facts below the
first level and will replace p with Robert.
• Here we can see American (Robert) is a fact, so it is proved
here.
 B. Backward Chaining:

B. Backward Chaining:
Step-3:
• At step-3, we will extract further fact Missile(q) which
infer from Weapon(q), as it satisfies Rule-(5). Weapon (q) is
also true with the substitution of a constant T1 at q.

B. Backward Chaining:
Step-4:
• At step-4, we can infer facts Missile(T1) and Owns(A, T1) form
Sells(Robert, T1, r) which satisfies the Rule- 4, with the
substitution of A in place of r.
• So these two statements are proved here.
B. Backward Chaining:
 B. Backward Chaining:
Step-5:
• At step-5, we can infer the fact Enemy(A, America ) from
Hostile(A) which satisfies Rule- 6.
• And hence all the statements are proved true using backward
chaining.
B. Backward Chaining: