OntologiesReasoningComponentsAgentsSimulations

Propositional Classical DeductionPropositional Classical Deduction

Jacques Robin

OutlineOutline

Classical Propositional Logic (CPL) Syntax Full CPL Implicative Normal Form CPL (INFCPL) Horn CPL (HCPL)

CPL Semantics Cognitive and Herbrand interpretations, models

CPL Reasoning FCPL Reasoning

Truth-tabel based model checking Multiple inference rules

INFCPL Reasoning Resolution and factoring DPLL WalkSat

HCPL Reasoning Forward chaining Backward chaining

Full Classical Propositional Logic Full Classical Propositional Logic (FCPL): syntax(FCPL): syntax

FCPLFormula

Syntax

(a (b ((c d) a) b))

FCPLConnectiveFunctor

ConstantSymbolArg1..2

FCPLUnaryConnective

Connective: enum{}

FCPLBinaryConnective

Connective: enum{, , , }

CPL Normal FormsCPL Normal Forms

INFCPLFormula

Functor =

Implicative Normal Form (INF)

Conjunctive Normal Form (CNF)

CNFCPLFormula

Functor =

Semantic equivalence: a b c d (a b) c d a b c d

INFCPLClause

Functor = *

INFCLPLHS

Functor = Premise

INFCLPRHS

Functor = Conclusion

* ConstantSymbol

*

CNFCPLClause

Functor = *

Literal*

NegativeLiteral

Functor =

ConstantSymbol

Horn CPLHorn CPL

ConstantSymbol

INFCPLFormula

Functor =

INFCPLClause

Functor =

INFCLPLHS

Functor = Premise

Conclusion

Implicative Normal Form (INF)

Conjunctive Normal Form (CNF)

CNFCPLFormula

Functor =

CNFCPLClause

Functor =

NegativeLiteral

Functor =

Literal ConstantSymbol

*

*

* *

DefiniteClause context DefiniteClause inv DC: Literal.oclIsKindOf(ConstantSymbol)->size() = 1

DefiniteClause context DefiniteClause inv DC: Conclusion.ConstantSymbol <> false a b c d

a b c d

IntegrityConstraint context IntegrityConstraint inv IC: Literal->forAll(oclIsKindOf(NegativeLiteral)) a b c

Fact context Fact inv Fact: Literal->forAll(oclIsKindOf(ConstantSymbol)) d

Fact context Fact inv Fact: Premise -> size() = 1 and Premise -> ConstantSymbol = true true d

IntegrityConstraint context IntegrityConstraint inv IC: Conclusion.ConstantSymbol = false a b c false

FCLPCognitiveInterpretation

Conventiondefined by knowledge engineer

FCPL semantics:FCPL semantics:CognitiveCognitive and and HerbrandHerbrand

InterpretationsInterpretations

FCPLFormulaFCPLConnective

FCPLUnaryConnective

Connective: enum{}

FCPLBinaryConnective

Connective: enum{, , , }

FCLPHerbrandInterpretation

Syntax

ArgFunctor

ConstantValuation

1..2

FCLPHerbrandModel

ConstantSymbol

AtomicDomainProperty

ConstantMapping

• csm1(pitIn12) = there is a pit in (1,2)• csm2(pitIn12) = John is King of England

CompoundDomainProperty

FormulaMapping

• fm1(pitIn12 pitIn11) = there is a pit in (1,2) and no pit in (1,1)• fm1(pitIn12 pitIn11) = John is Kind of England and is not King of France

Semantics

TruthValue

Value: enum{true,false}

Known by knowledge engineer

Entered as input to inference engine by knowledge engineer

FormulaValuation

Defined from Arg.AtomicDomainProperty.TruthValu

eand FCPL truth table

Derived by the knowledge engineer:CompoundDomainProperty.TruthValue = FCPLFormula.TruthValue

Entailment and modelsEntailment and models

Ic(f): cognitive interpretation of formula f Ih(f): Herbrand interpretation of formula f Herbrand model:

A Herbrand interpretation Ih(f) of formula f is a Herbrand model Mh(f) iff f is true in Mh(f)

Entailment |=: f |= f’ iff: Ic, (f true in Ic(f) f´true in Ic(f’))

Logical equivalence : f f’ iff f |= f’ and f’ |= f

f valid (or tautology) iff true in all Ih(f), ex, a a f satisfiable iff true in at least one Ih(f) f unsatisfiable (or contradiction) iff false in all Ih(f), ex, a a Theorems:

