Re: Proposed extensions to OWL?

[Danny Ayers]
[I wrote]
> > An operation has parameters and an algorithm or formula.  It is not
> > (necessarily) just a predicate.  Modeling a units conversion as a
> > resource,
> > as I did in my last post, is a way to represent a simple, scalar
operator.
> > It would probably be better in the long run to devise a general way to
> > represent operators that can perform non-scalar as well as scalar
> > transformations.  These would probably turn to be extremely useful in
many
> > ways, some of them not anticipated now.
>
> I think there already are the facilities for representing operators in
RDF,
> even if we call them by another name - processes [1] (as in a strawman
> schema I did a while ago) or services [2] (as in DAML-S).
>

I __am__ talking about using RDF.  As you say, rpp is a strawman, and anyway
it is for process modeling, is it not?  I do not think that is really the
right concept, although obviously it could be made to work (see below).

I do think you might be able to use a DAML-S SimpleProcess, but there are
two things about doing so -

1) It is not the right concept, since the relationship between units is not
really a process.

2) DAML does not have a vocabulary for describing the actual transformation
itself (like units-cm = 2.54*units-inch).  So we still have to invent an
ontology for it and some machinery for making it work, even if we do use a
DAML SimpleProcess description.  If we have to do that anyway, why not take
the next step and create a vocabulary for the purpose, one that could be
extended to more complicated transforms in the future?

I say SimpleProcess instead of AtomicProcess just because the current DAML-S
draft says that an AtomicProcess must be grounded, but not a SimpleProcess.
Since we are describing an abstract transfomation rather than a service, I
think that SimpleProcess fits best.

> An alternative might be simply to include the appropriate bit of Python
(or
> whatever) in a literal, with a predicate something like 'applyThis'. This
> sounds quick and dirty, but if the language used is well defined, then it
> should be possible for the whole thing to be (formally) well defined.
>

I do not think that this will let a processor discover that two different
statements that use different units refer correctly to the same quantity.
It _will_ let the processor figure out how to make a conversion (which I
suppose could then be checked for consistency, but that can be tricky), but
I do not think that is what we are really after here.  If we go and invent
the vocabulary and machinery to do this, we might as well just do the real
thing instead.

Cheers,

Tom P

Received on Sunday, 15 June 2003 22:47:39 UTC