[SWSL] notes from SWSL teleconf of May 6, 2004

May 6, 2004, SWSL teleconf

notetaker: Rick Hull

Attending:
 Dave Martin
 Benjamin Grosof
 Sheila McIlraith
 Michael Kifer
 Karl Aberer
 Michael Gruninger
 Steve Battle
 Bijan Parsia
 Rick Hull
 Terry Payne
 Richard Goodwin

No administrative tasks today (a surprising precedent, hopefully to be
repeated!)

==============

Benjamin Grosof presents his strawperson proposal,
  using as materials a text file "proposal-on-avoid-process-model-101903.txt"
  and a pdf file "strawman-050604-v1.pdf"


Benjamin: 

That in the f2f meeting in Nov in Florida we discussed idea of
something that could be proposed for SWSL in a timely fashion.

  People wondered if we could get a model out that included process or procedural
  aspects.

  Austin and Michael G and Michael K thought we could get a model out
  with some process aspects, but others were pessimistic

  in any case, Benjamin suggests
  that we start with a more declarative starting point,
  and then grow it to include procedural as a distinct second step, to be 
  done *after* we nail down a more declarative, KR-y model

(moving to the pdf file)

Rules are a natural starting point for the declarative model/language for this
-- they can do stuff, they are active, 
-- tractable, commercially deployed tools, incremental in 

What can we get into a rules formalism
-- Horn clauses
-- Negation of failure (for override, negation, etc in a basic way)
-- add in priorities (cf SweetDeal, some F-Logic stuff)
-- add procedural attachments
-- other extensions are currently being worked on

What can you get
-- can get parts of DL, roughly OWL-Lite

Bijan: it is less than OWL-Lite
MichaelK: if you have negation as failure, that is more than OWL-Lite

Bijan: DLP does an "embedding way" of combining DL and rules;
  this isn't the only arguably reasonable way to combine DL and rules
  e.g., AL-Log 
        there is other work recently submitted or developed

Michael K: how these proposals handle open world vs. closeworld?

Bijan: AL-Log: similar to att properties in OWL
  you have rules as a set of constraints
  then you ask a DL reasonor to do satisfiable check

Benjamin:
  the rules are a kind of "oracle approach"

Bijan: we've been looking at variations, e.g., multi-sorted logics, ...

Sheila: article she found in CiteSeer: "Integrating ?? into DLs: AL-Log"
        Lenzerini et al
        1998, Journal of Intelligent Systems

Benjamin:

Rather than having a lot of DL expressivness, subsumption, etc,
he thinks that many people have been missing the boat.
That OO with inheritance and override are very useful in SW engineering world
That we can capture this "default character" using negation as failure
  eg "courteous inheritance" from Benjamen
  something from Michael K and ???
  various ways to do it in LP

If we want to affect the way that web services are being developed, we
  should connect to the framework kind of info, style available from
  OO, including class defintiions - cf, Java, C++, C#, UML (to a lesser extent)
  the first three have default override inheritance

So we can model the taxonomies of sw components (in Java, in C++) using LP,
  so we should apply this technique to web services

This has an immediate, pragmatic value, and so there is an imperative that
  we go down this course right away (rather than trying to take advantage
  of richer portions of OWL-S or whatever)

That MichaelK and Pat Hayes and others have been doing good work on
  getting lots of expressiveness in variants of LP (e.g., Hilog, F-Logic-y)

Extensibility is also important, 
  eg towards FOL, eg
     adding constraints
     getting aspects of DL not in DLP
     what else?
  also how to extend to include some aspects of process models
     no strong feeling about which way to extend (CTL?, other?, ..)
     but, to be productive, lets start with things like BPEL, Choreography

  so one challenge is: what will the "extension points" of a LP-based thing
     to add in the procedural

Michael G: what do you mean by declarative vs procedural here?
  eg, there are declarative axiomatizations of procedural models

Benjamin: I'm thinking of "belief semantics"
  The line between declarative and procedural is blurred
  some examples
    idea of class and subclass: not very procedural
    ideas such as: sequence, concurrency, locking - 
       he views these as "procedural"

