wsml logo

D32v0.1 WSML/RDF

WSML Working Draft 15 February 2006

This version
http://www.wsmo.org/TR/d32/v0.1/20060215/
Latest version
http://www.wsmo.org/TR/d32/v0.1/
Previous version
http://www.wsmo.org/TR/d32/v0.1/20060127/
Editor:
Jos de Bruijn
Authors:
Jos de Bruijn
Jacek Kopecký
Reto Krummenacher
Reviewers:
Atanas Kiryakov

For printing and off-line reading, this document is also available in non-normative PDF version.

Copyright © 2006 DERI ®, All Rights Reserved. DERI liability, trademark, document use, and software licensing rules apply.


Abstract

We introduce two distinct ways to relate WSML and RDF: The RDF representation of WSML describes the preferred way of representing WSML descriptions in RDF. Due to the context-free nature of RDF, not all of WSML is captured faithfully in this RDF representation. The RDF syntax is a serialization for WSML which syntactically uses RDF but diverges from the RDF semantics.


All tools and resources related to WSML can be found at: http://www.wsmo.org/wsml/wsml-syntax


Table of Contents


1. Introduction

We introduce two distinct ways to relate WSML and RDF:

RDF Representation

The RDF representation for WSML is the preferred way of representing WSML goals, web services, mediators and ontologies in RDF.

Because of the nature of RDF, where every triple can be interpreted separately, it is hard to accurately capture WSML, because many parts of WSML descriptions are context-dependent, for example, non-functional properties. In WSML, URIs are interpreted depending on their context, because their context is always clear. In RDF, there is no such distinction of context and therefore it is very hard to capture WSML completely in RDF.

The RDF representation of WSML is therefore not completely accurate with respect to standard WSML. For example, in the RDF representation, one cannot use the same identifier both for an attribute and a non-functional property. We believe, however, that such cases will occur seldom and that engineering tools should actually discourage such duplicate use of identifiers.

Below, we explain the relationship between WSML specifications and RDF graphs in Chapter 2. We present the RDF representation for WSML in Chapter 3. In Chapter 4 we introduce the formal mapping between WSML surface syntax and WSML/RDF. This mapping specifies the RDF graphs which can be derived from WSML specifications.

RDF Syntax

As pointed out above, the RDF representation of WSML does not accurately capture WSML. Therefore, we present the WSML RDF syntax in Chapter 5. This RDF syntax is a faithful representation of WSML using RDF triples. This representation, however, does not completely adhere to the RDF semantics, but can be used for exchanging WSML specification over the Semantic Web and using RDF tools for storing and retrieving WSML specifications.

We conclude with a summary in Chapter 6.

2. Relation between WSML and RDF

The Web Service Modeling Language (WSML) is a language for specifying ontologies (including their instances) and for describing various aspects of Web Services. In order to allow WSML data to become an integral part of the Semantic Web, we need an RDF representation, as it is assumed that the Semantic Web will most likely represent data in this format.

WSML data can be translated to RDF in a straightforward way, making WSML an ontology and the WSML data an instance of that ontology. The following listing shows a simple WSML document and how it could be translated into RDF (following D16.1 v0.21):

// trivial WSML ontology and Web service
namespace {ns _"http://example.com/"}
ontology ns:Transportation
   concept ns:Vehicle

webService ns:TicketService
   capability ns:TicketServiceCapability


// RDF triples (N3 representation) for the above information
@prefix ns: <http://example.com/>
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
@prefix wsml: <http://www.wsmo.org/wsml/wsml-syntax#>
ns:Transportation
    rdf:type wsml:ontology;
    wsml:hasConcept ns:Vehicle .

ns:Vehicle
    rdf:type wsml:concept .

ns:TicketService 
    rdf:type wsml:webService;
    wsml:useCapability ns:TicketServiceCapability

Such direct translation is a useful solution for most parts of WSML data, but it is suboptimal for WSML ontologies and their instances, because the direct translation of WSML to RDF does not indicate that WSML concepts are similar to RDF classes. In fact, the semantics of WSML concepts and RDF classes differ slightly (for example, rdfs:Resource is a class that contains all resources, i.e. everything, but there is no such concept in WSML; and rdfs:Class contains itself, which cannot be modeled in WSML).

The direct translation approach (taken originally by D16.1) is based on the assumption that WSML must be represented completely and accurately in RDF. This document relaxes this assumption, recognizing that the result harms reusability, and reusability is the main point of WSML/RDF. Therefore in this document we attempt to transform from WSML to RDF only those parts that are expressible in RDFS, trying to capture the intention of a WSML ontology, not all its properties. The main differences between WSML data and the same data after translation to RDF are listed below:

  1. WSML allows putting different and independent non-functional properties on entities with the same identifier but different type (concept, instance, attribute etc.), but in RDF non-functional properties are attached to the identifier, so in effect all the entities with the same name share the same non-functional properties. However, when multiple entities have the same IRI identifier, they must be considered the same in some sense already, so this limitation should not be a problem.
  2. In the RDF representation we model attribute values directly as triples, and we do the same for non-functional properties. To differentiate between non-functional properties and (functional) attribute values, we mark non-functional properties as members of the class owl:AnnotationProperty. The following listing illustrates the mapping:
    // wsml source data
    instance instA
      nonFunctionalProperties
        dc:title hasValue "Instance A"
      endNonFunctionalProperties
      attr hasValue "value"
    
    // resulting RDF triples
    instA dc:title "Instance A" .
    instA attr "value" .
    dc:title rdf:type owl:AnnotationProperty .
    This approach has the limitation that one identifier cannot be used as an attribute and as a non-functional property in the same ontology, but we do not expect this to be a problem.

In effect the RDF representation of WSML cannot reliably serve as syntax for WSML, but it is not intended to do so.

3. RDF representation for WSML

Please find the complete RDF Schema for WSML in Appendix A.

Non-functional properties in WSML are translated to ordinary triples in RDF. Additionally, for each non-functional property nfp, the following triple is added (with rdf and owl denoting the RDF and OWL namespaces, respectively):

:nfp rdf:type owl:AnnotationProperty .

In the remainder of the chapter, wsml stands for the namespace http://www.wsmo.org/wsml/wsml-syntax#, rdf stands for the namespace http://www.w3.org/1999/02/22-rdf-syntax-ns#, rdfs stands for the namespace http://www.w3.org/2000/01/rdf-schema#, owl stands for the namespace http://www.w3.org/2002/07/owl#, and xsd stands for the namespace http://www.w3.org/2001/XMLSchema#. Finally, prefix:localname stands for the concatenation of the namespace and the local name.

3.1. General structure of WSML/RDF graph

WSML descriptions group all data related to a particular ontology, Web service, goal or mediator in one description. This is achieved in the WSML surface syntax by grouping all descriptions under the ontology, webService, goal, ggMediator, wgMediator, wwMediator, and ooMediator keywords. The same holds for lower-level entities: concepts in an ontology, for example, group a number of attribute definitions and Web service capabilities group preconditions, postconditions, assumptions and effects. Conceptually, a WSML description can be seen as a part-whole hierarchy. An ontology has as parts the concept, relation, axiom, and instance definitions; in turn, these definitions are part of the ontology. Similarly it works for Web services, goals and mediators.

In WSML/RDF, WSML descriptions are part-whole hierarchies. For this purpose we reuse the part-whole ontology developed by the Semantic Web Best Practices Working Group: http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/part.owl.

Each ontology, Web service, goal, and mediator is a node in the RDF graph, which is connected to all its parts using the relationship hasPart_directly.[1] This is illustrated in Figure 1.

WSML Descriptions as part-whole hierarchy
Figure 1. WSML Descriptions as part-whole hierarchy

