OWL Web Ontology Language
XML Presentation Syntax

W3C Note 11 June 2003

This version:

http://www.w3.org/TR/2003/NOTE-owl-xmlsyntax-20030611/

Latest version:

http://www.w3.org/TR/owl-xmlsyntax/

Authors:

Masahiro Hori, Kansai University (formerly IBM Tokyo Research)

Jérôme Euzenat, INRIA Rhône-Alpes

Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies

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

---

Abstract

This document specifies XML presentation syntax for OWL, which is defined as a dialect similar to OWL Abstract Syntax [OWL Semantics]. It is not intended to be a normative specification. Instead, it represents a suggestion of one possible XML presentation syntax for OWL.

Table of Contents

• 1. Introduction
  • 1.1 OWL Document Structure
  • 1.2 Notational Conventions
• 2. Element Reference
  • 2.1 The Root Element
  • 2.2 Header Elements
  • 2.3 Classes
    • 2.3.1 Class descriptions
    • 2.3.2 Property restrictions
    • 2.3.3 Enumeration of individuals
    • 2.3.4 Boolean combination
    • 2.3.5 Class relationship
  • 2.4 Properties
  • 2.5 Individuals
    • 2.5.1 Individual axioms
    • 2.5.2 Individual identity
  • 2.6 Datatypes
    • 2.6.1 Data value
    • 2.6.2 Enumeration of data values
• 3. Element Index and Cross Reference
  • 3.1 Element Index
  • 3.2 Cross Reference

• Appendix A. XML Schemas
• Appendix B. OWL Examples in XML Syntax
• Appendix C. Transformation to OWL in RDF/XML
• Appendix D. Acknowledgements
• Appendix E. References
• Appendix F. Change Log

1 Introduction

This document specifies XML presentation syntax for OWL, which is defined as a dialect similar to OWL Abstract Syntax [OWL Semantics]. The OWL language provides three increasingly expressive sublanguages: OWL Lite, OWL DL, and OWL Full. This document provides XML Schemas for XML presentation syntax corresponding to the three sublanguages. 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.

Three Schemas are defined for the sublanguages: OWL Lite (owl1-lite.xsd), OWL DL (owl1-dl.xsd), and OWL Full (owl1-full.xsd). The definitions of these Schemas are given in Appendix A.

1.1 OWL Document Structure

The root element of OWL documents for the XML presentation syntax must be Ontology element (2.1), and an OWL document further consists of optional header elements (2.2) as well as any number of classes (2.3), properties (2.4), and individuals (2.5).

<?xml version="1.0"?>
<!DOCTYPE Ontology [
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" > 
]>
<owlx:Ontology owlx:name="http://www.example.org/wine" 
  xmlns:owlx="http://www.w3.org/2003/05/owl-xml">

  <!--  
    Contains optional header elements as well as 
    any number of classes, properties, and individuals.  
  -->

</owlx:Ontology>

Attribute values are frequently used for referring to identifiers in OWL. Since attribute values are not namespace sensitive, they may be written down in their fully expanded form (e.g., http://www.example.org/owl/wine#merlot). Alternatively, XML entities can be used as abbreviations. In the XML presentation syntax, XML Schema datatypes (2.6) are referred to by owlx:datatype attributes, and an XML entity &xsd; can be used for readability.

1.2 Notational Conventions

A number of namespace prefixes are used in this document as listed below. Note that the choice of any namespace prefix is arbitrary, and not semantically significant.

2. Element Reference

All the elements and their attributes and element contents in the XML syntax are listed in this section. In order to indicate partial availability for OWL sublanguages, subscript enclosed within parentheses [e.g., (L) and (D,F)] may be appended to either element names, attribute names, or labels for element contents (i.e., Content:). For example, EnumeratedClass_(D,F) means that EnumeratedClass element is only available for OWL DL and OWL Full. Note that all the elements, attributes, and element contents without subscript in parentheses means that those constructs are available for all the three OWL sublanguages.

Examples and their brief explanations of OWL statements in this section are derived from the Reference document [OWL Reference], and more examples in Appendix B are created on the basis of the Guide document [OWL Guide]. In addition, element index (3.1) gives an alphabetical list of elements in the XML presentation syntax, and cross reference (3.2) shows the correspondence between constructs in RDF/XML syntax and elements of XML presentation syntax. In Appendix C, an XSLT stylesheet is given for the transformation from the XML presentation syntax toward RDF/XML syntax of OWL.

2.1 The Root Element

<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[axiom] | 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. In the presentation syntax, there is no header element in contrast to the RDF/XML syntax in which owl:Ontology is provided as a construct for the header component.

A sample ontology header could look like this (see also 3 in [OWL Reference]):

<owlx:VersionInfo>2003/02/24 22:37:39</owlx:VersionInfo>
<owlx:Annotation>
  <owlx:Documentation>An example OWL ontology</owlx:Documentation> 
</owlx:Annotation>
<owlx:PriorVersion owlx:ontology="http://www.example.org/wine-112102.owl" /> 
<owlx:Imports owlx:ontology="http://www.example.org/food.owl"/> 
<owlx:Annotation>
  <owlx:Label>Wine Ontology</owlx:Label> 
</owlx:Annotation>

<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 | xsd:any )*
</Annotation>

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

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

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". "Axiom" is a formal term, and may be called "definition" informally.

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