Sheila: are you excluding things because you feel that they are
  difficult to represent in DL or LP, or is it that you think they are
  fundamentally more complex than the stuff you're focusing on?

Benjamin: that there are different tools good for different things
  when we create an implementation, we use eg Java or C++
  while in principle you can describe the semantics in terms of
     state transitions, or FOL, or higher-order logic, 
     or some non-monotonic logic,
     it is not the best tool for the purpose.

  as you get further into procedural kinds of things, then he feels
    that a declarative language may be less natural for expressing the
    things

MichaelG: that your objection seems to be "awkward declarative syntax for
    procedural constructs"

Benjamin: 2 sense of "awkward" -
   1) you can't express it at all
   2) there's not an efficient way for human understanding for specifying it
 my objection is the 2nd one
 
Sheila: here's where I'm not clear
  if we're going to start with something "smaller", what do we start with?

Benjamin: I propose that we start with LP, specifically "normal logic
  programs" I like to work with "courteous" and ..  then extend from
  there

Sheila: it may be hard to extend from what you describe, because the
  reasoning engines are different because of treatment of negation,
  non-monotonicity, etc So maybe better to start with FOL and then
  restrict

Benjamin: FOL doesn't include some useful things, such as procedural
attachments

  I think that FOL is also a valuable starting point, but
  it is missing
    -- intuitive appeal
    -- existance of tools
    -- tractability

MichaelK; lots of educated people have trouble with quantifiers

MichaelG: that people have trouble with various diagramitic techniques

Rick: people have trouble with LP once you throw
  in a particular negation as failure semantics

Benjamin: I think that the courteous extensions are more intuitive.
   you can get away without talking explicitly about the negation 
   as failure semanitcs

Bijan: I'm not clear on the desiderata are, besides perhaps a personal taste.
  What in particular are you hoping to represent about services?

Benjamin: (see slide 4)
  main point of SWS is **knowledge re-use**
  across key tasks, eg., 
    advertising/discovery/matchmaking;
    contracts
    enactment
    composition
    monitoring, problem resolution, exception handling
    verification
    trust/security/privacy policies

    hypothetical reasoning also

(slide 5)
Claim: Rules and Ontologies alone are useful for:

advertising/discover/matchmaking - partial contracts, subsumption
   cf WWW-2003, e-commerce session

Contracts/selection/negotiation: pricing, policies, contingent provisiongs
  
area of "action rules" are starting to be a growth area for KR

composition: he had an interesting discussion with Yannis Labrew
  (spelling?)  Yannis showed him work from Fujitsu something
  practical, for users to compose services, as a dynamic human process
  use rulebases, one for each service, then you can take their union

Rick: there is a spectrum in composition, concerning how rich the
  description of the composition is from atomic services (cf OWL-S) to
  fsa-described services (Roman, Mealy machine/behavioral sig,
  WS-choreography) simple sequnce of atomic services to very
  interleaved fsa's

Benjamin:
  if 1 was the bottom of the scale and 9 the top of the scale, I think
  that I think we could express in the range of 1 to 3 in his framework
  (and that with extensions we could add stuff to get all the way to 9)

That we could get an "early win" here, by getting at things like
 -- trust policies
      eg XACML, P3P view themselves as rules-based already

Rick: you mention XACML - is part of your core proposal to 
   incorporate XML data types?

Benjamin: he didn't plan to go to this level of detail, but btw
  eg, latest release of SWRL does get some aspects of XML data types into LP
  SWRL includes XML schema, data types , etc
  SWRL is combo of OWL and RuleML - just released 0.6 on Tuesday


also, an underlying task for SWS would be hypothetical reasoning
  - and this is a major strength of rule-based KR


end of slide show proper

----------

Bijan: my question from before: what kinds of things will you be able
  to say about services vs things that you won't be able to say

Sheila: will there be process models a la OWL-S?
   will there only be atomic processes?
   will there be compound processes, but eg without loops (that
       are classically defined without 2nd order something)?
   will there be data flow?

