wsml logo

D36v0.1 WSML/XML

WSML Working Draft 15 January 2008

This version
http://www.wsmo.org/TR/d36/v0.1/20080115/
Latest version
http://www.wsmo.org/TR/d36/v0.1/
Previous version
-
Editor:
Ioan Toma
Authors:
The WSML working group members

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

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


Abstract

This document presents the XML representation of WSML, called WSML/XML. A particular WSML description is an XML document which conforms to the WSML/XML schema.


Table of Contents

1. Introduction

2. XML Syntax for WSML

Appendix A. Schemas for the XML Exchange Syntax

References

Acknowledgements


1. Introduction

We present the XML syntax for WSML. The XML exchange syntax is introduced to overcome the limitations with respect to the exchange of the human-readable syntax over the Web. This syntax is the preferred syntax for the exchange of WSML specifications between machines. The XML syntax for WSML is based on abstract syntax presented in [WSML-Semantics] and is compliant with the human-readable syntax presented in [WSML].

2. XML Syntax for WSML

In this chapter, we explain the XML syntax for WSML. The XML syntax for WSML captures all WSML variants. The user can specify the variant of a WSML/XML document through the 'variant' attribute of the <wsml> root element.

The complete XML Schema, including documentation, for the WSML/XML syntax can be found in Appendix A. Table 2.1 provides the transformations of the conceptual syntax, Table 2.2 presents the transformation of logical expressions, while in Table 2.3 a simple mapping example is given.

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

Before beginning the transformation process the following pre-processing steps need to be performed:

T(...) denotes a function which is recursively called to transform the first parameter (a fragment of WSML syntax) to the XML syntax.

In Table 2.1, all WSML keywords are marked bold. A,B,C 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. k,m,n are integer numbers. Productions in the grammar are underlined and linked to the production rules in [WSML], Appendix A. Note that in the table we use the familiar sQName macro mechanism to abbreviate the IRIs of resources.

Table 2.1: Mapping the WSML conceptual syntax to the WSML/XML syntax
WSML syntax XML Tree Remarks
T (
wsmlVariantA
  definition1
  ...
  definitionn
)
<wsml xmlns="http://www.wsmo.org/wsml/wsml-syntax#" variant="A">
  T(definition1)
  ...
  T(definitionn)
</wsml>
definitions are Ontology, Goal, WebService, Mediators, Capability and Interface
T (
namespace { N,
  P1 N1,
  ...,
  Pn Nn } )
  Because sQnames were resolved to full IRIs during pre-processing, there is no translation to XML necessary for namespace definitions
T (
ontology A
  header1
  ...
  headern
  ontology_element1
  ...
  ontology_elementn
)
<ontology name="A">
  T(header1)
  ...
  T(headern)
  T(ontology_element1)
  ...
  T(ontology_elementn)
</ontology>
An ontology_element represents all possible content of an ontology definition, i.e., concepts, relations, instances, ...
T (
concept C
  subConceptOf {B1,...,Bn}
  annotations
  attribute1
  ...
  attributen
)
<concept name="C">
  T(annotations)
  <superConcept>B1<superConcept>
  ...
  <superConcept>Bn<superConcept>
  T(attribute1)
  ...
  T(attributen)
</concept>
T (
A attributefeature1 ... attributefeaturen ofType cardinality C
  annotations
)
<attribute name="A" type="constraining">
  <range>C</range>
  T(attributefeature1)
  ...
  T(attributefeaturen)
  T(cardinality)
  T(annotations)
</attribute>
 
T (
A attributefeature1 ... attributefeaturen impliesType cardinality C
  annotations
)
<attribute name="A" type="inferring">
  <range>C</range>
  T(attributefeature1)
  ...
  T(attributefeaturen)
  T(cardinality)
  T(annotations)
</attribute>
 
T (
transitive
)
<transitive/>  
T (
symmetric
)
<symmetric/>  
T (
reflexive
)
<reflexive/>  
T (
inverseOf(A)
)
<inverseOf type="A"/>  
T (
subAttributeOf(A)
)
<subAttributeOf type="A"/>  
T (
(minCard maxCard)
)
<minCardinality>minCard</minCardinality>
<maxCardinality>maxCard</maxCardinality>
 
T (
(card)
)
<minCardinality>card</minCardinality>
<maxCardinality>card</maxCardinality>
 
