Web Ontology Language (OWL)
XML Presentation Syntax

Editor's Note 20 February 2003 - no W3C status at this time

Editors:

Masahiro Hori (IBM Tokyo Research) horim@jp.ibm.com

Jérôme Euzenat (INRIA Rhône-Alpes) Jerome.Euzenat@inrialpes.fr

Peter F. Patel-Schneider (Bell Labs Research, Lucent Technologies) pfps@research.bell-labs.com

Copyright © 2003 W3C^® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.

---

Abstract

This document describes an XML presentation sytax and XML Schemas for OWL 1.0 sublanguages: OWL Lite, OWL DL, and OWL Full.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. The latest status of this document series is maintained at the W3C.

This Note has been written to meet the requirement that OWL 1.0 must have an XML syntax [OWL Requirement]. It is not intended to be a normative specification. Instead, it represents a suggestion of one possible XML presentation syntax schema for OWL. At the time of writing, the schema described here has not benefited from implementation experience.

The authors welcome comments on this document, but does not guarantee a reply or any further action. Please send comments on this draft to public-webont-comments@w3.org; public archives are available. Comments may also be sent to the authors at the above addresses.This document may be updated or added to based on implementation experience, but no commitment is made by the W3C, or any of its members, regarding future updates.

This document is a NOTE made available by the W3C for discussion only. Publication of this Note by W3C indicates no endorsement by W3C or the W3C Team, or any W3C Members. A list of current W3C technical reports and publications, including Working Drafts and Notes, can be found at http://www.w3.org/TR/.

Acknowledgements

This document is the result of extensive discussions within the Web Ontology Working Group as a whole. The members of this working group were Jean-Fran-ois Baget, James Barnette, Sean Bechhofer, Jonathan Borden, Frederik Brysse, Stephen Buswell, Peter Crowther, Jos De Roo, David De Roure, Mike Dean, Larry Eshelman, J-r-me Euzenat, Dieter Fensel, Tim Finin, Nicholas Gibbins, Pat Hayes, Jeff Heflin, Ziv Hellman, James Hendler, Bernard Horan, Masahiro Hori, Ian Horrocks, Francesco Iannuzzelli, Mario Jeckle, Ruediger Klein, Ora Lassila, Alexander Maedche, Massimo Marchiori, Deborah McGuinness, Libby Miller, Enrico Motta, Leo Obrst, Laurent Olivry , Peter Patel-Schneider, Martin Pike, Marwan Sabbouh, Guus Schreiber, Noboru Shimizu, Michael Sintek, Michael Smith, Ned Smith, John Stanton, Lynn Andrea Stein, Herman ter Horst, Lynne R. Thompson, David Trastour, Frank van Harmelen, Raphael Volz, Evan Wallace, Christopher Welty, and John Yanosy.

Table of Contents

• 1. Introduction
• 1.1 Notational Conventions
• 1.2 How to Use an XML Schema
• 1.3 XML Schema Modules
• 2. Element Reference
  • 2.1 The Root Element
  • 2.2 Header Elements
  • 2.3 Classes
  • 2.4 Properties
  • 2.5 Individuals
  • 2.6 Enumerated Datatype
  • 2.7 Index of Elements
• Appendix A. XML Schemas
• Appendix B. OWL Examples in XML Syntax
• Appendix C. Term Index and Cross Reference
• Appendix D. Transformation to OWL in RDF/XML
• Appendix E. References
• Appendix F. Change Log

1 Introduction

This document specifies XML presentation syntax for OWL, which is defined as dialect similar to OWL Abstract Syntax [OWL Abstract Syntax]. The OWL 1.0 language provides three increasingly expressive sublanguages: OWL Lite, OWL DL, and OWL Full. This document provides XML Schemas for XML presentation syntax corresponding to each of the three sublanguages:

• "owl1-lite.xsd" for OWL 1.0 Lite
• "owl1-dl.xsd" for OWL 1.0 DL
• "owl1-full.xsd" for OWL 1.0 Full

The root element of OWL documents for the XML presentation syntax must be Ontology element.

Each of the sublanguages is an extension of its simpler predecessor, and the following relations hold but the inverses do not.

• Every document valid against the XML Schema of OWL Lite is valid against the XML Schema of OWL DL.
• Every document valid against the XML Schema of OWL DL is valid against the XML Schema of OWL Full.

A zip archive of all the Schemas for XML presentation syntax is available.

1.1 Notational Conventions

This document uses a number of namespace prefixes as listed below. Note that the choice of any namespace prefix is arbitrary, and not semantically significant.

1.2 How to Use an XML Schema

XML Schemas do not have to be specified in an OWL document instance itself, but it may be specified in an instance by adding schemaLocation attribute (in the XML Schema instance namespace) to the root element. For example, if an author uses the XML Schema for OWL Lite, the start tag of the Ontology element may designate the location of the XML Schema as shown below:

<owls:Ontology 
  xmlns:owls="http://www.w3.org/2003/OWL-XMLSchema"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.w3.org/2003/OWL-XMLSchema
                      http://example.org/owl1-lite.xsd" >

