verifying resource requirements for ontology-driven rule-based agents

Introduction Distributed Rule-Based Agents Ontological Representation of Distributed Agents Rule-Based systems from OWL 2 RL + SWRL ontologies Proposed verification framework for Distributed Rule-Based Systems Experiments using the Tovrba tool Conclusion

Verifying Resource Requirements forOntology-Driven Rule-Based Agents

Abdur Rakib, Rokan Uddin Faruqui, and Wendy MacCaull

StFX Centre for Logic and InformationSt. Francis Xavier University

Antigonish, NS, Canada{arkib,mfaruqui,wmaccaul}@stfx.ca

March 6, 2012

1


Building Decision-Support Through Dynamic WorkflowSystems, Academia and Industry Working Together for Better

Healthcare

2


OUTLINE

Introduction

Distributed Rule-Based Agents

Ontological Representation of Distributed Agents

Rule-Based systems from OWL 2 RL + SWRL ontologies

Proposed verification framework for Distributed Rule-BasedSystems

Experiments using the Tovrba tool

Conclusion

3


INTRODUCTION

I The combination of rules and ontologies provides a newparadigm for design, development, and analysis ofsophisticated distributed rules-based agents

I While rule-based computing provides great benefits indeveloping many complex software applications, they alsopresent new challenges to application developers:

I how to ensure the correctness of rule-based designsI terminationI response time

I These problems become even more challenging in the caseof distributed rule-based systems, where severalcommunicating rule-based agents exchange informationvia messages

4


INTRODUCTION CONTD ..I We present a framework for verifying systems of

ontology-driven rule-based agentsI We consider the distributed problem-solving strategy in

systems of communicating rule-based agents, and askI how much time (measured as the number of rule firings)

I how many message exchanges it takes the system to find asolution

I We use standard model checking techniques to verifyinteresting properties of such systems

I We show how the Maude LTL model checker can be usedto verify properties including response-time guarantees ofthe form:

I if the system receives a query, then a response will beproduced within n timesteps.

5


DISTRIBUTED RULE-BASED AGENTS

I Multiple-agents combine their knowledge andcomputational resources to solve problems

I No single agent can solve the problem on its own

I because no single agent has all the information necessary tosolve the problem

I to solve problems more effectively, e.g., in less time than asingle agent

I By sharing information agents can solve the problem moreeffectively

6


A SIMPLE DISTRIBUTED SYSTEM

I Time: how many inference steps does the system need toperform, in parallel?

I Communication: how many messages do the agents needto exchange?

7


A SIMPLE DISTRIBUTED SYSTEM CONTD.

Agent 1 KB1 = {A,B} Agent 2 KB2 = {D}

# Step Config 1 Action 1 Config 2 Action 20 {A,B} - {D} -1 {A,B,C} RuleC {D,Ask(2, 1, C)} RuleAsk2 {A,B,C,Ask(2, 1, C)} Copy {D,Ask(2, 1, C)} Idle3 {A,B,C,Ask(2, 1, C), RuleTell {D,Ask(2, 1, C)} Idle

Tell(1, 2, C)}4 {A,B,C,Ask(2, 1, C), Idle {D,Ask(2, 1, C), Copy

Tell(1, 2, C)} Tell(1, 2, C)}5 {A,B,C,Ask(2, 1, C), Idle {D,Ask(2, 1, C), RuleTrust

Tell(1, 2, C)} Tell(1, 2, C), C}6 {A,B,C,Ask(2, 1, C), Idle {D,Ask(2, 1, C), RuleE

Tell(1, 2, C)} Tell(1, 2, C), C,E}

Table: The table shows that from the initial configuration agents canderive E in 6 time steps exchanging two messages

8


SYSTEMS OF COMMUNICATING RULE-BASED AGENTS

I Let the system consists of n agents, A = {1, 2, ..., n}

I Each agent has a program, consisting of first order Hornclause rules, and a working memory, which contains facts

I If an agent i has a rule A1 ∧A2 ∧ . . . ∧Ak → B1