In some cases it is necessary to disambiguate between different parts of a whole using the hasPart property. This is for example the case for the preconditions, postconditions, assumptions and effects of a capability. For example, one axiom may be a precondition of one capability and a postcondition of another capability. For this reason, we define sub-properties of hasPart_directly, namely hasPrecondition, hasPostcondition, hasAssumption, and hasEffect.

Logical expressions defined in axioms are converted to XML literals, according to [WSML], Chapter 9.

The WSML top-level entities ontology, goal, webService, and mediator correspond to RDFS classes. These RDFS class, together with the properties which can be used in combination with these classes, are listen in Tables 1 and 2.

Table 1. Classes for top-level elements of WSML/RDF
Class WSML entity Has parts Remarks
wsml:ontology ontology (2.3) wsml:concept, wsml:relation, wsml:instance, wsml:relationInstance, wsml:axiom The WSML variant is indicated using the property wsml:variant.
wsml:goal goal (2.5) wsml:capability, wsml:interface The WSML variant is indicated using the property wsml:variant.
wsml:webService webService (2.7) wsml:capability, wsml:interface The WSML variant is indicated using the property wsml:variant.
wsml:mediator (2.6) The WSML variant is indicated using the property wsml:variant. Source, target and used service are indicated using the respective properties.
Table 2. Properties for top-level elements of WSML/RDF
Property WSML entity Range Remarks
wsml:variant wsmlVariant (2.2.1) Use one of the standard URIs for WSML variants.
wsml:importsOntology importsOntology (2.2.3) wsml:ontology
wsml:usesMediator usesMediator (2.2.3) wsml:mediator

3.2. IRIs and data values

As can be seen from [WSML], Section 2.1.2, there are three kinds of identifiers in WSML:

3.3. Ontologies

Table 3 describes the different classes used for representing entities in WSML ontologies. The section on the WSML specification [WSML] which describes the particular WSML entity is mentioned in parenthesis. The parts comprising the whole are listed in the 3rd column.

Table 4 lists the properties one can use in ontology definitions. In case there are several classes mentioned in the domain or range of a property, separated with a comma ',', these should be interpreted disjunctively, i.e., the domain (range) is a member of one of these classes, but not necessarily all.

Table 3. Classes for ontologies in WSML/RDF
Class WSML entity Has parts Remarks
wsml:concept concept (2.3.1) wsml:attributeDefinition is a subclass of rdfs:Class
wsml:relation relation (2.3.2) rdf:List of wsml:parameterDefinition
wsml:instance instance (2.3.4)
wsml:relationInstance relationInstance (2.3.4) rdf:List of rdfs:Resource A relationInstance has a (single) rdf:List of values, the ordered list of parameter values.
wsml:axiom axiom (2.3.4) The logical expression, in WSML/XML format, is linked to the axiom via rdfs:isDefinedBy.
wsml:attributeDefinition (2.3.1) An attribute definition is part of a concept and has an associated attribute, an possibly range restrictions and min/max cardinalities.
wsml:reflexiveAttributeDefinition (2.3.1) A reflexive attribute definition. This is a rdfs:subClassOf attributeDefinition.
wsml:symmetricAttributeDefinition (2.3.1) A symmetric attribute definition. This is a rdfs:subClassOf attributeDefinition.
wsml:transitiveAttributeDefinition (2.3.1) A transitive attribute definition. This is a rdfs:subClassOf attributeDefinition.
wsml:attribute (2.3.1) An attribute is associated with a particular attribute definition.
wsml:parameterDefinition (2.3.2) A relation may have a (single) rdf:List of parameter definitions, each restricted with the property wsml:ofType or wsml:impliesType.
Table 4. Properties for ontologies in WSML/RDF
Property WSML entity Domain Range
wsml:forAttribute wsml:attributeDefinition wsml:attribute
wsml:ofType ofType (2.3.1) wsml:attributeDefinition, wsml:parameterDefinition wsml:concept
wsml:impliesType impliesType (2.3.1) wsml:attributeDefinition, wsml:parameterDefinition wsml:concept
wsml:maxCardinality (2.3.1) wsml:attributeDefinition xsd:nonNegativeInteger
wsml:minCardinality (2.3.1) wsml:attributeDefinition xsd:nonNegativeInteger
wsml:inverseOf inverseOf (2.3.1) wsml:attributeDefinition wsml:attribute
wsml:arity (2.3.2) wsml:relation xsd:nonNegativeInteger
wsml:subRelationOf subRelationOf (2.3.2) wsml:relation wsml:relation

Example 2.1 Given the following WSML ontology:

wsmlVariant _"http://www.wsmo.org/wsml/wsml-syntax/wsml-flight"
namespace {_"http://example.org/bookOntology#",
        dc _"http://purl.org/dc/elements/1.1/"}
ontology _"http://example.org/amazonOntology"
  nonFunctionalProperties
    dc#title hasValue "Example Book ontology"
    dc#description hasValue "Example ontology about books and shopping carts"
  endNonFunctionalProperties
    concept book
        title ofType _string
        hasAuthor ofType author
    concept author subConceptOf person
        authorOf inverseOf(hasAuthor) ofType book
    concept cart
      nonFunctionalProperties
        dc#description hasValue "A shopping cart has exactly one id
          and zero or more items, which are books."
      endNonFunctionalProperties
        id ofType (1) _string
        items ofType book
    instance crimeAndPunishment memberOf book
        title hasValue "Crime and Punishment"
        hasAuthor hasValue dostoyevsky

    relation authorship(impliesType author, impliesType document)
      nonFunctionalProperties
        dc#relation hasValue authorshipFromAuthor
      endNonFunctionalProperties

    axiom authorshipFromAuthor
      definedBy
        authorship(?x,?y) :- ?x[authorOf hasValue ?y] memberOf author.
  

