R euse O riented A utomated R easoning S oftware

1. ReuseOrientedAutomatedReasoningSoftware Jacques Robin

2. Outline • Motivation and goal • Design principles of the ROARS framework • Reuse-oriented software engineering techniques • CHRV as a platform for automated reasoning service integration • Current status and next steps

3. Most information system issues related to: • Scalable and secure concurrent access • Component-based web deployment • Software process • Solved by current standards: • J2EE, .Net, Web Services, SQL,XML,UML,RUP • Competitive edge thus based on: • Embedded automated reasoning • Automated reasoning techniques over last two decades: • Diversification (abduction, inheritance,belief revision, belief update, planning, constraint solving,induction, analogy) • Practical scalability • Rigorous formal foundations • Cutting-edge AR techniques remain ignored by commercial software • Prohibitive cost of incorporating AR techniques in mainstream software • Too costly to develop from scratch • Available AR software not built for integration, extension and reuse Motivation: the CurrentAutomated Reasoning Paradox

4. Goal of ROARS Project • Develop a framework for low-cost engineering of inference engines, knowledge bases and applications with embedded automated reasoning • By exploiting conceptual reuse among automated reasoning techniques at the software architecture level Software Process Reasoning Component Library ROARS Framework CASE Tools Benchmark Application Library

5. UML2 Component,Application OO Models Standard MDA Languages MOF2 Modeling Language OO Meta-Models Built-In Contract Testing QVT/ATL Model Transformation OO Models SPEM2 Software Process OO Models OCL2 Logical Constraints on OO Models Model Driven CHRV Fruehwirth,Abdennadheret al. Component Based KobrA Process Atkinson, Gross et al. Frame Logic GUI Modeling Blankenhorn et al. Koch et al. Kifer, Yang et al. Design Principles: Paradigm Integration Formal Methods CHORD: executable yet formal OO rules ROARS Process Fast Prototyping AspectOriented

6. Raw Main Concern Functionalities Model or Code Advices Aspect A Pointcuts Aspect 1 Aspect 1: Model or Code Transformation to Insert (Weave) Cross-Cutting Functionality 1 Through Pattern-Matching Aspect N: Model or Code Transformation to Insert (Weave) Cross-Cutting Functionality N Through Pattern-Matching Aspect Weaving Engine Advices Aspect N Main Concern Functionalities Model or Code w/ Woven Cross-Cutting Functionalities Pointcuts Aspect N Aspect-Oriented Development (AOD) • Aspects recurrent in many domains: persistence, distribution, concurrency, authentication, logging • Too tightly coupled w/ main concern to be encapsulated as component

7. ATL / QVT Rules Advices Poincuts UML2 ATL / QVT Rules ATL / QVT Rules CHORD Poincuts Advices ATL / QVT Rules ATL / QVT Rules UML2 Profile for J2EE / .Net Poincuts Advices ATL / QVT Rules Poincuts J2EE / .Net AspectJ Aspect C# Advices Aspect Weaver J2EE / .Net Java / C# Compiler .Jar / .dll ROARS MDAOCB Software Process Vertical Meta- Transform. Main Concern Components Vertical Transform. Cross-Cutting Concerns Aspects: Horizontal Transformations Knowledge-level Platform Independent Model ATL / QVT Rules Formal-level Platform Independent Model ATL / QVT Rules Platform Specific Model ATL / QVT Rules Separated Source Code & Meta-Code Woven Source Code Deployed Code

8. Knowledge Representation Language Ontological Commitment High-Order OO High-Order Relational First-Order OO First-Order Relational Propositional Deduction Abduction Inheritance Belief Revision Belief Update Constraint Solving Planning Optimization Induction Analogy Boolean Logic CWA Boolean Logic OWA Ternary Logic CWA Ternary Logic OWA Reasoning Task Probabilistic Knowledge Representation Language Epistemological Commitment Dimensions of AR Services

9. Deduction Abduction Inheritance Belief Revision Planning Belief Update Constraint Solving Optimization Induction Analogy Dimensions of AR Services From: X,Y p(X,a)  q(b,Y)  r(X,Y)  p(1,a)  q(b,2) Deduce: r(1,2) From: A si(A)  do(A,k)  sj(A)  p(A)  si(A)  p(a) Initially believe: si(a) But after executing do(a,k) Update belief si(a) into sj(a) From: X,Y,Z  N X+Y=Z  1X  XZ  XY  YZ  Z 7w/ utility(X,Y,Z) = X + Z Derive optimum: X=2  Y=4  Z=6 From: X,Y p(X,a)  q(b,Y)  r(X,Y)  p(X,c)  n(Y)  r(X,Y)  p(1,a)  r(1,2)  p(1,c) w/ bias: q(A,B) Abduce: q(b,2) From: p(1,a) q(b,2) r(1,2)  p(1,c)  n(2) ...  p(3,a)  q(b,4) r(3,4)  p(3,c)  n(4) w/ bias: F(A,B)  G(C,D)  H(A,D) Induce: X,Y p(X,a)  q(b,Y)  r(X,Y) From: A sa(A)  do(A,i)  sb(A) ... sh(A)  do(A,k)  sg(A)  sa(a)  goal(a) = sg(a) Plan to execute: [do(a,i), ... , do(a,k)] From: G G instanceOf g  p(G)  s subclassOf g  s1 instanceOf s Inherit: p(s1) From: a ~1 b  a ~2 c  a ~11 d  p(b,x)  p(c,x)  p(d,y) Derive by analogy: p(a,x) From: X p(X) ~ r(X)  q(X)  n(X)  (r(X)  n(X))  p(a) Believe by default: r(a) But from new fact: q(a)Revise belief r(a) into n(a) Solve: X,Y,Z N X+Y=Z 1X XZ  XY YZ  Z 7 Into: X=2  3Y  Y 4  5 Z  Z6 or (X=2  Y=3  Z=5)  (X=2  Y=4  Z=6) Reasoning Task

