Towards A Web Ontology Language for Descriptions of Continuous Processes

manyfarmswalkingInternet και Εφαρμογές Web

21 Οκτ 2013 (πριν από 3 χρόνια και 9 μήνες)

91 εμφανίσεις

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
dierent 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 dierent
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 dierential 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 dierent 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 conned 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 reied 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 dierent 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 dierential 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 Articial Intelligence.The rele-
vant works can be broadly classied 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 classied 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 justications
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 modied 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 Specication 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 denitions 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] oer 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 specic software or techniques such as specic QR tech-
niques.Processes are dened 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 dierent contexts such as real time systems [17],
planning [13],and reasoning about actions and their eects
[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 verication,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 dierent HAs which may independently describe parts
of a larger system.Planning Domain Denition 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 dened
by mapping into HA.
Several logic-based formalisms for reasoning about actions
and their discrete eects,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 eects 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 dierent
set of changes,and they correspond to a dierent 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 dened problems in representation of actions and their
eects:frame problem,qualication problem,ramication
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 eects,etc.We have further extended contin-
uous EC for more general,concise,and elaboration tolerant
descriptions of discrete and continuous additive eects [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 eects of actions without
explicitly representing all their non-eects,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-
specic 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-specic 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 dene their semantics,and a domain-independent
default reasoning strategy.Dynamic domains are axioma-
tized through domain-specic axioms using the predened
predicate and function symbols (new symbols can also be
used).The review follows the denitions 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 dened 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 eects are
described dierently,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 aected 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
eect 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 eects
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 dierent taps are
the same Emptying(A;x) and Filling(B;x) uniquely iden-
tify the additive eects from dierent sources.(Level(x))
is referred to as an additive quantity,as it can potentially
be subject to direct continuous,additive eects.
The value of additive quantities when not subject to any
additive eect must be specied 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 modied 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
modication involves reication (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 dening 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 dened 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 aect 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 eects 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 dierent categories of domain-specic axioms that can
be specied 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 dened via mappings
into domain-specic 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 dened in SPARQL Grammar [5].
Figure 3:Presentation syntax for declaring quantities,relations,and actions.
using the  function,with help of an auxiliary function .
(Ele) denes the mapping for element Ele,and optional
arguments are used to pass contextual information such as
time.( is dened 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-specic axioms of EC are logic axioms,and RIF-
FLD [4] could be used for sharing web-ized domain descrip-
tions.However,we dene 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 ecient 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 identiers 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:Denition 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 quantied.The short-hand notations HoldsAt
A
(RELATION;Ti),Initiates(Act;RELATION;Ti),and Terminat-
es(Act;RELATION;Ti) are dened 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 eect 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 dened in RIF-FLD [4].
Figure 5:Presentation syntax for describing the direct eects 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 quantiers 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:Denition of  function for the elements used for dening the direct eects 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-dierential-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-
tied 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:Denition 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 eects 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,dierent proles of WOLCC
with increasing complexities can be dened similar to OWL
2 proles [3].
We have provided motivations for a WOLCC-like language
and justications for dening 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-specicity),
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 dierential 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 dierential 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 Proles W3C
Recommendation 27 October 2009.
http://www.w3.org/TR/owl2-proles/.
[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 Articial 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.Bermudez,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
Articial Intelligence Res.,27(1):235{297,Oct.2006.
[14] J.M.Gomez-Perez,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
Specication 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 Eects via Aggregates in the Circumscriptive
Event Calculus.Submitted on <TBD> to J.of
Articial 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 Articial 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
Articial 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 Articial Intelligence,pages 3 { 88.
Elsevier,2008.
[24] J.Ma and B.Knight.Reied Temporal Logics:An
Overview.Articial 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
Articial 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
Articial 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 Dierential 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 dierentiable 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
denitions 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 eects 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 eect immediately after the action occurs.Axioms
(EC8){(EC9) express that functions associated with param-
eters are continuous and dierentiable by default.Deni-
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 denition of Next(T).
BreaksPartBy and PartV alue are used for distinct descrip-
tions of discrete and continuous additive eects 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 identied 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 unjustied
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 eects of actions
on uents (using Initiates,Terminates and Releases),the
instantaneous (non-additive) eects of actions on parame-
ters (using Breaks and BreaksTo),the instantaneous addi-
tive eects of actions on parameters (using BreaksPartBy),
the mathematical constraints between parameters in dif-
ferent circumstances,the continuous additive eects (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 dierent 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 eects,#sumhr;px:
PartV alue(p;t;px;un;r)i,whenever parameter p is subject
to some additive eects 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
dene necessary conditions for the corresponding eects to
be active.Sucient conditions are encoded via circumscrib-
ing these axioms.This approach makes a clear separation
between the classical aspects of representation of eects 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-specic 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 eect
dependencies.But,consider the following eect 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:Denition 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 dened 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)).