[OWL-S] Proposal for Making Progress on Process Modeling esp. Preconditons and Effects

This is to fulfill an action item on me. (I hate those pesky things.)

In our last telecon, we discussed a proposal from Mark Burstein for 
ripping bits of the Semantic Web Rule Language (SWRL, ne้ OWL Rules) 
proposal and plopping them into OWL KBs that would purport to represent 
Process Models, in particular, the preconditions and effects of 
specific processes.

In essence, the proposal relies on  hanging sets of SWRL Atoms 
(potentially with variables) off of a property attached to a 
Process-as-Instance. This would require some sort of Atom quoting 
mechanism (either reification (Mark's pick), or literals (my pick)), 
and providing some semantics for these constructs (which would *not* be 
SWRLy). This was inspired by Drew McDermott's DRS encoding of logical 
formulas in RDF (or perhaps an attempt to make DRS all SWRLy).

In discussion, a number of issues arose, including whether we wanted to 
"make up our own" language in this way, or see whether SWRL (or a 
likely RDF Rules) could do the job, perhaps with some extension. If we 
could identify those extensions, then we could present them to the 
various groups as requirements.

After some discussion (particularly about how to handle delete lists in 
OWL), we decided that what we knew we knew how to do was encode OWL-S 
process models in the situation calculus[1]. We also decided to go for 
a first-order axiomatization (over, say, a non-monotonic one), partly 
so we could build on SWRL/OWL-Rules, but for an number of other reasons 
(prior work, familiarity, connection to other efforts such as PSL). 
Sheila McIlraith put forth the following justification:

> In my mind, the reason for the first-order axiomatization is because I
> view the process model as a specification, and I think it (as a
> specification) should have a "stardard" model-theoretic semantics, 
> rather
> than a nonmonotonic interpretation.  This enables people who use 
> different
> forms of reasoners (monotonic or nonmonotonic) to easily understand 
> how to
> map the specification into their implementations.

We do intend to produce a mapping from this axiomatization to a 
non-monotonic one, for implementation purposes. Sheila elaborates:

> In particular, in the situation calculus, the solution to the frame
> problem (encoding that everything stays the same unless it is 
> explicitly
> changed by the execution of a process) is encoded using 
> "if-and-only-if"
> (iff) axioms.  These axioms are easily translated to "if" rules in a 
> logic
> programming (i.e., nonmonotonic) reasoner.  The completion semantics
> of the logic program ensures that the interpretations of the logic 
> program
> are identical to the interpretations of the original first-order
> axiomatization.   See [2] for details.
>
> E.g., the first-order logic axiom
>    Forall a,s.holding(cup, do(a,s)) iff a=pickup(x)
>
> is translated into the following logic programming rule
>    Forall a,s.holding(cup, do(a,x)) <- a=pickup(x)
>
> The interpretation is equivalent.

So, we have two classes of issue:
	1) How much do we have to add to SWRL to get a language that a) can 
handle sitcalc and b) is otherwise sufficient?
	2) Is the sitcalc the right way to go? What exactly will be it's 
point? (Sheila has given (some of) her view above. We're especially 
interested if people have *problems* with this approach.)

(Actually, there are other sets of issues, such as it's not clear how 
to allow full OWL expressiveness into the precondition and effect 
lists, and thus how to smoothly integrate process descriptions with 
what one would expect to be the common ontologies and knowledge bases 
on the Semantic Web. I expect these'll all emerge in subsequent 
discussion ;))

Cheers,
Bijan Parsia.


[1]  	Srini Narayanan & Sheila McIlraith , "Simulation, Verification 
and Automated Composition of Web Services"
	http://citeseer.nj.nec.com/narayanan02simulation.html

	This gives a sitcalc based semantics to an earlier version of OWL-S 
(ne้ DAML-S). This representation has been used subsequently to provide 
translations to other formalisms and ontologies (e.g., SHOP2, PSL[5], 
and others).

[2]	Raymond Reiter 2001 {\it Knowledge in Action: Logical Foundations 
for
Specifying and Implementing Dynamical Systems.}  Cambridge, Mass.: The
MIT Press

[3] 	OWL-S 1.0:
	http://www.daml.org/services/owl-s/1.0/

[4]	SWRL:
	http://www.daml.org/2003/11/swrl/

[5]  	Michael Gruninger, "Applications of PSL to Semantic Web Services"

	http://www.cs.uic.edu/~ifc/SWDB/papers/Gruninger.pdf

Received on Friday, 2 January 2004 12:54:18 UTC