Ontologies Reasoning Components Agents Simulations Introduction to Rule-Based Reasoning Jacques...

OntologiesReasoningComponentsAgentsSimulations

Introduction to Rule-Based Introduction to Rule-Based ReasoningReasoning

Jacques Robin

OutlineOutline

Rules as a knowledge representation formalism Common characteristics of rule-based systems Roadmap of rule-based languages Common advantages and limitations Example practical application of rules: declarative business rules

History of rule-based systems Production Systems Term Rewriting Systems Logic Programming and Prolog

Rules as a Rules as a Knowledge Representation Knowledge Representation

FormalismFormalism What is a rule? A statement that specifies that:

If a determined logical combination of conditions is satisfied, over the set of an agent’s percepts and/or facts in its Knowledge Base (KB) that represent the current, past and/or hypothetical future of its

environment model, its goals and/or its preferences, then a logico-temporal combination of actions can or must be

executed by the agent, directly on its environment (through actuators) or on the facts in

its KB. A KB agent such that the persistent part of its KB consists

entirely of such rules is called a rule-base agent; In such case, the inference engine used by the KB agent is an

interpreter or a compiler for a specific rule language.

Rule-Based AgentRule-Based Agent

Enviro

nm

ent

Sensors

Effectors

Rule Base:Rule Base:• Persistant intentional knowledge• Dependent on problem class, not instance• Declarative code

Ask

Fact Base:Fact Base:• Volatile knowledge• Dependent on problem instance• Data

Rule Engine:Rule Engine:• Problem class independent• Only dependent on rule language• Declarative code interpreter or compiler

Tell Retract

Ask

Rule Languages: Common Rule Languages: Common CharacteristicsCharacteristics

Syntax generally: Extends a host programming language and/or Restricts a formal logic and/or Uses a semi-natural language with

closed keyword set expressing logical connectives and actions classes, and an open keyword set to refer to the entities and relations appearing

in the agent’s fact base; Some systems provide 3 distinct syntax layers for different users

with automated tools to translate a rule across the various layers; Declarative semantics: generally based on some formal logic; Operational semantics:

Generally based on transition systems, automata or similar procedural formalisms;

Formalizes the essence of the rule interpreter algorithm.

Rule Languages: General AdvantagesRule Languages: General Advantages

Human experts in many domains (medicine, law, finance, marketing, administration, design, engineering, equipment maintenance, games, sports, etc.) find it intuitive and easy to formalize their knowledge as a rule base Facilitates knowledge acquisition

Rules can be easily paraphrased in semi-natural language syntax, friendlier to experts averse to computational languages Facilitates knowledge acquisition

Rule bases easy to formalize as logical formulas (conjunctions of equivalences and/or implications) Facilitates building rule engine that perform sound, logic-based inference

Each rule largely independent of others in the base (but to precisely what degree depends highly of the rule engine algorithm) Can thus be viewed as an encapsulated, declarative piece of knowledge; Facilitates life cycle evolution and composition of knowledge bases

Very sophisticated, mature rule base compilation techniques available Allows scalable inference in practice Some engines for simple rule languages can efficiently handle millions of rules

Rule Languages: General LimitationsRule Languages: General Limitations

Subtle interactions between rules hard to debug without: sophisticated rule explanation GUI detailed knowledge of the rule engine’s algorithm

Especially serious with: Object-oriented rule languages for combining rule-based deduction

or abduction with class-based inheritance; Probabilistic rule languages for combining logical and Bayesian

inference; But purely logical relational rule language do not naturally:

Embed within mainstream object-oriented modeling and programming languages

Represent inherently procedural, taxonomic and uncertain knowledge

Current research challenge: User-friendly reasoning engine for probabilistic object-oriented

rules

Business Rules Business Rules

Example of modern commercial application of rule-based knowledge representation

GUI Layer

Data Layer

Business LogicLayer

Classic 3-TierInformation System

Architecture

Imperative OOProgram

Imperative OOLanguageSQL API

Imperative OOLanguageGUI API

ClassicImperative OOImplementation

Rule-Based Implementation