2.3.1 Class descriptions

A class description is the term used in [OWL Reference] [OWL Semantics], and used as a basic building block of class axioms (or called class definitions informally).

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

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

<owlx:Class owlx:name="Student" owlx:complete="false"> 
  <owlx:Annotation>
    <owlx:Label xml:lang="nl">student</owlx:Label>
    <owlx:Label xml:lang="it">studente</owlx:Label>
    <owlx:Label xml:lang="es">estudiante</owlx:Label>
    <owlx:Documentation xml:lang="en">Undergraduates students</owlx:Documentation>
  </owlx:Annotation>
  <owlx:Class owlx:name="Person" />
</owlx:Class> 

2.3.2 Property restrictions

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).

<owlx:Class owlx:name="Student" owlx:complete="false"> 
  <owlx:Class owlx:name="Person" />

  <owlx:DataRestriction owlx:property="studentID">
    <owlx:cardinality owlx:value="1" />
    <owlx:allValuesFrom owlx:datatype="&xsd;integer" />
  </owlx:DataRestriction>                        

  <owlx:DataRestriction owlx:property="grade">
    <owlx:cardinality owlx:value="1" />
    <owlx:allValuesFrom>                        
      <owlx:OneOf>                               
        <owlx:DataValue owlx:datatype="&xsd;integer">1</owlx:DataValue>
        <owlx:DataValue owlx:datatype="&xsd;integer">2</owlx:DataValue>
        <owlx:DataValue owlx:datatype="&xsd;integer">3</owlx:DataValue>
        <owlx:DataValue owlx:datatype="&xsd;integer">4</owlx:DataValue>
      </owlx:OneOf>                              
    </owlx:allValuesFrom>                       
  </owlx:DataRestriction>

  <owlx:ObjectRestriction owlx:property="schoolYear">
    <owlx:cardinality owlx:value="1" />
    <owlx:allValuesFrom> 
      <owlx:OneOf> 
        <owlx:Individual owlx:name="Freshman" />   
        <owlx:Individual owlx:name="Sophomore" />  
        <owlx:Individual owlx:name="Junior" />     
        <owlx:Individual owlx:name="Senior" /> 
      </owlx:OneOf>                              
    </owlx:allValuesFrom>                       
  </owlx:ObjectRestriction>

  <owlx:ObjectRestriction owlx:property="advisor">
    <owlx:minCardinality owlx:value="1" />
    <owlx:allValuesFrom owlx:class="Person" />
    <owlx:someValuesFrom>
      <owlx:Class owlx:name="Professor" />
      <owlx:Class owlx:name="AssociateProfessor" />
    </owlx:someValuesFrom>
  </owlx:ObjectRestriction>                  

</owlx:Class>

<DataRestriction
  property = xsd:anyURI {required} 