I the facts A1 ∧A2 ∧ . . . ∧Ak are in the agent’s workingmemory and B1 is not in the agent’s working memory instate s

I the agent can fire the rule which adds B1 to the agent’sworking memory in the successor state s′

I In addition to firing rules, agents can exchange messagesregarding their facts

9


DERIVATION OF A GOAL

I The initial configuration of the system contains theworking memory facts

I Producing the next configuration by one of the followingoperations:

I Rule: applies a rule of the form A1 ∧A2 ∧ . . . ∧Ak → B1

I Communication : agents can exchange messages regardingtheir facts using their Ask and Tell

I Idle: which leaves its configuration unchanged

I The goal formula G is derived if it occurs in theconfiguration of one of the agents

I A problem is considered to be solved if one of the agentshas derived the goal

10


MEASURING RESOURCES

I We take the time complexity of a derivation to be the totalnumber of inference steps by the system

I Our model of communication complexity is based on thenumber of facts exchanged by the agents

I The communication complexity of a joint derivation is thenthe (total) number of message exchanges in the derivation

11


SYSTEM PROPERTIES OF INTEREST

I Temporal epistemic propertiesI there is a possibility that eventually Agent i will derive

formula G in nT time steps while exchanging fewer thannC messages

I always Agent i fails to derive formula G in nT time stepswhile exchanging fewer than nC messages

I always every request of Agent i will be responded to Agentj in nT time steps

12


REPRESENTATON OF DISTRIBUTED RULE-BASED AGENTS

I An ontology is an explicit formal specification of aconceptualization

I A model of a domainI introduces vocabulary relevant to the domainI specifies semantics of terms

I The Web Ontology Language OWLI W3C RecommendationsI based on Description Logic (SHOIN -OWL 1 and SROIQ

- OWL 2)

13


THE SEMANTIC WEB RULE (SWRL)

I Both the description logic based OWL 1 and OWL 2 aredecidable fragments of first order logic

I However, the expressive power of OWL 1 is strictly limitedto certain tree structure-like axioms

I For instance, a simple rulehasFather(?x, ?y)∧hasBrother(?y, ?z)→ hasUncle(?x, ?z)can not be modelled using OWL 1 axioms.

I Although OWL 2 can express this uncle rule indirectly,many rules are still not possible to model using OWL 2axioms

14


WHY DO WE NEED BOTH OF THEM?

I DL-Safe rules can remove such restrictions while beingdecidable; however, they are restricted to universalquantification and lack negation in their basic form

I A combination of OWL 2 with rules offers a moreexpressive formalism for building Semantic Webapplications.

I We use SWRL that extends OWL DL by adding newaxioms, namely Horn clause rules.

I We combine a set of SWRL rules with the set of OWL 2axioms and facts to build our ontology.

15


ONTOLOGICAL REPRESENTATON OF DISTRIBUTED RULE-BASED AGENTS

⇓

16


ONTOLOGICAL REPRESENTATON OF DISTRIBUTED RULE-BASED AGENTS

⇓Tbox

SubClassOf (Doctor CareGiver)

InverseObjectProperties(isFeeling isFeltBy)

AboxClassAssertion(Patient Mary)

ObjectPropertyAssertion(isFeeling Mary MucositisPainTwo)

SWRLPatient(?p) ∧ isFeeling(?p, ?x ) ∧ Pain(?x ) ∧ hasPainLevel(?x , “2”)

→ hasPaintIntensity(?p,MildPainIn)

17


RULE-BASED SYSTEMS FROM OWL 2 RL + SWRL ONTOLOGIES

I OWL 2 RL is based on Description Logic Program (DLP),the set of axioms and facts of an OWL 2 RL ontology canbe translated to Horn clause rules.

I We use the DLP framework, a mapping between DL basedontology and datalog programs, to translate an ontology toa set of Horn clause rules.

I OWL 2 RL, one of the profiles of OWL 2, is suitable forscalable implementation of rule-base systems

