Download presentation
Presentation is loading. Please wait.
Published byDarren Shelton Modified over 8 years ago
1
Ontologies Reasoning Components Agents Simulations Reasoning with Classical Propositional Logic Jacques Robin
2
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 INFCPL Reasoning Resolution and factoring DPLL WalkSat HCPL Reasoning Forward chaining Backward chaining
3
Full Classical Propositional Logic (FCPL): syntax FCPLFormula Syntax FCPLUnaryConnective Connective: enum{ } FCPLBinaryConnective Connective: enum{ , , , } FCPLConnective Functor ConstantSymbol Arg 1..2 (a (b (( c d) a) b))
4
CPL 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 * * * **
5
Horn CLP 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 = LiteralConstantSymbol * * * * 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
6
FCPL semantics: cognitive interpretation FCPLFormulaConstantSymbol FCPLConnective FCPLUnaryConnective Connective: enum{ } FCPLBinaryConnective Connective: enum{ , , , } TruthValue Value: enum{true,false} FCLPCognitiveInterpretation Syntax Semantics Arg Functor 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
7
FCPL semantics: Herbrand interpretation FCPLFormulaConstantSymbol FCPLConnective FCPLUnaryConnective Connective: enum{ } FCPLBinaryConnective Connective: enum{ , , , } TruthValue Value: enum{true,false} FCLPHerbrandInterpretation Syntax Semantics Arg Functor ConstantValuation FormulaValuation 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,...}
8
FCPL semantics FCPLFormulaConstantSymbol FCPLConnective CompoundDomainProperty FCPLUnaryConnective Connective: enum{ } FCPLBinaryConnective Connective: enum{ , , , } AtomicDomainProperty TruthValue Value: enum{true,false} FCLPCognitiveInterpretation FCLPHerbrandInterpretation Syntax Semantics Arg Functor ConstantValuationFormulaValuation FCLPHerbrandModel FormulaMapping ConstantMapping 1..2 (a (b (( c d) a) b))
9
Entailment and models Entailment |=: f |= f’ iff: H i, H i (f) = true H i (f’) = true Logical equivalence : f f’ iff f |= f’ and f’ |= f Herbrand model: An Herbrand interpretation H i 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 H i of the constant symbols that compose f f valid (or tautology) iff true in all H i (f), ex, a a f satisfiable iff true in at least one H i (f) f unsatisfiable (or contradiction) iff false in all H i (f), ex, a a Valid formulas Satisfiable formulas Unsatisfiable formulas
10
Logic-Based Agent Ask Tell Retract Environment Actuators Knowledge Base B: Domain Model in Logic L Inference Engine: Theorem Prover 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
11
Truth-table based model checking To answer: Ask( ) Enumerate all H i s from domain proposition alphabet Use truth-table to compute M h (KB) and M h ( ) If M h (KB) M h ( ), then answer yes, else answer no Example: KB = pit11 breeze11 pit12 breeze12 1 = pit21 2 = pit22
12
FCLP inference rules Bi-directional (logical equivalences) R 1 : f g g f R 2 : f g g f R 3 : (f g) h f (g h) R 4 : (f g) h f (g h) R 5 : f f R 6 : f g g f R 7 : f g f g R 8 : f g (f g) (g f) R 9 : (f g) f g R 10 : (f g) f g R 11 : f (g h) (f g) (f h) R 12 : f (g h) (f g) (f h) R 13 : f f f %factoring Directed (logical entailments) R 14 : f g, f |= g %modus ponens R 15 : f g, g |= f %modus tollens R 16 : f g |= f %and-elimination R 17 : l 1 ... l i ... l k, m 1 ... m j-1 l i m j-1... m k |= l 1 ... l i-1 l i-1... l k m 1 ... m j-1 m j-1... m k %resolution
13
Multiple inference rule application Idea: KB |= f ? KB 0 = KB Apply inference rule: KB i |= g Update KB i+1 = KB i g Iterate until f KB k or until f KB n and KB n+1 = KB n Transforms proving KB |= f into search problem At each step: Which inference rule to apply? To which sub-formula of f? Example proof: KB 0 = P 1,1 (B 1,1 P 1,2 P 2,1 ) (B 2,1 P 1,1 P 2,2 P 3,1 ) B 1,1 B 2,1 Query: (P 1,2 P 2,1 ) Cognitive interpretation: B X,Y : agent felt breeze in coordinate (X,Y) P X,Y : agent knows there is a pit in coordinate (X,Y) Apply R 8 to B 1,1 P 1,2 P 2,1 KB 1 = KB 0 (B 1,1 (P 1,2 P 2,1 )) ((P 1,2 P 2,1 ) B 1,1 ) Apply R 6 to last sub-formula KB 2 = KB 1 ( B 1,1 (P 1,2 P 2,1 )) Apply R 14 to B 1,1 and last sub-formula KB 3 = KB 2 (P 1,2 P 2,1 )
14
Resolution 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:
15
Resolution 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 KB 0, or (b) an ancestor of g in the proof tree Input resolution: Specialization of linear resolution excluding (b) case Generates spine-looking proofs trees
16
FCPL theorem proving as boolean CSP exhaustive global backtracking search 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 L i (i th literal in f) Apply truth table definitions to propagate constraints in which L i appears (clauses of f involving L) If propagation violates one constraint, backtrack on L i If propagation satisfies all constraints: iterate on L i+1 if L i was last literal in f, fail, KB Query satisfiable, and thus KB | Query
17
FCPL theorem proving as boolean CSP backtracking search: example Variables = {B 1,1, P 1,2, P 2,1 } Constraints: { B 1,1, P 1,2 B 1,1, P 2,1 B 1,1, B 1,1 P 1,2 P 2,1, P 1,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]
18
DPLL 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 L i = true, propagate C j = true C j | L i C j (avoiding truth-table look-ups) Prune sub-tree below any node where C j | C j = false Clause learning
19
Satisfiability of formula as boolean CSP 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
20
Direct x indirect use of search for agent reasoning Agent Decision Problem Domain Specific Agent Decision Problem Search Model: State data structure Successor function Goal function Heuristic function Domain Specific Knowledge Base Model: Logic formulas true d f g h c... Domain Independent Inference Engine Search Model State data structure Successor function Goal function Heuristic function Domain Independent Search Algorithm Agent Application Developer Reasoning Component Developer
21
Horn 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 p 1 and... and p n then c, with logical semantics p 1 ... p n 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 KB 1 = p q c d has no logical equivalent in HCPL in terms of alphabet {p,q,c,d} However KB 2 = (p q notd c) (p q notc d) (c notc false) (d notd false) is an HCPL formula logically equivalent to KB 1
22
Propositional 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 KB k = KB k-1 KB k = {f | KB 0 |= f}, i.e., all logical conclusions of KB 0 If f KB k, then KB 0 |= f, otherwise, KB 0 | f Naturally data-driven reasoning: Guided by fact (axioms) in KB 0 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
23
Propositional forward chaining: example
30
Propositional backward chaining Repeated application of resolution using: Unit input resolution strategy with negated query as initial set of support At each step i: Search KB 0 for clause of the form p 1 ... p n g to resolve with clause g popped from the goal stack If there are several ones, pick one, push p 1 ... p n 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
31
Propositional backward chaining: example Goal Stack Q Alternative Stack
32
Propositional backward chaining: example Goal Stack P Alternative Stack
33
Propositional backward chaining: example Goal Stack L M Alternative Stack
34
Propositional backward chaining: example Goal Stack A P M Alternative Stack A B
35
Propositional backward chaining: example Goal Stack P M Alternative Stack A B
36
Propositional backward chaining: example Goal Stack A B M Alternative Stack
37
Propositional backward chaining: example Goal Stack M Alternative Stack
38
Propositional backward chaining: example Goal Stack B L Alternative Stack
39
Propositional backward chaining: example Goal Stack Alternative Stack
40
Propositional backward chaining: example Goal Stack Alternative Stack
41
Propositional backward chaining: example Goal Stack Alternative Stack
42
Limitations 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)
Similar presentations
© 2024 SlidePlayer.com Inc.
All rights reserved.