The WSML/RDF representation is the following (using N3 notation):

  @prefix :
        <http://example.org/bookOntology#>.
  @prefix dc:
        <http://purl.org/dc/elements/1.1/>. 
  @prefix wsml:
        <http://www.wsmo.org/wsml/wsml-syntax#>.
  @prefix part-whole:
        <http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/part.owl#>.
  @prefix rdf:
        <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
  @prefix rdfs:
        <http://www.w3.org/2000/01/rdf-schema#>.
  @prefix xsd:
        <http://www.w3.org/2001/XMLSchema#>.
        
   <http://example.org/amazonOntology>
          rdf:type wsml:ontology;
          wsml:variant, <http://www.wsmo.org/wsml/wsml-syntax/wsml-flight>
          dc:title "Example Book ontology";
          dc:description "Example ontology about books and shopping carts".
      dc:title rdf:type owl:AnnotationProperty.
      dc:description rdf:type owl:AnnotationProperty.

   <http://example.org/bookOntology>
      part-whole:hasPart_directly :book;
      part-whole:hasPart_directly :author;
      part-whole:hasPart_directly :cart;
      part-whole:hasPart_directly :crimeAndPunishment;
      part-whole:hasPart_directly :authorship;
      part-whole:hasPart_directly :authorshipFromAuthor.
    
   :book
      rdf:type wsml:concept;
      part-whole:hasPart_directly _:title;
      part-whole:hasPart_directly _:hasAuthor.
    
   _:title
      rdf:type wsml:attributeDefinition;
      wsml:forAttribute :title;
      wsml:ofType xsd:string.
           
   _:hasAuthor
      rdf:type wsml:attributeDefinition;
      wsml:forAttribute :hasAuthor;
      wsml:ofType :author.

   :author 
      rdf:type wsml:concept;
      rdfs:subClassOf :person;
      part-whole:hasPart_directly _:authorOf.
    
   _:authorOf
      rdf:type wsml:attributeDefinition;
      wsml:forAttribute :authorOf;
      wsml:ofType :book;
      wsml:inverseOf :hasAuthor.

   :cart
      rdf:type wsml:concept;
      dc:description "A shopping cart has exactly one id
          and zero or more items, which are books.";
      part-whole:hasPart_directly _:id;
      part-whole:hasPart_directly _:items.

   _:id
      rdf:type wsml:attributeDefinition;
      wsml:forAttribute :id;
      wsml:ofType xsd:string;
      wsml:minCardinality "1"^^xsd:integer;
      wsml:maxCardinality "1"^^xsd:integer.
          
   _:items
      rdf:type wsml:attributeDefinition;
      wsml:forAttribute :items;
      wsml:ofType :book.
            
   :crimeAndPunishment 
      rdf:type wsml:instance;
      rdf:type :book;
      :title "Crime and Punishment";
      :hasAuthor :dostoyevsky.

   :authorship
      rdf:type wsml:relation;
      dc:relation authorshipFromAuthor;
      part-whole:hasPart_directly _:list1.
    
   _:list1
      rdf:first _:par1;
      rdf:rest _:list2.
        
   _:list2
      rdf:first _:par2;
      rdf:rest rdf:nil.
        
   _:par1
      rdf:type wsml:parameterDefinition;
      wsml:impliesType :author.
        
   _:par2
      rdf:type wsml:parameterDefinition;
      wsml:impliesType :document.

   :authorshipFromAuthor
      rdf:type wsml:axiom;
      rdfs:isDefinedBy "<impliedByLP><atom name="http://example.org/bookOntology#authorship">
          <term name="?x"/><term name="?y"/></atom>
          <and>
              <molecule><term name="?x"/><isa type="memberOf"><term name="?y"/></isa></molecule>
              <molecule><term name="?x"/>
                  <attributeValue>
                      <term name="http://example.org/bookOntology#authorOf"/>
                      <term name="?y"/>
                  </attributeValue>
              </molecule>
          </and></impliedByLP>"^^rdf:XMLLiteral.

3.4. Goals and Web Services

Tables 5 and 6, respectively, describe the classes and properties used for goals and web services in WSML/RDF.

Table 5. Classes for goals and web services in WSML/RDF
Class WSML entity Has parts Remarks
wsml:capability capability (2.4.1) wsml:axiom The parts of the capability, namely the axioms, are subdivided into preconditions, postconditions, assumptions and effects by the use of the properties wsml:hasPrecondition, wsml:hasPostcondition, wsml:hasAssumption, and wsml:hasEffect, respectively.
wsml:interface interface (2.4.2) wsml:choreography, wsml:orchestration
wsml:choreography choreography (2.4.2) Choreographies are external to WSML.
wsml:orchestration orchestration (2.4.2) Orchestrations are external to WSML.
Table 6. Properties for goal and web services in WSML/RDF
Property WSML entity Domain Range
wsml:hasPrecondition precondition (2.4.1) wsml:capability wsml:axiom
wsml:hasPostcondition postcondition (2.4.1) wsml:capability wsml:axiom
wsml:hasAssumption assumption (2.4.1) wsml:capability wsml:axiom
wsml:hasEffect effect (2.4.1) wsml:capability wsml:axiom
wsml:sharedVariable sharedVariables (2.4.1) wsml:capability xsd:string

3.5. Mediators

Tables 7 and 6, respectively, describe the classes and properties used for mediators in WSML/RDF.

Table 7. Classes for mediators in WSML/RDF
Class WSML entity Has parts Remarks
wsml:ooMediator ooMediator (2.6.1) Sub-class of wsml:mediator
wsml:wwMediator wwMediator (2.6.3) Sub-class of wsml:mediator
wsml:ggMediator ggMediator (2.6.3) Sub-class of wsml:mediator
wsml:wgMediator wgMediator (2.6.4) Sub-class of wsml:mediator
Table 8. Properties for mediators in WSML/RDF
Property WSML entity Domain Range
wsml:source source (2.6) wsml:mediator wsml:mediator, wsml:ontology, wsml:goal, wsml:webService
wsml:target source (2.6) wsml:mediator wsml:mediator, wsml:ontology, wsml:goal, wsml:webService
wsml:usesService usesService (2.6) wsml:mediator wsml:mediator, wsml:goal, wsml:webService

4. Translating WSML to the RDF Representation

This section will contain a mapping from the WSML surface syntax to RDF. The mapping will be created as soon at there is agreement on the RDF representation of WSML. See Appendix A for the RDF Schema.

In this chapter an RDF [RDF] representation for WSML is introduced. The vocabulary used is an extension of the RDF Schema vocabulary defined in [Brickley & Guha, 2004]. The extension consists of WSML language components, as given in the previous chapters and the class owl:AnnotationProperty used to model the Non-Functional Properties available in WSML.

The big advantage of having an RDF/WSML representation encoded in <subject><predicate><object>-triples and of reusing the RDFS-vocabulary as much as possible, is the fact that there are many existing RDF(S)-based tools available. These tools are optimized to handle triples and are thus able to process the semantics of our specification and in a more general sense we can guarantee inter-operability with those.

Table 4.1 defines the mapping function T from WSML entities to RDF triples. Logical expressions are not translated to RDF. Instead, they are translated to the WSML/XML syntax and are specified as literals of type rdf:XMLLiteral. The transformation creates an RDF-graph based on above introduced RDF-triples. As definitions, i.e., top-level entities like ontologies, Web services, goals and mediators are disjoint constructs, their graphs are not inter-related. In other words the transformation defines one graph per definition. Note that in the table we use the N3 notation's prefix mechanism to abbreviate IRIs. The following prefix are applied:

In Table 4.1, A,B,C,Z stand for identifiers, D stands for a datatype identifier, DVi stands for an integer value, DVd stands for a decimal, and DVs stands for a string data value, and k,m,n are integer numbers.

The basic namespace for the WSML predicates and classes is http://www.wsmo.org/wsml/wsml-syntax#. This is in fact the namespace for all elements in WSML.

Before transforming WSML into the RDF/WSML representation the following pre-processing steps need to be performed:

The most significant 64 bits:

Name Bits Example
time_low 0xFFFFFFFF00000000 989C6E5C
time_mid 0x00000000FFFF0000 2CC1
version 0x000000000000F000 11CA
time_hi 0x0000000000000FFF 11CA

The least significant 64 bits:

Name Bits Example
variant 0xE000000000000000 9044
clock_seq 0x1FFF000000000000 9044
node 0x0000FFFFFFFFFFFF 08002B1BB4F5
   

A Universally Unique Identifier (UUDI) is a 128 bits long identifier and is guaranteed to be unique across space and time and requires no central registration.
The 128 bits are put together as listed above (from most to least significant), more details about the different elements of an UUID can be found in [RFC4122].

Table 4.1: Mapping to the RDF representation
WSML syntax RDF Triples Remarks
T (
wsmlVariant A
  definition
)
T(definition, A) A definition is one (1) Ontology, Goal, Web service or Mediator description
namespace { N,
  P1 N1
  ...
  Pn Nn }
  Because sQnames were resolved to full IRIs during pre-processing, there is no translation to RDF necessary for namespace definitions.

If for example the N3 notation is applied as in the examples above, the namespaces are given by @prefix statements of the form:
@prefix : N .
@prefix P1: N1
T (
ontology A
  header1
  ...
  headern
  ontology_element1
  ...
  ontology_elementn
, Z )
A rdf:type wsml:ontology
A wsml:variant Z
T(header1, A)
...
T(headern, A)
T(ontology_element1, A)
...
T(ontology_elementn, A)
An ontology_element represents possible content of an ontology definition, i.e., concepts, relations, instances, ...
T (
concept A
  subConceptOf {B1,...,Bn}
  nfp
  attribute1
  ...
  attributen
, Z )
Z part-whole:hasPart_directly A
A rdf:type wsml:concept
T(nfp, A)
A rdfs:subClassOf B1
...
A rdfs:subClassOf Bn
T(attribute1, A)
...
T(attributen, A)
 