Imperative OOHost Language

EmbeddedProduction

RuleEngine

Imperative OOLanguageSQL API

Imperative OOLanguageGUI API

ProductionRule Base

Generic ComponentReusable in Any

Application Domain

Easier to reflect frequent policy changes

than imperative code

Semi-Natural Language SyntaxSemi-Natural Language Syntaxfor Business Rulesfor Business Rules

Associate key word or key phrase to: Each domain model entity or relation name Each rule language syntactic construct Each host programming language construct used in rules

Substitute in place of these constructs and symbols the associated words or phrase

Example: “Is West Criminal?” in semi-natural language syntax: IF P is American AND P sells a W to N AND W is a weapon AND N is a nation AND N is hostile THEN P is a criminal

IF nono owns a W AND W is a missile THEN west sells W to nono

IF W is a missile THEN W is a weapon

IF N is an enemy of America THEN N is hostile

OO RuleLanguages

NeOPS

JEOPS

CLIPS

JESS

XML

Web MarkupLanguages

CLP(X)

Rule-BasedConstraintLanguages

Roadmap of Rule-Based LanguagesRoadmap of Rule-Based Languages

XSLT

OPS5

ProductionRules

ISO Prolog

Logic Programming

TransactionLogic

HiLogConcurrentProlog

CourteousRules

CCLP(X)

FrameLogic

Flora

OCLMOF

UML

CHORD

RuleML

ELAN

Maude

Otter

EProver

RewriteRules

SWSL

CHRV

CHR

QVT

Java

Smalltalk

C++

Pure OOLanguages

Rewrite Rules: Abstract SyntaxRewrite Rules: Abstract Syntax

RewriteRule Base

RewriteRule

* RHS plus(X,0) X

fib(suc(suc(N))) plus(fib(suc(N)),fib(N))

FunctionalTerm

Non-FunctionalTerm

GroundTerm

Non-GroundTerm

FunctionSymbol

ConstantSymbol

Variable

*args

{disjoint, complete} {disjoint, complete}

LHS

Term

Rewrite Rules: Operational Rewrite Rules: Operational SemanticsSemantics

: RewriteRuleBase

T : Term

Unify LHS of Rewrite Rule Baseagainst sub-terms of Term

: Unifying Set of Pairs:- Instantiated Rule- Instantiated Sub-term

[ Matching Pair Set Empty ]

[ Matching Pair Set Singleton ] : Pair

- Instantiated Rule R- Instantiated Sub-Term S

Pick onePair Set[ Else ]

Substitute Sub-Term S in Term T

by RHS of Rule R

Rewrite Rule Base Computation Rewrite Rule Base Computation ExampleExample

a) plus(X,0) X

b) plus(X,suc(Y)) suc(plus(X,Y))

c) fib(0) suc(0)

d) fib(suc(0)) suc(0)e) fib(suc(suc(N))

plus(fib(suc(N)),fib(N))

1. fib(suc(suc(suc(0)))) w/ rule e2. plus(fib(suc(suc(0))),fib(suc(0))) w/ rule d3. plus(fib(suc(suc(0))),suc(0)) w/ rule

b4. suc(plus(fib(suc(suc(0))),0)) w/ rule

a5. suc(fib(suc(suc(0)))) w/ rule e6. suc(plus(fib(suc(0)),fib(0))) w/ rule c7. suc(plus(fib(suc(0)),suc(0))) w/ rule

b8. suc(suc(plus(fib(suc(0)),0))) w/ rule

a9. suc(suc(fib(suc(0)))) w/ rule d10.suc(suc(suc(0)))

Conditional Rewrite Rules:Conditional Rewrite Rules:Abstract SyntaxAbstract Syntax

RewriteRule Base

RewriteRule

*

LHS

Term

RHS

Condition

Equation

*

2

X = 0 Y = 0 | X + Y 0

• Rule with matching LHS can only be fired if condition is also verified• Proving condition can be recursively done by rewriting it to true

Rewrite Rule Base Deduction Rewrite Rule Base Deduction Example:Example:

Is West Criminal?Is West Criminal?Rewrite Rule Base:a) criminal(P) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W)b) sells(west,nono,W) owns(nono,W) missile(W)c) hostile(N) enemy(N,america)d) weapon(W) missile(W)e) owns(nono,m1) missile(m1) american(west) nation(nono) enemy(nono,america) truef) A B B Ag) A A A