T (
instance A
  memberOf C1,...,Cn
  annotations
  attributevalue1
  ...
  attributevaluen
)
<instance name="A">
  <memberOf>C1</memberOf>
  ...
  <memberOf>Cn</memberOf>
  T(annotations)
  T(attributevalue1)
  ...
  T(attributevaluen)
</instance>
 
T (
A hasValue {value1, ..., valuen}
)
<attributeValue name="A">
  T(value1)
  ...
  T(valuen)
</attributeValue>
A value has always a datatype. There are four built-in datatypes: IRI, string, integer, decimal. In addition any arbitrary datatype can be defined by use of datatype wrappers. The next four transformations show how to handle these five cases.
T (
  A
)
<value type="wsml#iri">
  A
</value>
 
T (
  DVs
)
<value type="wsml#string">
  DVs
</value>
 
T (
  DVi
)
<value type="wsml#integer">
  DVi
</value>
 
T (
  DVd
)
<value type="wsml#decimal">
  DVd
</value>
 
T (
  DV
)
<value type="http://www.example.org/datatype#any">
  <argument>DV.arg1</argument>
  ...
  <argument>DV.argn</argument>
</value>
A datatype wrapper is defined by the type and a number of arguments that define the value, e.g., _date(2005,12,12) for December 12, 2005 (and thus the value of type date has three arguments). In case there is just on argument, the element <argument> is optional and the value can be given as above for IRI, string, integer, decimal.
T (
A hasValue {valuenfp1, ..., valuenfpn}
)
<attributeValueNfp name="A">
  T(valuenfp1)
  ...
  T(valuenfpn)
</attributeValueNfp>
A valuenfp is mapped same as a value. Additionally a valuenfp might be a variable.
T (
  V
)
<value>
  <variable name="V"/>
</value>
 
T (
relation A / n (paramtype1,...,paramtypem)
  subRelationOf {C1,...,Ck}
  annotations
)
<relation name="A" arity="n">
  <parameters>
    T(paramtype1>)
    ...
    T(paramtypen)
  </parameters>
  <superRelation>C1</superRelation>
  ...
  <superRelation>Ck</superRelation>
  T(annotations)
</relation>
Note that the parameters of a relation are ordered and thus the order of the parameters elements in the XML representation important.
T (
ofType {C1,...,Cn}
)
<parameter type="constraining">
  <range>C1</range>
  ...
  <range>Cn</range>
</parameter>
 
T (
impliesType {C1,...,Cn}
)
<parameter type="inferring">
  <range>C1</range>
  ...
  <range>Cn</range>
</parameter>
 
T (
relationInstance A B
(value1,...,valuen)
  annotations
)
<relationInstance name="A">
  <memberOf>B</memberOf>
  T(value1)
    ...
  T(valuen)
  T(annotations)
</relationInstance>
 
T (
{value1,...,valuen} )
<parameterValue>
  T(value1)
  ...
  T(valuen)
</parameterValue>
Note that the parameters of a relationInstance are ordered and thus the order of the value elements is important.
T (
axiom A
  axiomdefinition
)
<axiom name="A">
  T(axiomdefinition)
</axiom>
 
T (
  annotations
  definedBy
    log_expr
)
T(annotations)
<definedBy>
  T(log_expr)
</definedBy>
The mapping of logical expressions is defined in Table 2.2.
T (
goal A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  capability
  interface1
  ...
  interfacen
)
<goal name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(capability)
  T(interface1)
  ...
  T(interfacen)
</goal>
 
T (
ooMediator A
  annotations
  importsontology
  nfp1
  ...
  nfpn
  source
  target
  use_service
)
<ooMediator name="A">
  T(annotations)
  T(importsontology)
  T(nfp1)
  ...
  T(nfpn)
  T(source)
  T(target)
  T(use_service)
</ooMediator>
 
T (
ggMediator A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  source
  target
  use_service
)
<ggMediator name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(source)
  T(target)
  T(use_service)
</ggMediator>
 
T (
wgMediator A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  source
  target
  use_service
)
<wgMediator name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(source)
  T(target)
  T(use_service)
</wgMediator>
 
T (
wwMediator A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  source
  target
  use_service
)
<wwMediator name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(source)
  T(target)
  T(use_service)
</wwMediator>
 
T (
  source { A1,...,An }
)
  <source>A1</source>
  ...
  <source>An</source>
 
T (
  target A
)
  <target>A</target>  
T (
  usesService A
)
  <usesService>A</usesService>  
T (
webService A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  capability
  interface1
  ...
  interfacen
)
<webService name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(capability)
  T(interface1)
  ...
  T(interfacen)