Benjamin: some things I think I've figured out
  we can have atomic services nicely
  also simple end of MichaelK's approach, with Concurrent Transaction Logic
  also simple compounding, e.g., 
       nesting activity expressions    
  probably not complicated loops
  some simple data flow, yes, because you would have to compose things
     and so at least implicitly there is data flowing

  you can think of an annotative thing outside of the LP
     representation proper eg, prices, what is supposed to happen if
     failure to execute within a certain amount of time


MichaelK: you were brave to present the first strawperson proposal, but anyway,
   did you attempt to represent any of the 3 use cases?        

Benjamin: I think the Amazon can be represented, I've been busy on
   other things, I do hope to have some of those worked out in time
   for the f2f

Bijan: The "schtick" seems to be "let's not talk about procedural models"
  I think this is a bit misleading
  I still don't see the fundemantal aspect of 
        what you're including vs not including
        as being procedural vs non-procedural
  I don't think that our problem has been that we've focused on procedural.
  Most of the debates we've had about procedural we would probably
     still have the exact same kind of debate if we focused on *match-making*

Benjamin: I would disagree.  If we looked only at match-making then
  there would be more to constrain the discussion

  I think there's been much more controversy about what process model
  to look at
    
  everyone in CS would agree that modeling process is much harder than
    modeling the more static, descriptive aspects

Benjamin, MichaelG: Three approaches to modeling process
   DL
   PSL
   Logic programming as in CTL

Benjamin: and lots of other aspects, too
  I think it is a black hole

Bijan: I think the problem is that there are 3 possible choices (listed above),
  and no immediate way to choose between these,
  and MichaelK has tried to identify a way to resolve (by looking how they 
  work on the use cases)

  So, I still don't know how your mindset will help us make a resolution

Benjamin: one issue will be the "extension points" 
  also, there isn't much deep scientific knowledge on transforming between
     the DL, PSL, CTL perspectives
  but there is deep knowledge for going between LP, to DL, to FOL, 
     the intersection

  we run the risk of being by-passed by the rest of the community, who
  might make some half-assed proposals to do some of this stuff

Bijan: he was at W3C, hearing about WS-policy, which is *not* W3C,
  and W3C is thinking of creating a "counter" to this

  There is some big 3, maybe IBM, MS, BEA, doing it kind of privately
  right now

Benjamin: Frank from Fujitsu was saying that WS-policy 

Benjamin: Muninder Singh is organizing a panel at WWW2004 on something related

Bijan: W3C trying to create a workshop - maybe it is Tsucherai
      (spelling?) is trying to get this organized

-----------
excerpt from email exchange between Dave Martin and Philippe Le Hegaret of W3C

   The current plan is to organize a workshop among the members of various
   interested communities (WS-Policy, WSDL, P3P, CC/PP, OASIS related
   technologies, etc.) to brainstorm around the need to express the
   capabilities of a Web service and the constraints that need to be met to
   interact with it. 
-----------

Benjamin: rules as very useful for trust, contracts, discovery,etc.
  can extend to some aspects of procedural

someone: can you give example of why the hypothetical reasoning is important?

Benjamin: before I do a deal, lots of tests I might do
   what are impacts of canceling?
   if I have certain characteristics in my order what will price or impact be?
   what if I combine with another service from a second vendor?

  these are important in the ADM phase, in the contract phase
  most intensively useful in the contract phase, because you want to understand
     all sorts of unusual possible cases

Dave: a question is whether rule-based is any better at hypothetical reasoning
  than some other formalisms?

Benjamin: well, easier than doing this kind of reasoning about fsa's,
  or about procedural languages such 

Rick:
  1) Benjamin suggests make the rule thing first and richer thing second
     we could put the other order in place

  2) if we go in the Benjamin order, this might implicitly force us to choose
     one of the three approachs to modeling processes

Benjamin: is there a systematic look at putting automata into DL,
   CTL/rules, FOL?  Daniela seems to have embedded fsa's into DL

