W3C home > Mailing lists > Public > public-sws-ig@w3.org > January 2006

Re: OWL-S Grounding: changes for 1.2 release

From: David Martin <martin@AI.SRI.COM>
Date: Tue, 03 Jan 2006 23:19:03 -0800
Message-ID: <43BB76E7.8030502@ai.sri.com>
To: public-sws-ig <public-sws-ig@w3.org>

David Martin wrote:
> This message is meant to summarize new directions regarding the
> grounding part of OWL-S.  These new directions will show up in OWL-S
> 1.2, subject of course to any further evolution that results from
> discussion on this list.  These directions have arisen from
> discussions within the OWL-S Coalition. (Evren, Naveen, Massimo and
> Daniel and all please check me on this message and feel free to chime
> in if anything needs further clarification).
> The first thing to note is that these new directions do not involve
> any ontology changes (except for one minor exception that's noted near
> the end of this message).  Rather they involve new conventions
> regarding the relationship between the parameters and preconditions of
> atomic processes and the WSDL script specified by a grounding.
> The second thing to note is that here we are dealing with the case
> where an XSLT script is used to generate an input message for a WSDL
> operation.  (There are a couple other cases that aren't addressed in
> this message.)
> In the past we assumed that the input to the WSDL script was some
> atomic process input expressed in OWL (i.e., as an OWL instance
> expressed in the XML/RDF syntax).  That assumption had some problems,
> so now the new approach is to pass values into the WSDL script by
> means of variable / param bindings.  Specifically, variables that
> appear in an atomic process precondition get bound to values when that
> precondition is evaluated, and those values also get bound to params
> that appear in an XSLT script.  The XSLT script then can produce a
> WSDL input message that includes those values.
> The precondition should be arranged so that all values required by the
> XSLT script are assigned either to input parameters or to local
> variables of the atomic process.
> XSLT params should be defined using the URIs of the required input
> parameters and local variables, as illustrated in the example below.
> We note that the binding of the XSLT params will not come "for free";
> that is, XSLT software will not know where to get those values
> from. That binding will need to be done by the execution environment
> (e.g., by preprocessing the XSLT script before it is evaluated).
> OWL-S allows that preconditions can be expressed in a variety of logic
> languages, including e.g. SWRL, DRS, RDQL, SPARQL, and KIF.  Here's an
> example that employes SWRL.  The thing to notice about this example is
> simply that evaluation of this precondition binds local variables
> #Firstname, #Lastname, and #Title to values contained in the input
> #Book.  These same values are then plugged in to the XSLT script (as
> xsl:params) when it gets processed.  The precondition is the following
> query expressed in SWRL:
>   (?Book :hasAuthor ?Author)
>   (?Author :hasFirstname ?Firstname)
>   (?Author :hasLastname ?Lastname)
>   (?Book :hasTitle ?Title)
> Also note that the grounding is still based on WSDL 1.1 (hence the
> reference to wsdlMessagePart), but this will be updated soon.
> <!-- For simplicity we omit the definitions of Book, Firstname,
>      Lastname, Title
>      "congo" is the namespace prefix for the example
>        ("http://www.example.org/congo")
>      "congo_wsdl" is the namespace prefix for the WSDL spec
>      "p" is the namespace prefix for owl-s/1.2/Process.owl
>      "e" is the namespace prefix for owl-s/1.2/generic/Expression.owl
>      "e" is the namespace prefix for owl-s/1.2/Grounding.owl
> -->
> <p:AtomicProcess rdf:ID="BookInfo">
>     <p:hasInput rdf:resource="#Book">
>     <p:hasLocal rdf:resource="#Firstname">
>     <p:hasLocal rdf:resource="#Lastname">
>     <p:hasLocal rdf:resource="#Title">
>     <p:hasPrecondition>
>        <e:Expression>
>            <e:expressionObject parsetype="Collection">
>               <swrl:IndividualPropertyAtom>
>                 <swrl:propertyPredicate rdf:resource="publ:hasAuthor"/>
>                 <swrl:argument1 rdf:resource="#Book"/>
>                 <swrl:argument2 rdf:resource="#Author"/>
>               </swrl:IndividualPropertyAtom>
>               <swrl:IndividualPropertyAtom>
>                 <swrl:propertyPredicate
>                   rdf:resource="publ:hasFirstname"/>
>                 <swrl:argument1 rdf:resource="#Author"/>
>                 <swrl:argument2 rdf:resource="#Firstname"/>
>               </swrl:IndividualPropertyAtom>
>               <swrl:IndividualPropertyAtom>
>                 <swrl:propertyPredicate
>                   rdf:resource="publ:hasFirstname"/>
>                 <swrl:argument1 rdf:resource="#Author"/>
>                 <swrl:argument2 rdf:resource="#Lastname"/>
>               </swrl:IndividualPropertyAtom>
>               <swrl:IndividualPropertyAtom>
>                 <swrl:propertyPredicate rdf:resource="publ:hasTitle"/>
>                 <swrl:argument1 rdf:resource="#Book"/>
>                 <swrl:argument2 rdf:resource="#Title"/>
>               </swrl:IndividualPropertyAtom>
>            </e:expressionObject>
>        </e:Expression>
>     </e:hasPrecondition>
> </e:AtomicProcess>
> <g:WsdlAtomicProcessGrounding>
>  <g:owlsProcess rdf:resource="#BookInfo>
>   <g:wsdlInput>
>    <g:XSLTInputMessageMap>
>     <grounding:wsdlMessagePart rdf:datatype="&xsd;#anyURI">
>        congo_wsdl:BookInfoMessagepart
>     </grounding:wsdlMessagePart>
>     <g:xsltTransformationString>
>      <![CDATA[
>       <xsl:stylesheet version="1.0"
>        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
>        xmlns:congo="http://www.example.org/congo">
>        <xsl:param name="congo:Firstname"/>
>        <xsl:param name="congo:Lastname"/>
>        <xsl:param name="congo:Title"/>
>        <xsl:template match="/">
>             <Book>
>                <author>
>                   <xsl:value-of select="$congo:Firstname"/>
>                   <xsl:value-of select="$congo:Lastname"/>
>                </author>
>                <title>
>                   <xsl:value-of select="$congo:Title"/>
>                </title>
>             </Book>
>        </xsl:template>
>      </xsl:stylesheet>
>     ]]>
>    </g:xsltTransformationString>
>   </g:XSLTInputMessageMap>
>  </g:wsdlInput>
> </g:WsdlAtomicProcessGrounding>
> Final note: In SWRL and DRS the input parameters and local parameters
> can be mentioned by their URI.  But that isn't true of SPARQL, RDQL,
> and KIF. When one of those languages is used a mapping is needed that
> explicitly shows the correspondence between atomic process variables
> and the corresponding variables mentioned in the precondition.  This
> requires a minor extension to the existing grounding ontology (which
> was mentioned at the beginning of this message).  This will be
> described in a separate message.