</webService>
 
T (
capability C
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  sharedvardef
  pre_post_ass_or_eff1
  ...
  pre_post_ass_or_effn
)
<capability name="C">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(sharedvardef)
  T(pre_post_ass_or_eff1)
  ...
  T(pre_post_ass_or_effn)
</capability>
pre_post_ass_or_eff unites the axiom definitions for precondition, assumption, postcondition and effect.
T (
sharedVariables {?v1, ..., ?vn}
)
<sharedVariables>
  <variable name="?v1"/>
  ...
  <variable name="?vn"/>
</sharedVariables>
 
T (
precondition B
  axiomdefinition
)
<precondition name="B">
  T(axiomdefinition)
</precondition>
 
T (
assumption B
  axiomdefinition
)
<assumption name="B">
  T(axiomdefinition)
</assumption>
 
T (
postcondition B
  axiomdefinition
)
<postcondition name="B">
  T(axiomdefinition)
</postcondition>
 
T (
effect B
  axiomdefinition
)
<effect name="B">
  T(axiomdefinition)
</effect>
 
T (
interface A
  header1
  ...
  headern
  nfp1
  ...
  nfpn
  choreography
  orchestration
)
<interface name="A">
  T(header1)
  ...
  T(headern)
  T(nfp1)
  ...
  T(nfpn)
  T(choreography)
  T(orchestration)
</interface>
 
T (
choreography C
  header1
  ...
  headern
  statesignature
  transitions
)
<choreography name="C">
  T(header1)
  ...
  T(headern)
  T(statesignature)
  T(transitions)
</choreography>
 
T (
statesignature C
  header1
  ...
  headern
  mode1
  ...
  moden
)
<statesignature name="C">
  T(header1)
  ...
  T(headern)
  T(mode1)
  ...
  T(moden)
</statesignature>
 
T (
mode
  mode_id
  mode_entry1
  ...
  mode_entryn
)
<mode>
  T(mode_id)
  T(mode_entry1)
  ...
  T(mode_entryn)
</mode>
 
T (
static
)
<static/>  
T (
in
)
<in/>  
T (
out
)
<out/>  
T (
shared
)
<shared/>  
T (
controlled
)
<controlled/>  
T (
mode_entry
  mode_entry_id
  A
  grounding
)
<mode_entry>
  T(mode_entry_id)
  <iri>A</iri>
  T(grounding)
</mode_entry>
 
T (
default_mode
)
<default_mode/>  
T (
concept_mode
)
<concept_mode/>  
T (
relation_mode
)
<relation_mode/>  
T (
grounding {A1,...,An}
)
<grounding>A1</grounding>
...
<grounding>An</grounding>
 
T (
transitions A
  annotations
  rule1
  ...
  rulen
)
<transitions name="A">
  T(annotations)
  T(rule1)
  ...
  T(rulen)
</transitions>
 
T (
rule
  if
  condition
  then
  rule1
  ...
  rulen
  endif
  piped_rule
)
<rule>
  T(if)
  T(condition)
  T(then)
  T(rule1)
  ...
  T(rulen)
  T(endif)
  T(piped_rule)
</rule>
 
T (
rule
  forall
  variable1
  ...
  variablen
  with
  condition
  do
  rule1
  ...
  rulen
  endforall
  piped_rule
)
<rule>
  T(forall)
  T(variable1)
  ...
  T(variablen)
  T(with)
  T(condition)
  T(do)
  T(rule1)
  ...
  T(rulen)
  T(endforall)
  T(piped_rule)
</rule>
 
T (
rule
  choose
  variable1
  ...
  variablen
  with
  condition
  do
  rule1
  ...
  rulen
  endchoose
  piped_rule
)
<rule>
  T(choose)
  T(variable1)
  ...
  T(variablen)
  T(with)
  T(condition)
  T(do)
  T(rule1)
  ...
  T(rulen)
  T(endchoose)
  T(piped_rule)
</rule>
 
T (
rule
  updaterule
)
<rule
  T(updaterule)
</rule>
 
T (
if
)
<if/>  
T (
then
)
<then/>  
T (
endif
)
<endif/>  
T (
forall
)
<forall/>  
T (
with
)
<with/>  
T (
do
)
<do/>  
T (
endforall
)
<endforall/>  
T (
choose
)
<choose/>  
T (
endchoose
)
<endchoose/>  
T (
condition
  expr
)
<condition>
  T(expr)
