Transcript First-Order Classical Deduction

Deduction
Jacques Robin
Ontologies
Reasoning
Components
Agents
Simulations
Outline
 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
 Classical First-Order Logic (CFOL)
 Syntax
 Full CFOL
 Implicative Normal Form CFOL
(INFCFOL)
 Horn CFOL (HCFOL)
 Semantics
 First-order interpretations and models
 Reasoning
 Lifting propositional reasoning to firstorder reasoning
 INFCFOL reasoning:

First-order resolution
An ontology of logics and engines
 Properties of logics
 Commitments, complexity
 Properties of inference engines
 Soundness, completeness, complexity
Full Classical Propositional Logic (FCPL):
syntax
Syntax
FCPLBinaryConnective
FCPLUnaryConnective
Connective: enum{, , , }
Connective: enum{}
FCPLConnective
Functor
(a  (b  ((c  d)  a)  b))
Arg
FCPLFormula
1..2
ConstantSymbol
CPL Normal Forms
Implicative Normal Form (INF)
INFCPLFormula
Functor = 
*
INFCPLClause
Functor = 
Premise
Conclusion
INFCLPLHS
Functor = 
INFCLPRHS
*
*
ConstantSymbol
Functor = 
Conjunctive Normal Form (CNF)
CNFCPLFormula
Functor = 
CNFCPLClause
*
*
Literal
Functor = 
NegativeLiteral
Functor = 
ConstantSymbol
Semantic equivalence:
abcd
 (a  b)  c  d
 a  b  c  d
Horn CPL
Implicative Normal Form (INF)
INFCPLFormula
*
Functor = 
Premise
INFCPLClause
INFCLPLHS
Functor = 
*
Conclusion
Functor = 
ConstantSymbol
IntegrityConstraint
context IntegrityConstraint inv IC: Conclusion.ConstantSymbol = false
a  b  c  false
DefiniteClause
context DefiniteClause inv DC: Conclusion.ConstantSymbol <> false
abcd
context Fact inv Fact: Premise -> size() = 1 and Premise -> ConstantSymbol = true
Fact
true  d
Conjunctive Normal Form (CNF)
CNFCPLFormula
*
Functor = 
CNFCPLClause
Functor = 
IntegrityConstraint
DefiniteClause
Fact
*
Literal
NegativeLiteral
ConstantSymbol
Functor = 
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
a  b  c  d
d
FCPL semantics:
Cognitive and Herbrand Interpretations
FCPLBinaryConnective
FCPLUnaryConnective
Connective: enum{, , , }
Connective: enum{}
• csm1(pitIn12) = there is a pit in (1,2)
• csm2(pitIn12) = John is King of England
Entered as input to
inference engine by
knowledge engineer
Arg
FCPLFormula
Syntax
FCPLConnective
Functor
• 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
ConstantSymbol
1..2
FormulaValuation
ConstantValuation
FormulaMapping
FCLPHerbrandInterpretation
FCLPCognitiveInterpretation
ConstantMapping
CompoundDomainProperty
AtomicDomainProperty
Defined from
Arg.AtomicDomainProperty.TruthValue
and FCPL truth table
Known by knowledge
engineer
TruthValue
Value: enum{true,false}
Derived by the knowledge engineer:
CompoundDomainProperty.TruthValue = FCPLFormula.TruthValue
Semantics
Convention
defined by
knowledge
engineer
FCLPHerbrandModel
Entailment 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)
Valid
formulas
Satisfiable
formulas
Unsatisfiable
formulas
 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: ff´is satisfiable
 f |= f’ iff: ff´is unsatisfiable (since ff´  (ff´)  (ff´)
Cognitive 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 Agent
Given B as axiom, formula f is a theorem of L?
i.e., B |=L f ?
Sensors
Ask
Environment
Inference
Engine:
Theorem
Prover
for Logic L
Tell
Retract
Knowledge
Base B:
Domain Model
in Logic L
Actuators
Relies on:
• Mh(f)  Mh(f´) ? (model checking)
• ff´is satisfiable ? (boolean CSP search)
• ff´is unsatisfiable ? (refutation proof)
 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
Model 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,
12
P?
22
V
11
P?
A, B
21
P?
31
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
FCLP 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 ponens
R15: 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 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 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 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 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 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 CSP
backtracking 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,?,?,?,?]
false
V = [0,0,?]
C = [1,1,?,1,0]
V = [0,1,?]
C = [1,0,?,1,1]
false
false
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
 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 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