I The syntax of OWL 2 RL is asymmetric. These restrictionsfacilitate the translation of OWL 2 RL axioms into Hornclause rules based on the DLP framework.

I The translation of SWRL rules is straightforward becausethey are already in the Horn clause rule format.

18


TRANSLATION OF OWL 2 RL AXIOMS INTO HORN CLAUSE RULES

OWL 2 Axioms and Facts DL Syntax Horn clause ruleClassAssertions a : C C(a)PropertyAssertion 〈a, b〉 : P P (a, b)SubClassOf C v D C(x)→ D(x)EquivalentClasses C ≡ D C(x)→ D(x),D(x)← C(x)EquivalentProperties P ≡ Q Q(x, y)→ P (x, y)

P (x, y)→ Q(x, y)ObjectInverseOf P ≡ Q− P (x, y)→ Q(y, x)

Q(y, x)→ P (x, y)TransitiveObjectProperty P+ v P P (x, y) ∧ P (y, z)→ P (x, z)SymmetricObjectProperty P ≡ P− P (x, y)→ P (y, x)Object/DataUnionOf C1 t C2 v D C1(x)→ D(x), C2(x)→ D(x)Object/DataIntersectionOf C v D1 uD2 C(x)→ D1(x),C(x)→ D2(x)Object/DataSomeValuesFrom ∃P.C v D P (x, y) ∧ C(y)→ D(x)Object/DataAllValuesFrom C v ∀P.D C(x) ∧ P (x, y)→ D(y)Object/DataPropertyDomain > v ∀P−.C P (y, x)→ C(y)Object/DataPropertyRange > v ∀P.C P (x, y)→ C(y)

19


BUILDING RULE-BASED AGENTS

I An agent in the system is either concrete or abstract

I Each concrete agent has a program, consisting ofI Horn clause rules - derived from OWL 2 RL + SWRL

ontologies,

I a working memory -contains facts (ground atomicformulae) representing the initial state of the system

I The behavior of each abstract agent is represented in termsof a set of LTL formulae

20


CONCRETE AGENTS

Reasoning Strategies: to impose restrictions on possible actions

21


CONCRETE AGENTS CONTD..Rules of a concrete agent follow the following BNF:

Rule ::= ’<’ Priority ’:’ Atoms ’→’ Atom ’>’Atoms ::= Atom {∧ Atom}∗Atom ::= standardAtom | commmunicationAtomstandardAtom ::= description’(’i-object ’)’

| individualvaluedProperty’(’i-object ’,’ i-object ’)’| datavaluedProperty’(’i-object ’,’ d-object ’)’| sameIndividuals’(’i-object ’,’ i-object ’)’| differentIndividuals’(’i-object ’,’ i-object ’)’| dataRange’(’ d-object ’)’| builtIn’(’ builtinId ’,’ {d-object}∗ ’)’

communicationAtom ::= ’Ask(’ i ’,’ j ’,’ standardAtom ’)’| ’Tell(’ i ’,’ j ’,’ standardAtom ’)’

Priority ::= N≥0N≥0 ::= 0 | 1 | 2 | ...i ::= 1 | 2 | ... | nAgj ::= 1 | 2 | ... | nAgbuiltinID ::= URIreferencei-object ::= i-variable | individualIDd-object ::= d-variable | dataLiterali-variable ::= ’I-variable(’URIreference’)’d-variable ::= ’D-variable(’URIreference’)’

22


CONCRETE AGENTS CONTD..I To allow the implementation of reasoning strategies, each

atom is associated with a time stamp which records thecycle at which the atom was added to working memory

I Rule priorities and fact time stamps can be used todetermine which rule instance(s) are selected from theconflict set for execution

I For example, a rule instance with the highest priority maybe selected, or a rule instance may be selected whoseantecedent atoms are associated with highest time stampetc.

I The internal configurations of the rules follow the syntaxgiven below:

〈 n : [ t1 : P1] ∧ [ t2 : P2] ∧ . . . ∧ [ tn : Pn]→ [ t : P ] 〉

23


ASK-TELL COMMUNICATION