Term:criminal(P) american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) w/ rule aamerican(P) weapon(W) nation(N) hostile(N) owns(nono,W) missile(W) w/ rule bamerican(P) weapon(W) nation(N) enemy(N,america) owns(nono,W) missile(W) w/ rule camerican(P) missile(W) nation(N) enemy(N,america) owns(nono,W) missile(W) w/ rule damerican(P) missile(W) nation(N) enemy(N,america) owns(nono,W) w/ rule g ... w/ rule fowns(nono,W) missile(W) american(P) nation(N) enemy(N,america) w/ rule ftrue w/ rule e

Rewriting Systems: Practical Rewriting Systems: Practical ApplicationApplication

Theorem proving CASE:

Programming language formal semantics Program verification Compiler design and implementation Model transformation and automatic programming

Data integration Using XSLT an XML-based language to rewrite XML-based data and

documents Web server pages and web services (also using XSLT)

Production Rules: Abstract SyntaxProduction Rules: Abstract Syntax

ProductionRule Base

ProductionRule

*

Arithmetic Predicate Symbol

Right-Hand Side(RHS)

Action*

Arithmetic Constant Symbol

IF (p(X,a) OR p(X,b)) AND p(Y,Z) AND q(c) AND X <> Y AND X > 3.5THEN Z = X + 12 AND add{r(a,c,Z} AND delete{p(Y,Z)}

FactFactBase

*

Atom

And-Or Formula

Connective: enum{and,or}

Left-Hand Side(LHS)

2..*

ArithmeticCalculation

Fact Base Update

Operator: enum{add,delete}

PredicateSymbol

Non-GroundAtom

ConstantSymbol

VariableGroundAtom

Non-FunctionalTerm

argsFunctor

Production System ArchitectureProduction System Architecture

Fact Base ManagementComponent

Rule FiringPolicy

Component

Host LanguageAPI

Action ExecutionComponent

FactBase

RuleBase

Pattern MatchingComponent

CandidateRules

Production Rules: Operational Production Rules: Operational SemanticsSemantics

[Matching Instantiated Rule Set Empty]

Pick one Instantiated Rule to Fire [Else]

[Matching InstantiatedRule Set Singleton]

SelectedInstantiated

Rule

Execute in SequenceActions in RHS

of SelectedInstantiated Rule

Match LHSof Rule BaseagainstFact Base

RuleBase

FactBase

MatchingInstantiated

Rule Set

Conflict Resolution StrategiesConflict Resolution Strategies

Conflict resolution strategy: Heuristic to choose at each cycle which of the matching rule set to

fire Common strategies:

Follow writing order of rules in rule base Follow absolute priority level annotations associated with each rule

or rule class Follow relative priority level annotations associated with pairs of

rules or rule classes Prefer rules whose LHS match the most recently derived facts in

the fact base Prefer rules that have remained for the longest time unfired while

matching a fact Apply control meta-rules that declaratively specify arbitrarily

sophisticated strategies

Production Rule Base Example:Production Rule Base Example:Is West Criminal?Is West Criminal?

Production Rule Base:IF american(P) AND weapon(W) AND nation(N) AND hostile(N) AND sell(P,N,W) THEN add{criminal(P)}

IF owns(nono,W) AND missile(W) THEN add{sells(west,nono,W)

IF missile(W) THEN add{weapon(W)}

IF enemy(N,america) THEN add{hostile(N)}

Initial Fact Base:owns(nono,m1)missile(m1)american(west)nation(nono)enemy(nono,america)nation(america)

Production Rule Inference Example:Production Rule Inference Example:Is West Criminal?Is West Criminal?

criminal(P)

american(P) weapon(W) nation(N) hostile(N) sells(P,N,W)

criminal(west)?

missile(W) enemy(N,america) owns(nono,W)

missile(m1)american(west) nation(nono)

nation(america)

enermy(nono,america)owns(nono,m1)

sells(west,nono,W)


criminal(P)


criminal(west)?

missile(m1) enemy(nono,america) owns(nono,m1)


nation(america)

enermy(nono,america) owns(nono,m1)

sells(west,nono,W)


criminal(P)

american(P) weapon(m1) nation(N) hostile(N) sells(P,N,W)

criminal(west)?

missile(W) enemy(nono,america) owns(nono,W)


nation(america)


sells(west,nono,W)


criminal(P)

american(P) weapon(m1) nation(N) hostile(N) sells(P,N,W)

criminal(west)?



nation(america)


sells(west,nono,W)


criminal(P)

american(P) weapon(m1) nation(N) hostile(nono) sells(P,N,W)

criminal(west)?

missile(W) owns(nono,W)


nation(america)

enemy(nono,america) owns(nono,m1)

sells(west,nono,W)


criminal(P)


criminal(west)?

missile(m1) owns(nono,m1)


nation(america)

enemy(nono,america) owns(nono,m1)

sells(west,nono,W)


criminal(P)


criminal(west)?


nation(america)


sells(west,nono,m1)


criminal(P)

american(west) weapon(m1) nation(nono) hostile(nono) sells(west,nono,m1)

criminal(west)?


nation(america)


sells(west,nono,m1)


criminal(west)

weapon(m1) hostile(nono)

criminal(west)?


nation(america)


sells(west,nono,m1)


criminal(west)

weapon(m1) hostile(nono)

criminal(west)? yes


nation(america)


sells(west,nono,m1)

Properties of Production SystemsProperties of Production Systems

Confluence: From confluent rule base, same final fact base is derived

independently of rule firing order Makes values of queries made to the system independent of the

conflict resolution strategy

Termination: Terminating system does not enter in an infinite loop; Example of non-termination production rule base:

Initial fact base: p(0) Production rule base: IF p(X) THEN Y = X + 1 AND add{p(Y)}

Any production system which conflict resolution strategy does not prevent the same rule instance to be fired in two consecutive cycles is trivially non-terminating.

Production System Inference vs.Production System Inference vs.Lifted Forward ChainingLifted Forward Chaining

Production System Inference Sequential conjunction of actions in

rule RHS Non-monotonic reasoning due to

delete actions Matching only Datalog atoms (i.e.,

atoms which arguments are all non-functional terms)

Matching ground fact atoms against non-ground atoms in rule LHS And-Or atom

Neither sound nor complete inference engine

Lifted Forward Chaining Unique conclusion in Horn Clause

Monotonic reasoning

Unifying arbitrary first-order atoms, possibly functional

Unifying two arbitrary atoms, possibly both non-grounds

Sound and refutation-complete

Common characteristics: Data driven reasoning Requires conflict resolution strategy to choose:

Which of several matching rules to fire Which of several unifying clauses for next Modus Ponens inference step

Embedded Production System: Embedded Production System: Abstract SyntaxAbstract Syntax

HPL Operation

HPL GroundData Structure

HPL Data Structureargs

*HPL BooleanOperation

Right-Hand Side(RHS)

Action*Fact Base Update

Operator: enum{add,delete}

FactFactBase

*

ProductionRule Base

ProductionRule

*

Left-Hand Side(LHS)

And-Or Formula

Connective: enum{and,or}2..*

HPL BooleanOperator

HPLOperator

Generalized Production Rules: ECA Generalized Production Rules: ECA RulesRules

Event-Condition-Action rule: extension of production rule with triggering event external to addition of facts in fact base

Only the rule subset which event just occurred is matched against the fact base

Events thus partition the rule base into subsets, each one specifying a behavior in response to a given events

EventCondtion

ActionRule

EventLHS RHS

Agent’sPercept

HPL BooleanOperation

Production Rules vs. Rewriting RulesProduction Rules vs. Rewriting Rules

Production System Inference Fact base implicitly conjunctive Matching only Datalog atoms (i.e.,

atoms which arguments are all non-functional terms)

Matching ground fact atoms against non-ground atoms in rule LHS And-Or atom

Term Rewriting Reified logical connectives in term

provide full first-order expressivity Unifying arbitrary first-order atoms,

possibly functional

Unifying two arbitrary atoms, possibly both non-grounds

Common characteristics: Data driven reasoning Requires conflict resolution strategy to choose:

Which of several matching rules to fire Which of several rules with an LHS unifying with a sub-term

Non-monotonic reasoning due to: Fact deletion actions in RHS Retraction of substituted sub-term

Tricky confluence and termination issues

FormalLogic

Theory

IntelligentDatabases

FormalSoftware

Specification

AutomatedReasoning

DeclarativeProgramming

Logic Programming: Logic Programming: a Versatile Metaphora Versatile Metaphor

Logic Programming

Logic Programming: Key IdeasLogic Programming: Key Ideas

Logical Theory

Software Specification

Declarative Programming

Automated Reasoning

Intelligent Databases

Logical Formula

Abstract Specification

Declarative Program / Data Structure

Knowledge Base

Database

Theorem Prover

Specification Verifier

Interpreter / Compiler

Inference Engine

Query Processor

Theorem Proof

Specification Verification

Program Execution Inference Query Execution

Theorem Proving Strategy

Verification Algorithm

Single, Fixed, Problem-Independent Control Structure

Inference Search Algorithm

Query Processing Algorithm

Logic programming visionLogic programming vision

Single language with logic-based declarative semanticslogic-based declarative semantics that is: A Turing-complete, general purpose programmingprogramming language A versatile, expressive knowledge representationknowledge representation language to support

deduction and other reasoning services useful for intelligent agents (abduction, induction, constraint solving, belief revision, belief update, inheritance, planning)

Data definition, query and update Data definition, query and update language for databases with built-in inference capabilities

"One tool solves all" philosophy: Any computation = resolution + unification + search Programming = declaring logical axioms (Horn clauses) Running the program = query about theorems provable from declared

axioms Algorithmic design entirely avoided (single, built-in control structure) Same language for formal specification (modeling) and

implementation Same language for model checking and code testing

PrologProlog

First and still most widely used logic programming language Falls short to fulfill the vision in many respect:

Many imperative constructs with no logical declarative semantics No commercial deductive database available

Most other logic programming languages both: Extend Prolog Fulfill better one aspect of the logic programming vision

In the 80s, huge Japanese project tried to entirely rebuild all of computing from ground up using logic programming as hardware basis

Definite Logic Program+connective =

Definite Query+connective =

Definite Clause+connective =

clauses

Pure Prolog: abstract syntaxPure Prolog: abstract syntax

Pure Prolog Atom

arg

headbody

0..1 *

*arg Pure Prolog Term*

c11 (...,Xk

1,...) :- p11(...,Xi

1,...), ... , pm1(...,Xj

1,...)....c1

n (...,Xkn,...) :- p1

n(...,Xin,...), ... , pm

n(...,Xjn,...).

parent(al,jim) parent(jim,joe) anc(A,D) parent(A,D) anc(A,D) parent(A,P) anc(P,D)

Numerical Symbol

Function-Free TermFunctional Term

Variable

functor

*

Symbol

predicate

Full PrologFull Prolog

Full Prolog Atom

Full Prolog Query+connective =

Full Prologl Clause+connective =

head

body

0..1

Full Prolog Program+connective =

*

Semantics of full Prolog:• Cannot be purely logic-based• Must integrate algorithmic ones

User-Defined Symbol

Built-in Symbol

Built-inLogical Symbol

Built-in Imperative Symbol

Meta-ProgrammingPredicate Symbol

NumericalSymbol

I/O Predicate Symbol

Program UpdatePredicate Symbol

Search CustomizationPredicate Symbol

Full Prolog Term

Function-Free TermFunctional Term

Variable

Symbol

functor

arg

predicate

* Prolog LiteralProlog Literal

+connective = naf

arg

*

Pure Prolog program Pure Prolog program declarative formal semantics declarative formal semantics

Declarative, denotational, intentional: Clark’s transformation to CFOL formula First-order formula semantically equivalent to program

Declarative, denotational, extentional, model-theoretic: Least Herbrand Model Intersection of all Herbrand Models Conjunction of all ground formulas that are deductive

consequences of program

CFOL x Prolog Semantic AssumptionsCFOL x Prolog Semantic Assumptions

Classical First-Order Predicate Logic: No Unique Name Assumption

(UNA): two distinct symbols can potentially be paraphrases to denote the same domain entity

Open-World Assumption (OWA): If KB |≠ Q but KB |≠ Q , the truth value of Q is considered unknown

Ex: KB: true core(ai) true core(se) core(C) offered(C,T) true offered(mda,fall)

Q: true offered(mda,spring) OWA necessary for monotonic,

deductively sound reasoning: If KB |= T then A, KB A |= T

Logic Programming: UNA: two distinct symbols

necessarily denote two distinct domain entities

Closed-World Assumption (CWA): If KB |≠ Q but KB |≠ Q , the truth value of Q is considered false

Ex: ?- offered(mda,spring) fail

CWA is a logically unsound form of negatively abductive reasoning

CWA makes reasoning inherently non-monotonic as one can have:KB |= T but KB A |≠ Tif the proof KB |= T included steps assuming A false by CWA

Motivation: intuitive, representational economy, consistent w/ databases

Clark’s completion semanticsClark’s completion semantics

Transform Pure Prolog Program P into semantically equivalent CFOL formula comp(P) Same answer query set derived

from P (abductively) than from FP (deductively)

Example P:core(se). core(ai). offered(mda,fall). offered(C,T) :- core(C).

?- offered(mda,spring)

no

?-

Naive semantics naive(P):C,T true core(ai) true core(se) true offered(mda,fall) core(C) offered(C,T) naive(P) |≠ offered(mda,spring)

Clark’s completion semantics comp(P):C,T,C1,T1

(core(C1) (C1=ai C1=se)) (offered(C1,T1) (C1=mda T1=fall) (C,T (C1=C T1=T core(C)))) (ai=se) (ai=mda) (ai=fall) (se=fall) (se=mda) (mda=fall)Fp |= offered(mda,spring)

Clark’s transformationClark’s transformation

Axiomatizes closed-world and unique name assumptions in CFOL Starts from naive Horn formula semantics of pure Prolog program Partitions program in clause sets, each one defining one predicate (i.e.,

group together clauses with same predicate c(t1, ..., tn) as conclusion) Replaces each such set by a logical equivalence One side of this equivalence contains c(X1, ..., Xn) where X1, ..., Xn are

fresh universally quantified variables The other side contains a disjunction of conjunctions, one for each

original clause Each conjunction is either of the form:

Xi = ci ... Xj = ci, if the original clause is a ground fact

Yi ... Yj Xi = Yi ... Xj = Yj p1( ...) ... pn( ... ) if the original clause is a rule with body p1( ...) ... pn( ... ) containing variables Yi ... Yj

Joins all resulting equivalences in a conjunction Adds conjunction of the form (ci = cj) for all possible pairs (ci,cj) of

constant symbols in pure Prolog program

SLD ResolutionSLD Resolution SLD resolution (Linear resolution with Selection function for Definite

logic programs): Joint use of goal-driven set of support and input resolution heuristics Always pick last proven theorem clause with next untried axiom clause Always questions last pick even if unrelated to failure that triggered

backtracking A form of goal-driven backward chaining of Horn clauses seen as deductive

rules Prolog uses special case of SLD resolution where:

Axiom clauses tried in top to bottom program writing order Atoms to unify in the two picked clauses:

Conclusion of selected axiom clause Next untried premise of last proven theorem clause in left to right program writing

order (goal) Unification without occur-check Generates proof tree in top-down, depth-first manner Failure triggers systematic, chronological backtracking:

Try next alternative for last selection even if clearly unrelated to failure Reprocess from scratch new occurrences of sub-goals previously proven true or

false

Simple, intuitive, space-efficient, time-inefficient, potentially non-terminating (incomplete)

Refutation Resolution Proof ExampleRefutation Resolution Proof Example

Refutation proof principle: To prove KB |= F Prove logically equivalent: (KB F) |= True

In turn logically equivalent to: (KB F) |= False

(american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) criminal(P)) //1 (T owns(nono,m1)) //2a (T missile(m1)) //2b (owns(nono,W) missile(W) sells(west,nono,W)) //3

(T american(west)) //4 (T nation(nono)) //5 (T enemy(nono,america)) //6 (missile(W) weapon(W)) //7 (enemy(N,america) hostile(N)) //8

(T nation(america)) //9 (criminal(west) F) //0

1. Solve 0 w/ 1 unifying P/west:american(west) weapon(W) nation(N) hostile(N) sells(west,N,W) F //10

2. Solve 10 w/ 4:weapon(W) nation(N) hostile(N) sells(west,N,W) F //11

3. Solve 11 w/ 7: missile(W) nation(N) hostile(N) sells(west,N,W) F //12

4. Solve 12 w/ 2b unifying W/m1:nation(N) hostile(N) sells(west,N,m1) F //13

5. Solve 13 w/ 5 unifying N/nono:hostile(nono) sells(west,nono,m1) F //14

6. Solve 14 w/ 8 unifying N/nono:enemy(nono,america) sells(west,nono,m1) F //15

7. Solve 15 w/ 6: sells(west,nono,m1) F //16

8. Solve 16 w/ 3 unifying W/m1: owns(nono,m1) missile(m1) F //17

9. Solve 17 with 2a: missile(m1) F //18

10. Solve 18 with 2b: F

SLD resolution example SLD resolution example

criminal(P)


criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)


criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)

american(west) weapon(W) nation(N) hostile(N) sells(west,N,W)

criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)

american(west) weapon(W) nation(N) hostile(N) sells(west,N,W)

criminal(west)?

missile(m1) enemy(N,america) owns(nono,W)


nation(america)


sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(N) hostile(N) sells(west,N,W)

criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(N) hostile(N) sells(west,N,m1)

criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(nono) hostile(N) sells(west,N,m1)

criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)


criminal(west)?



nation(america)


sells(west,nono,W)


criminal(west)


criminal(west)?

missile(m1) enemy(nono,america) owns(nono,W)


nation(america)


sells(west,nono,W)


criminal(west)


criminal(west)?

missile(m1) enemy(nono,america) owns(nono,W)


nation(america)


sells(west,nono,m1)


criminal(west)


criminal(west)?



nation(america)


sells(west,nono,m1)


criminal(west)


criminal(west)? yes



nation(america)


sells(west,nono,m1)

SLD resolution example with SLD resolution example with backtrackingbacktracking

criminal(west)


criminal(west)?


missile(m1)american(west)

nation(nono)

nation(america) enermy(nono,america)owns(nono,m1)

sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(america) hostile(N) sells(west,N,m1)

criminal(west)?



nation(nono)


sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(america) hostile(america) sells(west,america,m1)