Direct x indirect
use of search for agent reasoning
Domain Specific
Agent Decision Problem
Search Model:
• State data structure
• Successor function
• Goal function
• Heuristic function
Agent
Decision
Problem
Reasoning
Component
Developer
Agent
Application
Developer
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
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 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 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 KBi
 Add their respective conclusions to KBi+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: example
Propositional forward chaining: example
Propositional forward chaining: example
Propositional forward chaining: example
Propositional forward chaining: example
Propositional forward chaining: example
Propositional forward chaining: example
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 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:
example
Goal
Stack
Alternative
Stack
Q

Propositional backward chaining:
example
*
Goal
Stack
Alternative
Stack
P

Propositional backward chaining:
example
*
Goal
Stack
Alternative
Stack
L
M

Propositional backward chaining:
example
*
*
Goal
Stack
Alternative
Stack
A
P
M
A
B
Propositional backward chaining:
example
*
*
*
*
Goal
Stack
Alternative
Stack
P
M
A
B
Propositional backward chaining:
example
*
*
*
*
Goal
Stack
Alternative
Stack
A
B
M

Propositional backward chaining:
example
*
*
*
*
*
*
Goal
Stack
Alternative
Stack
M

Propositional backward chaining:
example
*
*
*
*
*
*
Goal
Stack
Alternative
Stack
B
L

Propositional backward chaining:
example
*
*
*
*
*
*
*
Goal
Stack
Alternative
Stack


Propositional backward chaining:
example
*
*
*
*
*
*
*
Goal
Stack
Alternative
Stack