T (
A attributefeature1 ... attributefeaturen ofType cardinality C
  nfp
, Z )
Z part-whole:hasPart_directly _:X
_:X rdf:type wsml:attributeDefinition
_:X wsml:forAttribute A
T(attributefeature1, _:X)
...
T(attributefeaturen, _:X)
T(cardinality, _:X)
_:X wsml:ofType C
T(nfp, _:X)
The blank identifier_:X denotes a helper node to bind the attribute A to its definition of cardinality, symmetry, ...
T (
A attributefeature1 ... attributefeaturen impliesType cardinality C
  nfp
, Z )
Z part-whole:hasPart_directly _:X
_:X rdf:type wsml:attributeDefinition
_:X wsml:forAttribute A
T(attributefeature1, _:X)
...
T(attributefeaturen, _:X)
T(cardinality, _:X)
_:X wsml:impliesType C
T(nfp, _:X)
The blank identifier_:X denotes a helper node to bind the attribute A to its definition of cardinality, symmetry, ...
T (
transitive
, Z )
Z rdf:type wsml:transitiveAttributeDefinition  
T (
symmetric
, Z )
Z rdf:type wsml:symmetricAttributeDefinition  
T (
reflexive
, Z )
Z rdf:type wsml:reflexiveAttributeDefinition  
T (
inverseOf(A)
, Z )
Z wsml:inverseOf A  
T (
(m n)
, Z )
Z wsml:minCardinality "m"^^xsd:integer
Z wsml:maxCardinality "n"^^xsd:integer
 
T (
(card)
, Z )
Z wsml:minCardinality "card"^^xsd:integer
Z wsml:maxCardinality "card"^^xsd:integer
 
T (
instance A
  memberOf C1,...,Cn
  nfp
  attributevalue1
  ...
  attributevaluen
, Z )
Z part-whole:hasPart_directly A
A rdf:type wsml:instance
A rdf:type C1
...
A rdf:type Cn
T(nfp, A)
T(attributevalue1, A)
...
T(attributevaluen, A)
 
T (
A hasValue value
, Z )
Z A T(value)  
T (
A hasValue { value1,...,valuen }
, Z )
Z A T(value1)
...
Z A T(valuen)
 
T (
DVs
)
DVs^^xsd:string Strings are already enclosed with double quotes in WSML; these do not have to be added for the RDF literals.
T (
DVi
)
"DVi"^^xsd:integer  
T (
DVd
)
"DVd"^^xsd:decimal  
T (
D(a1,...,an)
)
Tserializer(D(a1,...,an))^^Tdatatypes(D) Tserializer serializes the WSML representation of a data value to a string representation which can be readily used in RDF literals. This function is not yet defined.
Tdatatypes maps WSML datatypes to XML Schema datatypes, according to Table C.1 in Appendix C of D16.1.
T (
A
)
A IRIs are directly used in RDF.
T (
relation A / n (B1,...Bm)
  subRelationOf {C1,...,Ck}
  nfp
, Z )
Z part-whole:hasPart_directly A
A rdf:type wsml:relation
A wsml:arity "n"^^xsd:nonNegativeInteger
A part-whole:hasPart_directly _:l1
_:l1 rdf:first _:p1
_:l1 rdf:rest _:l2
...
_:ln rdf:first _:pn
_:ln rdf:rest rdf:nil

_:p1 rdf:type wsml:parameterDefinition
T(B1, _:p1)
...
_:pn rdf:type wsml:parameterDefinition
T(Bm, _:pn)
A wsml:subRelationOf C1
...
A wsml:subRelationOf Ck
T(nfp, A)
The parameters of a relation are unnamed and thus ordered. The ordering in RDF is provided by use of the rdf:List.
T (
ofType B
, Z )
Z wsml:ofType B  
T (
impliesType B
, Z )
Z wsml:impliesType B  
T (
relationInstance A B
(valuelist)
  nfp
, Z)
Z part-whole:hasPart_directly A
A rdf:type wsml:relationInstance
A rdf:type B
T(valuelist, A)
T(nfp, A)
 
T (
value1,..., valuen
, Z )
Z part-whole:hasPart_directly _:l1
_:l1 rdf:first T(value1)
_:l1 rdf:rest _:l2
...
_:ln rdf:first T(valuen)
_:ln rdf:rest rdf:nil
The values of a relationInstance are unnamed and thus ordered. The ordering in RDF is provided by use of the rdf:List.
T (
axiom A
  axiomdefinition
, Z )
Z part-whole:hasPart_directly A
A rdf:type wsml:axiom
T(axiomdefinition, A)
 
T (
  nfp
  definedBy
    log_expr
)
T(nfp, A)
A rdfs:isDefinedBy "TXML(log_expr)"^^rdf:XMLLiteral
log_expr denotes a logical expression. The logical expressions are translated to literals of type rdf:XMLLiteral using the mapping function defined in Table 9.2 of D16.1
T (
nonFunctionalProperties
  A1 hasValue { value11,...,value1n }
  ...
  An hasValue { valuen1,...,valuenn }
endNonFunctionalProperties
, Z )
Z A1 T(value11)
...
Z A1 T(value1n)
A1 rdf:type owl:AnnotationProperty
...
Z An T(valuen1)
...
Z An T(valuenn)
An rdf:type owl:AnnotationProperty
 
T (
nfp
  A1 hasValue { value11,...,value1n }
  ...
  An hasValue { valuen1,...,valuenn }
endnfp
, Z )
Z A1 T(value11)
...
Z A1 T(value1n)
A1 rdf:type owl:AnnotationProperty
... Z An T(valuen1)
...
Z An T(valuenn)
An rdf:type owl:AnnotationProperty
 
T (
importsOntology { A1,...,An}
, Z )
Z wsml:importsOntology A1
...
Z wsml:importsOntology An
 
T (
usesMediator {B1,...,Bn}
, Z )
Z wsml:usesMediator B1
...
Z wsml:usesMediator Bn
 

5. RDF Syntax for WSML

In this chapter the mapping to the fully round-trip supporting WSML/RDF syntax is presented (Table 5.1). In contrast to the RDF representation introduced previously, this syntax allows for the translation of the whole information content of a WSML document. It however still contains the known flaws mentioned in the Introduction.

For the translation of WSML surface syntax to the WSML/RDF syntax presented in this chapter depends on the same pre-processing steps as given in the previous chapter.

Furthermore the readers are asked to consider the same namespace-prefix bindings as given in Chapter 4. There is however one exception: to distinguish between the vocabularies used for the RDF representation and the WSML/RDF syntax the prefix 'wsmlrdf' is introduced to represent the namespace 'http://www.wsmo.org/wsml/wsml-rdf-syntax#'.

Table 5.1: Mapping to the WSML/RDF syntax
WSML syntax RDF Triples Remarks
T (
wsmlVariant A
  definition1
  ...
  definitionn
)
T(definition1, A)
...
T(definitionn, A)
definitions are Ontology, Goal, WebService and Mediators
namespace { N,
  P1 N1
  ...
  Pn Nn }
  Because sQnames were resolved to full IRIs during pre-processing, there is no translation to RDF necessary for namespace definitions
