# Rule-Based Reasoning: Constraint Solving and Deduction - PowerPoint PPT Presentation

Rule-Based Reasoning: Constraint Solving and Deduction

1 / 247
Rule-Based Reasoning: Constraint Solving and Deduction

## Rule-Based Reasoning: Constraint Solving and Deduction

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Outline • 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 • Constraint Handling Rules (CHR) • Production Systems • Term Rewriting Systems • Logic Programming and Prolog

2. Rules as a Knowledge Representation Formalism • 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.

3. Fact Base: • Volatile knowledge • Dependent on problem instance • Data Rule-Based Agent Environment Sensors Ask Tell Retract • Rule Engine: • Problem class independent • Only dependent on rule language • Declarative code interpreter or compiler Ask • Rule Base: • Persistant intentional knowledge • Dependent on problem class, not instance • Declarative code Effectors

4. Rule Languages: Common Characteristics • 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.

5. Rule 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

6. Rule 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

7. Classic Imperative OO Implementation Classic 3-Tier Information System Architecture Rule-Based Implementation Imperative OO Language GUI API Imperative OO Language GUI API GUI Layer Easier to reflect frequent policy changes than imperative code Embedded Production Rule Engine Production Rule Base Imperative OO Program Business Logic Layer Imperative OO Host Language Imperative OO Language SQL API Imperative OO Language SQL API Data Layer Generic Component Reusable in Any Application Domain Business Rules • Example of modern commercial application of rule-based knowledge representation

8. Semi-Natural Language Syntaxfor 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 nono to W IF W is a missile THEN W is a weapon IF N is an enemy of America THEN N is hostile

9. Rewrite Rules Logic Programming ISO Prolog Otter Concurrent Prolog Transaction Logic HiLog Production Rules EProver Courteous Rules Maude CLP(X) CCLP(X) CHR OPS5 ELAN Pure OO Languages Rule-Based Constraint Languages CHRV Frame Logic CHORD NeOPS Smalltalk UML QVT CLIPS C++ Flora MOF OCL Web Markup Languages JEOPS JESS Java SWSL OO Rule Languages RuleML XML XSLT Roadmap of Rule-Based Languages

10. Constraint Handling Rules (CHR):Key Ideas • Originally a logical rule-based language to declaratively program specialized constraint solvers on top of a host programming language (Prolog, Haskell, Java) • Since evolved in a general purpose first-order knowledge representation language and Turing-complete programming language • Fact base contains both extensional and intentional knowledge in the form of a conjunction of constraints • Rule base integrates and generalizes: • Event-Condition-Action rules (themselves generalizing production rules) for constraint propagation • Conditional rewrite rules for constraint simplification • Relies on forward chaining and rule Left-Hand-Side (LHS) matching • Extended variant CHRV adds backtracking search and thus generalizes Prolog rules as well

11. CHR by Example:Rule Base Defining  in Terms of = reflexivity@ X  Y <=> X = Y | true. asymmetry@ X  Y, Y  X <=> X=Y. % Constraint simplification (or rewriting) rules % Syntax: <ruleName>@ <simplifiedHead> <=> <guard> | <body> % Logically:Xvars(head  guard) % <guard>  (<head>  Yvars(body - (head  guard)) <body>) % Operationally: substitute in constraint store (knowledge base) constraints that match % the rule simplified head by those in rule body with their variables instantiated from % the match transitivity@ X  Y , Y  Z ==> X  Z. % Constraint propagation (or production) rule (in this case, unguarded) % Syntax: <ruleName>@ <propagatedHead> ==> guard | <body> % Logically:Xvars(head  guard) % <guard>  (<head>  Yvars(body - (head  guard)) <body>) % Operationally: if constraint store (knowledge base) contains constraints that match % the rule propagated head then add those in rule body to the store with their variables % instantiated from the match

