Inference in first order logic
Download
1 / 89

Inference in First-Order Logic - PowerPoint PPT Presentation


  • 146 Views
  • Uploaded on

Inference in First-Order Logic. Proofs Unification Generalized modus ponens Forward and backward chaining Completeness Resolution Logic programming. Inference in First-Order Logic. Proofs – extend propositional logic inference to deal with quantifiers Unification

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Inference in First-Order Logic' - ayala


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Inference in first order logic
Inference in First-Order Logic

  • Proofs

  • Unification

  • Generalized modus ponens

  • Forward and backward chaining

  • Completeness

  • Resolution

  • Logic programming

CS 460, Session 16-18


Inference in first order logic1
Inference in First-Order Logic

  • Proofs – extend propositional logic inference to deal with quantifiers

  • Unification

  • Generalized modus ponens

  • Forward and backward chaining – inference rules and reasoning

    program

  • Completeness – Gödel’s theorem: for FOL, any sentence entailed by

    another set of sentences can be proved from that set

  • Resolution – inference procedure that is complete for any set of

    sentences

  • Logic programming

CS 460, Session 16-18


Logic as a representation of the world

entails

Representation: Sentences

Sentence

Refers to

(Semantics)

follows

Fact

World

Facts

Logic as a representation of the World

CS 460, Session 16-18


Desirable properties of inference procedures

derivation

entail

Sentences

Sentence

Follows – from-1

Fact

Facts

Desirable Properties of Inference Procedures

CS 460, Session 16-18


Remember propositional logic
Remember:propositionallogic

CS 460, Session 16-18


Reminder
Reminder

  • Ground term: A term that does not contain a variable.

    • A constant symbol

    • A function applies to some ground term

  • {x/a}: substitution/binding list

CS 460, Session 16-18


Proofs
Proofs

CS 460, Session 16-18


Proofs1
Proofs

The three new inference rules for FOL (compared to propositional logic) are:

  • Universal Elimination (UE):

    for any sentence , variable x and ground term ,

    x 

    {x/}

  • Existential Elimination (EE):

    for any sentence , variable x and constant symbol k not in KB,

    x 

    {x/k}

  • Existential Introduction (EI):

    for any sentence , variable x not in  and ground term g in ,

    x {g/x}

CS 460, Session 16-18


Proofs2
Proofs

The three new inference rules for FOL (compared to propositional logic) are:

  • Universal Elimination (UE):

    for any sentence , variable x and ground term ,

    x  e.g., from x Likes(x, Candy) and {x/Joe}

    {x/} we can infer Likes(Joe, Candy)

  • Existential Elimination (EE):

    for any sentence , variable x and constant symbol k not in KB,

    x  e.g., from x Kill(x, Victim) we can infer

    {x/k} Kill(Murderer, Victim), if Murderer new symbol

  • Existential Introduction (EI):

    for any sentence , variable x not in  and ground term g in ,

     e.g., from Likes(Joe, Candy) we can infer

    x {g/x} x Likes(x, Candy)

CS 460, Session 16-18


Example proof
Example Proof

CS 460, Session 16-18


Example proof1
Example Proof

CS 460, Session 16-18


Example proof2
Example Proof

CS 460, Session 16-18


Example proof3
Example Proof

4 & 5

CS 460, Session 16-18



Unification
Unification

Goal of unification: finding σ

CS 460, Session 16-18


Unification1
Unification

CS 460, Session 16-18


Extra example for unification
Extra example for unification

CS 460, Session 16-18


Extra example for unification1
Extra example for unification

CS 460, Session 16-18


More unification examples

VARIABLE term

More Unification Examples

1 – unify(P(a,X), P(a,b)) σ = {X/b}

2 – unify(P(a,X), P(Y,b)) σ = {Y/a, X/b}