Rick: she embedded into DL as a proof technique, and BTW it is a fairly
   natural embedding;
   in separate work we've been embedding message-based and activity-based
    fsa's into PSL/FOL


Bijan: DCG - Definite Clause Grammar - this is equiv to push-down;
  does this give a hint on representing fsa's in LP?

Rick: I can see how to embed a single fsa into an LP, especially if
   I have function symbols so that the set of all terms produced
   is essentialy the language accepted by the fsa.

   But I don't see how to encode into LP the idea of building a new fsa
   out of three existing fsa's 

Benjamin: that branching is not especially natural to represent in rules,
  unless you use disjunction.  Maybe you can get to the level of "6" in that
  scale from before, but it would probably be painful

My concern about FOL is that anything we do there probably wouldn't be ready
for standardization within a one year time-frame, say

Besides, there are other groups looking at the procedural aspect, e.g.,
BPEL or .net people.  We should focus on our core strength, which would
be the logic, the declarative.  So we should set a realistic first goal
where our core strength can bring a tangible value in the short term
(ADM, contracts, basic connection to enactment via a procedural attachment)

Question: expressive power of SWRL vis-a-vis FOL

Benjamin: political decision: they took a lot of OWL and a little of RuleML
  (It could have gone with weighting in the other direction)
 
  so, I don't think SWRL is the right way to go.  Rather I think we
  should start with something primarily rule-based

Also, the rule engine market is much bigger than the DL engine market.
  so let's start with what we knwo, and in a principled fashion
  build out to some other capabilities

Put yourself in the shoes of a web service developer.  You want the
  code spit out in the end to be C# or Java or C++ so that it
  fits with everything else

  so, if you can't do inheritance that is really annoying, even a show-stopper

Bijan: in WSDL they are trying to get some kind of inheritance
  there are no objects in any classic sense
  anyway, web services people often say 
  "we aren't trying to do distributed object models"

Benjamin: I don't see inheritance as the first thing you need, for success.
  First step is a messaging model
  but as a second step

Bijan: SWSA group, some business people: 
  the abstractions they see as critical don't seems 
  to naturally include inheritance

Benjamin: that the need for inheritance will rapidly rear its ugly head once
  people really start incorporating web service creation tools into existing
  development environments

Bijan: still disagreeing.  That a large community thinking of moving from
  "object-oriented programming paradigm" to a 
          "service-oriented programming paradigm"
  Just to counter Benjamin's claims about how important inheritance might be
  to the industrial community

  So, it would be valid for us to focus on the semantics of something
  complimentary to object-oriented paradigm and inheritance in particular

  can you be more specific about what kind of inheritance 
  you're really talking about?

  bindings between interfaces, message types, 
  properties like security/encryption, ...

Benjamin: that some kinds of inheritance are pretty 
      striaght-forwradly monotonic
  in UML, everything except methods is monotonic
  the only overriding in UML is method
  in C++ you can have default inheritance
  likewise Java
   both pretty simple with respect to multiple inheritance
   C++: if an ambiguity, then report it as a compiler error

  many observers, knowledgable in theory and practice in sw eng, 
   think that inheritance is a good thing to have
   default inheritance is a useful thing to have
  so, let's be humble, let's try to stick to what has been found in practice
    to be useful.  We want to capture among other things legacy sources.
   and there is a whole body of OO sw components out there.
   Tons of structured service description knowledge organized in class 
     hierarchies;
     this should be grist for our mill, if we're talking 
            RuleML, OWL, Flora, ...

Bijan: that there is actually a lot of diversity of opinion re using OO to
  structure programs.  Eg delegation vs inheritance.  
   Mix-in vs deep multiple inheritance.
     etc
  much of that is based on behavioral aspects of code.

  I am all for using useful kinds of knowledge, but I'm not sure 
    that inheritiance
    of the sort you are talking about is really that useful for describing
    what we in SWSL might be focused on (which is more declarative aspects
    as opposed to behavioral aspects)

<< note-taker had to depart from meeting at this point >>