Towards A Web Ontology Language for Descriptions of

Continuous Processes

Ankesh Khandelwal

Rensselaer Polytechnic Institute

Troy,NY 12180

ankesh@cs.rpi.edu

Peter Fox

Rensselaer Polytechnic Institute

Troy,NY 12180

pfox@cs.rpi.edu

ABSTRACT

The Semantic Web community has taken big strides in de-

scribing,linking,and reasoning about data.In contrast,

continuous temporal changes which are part of natural pro-

cesses and dynamic systems,e.g.a body moving under the

in uence of external forces,have received little attention in

comparison.In fact there are no ontologies for quantita-

tive descriptions of such temporal changes.In this article

we present the Web Ontology Language for descriptions of

Continuous Changes (WOLCC) which provides vocabulary

for quantitative descriptions of dynamics,e.g.the mathe-

matical equations for the rate of acceleration of the body,

and logical descriptions of conditions under which the equa-

tions are active,boundary conditions at which the equations

cease to hold,transitions at boundary conditions,and inter-

actions between dynamically changing parts.We also ad-

vance the Event Calculus as a reasonable logical formalism

for developing a WOLCC-like language.WOLCC is orthog-

onal to OWL in that it provides for web-based descriptions of

changes in data,typically triggered by actions/events,where

the data and actions/events can be described in OWL (or

other data modeling languages).WOLCCcan potentially be

used for describing natural,physical processes in e-sciences,

which can be inter-linked and linked with observations for

dierent kinds of analysis,e.g.temporal projections (simu-

lations) and abduction (inferring active processes from the

data).

Categories and Subject Descriptors

H.4 [Information Systems Applications]:Miscellaneous;

D.2.8 [Software Engineering]:Metrics|complexity mea-

sures,performance measures

General Terms

Physical Laws,Semantic Web,Quantitative Description

Keywords

Physical Laws,Semantic Web,Quantitative Description

1.INTRODUCTION

The focus in the eld of Semantic Web has been on describ-

ing,linking,and reasoning about data.We believe there

is latent value in having descriptions of continuous tempo-

ral changes which are part of natural processes and dynamic

systems also shared and connected with relevant data on the

Web.The eld of Semantic Web subscribes to logic-based

declarative descriptions of data.E.g.,Description Logics

(DLs) are the foundational theory of the W3C standard,

OWL [2].Logics can also be used for describing dierent

aspects of dynamic systems such as:conditions under which

the equations of the dynamics are active,boundary condi-

tions at which the equations cease to hold,transitions at

boundary conditions,and interactions between dynamically

changing parts.We refer to the afore-mentioned aspects of

dynamic systems as the processual information.

In this article we present the Web Ontology Language for

Descriptions of Continuous Changes (WOLCC)

1

which pro-

vides vocabulary for describing the processual information.

WOLCC uses the Event Calculus (EC) [27,19] as the foun-

dational theory.We introduce concepts relevant to measure-

ments of quantities,namely units and physical dimensions,

within EC.The quantitative descriptions of processes are

given via systems of ordinary dierential equations (ODEs).

WOLCC is a general Knowledge Representation (KR) lan-

guage,which can be readily axiomatized in XML.It has been

carefully designed to work with RDF-based data models.

DLs have been extended with complex temporal constraints

based on standard temporal logics such as Computational

Tree Logic (CTL),e.g.[7].These temporal constraints

cannot model continuous temporal changes in the values of

quantities however.Several works,e.g.[29],have looked at

representing and querying validity times in RDF and OWL.

WOLCC can be used to represent knowledge about the dy-

namics in play that can explain,as well as predict,the va-

lidity times of dierent triples.

EC has previously been used in Semantic Web related re-

search for:a) designing ontologies for engineering design

processes and their environments [11],b) designing ontolo-

gies for the standard communication protocols [9],and c) au-

tomatically preparing and executing web service composi-

tions in OWL-S,by translating OWL-S to EC and utiliz-

ing its abductive planning capabilities [21].These works

1

WOLCC is probably just an ontology.It is an ontology

language only to the extent OWL is one!

are conned to the discrete-change aspects of EC,unlike

WOLCC.Besides,unlike the afore-mentioned ontologies,

WOLCC is not designed as an OWL ontology.WOLCC rep-

resents and reasons about temporal changes in RDF triples,

and the knowledge represented using WOLCC is akin to

rules described in RIF [4],where RDF triple patterns are

atomic well-formed formulas.

WOLCC concerns only with describing temporal changes,

typically represented as triggered by exogenous,endogenous

and sometimes,hypothetical actions/events.It is orthogo-

nal to the data modeling languages (DMLs) used for describ-

ing objects,quantities,properties,actions,measurements,

units,etc.,and makes a few assumptions about the underly-

ing logics of the DMLs.This is possible partly because EC

uses temporal arguments and is a reied temporal logic [24].

OWL can be used as a DML with WOLCC.Many DL ax-

ioms expressed as First-order logic (FOL) axioms can be

formulated as state constraints of EC.State constraints of a

dynamic systemare never violated,and are outside the scope

of any nonmonotonic reasoning in EC.A hybrid reasoning

approach whereby such state constraints are reasoned in-

dependently via exclusive DL reasoners could be employed.

Furthermore,in future,a combination of OWL and ECcould

be grounded in theories that reconcile OWL and rules,e.g.

[30].The results on reformulation of EC in the general the-

ory of stable models [20,19] would be of relevance there.

WOLCC can potentially be used for descriptions of natu-

ral laws and physical processes in e-science,which can be

inter-linked and linked with observations for dierent kinds

of analysis such as temporal projections (simulations),ab-

duction (inferring active processes from the data),planning,

and nding gaps in the knowledge of physical processes.

WOLCC is only a rst step towards logic-based,quanti-

tative,declarative descriptions of complex processes on the

Semantic Web.E.g.,we can only model dynamics described

using ODEs,which leaves out complex mathematical for-

malisms such as partial dierential equations and perturba-

tion theories.But success of WOLCC,either in the way

of its adoption or as creation of alternatives with the same

purpose,would provoke further research.

Representation of temporal changes,often through processes,

have been studied widely in Articial Intelligence.The rele-

vant works can be broadly classied into:a) ontologies with

process-related concepts,b) languages for unambiguous ex-

change of process-related information,c) representation of

process-related information for indexing process models,and

d) formalisms and systems that reason with descriptions of

continuous changes,which can be further classied into qual-

itative reasoning (QR) and quantitative reasoning.

We discuss the works in the rst three categories and QR in

Section 2.We cover formalisms for quantitative reasoning

in Section 3 wherein we also provide further justications

for choosing EC as the foundational theory.We describe a

running example of stacked water tanks in Section 4 and re-

view EC in Section 5.We describe a modied version of EC

to work with RDF-based descriptions of data in Section 6,

followed by presentation of the details of WOLCC in Sec-

tion 7.We conclude with a discussion in Section 8 and a

summary in Section 9.

2.ONTOLOGIES WITHAPROCESS CON-

CEPT

Most foundational ontologies,e.g.BFO,DOLCE,GFO,

SUMO and Sowa's,have process-related concepts,but they

do not provide for quantitative descriptions of behavior of

processes;see [25] for a general summary.

Process Specication Languages (PSL) [16] and Composi-

tional Modeling Language (CML) [12] are examples of lan-

guages used for exchanging process descriptions.PSL is

used for exchanging descriptions of manufacturing processes,

work- ows,etc.,which are modeled as complex ordering of

activities.Activities may be continuous or discrete,but we

are not aware of any description of continuous activities.

PSL uses branching time formalism Situation Calculus (SC)

as a foundational theory,but linear time formalisms are bet-

ter suited for representation of continuous temporal changes

(see Section 3 for a discussion).CML is a general declara-

tive modeling language for logically specifying the symbolic

and mathematical properties of the structure and behavior

of physical systems.CML does not enforce any semantic

interpretation for mathematical descriptions,which can be

qualitative or quantitative.In comparison,WOLCC is de-

ned strictly for quantitative descriptions,and the mathe-

matical denitions of derivatives and related concepts are

axiomatized in EC.Therefore,unlike CML,WOLCC has a

formal model-theoretic semantics.

Ontology languages such as PhysSys [10] and OntoCAPE

[28] oer KR layers around process models.The concepts

in those vocabularies are used for indexing library of pro-

cess models,which are numerical models interpreted only

by specic software or techniques such as specic QR tech-

niques.Processes are dened through scripts in CycL [6],

the ontology language of the Cyc project,as complex events

with temporally-ordered sub-events.But scripts can only

describe discrete processes.In the Halo project processes in

science textbooks are encoded by breaking into basic forms

which are mapped into basic problem solving methods [14].

This approach does not extend easily to complex descrip-

tions that involve,e.g.,ODEs.

So the above ontologies do not support,and cannot be ex-

tended for,declarative,quantitative descriptions of processes,

as intended for WOLCC.

3.FORMALISMS FORREASONINGABOUT

CONTINUOUS CHANGE

Reasoning about continuous temporal changes has been stud-

ied in many dierent contexts such as real time systems [17],

planning [13],and reasoning about actions and their eects

[32,27,19].They usually subscribe to one of the two,linear

or branching,time paradigms.In the linear time paradigm

time is treated as if each moment in time has unique pos-

sible future.There is a single time line,and formulas are

interpreted over the single time line.In the branching time

paradigm each moment in time may split into various possi-

ble futures.Time is tree-like,and formulas are interpreted

over the branches of a tree.

Hybrid automaton (HA) is a mathematical formalism for

model checking,or verication,of mixed discrete-continuous

systems [17].Systems are described by states and transi-

tions between the states.A state is typically associated

with ODEs.Since the values of all the properties and quan-

tities in a system have to be described for each state,the

descriptions cannot be general,and it is unwieldy to com-

bine dierent HAs which may independently describe parts

of a larger system.Planning Domain Denition Language

(PDDL) is a family of deterministic planning modeling lan-

guages and a standard modeling language for planning do-

mains.PDDL+ [13] is the most expressive language of the

PDDL family that supports mixed discrete-continuous do-

mains.The semantics of PDDL+ primitive terms is dened

by mapping into HA.

Several logic-based formalisms for reasoning about actions

and their discrete eects,e.g.SC and EC,have been ex-

tended to reason with continuous changes;see [19] for a de-

tailed summary.SC and EC are branching and linear time

