ontologies reasoning components agents simulations deduction jacques robin

OntologiesReasoningComponentsAgentsSimulations

DeductionDeduction

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

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

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



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


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 King 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 Ih(f)

Entailment |=: f |= f’ iff: Ih (f true in Ih(f) f´true in Ih(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(B) Mh(f) ? (model checking)• Bf is satisfiable ? (boolean CSP search)• Bf 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 = p12, q2 = p22, q3 = p31 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 f 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,1,1,?,?]

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


Goal Stack

P

AlternativeStack

*


Goal Stack

LM

AlternativeStack

*


Goal Stack

APM

AlternativeStack

AB

**


Goal Stack

PM

AlternativeStack

AB

**

*

*


Goal Stack

ABM

AlternativeStack

**

*

*


Goal Stack

M

AlternativeStack

**

****


Goal Stack

BL

AlternativeStack

**

****


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 wumpus1000_1_2 wumpus1000_2_1) ...... (stench1_10_10 wumpus1_9_10 wumpus1_10_9) ... ... (stench1000_10_10 wumpus1000_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 Full Classical First-Order Logic (FCFOL): syntax(FCFOL): syntax

Syntax

FCLUnaryConnective

Connective: enum{}

FCLBinaryConnective


FCLConnective FCFOLFormulaFunctor

QuantifierExpression

Quantifier: enum{,}

*

Arg1..2

X,Y (p(f(X),Y) q(g(a,b))) (U,V Z ((X = a) r(Z)) (U = h(V,Z))))

FCFOLAtomicFormula

PredicateSymbol

FCFOLTerm

Arg1..*

FCFOLFunctionalTermFCFOLNonFunctionalTerm

Arg 1..*

FunctionSymbolConstantSymbolFOLVariable

Functor

Functor

1..*

FCFOL Normal FormsFCFOL Normal Forms


CNFCFOLFormula

Functor =

CNFCFOLClause

Functor =

NegativeLiteral

Functor =

Literal*

INFCFOLFormula

Functor =

INFCFOLClause

Functor =

INFCLPLHS

Functor =

INFCLPRHS

Functor =

Premisse

Conclusion


*

FCFOLAtomicFormula

PredicateSymbol

FCFOLTerm

Arg1..*


Arg 1..*


Functor

Functor

*

*

*

*

Horn CFOL (HCFOL)Horn CFOL (HCFOL)

INFCFOLFormula

Functor =

INFCFOLClause

Functor =

INFCFOLLHS

Functor = Premisse

Conclusion



CNFCFOLFormula

Functor =

CNFCFOLClause

Functor =

NegativeLiteral

Functor =

Literal

*

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

FCFOLAtomicFormula

* *

*

FCFOLNonGroundTerm

FCFOL semantics: FCFOL semantics: cognitive interpretationscognitive interpretations

Syntax

FCFOLFormulaArg1..2

FCFOLAtomicFormula

PredicateSymbol

FCFOLTerm

Arg1..*


Arg1..*

FunctionSymbolConstantSymbolFOLVariable FCFOLGroundTerm

SimpleEntityProperty

SimpleRelation

*

EntitySet *

ComplexEntityProperty

ComplexRelation *

*

EntityName

ConstantMapping FunctionMapping

EntityPropertyName

RelationName

PredicateMapping

Entity

*

Semantics

TruthValue


EntitySet

FCFOLNonGroundTerm


Syntax

FCFOLFormulaArg1..2

FCFOLAtomicFormula

PredicateSymbol

FCFOLTerm

Arg1..*


Arg1..*


EntityPropertyName

RelationName EntityName

SimpleEntityProperty

SimpleRelation

Entity

FCFOLGroundTerm

ComplexEntityProperty

ComplexRelation

*

*

*

*

TruthValue


NounGroundTermMapping GroundTermMappingAtomMapping

*

Semantics

FormulaMapping

TruthMapping


FCFOLFormula

NounGroundTermMapping

AtomMapping

GroundTermMapping

FormulaMapping

TruthMapping

ConstantMapping

PredicateMapping

FunctionMapping

FCFOLCognitiveInterpretation

semantics

FCFOL semantics: FCFOL semantics: Herbrand interpretationsHerbrand 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)},...}


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

FCFOLNonGroundTerm


Syntax

FCFOLFormulaArg1..2

FCFOLAtomicFormula

PredicateSymbol

FCFOLTerm

Arg1..*


Arg1..*

FunctionSymbolConstantSymbolFOLVariable FCFOLGroundTerm

Semantics

HerbrandUniverse

HerbrandModel

TruthValue


AtomValuationHerbrandInterpretation

Herbrandsemantics

HerbrandBase

1..*

Reasoning in CFOLReasoning 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

PropositionalizationPropositionalization

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)


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


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 UnificationFirst-Order Term Unification

p

a X

p

Y b

p

a X

p

Y f

c Z

X/f(c,Z)

Y/a

p

a f

c Z

p

a b

X/b

Y/a

p

a X

p

X b

fail

X/b

X/a

p

a X

p

Y f

c Z

p

a f

c d

X/f(c,d)

Y/a

Z/d

p

a X

Xfail

X/p(a,X)

Failure by Occur-Check

p

a X

X X/p(a,X) p

a p

a pGuarantees termination

Lifted inference rulesLifted 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 FCFOL theorem proving by repeated lifted resolution and factoring: lifted resolution and factoring:

exampleexample

Deduction with equalityDeduction 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 t1 = t2, m1 ... mn(...,t3,...)

|= Subst(unif(t1, t2), l1 ... lk m1 ... mn(..., t2,...)) ex, p(f(X),a) f(X) = f(b) q(d,h(f(X)) |= p((f(b),a) q(d,h(f(b)))

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 Characteristics of logics and knowledge representation languagesknowledge 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 Characteristics of logics and knowledge representation languagesknowledge 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 enginesCharacteristics 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 Some theoretical results about logics and inference methodsand 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

semi-decidable 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 worst-case linear for Horn classical propositional logic

Lifted resolution-factoring sound, refutation complete and worst case exponential for full classical first-order logic

ontologies reasoning components agents simulations deduction jacques robin

Documents

f f iff f

h f iff f

h f of formula f

f fis satisfiable f

i h f f unsatisfiable

h f true

h f entailment

h f ftrue