- 34 Views
- Uploaded on
- Presentation posted in: General

Automated Reasoning Systems

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

Automated Reasoning Systems

For first order Predicate Logic

- Is F a logical consequence of T ?

- Given is a knowledge base in predicate logic: T

- is a set of formulae in first order logic
- formally also called: a “Theory’’

- Given is also an additional first order formula: F

- Notation: T |=F (T implies F)

- correctness -- completeness -- efficiency

- There CANNOT EXIST AN ALGORITHMthat decides whether T|=F, for any theory T and any formula F.

- There exists a reasoning technique, such that for any theory T and formula F, such that T|=F, the reasoning technique provesT |= F.

- Theorem Church ‘36:

- BUT: semi-decidable !
- Completeness Theorem of Goedel ‘31:

- SO: if F follows from T, then we find a proof, else it is possible that the procedure doesn’t terminate.

- The theorems of Church and Goedel are contradicting: We can try to prove F and ~F in parallel, and according to Goedel’s theorem one of these must succeed after a finite time.

- Wrong !
- Let: T ={smart(Kelly)} en F =strong(Kelly)
- Although strong(Kelly) ~strong(Kelly) is always true, we have:
- neither: {smart(Kelly)} |= strong(Kelly)
- nor: {smart(Kelly)} |= ~strong(Kelly)

- backward resolution

- First we sketch the most generally used approach for automated reasoning in first-order logic:

- The different technical componentswill only be explained in full detail in a second pass (outline (2)).

- ground Horn clause logic

- We study different subsets of predicate logic:

- Horn clause logic
- Clausal logic
- full predicate logic

- In each case we study semi-deciding procedures.
- Each extension requires the introduction of new techniques.

Backward Reasoning Resolution

… in a nutshell

- 0) The task: an example.
- 1) Proof by inconsistency.
- 2) Conversion to clausal form.
- 3) Unification.
- 4) The resolution step.
- 5) (Backward) resolution proofs.

T

p= parent

f= father

r= rich

q= old

z ~ q(z)

y p(f(y))

x p(x) q(x) r(x)

F

- In this world, is always true ?

u r(f(u))

- Are axioms: describe knowledge about some world.

- How to prove such theorems in general?

F

- Don’t prove F directly:

u r(f(u))

- NEW TASK:

~ u r(f(u))

z ~ q(z)

y p(f(y))

x p(x) q(x) r(x)

- is inconsistent.

- But add the negation of F to the axioms and prove that this extension is inconsistent.

- the 4 axioms are never true in 1 same interpretation.

- Each set of axioms can be transformed into a new set of formulae, that contains only formulae of the form:

xy…zp(…) q(…) …r(…) t(…) s(…) … u(…)

= Normalize the formulae to a (more simple) standard form.

- only left; only right
- no ~ ; no

which is inconsistentif and only ifthe original set was inconsistent.

Notice: “x y … z“can be dropped.

u false r(f(u))

z false q(z)

x q(x) r(x) p(x)

- ~ u r(f(u))

- z ~ q(z)

- y p(f(y))

: is already in clausal form: ( P P true)

- x p(x) q(x) r(x)

Ps: usually requires much more work!

- Ex.: p(f(A),y) p(x, g(x))

- Ex.: x must become: f(A)
- g(x) must become: g(f(A))
- y must become: g(f(A))

p(f(A), g(f(A)))

- Given 2 atomic formulae:

- find their most general common instance.

- Most general unifier (mgu) : x -> f(A)
- y -> g(f(A))

Modus tollens

Modus ponens

P Q

P

Q

P Q

~Q

~P

Q P

P true

Q true

Q P

false Q

false P

Resolution

P1 P2 … PnQ1 ... Qm

R1 … Rk P1 S1 … Sl

P2 … Pn R1 … RkQ1 ... Qm S1 … Sl

- Proposition logic:

p(x,f(A)) q(g(x))

r(z) p(B,z)

r(f(A)) q(g(B))

mgu(p(x,f(A)),p(B,z)) =

x-> B

z-> f(A)

- Predicate logic:
- Example:

= mgu applied tor(z) q(g(x))

Clauses on which resolution is performed

must not have any variables in common.

- select 2 of them, for which resolution is possible

AND inconsistency of the original set

AND that F was implied by T

- In order to prove a set of clauses inconsistent:

- apply resolution and add the result to the set
- if you obtain the clause false : STOP !

This means inconsistency of the last set

q(x) r(x) p(x)

false r(f(u))

x -> f(u)

q(f(u)) p(f(u))

false q(z)

z -> f(u)

false p(f(u))

p(f(y))

y -> u

false

So: inconsistent !

Ground Horn Logic

Modus ponens

Horn Logic

Unification

Clausal Logic

Resolution

Full Predicate Logic

Normalization

A deeper study:

- All formulae in T are of the form:

- x1 … xk A B1 B2 … Bn

- where A, B1, B2,…,Bn are atoms.
- An atom is a formula of the form p(t1,…,tm), with p a predicate symbol and t1,…,tm terms.
- Horn clause formulae are universally quantified over all variables that occur in them.
- B1,…,Bn are called body-atoms of the Horn clause; A is the head of the Horn clause.
- n may be 0: in this case we say that the Horn clause is a fact.

- In Horn clause logic, we limit ourselves to prove formulae F of the form:
- where B1, B2, …, Bn are again atoms.

x1 … xk B1 B2 … Bn

- All variables are existentially quantified !

- Bosmans is a showmaster (1)
- Showmasters are rich (2)
- Rich people have big houses (3)
- Big houses need a lot of maintenance (4)

- Goal: automatically deduce that Bosmans’ house needs a lot of maintenance.