Propositional backward chaining:
example
*
*
*
*
*
*
*
Goal
Stack
Alternative
Stack


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)
Full Classical First-Order Logic
(FCFOL): syntax
Syntax
Arg
Functor
FCLUnaryConnective
FCLConnective
FCFOLFormula
1..2
Connective: enum{}
FCLBinaryConnective
*
QuantifierExpression
Connective: enum{, , , }
Quantifier: enum{,}
Arg
FCFOLAtomicFormula
1..*
FCFOLTerm
Arg
Functor
PredicateSymbol
Arg
1..*
1..*
FCFOLNonFunctionalTerm
FCFOLFunctionalTerm
Functor
FOLVariable
ConstantSymbol
X,Y (p(f(X),Y)  q(g(a,b)))  (U,V Z ((X = a)  r(Z))  (U = h(V,Z))))
FunctionSymbol
FCFOL Normal Forms
Implicative Normal Form (INF)
INFCFOLFormula
Functor = 
*
INFCFOLClause
Premisse
INFCLPLHS
Functor = 
*
Functor = 
Conclusion
INFCLPRHS
Functor = 
Arg
FCFOLAtomicFormula
1..*
FCFOLTerm
Arg
1..*
Functor
PredicateSymbol
*
*
FCFOLNonFunctionalTerm
FOLVariable
CNFCFOLFormula
Functor = 
*
CNFCFOLClause
Functor = 
NegativeLiteral
Functor = 
Conjunctive Normal Form (CNF)
*
Literal
ConstantSymbol
FCFOLFunctionalTerm
Functor
FunctionSymbol
Horn CFOL (HCFOL)
Implicative Normal Form (INF)
INFCFOLFormula
*
Functor = 
Premisse
INFCFOLClause
DefiniteClause
Functor = 
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
Fact
FCFOLAtomicFormula
Conjunctive Normal Form (CNF)
CNFCFOLFormula
*
Functor = 
CNFCFOLClause
Functor = 
IntegrityConstraint
DefiniteClause
Fact
*
Conclusion
Functor = 
IntegrityConstraint
INFCFOLLHS
*
Literal
NegativeLiteral
Functor = 
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))
FCFOL semantics:
cognitive interpretations
Syntax
Arg
FCFOLFormula
FCFOLAtomicFormula
Arg
1..*
FCFOLTerm
1..2
Arg
1..*
FCFOLNonFunctionalTerm
FCFOLFunctionalTerm
FOLVariable
FunctionSymbol
PredicateSymbol
ConstantSymbol
FCFOLNonGroundTerm
FCFOLGroundTerm
EntitySet
ComplexRelation
ComplexEntityProperty
*
SimpleRelation
*
SimpleEntityProperty
TruthValue
Value: enum{true,false}
Semantics
RelationName
EntityName
*
*
EntityPropertyName
PredicateMapping
ConstantMapping
* Entity
FunctionMapping
FCFOL semantics:
cognitive interpretations
Syntax
Arg
FCFOLFormula
FCFOLAtomicFormula
Arg
1..*
FCFOLTerm
1..2
Arg
1..*
FCFOLNonFunctionalTerm
FormulaMapping
FCFOLFunctionalTerm
FCFOLNonGroundTerm
PredicateSymbol
FOLVariable
ConstantSymbol
FunctionSymbol
FCFOLGroundTerm
EntitySet
ComplexRelation
ComplexEntityProperty
*
SimpleRelation
*
SimpleEntityProperty
TruthValue
TruthMapping
RelationName
EntityName
*
* Entity
*
EntityPropertyName
AtomMapping
NounGroundTermMapping
GroundTermMapping
Value: enum{true,false}
Semantics
FCFOL semantics:
cognitive interpretations
FCFOLFormula
semantics
FCFOLCognitiveInterpretation
TruthMapping
FormulaMapping
AtomMapping
NounGroundTermMapping
GroundTermMapping
PredicateMapping
FunctionMapping
ConstantMapping
FCFOL semantics:
Herbrand interpretations
 Herbrand universe Uh of FCFOL formula k:
 Set of all terms built from constant and function symbols appearing in k
 Uh(k) = {t = f(t1,...,tn) | f  functions(k), ti  constants(k)  Uh(k)}
 ex: k = {parent(joe,broOf(dan))  parent(broOf(dan),pat) 
(A,D anc(A,D)  (parent(A,D)  (P anc(A,P)  parent(P,D))))}
Uh(k) = {joe,dan,pat,broOf(joe),broOf(dan),broOf(pat),
broOf(broOf(joe), broOf(broOf(dan), broOf(broOf(pat), ...}
 Herbrand base Bh of FCFOL formula k:
 Set of all atomic formulas built from predicate symbols appearing in k
and Herbrand universe elements as arguments
 Bh = {a = p(t1,...,tn) | p  predicates(k), ti  Uh(k)}
 ex: Bh = {parent(joe,joe), parent(joe,dan),...,
parent(broOf(pat),broOf(pat)),...,
anc(joe,joe), anc(joe,dan),...,
anc(broOf(pat),broOf(pat)},...}
FCFOL semantics:
Herbrand interpretations
 Herbrand interpretation Ih of FCFOL formula k:
 Truth valuation of Herbrand base
 Ih(k): Bh(k)  {true,false}
 ex: {parent(joe,joe) = false, ...parent(joe,dan) = true, ...
parent(broOf(pat),broOf(pat))= false, ...
anc(joe,joe) = true, ..., anc(joe,dan) = true}
 Herbrand model Mh of FCFOL formula k:
 Interpretation Ih(k) in which k is true
 ex, Mh(k) = {parent(joe,broOf(dan)) = true,
parent(broOf(dan),pat) = true,
anc(joe,brofOf(dan)) = true, anc(joe,pat) = true,
all others members of Bh(k) = false }
FCFOL semantics:
Herbrand interpretations
Syntax
Arg
FCFOLFormula
Arg
FCFOLAtomicFormula
1..*
FCFOLTerm
1..2
Arg
1..*
FCFOLNonFunctionalTerm
FCFOLFunctionalTerm
FOLVariable
FunctionSymbol
PredicateSymbol
Herbrand
semantics
ConstantSymbol
FCFOLNonGroundTerm
FCFOLGroundTerm
1..*
HerbrandBase
HerbrandInterpretation
HerbrandUniverse
AtomValuation
TruthValue
HerbrandModel
Value: enum{true,false}
Semantics
Reasoning in CFOL
 Key difference between CFOL and CPL?
 Quantified variables which extend expressive power of CPL
 Ground terms do not extend expressive power of CPL
 Alone, they are merely syntactic sugar
 i.e, clearer for the knowledge engineer but equivalent to constant symbols for
an inference engine
 ex, anc(joe,broOf(dan))  ancJoeBroOfDan,
loc(agent,step(3),coord(2,2))  locAgent3_2_2
 How to reason in CFOL?
 Reuse CPL reasoning approaches, principles and engines!
 Fully (formulas propositionalization)
 transforms CFOL formulas into CPL formulas as preprocessing step
 Partially (inference method generalization)
 lift CPL reasoning engines with new, variable handling component (unification)
 all CPL approaches free of exhaustive truth value enumeration can be lifted to
CFOL
Propositionalization
 Variable substitution function Subst(,k):
 Given a set  of pairs variable/constant,
 Subst(,k) = formula obtained from k by substituting its variables with
their associated constants in 
 Subst({X/a,Y/b}, X,Y,Z p(X,Y)  q(Y,Z))  (Z p(a,b)  q(b,Z))
 Substitutes CFOL formula k by conjunction of ground formulas
ground(k) generated as follows:
 For each universally quantified variable X in k and each v  Uh(k)
 Add Subst({X/v},k) to the conjunction
 For each existentially quantified variable Y in k
 Add Subst({Y/s},k) to the conjunction where s is a new Skolem ground term,
i.e. s  Uh(k)
 Skolem term to eliminate existentially quantified variable Y in scope of outer
universal quantifier Q must be function of the variables quantified by Q
 ex, Y X,Z p(X,Y,Z) becomes X,Z p(X,a,Z))
but X,Z Y p(X,Y,Z) becomes X,Z p(X,f(X,Z),Z)
Propositionalization
 Get prop(k) from ground(k) by turning each ground atomic formula into an equivalent
constant symbol through concatenation of its predicate, function and constant symbol
 Example:
 k = parent(joe,broOf(dan))  parent(broOf(dan),pat) 
(A,D anc(A,D)  (parent(A,D)  (P anc(A,P)  parent(P,D))))
 ground(k) = parent(joe,broOf(dan))  parent(broOf(dan),pat) 
(anc(joe,joe)  (parent(joe,joe)  (anc(joe,s1(joe,joe) 
parent(s1(joe,joe),joe))) 
(anc(joe,broOf(dan))  (parent(joe,broOf(dan)) 
(anc(joe,s2(joe,broOf(dan))) 
parent(s2(joe,broOf(dan)),joe)))  ...
...
(anc(pat,pat)  (parent(pat,pat)  (anc(pat,sn(pat,pat)) 
parent(sn(pat,pat),pat))))
 prop(k) = parentJoeBroOfDan  parentBroOfDanPat 
(ancJoeJoe  (parentJoeJoe  (ancJoeS1JoeJoe 
parentS1JoeJoeJoe))) 
(ancJoeBroOfDan  (parentJoeBroOfDan 
(ancJoeS2JoeBroOfDan 
parentS2JoeBroOfDanJoe  ...
...
(ancPatPat  (parentPatPat  (ancPatSnPatPat  parentSnPatPatPat)))
Propositionalization
 k |=CFOL k’ iff prop(k) |=CPL prop(k’)
 Fixed-depth Herbrand base: Uh(k,d) = {f  Uh(k) | depth(f) = d}
 Fixed-depth propositionalization:
prop(k,d) = {c1  ...  cn | ci built only from elements in Uh(k,d)}
 Thm de Herbrand:
 prop(k) |=CPL prop(k’)  d, prop(k,d) |=CPL prop(k’,d)
 For infinite prop(k) prove prop(k) |=CPL prop(k’) iteratively:




try proving prop(k,0) |=CPL prop(k’,0),
then prop(k,1) |=CPL prop(k’,1),
...
until prop(k,d) |=CPL prop(k’,d)
First-Order Term Unification
p
p
X/b
p
p
p
X/b
fail
a
X
Y
p
a
b
p
X
Y
p
X
a
X/f(c,Z)
Y/a
f
c
a
Y/a
Z
b
a
p
a
a
Failure by Occur-Check
X
Y
p
a
X
X/a
X/f(c,d)
p
Y/a
f
c
fail
b
p
Z
X/p(a,X)
X
X
p
f
c
X
Z
a
Z/d
c
X/p(a,X)
X
Guarantees termination
f
d
p
a
p
a
p
Lifted inference rules
 Bi-direction CPL rules trivially lifted as valid CFOL rules by
substituting CPL formulas inside them by CFOL formulas
 Lifted modus ponens:
 Subst(,p1), ..., Subst(,pn), (p1  ...  pn  c) |= Subst(,c)
 Lifted resolution:
l1  ...  li  ... lk, m1  ...  mj ... mk, Subst(,li) = Subst(,mj)
|= Subst(, l1  ...  li-1  li-1... lk  m1  ...  mj-1  mj-1... mk)
 CFFOL inference methods (theorem provers):
 Multiple lifted inference rule application
 Repeated application of lifted resolution and factoring
 CHFOL inference methods (logic programming):
 First-order forward chaining through lifted modus ponens
 First-order backward chaining through lifted linear unit resolution
guided by negated query as set of support
 Common edge over propositionalization: focus on relevant
substitutions
FCFOL theorem proving by repeated
lifted resolution and factoring: example
Deduction with equality
 Axiomatization:
 Include domain independent sub-formulas defining equality in the KB
 (X X = X)  (X,Y X = Y  Y = X)  (X,Y,Z (X = Y  Y = Z)  X = Z) 
(X,Y X = Y  (f1(X) = f1(Y)  ...  fn(X) = fn(Y)) 
(X,Y,U,V (X= Y  U = V)  f1(X,U) = f1(Y,V)  ...  fn(X,U) = fn(Y,V)) 
...
(X,Y X = Y  (p1(X)  p1(Y)  ...  pm(X)  pm(Y)) 
(X,Y,U,V (X= Y  U = V)  p1(X,U)  p1(Y,V)  ...  pm(X,U)  pm(Y,V)) 
...
 New inference rule (parademodulation):
 l1  ...  lk  x = y, m1  ...  mn(...,z,...)
|= Subst(unif(x,z), l1  ...  lk  m1  ...  mn(...,y,...))
 ex, p(a,X)  X = Y  p(a,z) |= p(a,z)  p(a,z)
 Extend unification to check for equality (equational unification):
 ex, if a = b + c, then p(X,f(a)) unifies with p(b,f(X+c)) with {X/b}
Characteristics of logics and knowledge
representation languages
 Commitments:
 ontological: meta-conceptual elements to model agent’s environment
 epistemological: meta-conceptual elements to model agent’s beliefs
 Hypothesis and assumptions:
 Unique name or equality theory
 open-world or closed-world
 Monotonicity: if KB |= f, then KB  g |= f
 Semantic compositionality:
 semantics(a1 c1 a2 c2 ... cn-1 an) = f(semantics(a1), ... ,semantics(an)
 ex, propositional logic truth tables define functions to compute
semantics of a formula from semantics of its parts
 Modularity
 semantics(ai) independent from its context in larger formulas
ex, semantics(a1) independent of semantics(a2), ... , semantics(an)
 in contrast to natural language
Characteristics of logics and knowledge
representation languages
 Expressive power:
 theoretical (in terms of language and grammar theory)
 practical: concisely, directly, intuitively, flexibly, etc.
 Inference efficiency:
 theoretical limits
 practical limits due to availability of implemented inference engines
 Acquisition efficiency:
 easy to formulate and maintain by human experts
 possible to learn automatically from data (are machine learning engines
available?)
Characteristics of inference engines
 Engine inference: f |-E g, if engine E infers g from f
 Engine E sound for logic L:
 f |-E g only if f |=L g
 Engine E fully complete for logic L:
 if f |=L g, then f |-E g
 if f |L g, then (f  g) |-E false
 Engine E refutation-complete for logic L:
 if f |=L g, then f |-E g
 but if f |L g, then either (f  g) |-E false or inference never
terminates (equivalent to halting problem)
 Engine inference complexity: exponential, polynomial, linear,
logarithmic in KB size
Some theoretical results about logics
and inference methods
 Results about logic:
 Satisfiability of full classical propositional logic formula is decidable but
exponential
 Entailment between two full classical first-order logic formulas is semidecidable
 Entailment between two full classical high-order logic formulas is
undecidable
 Results about inference methods:
Truth-table model checking, multiple inference rule application
resolution-factoring application and DPLL are sound and fully complete
for full classical propositional logic
WalkSAT sound but fully incomplete for full classical propositional logic
Forward-chaining and backward chaining sound, fully complete and worstcase linear for Horn classical propositional logic
Lifted resolution-factoring sound, refutation complete and worst case
exponential for full classical first-order logic