paradigms respectively.We refer to SC (and EC) formalisms

that only support discrete changes as discrete SC (and EC).

Reiter [32] proposed extensions to discrete SC for reasoning

about continuous changes described via functions of time.

He introduced special kinds of actions,namely natural ac-

tions,that unlike normal actions are executed whenever they

are executable.The development of discrete EC started in

logic programming traditions,but more extensive later de-

velopments have been carried out under the classical logic

setting via circumscription.Miller and Shanahan [27] in-

corporated ODE-based descriptions of continuous changes

in the circumscriptive,discrete EC.Natural actions are de-

scribed naturally in continuous EC because all actions are

executed at the time when they are triggered.

Narratives are descriptions of occurrences of external ac-

tions.In addition to axioms about eects of actions,linear

time approaches (LTAs) require descriptions of narratives.

In contrast,branching time approaches (BTAs) are said to

deal with hypothetical action occurrences.Each branch cor-

responds to unique sequence of action occurrences.Multiple

actions may be executable in a given situation.Any subset

of those actions may execute (or occur) yielding a dierent

set of changes,and they correspond to a dierent split in

time.Time is explicit for LTAs,which is not required to be

the case for BTAs.Descriptions of discrete changes are very

similar in LTAs and BTAs.Situations are indexed by time

in LTAs,whereas they are indexed by sequence of actions in

BTAs.Thus,BTAs,unlike LTAs,have ready access to his-

tories of sequence of actions,and they are better suited for

the kinds of modeling required by PSL [16].Time has to be

explicit even for BTAs for representing continuous changes

however,and a clear distinction is made between external

(e.g.,ball rolled by an agent) and natural actions (e.g.,ball

bouncing o a wall).Crucially,the treatment of continuous

temporal changes and natural actions are similar in both

LTAs and BTAs,but more natural in LTAs.

Both continuous EC and SC have robust solutions for the

well dened problems in representation of actions and their

eects:frame problem,qualication problem,ramication

problem,and elaboration tolerance;see,e.g.,[35] for de-

Figure 1:Stacked Water Tanks,courtesy [26]

.

tails.But unlike continuous SC,continuous changes can

be described using arbitrary autonomous ODEs

2

in con-

tinuous EC.Furthermore,continuous EC can handle do-

main constraints,concurrent actions,and actions with non-

deterministic eects,etc.We have further extended contin-

uous EC for more general,concise,and elaboration tolerant

descriptions of discrete and continuous additive eects [19].

Furthermore,EC is a subset of FOL,and it complies with

the open world and non-unique name assumptions that were

considered important in the design of OWL [2].Frame prob-

lem is the problem of representing eects of actions without

explicitly representing all their non-eects,and a formal-

ism is elaboration tolerant to the extent that it is conve-

nient to modify a set of facts expressed in the formalism

to take into account new phenomena or changed circum-

stances.The frame problem is resolved in EC by encoding

default assumptions through circumscription [22] of domain-

specic axioms.The circumscription strategy is domain-

independent.Nonmonotonic reasoning via circumscription

has the advantages that it makes a clear separation be-

tween the classical aspects of a representation and the non-

monotonic aspects and it achieves elaboration tolerant so-

lution to the frame problem [33].Descriptions in WOLCC

correspond with the domain-specic axioms and are far re-

moved from the non-monotonic aspects of EC.

4.RUNNINGEXAMPLE:THESTACKEDWA-

TER TANKS

This example,similar to examples in [26,27],involves two

open-top water tanks,Tank(A) and Tank(B),that have

identical length and width.Tank(A) is suspended above

Tank(B) and has two taps in the bottom,Tap(C) and

Tap(D),that discharge water into Tank(B).Taps can be

turned on and o.In addition,water can be scooped from

Tank(A),which instantaneously reduces the level by quarter

of the height of Tank(A).We assume that scoop happens

only when water is above the mid-level.That way two simul-

taneous scoops are always allowed.To illustrate triggered

events,we assume that when Tank(B) begins to over ow

the open taps are triggered to be closed.

5.REVIEW:EVENT CALCULUS

EC is a subset of many-sorted FOL which provides prede-

ned predicate and function constants,domain-independent

2

ODE are in general of the form,d(x)=dt = f(x;t),whereas

autonomous ODE are of the form,d(x)=dt = f(x).That is,

f is independent of t in autonomous ODE [34].

Initiates(TurnOn(x);Open(x);t) (T1)

Terminates(TurnOff(x);Open(x);t) (T2)

BreaksPartBy(Scoop(x);Level(A);t;un;

V alue(Height(A);t;un)

4

) (T3)

Happens(Scoop(x);t) !V alue(Level(A);t;un)

V alue(Height(A);t;un)

2

(T4)

HoldsAt(Open(x);t) !PartV alue((Level(A));t;Emptying(A;x)

;un;1 K V alue(Level(A);t;un)) (T5)

HoldsAt(Open(x);t) !PartV alue((Level(B));t;Filling(B;x)

;un;K V alue(Level(A);t;un)) (T6)

:9x:HoldsAt(Open(x);t) !V alue((Level(A));t;un) = 0 (T7)

:9x:HoldsAt(Open(x);t) !V alue((Level(B));t;un) = 0 (T8)

[HoldsAt(Open(x);t) ^ V alue(Level(B);t;un) V alue(Height(B);t;un) = 0] !Happens(TurnOff(x);t) (T9)

Breaks(TurnOn(x);(Level(y));t) (T10)

Breaks(TurnOff(x);(Level(y));t) (T11)

UNA[TurnOn;TurnOff;Scoop] ^ UNA[Open;Filling;Emptying] ^UNA[Level;Height;] (T12)

Figure 2:Axiomatic description of the stacked tanks example.

axioms that dene their semantics,and a domain-independent

default reasoning strategy.Dynamic domains are axioma-

tized through domain-specic axioms using the predened

predicate and function symbols (new symbols can also be

used).The review follows the denitions in [27,19],ex-

cept that we introduce the concepts of physical dimensions

and units for measurement of quantities (in addition to their

magnitudes).The domain-independent axioms and default

reasoning strategy are given in [18,19,27].

The following sorts are used:A (Actions),F (Fluents),T

(Times),P (Parameters),R (Real),PX (DCA sort),U

(Units),PD (Physical Dimension).T is interpreted as non-

negative real numbers.PX is a subsort of F.PD and U

are new sorts.Relations,properties,and qualities (hence-

forth,just relations) are denoted by uents and quantities

are denoted by parameters.

The following function symbols are used,V alue:P T

U 7!R,Dimension:(P [U) 7!PD,:P 7!P,and Next:

T 7!T.V alue((P);T;Un) represents the numerical value

of rst derivative of parameter P at time T in units of Un.

Quantities and units are associated with dimensions as in

EngMath ontology [15].We assume the conditions for con-

sistent association of units with quantities (they have the

same physical dimension),algebraic operations over quanti-

ties,and unit conversions are dened separately.

The following predicate symbols are used:Breaks,BreaksP-

artBy,BreaksTo,Continuous,Differentiable,Happens,

HoldsAt,InitiallyFalse,InitiallyTrue,Initiates,LeftCo-

ntinuous,PartV alue,RightLimit,and Terminates.

An axiomatization of the example domain is given in Fig-

ure 2,which is similar to that in [27],but additive eects are

described dierently,using BreaksPartBy and PartV alue.

The variable terms start with lower case and constants start

with upper case.The following constants symbols are used:

TurnOn(C),TurnOn(D),TurnOff(C),TurnOff(D),Sc-

oop(1),and Scoop(2) of sort A,Open(C) and Open(D) of

sort F,Emptying(A;C),Emptying(A;D),Filling(B;C),

and Filling(B;D) of sort PX,and Level(A),Level(B),

Height(A),and Height(B) of sort P.

Some uents are directly aected by actions,while others

are not.The former are called frame uents.And,the

latter are called non-frame uents,and they are also not

assigned any initial values.Open(x) are used as frame u-

ents,whereas Emptying(x;y) and Filling(x;y) are used as

non-frame uents.

By default,the frame uents are persistent and parame-

ters are continuous.The break in the persistence for u-

ents is described using Initiates or Terminates whereas

change in the continuity for parameters is described using

BreaksPartBy,BreaksTo and Breaks.The changes take

eect immediately after the action occurrences.

Axiom(T1) states that Open(x) becomes true if TurnOn(x)

occurs.Similarly,Axiom (T2) states that Open(x) becomes

false if TurnOff(x) occurs.Axiom (T3) states that each

Scoop(x) reduces the Level(A) by a quarter immediately

after it occurs.By the semantics of BreaksPartBy,when

multiple Scoop(x) actions occur simultaneously their eects

are summed implicitly.Also,Scoop(x) implicitly causes dis-

continuities in Level(A),(Level(A)) and higher derivatives.

Axiom (T4) describes an action precondition,which acts as

a constraint.It states that the Level(A) must be at least

half the Height(A) whenever Scoop(x) happens.

Let K be the constant of proportionality between the level

of water in Tank(A) and the ow through either of the taps

when open.Axiom (T6) describes the rate of reduction of

Level(A) when one of the taps is open,by an ODE of the

form d(l)=dt = K l where l denotes the level of wa-

ter in A.Likewise,Axiom (T7) describes the rate of lling

for Tank(B).By the semantics of PartV alue,when mul-

tiple taps are open their rates are summed implicitly.The

arguments for disambiguating contributions (DCAs) are un-

derlined.When the rates of out ows from dierent taps are

the same Emptying(A;x) and Filling(B;x) uniquely iden-

tify the additive eects from dierent sources.(Level(x))

is referred to as an additive quantity,as it can potentially

be subject to direct continuous,additive eects.

The value of additive quantities when not subject to any

additive eect must be specied explicitly (it is not assumed

to be zero).Axioms (T7) and (T8) give the rates of change

of levels of the tanks when none of the taps are open.

Axiom (T9) describes that TurnOff(x) is triggered when

Tank(B) begins to over ow.

Axioms (T10) and (T11) assert that turning on or o taps

potentially causes discontinuity in the rates of change of lev-

els of the tanks.Explicit enumeration of all potential dis-

continuities in quantities caused by an action is important

for eliminating anomalous models.It indirectly enumerates

all quantities that remain continuous after the occurrence

of the action.In its absence anomalous models where,e.g.,

Level(A) instantaneously becomes zero (from a value signif-

icantly greater than zero) when one of the taps is closed can

be deduced [27].

Finally,uniqueness-of-names must be expressed explicitly.

Axiom (T12) expresses that using the UNA[:::] notation

[27],which states that functions in the arguments are injec-

tions and have disjoint ranges.

6.EVENTCALCULUS ANDRDFDESCRIP-

TIONS

The semantics of WOLCCdescriptions is given via mappings

into EC,and a modied version of EC is devised to work

with RDF-based descriptions.Often relations,quantities,

and actions/events (henceforth,just actions or events) de-

noted respectively by sorts P,F,and A in EC have param-

eterized denotations,e.g.Level(A),Open(C),TurnOn(C).

Such constants would be expressed in RDF through RDF

statements about a resource.E.g.,a turn on action,nsa:Tur-

nOnActionC,may be described,in Turtle syntax [8],as {nsa:

TurnOnActionC a nst:TurnOnAction;nst:hasObject nsa:

TapC.}.In general relations,quantities,and actions would

be denoted as RDF resources and optionally,associated with

descriptions in one or more RDF statements.

We modify EC to handle RDF-style descriptions as follows.

Firstly,a new abstract sort corresponding to the space of

RDF triples and a ternary bijective function T that maps

RDF triples to constants in that sort are introduced.

T(?s

1

;?p

1

;?o

1

) =T(?s

2

;?p

2

;?o

2

)

![?s

1

=?s

2

^?p

1

=?p

2

^?o

1

=?o

2

]

IRIs and typed literals are treated as constants,whereas

variable names begin with'?'.IRIs denoting quantities,re-

lations,and actions are assumed to be disjoint.The rst

modication involves reication (see,e.g.[35]).Secondly,

RDF statements themselves are subject of change.Partic-

ularly RDF statements about relations and quantities are

considered uents,and their truth values are checked us-

ing HoldsAt.RDF statements about values or derivatives

of quantities and actions are not considered uents though.

Thirdly,RDF statements describing the values and deriva-

tives of quantities are not used directly and they must be

referred to using the V alue and as originally.

Finally,a new predicate constant HoldsAt

A

is introduced to

check the truth values of statements about actions.Holds-

At

A

(T(S;P;O);Ti) expresses that fS;P;Og is true at time

Ti.Such atoms will usually occur in conjunction with atoms

of the form Happens(A;Ti) such that fS;P;Og belongs to

the description of A.Thus,neither any independent ax-

ioms dening the semantics of HoldsAt

A

nor any default

assumptions regarding HoldsAt

A

relations are required.

3

7.WOLCC

Ahybrid systemof mixed discrete-continuous changes is per-

ceived to progress over time as a sequence of states and ac-

tions.A state is characterized as a period where the truth

values of uents are xed and the values of quantities are ei-

ther xed or subject to continuous changes dened by xed

set of equations.The xed aspects of a state may be dis-

turbed by external actions,which may cause discrete change

in the values of uents and/or quantities,or when the sys-

tem reaches a boundary for some equations.An event may

be triggered when the system reaches a boundary condition,

which may cause further changes.Continuous changes can

interact in various ways,e.g.multiple changes active concur-

rently may aect the same quantities or one set of changes

may trigger,and impede/accelerate,another set of changes.

The notion of a state is abstract here (unlike HA e.g.) in

that changes are described in terms of a select few uents

and quantities.Multiple descriptions of changes can be con-

joined to describe a system,which then consists of the union

of the uents and quantities used in those descriptions.

We present the vocabulary in four parts that cover descrip-

tions of a) quantities,relations,and actions (Section 7.1),