f |= f’ iff: Mh(f) Mh(f´) f |= f’ iff: ff´is satisfiable f |= f iff: ff´is unsatisfiable (since ff´ (ff´) (ff´)

Valid formulas

Satisfiable formulas

Unsatisfiable formulas

Cognitive x Herbrand SemanticsCognitive x Herbrand Semantics

Cognitive semantics: Knowledge engineer and application domain dependent symbolic

convention Truth values associated to constant symbols and formulas indirectly

via knowledge engineer beliefs about atomic and compound properties of the real world domain being represented

Allows deductively deriving new properties n1, … , ni about entities of this domain from other, given properties g1, …, gj

Herbrand semantics: Knowledge engineer and application domain independent

syntactical convention Truth values associated directly to constant symbols and formulas Relies on connective truth-table to deduct truth value of formula f

from those of its constant symbols Allows testing inference engine reasoning soundness and

completeness independently of any specific knowledge base or real world referential

Logic-Based AgentLogic-Based Agent

Ask

Tell

Retract

En

viro

nm

en

t

Actuators

KnowledgeBase B:

Domain Modelin Logic L

InferenceEngine:

TheoremProver

for Logic L

Given B as axiom, formula f is a theorem of L?i.e., B |=L f ?

Sensors

Strenghts: Reuse results and insights about correct reasoning that matured over 23

centuries Semantics (meaning) of a knowledge base can be represented formally as

syntax, a key step towards automating reasoning

Relies on:• Mh(f) Mh(f´) ? (model checking)• ff´is satisfiable ? (boolean CSP search)• ff´is unsatisfiable ? (refutation proof)

Model Checking: Truth-Table EnumerationModel Checking: Truth-Table Enumeration

kb = persistentKb volatileKb = pf1 pf2 pf3 vf1 vf2 = p11 (b11 p12 p21) (b21 p22 p31 p11) b11 b21

q1 = pit12, q2 = pit22, q3 = pit31 kb |= q1, kb |≠ q2, kb |≠ q3,

b11 b21 p11 p12 p21 p22 p31 pf1 pf2 pf3 vf1 vf2 kb q1 q2 q3

f f f f f f f t t t t f f t t t

f f f f f f t t t f t f f t t f

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

f t t f f f f t t f t t f t t t

f t f f f f t t t t t t t t t f

f t f f f t f t t t t t t t f t

f t f f f t t t t t t t t t f f

f t f f t f f t f f t t f t t t

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

t t t t t t t f t t f t f f f f

11 21 31

2212

V A, B

P?

P?

P?

FCLP inference rulesFCLP inference rules

Bi-directional (logical equivalences)

R1: f g g f

R2: f g g f

R3: (f g) h f (g h)

R4: (f g) h f (g h)

R5: f f

R6: f g g f

R7: f g f g

R8: f g (f g) (g f)

R9: (f g) f g

R10: (f g) f g

R11: f (g h) (f g) (f h)

R12: f (g h) (f g) (f h)

R13: f f f %factoring

Directed (logical entailments)R14: f g, f |= g %modus

ponensR15: f g, g |= f %modus tollens

R16: f g |= f %and-elimination

R17: l1 ... li ... lk, m1 ... mj-1 li mj+1... mk

|= l1 ... li-1 li+1... lk m1 ... mj-1 mj+1... mk

%resolution

Multiple inference rule applicationMultiple inference rule application

Idea: KB |= f ? KB0 = KB Apply inference rule: KBi |= g Update KBi+1 = KBi g Iterate until f KBk

or until f KBn and KBn+1 = KBn

Transforms proving KB |= f into search problem

At each step: Which inference rule to apply? To which sub-formula of f?

Example proof: KB0 = P1,1 (B1,1 P1,2 P2,1)

(B2,1 P1,1 P2,2 P3,1) B1,1 B2,1

Query: (P1,2 P2,1) Cognitive interpretation:

BX,Y: agent felt breeze in coordinate (X,Y)

PX,Y: agent knows there is a pit in coordinate (X,Y)

Apply R8 to B1,1 P1,2 P2,1

KB1 = KB0 (B1,1 (P1,2 P2,1)) ((P1,2 P2,1) B1,1)

Apply R6 to last sub-formula KB2 = KB1 (B1,1 (P1,2 P2,1))

Apply R14 to B1,1 and last sub-formula KB3 = KB2 (P1,2 P2,1)

Resolution and factoringResolution and factoring

Repeated application of only two inference rules: resolution and factoring

More efficient than using multiple inference rules search space with far smaller branching factor

Refutation proof: Derive false from KB Query

Requires both in normal form (conjunctive or implicative) Example proof in conjunctive normal form:

Resolution strategiesResolution strategies

Search heuristics for resolution-based theorem proving Two heuristic classes:

Choice of clause pair to resolve inside current KB Choice of literals to resolve inside chosen clause pair

Unit preference: Prefer pairs with one unit clause (i.e., literals) Rationale: generates smaller clauses, eliminates much literal choice in pair Unit resolution: turn preference into requirement

Set of support: Define small subset of initial clauses as initial “set of support” At each step:

Only consider clause pairs with one member from current set of support Add step result to set of support

Efficiency depend on cleverness of initial set of support Common domain-independent initial set of support: negated query

Beyond efficiency, results in easier to understand, goal-directed proofs Linear resolution:

At each step only consider pairs (f,g) where f is either: (a) in KB0, or (b) an ancestor of g in the proof tree

Input resolution: Specialization of linear resolution excluding (b) case Generates spine-looking proofs trees

FCPL theorem proving as boolean FCPL theorem proving as boolean CSP exhaustive global backtracking CSP exhaustive global backtracking

searchsearch Put f = KB Query in conjunctive normal form Try to prove it unsatisfiable Consider each literal in f as a boolean variable Consider each clause in f as a constraint on these variables Solve the underlying boolean CSP problem by using:

Exhaustive global backtracking search of all complete variable assignments showing none satisfies all constraint in f

Initial state: empty assignment of pre-ordered variables Search operator:

Tentative assignment of next yet unassigned variable Li (ith literal in f) Apply truth table definitions to propagate constraints in which Li appears

(clauses of f involving L) If propagation violates one constraint, backtrack on Li

If propagation satisfies all constraints: iterate on Li+1

if Li was last literal in f, fail, KB Query satisfiable, and thus KB | Query

FCPL theorem proving as boolean FCPL theorem proving as boolean CSP CSP

backtracking search: examplebacktracking search: example Variables = {B1,1 , P1,2, P2,1}

Constraints: {B1,1 , P1,2 B1,1 , P2,1 B1,1, B1,1 P1,2 P2,1 , P1,2}

V = [?,?,?]C = [?,?,?,?,?]

V = [0,?,?]C = [1,?,?,1,?]

V = [1,?,?]C = [0,?,?,?,?]

V = [0,0,?]C = [1,1,?,1,0]

V = [0,1,?]C = [1,0,?,1,1]

false false

false

DPLL algorithmDPLL algorithm

General purpose CSP backtracking search very inefficient for proving large CFPL theorems

Davis, Putnam, Logemann & Loveland algorithm (DPPL): Specialization of CSP backtracking search Exploits specificity of CFPL theorem proving recast as CSP search To apply search completeness preserving heuristics

Concepts: Pure symbol S: yet unassigned variable positive in all clauses or negated in

all clauses Unit clause C: clause with all but one literal already assigned to false

Heuristics: Pure symbol heuristic: assign pure symbols first Unit propagation:

Assign unit clause literals first Recursively generate new ones

Early termination heuristic: After assigning Li = true, propagate Cj = true Cj | Li Cj (avoiding truth-table look-

ups) Prune sub-tree below any node where Cj | Cj = false

Clause caching

Satisfiability of formula as boolean Satisfiability of formula as boolean CSP heuristic local stochastic searchCSP heuristic local stochastic search

DPLL is not restricted to proving entailment by proving unsatisfiability It can also prove satisfiability of a FCPL formula Many problems in computer science and AI can be recast as a

satisfiability problem Heuristic local stochastic boolean CSP search more space-scalable

than DPLL for satisfiability However since it is not exhaustive search, it cannot prove

unsatisfiability (and thus entailment), only strongly suspect it WalkSAT

Initial state: random assignment of pre-ordered variables Search operator:

Pick a yet unsatisfied clause and one literal in it Flip the literal assignment

At each step, randomly chose between to picking strategies: Pick literal which flip results in steepest decrease in number of yet unsatisfied

clauses Random pick

Direct x indirect Direct x indirect use of search for agent reasoninguse of search for agent reasoning

AgentDecisionProblem

Domain SpecificAgent Decision ProblemSearch Model:• State data structure• Successor function• Goal function• Heuristic function

Domain SpecificKnowledge Base Model:• Logic formulas

true df g h c

...

Domain Independent Inference Engine Search Model• State data structure• Successor function• Goal function• Heuristic function

Domain Independe

ntSearch

AlgorithmAgent

Application

Developer

Reasoning

Component

Developer

Horn CPL reasoningHorn CPL reasoning

Practical limitations of FCPL reasoning: For experts in most application domain (medicine, law, business, design,

troubleshooting): Non-intuitiveness of FCPL formulas for knowledge acquisition Non-intuitiveness of proofs generated by FCPL algorithms for knowledge validation

Theoretical limitation of FCPL reasoning: exponential in the size of the KB

Syntactic limitation to Horn clauses overcome both limitations: KB becomes base of simple rules

If p1 and ... and pn then c, with logical semantics p1 ... pn c Two algorithms are available, rule forward chaining and rule backward

chaining, that are: Intuitive Sound and complete for HCPL Linear in the size of the KB

For most application domains, loss of expressiveness can be overcome by addition of new symbols and clauses: ex, FCPL KB1 = p q c d has no logical equivalent in HCPL

in terms of alphabet {p,q,c,d} However KB2 = (p q notd c) (p q notc d) (c notc false)

(d notd false) is an HCPL formula logically equivalent to KB1

Propositional forward chainingPropositional forward chaining

Repeated application of modus ponens until reaching a fixed point

At each step i: Fire all rules (i.e., Horn clauses with at least one positive and one

negative literal) with all premises already in KB i

Add their respective conclusions to KB i+1

Fixed point k reached when KBk = KBk-1

KBk = {f | KB0 |= f}, i.e., all logical conclusions of KB0

If f KBk, then KB0 |= f, otherwise, KB0 | f Naturally data-driven reasoning:

Guided by fact (axioms) in KB0

Allows intuitive, direct implementation of reactive agents

Generally inefficient for: Inefficient for specific entailment query Cumbersome for deliberative agent implementations

Builds and-or proof graph bottom-up

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional forward chaining: Propositional forward chaining: exampleexample

Propositional backward chainingPropositional backward chaining

Repeated application of resolution using: Unit input resolution strategy with negated query as initial set of support

At each step i: Search KB0 for clause of the form p1 ... pn g to resolve with clause g

popped from the goal stack

If there are several ones, pick one, push p1 ... pn to goal stack, and push other ones to alternative stack for consideration upon backtracking

If there are none, backtrack (i.e., pop alternative stack) Terminates:

Successfully when goal stack is empty As failure when goal stack is non empty but alternative stack is

Naturally goal-driven reasoning: Guided by goal (theorem to prove)

Allows intuitive, direct implementation of deliberative agents Generally:

Inefficient for deriving all logical conclusions from KB Cumbersome implementation of reactive agents

Builds and-or proof graph top-down

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

Q

AlternativeStack

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

P

AlternativeStack

*

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

LM

AlternativeStack

*

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

APM

AlternativeStack

AB

**

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

PM

AlternativeStack

AB

**

*

*

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

ABM

AlternativeStack

**

*

*

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

M

AlternativeStack

**

****

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

BL

AlternativeStack

**

****

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

AlternativeStack

**

**

*

**

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

AlternativeStack

**

**

*

**

Propositional backward chaining: Propositional backward chaining: exampleexample

Goal Stack

AlternativeStack

**

**

*

**

Limitations of propositional logicLimitations of propositional logic

Ontological: Cannot represent knowledge intentionally No concise representation of generic relations (generic in terms of

categories, space, time, etc.) ex, no way to concisely formalize the Wumpus world rule:

“at any step during the exploration, the agent perceiving a stench makes him knows that there is a Wumpus in a location adjacent to his”

Propositional logic: Requires conjunction of 100,000 equivalences to represent this rule for an

exploration of at most 1000 steps of a cavern size 10x10 (stench1_1_1 wumpus1_1_2 wumpus1_2_1) ...

... (stench1000_1_1 wumpus100_1_2 wumpus1000_2_1) ...... (stench1_10_10 wumpus1_9_10 wumpus1_10_9) ... ... (stench1000_10_10 wumpus100_9_10 wumpus1000_9_10)

Epistemological: Agent always completely confident of its positive or negative beliefs No explicit representation of ignorance (missing knowledge) Only way to represent uncertainty is disjunction Once held, agent belief cannot be questioned by new evidence (ex, from

sensors)