In wrapping up loose ends for the 1.2 release, I've addressed the
above by adding the following class VariableBinding and 3 related
properties, in Expression.owl.  These can be used to define a
correspondence between a variable mentioned in a quoted expression and
an OWL instance.  This is useful with expression languages (such as
KIF, RDQL, and SPARQL) in which the variables aren't identified using


The full declarations are given below.  I believe this is all
straightforward and non-controversial, but (as always) comments are

These changes were arrived at in OWL-S Coalition telecons, and also in
discussions with Daniel Elenius.

<owl:ObjectProperty rdf:ID="variableBinding">
   <rdfs:domain rdf:resource="#QuotedExpression"/>
   <rdfs:range rdf:resource="#VariableBinding"/>

<owl:Class rdf:ID="VariableBinding">
     This class is used to define a correspondence between a variable
     mentioned in an quoted expression and an OWL instance.  This is
     useful with expression languages in which the variables
     can't be identified using URIs.
       <owl:onProperty rdf:resource="#theVariable"/>
       <owl:onProperty rdf:resource="#theObject"/>

<owl:DatatypeProperty rdf:ID="theVariable">
     The value of this property is a substring of a QuotedExpression.
     The substring represents a variable in the language of the
     QuotedExpression.  For example, if the QuotedExpression is in KIF,
     the substring would be something like "?a".
   <rdfs:domain rdf:resource="#VariableBinding"/>

<owl:ObjectProperty rdf:ID="theObject">
     The range is not defined, and so the value of this property can
     be any OWL instance.
     When used to bind an OWL-S process precondition variable, however,
     the value of this property must be an instance of process:Parameter.
   <rdfs:domain rdf:resource="#VariableBinding"/>

(The 1.2 - still draft - version of Expression.owl is here:

Received on Wednesday, 4 January 2006 07:19:11 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:54:15 UTC