b) direct eects of actions (Section 7.2),c) continuous changes

and relationship between quantities (Section 7.3),and d) data

modeling constraints (Section 7.4).

The EBNF notation

4

of the presentation syntax is given in

Figures 3,5,7,and 9 respectively.The top non-terminal

element,DOMAINDESCRIPTION,is described below.It refers

to the dierent categories of domain-specic axioms that can

be specied using WOLCC.The categorization is inspired

fromMueller's [31] pedagogic categorization of axioms about

discrete changes (and trajectories).

DOMAINDESCRIPTION::= (ACTIONDESCRIPTIONCONSTRAINT

| ADDITIVECONTINUOUSCHANGE

| ALGEBRAICEQUATIONDECLARATION

| BREAKINCONTINUITY | CONSTANTACTIONDESCRIPTION

| CONSTANTQTYDESCRIPTION | CONSTANTRELATION

| DIRECTEFFECTOFACTION | EFFECTSDEPENDENCY

| EVENTTRIGGER | NONADDITIVECONTINUOUSCHANGE

| OBSERVATION | OCCURRENCE

| OCCURRENCEPRECONDITION

| QTYDESCRIPTIONSCONSTRAINT | RELATIONSCONSTRAINT)*

The semantics of these elements is dened via mappings

into domain-specic axioms of EC.The mappings are given

3

Action descriptions related constraints can be expressed as

data constraints in WOLCC (Section 7.4).

4

EBNF notation:http://www.w3.org/TR/2004/REC-

xml11-20040204/#sec-notation