- Bosmans is a showmaster (1)
- Showmasters are rich (2)
- Rich people have big houses (3)
- Big houses need a lot of maintenance (4)
- To prove:

showmaster(Bosmans)

p rich(p) showmaster(p)

p big(house(p)) rich(p)

p lot_maint(house(p)) big(house(p))

Lot_maint(house(Bosmans))

AR for ground Horn clause logic

Backward reasoning proof procedures based on generalized Modus Ponens

- So, for now: Horn clauses without variables:
- Example:

showmaster(Bosmans)

rich(Bosmans) showmaster(Bosmans)

big(house(Bosmans)) rich(Bosmans)

lot_maint(house(Bosmans)) big(house(Bosmans))

- Prove:

lot_maint(house(Bosman))

- 3 applications of modus ponens:

showm(Bos)

rich(Bos) showm(Bos)

rich(Bos)

big(house(Bos)) rich(Bos)

big(house(Bos))

lot_maint(house(Bos)) big(house(Bos))

lot_maint(house(Bos))

- gives the desired conclusion.

- Modus ponens is correct:

B

A B

For any interpretation making both B and A B true(= any model of {B , A B} )

A

A is also true in this interpretation (see truth tables)

- Problem: how to organize this into a procedure which is also complete(for ground Horn clauses)?

- Theorem:

Let T be a theory and F a formula.

T implies Fif and only if T {~F} is inconsistent.

- A theory T is inconsistent if it has NO model.

- Proof:

T implies F iff Each model of T makes F true

iff Each model of T makes ~F false

iffT {~F} has no model

iffT {~F} is inconsistent

- Prove that the theory:

showm(Bos)

belg(Bos)

european(Bos) belg(Bos)

rich(Bos) showm(Bos) european(Bos)

big(house(Bos)) rich(Bos)

lot_maint(house(Bos)) big(house(Bos))

~ lot_maint(house(Bos))

- is inconsistent.

- Problem: this is NOT a Horn clause theory !?

- We introduce a new predicate symbol:

false

- We agree that false has the truth value ‘false’ under every interpretation.
- Imagine that we defined false as : false p ~p for some predicate p

- In the Horn logic setting F has the form:

x1 … xm B1 B2 … Bn

- So what is the form of ~F?

- ~(x1 … xm B1 B2 … Bn)
- x1 … xm ~(B1 B2 … Bn)
- x1 … xm false ~(B1 B2 … Bn)
- x1 … xm false B1 B2 … Bn

A ~B A B

- Observe: ~F is again a Horn clause !!

- The extended theory (to be proven inconsistent) now is:

showm(Bos)

belg(Bos)

european(Bos) belg(Bos)

rich(Bos) showm(Bos) european(Bos)

big(house(Bos)) rich(Bos)

lot_maint(house(Bos)) big(house(Bos))

false lot_maint(house(Bos))

- a ground Horn clause theory !

A B1 B2 … Bi … Bn

Bi C1 C2 … Cm

A B1 B2 … C1 C2 … Cm … Bn

- Ordinary Modus ponens is the special case with:
- n = i = 1 and m =0

- Correctness: via truth tables

false lot_maint(house(Bos))

lot_maint(house(Bos)) big(house(Bos))

false big(house(Bos))

big(house(Bos)) rich(Bos)

- and so on ...

false big(house(Bos))

false rich(Bos)

- Convert F into a definite goal:

false B1 B2 … Bi … Bn

- until: is deduced.

false

we have proven inconsistency ofT {~F}

- Apply generalized modus ponens to the body-atoms Bi of the goal, using the Horn clauses of T

- Then: a false formula ia a consequence of T {~F}

Goal := false B1 B2 … Bn;

Repeat

Select someBiatom from the body of Goal

Select some clauseBi C1 C2 … CmfromT

ReplaceBiin the body of Goal byC1 C2 … Cm

UntilGoal = false or no more Selections possible

- On top of this you need to apply backtracking over the selected clauses and the selected body atoms.
- If the algorithm stops because it has tried all these alternatives: F was not implied!

Step 0: Goal :=false lot_maint(house(Bos))

select: lot_maint(house(Bos)) big(house(Bos))

Step 1: Goal :=false big(house(Bos))

select: big(house(Bos)) rich(Bos)

Step 2: Goal :=false rich(Bos)

select: rich(Bos) showm(Bos) european(Bos)

Step 3: Goal :=false showm(Bos) european(Bos)

select:showm(Bos)

Step 4: Goal :=false european(Bos)

select:european(Bos) belg(Bos)

Step 5: Goal :=false belg(Bos)

select: belg(Bos)

Step 6: Goal :=false

p q r

q t

q s

r n

r o

s

o

n

- Prove: p
- Observe: non-determinism on both atom selection and on clause selection !
- we only illustrate the clause selection here

false q r

false t r

false s r

false r

false n

false o

false

false

false p

p q r

q t

q s

r n

r o

s

o

n

- The proof is goal directed towards the theorem.
- no exploration of irrelevant rules

- Different search methodescan be used to traverse this search tree.
- Atom-selection may influence efficiency too:
- ex.: by detecting a failing branch sooner

- but has no impact on whether or not we find a solution
(in case there are only finitely many ground Horn clauses)

(2)

(1)

false p

false

(1)

false p

(1)

……

- Example:

false p

p p(1)

p (2)

- Possible derivations:

false p

- Is only complete if the search tree is traversed using a complete search method.

- Example:

showm(Bos) showm_Bos

big(house(Bos)) big_house_Bos

- Is a subset of propositional logic.

- In general, more expressive logics are needed.
- Essence: with variables, one formula may be equivalent to a very large number of propositional formulae.