criminal(west)?



nation(nono)


sells(west,nono,W)


criminal(west)


criminal(west)?

missile(m1)

enemy(america,america)

owns(nono,W)


nation(nono)


sells(west,nono,W)


criminal(west)


criminal(west)?

missile(m1)

enemy(america,america)

owns(nono,W)


nation(nono)


sells(west,nono,W)

fail


criminal(west)


criminal(west)?



nation(nono)


sells(west,nono,W)

fail

backtrack


criminal(west)


criminal(west)?



nation(nono)


sells(west,nono,W)

backtrack


criminal(west)


criminal(west)?



nation(nono)


sells(west,nono,W)


criminal(west)

american(west) weapon(m1) nation(nono) hostile(N) sells(west,N,m1)

criminal(west)?



nation(nono)


sells(west,nono,W)

SLD resolution example with SLD resolution example with bactrackingbactracking

criminal(west)


criminal(west)?



nation(nono)


sells(west,nono,W)

Limitations of Pure Prolog Limitations of Pure Prolog and ISO Prologand ISO Prolog

For knowledge representationknowledge representation: search customization:

No declarative constructs Limited support procedimental

constructs (cuts) no support for uncertain

reasoning forces unintuitive rule-based

encoding of inherently taxonomic and procedural knowledge

knowledge base updates non-backtrackable and without logical semantics ab :- assert(a), b.