3 – unify(P(a,X), P(Y,f(a)) σ = {Y/a, X/f(a)}

4 – unify(P(a,X), P(X,b)) σ = failure

Note: If P(a,X) and P(X,b) are independent, then we can replace X with Y and get the unification to work.

CS 460, Session 16-18


Generalized modus ponens gmp
Generalized Modus Ponens (GMP)

CS 460, Session 16-18


Soundness of gmp
Soundness of GMP

CS 460, Session 16-18


Properties of gmp
Properties of GMP

  • Why is GMP and efficient inference rule?

    - It takes bigger steps, combining several small inferences into one

    - It takes sensible steps: uses eliminations that are guaranteed

    to help (rather than random UEs)

    - It uses a precompilation step which converts the KB to canonical

    form (Horn sentences)

    Remember: sentence in Horn from is a conjunction of Horn clauses

    (clauses with at most one positive literal), e.g.,

    (A  B)  (B  C  D), that is (B  A)  ((C  D)  B)

CS 460, Session 16-18


Horn form
Horn form

  • We convert sentences to Horn form as they are entered into the KB

  • Using Existential Elimination and And Elimination

  • e.g., x Owns(Nono, x)  Missile(x) becomes

    Owns(Nono, M)

    Missile(M)

    (with M a new symbol that was not already in the KB)

CS 460, Session 16-18


Forward chaining
Forward chaining

CS 460, Session 16-18


Forward chaining example
Forward chaining example

CS 460, Session 16-18


Backward chaining
Backward chaining

CS 460, Session 16-18


Backward chaining example
Backward chaining example

CS 460, Session 16-18


Another example from konelsky
Another Example (from Konelsky)

  • Nintendo example.

    • Nintendo says it is Criminal for a programmer to provide emulators to people. My friends don’t have a Nintendo 64, but they use software that runs N64 games on their PC, which is written by Reality Man, who is a programmer.

CS 460, Session 16-18


Forward chaining1
Forward Chaining

  • The knowledge base initially contains:

    • Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)  Criminal(x)

    • Use(friends, x)  Runs(x, N64 games) 

      Provide(Reality Man, friends, x)

    • Software(x)  Runs(x, N64 games)  Emulator(x)

CS 460, Session 16-18


Forward chaining2
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)  Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

  • Now we add atomic sentences to the KB sequentially, and call on the forward-chaining procedure:

    • FORWARD-CHAIN(KB, Programmer(Reality Man))

CS 460, Session 16-18


Forward chaining3
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)

 Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

  • This new premise unifies with (1) with

    subst({x/Reality Man}, Programmer(x))

    but not all the premises of (1) are yet known, so nothing further happens.

CS 460, Session 16-18


Forward chaining4
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)  Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

  • Continue adding atomic sentences:

    • FORWARD-CHAIN(KB, People(friends))

CS 460, Session 16-18


Forward chaining5
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)  Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

  • This also unifies with (1) with subst({z/friends}, People(z)) but other premises are still missing.

CS 460, Session 16-18


Forward chaining6
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)  Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

  • Add:

    • FORWARD-CHAIN(KB, Software(U64))

CS 460, Session 16-18


Forward chaining7
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)

 Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

  • This new premise unifies with (3) but the other premise is not yet known.

CS 460, Session 16-18


Forward chaining8
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y)

 Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)

 Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)

 Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

  • Add:

    • FORWARD-CHAIN(KB, Use(friends, U64))

CS 460, Session 16-18


Forward chaining9
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

  • This premise unifies with (2) but one still lacks.

CS 460, Session 16-18


Forward chaining10
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

  • Add:

    • FORWARD-CHAIN(Runs(U64, N64 games))

CS 460, Session 16-18


Forward chaining11
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

Runs(U64, N64 games) (8)

  • This new premise unifies with (2) and (3).

CS 460, Session 16-18


Forward chaining12
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

Runs(U64, N64 games) (8)

  • Premises (6), (7) and (8) satisfy the implications fully.

CS 460, Session 16-18


Forward chaining13
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

Runs(U64, N64 games) (8)

  • So we can infer the consequents, which are now added to the knowledge base (this is done in two separate steps).

CS 460, Session 16-18


Forward chaining14
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

Runs(U64, N64 games) (8)

Provide(Reality Man, friends, U64) (9)

Emulator(U64) (10)

  • Addition of these new facts triggers further forward chaining.

CS 460, Session 16-18


Forward chaining15
Forward Chaining

Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x) (1)

Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x) (2)

Software(x)  Runs(x, N64 games)  Emulator(x) (3)

Programmer(Reality Man) (4)

People(friends) (5)

Software(U64) (6)

Use(friends, U64) (7)

Runs(U64, N64 games) (8)

Provide(Reality Man, friends, U64) (9)

Emulator(U64) (10)

Criminal(Reality Man) (11)

  • Which results in the final conclusion: Criminal(Reality Man)

CS 460, Session 16-18


