R euse o riented a utomated r easoning s oftware
This presentation is the property of its rightful owner.
Sponsored Links
1 / 22

R euse O riented A utomated R easoning S oftware PowerPoint PPT Presentation


  • 88 Views
  • Uploaded on
  • Presentation posted in: General

R euse O riented A utomated R easoning S oftware. Jacques Robin. Outline. Motivation and goal Design principles of the ROARS framework Reuse-oriented software engineering techniques CHR V as a platform for automated reasoning service integration Current status and next steps.

Download Presentation

R euse O riented A utomated R easoning S oftware

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


R euse o riented a utomated r easoning s oftware

ReuseOrientedAutomatedReasoningSoftware

Jacques Robin


Outline

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


Motivation the current automated reasoning paradox

  • 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


    Goal of roars project

    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


    Design principles paradigm integration

    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


    Aspect oriented development aod

    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


    Roars mdaocb software process

    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


    Dimensions of ar services

    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


    Dimensions of ar services1

    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


    Epistemological commitment

    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


    Ontological commitment

    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


    Dimensions of ar services2

    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


    Ar service mappings

    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


    Ar service mappings1

    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


    Chr v

    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


    Frame logic

    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


    Chord chr v frame logic

    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


    Chr for fpim component assembly

    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


    Current status

    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)


  • Next steps

    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


    Conclusion

    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


    References

    References

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


  • Login