A value of the xsi:schemaLocation attribute is a pair (or pairs) of URI references consisting of a namespace name and a location of an XML Schema. Note that a pair of URI references is only a hint for XML Schema processors, which may use alternative XML Schemas indicated by other names. For the further details of schema document access, see "4.3.2 How schema definitions are located on the Web" of the XML Schema Part 1 [XMLSchema-1]

1.3 XML Schema Modules

This document provides a set of XML Schema modules for XML presentation syntax of OWL. The design goal of this modularization is to set up a core module common to all the OWL sublanguages and define additional modules to be customized for different sublanguages. Note that the modularization here is done for the adaptation to the three sublanguages, and is not designed for the arbitrary customization of OWL.

The top-level Schema document, which collects required modules together, is called a Schema driver. A driver document only includes other modules, and does not contain any markup declarations in itself. Modularization through drivers and modules is being done for the reformulation of the XHTML specification in XML Schema [XHTML m12n].

Three Schema drivers are defined for the sublanguages: OWL Lite (owl1-lite.xsd), OWL DL (owl1-dl.xsd), and OWL Full (owl1-full.xsd). These Schema drivers and modules included into the drivers are given separately in Appendix A.

2. Element Reference

2.1 The Root Element

An OWL document consists of an optional header elements and any number of classes, properties, and individuals. Note that "axiom" is a formal term, and may be called "definition" somewhat informally.

<Ontology
  name = xsd:anyURI 
>
  Content: (VersionInfo | PriorVersion | BackwardCompatibleWith | 
            IncompatibleWith | Imports | Annotation | 
            Class[axiom] | EnumeratedClass(D,F) | 
            SubClassOf(D,F) | EquivalentClasses | DisjointClasses(D,F) | 
            DatatypeProperty | ObjectProperty | 
            SubPropertyOf | EquivalentProperties | 
            Individual | SameIndividual | DifferentIndividuals)* 
</Ontology>

2.2 Header Elements

The root element Ontology may optionally contain, in any order, any number of header elements for versioning import and/or annotation statements.