Communication between agents: Ask and Tell

I A = {1, 2, . . . , n}, we assume special communicationprimitives in the language

I Ask(i, j, P ): i asks j whether P is the case is referred to asan Ask

I Tell(i, j, P ): i tells j that P is referred to as a Tell

24


ASK-TELL COMMUNICATIONThe position in which formulae Ask and Tell may appear in arule depends on which agent’s program the rule belongs to

I Agent i may have an Ask or a Tell in the consequent of arule, e.g.,

P1 ∧ P2 ∧ . . . ∧ Pn → Ask(i, j, P )

I Agent j may have the same expressions in the antecedentof the rule, e.g.,

Ask(i, j, P ) ∧ P → Tell(j, i, P )

Tell(i, j, P )→ P

25


ABSTRACT AGENTSAbstract agents are modelled using LTL formulae

ρ ::= X≤nϕ1 | G(ϕ2 → X≤n ϕ3 )ϕ1 ::= BiAsk(i , j ,P) | BiTell(i , j ,P) | BiAsk(j , i ,P) | BiTell(j , i ,P) | Bi Pϕ2 ::= Bi Ask(j , i ,P) | Bi Tell(j , i ,P)ϕ3 ::= Bi Tell(i , j ,P) | Bi Tell(i , k ,P) | Bi Ask(i , j ,P) | Bi Ask(i , k ,P)

I X≤nϕ1 - describe agents which produce a certain message orinput to the system within n time steps

I ϕ1 of the form Bi Ask(i, j, P ) or Bi Tell(i, j, P ) - when the beliefsappear (as an Ask or a Tell ) in the abstract agent i’s workingmemory, they are also copied to agent j’s working memory atthe next step.

I Bi P - represents a belief involving an atom P (other thanAsk and Tell ) may also appear in the abstract agent i’s workingmemory within n time steps

I G(ϕ2 → X≤n ϕ3) - describe agents which are alwaysguaranteed to reply to a request for information within n timesteps.26


THE MAUDE LTL MODEL CHECKER

I We use the Maude model checker - developed at SRI inMenlo Park California.

I The specification language of the Maude LTL Modelchecker based on rewriting logic

I Maude modules: basic units of specification andprogramming

I are essentially collections of sorts and a set of operations onthese sorts

I Functional modules - contains only equations

I System modules - contains both equations and rewritingrules

27


SYSTEM ENCODING STRUCTURE IN MAUDE

I Functional Modules - agent’s working memory,knowledge base, configuration (local state) of the agents,control strategies

I The system module - implements global configuration ofthe system

28


FUNCTIONAL MODULE CONTD..1 fmod ACM is2 protecting NAT .3 protecting BOOL .4 protecting QID .5 sorts Constant Atom sAtom cAtom Term Rule Agenda WM .6 sorts TimeA TimeWM RepT RepTime Config .7 subsort Atom < WM .8 subsorts aAtom cAtom < Atom .9 subsort Rule < Agenda .

10 subsort Qid < Constant .11 subsort TimeA < TimeWM .12 subsorts Constant < Term .13 subsort RepT < RepTime .14 ops void rule : -> Atom .15 ops com exec : -> Phase [ctor] .16 op nil : -> Term[ctor] .17 op [_ : _] : Nat Atom -> TimeA .18 op _ _ : WM WM -> WM [comm assoc] .19 op _ _ : TimeWM TimeWM -> TimeWM [comm assoc] .20 op _ _ : Agenda Agenda -> Agenda [comm assoc] .21 op <_ : _->_> : Nat TimeWM TimeA -> Rule .22 op _ _ : RepTime RepTime -> RepTime [comm assoc] .23 op Ask : Nat Nat sAtom -> cAtom .24 op Tell : Nat Nat sAtom -> cAtom .25 endfm

29


IMPLEMENTATION OF AGENTS

I Each agent (concrete/abstract)

I imports the Maude ACM module

I contains local configuration - a working memory, anagenda, time step, message counter

I Multi-agent systems (MAS)

I are constructed using a system module,