</condition>
 
T (
piped_rule
  pipe
  rule
)
<piped_rule>
  T(pipe)
  T(rule)
</piped_rule>
 
T (
pipe
)
<pipe/>  
T (
updaterule
  modifier
  fact
)
<updaterule>
  T(modifier)
  T(fact)
</updaterule>
 
T (
add
)
<add/>  
T (
delete
)
<delete/>  
T (
update
)
<update/>  
T (
fact
  term
  attr_fact memberOf
  term1
  ...
  termn
  fact_update
)
<fact>
  T(term)
  T(attr_fact)
  <isa type="memberOf">
  T(term1)
  ...
  T(termn)
  </isa>
  T(fact_update)
</fact>
 
T (
fact
  term
memberOf
  term1
  ...
  termn
  fact_update
  attr_fact
)
<fact>
  T(term)
  <isa type="memberOf">
  T(term1)
  ...
  T(termn)
  </isa>
  T(fact_update)
  T(attr_fact)
</fact>
 
T (
fact
  term
  attr_fact )
<fact>
  T(term)
  T(attr_fact)
</fact>
 
T (
fact
  at
  A
  term_updates )
<fact>
  T(at)
  <iri>A</iri>
  T(term_updates)
</fact>
 
T (
fact_update
  arrow
  term1
  ...
  termn
)
<fact_update>
  T(arrow)
  T(term1)
  ...
  T(termn)
</fact_update>
 
T (
arrow
)
<arrow/>  
T (
attr_fact
  lbracket
  term1
hasValue
  term11
  ...
  term1n
  fact_update1
  ...
  termm
hasValue
  termm1
  ...
  termmn
  fact_updatem
  rbracket
)
<attr_fact>
  T(lbracket)
  T(term1)
  <isa type="memberOf">
  T(term11)
  ...
  T(term1n)
  </isa>
  T(fact_update1)
  ...
  T(termm)
  <isa type="memberOf">
  T(termm1)
  ...
  T(termmn)
  </isa>
  T(fact_updatem)
  T(rbracket)
</attr_fact>
 
T (
lbracket
)
<lbracket/>  
T (
rbracket
)
<rbracket/>  
T (
term_updates
  term_update1
  ...
  term_updaten
)
<term_updates>
  T(term_update1)
  ...
  T(term_updaten)
</term_updates>
 
T (
term_update
  term
)
<term_update>
  T(term)
</term_update>
 
T (
term_update
  termold
  arrow
  termnew
)
<term_update>
  T(termold)   T(arrow)   T(termnew)
</term_update>
 
T (
new_term
  arrow
  term
)
<new_term>
  T(arrow)   T(term)
</new_term>
 
T (
orchestration A
)
<orchestration>A</orchestration>  
T (
nonFunctionalProperty
  annotations
  attributevaluenfp
  log_definition
)
<nonFunctionalProperty>
  T(annotations)
  T(attributevaluenfp)
  T(log_definition)
</nonFunctionalProperty>
 
T (
nfp
  annotations
  attributevaluenfp
  log_definition
)
<nfp>
  T(annotations)
  T(attributevaluenfp)
  T(log_definition)
</nfp>
 
T (
annotations
  attributevalue1
  ...
  attributevaluen
endAnnotations
)
<annotations>
  T(attributevalue1)
  ...
  T(attributevaluen)
</annotations>
 
T (
importsOntology { A1,...,An}
)
<importsOntology>A1</importsOntology>
...
<importsOntology>An</importsOntology>
 
T (
usesMediator {B1,...,Bn}
)
<usesMediator>B1</usesMediator>
...
<usesMediator>Bn</usesMediator>
 

The logical expression syntax is explained in Table 2.2. In the table, A stands for identifiers and T1,...,Tn stand for terms. V stands for a variable.

Table 2.2: [TODO: make distinction between expressions and terms in translation function] Mapping the WSML logical expression syntax to the WSML/XML syntax
WSML syntax XML Tree Remarks
T' (
A(term1, ..., termn)
)
<term name="A">
  T' (term1, arg)
  ...
  T' (termn, arg)
</term>
 
T' (
A(term1, ..., termn)
, name)
<name name="A">
  T' (term1, arg)
  ...
  T' (termn, arg)
</name>
 
T' (
V
)
<term name="V"/>  
T' (
V
, name)
<name name="V">
</name>
 
T (
A(term1, ..., termn)
)
<atom name="A">
  T'(term1, arg)
  ...
  T'(termn, arg)