Forward chaining16
Forward Chaining

  • Forward Chaining acts like a breadth-first search at the top level, with depth-first sub-searches.

  • Since the search space spans the entire KB, a large KB must be organized in an intelligent manner in order to enable efficient searches in reasonable time.

CS 460, Session 16-18


Backward chaining1
Backward Chaining

  • The algorithm (available in detail in textbook):

    • a knowledge base KB

    • a desired conclusion c or question q

    • finds all sentences that are answers to q in KB or proves c

      • if q is directly provable by premises in KB, infer q and remember how q was inferred (building a list of answers).

      • find all implications that have q as a consequent.

      • for each of these implications, find out whether all of its premises are now in the KB, in which case infer the consequent and add it to the KB, remembering how it was inferred. If necessary, attempt to prove the implication also via backward chaining

      • premises that are conjuncts are processed one conjunct at a time

CS 460, Session 16-18


Backward chaining2
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    • Criminal(Reality Man)

  • Possible answers:

    • Steal(x, y)  Criminal(x)

    • Kill(x, y)  Criminal(x)

    • Grow(x, y)  Illegal(y)  Criminal(x)

    • HaveSillyName(x)  Criminal(x)

    • Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x)

CS 460, Session 16-18


Backward chaining3
Backward Chaining

  • Question: Has Reality Man done anything criminal?

Criminal(x)

CS 460, Session 16-18


Backward chaining4
Backward Chaining

  • Question: Has Reality Man done anything criminal?

Criminal(x)

Steal(x,y)

CS 460, Session 16-18


Backward chaining5
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL

Criminal(x)

Steal(x,y)

CS 460, Session 16-18


Backward chaining6
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL

Criminal(x)

Steal(x,y)

Kill(x,y)

CS 460, Session 16-18


Backward chaining7
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL FAIL

Criminal(x)

Steal(x,y)

Kill(x,y)

CS 460, Session 16-18


Backward chaining8
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL FAIL

Criminal(x)

grows(x,y)

Illegal(y)

Steal(x,y)

Kill(x,y)

CS 460, Session 16-18


Backward chaining9
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL FAIL FAIL FAIL

Criminal(x)

grows(x,y)

Illegal(y)

Steal(x,y)

Kill(x,y)

CS 460, Session 16-18


Backward chaining10
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    FAIL FAIL FAIL FAIL

  • Backward Chaining is a depth-first search: in any knowledge base of realistic size, many search paths will result in failure.

Criminal(x)

grows(x,y)

Illegal(y)

Steal(x,y)

Kill(x,y)

CS 460, Session 16-18


Backward chaining11
Backward Chaining

  • Question: Has Reality Man done anything criminal?

  • We will use the same knowledge as in our forward-chaining version of this example:

    Programmer(x)  Emulator(y)  People(z)  Provide(x,z,y) Criminal(x)

    Use(friends, x)  Runs(x, N64 games)  Provide(Reality Man, friends, x)

    Software(x)  Runs(x, N64 games)  Emulator(x)

    Programmer(Reality Man)

    People(friends)

    Software(U64)

    Use(friends, U64)

    Runs(U64, N64 games)

CS 460, Session 16-18


Backward chaining12
Backward Chaining

  • Question: Has Reality Man done anything criminal?

Criminal(x)

CS 460, Session 16-18


Backward chaining13
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}

Criminal(x)

Programmer(x)

CS 460, Session 16-18


Backward chaining14
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

Criminal(x)

Programmer(x)

People(Z)

CS 460, Session 16-18


Backward chaining15
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

Criminal(x)

Programmer(x)

People(Z)

Emulator(y)

CS 460, Session 16-18


Backward chaining16
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

    Yes, {y/U64}

Criminal(x)

Programmer(x)

People(z)

Emulator(y)

Software(y)

CS 460, Session 16-18


Backward chaining17
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

    Yes, {y/U64} yes, {}

Criminal(x)

Programmer(x)

People(z)

Emulator(y)

Software(y)

Runs(U64, N64 games)

CS 460, Session 16-18


Backward chaining18
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

    Yes, {y/U64} yes, {}

Criminal(x)

Programmer(x)

People(z)

Emulator(y)

Provide

(reality man,

U64,

friends)

Software(y)

Runs(U64, N64 games)

CS 460, Session 16-18


Backward chaining19
Backward Chaining

  • Question: Has Reality Man done anything criminal?

    Yes, {x/Reality Man}Yes, {z/friends}

    Yes, {y/U64}

    yes, {}

