reasoning with classical propositional logic
DESCRIPTION
Reasoning with Classical Propositional Logic. Jacques Robin. Outline. Syntax Full CPL Implicative Normal Form CPL (INFCPL) Horn CPL (HCPL) Semantics Cognitive and Herbrand interpretations, models Reasoning FCPL Reasoning Truth-tabel based model checking Multiple inference rules - PowerPoint PPT PresentationTRANSCRIPT
OntologiesReasoningComponentsAgentsSimulations
Reasoning with Classical Reasoning with Classical Propositional LogicPropositional Logic
Jacques Robin
OutlineOutline
Syntax Full CPL Implicative Normal Form CPL (INFCPL) Horn CPL (HCPL)
Semantics Cognitive and Herbrand interpretations, models
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
FCPLUnaryConnective
Connective: enum{}
FCPLBinaryConnective
Connective: enum{, , , }
FCPLConnectiveFunctor
ConstantSymbolArg1..2
(a (b ((c d) a) b))
CPL Normal FormsCPL Normal Forms
ConstantSymbol
INFCPLFormula
Functor =
INFCPLClause
Functor =
INFCLPLHS
Functor =
INFCLPRHS
Functor =
Premisse
Conclusion
Implicative Normal Form (INF)
Conjunctive Normal Form (CNF)
CNFCPLFormula
Functor =
CNFCPLClause
Functor =
NegativeLiteral
Functor =
Literal
ConstantSymbol
Semantic equivalence: a b c d (a b) c d a b c d
**
*
* *
Horn CLPHorn CLP
ConstantSymbolINFCPLFormula
Functor =
INFCPLClause
Functor =
INFCLPLHS
Functor =
INFCLPRHS
Functor =
Premisse
Conclusion
Implicative Normal Form (INF)
Conjunctive Normal Form (CNF)
CNFCPLFormula
Functor =
CNFCPLClause
Functor =
NegativeLiteral
Functor =
Literal ConstantSymbol
*
*
* *
DefiniteClause
IntegrityConstraint
Fact
DefiniteClause
IntegrityConstraint
Fact
context IntegrityConstraint inv IC: Conclusion.ConstantSymbol = false
context DefiniteClause inv DC: Conclusion.ConstantSymbol false
context Fact inv Fact: Premisse -> size() = 1 and Premisse -> ConstantSymbol = true
context IntegrityConstraint inv IC: Literal->forAll(oclIsKindOf(NegativeLiteral))
context DefiniteClause inv DC: Literal.oclIsKindOf(ConstantSymbol)->size() = 1
context Fact inv Fact: Literal->forAll(oclIsKindOf(ConstantSymbol))
a b c false
a b c d
true d
a b c
a b c d
d
FCPL semantics: cognitive FCPL semantics: cognitive interpretationinterpretation
FCPLFormula ConstantSymbolFCPLConnective
FCPLUnaryConnective
Connective: enum{}
FCPLBinaryConnective
Connective: enum{, , , }
TruthValue
Value: enum{true,false}
FCLPCognitiveInterpretation
Syntax
Semantics
ArgFunctor
CompoundDomainProperty
FormulaMapping
AtomicDomainProperty
ConstantMapping
1..2
(a (b ((c d) a) b))
csm1(pitIn12) = agent knows there is a pit in coordinates (1,2)csm2(pitIn12) = John is the King of England
fm1(pitIn12 pitIn11) = agent knows there is a pit in coordinates (1,2) and no pit in coordinates (1,1) fm1(pitIn12 pitIn11) = John is the Kind of England and John is not the King of France
FCPL semantics: FCPL semantics: Herbrand interpretationHerbrand interpretation
FCPLFormula ConstantSymbolFCPLConnective
FCPLUnaryConnective
Connective: enum{}
FCPLBinaryConnective
Connective: enum{, , , }
TruthValue
Value: enum{true,false}
FCLPHerbrandInterpretation
Syntax
Semantics
ArgFunctor
ConstantValuationFormulaValuation
FCLPHerbrandModel
1..2
(a (b ((c d) a) b))
{cv1(pitIn12) = true, cv1(pitIn11) = true, ...}{cv2(pitIn12) = true, cv2(pitIn11) = false, ...}
{fv1(pitIn12 pitIn11) = true, fv1(pitIn12 pitIn11) = true, ...}{fv2(pitIn12 pitIn11) = true, fv2(pitIn12 pitIn11) = false, ...}
FCPL semanticsFCPL semantics
FCPLFormula ConstantSymbolFCPLConnective
CompoundDomainProperty
FCPLUnaryConnective
Connective: enum{}
FCPLBinaryConnective
Connective: enum{, , , }
AtomicDomainProperty TruthValue
Value: enum{true,false}
FCLPCognitiveInterpretation
FCLPHerbrandInterpretation
Syntax
Semantics
ArgFunctor
ConstantValuationFormulaValuation
FCLPHerbrandModel
FormulaMapping
ConstantMapping
1..2
(a (b ((c d) a) b))
Entailment and modelsEntailment and models
Entailment |=: f |= f’ iff: Hi, Hi(f) = true Hi(f’) = true
Logical equivalence : f f’ iff f |= f’ and f’ |= f
Herbrand model: An Herbrand interpretation Hi is a (Herbrand) model of formula f iff
its truth value corresponds to the application of the truth-table definition of the FCPL connectives to the truth value in Hi of the constant symbols that compose f
f valid (or tautology) iff true in all Hi(f), ex, a a
f satisfiable iff true in at least one Hi(f)
f unsatisfiable (or contradiction) iff false in all Hi(f), ex, a a
Valid formulas
Satisfiable formulas
Unsatisfiable formulas
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?B |=L f ?B f is valid in L? (Boolean CSP search proof)B f is unsatisfiable in L? (Refutation proof)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
Truth-table based model checkingTruth-table based model checking
To answer: Ask() Enumerate all His from domain proposition alphabet
Use truth-table to compute Mh(KB) and Mh()
If Mh(KB) Mh(), then answer yes, else answer no
Example: KB = pit11 breeze11 pit12 breeze12 1 = pit21
2 = pit22
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,?,?,?,?]
V = [1,?,?]C = [0,?,?,?,?]
V = [0,0,?]C = [1,0,?,?,0]
V = [0,1,?]C = [1,0,?,?,1]
V = [1,0,?]C = [0,1,?,?,0]
V = [1,1,?]C = [0,0,?,?,1]
V = [1,1,1]C = [0,0,0,0,1]
V = [1,1,0]C = [0,0,1,0,1]
V = [1,0,1]C = [0,1,0,0,0]
V = [1,0,0]C = [0,1,1,0,0]
V = [0,1,1]C = [1,0,0,1,1]
V = [0,1,0]C = [1,0,0,0,1]
V = [0,0,1]C = [1,0,0,0,0]
V = [0,0,0]C = [1,0,0,0,0]
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 Exploiting 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 learning
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 on goal stack, and push other ones alternative stack to consider 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)