<VersionInfo>
  Content: (#CDATA)
</VersionInfo>

<PriorVersion
  ontology = xsd:anyURI {required} 
>
  Content: (##empty)
</PriorVersion>

<BackwardCompatibleWith
  ontology = xsd:anyURI {required} 
>
  Content: (##empty)
</BackwardCompatibleWith>

<IncompatibleWith
  ontology = xsd:anyURI {required} 
>
  Content: (##empty)
</IncompatibleWith>

<Imports
  ontology = xsd:anyURI {required} 
>
  Content: (##empty)
</Imports>

<Annotation>
  Content: (Label | Documentation | Info | xsd:any )*
</Annotation>

<Label
  xml:lang = language 
>
  Content: (#CDATA)
</Label>

<Documentation
  xml:lang = language 
>
  Content: (#CDATA)
</Documentation>

<Info
  subject = xsd:anyURI
  object = xsd:anyURI
>
  Content: (##empty)
</Info>

2.3 Classes

Classes provide an abstraction mechanism for grouping resources with similar characteristics. OWL classes are described through "class descriptions", which can be combined into "class axioms".

<Class
  name = xsd:anyURI {required} 
  complete = xsd:boolean {required}
  deprecated = xsd:boolean 
>
  Content: (Annotation*, description*)
</Class>

2.3.1 Class Descriptions

  Content: (Class[ID] | DataRestriction | ObjectRestriction | UnionOf(D,F) | 
            IntersectionOf(D,F) | ComplementOf(D,F) | OneOf(D,F))

<Class
  name = xsd:anyURI {required} 
>
  Content: (##empty)
</Class>

(a) Property Restriction

A property restriction defines an anonymous class, namely a class of all individuals that satisfy the restriction. The XML syntax of OWL distinguishes two types of property restrictions: DataRestriction (restriction on properties for which the range value is a data literal) and ObjectRestriction (restriction on properties for which the range value is an individual).

<DataRestriction
  property = xsd:anyURI {required} 
  minCardinality(L)   = either '0' or '1' 
  minCardinality(D,F) = xsd:nonNegativeInteger
  maxCardinality(L)   = either '0' or '1' 
  manCardinality(D,F) = xsd:nonNegativeInteger
  cardinality(L)   = either '0' or '1'  
  cardinality(D,F) = xsd:nonNegativeInteger
>
  Content: ((allValuesFrom | someValueFrom | value(D,F))*)
</DataRestriction>

<allValuesFrom
  datatype = xsd:anyURI 
>
  Content(D,F): ( OneOf? )
</allValuesFrom>

<someValueFrom
  datatype = xsd:anyURI 
>
  Content(D,F): ( OneOf? )
</someValueFrom>

<value>
  Content: ( xsd:anySimpleType )
</value>

<ObjectRestriction
  property = xsd:anyURI {required} 
  minCardinality(L)   = either '0' or '1' 
  minCardinality(D,F) = xsd:nonNegativeInteger
  maxCardinality(L)   = either '0' or '1' 
  manCardinality(D,F) = xsd:nonNegativeInteger
  cardinality(L)   = either '0' or '1'  
  cardinality(D,F) = xsd:nonNegativeInteger
>
  Content: ((allValuesFrom | someValueFrom | value(D,F))*)
</ObjectRestriction>

<allValuesFrom
  class = xsd:anyURI 
>
  Content: ( description(D,F)* )
</allValuesFrom>

<someValueFrom
  class = xsd:anyURI 
>
  Content: ( description(D,F)* )
</someValueFrom>

(b) Enumeration

<OneOf>
  Content: ( Individual[ID]* ) 
</OneOf>

For example:

<owls:Class owls:name="WineColor" owls:complete="false">
  <owls:OneOf>
    <owls:Individual owls:name="#White" /> 
    <owls:Individual owls:name="#Rose" /> 
    <owls:Individual owls:name="#Red" /> 
  </owls:OneOf>
</owls:Class>

Note that EnumeratedClass can also be used for the OneOf enumeration. See the next example below.

<owls:EnumeratedClass owls:name="WineColor2">
  <owls:Individual owls:name="#White" owls:type="WineColor" />
  <owls:Individual owls:name="#Rose"  owls:type="WineColor" />
  <owls:Individual owls:name="#Red"   owls:type="WineColor" />
</owls:EnumeratedClass>

<EnumeratedClass
  name = xsd:anyURI {required} 
  deprecated = xsd:boolean 
>
  Content: (Annotation*, Individual[ID]*) 
</EnumeratedClass>

<Individual
  name = xsd:anyURI {required} 
  type = xsd:anyURI 
>
  Content: (##empty)
</Individual>

(c) Boolean Combination

<IntersectionOf
  class = xsd:anyURI 
>
  Content: ( description* )
</IntersectionOf>

<UnionOf
  class = xsd:anyURI 
>
  Content: ( description* )
</UnionOf>

<ComplementOf>
  Content: ( description )
</ComplementOf>

2.3.2 Class Axioms

<SubClassOf>
  Content: ( sub, super )
</SubClassOf>

<sub>
  Content: ( description )
</sub>

<super>
  Content: ( description )
</super>

<EquivalentClasses>
  Content(L): ( Class[ID], Class[ID]+ )
  Content(D,F): ( description, description+ )
</EquivalentClasses>

<DisjointClasses>
  Content: ( description, description+ )
</DisjointClasses>

2.4 Properties

OWL distinguishes between two types of properties: DatatypeProperty and ObjectProperty.

<DatatypeProperty
  name = xsd:anyURI {required}  
  functional = xsd:boolean 
  inverseFunctional(L,D) = xsd:boolean {fixed as 'false'}
  inverseFunctional(F) = xsd:boolean 
  deprecated = xsd:boolean 
>
  Content: ((super[prop] | domain | range)*)
</DatatypeProperty>

<ObjectProperty
  name = xsd:anyURI {required}  
  inverseOf = xsd:anyURI 
  transitive = xsd:boolean 
  symmetric = xsd:boolean 
  functional = xsd:boolean 
  inverseFunctional(L) = xsd:boolean {fixed as 'false'}
  inverseFunctional(D,F) = xsd:boolean 
  deprecated = xsd:boolean 
>
  Content: ((super[prop] | domain | range)*)
</ObjectProperty>

<super
  name = xsd:anyURI {required}  
>
  Content: (##empty)
</super>

<domain
  class = xsd:anyURI 
>
  Content(L): ( Class[ID]* )
  Content(D,F): ( description* )
</domain>

<domain
  datatype = xsd:anyURI 
>
  Content(D,F): ( OneOf? )
</domain>

<range
  class = xsd:anyURI 
>
  Content(L): ( Class[ID]* )
  Content(D,F): ( description* )
</range>

<SubPropertyOf
  sub = xsd:anyURI {required}  
>
  Content: ( DatatypeProperty[ID] | ObjectProperty[ID] )
</SubPropertyOf>

<EquivalentProperties>
  Content: ( (DatatypeProperty[ID], DatatypeProperty[ID]+ ) |
             (ObjectProperty[ID], ObjectProperty[ID]+) ) 
</EquivalentProperties>

<DatatypeProperty
  name = xsd:anyURI {required} 
>
  Content: (##empty)
</DatatypeProperty>

<ObjectProperty
  name = xsd:anyURI {required} 
>
  Content: (##empty)
</ObjectProperty>

2.5 Individuals

Individual axioms (also called "facts") are statements about individuals, indicating class membership and statements about relevant properties.

Individual axioms need not necessarily be about named individuals: they can also refer to anonymous individuals.

2.6 Enumerated Datatype

A range of data values can be defined as an enumerated datatype.

<OneOf>
  Content: ( DataValue* ) 
</OneOf>

<DataValue
  xsi:type = a type of data value (literal)
>
  Content: ( xsd:anySimpleType )
</DataValue>

2.7 Index of Elements