</atom>
 
T (
T1[attr_relation1, ..., attr_relationn] subConceptOf T2,...,Tn
)
<molecule>
  T'(T1)
  <isa type="subConceptOf">
    T'(T2)
    ...
    T'(Tn)
  </isa>
  T(attr_relation1)
  ...
  T(attr_relationn)
</molecule>
 
T (
T1[attr_relation1, ..., attr_relationn] memberOf T2,...,Tn
)
<molecule>
  T'(T1)
  <isa type="memberOf">
    T'(T2)
    ...
    T'(Tn)
  </isa>
  T(attr_relation1)
  ...
  T(attr_relationn)
</molecule>
 
T (
T [attr_relation1, ..., attr_relationn]
)
<molecule>
  T'(T)
  T(attr_relation1)
  ...
  T(attr_relationn)
</molecule>
 
T (
T0 ofType {T1, ..., Tn}
)
<attributeDefinition type="constraining">
  T'(T0, name)
  T'(T1, type)
  ...
  T'(Tn, type)
</attributeDefinition>
 
T (
T0 impliesType {T1, ..., Tn}
)
<attributeDefinition type="inferring">
  T'(T0, name)
  T'(T1, type)
  ...
  T'(Tn, type)
</attributeDefinition>
 
T (
T0 hasValue {T1, ..., Tn}
)
<attributeValue>
  T'(T0, name)
  T'(T1, value)
  ...
  T'(Tn, value)
</attributeValue>
 
T (
expr1 and expr2
)
<and>
  T(expr1)
  T(expr2)
</and>
 
T (
expr1 or expr2
)
<or>
  T(expr1)
  T(expr2)
</or>
 
T (
neg expr
)
<neg>
  T(expr)
</neg>
 
T (
naf expr
)
<naf>
  T(expr)
</naf>
 
T (
expr1 implies expr2
)
<implies>
  T(expr1)
  T(expr2)
</implies>
 
T (
expr1 impliedBy expr2
)
<impliedBy>
  T(expr1)
  T(expr2)
</impliedBy>
 
T (
expr1 equivalent expr2
)
<equivalent>
  T(expr1)
  T(expr2)
</equivalent>
 
T (
forall ?v1, ..., ?vn ( expr )
)
<forall>
  <variable name="?v1"/>
  ...
  <variable name="?vn"/>
  T(expr)
</forall>
 
T (
exists ?v1, ..., ?vn ( expr )
)
<exists>
  <variable name="?v1"/>
  ...
  <variable name="?vn"/>
  T(expr)
</exists>
 
T (
!- expr
)
<constraint>
  T(expr)
</constraint>
 
T (
expr1 :- expr2
)
<impliedByLP>
  T(expr1)
  T(expr2)
</impliedByLP>
 

Table 2.3 provides a simple translation example.

Table 2.3: A Mapping Example
WSML syntax XML Tree

wsmlVariant
  _"http://www.wsmo.org/wsml/wsml-syntax/wsml-flight"

namespace {_"http://www.example.org/ex1#",
    dc _"http://purl.org/dc/elements/1.1#",
    wsml _"http://www.wsmo.org/wsml/wsml-syntax#",
    ex _"http://www.example.org/ex2#"}