I contain global configuration of the system

I The inference engine and communication mechanism

I are implemented in the MAS system module using Mauderules

30


THE TOVRBA TOOL ARCHITECTURE

Modeling problems using

Ontology plus Rules

(OWL 2 RL + SWRL)

Read/Write/Edit

OWL 2 RL + SWRL

Develop Ontologies

Pellet ontology reasoner

plugged in

Ontology plus Rules in

OWL/XML syntax

Translator

Plain text syntax rules which

are used in system design

Encoding generator

Generating Maude encoding

and

allowing property specification

to be verified

The Maude

LTL model checker

Verified design

31


EXPERIMENTS USING THE TOVRBA TOOL

Pain Ontology - Terminology and Concepts from SNOMED, ICNP,Cancer Care NS and Local health authority

32


EXPERIMENTS USING THE TOVRBA TOOL CONTD..I We model a multi-agent rule-based system using

TOVRBA based on the pain monitoring ontology.

33


EXPERIMENTS USING THE TOVRBA TOOL CONTD..

I The system consists of one concrete agent and five abstractagents:

I concrete agent - planner(p)

I abstract agents - assessor (a), reassessor(r),sideeffectmanager(s), caregiver(c), and emergency(e).

I These abstract agents interact with the concrete agent andthey communicate via message passing.

34


EXPERIMENTS USING THE TOVRBA TOOL

I An example temporal formula for an assessor agent a :X≤5 Ba Tell(a, p, isFeeling(′Mary , ′MucositisPainOne))

I An example rule for the planner agent p:

< 2 : Patient(?p) ∧ isFeeling(?p, ?x ) ∧ Pain(?x )∧hasPainLevel(?x ,′2 )→ hasPaintIntensity(?p, ′MildPainIn) >

35



I Following system properties are verified, using the MaudeLTL model checker

1. G( Bp Tell(a, p, isFeeling(′Mary ,′MucositisPainOne))→ X n Bp hasPaintIntensity(′Mary ,′BackgroundDiscomfortIn) )

I whenever agent a tells agent p that Mary is feelingMucositisPainOne, agent p classifies Mary’s pain intensityas Background Discomfort within n time steps

2. G( Bp hasCarer(′Mary ,′John) ∧ Bp hasPainCrisis(′Mary)∧Bp Tell(c, p, hasAcknowledgement(′John,′Busy))→ X n Bp Tell(p, e, hasPainCrisis(′Mary)) )

I whenever a pain crisis occurs with a patient and agent p hasreceived negative acknowledgment from agent c, agent p contactsthe emergency agent e within n time steps.

36



I For a particular experimental set up, these properties areverified as true when the value of n is 2 in the firstproperty, and 3 in the second property

I However, when we assign a value to n which is less than 2in the first property, and less than 3 in the second property,the properties are verified as false and the model checkerreturns counterexamples

37


CONCLUSION

I We described an automated verification framework forcommunicating ontology-driven resource-boundedrule-based agents

I A set of agents specified in terms of facts and Horn clauserules and automatically produces a Maude specification ofthe system which can be efficiently verified

I The System is described in terms of concrete and abstractspecifications

I The properties that we verify are response-time guaranteesof the form: if the system receives a query, then a responsewill be produced within n time steps.

38


Thanks

39


THE SCALABILITY PROBLEM IN MAS VERIFICATIONI Usually intelligent agents can perform many

non-deterministic actions while moving from one state toanother

I A common way to define a global state of a multi-agentsystem is using a (parallel) composition of the local statesof all agents in the system

I It is assumed that in every (global) state the agentsperform simultaneous actions, where some agents mayperform idle actions

I In a multi-agent system composed of n(≥ 1) agents, ifeach agent i can perform at most m(≥ 1)non-deterministic actions, then the system as a whole canmove in mn different ways from a given state at a givenpoint in time

40

verifying resource requirements for ontology-driven rule-based agents

Documents

introduction

ovrba tool

nat nat satom

horn clause

distributed

agents working

nt time steps

distributed