10. Epistemological Commitment Probabilistic f  KB xor f  KB From: KB |= f  KB | f Derive: f unknown Ternary Logic OWA Boolean Logic OWA Ternary Logic CWA f  KB From: KB | f Assume: f Boolean Logic CWA

11. Universally quantified variables in class, attribute, association and method positions In essence, meta-circular UML (M3 = M2 = M1) S,G,A,T trans(subclassOf)(S,G)  type(G.A) = T  type(S.A) = T Universally quantified variables in predicates, functions, and formula positions R,X,Y trans(R)(X, Y)  (R(X, Y)  (R(X, Z)  trans(R)(Z,Y)) In essence, UML: classes, objects, attributes, associations (relations), operations Predicates (relations) with universally quantified variable arguments, and recursive functions, but no structural aggregation of properties nor distinguished generalization relation D,G day(D)  rain(D)  ground(G) state(G,wet)  ground(grass) Only propositions (no variables, relations, classes nor objects) rain  wetGrass Ontological Commitment High-Order OO High-Order Relational First-Order OO First-Order Relational Propositional

12. Knowledge Representation Language Ontological Commitment What minimal set of basic components can cover this entire service space through assembly ? High-Order OO High-Order Relational First-Order OO First-Order Relational Propositional Deduction Abduction Inheritance Belief Revision Belief Update Constraint Solving Planning Optimization Induction Analogy Boolean Logic CWA Boolean Logic OWA Ternary Logic CWA Ternary Logic OWA Reasoning Task Probabilistic Knowledge Representation Language Epistemological Commitment Dimensions of AR Services

13. Deduction High-Order OO Ternary Logic CWA Deduction First-Order OO Probabilistic Abduction First-Order OO Probabilistic Inheritance Object-Oriented Bayes Nets (OOBN) Frame Logic Deduction First-Order Relational Ternary Logic CWA Deduction First-Order Relational Probabilistic Abduction First-Order Relational Probabilistic Belief Revision First-Order Relational Boolean Logic CWA CLP(BN) Deduction First-Order Relational Boolean Logic CWA Optimization First-Order Relational Probabilistic Kakas et al. CHRV Dechter CHRV Deduction First-Order Relational Ternary Logic OWA Constraint Solving First-Order Relational Ternary Logic OWA Abduction First-Order Relational Ternary Logic OWA AR Service Mappings

14. Belief Update First-Order Relational Probabilistic Planning First-Order Relational Probabilistic Induction High-Order OO Ternary Logic CWA Induction First-Order OO Probabilistic OOBN Cigolf ACLP Induction First-Order Relational Ternary Logic CWA Induction First-Order Relational Probabilistic Abduction First-Order Relational Ternary Logic CWA Constraint Solving First-Order Relational Ternary Logic OWA CHRV AR Service Mappings

15. CHRV • CHRV engine versatile basic component with very high reuse potential for ROARS framework • Integrates and generalizes three main logical rule based reasoning and programming paradigms: • Conditional rewrite rule forward chaining for constraint simplification and non-monotonic reasoning • h1 ...  hn g1 ...  gn | (b11 ...  b1n)  ...  (bk1 ...  bkm) • Event-triggered production rules forward chaining for constraint propagation and monotonic reasoning • h1 ...  hn g1 ...  gn | (b11 ...  b1n)  ...  (bk1 ...  bkm) • Backtracking search of alternatives in disjunctive bodies for simulating Prolog's backward chaining and labeling in finite domain constraint solving • CHRV syntax covers full first-order logic in implicative normal form: • atom1 ...  atomn atomn+1 ...  atomm • Not limited to Horn logic • Open-world assumption, but selective closed-world assumption with additional propagation rules

16. Frame Logic • Integrates object-oriented and logical rule based programming and reasoning • Multiple, single source, non-monotonic inheritance (overriding) of: • Attribute and method type constraints and values • Method code • Ternary logic well-founded semantics with CWA for negation as failure, non-monotonic inheritance and interferences between inheritance and deduction • High-order syntax allowing logical variables in position of function predicate, atom, object, classe, attribute and method names • Permits logical meta-rules and object-oriented reflection while remaining within first-order logic semantics and complexity • Operator to reify formulas as terms in rule bodies • Database aggregation operators in rule bodies • Backtrackable explicit knowlegde base updates operators in rule bodies with transaction roll-back semantics guaranteeing consistency (but no built-in turth-maintenance) • Procedural operators in rule bodies

17. CHORD: CHRV + Frame Logic • CHORD:Constraint Handling Object-oriented Rules with Disjunctive bodies • FPIM layer in ROARS framework intermediate representation between two object-oriented layers: • KPIM in UML and OCL • PSM in UML profile for J2EE or .Net • Using purely relational CHRV as FPIM layer language would make automated transformations from KPIM to FPIM to PSM uselessly complex • CHORD key idea: • Extends CHRV with Frame Logic's object-oriented features • Syntactically, add: • High-order OO frame molecules and OO path expressions as constraints start ==> t:square, quadrilateral[side1 *=> line[length *=> int], ..., side4 *=> line], square::quadrilateral. T:square ==> T.side1.length = T.side2.length, ..., T.side1.length = T.side4.length | true. • Reification operator • Semantically: • Soundly integrate Frame Logic's multiple, single-source, non-monotonic inheritance under CWA with CHRV deduction and abduction under OWA

18. min(X,Y,Z) <<Component>>  CHRD Base <<Component>> Min CHRD Base XY XY derive X  X  false X  Y  Y  Z  X  Y  Y  Z | X  Z X  Y  Y  Z  X  Y  Y  Z | X  Z X  Y  Y  Z  X  Y  Y  Z | X  Z min(X,Y,Z)  X  Y | Z = X min(X,Y,Z)  Z  Y | Z = X min(X,Y,Z)  Y  Z | Z = Y min(X,Y,Z)  Z  X | Z = Y min(X,Y,Z)  Z  X  Z  Y XY XY derive XY X=Y <<Component>> CHRD Base derive XY X=Y X  Y  X = Y | true X  Y  Y  X  X = Y X  Y  Y  Z  X = Z X  Y  X  Y  X  Y derive <<Component>> Host Platform <<Component>> CHRD Engine CHR for FPIM Component Assembly • Distinction between user-defined and built-in constraints in CHR can be generalized into constraints locally defined in rule base component and externally defined in server rule base component

19. Current Status • ROARS project recently funded by CAPES-DAAD • Current team: • Universidade Federal de Pernambuco, Brazil: Profs. Jacques Robin, Silvio Meira, PhD. student Jairson Vitorino, Undergraduate research assistant Marcos Silva, MSc. student João Prazeres • Universidade de Pernambuco, Brazil: Prof. Luis Menezes • Ulm Universität, Germany: Prof. Thom Fruehwirth, PhD. student Marc Meister • Mannheim Universität, Germany: Prof. Colin Atkinson,PhD. students Matthias Gutheil and Dietmar Stoll • Fraunhofer-Gesellschaft Berlin, Germany: Dr. Armin Wolf, Matthias Hoche • Available results: • CHREK 1.0: prototype Java/AspectJ CHRV inference engine with Eclipse plug-in GUI (Silva, Vitorino, Robin) • CHORD MOF metamodel (Robin, Silva, Vitorino) • CHORD 1.0: prototype Java/AspectJ CHORD inference engine with Eclipse plug-in GUI with rule-based inheritance (Silva, Robin)

20. Next Steps • SPEM specification of ROARS process • Vitorino, Robin, Atkinson, Blanc • Model-Driven, Component-Based, Aspect-Oriented Development of CHREK 2.0 • Scalable adaptive CHRV engine w/low-level truth-maintenance and detailed explanation GUI • Vitorino, Prazeres, Robin, Wolf, Atkinson, Fruehwirth, Menezes • Adapt Built-In Contract Testing techniques for FPIM layer CHRV/CHORD rule based components • Prazeres, Robin, Atkinson, Fruehwirth • CHORD formal semantics in transaction logic • Meister, Robin, Fruehwirth, Menezes • Investigate inheritance built in pattern matching for CHORD, by adapting techniques from ordered sort feature term unification (Aït-Kaci, Cortiuz, etc) • Silva, Robin

21. Conclusion • Cutting-edge automated reasoning techniques: • Conceptually highly compositional • Compositionality never exploited by architecture of available automated reasoning software • Result in prohibitive cost of incorporating these techniques in mainstream applications • ROARS: • Exploit, adapt and extend cutting-edge, reuse-oriented software engineering techniques to lower cost of automated reasoning software development • Define software process integrating MDD, CBD and AOD • Define CHORD language by extending CHRV with Frame Logic style object-orientation and inheritance • Use software process to develop scalable, adaptive CHORD inference engine as a first large grained ROARS component integrating deduction, abduction, belief revision, inheritance and constraint solving services

22. References • http://www.cin.ufpe.br/~jr/mysite/RoarsProject.html