ACTIONDECLARATION::=`Action'`('VARORIRI DESCRIPTION?`)'

ALGEBRAICVALUE::= (* Algebraic-expression-over-reals-qtys-VALUEVAR *)

CONSTANTACTIONDESCRIPTION::=`Action'`('IRIref DESCRIPTION`)'

CONSTANTQTYDESCRIPTION::=`Quantity'`('IRIref DESCRIPTION`)'

CONSTANTRELATION::=`Relation'`('TriplesBlock`)'

DERIVATIVEQTY::=`Derivative'`('VARORIRI ORDER QTYDECLARATION VALUEOFQTYREF*`)'

DESCRIPTION::=`Description'`('TriplesBlock`)'

OBSERVATION::= (`Neg')?`HoldsAt'`('RELATION TIME`)'

|`ValueAt'`('QTYDECLARATION TIME UNIT VALUEDECLARATION`)'

OCCURRENCE::=`Happens'`('TIME ACTIONDECLARATION`)'

ORDER::=`Order'(INTEGER)

QTYDECLARATION::=`Quantity'`('VARORIRI DESCRIPTION?VALUEOFQTYREF*`)'| DERIVATIVEQTY

RELATION::=`Relation'`('('Exists'Var*)?TriplesBlock`)'

TIME::=`Time'((DOUBLE UNIT) |'?t')

UNIT::=`Unit'(VARORIRI |'?un')

VALUEDECLARATION::=`HasValue'`('QTYDECLARATION* (`Value'`('ALGEBRAICVALUE`)')`)'

VALUEOFQTYREF::=`QValueRef'`('QVALUEVAR TIME UNIT`)'

VALUEVAR::= Var

VARORIRI::= Var | IRIref

DOUBLE,INTEGER,IRIref,TriplesBlock,Var as dened in SPARQL Grammar [5].

Figure 3:Presentation syntax for declaring quantities,relations,and actions.

using the function,with help of an auxiliary function .

(Ele) denes the mapping for element Ele,and optional

arguments are used to pass contextual information such as

time.( is dened later.) The mappings for the rst three

set of elements is shown in Figures 4,6,and 8 respectively,

while for the fourth are given in [18].

Domain-specic axioms of EC are logic axioms,and RIF-

FLD [4] could be used for sharing web-ized domain descrip-

tions.However,we dene a new vocabulary for the follow-

ing reasons:A) WOLCC abstracts away some nuances of

the underlying logic for the domain experts,by introducing

additional vocabulary e.g.B) EC imposes little restrictions

on how EC constants are combined,but only a subset of ax-

ioms which have been deemed useful are allowed in WOLCC.

Controlled generation of axioms is also ecient for designing

reasoners.C) Because descriptions and semantics are sep-

arate,WOLCC descriptions can potentially be used with

other formalisms such as SC and HA.

As stated earlier,WOLCC is orthogonal to DMLs but im-

poses a few restrictions on DMLs.We discuss those restric-

tions and descriptions of data constraints in Section 7.4.The

XML serialization is discussed brie y in Section 7.5.

7.1 Quantities,Relations,Actions

Relations (and qualities,properties, uents) exist in all-or-

none (e.g.,tap is either on or o),whereas quantities admit

of degrees (e.g.,rate at which water ows through the tap

can take a range of real values) [15].Only scalar quantities

are supported in the current version.Vector quantities can

be expressed in terms of scalar quantities.E.g.,a three

dimensional velocity vector can be decomposed into three

scalar quantities for a particular choice of reference.

RELATIONs are usually denoted by SPARQL BGP-like triple

patterns (for obvious reasons).E.g.,a variable open tap can

be declared as {?x a nst:Tap,nst:Open.}.

5

Quantities and actions are denoted by IRIs or variable sym-

bols and optionally,associated with RDF statements.E.g.,

height of a tank can be declared as

Quantity(?q

Description({?y a nst:Tank;nst:hasQuantity?q.

?q nst:measureOf nst:Height.})

QValueRef(?qv Time(?t) Unit(nst:Meter))).

VALUEOFQTYREF can be used to create a variable reference to

the value of a quantity,in a given unit,at a given time.E.g.,

?qv = Value(?q,?t,nst:Meter).The rst derivative of

the height of the tank can be declared as

Derivative(?dq Order(1) Quantity(?q

Description({?y a nst:Tank;nst:hasQuantity?q.

?q nst:measureOf nst:Height.}))

QValueRef(?qdv Time(?t) Unit(nst:MeterPerSecond))).

E.g.,an act of turning on a variable tap can be denoted as

Action(?a Description({?x a nst:Tap.

?a a nst:TurnOnAction;nst:hasObject?x.})).

Some example CONSTANTACTIONDESCRIPTIONs,CONSTANTQ-

TYDESCRIPTIONs,and CONSTANTRELATIONs are:

Action(nsa:TurnOnActionC Description(

{ nsa:TurnOnActionC a nst:TurnOnAction;

nst:hasObject nsa:TapC.} ))

Quantity(nsa:HeightA Description(

{ nsa:TankA nst:hasQuantity nsa:HeightA.

nsa:HeightA nst:measureOf nst:Height.}))

Relation({ nsa:TankA a nst:Tank.}).

E.g.,OBSERVATIONs that tap C is not open initially and the

height of tank A is 2 meters can be declared as:

5

We create new concepts,properties,and individual names

as needed without explicitly declaring an ontology.The frag-

ment identiers are assumed to be self explanatory.nst and

nsa are used as namespaces for Tbox and Abox respectively.

(ACTIONDECLARATION;t):= HoldsAt

A

((DESCRIPTION);t)

(ALGEBRAICVALUE):= (* Replace-any-qty-by-EC-notation-V alue(qty;?t;?un) *)

(CONSTANTACTIONDESCRIPTION):= HoldsAt

A

((DESCRIPTION);?t)

(CONSTANTQTYDESCRIPTION):= HoldsAt((DESCRIPTION);?t)

(CONSTANTRELATION):= HoldsAt((TriplesBlock);?t)

(DERIVATIVEQTY,t):= (QTYDECLARATION;t) ^

V

(VALUEOFQTYREF;VARORIRI)

^ [(VARORIRI) =

(ORDER)

((QTYDECLARATION))]

(DESCRIPTION):= TriplesBlock

(OBSERVATION):= HoldsAt(RELATION;TIME) j:HoldsAt(RELATION;TIME)

j [(QTYDECLARATION;TIME) ^ (VALUEDECLARATION;TIME;?nv)

^ V alue((QTYDECLARATION);TIME;UNIT) =?nv]

(OCCURRENCE):= (ACTIONDECLARATION;(TIME)) ^ Happens((ACTIONDECLARATION);(TIME))

(ORDER):= INTEGER

(QTYDECLARATION;t):= HoldsAt((DESCRIPTION);t) ^

V

((VALUEOFQTYREF);VARORIRI)

(RELATION;t):= HoldsAt((TriplesBlock);t)

(TIME):= (double-in-units-of-seconds) j?t

(UNIT):= (VARORIRI) j?un

(VALUEDECLARATION;t;?nv):=

V

(QTYDECLARATION;t) ^?nv = (ALGEBRAICVALUE)

(VALUEOFQTYREF;qty):= (QVALUEVAR) = V alue(qty;(TIME);(UNIT))

(VALUEVAR):= Var

(VARORIRI):= Var j IRIref

Figure 4:Denition of function for the elements used for declaring quantities,relations,and actions.

Neg HoldsAt({ nsa:TapC a nst:Open.} Time(0))

ValueAt( Quantity(nsa:HeightA)

Time(?t) Unit(nst:Meter) HasValue(Value(2)))

And OCCURRENCE of Tap C turning on at 20s can be declared

as:Happens(Time(20) Action(nsa:TurnOnActionC)).

The TIME is assumed to be in the units of Seconds.DMLs are

responsible for uniqueness-of-names axioms (Section 7.4).

(x) where x is an ACTIONDECLARATION,QTYDECLARATION,

or DCA returns the VARORIRI that identify respectively the

action,quantity,or DCA in x.

The short-hand notation HoldsAt(TriplesBlock;Ti) stands

for

n

V

i=1

HoldsAt(T(S

i

;P

i

;O

i

);Ti) where TriplesBlock is a

collection of n triples,{S

i

,P

i

,O

i

},for some n 1.The

short-hand notation HoldsAt(RELATION;Ti) stands for 9Var

:HoldsAt(TriplesBlock;Ti) where zero or more Vars are

existentially quantied.The short-hand notations HoldsAt

A

(RELATION;Ti),Initiates(Act;RELATION;Ti),and Terminat-

es(Act;RELATION;Ti) are dened similarly.

(QTYDECLARATION;Ti) and (ACTIONDECLARATION;Ti) for

the quantity and action declarations above are given below:

[HoldsAt(T(?y;rdf:type;nst:Tank);Ti) ^HoldsAt(T(?y;

nst:hasQuantity;?q);Ti) ^HoldsAt(T(?q;nst:measureOf;

nst:Height);Ti) ^?qv = V alue(?q;?t;nst:Meter)],

[HoldsAt(T(?y;rdf:type;nst:Tank);Ti) ^HoldsAt(T(?y;

nst:hasQuantity;?q);Ti) ^HoldsAt(T(?q;nst:measureOf;

nst:Height);Ti)] ^?dq =

1

(?q) ^?qdv = V alue(?dq;?t;

nst:MeterPerSecond)],

[Happens(?a;Ti) ^HoldsAt

A

(T(?x;rdf:type;nst:Tap);Ti)

^ HoldsAt

A

(T(?a;rdf:type;nst:TurnOnAction);Ti) ^

HoldsAt

A

(T(?a;nst:hasObject;?x);Ti)].

Finally,HoldsAt((RELATION);t) for the relation declared

above is given below:

[HoldsAt(T(?x;rdf:type;nst:Tap);t) ^ HoldsAt(T(?x;

rdf:type;nst:Open);t)].

7.2 Direct Effects of Actions

DIRECTEFFECTOFACTIONs in Axioms (T1) and (T3) can be

declared as:

Effect(

Action(?a Description({?a a nst:TurnOnAction;

nst:hasObject?tap.})

FluentInitiation({?tap a nst:OpenTap.}))

Effect(

Action(?a Description({?a a nst:ScoopAction.})

AdditiveChangeInValue(

Quantity(nsa:LevelA)

Unit(?un)

HasValue(

Quantity(nsa:HeightA)

Value(-1 nsa:HeightA=4))))

The water tank example does not contain any eect depen-

dencies.Consider the following.If an object o is placed

inside another object x,which itself is inside another object

y,then o is also placed inside y.

[HoldsAt(In(x;y);t) ^ Initiates(PlaceIn(o;x);In(o;x);t)]

!Initiates(PlaceIn(o;x);In(o;y);t)

The above EFFECTSDEPENDENCY can be declared as:

ConstraintsOnEffectsOfActions(

Action(?a Description({?a a nst:PlaceInAction;

nst:targetObject?o;

ALGEBRAICCONSTRAINT::= (* Algebraic-inequality-or-equality-over-reals-qtys-VALUEVAR *)

CONDITION::= CONSTRAINTONSTATE?('ConditionOnCooccurrence'

`('CONDITIONONCOOCCURRENCE`)')?

CONDITIONONCOOCCURRENCE::= CONNECTIVE`('CONDITIONONCOOCCURRENCE*`)'

| QUANTIFIER`('CONDITIONONCOOCCURRENCE`)'

|`Neg'CONDITIONONCOOCCURRENCE | ACTIONDECLARATION

CONDITIONONQTY::= QTYDECLARATION+ (`ValueConstraint'`('ALGEBRAICCONSTRAINT`)')

CONDITIONONRELATION::= CONNECTIVE`('CONDITIONONRELATION*`)'

| QUANTIFIER`('CONDITIONONRELATION`)'

|`Neg'CONDITIONONRELATION | RELATION

CONSTRAINTONSTATE::=`ConstraintOnState'`('CONDITIONONRELATION?CONDITIONONQTY?`)'

DIRECTEFFECTOFACTION::=`Effect'`('IRIref?ACTIONDECLARATION (FLUENTINITIATION

| FLUENTTERMINATION | QTYNEWVALUE | QTYADDITIVECHANGEINVALUE)`)'

EFFECTSDEPENDENCY::=`ConstraintOnEffectsOfActions'`('IRIref?ACTIONDECLARATION

CONDITION`Implies'`('FLUENTINITORTERM FLUENTINITORTERM`)'`)'

FLUENTINITORTERM::=`FluentInitiation'`('RELATION`)'|`FluentTermination'`('RELATION`)'

FLUENTINITIATION::=`FluentInitiation'`('RELATION CONDITION`)'

FLUENTTERMINATION::=`FluentTermination'`('RELATION CONDITION`)'

OCCURRENCEPRECONDITION::=`OccurrencePrecondition'`('ACTIONDECLARATION CONSTRAINTONSTATE`)'

QTYADDITIVECHANGEINVALUE::=`AdditiveChangeInValue'`('QTYDECLARATION UNIT VALUEDECLARATION

CONDITION`)'

QTYNEWVALUE::=`NewValue'`('QTYDECLARATION UNIT VALUEDECLARATION CONDITION`)'

CONNECTIVE,QUANTIFIER as dened in RIF-FLD [4].

Figure 5:Presentation syntax for describing the direct eects of actions.

nst:destination?x.})

ConstraintOnState({?x nst:in?y.})

Implies(

FluentInitiation({?o nst:in?x.})

FluentInitiation({?o nst:in?y.})))

OCCURRENCEPRECONDITION in Axiom (T4) can be declared:

OccurrencePrecondition(

Action(?a Description({?a a nst:ScoopAction.})

ConstraintOnState(

Quantity(nsa:LevelA) Quantity(nsa:HeightA)

ValueConstraint(nsa:LevelA (nsa:HeightA=2)))).

The short-hand notation HoldsAt(CONDITIONONRELATION;Ti)

stands for the formula obtained by combining HoldsAt(Tripl-

esBlock;Ti) using connectives and quantiers as Triples-

Blocks (or RELATIONs) in the TriplesBlockFormula are com-

bined.Similarly,the short-hand notation Happens(CONDITI-

ONONCOOCCURRENCE;Ti) stands for the formula obtained by

combining [(ACTIONDECLARATION;Ti) ^Happens((ACTION-

DECLARATION);Ti)] as ACTIONDECLARATIONs in the CONDI-

TIONONCOOCCURRENCE are combined.

7.3 Continuous Change

ADDITIVECONTINUOUSCHANGE in Axiom(T5) can be declared:

AdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelA))

Unit(?un)

ActiveWhen({?x a:Tap,:Open.})

DisambiguatedBy(?y {?y a nst:EmptyingTank;

nst:hasTank nsa:TankA;

nst:hasTap?x.})

HasValue(

Quantity(nsa:LevelA)

Value(-1 K nsa:LevelA))).

DCAs are denoted as instances of RDF concepts which de-

note uent types,e.g.nst:EmptyingTank and nst:FillingTank.

The water tanks example does not contain algebraic equa-

tions.Consider the following.If a block b

1

is on top of

another block b

2

then the friction force applied by b

2

on b

1

(Fr(b

1

;b

2

)) is equal and opposite to that by b

1

on b

2

.

Holds(On(b

1

;b

2

);t) !

V alue(Fr(b

1

;b

2

);t) = 1 V alue(Fr(b

2

;b

1

);t)

The above ALGEBRAICEQUATIONDECLARATION can be declared:

AlgebraicRelationship(

Quantity(?f1 Description({?f1 a nst:FrictionForce;

nst:forceBy?b2;nst:forceOn?b1.}))

Quantity(?f2 Description({?f2 a nst:FrictionForce;

nst:forceBy?b1;nst:forceOn?b2.}))

Equation(?f1 = -1 ?f2)

ConstraintOnstate({?b1 nst:on?b2.})).

BREAKINCONTINUITY in Axiom (T10) can be declared as:

BreakInContinuity(

Action(?a Description({?a a nst:TurnOnAction.}))

Derivative(

?dq Order(1)

Quantity(?q Description({?x a nst:ContainedLiquid;

nst:hasQuantity?q.

?q nst:measureOf nst:Level.}))).

EVENTTRIGGER in Axiom (T9) can be declared as:

EventTrigger(

Action(?a Description({?x a?Tap.

?a a?nst:TurnOffAction;nst:hasObject?x.}))

ConstraintOnstate(

{?x a nst:Open.}

Quantity(nsa:LevelB) Quantity(nsa:HeightB)

ValueConstraint((nsa:LevelB - nsa:HeightB) = 0)))

(ALGEBRAICCONSTRAINT):= (* Replace-any-qty-by-EC-notation-V alue(qty;?t;?un) *)

(CONDITION;t):= (CONSTRAINTONSTATE;t) ^ (CONDITIONONCOOCCURRENCE;t)

(CONDITIONONQTY;t):=

V

(QTYDECLARATION;t) ^

V

(ALGEBRAICCONSTRAINT)

(CONDITIONONRELATION;t):= HoldsAt(CONDITIONONRELATION;t)

(CONSTRAINTONSTATE;t):= (CONDITIONONRELATION;t) ^ (CONDITIONONQTY;t)

(DIRECTEFFECTOFACTION;t):= (FLUENTINITIATION;t;ACTIONDECLARATION)

j (FLUENTTERMINATION;t;ACTIONDECLARATION) j (QTYNEWVALUE;t;ACTIONDECLARATION)

j (QTYADDITIVECHANGEINVALUE;t;ACTIONDECLARATION)

(EFFECTSDEPENDENCY):= [(ACTIONDECLARATION;?t) ^ (CONDITION;?t)

^ (FLUENTINITORTERM;?t;(ACTIONDECLARATION))] !(FLUENTINITORTERM;?t;(ACTIONDECLARATION))

(FLUENTINITORTERM;t;Act):= Initiates(Act;RELATION;t) j Terminates(Act;RELATION;t)

(FLUENTINITIATION;t;ActDecl):= [(ActDecl;t) ^ (CONDITION;t)] !Initiates((ActDecl);RELATION;t)

(FLUENTTERMINATION;t;ActDecl):= [(ActDecl;t) ^ (CONDITION;t)] !Terminates((ActDecl);RELATION;t)

(OCCURRENCEPRECONDITION;t):= [(ACTIONDECLARATION;t) ^ Happens((ACTIONDECLARATION);t)]

!(CONSTRAINTONSTATE;t)

(QTYADDITIVECHANGEINVALUE;t;ActDecl):= [(ActDecl;t) ^ (QTYDECLARATION;t) ^ (CONDITION;t)

^ (VALUEDECLARATION;t;?nv)] !BreaksPartBy((ActDecl);t;(UNIT);?nv)

(QTYNEWVALUE;t;ActDecl):= [(ActDecl;t) ^ (QTYDECLARATION;t) ^ (CONDITION;t) ^ (VALUEDECLARATION;t;?nv)]

!BreaksTo((ActDecl);t;(UNIT);?nv)

Figure 6:Denition of function for the elements used for dening the direct eects of actions.

ACTIVECONDITION::=`ActiveWhen'`('CONDITIONONRELATION?CONDITIONONQTY?`)'

ADDITIVECONTINUOUSCHANGE::=`AdditiveContinuousChange'`('IRIref QUANTITYDECLARATION UNIT

VALUEDECLARATION DCA ACTIVECONDITION INSIDEBOUNDARY?`)'

ALGEBRAICEQUATION::= (* Algebraic-equation-over-reals-qtys-VALUEVAR *)

ALGEBRAICEQUATIONDECLARATION::=`AlgebraicRelationship'`('QUANTITYDECLARATION+

(`Equation'`('ALGEBRAICEQUATION`)') CONSTRAINTONSTATE?`)'

BREAKINCONTINUITY::=`BreakInContinuity'`('IRIref ACTIONDECLARATION QTYDECLARATION CONDITION`)'

DCA::=`DisambiguatedBy'`('VARORIRI RELATION`)'

EVENTTRIGGER::=`EventTrigger'`('IRIref ACTIONDECLARATION CONDITION`)'

INSIDEBOUNDARY::=`WithinBoundaryWhen'`('CONDITIONONQTY`)'

NONADDITIVECONTINUOUSCHANGE::=`NonAdditiveContinuousChange'`('IRIref QUANTITYDECLARATION+

(`ODE'`('ODE`)') ACTIVECONDITION INSIDEBOUNDARY?`)'

ODE::= (* ordinary-dierential-equation-over-qtys *)

Figure 7:Presentation syntax for describing continuous changes.

NONADDITIVECONTINUOUSCHANGE in Axiom (T7) can be de-

clared as:

NonAdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelA))

ActiveCondition((Neg EXIST?x ({?x a nst:Tap,

nst:Open.})))

ODE(?dq = 0))

7.4 Working with Data Modeling Languages

Since EC is FOL-based,a DML with standard FO seman-

tics,e.g.OWL 2 with Direct Semantics [2] and RIF-BLD

[4],can be readily used.Axioms of a DML can be viewed

as either inferential or imposing constraints.EC makes a

distinction between frame and non-frame RDF statements

(Section 5).Any inferences for frame statements can only

be expressed via EFFECTSDEPENDENCY (Section 7.2).Rest of

the axioms,including uniqueness-of-name axioms and func-

tionality constraints,can be expressed as data constraints

in WOLCC.The constraints on actions are distinctly iden-

tied as they are interpreted via HoldsAt

A

,instead of usual

HoldsAt.

7.5 XML Representation

An XML serialization of descriptions in WOLCC follows

straightforwardly from the presentation syntax.The con-

tent markup of MathML [1] can be used for serializing math

formulas.We are not aware of any standards for XML se-

rialization of RDF triple patterns with variables.We rst

undo short-hand notations used in TriplesBlocks.E.g.,{?x

nst:hasValue 10,20.} is expanded into {?x nst:hasValue

10.?x nst:hasValue 20.}.Then subject,predicate,

and object are marked inside a triple-pattern element.

E.g.,the rst triple is marked as:

<triple-pattern>

<sub><Var>X</Var></sub>

<pred><Const type="&rif;iri">&xyz;hasValue

</Const></pred>

<obj><Const type="&xsd;Integer">10</Const></obj>

</triple-pattern>

8.DISCUSSION

There has been very little work in the literature towards

building reasoners for EC-like formalisms that combine logi-

cal and mathematical representations,especially ODE-based

descriptions,even in domains such as Constraint Program-

ming (see,e.g.,[35]).The complexity of reasoning about EC

(ACTIVECONDITION;t):= (CONDITIONONRELATION;t) ^ (CONDITIONONQTY;t)

(ADDITIVECONTINUOUSCHANGE):= (i) [(QUANTITYDECLARATION;?t) ^ (VALUEDECLARATION;?t;?nv)

^ (ACTIVECONDITION;?t) ^ (INSIDEBOUNDARY;?t)]

!9(DCA)[PartV alue((QUANTITYDECLARATION);?t;(DCA);(UNIT);?nv) ^ (DCA;?t)]

(ii) 9?q;?un;?vPartV alue(?q;?t;(DCA);?un;?v) !(DCA;?t)

(ALGEBRAICEQUATION):= (* Replace-any-qty-by-EC-notation-V alue(qty;?t;?un) *)

(ALGEBRAICEQUATIONDECLARATION):= [(CONSTRAINTONSTATE;?t) ^

V

(QUANTITYDECLARATION;?t)]

!(ALGEBRAICEQUATION)

(BREAKINCONTINUITY):= [(ACTIONDECLARATION;?t) ^ (QTYDECLARATION;?t) ^ (CONDITION;?t)]

!Breaks((ACTIONDESCRIPTION;?t);(QTYDECLARATION);?t)

(DCA;t):= HoldsAt(RELATION;?t)

(EVENTTRIGGER):= [(CONDITION;?t) ^ (ACTIONDECLARATION;?t)] !Happens((ACTIONDECLARATION);?t)

(INSIDEBOUNDARY;?t):= (CONDITIONONQTY;?t)

(NONADDITIVECONTINUOUSCHANGE):= [

V

(QUANTITYDECLARATION;?t) ^ (ACTIVECONDITION;?t) ^ (INSIDEBOUNDARY;?t)]

!(ODE)

(ODE):= (* Replace-any-qty-by-EC-notation-V alue(qty;?t;?un) *)

Figure 8:Denition of function for the elements used for describing continuous changes.

ACTIONDESCRIPTIONSCONSTRAINT::=`ConstraintOnActionDescriptions'`('

IMPLIESCONSTRAINT | EQUIVALENTCONSTRAINT | SAME | DIFFERENT`)'

QTYDESCRIPTIONSCONSTRAINT::=`ConstraintOnQuantityDescriptions'

`('IMPLIESCONSTRAINT | EQUIVALENTCONSTRAINT | SAME | DIFFERENT`)'

Figure 9:The top elements for describing the data constraints.The full presentation syntax is given in [18].

theories increases with features like non-deterministic event

occurrences and non-deterministic eects of actions,inde-

pendent of the complexities of DMLs.Features like non-

deterministic class inclusions and inferring new individuals

in OWL further increase the complexity of reasoning for

WOLCC.We have not let the lack of implementation for

EC come in way of designing WOLCC,and focused just at

expressiveness and soundness.We are implementing a pro-

totypical temporal projection reasoner for EC by combining

logical reasoning,via Answer-set solver DLVHEX

6

,and nu-

merical solving.Going forward,dierent proles of WOLCC

with increasing complexities can be dened similar to OWL

2 proles [3].

We have provided motivations for a WOLCC-like language

and justications for dening a new language (because of

absence of WOLCC-like languages in the literature) and

choosing EC as the foundational theory.Furthermore,we

have considered expressivity,generality (or non-specicity),

and elaboration tolerance (or extendability) while designing

WOLCC.Other forms of evaluations for usability,shareabil-

ity,reusability,modularity,synergy with other formalisms

like HA and SC,benchmarks,etc.are foreseeable.

9.SUMMARY

We presented a web ontology language for descriptions of

continuous changes,namely WOLCC,that provides vocabu-

lary for expressing changes in temporal properties and quan-

tities,causative actions,quantitative descriptions of contin-

uous changes using simultaneous ordinary dierential equa-

tions (ODEs),triggered events,et al.WOLCC is mainly

concerned with descriptions of changes,and it is orthogo-

nal to the data modeling languages concerned with descrip-

6

http://www.kr.tuwien.ac.at/research/systems/dlvhex/

tions of properties,quantities,and actions.Event Calcu-

lus (EC) is used as the foundational theory for WOLCC

because it is the most advanced logic-based formalism for

ODE-based descriptions of continuous changes,and its lin-

ear time paradigm is ideally suited,especially for descrip-

tions of changes happening in natural,physical processes.

We believe WOLCC can contribute towards ontologies for

natural laws and physical processes.But WOLCC is only a

rst step towards logic-based,quantitative,declarative de-

scriptions of complex processes,as complex processes are

captured via more complex mathematical formalisms such

as partial dierential equations and perturbation theories

e.g.

10.ACKNOWLEDGMENTS

This work is supported by the Tetherless World Constella-

tion at Rensselaer Polytechnic Institute.

11.REFERENCES

[1] Mathematical Markup Language (MathML) Version

2.0 (Second Edition).W3C Recommendation 21

October 2003.http://www.w3.org/TR/MathML2/.

[2] OWL 2 Web Ontology Language Primer.W3C

Recommendation 27 October 2009.

http://www.w3.org/TR/owl2-primer/.

[3] OWL 2 Web Ontology Language Proles W3C

Recommendation 27 October 2009.

http://www.w3.org/TR/owl2-proles/.

[4] RIF Framework for Logic Dialects.W3C

Recommendation 22 June 2010.

http://www.w3.org/TR/rif- d/.

[5] SPARQL Query Language for RDF.W3C

Recommendation 15 January 2008.

http://www.w3.org/TR/rdf-sparql-query/.

[6] S.Aitken and J.Curtis.A Process Ontology.In

Knowledge Engineering and Knowledge Management:

Ontologies and the Semantic Web.2002.

[7] A.Artale and E.Franconi.A Survey of Temporal

Extensions of Description Logics.Annals of

Mathematics and Articial Intelligence,

30(1-4):171{210,Mar.2001.

[8] D.Beckett and T.Berners-Lee.Turtle - Terse RDF

Triple Language.W3C Team Submission 28 March

2011.http://www.w3.org/TeamSubmission/turtle/.

[9] I.Berges,J.Bermudez,A.Go~ni,and A.Illarramendi.

Semantic Web Technology for Agent Communication

Protocols.In Proceedings of the 5th European

Semantic Web Conference,ESWC'08,pages 5{18,

Berlin,Heidelberg,2008.Springer-Verlag.

[10] P.Borst,H.Akkermans,and J.Top.Engineering

Ontologies.International Journal of Human-Computer

Studies,46:365{406,1997.

[11] V.Ermolayev,N.Keberle,and W.-E.Matzke.An

Ontology of Environments,Events,and Happenings.

In Proceedings of the 2008 32nd Annual IEEE

International Computer Software and Applications

Conference,COMPSAC'08,pages 539{546,

Washington,DC,USA,2008.IEEE Computer Society.

[12] B.Falkenhainer,A.Farquhar,D.G.Bobrow,

R.Fikes,K.D.Forbus,T.R.Gruber,Y.Iwasaki,and

B.Kuipers.CML:A Compositional Modeling

Language.Technical Report KSL-94-16,Stanford

Knowledge Systems,AI Laboratory,1994.

[13] M.Fox and D.Long.Modelling Mixed

Discrete-Continuous Domains for Planning.J.of

Articial Intelligence Res.,27(1):235{297,Oct.2006.

[14] J.M.Gomez-Perez,M.Erdmann,M.Greaves,

O.Corcho,and R.Benjamins.A Framework and

Computer System for Knowledge-level Acquisition,

Representation,and Reasoning with Process

Knowledge.Int.J.of Human-Comp.Studies,68,2010.

[15] T.R.Gruber and G.R.Olsen.An Ontology for

Engineering Mathematics.In 4th Int.Conf.on Prin.

of Know.Repr.and Reasoning.1994.

[16] M.Gr

uninger and C.Menzel.The Process

Specication Language (PSL) Theory and

Applications.AI Magazine,24,2003.

[17] T.A.Henzinger.The Theory of Hybrid Automata.In

Proceedings of the 11th Annual IEEE Symposium on

Logic in Computer Science.Invited Tutorial,LICS'96,

pages 278{,1996.

[18] A.Khandelwal.Longer version of this article.

http://www.cs.rpi.edu/~ankesh/wolcc.pdf,2012.

[19] A.Khandelwal and P.Fox.General Descriptions of

Additive Eects via Aggregates in the Circumscriptive

Event Calculus.Submitted on <TBD> to J.of

Articial Intelligence Research (JAIR).http:

//www.cs.rpi.edu/~ankesh/additiveeffects.pdf,

2012.

[20] T.-W.Kim,J.Lee,and R.Palla.Circumscriptive

Event Calculus as Answer Set Programming.In Proc.

of the 21st Int.Joint Conf.on Articial Intelligence,

IJCAI'09,pages 823{829,2009.

[21] E.Kirci Ozorhan,E.K.Kuban,and N.K.Cicekli.

Automated Composition of Web Services with the

Abductive Event Calculus.Information Sciences,

180(19):3589{3613,Oct.2010.

[22] V.Lifschitz.Circumscription.In Handbook of Logic in

Articial Intelligence and Logic Programming (vol.3).

Oxford University Press,Inc.,1994.

[23] V.Lifschitz,L.Morgenstern,and D.Plaisted.Chapter

1 Knowledge Representation and Classical Logic.In

Handbook of Knowledge Representation,volume 3 of

Foundations of Articial Intelligence,pages 3 { 88.

Elsevier,2008.

[24] J.Ma and B.Knight.Reied Temporal Logics:An

Overview.Articial Intelligence Review,

15(3):189{217,May 2001.

[25] V.Mascardi,V.Cord`i,and P.Rosso.A Comparison

of Upper Ontologies.Technical Report DISI-TR-06-21,

Dipartimento di Informatica e Scienze

dell'Informazione (DISI),Universit'a degli Studi di

Genova,2006.

[26] R.Miller.A Case Study in Reasoning about Actions

and Continuous Change.In European Conference on

Articial Intelligence (ECAI).John Wiley & Sons,

1996.

[27] R.Miller and M.Shanahan.Reasoning about

Discontinuities in the Event Calculus.In Principles of

Knowledge Representation and Reasoning (KR),1996.

[28] J.Morbach,A.Yang,and W.Marquardt.

OntoCAPE-A Large-scale Ontology for Chemical

Process Engineering.Engineering Applications of

Articial Intelligence,20:147{161,2007.

[29] B.Motik.Representing and Querying Validity Time in

RDF and OWL:A Logic-based Approach.Web

Semantics:Science,Services and Agents on the World

Wide Web,12-13:3{21,Apr.2012.

[30] B.Motik and R.Rosati.Reconciling Description

Logics and Rules.Journal of the ACM,

57(5):30:1{30:62,June 2008.

[31] E.T.Mueller.Commonsense Reasoning.Morgan

Kaufmann Pub.Inc.,San Francisco,CA,USA,2006.

[32] R.Reiter.Natural Actions,Concurrency and

Continuous Time in the Situation Calculus.In Pri.of

Know.Repr.and Reasoning,pages 2{13,1996.

[33] M.Shanahan.Solving the Frame Problem:A

Mathematical Investigation of the Common Sense Law

of Inertia.MIT Press,1997.

[34] G.Teschl.Ordinary Dierential Equations and

Dynamical Systems.Graduate Studies in

Mathematics,ISSN:1065-7338.American

Mathematical Society,2012.

[35] F.van Harmelen,V.Lifschitz,and B.Porter,editors.

Handbook of Knowledge Representation.Elsevier

Science,San Diego,USA,2007.

APPENDIX

A.DOMAIN-INDEPENDENT AXIOMS OF

EVENT CALCULUS

The domain-independent axioms of EC are listed in Fig-

ure 10.

LeftContinuous(P;T),Continuous(P;T),and Differenti

able(P;T) express that at time T,the function associated

with parameter P (henceforth,just parameter P) is left-

hand continuous,continuous,and dierentiable respectively.

Continuous(p;t) 8r9t

1

8t

2

[[jt t

2

j < t

1

^0 < r] !jV alue(p;un;t) V alue(p;un;t

2

)j < r] (A1)

Differentiable(p;t) 8r9t

1

8t

2

[[0 < jt t

2

j < t

1

^ 0 < r] !

(V alue(p;un;t) V alue(p;un;t

2

))

(t t

2

)

(A2)

V alue((p);un=Second;t)

< r]

LeftContinuous(p;t) 8r9t

1

8t

2

[[t

2

< t ^(t t

2

) < t

1

^0 < r] !jV alue(p;un;t) V alue(p;un;t

2

)j < r] (A3)

RightLimit(p;t;un;r) 8r

1

9t

1

8t

2

[[t < t

2

^(t

2

t) < t

1

^0 < r

1

] !jV alue(p;un;t

2

) rj < r

1

] (A4)

HoldsAt(f;t) [InitialisedTrue(f) ^:Clipped(0;f;t)] (EC1)

:HoldsAt(f;t) [InitialisedFalse(f) ^:Declipped(0;f;t)] (EC2)

HoldsAt(f;t

2

) [Happens(a;t

1

) ^Initiates(a;f;t

1

) ^t

1

< t

2

^:Clipped(t

1

;f;t

2

)] (EC3)

:HoldsAt(f;t

2

) [Happens(a;t

1

) ^ Terminates(a;f;t

1

) ^t

1

< t

2

^:Declipped(t

1

;f;t

2

)] (EC4)

Clipped(t

1

;f;t

2

)

def

9a;t[Happens(a;t) ^t

1

< t < t

2

^Terminates(a;f;t)] (EC5)

Declipped(t

1

;f;t

2

)

def

9a;t[Happens(a;t) ^ t

1

< t < t

2

^ Initiates(a;f;t)] (EC6)

LeftContinuous(p;t) (EC7)

:[Happens(a;t) ^Breaks(a;p;t)] !Continuous(p;t) (EC8)

:[Happens(a;t) ^Breaks(a;(p);t)] !Differentiable(p;t) (EC9)

[BreaksTo(a;p;t;un;r) ^Happens(a;t)] !RightLimit(p;t;un;r) (EC10)

BreaksTo(a;p;t;un;r) !Breaks(a;p;t) (EC11)

Breaks(a;p;t) !Breaks(a;(p);t) (EC12)

t < Next(t) (EC13)

[t < t

1

^t

1

< Next(t)] !:Happens(a;t

1

) (EC14)

[Happens(a

1

;t

1

) ^t < t

1

] !9a:Happens(a;Next(t)) (EC15)

[9a;r:(BreaksPartBy(a;p;t;un;r) ^Happens(a;t)) ^ s = V alue(p;un;t) +#sumhr;a:(BreaksPartBy(a;p;(EC16)

t;un;r) ^Happens(a;t))i] !RightLimit(p;t;un;s)

BreaksPartBy(a;p;t;un;r) !Breaks(a;p;t) (EC17)

[9r;px:PartV alue(p;t;px;un;r) ^s =#sumhr;px:PartV alue(p;t;px;un;r)i] !V alue(p;un;t) = s (EC18)

Figure 10:Domain-independent Axioms of Event Calculus

RightLimit(P;T;Un;R) expresses that at time T,the right

limit value of parameter P is Rin units of Un.Mathematical

denitions of Continuous,Differentiable,LeftContinuous,

and RightLimit are axiomatized in Axioms (A1){(A4).

Initiates(A;F;T) expresses that action A initiates uent F

at time T (Terminates is used similarly).BreaksTo(A;P;T;

Un;R) expresses that at time T,an occurrence of action A

will cause parameter P to instantaneously take on value R

in units of Un.Breaks(A;P;T) expresses that at time T,

action A potentially causes discontinuity in parameter P.

Axioms (EC1){(EC4) express the default persistence of u-

ents and initiation and termination eects when correspond-

ing actions happen.

Axiom (EC7) expresses that parameters are left-hand con-

tinuous at every time-point,including those at which actions

occur.In other words,discontinuity caused by an action

takes eect immediately after the action occurs.Axioms

(EC8){(EC9) express that functions associated with param-

eters are continuous and dierentiable by default.Deni-

tion of BreaksTo is axiomatized in Axiom (EC10).Axiom

(EC11) expresses the relationship between BreaksTo and

Breaks,and Axiom (EC12) expresses that an action that

potentially causes discontinuity in a given parameter also

causes a potential discontinuity in its higher derivatives.Ax-

ioms (EC13){(EC15) axiomatize the denition of Next(T).

BreaksPartBy and PartV alue are used for distinct descrip-

tions of discrete and continuous additive eects respectively.

BreaksPartBy(A;P;T;Un;R) expresses that if action A

occurs at time T,then it discontinuously changes value of pa-

rameter P by Rin units of Un.PartV alue(P;T;PX;Un;R)

expresses that R in units of Un is one of the additive val-

ues of parameter P,uniquely identied by PX.PX is re-

ferred to as the argument for disambiguating contributions

or DCA,and is typically a non-frame uent.P usually rep-

resents rate of change (that is,rst-derivative) of another

quantity,and R may be a function of values of other quan-

tities including derivatives.

The semantics of BreaksPartBy and PartV alue are given

using FO aggregate summation formulas (Axioms (EC16)

and (EC18)).The formula,#sumhx:F(x)i,equals sum of

elements in the multiset (x:F(x)),that is multiset of tu-

ples that satisfy F(x).Axiom (EC17) is similar to Axiom

(EC11).

It is recommended that DCAs be chosen such that they

uniquely identify the corresponding additive value and con-

form to the following constraint:

HoldsAt(px;t) !9p;r:PartV alue(p;t;px;r):

[(EC1) ^:::^(EC18)] are the domain-independent axioms

of EC,which are associated with every domain description.

B.DEFAULTREASONINGINEVENTCAL-

CULUS

The frame problem is resolved by modeling default assump-

tions,like by default a given action does not occur at a

given time point,by default an action does not change the

value of a given uent or a given parameter,and by de-

fault a given action occurrence does not result in a dis-

continuity for a given parameter,through circumscription.

CIRC[F;P] [22] denotes a transformation of the formula

F such that the extensions of predicates in the tuple P

are minimized.CIRC

A

[F;P] [19],is a circumscription-

like transformation for formulas containing aggregate for-

mulas,with a unique transformation for aggregate formu-

las.CIRC

A

[F;P] excludes those models of CIRC[F;P] in

which the extensions of predicates in P contain unjustied

facts;refer [19] for details.

Let D denote the collection of domain-dependent axioms.

Then,Nar(D),E(D),Inst(D),Inst

P

(D),Con(D),Con

P

(D),

Cnst(D),Abn(D),and Una(D) stand for axioms describing,

respectively,the narrative (Happens facts and statements

about the initial values of uents),the eects of actions

on uents (using Initiates,Terminates and Releases),the

instantaneous (non-additive) eects of actions on parame-

ters (using Breaks and BreaksTo),the instantaneous addi-

tive eects of actions on parameters (using BreaksPartBy),

the mathematical constraints between parameters in dif-

ferent circumstances,the continuous additive eects (using

PartV alue),the relationship between the values of uents

and,optionally,parameters (using HoldsAt),the abnor-

mality conditions (using abnormality predicates),and the

uniqueness-of-names.Rem(D) stands for axioms that are

not covered by the above categories.

The circumscription policy,CIRC

CECA

(D) [19],for model-

ing the default assumptions (which are domain-independent)

is given below.Extensions of predicates are minimized sepa-

rately in dierent parts,and this strategy is referred to as the

forced separation strategy,which is based on the idea of lter

preferential entailment.T

ESI

[Con

P

(D)] rewrites axioms in

Con

P

(D) such that V alue(p;un;t) references are replaced

by aggregate summation of additive eects,#sumhr;px:

PartV alue(p;t;px;un;r)i,whenever parameter p is subject

to some additive eects at a given time.

CIRC[Nar(D);Happens]

^ CIRC[Eff(D);Initiates;Terminates;Releases]

^ CIRC[Inst(D) ^ (EC11) ^(EC12) ^(EC17);

Breaks;BreaksTo]

^CIRC[Inst

P

(D);BreaksPartBy]

^CIRC

A

[T

ESI

[Con

P

(D)];PartV alue]

^CIRC[Abn(D);Ab

1

;Ab

2

;:::] ^[Con(D) ^ (EC18)]

^Cnst(D) ^Rem(D) ^Una(D) ^ [(EC1) ^:::^(EC16)]

CIRC

CECA

(D) is referred to as the EC theory for domain

D.Nar(D),E(D),Inst(D),Inst

P

(D),Con

P

(D) typically

dene necessary conditions for the corresponding eects to

be active.Sucient conditions are encoded via circumscrib-

ing these axioms.This approach makes a clear separation

between the classical aspects of representation of eects of

actions and non-monotonic aspects,and achieves elabora-

tion tolerance while at it.

B.1 Circumscription Policy for The Running

Example

(T1) ^:::^ (T12) are the domain-specic axioms,and EC

theory for the domain can be constructed using CIRC

CECA

policy.Note that T

ESI

[(T5) ^ (T6)] ^ (EC18p) [(T5) ^

(T6)] ^ (EC18p),and no initial scenario or narrative were

given.

CIRC[(T9) ^:::;Happens]

^CIRC[(T1) ^ (T2);Initiates;Terminates;Releases]

^CIRC[(T10) ^ (T11) ^ (EC11) ^ (EC12) ^ (EC17);

Breaks;BreaksTo]

^CIRC[(T3) ^ (T4);BreaksPartBy]

^CIRC

A

[(T5) ^ (T6);PartV alue]

^[(T7) ^(T8) ^ (EC18)] ^ (T12) ^ (EC1) ^:::^ (EC16)

C.WOLCCDESCRIPTIONS FORTHERUN-

NINGEXAMPLE

The descriptions of actions,quantities,and uents used in

the water tanks example are given below.

E.g.,CONSTANTACTIONDESCRIPTIONs:

Action(nsa:TurnOnActionC Description(

{ nsa:TurnOnActionC a nst:TurnOnAction;

nst:hasObject nsa:TapC.} ))

Action(nsa:TurnOnActionD Description(

{ nsa:TurnOnActionD a nst:TurnOnAction;

nst:hasObject nsa:TapD.}))

Action(nsa:TurnOffActionC Description(

{ nsa:TurnOffActionC a nst:TurnOffAction;

nst:hasObject nsa:TapC.}))

Action(nsa:TurnOffActionD Description(

{ nsa:TurnOffActionD a nst:TurnOffAction;

nst:hasObject nsa:TapD.}))

Action(nsa:Scoop1 Description(

{ nsa:Scoop1 a nst:ScoopAction.}))

Action(nsa:Scoop2 Description(

{ nsa:Scoop2 a nst:ScoopAction.}))

E.g.,CONSTANTQTYDESCRIPTIONs:

Quantity(nsa:HeightA Description(

{ nsa:TankA nst:hasQuantity nsa:HeightA.

nsa:HeightA nst:measureOf nst:Height.}))

Quantity(nsa:HeightB Description(

{ nsa:TankB nst:hasQuantity nsa:HeightB.

nsa:HeightB nst:measureOf nst:Height.}))

Quantity(nsa:LevelA Description(

{ nsa:ContainedWaterA nst:hasQuantity nsa:LevelA.

nsa:LevelA nst:measureOf nst:Level.}))

Quantity(nsa:LevelB Description(

{ nsa:ContainedWaterB nst:hasQuantity nsa:LevelB.

nsa:LevelB nst:measureOf nst:Level.}))

E.g.,CONSTANTRELATIONs:

Relation({ nsa:TankA a nst:Tank.})

Relation({ nsa:TankB a nst:Tank.})

Relation({ nsa:TapC a nst:Tap.})

Relation({ nsa:TapD a nst:Tap.})

Relation({ nsa:ContainedWaterA a

nst:ContainedLiquid;

nst:containedIn nsa:TankA.})

Relation({ nsa:ContainedWaterB a

nst:ContainedLiquid;

nst:containedIn nsa:TankB.})

To illustrate observations and occurrences,we assume the

following observations,

:HoldsAt(Open(C);0) ^:HoldsAt(Open(D);0)

^ V alue(Height(A);t;nst:Meter) = 2

^ V alue(Level(A);0;nst:Meter) = 1:5,

and the occurrence,Happens(TurnOn(C);20).

E.g.,OBSERVATIONs:

Neg HoldsAt({ nsa:TapC a nst:Open.} Time(0))

Neg HoldsAt({ nsa:TapD a nst:Open.} Time(0))

ValueAt(

Quantity(nsa:HeightA)

Time(?t)

Unit(nst:Meter)

HasValue(Value(2)))

ValueAt(

Quantity(nsa:LevelA)

Time(0)

Unit(nst:Meter)

HasValue(Value(1.5)))

E.g.,OCCURRENCEs:

Happens(Time(20) Action(nsa:TurnOnActionC))

DIRECTEFFECTOFACTION in Axioms (T1),(T2),and (T3) can

be declared as:

Effect(

Action(?a Description({?a a nst:TurnOnAction;

nst:hasObject?tap.})

FluentInitiation({?tap a nst:OpenTap.}))

Effect(

Action(?a Description({?a a nst:TurnOffAction;

nst:hasObject?tap.})

FluentTermination({?tap a nst:OpenTap.}))

Effect(

Action(?a Description({?a a nst:ScoopAction.})

AdditiveChangeInValue(

Quantity(nsa:LevelA)

Unit(?un)

HasValue(

Quantity(nsa:HeightA)

Value(-1 nsa:HeightA=4))))

The water tank example axiomatization contains no eect

dependencies.But,consider the following eect dependency.

If an object o is placed inside another object x,which itself

is inside another object y,then o is also placed inside y.

[HoldsAt(In(x;y);t) ^Initiates(PlaceIn(o;x);In(o;x);t)]

!Initiates(PlaceIn(o;x);In(o;y);t)

The above EFFECTSDEPENDENCY can be declared as:

ConstraintsOnEffectsOfActions(

Action(?a Description({?a a nst:PlaceInAction;

nst:targetObject?o;

nst:destination?x.})

ConstraintOnState({?x nst:in?y.})

Implies(

FluentInitiation({?o nst:in?x.})

FluentInitiation({?o nst:in?y.})))

OCCURRENCEPRECONDITION in Axiom(T4) can be declared as:

OccurrencePrecondition(

Action(?a Description({?a a nst:ScoopAction.})

ConstraintOnState(

Quantity(nsa:LevelA)

Quantity(nsa:HeightA)

ValueConstraint(nsa:LevelA (nsa:HeightA=2))))

ADDITIVECONTINUOUSCHANGE in Axioms (T5) and (T6) can

be declared as:

AdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelA))

Unit(?un)

ActiveWhen({?x a:Tap,:Open.})

DisambiguatedBy(?y {?y a nst:EmptyingTank;

nst:hasTank nsa:TankA;

nst:hasTap?x.})

HasValue(

Quantity(nsa:LevelA)

Value(-1 K nsa:LevelA)))

AdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelB))

Unit(?un)

ActiveWhen({?x a:Tap,:Open.})

DisambiguatedBy(?y {?y a nst:FillingTank;

nst:hasTank nsa:TankB;

nst:hasTap?x.})

HasValue(

Quantity(nsa:LevelA)

Value(K nsa:LevelA)))

BREAKINCONTINUITY in Axioms (T10) and (T11) can be de-

clared as:

BreakInContinuity(

Action(?a Description({?a a nst:TurnOnAction.}))

Derivative(

?dq

Order(1)

Quantity(?q Description({?x a nst:ContainedLiquid;

nst:hasQuantity?q.

?q nst:measureOf nst:Level.})))

BreakInContinuity(

ACTIONDESCRIPTIONSCONSTRAINT::=`ConstraintOnActionDescriptions'`('

IMPLIESCONSTRAINT | EQUIVALENTCONSTRAINT | SAME | DIFFERENT`)'

DIFFERENT::= VARORIRI 6= VARORIRI

EQUIVALENCECONSTRAINT::=`Equivalent'`('TRIPLESBLOCKFORMULA TRIPLESBLOCKFORMULA`)'

IMPLIESCONSTRAINT::=`Implies'`('TRIPLESBLOCKFORMULA TRIPLESBLOCKFORMULA`)'

QTYDESCRIPTIONSCONSTRAINT::=`ConstraintOnQuantityDescriptions'

`('IMPLIESCONSTRAINT | EQUIVALENTCONSTRAINT | SAME | DIFFERENT`)'

RELATIONSCONSTRAINT::=`ConstraintOnRelations'`('

IMPLIESCONSTRAINT | EQUIVALENTCONSTRAINT | SAME | DIFFERENT`)'

SAME::= VARORIRI'='VARORIRI

TRIPLESBLOCKFORMULA::= CONNECTIVE`('TRIPLESBLOCKFORMULA`)'

| QUANTIFIER`('TRIPLESBLOCKFORMULA`)'

|`Neg'TRIPLESBLOCKFORMULA | TriplesBlock | SAME | DIFFERENT

Figure 11:Presentation syntax for describing the constraints of data modeling languages.

(ACTIONDESCRIPTIONSCONSTRAINT):= (IMPLIESCONSTRAINT;HoldsAt

A

) j (EQUIVALENTCONSTRAINT;HoldsAt

A

)

j (SAME) j (DIFFERENT)

(DIFFERENT):= (VARORIRI) 6= (VARORIRI)

(EQUIVALENCECONSTRAINT;Pred):= (TRIPLESBLOCKFORMULAOREQUALITY;Pred)

!(TRIPLESBLOCKFORMULAOREQUALITY;Pred)

(IMPLIESCONSTRAINT):= (TRIPLESBLOCKFORMULAOREQUALITY;Pred) !(TRIPLESBLOCKFORMULAOREQUALITY;Pred)

(QTYDESCRIPTIONSCONSTRAINT):= (IMPLIESCONSTRAINT;HoldsAt) j (EQUIVALENTCONSTRAINT;HoldsAt)

j (SAME) j (DIFFERENT)

(RELATIONSCONSTRAINT):= (IMPLIESCONSTRAINT;HoldsAt) j (EQUIVALENTCONSTRAINT;HoldsAt)

j (SAME) j (DIFFERENT)

(SAME:= (VARORIRI) = (VARORIRI)

(TRIPLESBLOCKFORMULAOREQUALITY;Pred) = Pred((TRIPLESBLOCKFORMULA;?t) j (SAME) j (DIFFERENT)

Figure 12:Denition of function for the elements used for describing the constraints of data modeling

languages.

Action(?a Description({?a a nst:TurnOffAction.}))

Derivative(

?dq

Order(1)

Quantity(?q Description({?x a nst:ContainedLiquid;

nst:hasQuantity?q.

?q nst:measureOf nst:Level.})))

EVENTTRIGGER in Axiom (T9) can be declared as:

EventTrigger(

Action(?a Description({?x a?Tap.

?a a?nst:TurnOffAction;nst:hasObject?x.}))

ConstraintOnstate(

{?x a nst:Open.}

Quantity(nsa:LevelB)

Quantity(nsa:HeightB)

ValueConstraint((nsa:LevelB - nsa:HeightB) = 0)))

NONADDITIVECONTINUOUSCHANGE in Axioms (T7) and (T8)

can be declared as:

NonAdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelA))

ActiveCondition((Neg EXIST?x ({?x a nst:Tap,

nst:Open.})))

ODE(?dq = 0))

NonAdditiveContinuousChange(

Derivative(?dq Order(1) Quantity(nsa:LevelB))

ActiveCondition((Neg EXIST?x ({?x a nst:Tap,

nst:Open.})))

ODE(?dq = 0))

D.DATA MODELINGCONSTRAINTS

The presentation syntax of data modeling constraints is given

in Figure 11.Its mapping to EC is given in Figure 12.

The axiomatization of FOL-based based data modeling lan-

guages can be replicated in EC framework,albeit with rei-

cation [23] of predicates.E.g.,the prp-fp rule from OWL 2

RL/RDF rules [3],

T(?p;rdf:type;owl:FunctionalProperty) ^T(?x;?p;?y

1

)

^ T(?x;?p;?y

2

) !T(?y

1

;owl:sameAs;?y

2

);

interpreted under the OWL 2 Direct Semantics,can be for-

mulated in EC framework as:

[HoldsAt(T(?p;rdf:type;owl:FunctionalProperty);?t)

^HoldsAt(T(?x;?p;?y

1

);?t) ^ HoldsAt(T(?x;?p;?y

2

);?t)]

!?y

1

=?y

2

:

Other OWL 2 RL/RDF rules can be described in EC simi-

larly.

E.g.,the unique name assertions given by Axioms (T12)

can be described using ACTIONDESCRIPTIONCONSTRAINT as

follows:

ConstraintOnActionDescriptions(

Implies(({?a1 a nst:TurnOnAction.

?a2 a nst:TurnOffAction.})

(?a1 6=?a2)))

ConstraintOnActionDescriptions(

Implies(And(({?a1 a nst:TurnOnAction;

nst:hasObject?tap1.

?a2 a nst:TurnOnAction;

nst:hasObject?tap2.})

(?a1 =?a2)) (?tap1 =?tap2)))

Other unique name assumptions in UNA[TurnOn;TurnOff;

Scoop] can be asserted similarly.Also,QTYDESCRIPTION-

SCONSTRAINT for UNA[Level;Height;] and RELATIONSCON-

STRAINT for UNA[Open] can be dened similarly.

We could alternatively assert disjoint resources.

ConstraintOnActionDescriptions(

nsa:TurnOnActionC 6= nsa:TurnOnActionD)

ConstraintOnActionDescriptions(

nsa:TurnOnActionC 6= nsa:TurnOffActionC)

We can also assert that nst:hasObject is a functional prop-

erty.

ConstraintOnActionDescriptions((

{?a nst:hasObject?tap1,?tap2.})

(?tap1 =?tap2)).

## Σχόλια 0

Συνδεθείτε για να κοινοποιήσετε σχόλιο