T (
ontology A
  header1
  ...
  headern
  ontology_element1
  ...
  ontology_elementn
, Z )
A rdf:type wsmlrdf:ontology
A wsmlrdf:variant Z
T(header1, A)
...
T(headern, A)
T(ontology_element1, A)
...
T(ontology_elementn, A)
An ontology_element represents possible content of an ontology definition, i.e., concepts, relations, instances, ...
T (
concept A
  subConceptOf {B1,...,Bn}
  nfp
  attribute1
  ...
  attributen
, Z )
Z wsmlrdf:hasConceptDescription _:X
_:X wsmlrdf:hasConcept A
T(nfp, _:X)
_:X rdfs:subClassOf B1
...
_:X rdfs:subClassOf Bn
T(attribute1, _:X)
...
T(attributen, _:X)
 
T (
A attributefeature1 ... attributefeaturen ofType cardinality C
  nfp
, Z )
_:X wsmlrdf:attribute A
T(attributefeature1, _:X)
...
T(attributefeaturen, _:X)
_:X wsmlrdf:ofType C
T(cardinality, _:X)
T(nfp, _:X)
Z wsmlrdf:hasAttribute _:X
The blank identifier_:X denotes a helper node to bind the attribute A to a defined owner: attributes are locally defined!
T (
A attributefeature1 ... attributefeaturen impliesType cardinality C
  nfp
, Z )
_:X wsmlrdf:attribute A
T(attributefeature1, _:X)
...
T(attributefeaturen, _:X)
_:X rdfs:range C
T(cardinality, _:X)
T(nfp, _:X)
Z wsmlrdf:hasAttribute _:X
 
T (
transitive
, Z )
Z rdf:type wsmlrdf:transitiveAttribute  
T (
symmetric
, Z )
Z rdf:type wsmlrdf:symmetricAttribute  
T (
reflexive
, Z )
Z rdf:type wsmlrdf:reflexiveAttribute  
T (
inverseOf(A)
, Z )
Z wsmlrdf:inverseOf A  
T (
(m n)
, Z )
Z wsmlrdf:minCardinality m
Z wsmlrdf:maxCardinality n
 
T (
(card)
, Z )
Z wsmlrdf:minCardinality card
Z wsmlrdf:maxCardinality card
 
T (
instance A
  memberOf C1,...,Cn
  nfp
  attributevalue1
  ...
  attributevaluen
, Z )
Z wsmlrdf:hasInstanceDescription _:X
_:X wsmlrdf:hasInstance A
_:X rdf:type C1
...
_:X rdf:type Cn
T(nfp, _:X)
T(attributevalue1, _:X)
...
T(attributevaluen, _:X)
It is not required to associate an instance with an identifier. In that case the identifier J is replaced by a blank node identifier, e.g _:X.
The same counts for all entities that do not require an ID: instance, relationInstance, but also goal, mediators, webService and capabilty and interface definitions.
T (
dc#title hasValue value
, Z )
Z rdfs:label T(value)  
T (
dc#description hasValue value
, Z )
Z rdfs:comment T(value)  
T (
dc#relation hasValue value
, Z )
Z rdfs:seeAlso T(value)  
T (
A hasValue value
, Z )
Z A T(value)  
T (
DVs
)
DVs^^xsd#string Strings are already enclosed with double quotes in WSML; these do not have to be added for the RDF literals.
T (
DVi
)
"DVi"^^xsd#integer  
T (
DVd
)
"DVd"^^xsd#decimal  
T (
D(a1,...,an)
)
Tserializer(D(a1,...,an))^^Tdatatypes(D) Tserializer serializes the WSML representation of a data value to a string representation which can be readily used in RDF literals. This function is not yet defined.
Tdatatypes maps WSML datatypes to XML Schema datatypes, according to Table C.1 in Appendix C.
T (
A
)
A IRIs are directly used in RDF.
T (
relation A / n (B1,...Bm)
  subRelationOf {C1,...,Ck}
  nfp
, Z )
Z wsmlrdf:hasRelationDescription _:X1 _:X1 wsmlrdf:hasRelation A
_:X1 wsmlrdf:arity "n"^^xsd#integer
_:X1 wsmlrdf:param _:X
_:X rdf:type rdf:List
_:X rdf:first _:X1
T(B1, _:X1)
_:X rdf:rest _:1
_:1 rdf:type rdf:List
_:1 rdf:first _:X2
...
_:m rdf:type rdf:List
_:m rdf:first _:Xn
T(Bm, _:Xn)
_:X1 wsmlrdf:subRelationOf C1
...
_:X1 wsmlrdf:subRelationOf Ck
T(nfp, _:X1)
The parameters of a relation are unnamed and thus ordered. The ordering in RDF is provided by use of the rdf:List.
T (
ofType C
, Z )
Z wsmlrdf:ofType C  
T (
impliesType C
, Z )
Z rdfs:range C  
T (
relationInstance A B
(valuelist)
  nfp
, Z)
Z wsmlrdf:hasRelationInstanceDescription _:X _:X wsmlrdf:hasRelationInstance A
_:X rdf:type B
T(valuelist, _:X)
T(nfp, _:X)
 
T (
value1,...,valuen
, Z )
Z wsmlrdf:param _:X
_:X rdf:type rdf:List
_:X rdf:first T(value1)
_:X rdf:rest _:1
_:1 rdf:type rdf:List
_:1 rdf:first T(value2)
_:1 rdf:rest _:2
...
_:m rdf:type rdf:List
_:m rdf:first T(valuen)
The arguments of a relationinstance are unnamed and thus ordered. The ordering in RDF is provided by use of the rdf:List.
T (
axiom A
  axiomdefinition
, Z )
Z wsmlrdf:hasAxiomDescription _:X _:X wsmlrdf:hasAxiom A
T(axiomdefinition, _:X)
 
T (
  nfp
  definedBy
    log_expr
)
T(nfp, A)
A rdfs:isDefinedBy "TXML(log_expr)"^^rdf:XMLLiteral
log_expr denotes a logical expression. The logical expressions are translated to literals of type rdf:XMLLiteral using the mapping function defined in Table 9.2 of D16.1
T (
goal A
  header1
  ...
  headern
  capability
  interface1
  ...
  interfacen
, Z)
A wsmlrdf:variant Z
A rdf:type wsmlrdf:goal
T(header1, A)
...
T(headern, A)
T(capability, A)
T(interface1, A)
...
T(interfacen, A)
 
T (
ooMediator A
  nfp
  importsontology
  source
  target
  use_service
, Z)
A wsmlrdf:variant Z
A rdf:type wsmlrdf:ooMediator
T(nfp, A)
T(importsontology, A)
T(source, A)
T(target, A)
T(use_service, A)
 
T (
ggMediator A
  nfp
  importsontology
  source
  target
  use_service
, Z)
A wsmlrdf:variant Z
A rdf:type wsmlrdf:ggMediator
T(nfp, A)
T(importsontology, A)
T(source, A)
T(target, A)
T(use_service, A)
 
T (
wgMediator A
  nfp
  importsontology
  source
  target
  use_service
, Z)
A wsmlrdf:variant Z
A rdf:type wsmlrdf:wgMediator
T(nfp, A)
T(importsontology, A)
T(source, A)
T(target, A)
T(use_service, A)
 
T (
wwMediator A
  nfp
  importsontology
  source
  target
  use_service
, Z)
A wsmlrdf:variant Z
A rdf:type wsmlrdf:wMediator
T(nfp, A)
T(importsontology, A)
T(source, A)
T(target, A)
T(use_service, A)
 
T (
source { A1,...,An }
, Z)
Z wsmlrdf:source A1
  ...
Z wsmlrdf:source An
 
T (
target A
, Z)
Z wsmlrdf:target A  
T (
usesService A
, Z)
Z wsmlrdf:usesService A  
T (
webService A
  header1
  ...
  headern
  capability
  interface1
  ...
  interfacen
, Z )
A wsmlrdf:variant Z
A rdf:type wsmlrdf:webService
T(header1, A)
...
T(headern, A)
T(capability, A)
T(interface1, A)
...
T(interfacen, A)
 