12. CHR by Example: Rule Base Defining  in Terms of = idempotence@ X  Y \ X Y <=> true. % Constraint simpagation rule (in this case, unguarded) % Syntax: <ruleName>@ <propagatedHead> \ <simplifiedHead> <=> guard | <body> % Logically:Xvars((head  guard) <propagatedhead>  <simplifiedHead>%  Yvars(body - (head  guard)) <body>  <propagatedhead> % Operationally: if constraint store (knowledge base) contains constraints that match % the rule simplified head and the rule propagated head, then substitute in the store% those matching the simplified head by the rule body with their variables instantiated% from the match query1: A  B, C  A, B  C, A = 2% Initial constraint store: a constraint conjunction answer1:A = 2, B = 2, C = 2, % Final constraint store = initial constraint store% simplified through repeated rule application until no rule neither simplifies nor% propagates any new constraint query2:A  B, B  C, C  A answer2:A = B, B = C

13. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Rule-Defined Constraint Store Built-In Constraint Store Matching Equations  Guard

14. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Condition for firing a rule: Rule head matches active constraint in RDCS Generates set of equations between variables and constants from the head and the constraint (inserted to MEG) Every other head from the rule matches against some other (partner) constraint in the RDCS Generates another set of equations (inserted to MEG) Rule r fires iff:X1,...,Xi  vars(MEGS  BICS - r) BICS  Y1,...,Yj  vars(r) MEG CHR by Example: Rule Base Defining  in Terms of = Active Constraint

15. CHR by Example: Rule Base Defining  in Terms of = r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Normalizing Simplification Active Constraint

16. r@ X  Y <=> X = Y | true.A,B A = 2 | X',Y' X' = A = Y' = B, eg, B = 3  2 = A a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint

17. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Rule firing order depends on 3 heuristics, with the following priority: Rule-defined constraint ordering to become active Rule ordering to try matching and entailment check with active constraint Rule-defined constraint ordering to become partner constraints Engine first tries matching and entailment check for all rules with current active constraint, before trying any rule with the next constraint in the RDCS CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

18. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y A,B,C A = 2 | X',Y' X' = A, Y' = B = C, eg, B = 3  4 = C t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

19. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

20. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y A,B,C A = 2 | X',Y' X' = B = C, Y' = Aeg, B = 3  4 = C t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

21. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

22. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 | X',Y', Z' X' = Z' = A, Y' = B = C, eg, B = 3  4 = C i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

23. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

24. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 |= X'=C,Y'=2,Z'=B, X' = C, Y' = A, Z' = B i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Active Constraint Partner Constraint

25. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of =

26. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint

27. r@ X  Y <=> X = Y | true.B,C A = 2 | X',Y' X' = Y' = B = C, eg, B = 3  2 = C a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Active Constraint

28. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

29. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=YA,B,C A = 2 | X',Y' X' = Y' = A = B = C, eg, B = 3  2 = C t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

30. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

31. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=YA,B,C A = 2 | X',Y' X' = Y' = A = B = C, eg, B = 3  2 = C t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

32. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

33. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 | X',Y',Z' X' = C, Y' = A = B = Ceg, B = 3  2 = C i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

34. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

35. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 | X',Y',Z' X' = A, Y' = B = C, Z' = Beg, B = 3  2 = C i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

36. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

37. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. A,B,C A = 2 | X',Y' X' = A = C, Y' = B, eg, C = 3  2 = A CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

38. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

39. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. A,B,C A = 2 | X',Y' X' = A = C, Y' = B, eg, C = 3  2 = A Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

40. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

41. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=YA,B,C A = 2 | X',Y' X' = Y' = A = B = Ceg, C = 3  2 = A t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

42. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

43. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y A,B,C A = 2 | X',Y' X' = C, Y' = A = Beg, B = 3  2 = A t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost head CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

44. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

45. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 | X',Y',Z' X' = Y' = B = C, Z' = Aeg, B = 3  2 = C i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

46. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

47. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z.A,B,C A = 2 | X',Y',Z' X' = Y' = A = C, Z' = Beg, B = 3  2 = A i@ X  Y \ X  Y <=> true. Alternate matching combination: Active constraint matched against rightmost head Partner constraint matched against leftmost CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

48. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint

49. r@ X  Y <=> X = Y | true. a@ X  Y, Y  X <=> X=Y t@ X  Y, Y  Z ==> X  Z. i@ X  Y \ X  Y <=> true. A,B,C A = 2 | X',Y' X' = C, Y' = A = Beg, B = 3  2 = A CHR by Example: Rule Base Defining  in Terms of = Partner Constraint Active Constraint