if b fails, a remains as true

For programmingprogramming: no fine-grained encapsulation no code factoring (inheritance) poor data structures (function

symbols as only construct) mismatch with dominant object-

oriented paradigm not integrated to comprehensive

software engineering methodology IDE not friendly enough scarce middleware very scarce reusable libraries or

components (ex, web, graphics) mono-thread

For declarative logicdeclarative logic programming:

imperative numerical computation, I/O and meta-programming without logical semantics

Limitation of SLD resolution enginesLimitation of SLD resolution engines

Unsound: unification without occur-check Incomplete: left-recursion

Correct ancestor Prolog program: anc(A,D) :- parent(A,D). anc(A,D) :- parent(P,D), anc(A,P). Logically equivalent program (since conjunction is a commutative

connective) that infinitely loops: anc(A,D) :- anc(A,P), parent(P,D). anc(A,D) :- parent(A,D).

Inefficient: repeated proofs of same sub-goals irrelevant chronological backtracking

Prolog’s imperative arithmeticsProlog’s imperative arithmetics

fac(0,1) :- !.fac(I,O) :- I1 is I - 1, fac(I1,O1), O is I * O1.?- fac(1,X).X = 1?- fac(3,X).X = 6

?- I1 is I -1error?- I1 = I -1I1 = I -1?- I = 2, I1 = I -1I1 = 2 -1?- I = 2, I1 is I -1I1 = 1