T (
capability C
  header1
  ...
  headern
  sharedvardef
  pre_post_ass_or_eff1
  ...
  pre_post_ass_or_effn
, Z )
Z wsmlrdf:useCapabilty C

T(header1, C)
...
T(headern, C)
T(sharedvardef, C)
T(pre_post_ass_or_eff1, C)
...
T(pre_post_ass_or_effn, C)
pre_post_ass_or_eff reunites the axiom definitions for precondition, assumption, postcondition and effect.
T (
sharedVariables {?v1, ..., ?vn}
, Z)
Z wsmlrdf:sharedVariables ?v1
...
Z wsmlrdf:sharedVariables ?vn
Please note that instead of simply using a triple per shared variable it is possible to apply the rdf:Bag container to better describe the group character of shared variables.
T (
precondition B
  axiomdefinition
, Z)
Z wsmlrdf:precondition B
T(axiomdefinition, B)
 
T (
assumption B
  axiomdefinition
, Z)
Z wsmlrdf:assumption B
T(axiomdefinition, B)
 
T (
postcondition B
  axiomdefinition
, Z)
Z wsmlrdf:postcondition B
T(axiomdefinition, B)
 
T (
effect B
  axiomdefinition
, Z)
Z wsmlrdf:effect B
T(axiomdefinition, B)
 
T (
interface A
  header1
  ...
  headern
  choreography
  orchestration
, Z )
Z wsmlrdf:useInterface A
T(header1, A)
...
T(headern, A)
T(choreography, A)
T(orchestration, A)
 
T (
choreography C
, Z )
Z wsmlrdf:choreography C  
T (
orchestration A
, Z )
Z wsmlrdf:orchestration A  
T (
nonFunctionalProperties
  attributevalue1
  ...
  attributevaluen
endNonFunctionalProperties
, Z )
Z wsmlrdf:nfp _:P1
T(attributevalue1, _:P1)
...
Z wsmlrdf:nfp _:Pn
T(attributevaluen, _:Pn)
 
T (
nfp
  attributevalue1
  ...
  attributevaluen
endnfp
, Z )
Z wsmlrdf:nfp _:P1
T(attributevalue1, _:P1)
...
Z wsmlrdf:nfp _:Pn
T(attributevaluen, _:Pn)
 
T (
importsOntology { A1,...,An}
, Z )
Z wsmlrdf:importsOntology A1
...
Z wsmlrdf:importsOntology An
 
T (
usesMediator {B1,...,Bn}
, Z )
Z wsmlrdf:usesMediator B1
...
Z wsmlrdf:usesMediator Bn
 

6. Summary

In this deliverable we have presented the RDF representation as well as the RDF syntax of WSML. The RDF representation comes with an RDF Schema ontology which describes its classes and properties. Both the RDF representation and the RDF syntax come with a formal mapping from the surface syntax of WSML to the RDF representation and syntax, respectively.

The RDF representation captures that part of WSML which can be captured in the spirit of RDF. This means that in the RDF representation one cannot, in general, use the same identifier in different contexts (e.g., as both non-functional property and attribute). We believe, however, that this is not a significant limitation.

The RDF syntax is a faithful representation of WSML using RDF triples. This means that this syntax is an alternative syntax for WSML, just like the surface syntax and XML syntax presented in the WSML specification. The advantage of using this RDF syntax over the surface syntax and XML syntax is that one can use RDF tools for storing, retrieving and manipulating WSML specifications.

Appendix A. The RDFS ontology for WSML/RDF

The complete RDF Schema for WSML can also be found here.

Once the ontology is finalized, it will be accessible at a standardized URI and at http://www.wsmo.org/wsml/wsml-syntax for RDF-aware agents.


<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE rdf:RDF [
     <!ENTITY rdf  'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
     <!ENTITY wsml 'http://www.wsmo.org/wsml/wsml-syntax#'>
     <!ENTITY wsmo 'http://www.wsmo.org/TR/d2/#'>
     <!ENTITY rdfs 'http://www.w3.org/2000/01/rdf-schema#'>
     <!ENTITY xsd  'http://www.w3.org/2001/XMLSchema#'>
     <!ENTITY owl  'http://www.w3.org/2002/07/owl#'>
     <!ENTITY dc   'http://purl.org/dc/elements/1.1/'>
     <!ENTITY part-whole 'http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/part.owl#'>
]>

<rdf:RDF xmlns:rdf="&rdf;"
     xmlns:wsml="&wsml;"
     xmlns:rdfs="&rdfs;"
     xmlns:wsmo="&wsmo;"
     xmlns:dc="&dc;"
     xmlns:owl="&owl;"
     xmlns:part-whole="&part-whole;"
     xml:base="http://www.wsmo.org/wsml/wsml-syntax">
     
<!-- In the definition of the WSML vocabulary, we reuse the following vocabularies:

RDF: http://www.w3.org/1999/02/22-rdf-syntax-ns#
RDFS: http://www.w3.org/2000/01/rdf-schema#
XSD: http://www.w3.org/2001/XMLSchema#
OWL: http://www.w3.org/2002/07/owl#
DC (Dublin Core): http://purl.org/dc/elements/1.1/
Part-Whole relations (from the SWBP WG): http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/part.owl#
  see also: http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/

Non-functional properties are captured using the owl:AnnotationProperty. Each NFP is made 
  rdf:type owl:AnnotationProperty

Note that this ontology was written in the spirit of RDF: any RDF processor may use the statements which 
it can work with and will ignore all statements it cannot work with. For example, in case the RDF processor 
cannot deal with owl:sameAs, it will not. This ontology was explicitly not constructed to fall inside any 
of the species of OWL, although it necessarily falls inside OWL Full, since every RDF graph is 
a valid OWL Full ontology.
 -->
     
<!-- WSML top-level entities -->

<rdfs:Class rdf:ID="ontology"
     rdfs:label="ontology">
    <rdfs:comment>
        An ontology can be seen as a part-whole hierarchy. An ontology (whole) has parts concepts, 
        relations, instances, axioms and relation instances. A concept (whole) has parts attribute 
        definitions.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="webService"
     rdfs:label="webService">
    <rdfs:comment>
        A web service can be seen as a part-whole hierarchy. A web service (whole) has parts 
        (at most one) capability and (possibly multiple) interfaces.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="goal"
     rdfs:label="goal">
    <rdfs:comment>
        A goal can be seen as a part-whole hierarchy. A goal (whole) has parts (at most one) capability 
        and (possibly multiple) interfaces.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="mediator"
     rdfs:label="mediator">
    <rdfs:comment>
        A mediator may have a source and multiple targets and may use a service for its implementation.
    </rdfs:comment>
</rdfs:Class>

<rdf:Property rdf:ID="importsOntology"
     rdfs:label="importsOntology">
    <rdfs:comment>
        Any WSML entity (goal, webService, ontology, mediator, interface, capability, 
        choreography) may import ontologies in order to reuse vocabularies.
    </rdfs:comment>
    <rdfs:range rdf:resource="#ontology"/>
</rdf:Property>

<rdf:Property rdf:ID="variant"
     rdfs:label="variant">
    <rdfs:comment>
        A WSML entity (goal, webService, mediator, ontology) may have a WSML variant associated with it.
        Defined values:
        http://www.wsmo.org/wsml/wsml-syntax/wsml-full
        http://www.wsmo.org/wsml/wsml-syntax/wsml-rule
        http://www.wsmo.org/wsml/wsml-syntax/wsml-flight
        http://www.wsmo.org/wsml/wsml-syntax/wsml-dl
        http://www.wsmo.org/wsml/wsml-syntax/wsml-core

        In case the same ontology, goal, etc. has different variants associated with it, 
        the highest variant is chosen.
    </rdfs:comment>
