Loading in 5 sec....

R euse O riented A utomated R easoning S oftwarePowerPoint Presentation

R euse O riented A utomated R easoning S oftware

- By
**major** - Follow User

- 111 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' R euse O riented A utomated R easoning S oftware' - major

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

### ReuseOrientedAutomatedReasoningSoftware

Solved by current standards: Competitive edge thus based on:

Jacques Robin

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

- Most information system issues related to:
- Scalable and secure concurrent access
- Component-based web deployment
- Software process

- J2EE, .Net, Web Services, SQL,XML,UML,RUP

- 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

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

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 IntegrationFormal

Methods

CHORD:

executable

yet formal

OO rules

ROARS

Process

Fast

Prototyping

AspectOriented

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

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 ProcessVertical

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

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 ServicesAbduction

Inheritance

Belief

Revision

Planning

Belief

Update

Constraint

Solving

Optimization

Induction

Analogy

Dimensions of AR ServicesFrom: 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 1X XZ XY YZ 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 1X XZ XY YZ Z 7

Into: X=2 3Y Y 4 5 Z Z6

or (X=2 Y=3 Z=5) (X=2 Y=4 Z=6)

Reasoning Task

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

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

OO

High-Order

Relational

First-Order

OO

First-Order

Relational

Propositional

Knowledge Representation Language association and method positions

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 ServicesDeduction association and method positions

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 MappingsBelief Update association and method positions

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 MappingsCHR association and method positionsV

- 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

- Conditional rewrite rule forward chaining for constraint simplification and non-monotonic reasoning
- 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 association and method positions

- 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 association and method positionsV + 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

- High-order OO frame molecules and OO path expressions as constraints
- Semantically:
- Soundly integrate Frame Logic's multiple, single-source, non-monotonic inheritance under CWA with CHRV deduction and abduction under OWA

min(X,Y,Z) association and method positions

<<Component>>

CHRD Base

<<Component>>

Min CHRD Base

XY

XY

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

XY

XY

derive

XY

X=Y

<<Component>>

CHRD Base

derive

XY

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 association and method positions Available results:

- 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

- 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 association and method positions

- 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 association and method positions

- 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 association and method positions

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

Download Presentation

Connecting to Server..