Re: Question about OWL-S sequence

Quoting Drew McDermott <drew.mcdermott@yale.edu>:

> > [Jeff]
> > Did they gag on the DAG idea or only on the parallel / sequence
> > example above?  [Now the middle, "looks bad", example below.]
> 
> I believe only on the occurrence of the same process invocation in
> more than one 'sequence'.
>
> > [Jeff]
> > I was thinking of something more like this:
> > 
> >   (tags 
> >       (tag A (arf))
> >       (tag B (barf))
> >       (tag C (scarf))
> >       (tag D (darth))
> >       (tag E (earth))
> >     (sequence A B D E)
> >     (sequence B C)
> >     (sequence A C E))
> > 
> 
> They're equivalent if you translate to RDF.

I thought they might be, and that's in part why I thought my
original suggestion was reasonable.  If it's written out as

> >    (parallel (sequence (tag A (arf)) (tag B (barf)) (darth)
> >                        (tag E (earth)))
> >              (sequence B C)
> >              (sequence A (tag C (scarf)) E))

then it does look bad.  I'd gag at that too.  Still, if it's
written as in my tags example above or your parallel example
below, it looks ok.  (And it wouldn't be the only thing in RDF
that looks ok when written one way and disgustingly messy
when written another.)

> The tags become rdf:ID's.
> When you undo the abbreviations and translate everything to triples,
> you get the same thing from my 'parallel' example above as you would
> from this:
>    
>    (parallel (tag A (arf))
>              (tag B (barf))
>              (tag C (scarf))
>              (tag D (darth))
>              (tag E (earth))
>       (sequence A B D E)
>       (sequence B C)
>       (sequence A C E))

Which in turn is much the same as the DAG example.

> except that we've now introduced an ID for the occurrence of (darth)
> that we didn't need before.  It's not syntactically the same, but it
> is semantically, because 'parallel' imposes no constraints on its
> arguments.

Yes, that's what I expected for parallel; and for sequence,
I expected it to be equivalent to a set of ordering constraints,
like the ones given more explicitly by arrows in the DAG syntax.

If sequence were equivalent to such ordering constraints,
then it should be possible to use it to express arbitrary
DAGs as we've been doing in these examples.

I don't want to be a pain about this, but if the semantics of
sequence doesn't let us do this, then it's not clear to me what
the semantics is.  It must be something more than the ordering
constraints, but it's not clear what that more is.

I don't see anything in the technical overview which blocks
this move, and I don't know of any more authoritative reference.

The technical overview even has this example:

  Let a, b, c, and d be atomic processes, and X, Y, and Z be
  composite   processes:

  X = (Sequence a b)
  Y = (Sequence c d)
  Z = (Unordered X Y)

True, that doesn't put anything in more than one sequence;
but if sequence is just a way to express ordering constraints,
then there's a semantics for cases in which something appears
in more than one sequence, and we could write for example

   (Sequence a b)
   (Sequence a c)

if we wanted to express the constraints a -> b, a -> c.

-- Jeff

Received on Thursday, 20 May 2004 15:56:07 UTC