</rdf:Property>

<rdf:Property rdf:ID="usesMediator"
     rdfs:label="usesMediator">
    <rdfs:comment>Any WSML entity may use a mediator.</rdfs:comment>
    <rdfs:range rdf:resource="#mediator"/>
</rdf:Property>

<!-- Ontologies -->

<rdfs:Class rdf:ID="attribute"
     rdfs:label="attribute">
    <rdfs:comment>An attribute is a specific type of rdf:Property.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="attributeDefinition"
     rdfs:label="attributeDefinition">
    <rdfs:comment>
        A concept may have a number of attribute definitions. An attribute 
        definition consists of an attribute, a possible inverse attribute, 
        and maximal and minimal cardinality definitions.
    </rdfs:comment>
    <dc:relation>&owl;Restriction</dc:relation>
</rdfs:Class>

<rdfs:Class rdf:ID="reflexiveAttributeDefinition"
     rdfs:label="reflexiveAttributeDefinition">
    <rdfs:comment>Reflexive attribute definition</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#attributeDefinition"/>
</rdfs:Class>

<rdfs:Class rdf:ID="symmetricAttributeDefinition"
     rdfs:label="symmetricAttributeDefinition">
    <rdfs:comment>Symmetric attribute definition</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#attributeDefinition"/>
</rdfs:Class>

<rdfs:Class rdf:ID="transitiveAttributeDefinition"
     rdfs:label="transitiveAttributeDefinition">
    <rdfs:comment>Transitive attribute definition</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#attributeDefinition"/>
</rdfs:Class>

<rdf:Property rdf:ID="forAttribute"
     rdfs:label="forAttribute">
    <rdfs:comment>An attribute definition is associated with one attribute.</rdfs:comment>
    <rdfs:range rdf:resource="#attribute"/>
    <rdfs:domain rdf:resource="#attributeDefinition"/>
    <dc:relation rdf:resource="&owl;onProperty"/>
</rdf:Property>

<rdf:Property rdf:ID="ofType"
     rdfs:label="ofType">
    <rdfs:comment>
        The attribute value or relation parameter definition is checked to 
        be of the specific type.
    </rdfs:comment>
    <rdfs:range rdf:resource="#concept"/>
</rdf:Property>

<rdf:Property rdf:ID="impliesType"
     rdfs:label="impliesType">
    <rdfs:comment>
        Attribute values and relation parameter definitions are inferred to have a 
        particular type.
    </rdfs:comment>
    <rdfs:range rdf:resource="#concept"/>
    <rdfs:seeAlso rdf:resource="&owl;allValuesFrom"/>
</rdf:Property>

<rdf:Property rdf:ID="maxCardinality"
     rdfs:label="maxCardinality">
    <rdfs:comment>
        An attribute definition may have a maximal cardinality. If no maximal cardinality is 
        described, there is not constraint on the maximal cardinality.
    </rdfs:comment>
    <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
    <rdfs:domain rdf:resource="#attributeDefinition"/>
</rdf:Property>

<rdf:Property rdf:ID="minCardinality"
     rdfs:label="minCardinality">
    <rdfs:comment>
        An attribute definition may have a minimal cardinality. If no minimal cardinality 
        is described, the attribute is optional.
    </rdfs:comment>
    <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
    <rdfs:domain rdf:resource="#attributeDefinition"/>
</rdf:Property>

<rdf:Property rdf:ID="inverseOf"
     rdfs:label="inverseOf">
    <rdfs:comment>
        An attribute definition may have an inverse attribute 
        associated with it.
    </rdfs:comment>
    <rdfs:range rdf:resource="#attribute"/>
    <rdfs:domain rdf:resource="#attributeDefinition"/>
</rdf:Property>

<rdfs:Class rdf:ID="axiom"
     rdfs:label="axiom">
    <rdfs:comment>
        An axiom is an arbitrary logical specification which can be used 
        for ontology, but also, for example, for the specification of the 
        functionaly of web services through capabilities.
        
        The logical expression itself is expressed using the WSML/XML syntax 
        for logical expressions as an XML literal, which is linked to the 
        axiom using rdfs:isDefinedBy.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="concept"
     rdfs:label="concept">
    <rdfs:comment>
        A type of rdfs:Class
        A concept may have a number of attribute definitions associated with 
        it through the hasPart relationship.
    </rdfs:comment> 
    <rdfs:subClassOf rdf:resource="&rdfs;Class"/>
</rdfs:Class>

<rdfs:Class rdf:ID="instance"
     rdfs:label="instance">
    <rdfs:comment>
        A concept may have a number of instances associated with it, 
        through rdf:type.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="parameterDefinition"
     rdfs:label="parameterDefinition">
    <rdfs:comment>
        A parameter definition consists of a type (ofType/impliesType) 
        for the parameter, either via the property impliesType or ofType. A relation 
        contains a single rdf:list of parameter definitions.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="relation"
     rdfs:label="relation">
    <rdfs:comment>
        An RDF property can be seen as a specific kind of WSML relation, namely a 
        binary relation.
        
        A relation has either an arity or a parameter definition associated with 
        it; a relation definition can be compared with the signature specification 
        of a predicate in predicate calculus.
    </rdfs:comment>
    <dc:relation>&rdf;Property</dc:relation>
</rdfs:Class>

<rdf:Property rdf:ID="arity"
     rdfs:label="arity">
    <rdfs:comment>
        A relation has either an explicit arity or an explicit parameter 
        definition, which is an rdf:list.
    </rdfs:comment>
    <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
    <rdfs:domain rdf:resource="#relation"/>
</rdf:Property>

<rdf:Property rdf:ID="subRelationOf"
     rdfs:label="subRelationOf">
    <rdfs:comment>
        A relation may be a subrelation of a number of other relations. 
        A subrelation must have the same arity as the super relation.
    </rdfs:comment>
    <rdfs:range rdf:resource="#relation"/>
    <rdfs:domain rdf:resource="#relation"/>
</rdf:Property>

<rdfs:Class rdf:ID="relationInstance"
     rdfs:label="relationInstance">
    <rdfs:comment>
        A relation instance is an actual ground fact which corresponds 
        to a particular relation; it can be seen as a ground atomic formula 
        in predicate calculus.
        A relation instance has a list of parameter values.
    </rdfs:comment>
</rdfs:Class>

<!-- Capabilities -->

<rdfs:Class rdf:ID="capability"
     rdfs:label="capability">
    <rdfs:comment>
        A web service capability has a number of postconditions, 
        preconditions, effects, and assumptions, as well as a list 
        of shared variables.
    </rdfs:comment>
</rdfs:Class>

<rdf:Property rdf:ID="hasPrecondition"
     rdfs:label="hasPrecondition">
    <rdfs:comment>
        A pre-condition is an axiom which expresses conditions over the input of the service.
    </rdfs:comment>
    <rdfs:subPropertyOf rdf:resource="&part-whole;hasPart_directly"/>
    <rdfs:domain rdf:resource="#capability"/>
    <rdfs:range rdf:resource="#axiom"/>
</rdf:Property>

<rdf:Property rdf:ID="hasPostcondition"
     rdfs:label="hasPostcondition">
     <rdfs:comment>
        A post-condition is an axiom which describes the relation between the input and the 
        output of the service, as well as conditions which are guaranteed to hold over the output.
     </rdfs:comment>
    <rdfs:subPropertyOf rdf:resource="&part-whole;hasPart_directly"/>
    <rdfs:domain rdf:resource="#capability"/>
    <rdfs:range rdf:resource="#axiom"/>