Criminal(x)

Programmer(x)

People(z)

Emulator(y)

Provide

(reality man,

U64,

friends)

Software(y)

Runs(U64, N64 games)

Use(friends, U64)

CS 460, Session 16-18


Backward chaining20
Backward Chaining

  • Backward Chaining benefits from the fact that it is directed toward proving one statement or answering one question.

  • In a focused, specific knowledge base, this greatly decreases the amount of superfluous work that needs to be done in searches.

  • However, in broad knowledge bases with extensive information and numerous implications, many search paths may be irrelevant to the desired conclusion.

  • Unlike forward chaining, where all possible inferences are made, a strictly backward chaining system makes inferences only when called upon to answer a query.

CS 460, Session 16-18


Field trip russell s paradox bertrand russell 1901
Field Trip – Russell’s Paradox (Bertrand Russell, 1901)

  • Your life has been simple up to this point, lets see how logical negation and self-referencing can totally ruin our day.

  • Russell's paradox is the most famous of the logical or set-theoretical paradoxes. The paradox arises within naive set theory by considering the set of all sets that are not members of themselves. Such a set appears to be a member of itself if and only if it is not a member of itself, hence the paradox.

  • Negation and self-reference naturally lead to paradoxes, but are necessary for FOL to be universal.

  • Published in Principles of Mathematics (1903).

CS 460, Session 16-18


Field trip russell s paradox
Field Trip – Russell’s Paradox

  • Basic example:

    • Librarians are asked to make catalogs of all the books in their libraries.

    • Some librarians consider the catalog to be a book in the library and list the catalog in itself.

    • The library of congress is asked to make a master catalog of all library catalogs which do not include themselves.

    • Should the master catalog in the library of congress include itself?

  • Keep this tucked in you brain as we talk about logic today. Logical systems can easily tie themselves in knots.

  • See also: http://plato.stanford.edu/entries/russell-paradox/

  • For additional fun on paradoxes check out “I of Newton” from: TheNew Twilight Zone (1985) http://en.wikipedia.org/wiki/I_of_Newton

CS 460, Session 16-18


Completeness
Completeness

  • As explained earlier, Generalized Modus Ponens requires sentences to be in Horn form:

    • atomic, or

    • an implication with a conjunction of atomic sentences as the antecedent and an atom as the consequent.

  • However, some sentences cannot be expressed in Horn form.

    • e.g.: x  bored_of_this_lecture (x)

    • Cannot be expressed in Horn form due to presence of negation.

CS 460, Session 16-18


Completeness1
Completeness

  • A significant problem since Modus Ponens cannot operate on such a sentence, and thus cannot use it in inference.

  • Knowledge exists but cannot be used.

  • Thus inference using Modus Ponens is incomplete.

CS 460, Session 16-18


Completeness2
Completeness

  • However, Kurt Gödel in 1930-31 developed the completeness theorem, which shows that it is possible to find complete inference rules.

  • The theorem states:

    • any sentence entailed by a set of sentences can be proven from that set.

      => Resolution Algorithm which is a complete inference method.

CS 460, Session 16-18


Completeness3
Completeness

  • The completeness theorem says that a sentence can be proved ifit is entailed by another set of sentences.

  • This is a big deal, since arbitrarily deeply nested functions combined with universal quantification make a potentially infinite search space.

  • But entailment in first-order logic is only semi-decidable, meaning that if a sentence is not entailed by another set of sentences, it cannot necessarily be proven.

    • This is to a certain degree an exotic situation, but a very real one - for instance the Halting Problem.

    • Much of the time, in the real world, you can decide if a sentence it not entailed if by no other means than exhaustive elimination.

CS 460, Session 16-18


Completeness in fol
Completeness in FOL

CS 460, Session 16-18


Historical note
Historical note

CS 460, Session 16-18


Kinship example
Kinship Example

KB:

(1) father (art, jon)

(2) father (bob, kim)

(3) father (X, Y)  parent (X, Y)

Goal: parent (art, jon)?

CS 460, Session 16-18


Refutation proof graph
Refutation Proof/Graph

¬parent(art,jon) ¬father(X, Y) \/ parent(X, Y)

\ /

¬father (art, jon) father (art, jon)

\ /

[]

CS 460, Session 16-18


Resolution
Resolution

CS 460, Session 16-18


Resolution inference rule
Resolution inference rule