>
  Content(L): ( (minCardinality | maxCardinality | cardinality | 
                 allValuesFrom | someValuesFrom) )
  Content(D,F): ( (minCardinality | maxCardinality | cardinality | 
                  allValuesFrom | someValuesFrom | hasValue)+ )
</DataRestriction>

<minCardinality
  value(L)   = either '0' or '1' {required}
  value(D,F) = xsd:nonNegativeInteger {required}
>
  Content: ( ##empty )
</minCardinality>

<maxCardinality
  value(L)   = either '0' or '1' {required}
  value(D,F) = xsd:nonNegativeInteger {required}
>
  Content: ( ##empty )
</maxCardinality>

<cardinality
  value(L)   = either '0' or '1' {required}
  value(D,F) = xsd:nonNegativeInteger {required}
>
  Content: ( ##empty )
</cardinality>

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

<someValuesFrom
  datatype = xsd:anyURI 
>
  Content(D,F): ( OneOf[data]? )
</someValuesFrom>

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

<ObjectRestriction
  property = xsd:anyURI {required} 
>
  Content(L): ( (minCardinality | maxCardinality | cardinality | 
                 allValuesFrom | someValuesFrom) )
  Content(D,F): ( (minCardinality | maxCardinality | cardinality | 
                  allValuesFrom | someValuesFrom | hasValue)+ )
</ObjectRestriction>

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

The example below describes a class of all individuals for which the "hasParent" property only has range values of class "Human" (see also owl:allValuesFrom in [OWL Reference]).

<owlx:Class owlx:name="Child1" owlx:complete="false">
  <owlx:ObjectRestriction owlx:property="#hasParent"> 
    <owlx:allValuesFrom owlx:class="#Human" />
  </owlx:ObjectRestriction> 
</owlx:Class>

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

The following example defines a class of individuals which have at least one parent who is a physician (see also owl:someValuesFrom in [OWL Reference]):

<owlx:Class owlx:name="Child2" owlx:complete="false">
  <owlx:ObjectRestriction owlx:property="#hasParent"> 
    <owlx:someValuesFrom owlx:class="#Physician" />
  </owlx:ObjectRestriction> 
</owlx:Class>

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

The following example describes the class of individuals who have the individual referred to as "Clinton" as their parent (see also owl:hasValue in [OWL Reference]):

<owlx:Class owlx:name="Child3" owlx:complete="false"> 
  <owlx:ObjectRestriction owlx:property="#hasParent">
    <owlx:hasValue owlx:name="#Clinton" /> 
  </owlx:ObjectRestriction> 
</owlx:Class>

2.3.3 Enumeration of individuals

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

For example, the following OneOf statement defines a class of all continents (see also Enumeration in [OWL Reference]):

<owlx:Class owlx:name="AllContinents" owlx:complete="true">
  <owlx:OneOf>
    <owlx:Individual owlx:name="#Eurasia" /> 
    <owlx:Individual owlx:name="#Africa" /> 
    <owlx:Individual owlx:name="#NorthAmerica" /> 
    <owlx:Individual owlx:name="#SouthAmerica" /> 
    <owlx:Individual owlx:name="#Australia" /> 
    <owlx:Individual owlx:name="#Antarctica" /> 
  </owlx:OneOf>
</owlx:Class>

A statement of the form <owlx:Individual owlx:name="..."/> refers to some individual (remember: all individuals are by definition instances of owlx:Individual).

In the section on datatypes we will see another use of the OneOf element, namely to define an enumeration of data values.

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

EnumeratedClass can also be used for the OneOf enumeration, and the enumeration of all continents can be described as follows (see also Enumeration in [OWL Reference]):

<owlx:EnumeratedClass owlx:name="AllContinents">
  <owlx:Individual owlx:name="#Eurasia" /> 
  <owlx:Individual owlx:name="#Africa" /> 
  <owlx:Individual owlx:name="#NorthAmerica" /> 
  <owlx:Individual owlx:name="#SouthAmerica" /> 
  <owlx:Individual owlx:name="#Australia" /> 
  <owlx:Individual owlx:name="#Antarctica" /> 
</owlx:EnumeratedClass>

2.3.4 Boolean combination

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

In the example below, the range of the intersection statement is a list of two class descriptions, namely two enumerations, both describing a class with two individuals. The resulting intersection is a class with one individual, namely "Tosca" since this is the only individual that is common to both enumerations (see also owl:intersectionOf in [OWL Reference]).

<owlx:Class owlx:name="IntersectionOf-eg" owlx:complete="true">
  <owlx:IntersectionOf>
    <owlx:OneOf>
      <owlx:Individual owlx:name="#Tosca" /> 
      <owlx:Individual owlx:name="#Salome" /> 
    </owlx:OneOf>
    <owlx:OneOf>
      <owlx:Individual owlx:name="#Turandot" /> 
      <owlx:Individual owlx:name="#Tosca" /> 
    </owlx:OneOf>
  </owlx:IntersectionOf>
</owlx:Class>

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

The example below describes a class for which the class extension contains three individuals, namely "Tosca", "Salome", and "Turandot" assuming they are all different (see also owl:unionOf in [OWL Reference]).

<owlx:Class owlx:name="UnionOf-eg" owlx:complete="true">
  <owlx:UnionOf>
    <owlx:OneOf>
      <owlx:Individual owlx:name="#Tosca" /> 
      <owlx:Individual owlx:name="#Salome" /> 
    </owlx:OneOf>
    <owlx:OneOf>
      <owlx:Individual owlx:name="#Turandot" /> 
      <owlx:Individual owlx:name="#Tosca" /> 
    </owlx:OneOf>
  </owlx:UnionOf> 
</owlx:Class>

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

For example, the expression "neither meat nor fish" could be written as follows by using ComplementOf element (see also owl:complementOf in [OWL Reference]).

<owlx:Class owlx:name="ComplementOf-eg" owlx:complete="true">
  <owlx:ComplementOf>
    <owlx:UnionOf> 
      <owlx:Class owlx:name="#Meat" /> 
      <owlx:Class owlx:name="#Fish" /> 
    </owlx:UnionOf> 
  </owlx:ComplementOf>
</owlx:Class>

2.3.5 Class relationships

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

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

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

For example, the following class axiom declares a subclass relation between two classes that are described through their names ("Opera" and "MusicalWork"). Subclass relations provide necessary conditions for belonging to a class. In this case, to be an opera the individual also needs to be a musical work (see also rdfs:subClassOf in [OWL Reference]).

<owlx:Class owlx:name="Opera" owlx:complete="false">
  <owlx:Class owlx:name="#MusicalWork" /> 
</owlx:Class>

For any class there may be any number of subClassOf axioms. For example, it is possible to add the following axiom about the Opera class.

<owlx:SubClassOf>
  <owlx:sub>
    <owlx:Class owlx:name="Opera" />
  </owlx:sub>
  <owlx:super>
    <owlx:ObjectRestriction owlx:property="#hasLibrettist">  
      <owlx:minCardinality owlx:value="1" /> 
    </owlx:ObjectRestriction> 
  </owlx:super>
</owlx:SubClassOf>

This class axiom contains a property restriction. The example states that Opera is a subclass of an anonymous OWL class that has as its class extension the set of all individuals for which the property hasLibrettist has at least one value. Thus, operas should have at least one librettist.

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

In its simplest form, an EquivalentClass axiom states the equivalence (in terms of their class extension) of two named classes. For example:

<owlx:EquivalentClasses>
  <owlx:Class owlx:name="US_President" />
  <owlx:Class owlx:name="PrincipalResidentOfWhiteHouse" /> 
</owlx:EquivalentClasses>

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

Declaring two classes to be disjoint is a partial definition: it imposes a necessary but not sufficient condition on the class. A popular example of class disjointness is given below:

<owlx:DisjointClasses> 
  <owlx:Class owlx:name="#Man" />
  <owlx:Class owlx:name="#Woman" />
</owlx:DisjointClasses>

The following example shows a common use of class disjointness in subclass hierarchies. The next example indicates that MusicDrama is either an opera, an Operetta, or a Musical (i.e., the subclass partitioning is complete).

<owlx:Class owlx:name="MusicDrama" owlx:complete="true">
  <owlx:UnionOf>
    <owlx:Class owlx:name="#Opera" />
    <owlx:Class owlx:name="#Operetta" />
    <owlx:Class owlx:name="#Musical" />
  </owlx:UnionOf>
</owlx:Class>

In the examples below, individuals belonging to one subclass such as Opera cannot belong to another subclass such as Musical (disjoint or non-overlapping subclasses).

<owlx:Class owlx:name="#Opera" owlx:complete="false">
  <owlx:Class owlx:name="#MusicDrama" /> 
</owlx:Class>

<owlx:Class owlx:name="#Operetta" owlx:complete="false">
  <owlx:Class owlx:name="#MusicDrama" /> 
</owlx:Class>

<owlx:Class owlx:name="#Musical" owlx:complete="false">
  <owlx:Class owlx:name="#MusicDrama" /> 
</owlx:Class>

<owlx:DisjointClasses> 
  <owlx:Class owlx:name="#Opera" />
  <owlx:Class owlx:name="#Operetta" />
  <owlx:Class owlx:name="#Musical" />
</owlx:DisjointClasses>

In the above examples, DisjointWith elements were used together with UnionOf, in order to define a set of mutually disjoint and complete subclasses of a superclass (see also owl:disjointWith in [OWL Reference]).

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: ((superProperty | domain | range)*)
</DatatypeProperty>

<owlx:DatatypeProperty owlx:name="age">
  <owlx:domain owlx:class="Person" />
  <owlx:range owlx:datatype="&xsd;integer" />
</owlx:DatatypeProperty> 

See also the other examples of datatype property: timeStamp in 2.6 and tennisGameScore in 2.6.2.

<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: ((superProperty | domain | range)*)
</ObjectProperty>

A property axiom defines characteristics of a properties. In its simplest form, a property axiom just defines the existence of a property. For example:

<owlx:ObjectProperty owlx:name="hasParent" /> 

This defines a property with the restriction that the range values should be individuals (i.e., ObjectProperty).

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

The next example states that all instances (pairs) contained in the property extension of the property hasMother are also members of the property extension of the property hasParent.

<owlx:ObjectProperty owlx:name="hasMother">
  <owlx:superProperty owlx:name="#hasParent" />
</owlx:ObjectProperty>

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

For example, it is possible to state that the domain of the property hasBankAccount can be either a Person or a Corporation in the following manner:

<owlx:ObjectProperty owlx:name="hasBankAccount">
  <owlx:domain>
    <owlx:UnionOf>
      <owlx:Class owlx:name="#Person" />
      <owlx:Class owlx:name="#Corporation" />
    </owlx:UnionOf>
  </owlx:domain>
</owlx:ObjectProperty>

<range
  datatype = xsd:anyURI 
>
  Content(D,F): ( OneOf[data]? )
</range>

<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

2.5.1 Individual axioms

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

<Individual
  name = xsd:anyURI
>
  Content: (Annotation*, (type | DataPropertyValue | ObjectPropertyValue)* ) 
</Individual>

As an example, consider the following set of statements about an instance of the class Opera (see also 6.1 in [OWL Reference]):

<owlx:Individual owlx:name="Tosca">
  <owlx:type owlx:name="Opera" /> 
  <owlx:ObjectPropertyValue owlx:property="hasComposer"> 
    <owlx:Individual owlx:name="#Giacomo_Puccini" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:ObjectPropertyValue owlx:property="hasLibrettist"> 
    <owlx:Individual owlx:name="#Victorien_Sardou" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:ObjectPropertyValue owlx:property="hasLibrettist"> 
    <owlx:Individual owlx:name="#Luigi_Illica" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:DataPropertyValue owlx:property="premiereDate">
    <owlx:DataValue owlx:datatype="&xsd;date">1900-01-14</owlx:DataValue> 
  </owlx:DataPropertyValue>
  <owlx:ObjectPropertyValue owlx:property="premierePlace"> 
    <owlx:Individual owlx:name="#Roma" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:DataPropertyValue owlx:property="numberOfActs">
    <owlx:DataValue owlx:datatype="&xsd;positiveInteger">3</owlx:DataValue>
  </owlx:DataPropertyValue>
</owlx:Individual>

<type
  name = xsd:anyURI 
>
  Content: ( description* ) 
</type>

<DataPropertyValue
  property = xsd:anyURI {required} 
>
  Content: ( DataValue* ) 
</DataPropertyValue>

<ObjectPropertyValue
  property = xsd:anyURI {required} 
>
  Content: ( Individual[axiom]* ) 
</ObjectPropertyValue>

Individual axioms need not necessarily be about named individuals: they can also refer to anonymous individuals. As an example, consider the example below. The example defines some facts about an anonymous instance of the class Measurement, a quantitative observation for which facts such as the observed subject, the observed phenomenon, the observed value, and the observation time are listed (see also 6.1 in [OWL Reference]):

<owlx:Individual>
  <owlx:type owlx:name="Measurement" /> 
  <owlx:ObjectPropertyValue owlx:property="observedSubject"> 
    <owlx:Individual owlx:name="#JaneDoe" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:ObjectPropertyValue owlx:property="observedPhenomenon"> 
    <owlx:Individual owlx:name="#Weight" /> 
  </owlx:ObjectPropertyValue> 
  <owlx:ObjectPropertyValue owlx:property="observedValue"> 
    <owlx:Individual> 
      <owlx:type owlx:name="Quantity" /> 
      <owlx:DataPropertyValue owlx:property="quantityValue">
        <owlx:DataValue 
          owlx:datatype="&xsd;float">59.5</owlx:DataValue>
      </owlx:DataPropertyValue>
      <owlx:ObjectPropertyValue owlx:property="quantityUnit"> 
        <owlx:Individual owlx:name="#Kilogram" /> 
      </owlx:ObjectPropertyValue> 
    </owlx:Individual>
  </owlx:ObjectPropertyValue> 
  <owlx:DataPropertyValue owlx:property="timeStamp">
    <owlx:DataValue 
      owlx:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</owlx:DataValue>
  </owlx:DataPropertyValue>
</owlx:Individual>

2.5.2 Individual identity

Many languages have a so-called "unique names" assumption: different names refer to different things in the world. On the web, such an assumption is not possible. For example, the same person could be referred to in many different ways (i.e. with different URI references). For this reason OWL does not make this assumption. Unless an explicit statement is being made that two URI references refer to the same or to different individuals, OWL tools should in principle assume either situation is possible.

Two elements SameIndividual and DifferentIndividuals are provided for making statements about the identity of individuals.

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

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

For example, we could state that the following two URI references actually refer to the same person (see also 6.2 in [OWL Reference]):

<owlx:SameIndividual>
  <owlx:Individual owlx:name="#William_Jefferson_Clinton" owlx:type="Human" />
  <owlx:Individual owlx:name="#BillClinton" /> 
</owlx:SameIndividual>

In OWL Full, where class can be treated as instances of (meta)classes, we can use the SameIndividual element to define class equality, thus indicating that two concepts have the same intensional meaning. An example (see also 6.2 in [OWL Reference]):

<owlx:Individual owlx:name="FootballTeam">
  <owlx:type owlx:name="&owlx;Class" /> 
</owlx:Individual>

<owlx:SameIndividual>
  <owlx:Individual owlx:name="FootballTeam" />
  <owlx:Individual owlx:name="http://sports.org/US#SoccerTeam" /> 
</owlx:SameIndividual>

Note that the first Individual element in the above example is an individual axiom, while the other Individual elements contained in SameIndividual are individual IDs.

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

The following example states that there are three operas, which are all different individuals (see also 6.2 in [OWL Reference]).

<owlx:Individual owlx:name="Don_Giovanni">
  <owlx:type owlx:name="Opera" /> 
</owlx:Individual>

<owlx:Individual owlx:name="Nozze_di_Figaro">
  <owlx:type owlx:name="Opera" /> 
</owlx:Individual>

<owlx:Individual owlx:name="Cosi_fan_tutte">
  <owlx:type owlx:name="Opera" /> 
</owlx:Individual>

<owlx:DifferentIndividuals>
  <owlx:Individual owlx:name="#Don_Giovanni" />
  <owlx:Individual owlx:name="#Nozze_di_Figaro" />
  <owlx:Individual owlx:name="#Cosi_fan_tutte" /> 
</owlx:DifferentIndividuals>

2.6 Datatypes

OWL uses the facilities of XML Schema Datatypes [XMLSchema-2], and the following built-in XML Schema datatypes can be used.

xsd:string	xsd:boolean	xsd:decimal
xsd:float	xsd:double	xsd:dateTime
xsd:time	xsd:date	xsd:gYearMonth
xsd:gYear	xsd:gMonthDay	xsd:gDay
xsd:gMonth	xsd:hexBinary	xsd:base64Binary
xsd:anyURI	xsd:normalizedString	xsd:token
xsd:language	xsd:NMTOKEN	xsd:Name
xsd:NCName	xsd:integer	xsd:nonPositiveInteger
xsd:negativeInteger	xsd:long	xsd:int
xsd:short	xsd:byte	xsd:nonNegativeInteger
xsd:unsignedLong	xsd:unsignedInt	xsd:unsignedShort
xsd:unsignedByte	xsd:positiveInteger

The specific considerations with the other built-in XML Schema datatypes are explained in the Abstract Syntax document [OWL Semantics].

A datatype can be specified as a value of datatype attribute, which is decleared in allValuesFrom and someValuesFrom elements (for DataRestriction) as well as range element (for DatatypeProperty). A value of the datatype attribute should be a canonical URI reference to an XML Schema datatype: "http://www.w3.org/2001/XMLSchema#name", where name is a local name of a built-in XML Schema datatype. For example (see also 7.1 in [OWL Reference]):

<owlx:DatatypeProperty owlx:name="#timeStamp">
  <owlx:domain owlx:class="#Measurement" />
  <owlx:range owlx:datatype="http://www.w3.org/2001/XMLSchema#dateTime" />
</owlx:DatatypeProperty>

Note here that XML entities can be used as abbreviations. For example, an XML entity xsd is defined in the DOCTYPE declaration:

   <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >

Then, the above owlx:datatype attribute of owlx:range element may be specifid in the following manner.

   <owlx:range owlx:datatype="&xsd;dateTime" />

2.6.1 Data value

Data values can be either plain (no datatype) or typed. In DataValue element, typed value may be specified by using datatype attribute.

<DataValue
  datatype = xsd:anyURI 
>
  Content: (#CDATA)
</DataValue>

For example, a type of time stamp property value can be specified with the dateTime datatype defined as an XML Schema datatype, by using the datatype attribute (see also 7.1 in [OWL Reference]).

<owlx:Individual>
  <owlx:type owlx:name="Measurement" /> 
  <owlx:DataPropertyValue owlx:property="timeStamp">
    <owlx:DataValue 
      owlx:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</owlx:DataValue>
  </owlx:DataPropertyValue>
</owlx:Individual>

2.6.2 Enumeration of data values

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

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

For example, the range of tennisGameScore property to be the list of integer values {0, 15, 30, 40} can be specifies as below (see also 7.2 in [OWL Reference]):

<owlx:DatatypeProperty owlx:name="tennisGameScore">
  <owlx:range>
    <owlx:OneOf>                               
      <owlx:DataValue owlx:datatype="&xsd;integer">0</owlx:DataValue>
      <owlx:DataValue owlx:datatype="&xsd;integer">15</owlx:DataValue>
      <owlx:DataValue owlx:datatype="&xsd;integer">30</owlx:DataValue>
      <owlx:DataValue owlx:datatype="&xsd;integer">40</owlx:DataValue>
    </owlx:OneOf>
  </owlx:range>
</owlx:DatatypeProperty>

3. Element Index and Cross Reference

3.1 Element Index

3.2 Cross Reference

The table below shows the term correspondence between RDF/XML and the XML presentation syntax. In the column of presentation syntax, the terms begin with '@' indicate attributes belong to an element concatenated before the attribute with a '/' delimiter.

Note: Appendix A of the OWL Reference [OWL Reference] provides a systematic set of links for each language construct in the Reference document and corresponding sections in the Guide [OWL Guide] as well as the Semantics [OWL Semantics] documents.