Arithmetic functions and predicates generate exception if queried with non-ground terms as arguments is: requires a uninstantiated variable on the left and an arithmetic expression on the right Relational programming property lost Syntax more like assembly than functional ! is: Prolog’s sole explicit variable variable assignmentassignment predicate (only for arithmetics) =: is a bi-directional, general-purpose unification queryquery predicate

Prolog’s redundant sub-goal proofsProlog’s redundant sub-goal proofs

Extensions of pure PrologExtensions of pure Prolog

Pure Prolog

ISO Prolog

High-Order LP

Functional LP

Constraint LP

Abductive LP

Transaction LP

Frame (OO) LP

Preference LP

Tabled LP

Inductive LP

XSB

Aleph

Flora

Constraint Logic Programming (CLP)Constraint Logic Programming (CLP)

CSP libraries’ strengths: Specification level, declarative

programming for predefined sets of constraints over given domains

Efficient Extensive libraries cover both finite

domain combinatorial problems and infinite numerical domain optimization problems

CSP libraries’ weaknesses: Constraint set extension can only

be done externally through API using general-purpose programming language

Same problem for mixed constraint problems (ex, mixing symbolic finite domain with real variables)

Prolog’s strengths:Allows specification level,

declarative programming of arbitrary general purpose problems

A constraint is just a predicateNew constraints easily

declaratively specified through user predicate definitions

Mixed-domain constraints straightforwardly defined as predicate with arguments from different domains

Prolog’s weakness:Numerical programming is

imperative, not declarativeVery inefficient at solving finite

domain combinatorial problem

CLPCLP

Integrate Prolog with constraint satisfaction and solving libraries in a single inference engine

Get the best of both worlds: Declarative user definition of arbitrary constraints Declarative definition of arbitrarily mixed constraints Declarative numerical and symbolic reasoning, seamlessly

integrated Efficient combinatorial and optimization problem solving Single language to program constraint satisfaction or solving

problems and the rest of the application

CLP Engine CLP Application Rule Base

Prolog EngineProcedural Solver

for Domain D1

Procedural Solverfor Domain Dk

Solver Programming Language L

...Prolog/L Bridge

Ontologies Reasoning Components Agents Simulations Introduction to Rule-Based Reasoning Jacques...

Documents

Transcript of Ontologies Reasoning Components Agents Simulations Introduction to Rule-Based Reasoning Jacques...