CS 460, Session 16-18


Remember normal forms
Remember: normal forms

“product of sums of

simple variables or

negated simple variables”

“sum of products of

simple variables or

negated simple variables”

CS 460, Session 16-18



Skolemization
Skolemization

If x has a y we can infer that y exists. However, its existence is contingent on x, thus y is a function of x as H(x).

CS 460, Session 16-18


Examples converting fol sentences to clause form
Examples: Converting FOL sentences to clause form…

Convert the sentence

1. (x)(P(x) => ((y)(P(y) => P(f(x,y))) ^ ¬(y)(Q(x,y) => P(y))))

(like A => B ^ C)

2. Eliminate =>

(x)(¬P(x)  ((y)(¬P(y)  P(f(x,y))) ^ ¬(y)(¬Q(x,y)  P(y))))

3. Reduce scope of negation

(x)(¬P(x)((y)(¬P(y)  P(f(x,y))) ^ (y)(Q(x,y) ^ ¬P(y))))

4. Standardize variables

(x)(¬P(x) ((y)(¬P(y)  P(f(x,y))) ^ (z)(Q(x,z) ^ ¬P(z))))

CS 460, Session 16-18


Examples converting fol sentences to clause form1
Examples: Converting FOL sentences to clause form…

5. Eliminate existential quantification

(x)(¬P(x)  ((y)(¬P(y)  P(f(x,y))) ^ (Q(x,g(x)) ^ ¬P(g(x)))))

6. Drop universal quantification symbols

(¬P(x) ((¬P(y)  P(f(x,y))) ^ (Q(x,g(x)) ^ ¬P(g(x)))))

7. Convert to conjunction of disjunctions

(¬P(x)  ¬P(y)  P(f(x,y))) ^ (¬P(x)  Q(x,g(x))) ^ (¬P(x)  ¬P(g(x)))

  • (x)(¬P(x) ((y)(¬P(y)  P(f(x,y))) ^ (z)(Q(x,z) ^ ¬P(z)))) …

CS 460, Session 16-18


Examples converting fol sentences to clause form2
Examples: Converting FOL sentences to clause form…

8. Create separate clauses

¬P(x)  ¬P(y)  P(f(x,y))

¬P(x)  Q(x,g(x))

¬P(x)  ¬P(g(x))

9. Standardize variables

¬P(x)  ¬P(y)  P(f(x,y))

¬P(z)  Q(z,g(z))

¬P(w)  ¬P(g(w))

(¬P(x)  ¬P(y)  P(f(x,y))) ^ (¬P(x)  Q(x,g(x))) ^ (¬P(x)  ¬P(g(x))) …

CS 460, Session 16-18



Resolution proof
Resolution proof

Note: This is not a

particularly good example

that came from AIMA 1st ed.

AIMA 2nd ed. Ch 9.5 has

much better ones.

Want to prove

CS 460, Session 16-18


Inference in first order logic2
Inference in First-Order Logic

  • Canonical forms for resolution

    Conjunctive Normal Form (CNF) Implicative Normal Form (INF)

CS 460, Session 16-18


Example of refutation proof in conjunctive normal form

Cats like fish

Cats eat everything they like

Josephine is a cat.

Prove: Josephine eats fish.

cat (x)  likes (x,fish)

cat (y)  likes (y,z)  eats (y,z)

cat (jo)

eats (jo,fish)

Example of Refutation Proof(in conjunctive normal form)

CS 460, Session 16-18


Refutation
Refutation

Negation of goal wff:  eats(jo, fish)

 eats(jo, fish)  cat(y)  likes(y, z)  eats(y, z)

 = {y/jo, z/fish}

 cat(jo)  likes(jo, fish) cat(jo)

 = 

 cat(x)  likes(x, fish)  likes(jo, fish)

 = {x/jo}

 cat(jo) cat(jo)

 (contradiction)

CS 460, Session 16-18


Forward chaining17
Forward chaining

cat (jo) cat (X)  likes (X,fish)

\ /

likes (jo,fish) cat (Y)  likes (Y,Z)  eats (Y,Z)

\ /

cat (jo)  eats (jo,fish) cat (jo)

\ /

eats (jo,fish)  eats (jo,fish)

\ /

[] []

CS 460, Session 16-18


Backward chaining21
Backward chaining

  • Is more problematic and seldom used…

CS 460, Session 16-18


ad