</rdf:Property>

<rdf:Property rdf:ID="hasAssumption"
     rdfs:label="hasAssumption">
     <rdfs:comment>
        An assumption is an axiom which describes conditions on the state of the world which 
        must hold for the web service to be able to execute.
     </rdfs:comment>
    <rdfs:subPropertyOf rdf:resource="&part-whole;hasPart_directly"/>
    <rdfs:domain rdf:resource="#capability"/>
    <rdfs:range rdf:resource="#axiom"/>
</rdf:Property>

<rdf:Property rdf:ID="hasEffect"
     rdfs:label="hasEffect">
     <rdfs:comment>
        An effect is an axiom which describes conditions which are guaranteed to hold over the 
        state of the world after execution of the service.
     </rdfs:comment>
    <rdfs:subPropertyOf rdf:resource="&part-whole;hasPart_directly"/>
    <rdfs:domain rdf:resource="#capability"/>
    <rdfs:range rdf:resource="#axiom"/>
</rdf:Property>

<rdf:Property rdf:ID="sharedVariable"
     rdfs:label="sharedVariable">
    <rdfs:comment>
        A capability has a number of variables which are shared across all definitions. 
        By default, all free variables in a logical expression are implicitly universally 
        quantified over this logical expression. Shared variables are free in the logical 
        expression and a universally quantified over the entire capability.
    </rdfs:comment>
    <rdfs:range rdf:resource="&xsd;string"/>
    <rdfs:domain rdf:resource="#capability"/>
</rdf:Property>

<!-- Interfaces -->

<rdfs:Class rdf:ID="interface"
     rdfs:label="interface">
    <rdfs:comment>
        A Web Service interface may have a number of choreographies and one orchestration 
        associated with it.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="choreography"
     rdfs:label="choreography">
    <rdfs:comment>
        A Web Service interface may have a choreography associated with it.
    </rdfs:comment>
</rdfs:Class>

<rdfs:Class rdf:ID="orchestration"
     rdfs:label="orchestration">
    <rdfs:comment>
        A Web Service interface may have an orchestration associated with it.
    </rdfs:comment>
</rdfs:Class>

<!-- Mediators -->

<rdfs:Class rdf:ID="ggMediator"
     rdfs:label="ggMediator">
    <rdfs:subClassOf rdf:resource="#mediator"/>
</rdfs:Class>

<rdfs:Class rdf:ID="ooMediator"
     rdfs:label="ooMediator">
    <rdfs:subClassOf rdf:resource="#mediator"/>
</rdfs:Class>

<rdfs:Class rdf:ID="wgMediator"
     rdfs:label="wgMediator">
    <rdfs:subClassOf rdf:resource="#mediator"/>
</rdfs:Class>

<rdfs:Class rdf:ID="wwMediator"
     rdfs:label="wwMediator">
    <rdfs:subClassOf rdf:resource="#mediator"/>
</rdfs:Class>

<rdf:Property rdf:ID="target"
    rdfs:label="target">
    <rdfs:comment>A mediator may have one or more targets.</rdfs:comment>
    <rdfs:domain rdf:resource="#mediator"/>
</rdf:Property>

<rdf:Property rdf:ID="usesService"
    rdfs:label="usesService">
    <rdfs:comment>A mediator may use a service for its implementation.</rdfs:comment>
    <rdfs:domain rdf:resource="#mediator"/>
</rdf:Property>

<rdf:Property rdf:ID="source"
    rdfs:label="source">
    <rdfs:comment>A mediator may have a source.</rdfs:comment>
    <rdfs:domain rdf:resource="#mediator"/>
</rdf:Property>

<!-- Relating the WSML vocabulary to the OWL vocabulary -->

<rdf:Property rdf:about="#version">
    <rdfs:subPropertyOf rdf:resource="&owl;AnnotationProperty"/>
    <owl:sameAs rdf:resource="&owl;versionInfo"/>
</rdf:Property>

</rdf:RDF>

Appendix B. Serving WSML specifications on the Web

When publishing ontologies on the Web, the namespace of the ontology need not be the same as the URI where the ontology file is located. A namespace URI should be a neutral URI instead, which allows changes in the definition or the language (HTML, WSML or even OWL) in which the ontology is defined, without changing the namespace and thus keeping compatibility. An example neutral URI is http://example.com/ontologies/e-shop which can be contrasted to the following implementation-specific URI http://dev.example.com/ontologies/e-shop/v3.14/e-shop.wsml. Redirection or internal URI rewriting can be used to serve the WSML document from the neutral URI.

The issue of what should be available at the namespace URI is not yet resolved in an agreed standard way, see W3C Technical Architecture Group issue namespaceDocument-8. However, it seems useful to make different content available for different agents, for example a Web browser going to an ontology URI might get the textual HTML page, whereas an automated agent will retrieve the WSML document from the same URI. The separate documents (the HTML description and the WSML ontology) can still have their own separate URIs, but they should be redundantly available at the namespace URI as well.

In [HTTPExamples] the W3C Semantic Web Best Practices and Deployment Working Group drafts a number of techniques for configuring the popular Apache Web server for serving different content to different user agents, depending on the agents' capabilities represented with the set of accepted media types. These tips can also be followed when serving together the HTML description and the WSML ontology in any of the provided syntaxes (human-readable or WSML/XML) or in the RDF form presented in this document. The media types in the tips must be changed as follows: files in the human-readable syntax of WSML should be served under the media type application/x-wsml and WSML/XML files should have the media type application/x-wsml+xml, as specified in [WSML]. Finally files in the RDF form presented in this document should be served using the media type application/rdf+xml (provided RDF/XML is used to serialize the RDF graph).

The media type for the RDF form is the same as the one used by the direct WSML/RDF syntax from [WSML], therefore files in both forms cannot be served from the same URI, as there is no way to distinguish what the requesting agent wants. In fact, the use of WSML/RDF (the direct and complete translation of WSML into an RDF syntax) is discouraged — an agent who wants an RDF version will probably work better with the RDF form presented in this document.


References

[RFC4122] P. Leach, M. Mealling and R. Salz. A Universally Unique IDentifier (UUID) URN Namespace. IETF RFC 4122, 2005. http://ietf.org/rfc/rfc4122.txt.

[WSML] J. de Bruijn, editor. The Web Service Modeling Language WSML. 2005. WSMO Final Draft D16.v0.21. http://www.wsmo.org/TR/d16/d16.1/v0.21/.

[HTTPExamples] A. Miles (editor): Configuring Apache HTTP Server for RDFS/OWL Ontologies Cookbook, editor's draft within the Semantic Web Best Practices and Deployment Working Group at W3C; available at http://www.w3.org/2001/sw/BestPractices/VM/http-examples/.

Acknowledgements

The work is funded by the European Commission under the projects DIP, Knowledge Web, InfraWebs, SEKT, SWWS, ASG and Esperonto; by Science Foundation Ireland under the DERI-Lion project; by the FIT-IT (Forschung, Innovation, Technologie - Informationstechnologie) under the projects RW2 and TSC.

The editors would like to thank to all the members of the WSML working group for their advice and input into this document. We would especially like to thank Douglas Foxvog and Eyal Oren for their work on deliverables superseded by this deliverable.


Footnotes

[1] The part-whole ontology we use has a distinction between hasPart and hasPart_directly. hasPart is a transitive property, and thus we would not be able to infer which part is directly contained in which whole. hasPart_directly is a subproperty of hasPart; thus, for each pair in the hasPart_directly relation is also in the hasPart relation, but it allows us to distinguish direct part-whole containment.

Valid XHTML 1.1!

$Date: 2006/02/15 17:50:29 $