RE: Composition as planning

hi Charlie,

i think the constraints that you are describing are basically capturing the
kind of information that is typically capturered by a "plan".

lets take for instance plans produced by partial order planners: in POP
planning, a plan is represented by a set of action instances A representing
the steps to be taken by the agent; a set of causal Links L indicating
dependencies among those actions; a set of ordering constraints O defining
a partial order of the actions; and a set of binding constraints B on the
action parameters.

Your constraints <output=input> could be represented by a *binding*
constraint. It should be noted, however, that most planners do not support
those constraints in their final plans, because they assume that all
parameters are ground (= fully instantiated). This is what makes them, in
my view, rather unusable for Web service compositions, where certain pieces
of information CAN not be known at planning time.

On the other hand, planners that do support binding constraints *can* be
used for WSC quite effectively, at least as far as my preliminary
experiments (toy examples) have shown. In the next time, i am planning to
investigate the boundaries of this approach, and if you are interested we
can work together and share example scenarios etc.  I am using VHPOP
currently (which supports partially instantiated actions / binding
constraints) in plans (http://www-2.cs.cmu.edu/~lorens/vhpop.html)

cheers
Joe




                                                                                                                                
                      "Charlie Abela"                                                                                           
                      <abcharl@keyworld         An:      <public-sws-ig@w3.org>                                                 
                      .net>                     Kopie:                                                                          
                      Gesendet von:             Thema:   RE: Composition as planning                                            
                      public-sws-ig-req                                                                                         
                      uest@w3.org                                                                                               
                                                                                                                                
                                                                                                                                
                      26.02.2004 10:06                                                                                          
                                                                                                                                





Hi,

I've been thinking about this for some time and would like to get some
feedback.
I have considered, to some extent, work on planning and how it can be
applied to Web services
composition. From earlier discussions over this list it is clear that
traditional classic planning
techniques have to be in some way adapted to handle the diversity issues
over the Web. I want to put
forward the following thoughts:

Various planning techniques where devised around specific problems and
domains (correct me if I'm
wrong): for example STRIPS planning.
When considering the planning required for Web services, there are issues
which seem to crop up in
every composition hence there is place for capturing these commonalities
into some form of
operator-like descriptions.

For instance consider a simple sequential service composition:

Two services can be composed sequentially if the outputs/effects of one
service match with the
inputs/preconditions of the other.
In the real world, apart from checking this, some composer should also make
sure that once the
message with the outputs/effects from the first service has been received
then another message that
includes this information is sent to the second service.

Hence though an initial plan that matches IOPE can be performed in some
preliminary phase of
composition, then monitoring of message passing is required to make sure
that the initial plan can
actually be executed in the real world.

Returning to my initial point, one can say that these actions are common to
most compositions that
can occur. So it would be possible to capture these into a set of operators
that represent the
actions that are available for service composition.

For example: if the output/effect from service A have been received then a
message to service B can
be sent

Operator: sendInvocationMsg
Preconditions: (and (output=input)(effect=precondition)) (some constraint
here over the issue of
services having both output/effects and requiring input/precond)
Effect: (service A executed)

Other operators can be defined in a similar way to capture other common
behaviours related to
service composition.

Now this is just an idea and might have been explored by others, but IMHO
it gives some standard way
of composing services and gives a planner the possibility to monitor real
world compositions.

Would really like to get feedback on this and possibly other ideas that
confirm/or not the above.

Regards,

Charlie