ontology _"http://www.example.org/ex1"
    annotations
        dc#title hasValue "WSML to RDF"
        dc#date hasValue _date(2005,12,12)
    endAnnotations

    importsOntology _"http://www.example.net/ex2"

    concept Woman subConceptOf
            {ex#Human, ex#LivingBeing}
        name ofType _string
        ancestorOf transitive impliesType ex#Human
        age ofType (1) _integer

    axiom GenderConstraint
        definedBy
              !- ?x memberOf ex#Man and
                ?x memberOf Woman.

    instance Mary memberOf Woman
        name hasValue "Mary Jones"
        age hasValue 23

    relation childOf
        (ofType ex#Human, impliesType ex#Parent)


webService ws
    capability itineraryInfo
    interface
      {_"http://example.org/i1",_"http://example.org/i2"}

<wsml xmlns="http://www.wsmo.org/wsml/wsml-syntax#"
      variant="http://www.wsmo.org/wsml/wsml-syntax/wsml-flight">
  <ontology name="http://www.example.org/ex1">
    <annotations>
      <attributeValue name="http://purl.org/dc/elements/1.1#title">
        <value type="http://www.wsmo.org/wsml/wsml-syntax#string">
          WSML to RDF
        </value>
      </attributeValue>
      <attributeValue name="http://purl.org/dc/elements/1.1#date">
        <value type="http://www.wsmo.org/wsml/wsml-syntax#date">
          <argument>2005</argument>
          <argument>12</argument>
          <argument>12</argument>
        </value>
      </attributeValue>
    </annotations>
    <importsOntology>http://www.example.org/ex2</importsOntology>
    <concept name="http://www.example.org/ex1#Woman">
      <superConcept>
        http://www.example.org/ex2#Human
      </superConcept>
      <superConcept>
        http://www.example.org/ex2#LivingBeing
      </superConcept>
      <attribute name="http://www.example.org/ex1#name" type="constraining">
        <range>http://www.wsmo.org/wsml/wsml-syntax#string</range>
      </attribute>
      <attribute name="http://www.example.org/ex1#ancestor" type="inferring">
        <range>http://www.example.org/ex2#Human</range>
        <transitive/>
      </attribute>
      <attribute name="http://www.example.org/ex1#age" type="inferring">
        <range>http://www.wsmo.org/wsml/wsml-syntax#integer</range>
        <minCardinality>1</minCardinality>
        <maxCardinality>1</maxCardinality>
      </attribute>
    </concept>
    <axiom name="http://www.example.org/ex1#GenderConstraint">
      <definedBy>
        <constraint>
          <and>
             <molecule>
               <term name="?x"/>
               <isa type="memberOf">
                 <term name="http://www.example.org/ex1#Woman"/>
               </isa>
             </molecule>
             <molecule>
               <term name="?x"/>
               <isa type="memberOf">
                 <term name="http://www.example.org/ex2#Man"/>
               </isa>
             </molecule>
          </and>
        </constraint>
      </definedBy>
    </axiom>
    <instance name="http://www.example.org/ex1#Mary">
      <memberOf>http://www.example.org/ex1#Woman</memberOf>
      <attributeValue name="http://www.example.org/ex1#name">
        <value type="http://www.wsmo.org/wsml/wsml-syntax#string">
          Mary Jones
        </value>
      </attributeValue>
      <attributeValue name="http://www.example.org/ex1#age">
        <value type="http://www.wsmo.org/wsml/wsml-syntax#integer">
          23
        </value>
      </attributeValue>
    </instance>
    <relation name="http://www.example.org/ex1#childOf">
      <parameters>
        <parameter type="constraining">
          <range>http://www.example.org/ex2#Human</range>
        </parameter>
        <parameter type="inferring">
          <range>http://www.example.org/ex2#Parent</range>
        </parameter>
      </parameters>
    </relation>
  </ontology>
  <webService name="http://www.example.org/ex1#ws">
    <capability name="http://www.example.org/ex1#itineraryInfo"/>
    <interface name="http://example.org/i1</interface"/>
    <interface name="http://example.org/i2</interface"/>
  </webService>
</wsml>

Appendix A. Schemas for the XML Exchange Syntax

In the following sections we present the XML Schemas for the XML syntax of WSML.
The schemas are available online at http://www.wsmo.org/TR/d36/v0.1/xml-syntax/wsml_xml_syntax.xsd.

This schema includes two module schemas:

Furthermore, the schema imports an additional schema for the basic Dublin Core elements (http://dublincore.org/schemas/xmls/qdc/2003/04/02/dc.xsd).

Userfriendly documentation for the schemas is available from the following locations:

References

[WSML-Semantics] J. de Bruijn, editor. WSML Abstract Syntax and Semnatics. 2007. WSML Working Draft D16.3v0.3 http://www.wsmo.org/TR/d16/d16.3/v0.3/.

[WSML] I. Toma and N. Steinmetz, editors. The Web Service Modeling Language WSML. 2007. WSML Working Draft D16.1v0.3 http://www.wsmo.org/TR/d16/d16.1/v0.3/.


Acknowledgements

The work is partially funded by the European Commission under the projects ASG, EASAIER, enIRaF, Knowledge Web, Musing, Salero, Seemp, Semantic- GOV, Super, SWING and TripCom; by Science Foundation Ireland under the DERI-Lion Grant No.SFI/02/CE1/I13; by the FIT-IT (Forschung, Innovation, Technologie - Informationstechnologie) under the projects Grisino, RW2, Sem-Biz, SeNSE and TSC.

The authors would like to thank to all the members of the WSML working group for their advice and input into this document.


Valid XHTML 1.1!

$Date: 2008-01-15 $