| CARVIEW |
Web Ontology Language (OWL)
Reference Version 1.0
W3C Working Draft 12 November 2002
- This version:
- https://www.w3.org/TR/2002/WD-owl-ref-20021112/
- Latest version:
- https://www.w3.org/TR/owl-ref/
- Previous version:
- https://www.w3.org/TR/2002/WD-owl-ref-20020729/
- Editors:
-
Mike Dean
Dan Connolly
Frank van Harmelen
James Hendler
Ian Horrocks
Deborah L. McGuinness
Peter F. Patel-Schneider
Lynn Andrea Stein
Copyright ©2002 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
Abstract
OWL is a semantic markup language for publishing and sharing ontologies on the World Wide Web. OWL is derived from the DAML+OIL Web Ontology Language [DAML+OIL] and builds upon the Resource Description Framework [RDF/XML Syntax].
Status of this document
This Working Draft is the first version of the OWL Web Ontology Language 1.0 specification. The Web Ontology (WebOnt) Working Group expects to update it to reflect changes in requirements until such time as OWL becomes a W3C Recommendation. The working group has not reached consensus on all issues, and has produced an online issues list [OWL Issues] that maintains the current status of all issues being considered. Links to associated issues are highlighted.
Editorial notes to be addressed in future revisions are also highlighted.
Comments on this document should be sent to public-webont-comments@w3.org, a mailing list with a public archive. General discussion of related technology is welcome in www-rdf-logic.
There are no patent disclosures related to this work at the time of this writing.
This is a W3C Working Draft for review by W3C members and other interested parties. It is a draft document and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference materials or to cite them as other than "work in progress." A list of current W3C Recommendations and other technical documents can be found at https://www.w3.org/TR/.
This document has been produced as part of the W3C Semantic Web Activity (Activity Statement) following the procedures set out for the W3C Process. The document has been written by the Web Ontology Working Group. The goals of the Web Ontology working group are discussed in the Web Ontology Working Group charter.
This document is derived from the DAML+OIL (March 2001) Reference Description [DAML+OIL] included in the DAML+OIL submission. The work of the authors, editors, and sponsors of that and predecessor documents is gratefully acknowledged.
Table of contents
Appendices
- Appendix A. Index of all language elements
- Appendix B. Notes
- Appendix C. https://www.w3.org/2002/07/owl
- Appendix D. Changes from DAML+OIL
1. Introductory remarks
This document gives a systematic, compact and informal description of all the modelling primitives of OWL. We expect this document to serve as a reference guide for users of the OWL language.
- Readers unfamiliar with OWL may wish to first consult the [OWL Guide] for a more narrative description of example uses of the language.
- The normative reference on the precise syntax of the language constructs is the machine readable RDF Schema definition of OWL, also included as Appendix C.
- This document specifies the exchange syntax for OWL. An abstract syntax designed to serve as a basis for formal specification is specified in the OWL Web Ontology Language 1.0 Abstract Syntax [OWL Abstract Syntax].
- A precise definition of the meaning of the language constructs is given in the future Formal Specification.
- OWL Lite is a subset of the OWL language. The layering of language features is given in the Feature Synopsis for OWL Lite and OWL [OWL Features].
- Several other documents have been prepared describing how
other "presentation syntax" realizations of the abstract syntax can be used to
produce documents that map into the normative exchange syntax. These
documents include:
- future UML
- future XML
- future, possibly frame syntax
- future, possibly N3
An OWL knowledge base is a collection of RDF triples as defined in the RDF/XML Syntax Specification (Revised) [RDF/XML Syntax]. OWL prescribes a specific meaning for triples that use the OWL vocabulary. This document specifies which collections of RDF triples constitute the OWL vocabulary and what the prescribed meaning of such triples is.
Different syntactic forms
As with any set of RDF triples, OWL triples can be represented in many different syntactic forms (as described in the RDF/XML Syntax Specification (Revised) [RDF/XML Syntax]). The current document uses a specific RDF syntactic form for these triples. However, it is also allowed to use any other syntactic RDF form that results in the same underlying set of RDF triples as the syntax used in this document. Such other syntactic forms would then carry exactly the same prescribed meaning as the equivalent syntactic form used in this document. See Syntax Note for an example of this.
Mixing OWL with arbitrary RDF
As stated above, OWL assigns a specific meaning to certain RDF triples. The future Formal Specification specifies exactly which triples are assigned a specific meaning, and what this meaning is. OWL only provides a semantic interpretation for those parts of an RDF graph that instantiate the schema defined in https://www.w3.org/2002/07/owl. Any additional RDF statements, resulting in additional RDF triples are perfectly allowed, but OWL is silent on the semantic consequences (or lack thereof) of such additional triples. See Mixing Note for an example of this.
2. Language structure
An OWL ontology is made up of several components, some of which are optional, and some of which may be repeated. See the index for a listing of all these components. Throughout this document, OWL constructs will be presented in a structured format, and not as bare RDF triples. This structured RDF format is more natural to read, but, of course, any way of generating the same RDF triples as generated by the structured RDF format is equivalent.
Several components employ lists constructed using the rdf:List, rdf:first, rdf:rest, rdf:nil, and rdf:parseType="Collection" vocabulary [Ed: identify link] recently added to RDF.
An OWL ontology consists of zero or more headers, followed by zero or more class elements, property elements, and instances.
Header
An owl:Ontology
element contains zero or more version information
and imports elements.
<owl:Ontology rdf:about=""> <owl:versionInfo>$Id: Overview.html,v 1.3 2018/10/09 13:21:01 denis Exp $</versionInfo> <rdfs:comment>An example ontology</rdfs:comment> <owl:imports rdf:resource="https://www.w3.org/2002/07/owl"/> </owl:Ontology>
Version information
The
owl:versionInfo element generally contains a string giving
information about this version, for example RCS/CVS keywords. This element
does not contribute to the logical meaning of the ontology. See the example
above.
See issue #5.14-Ontology-versioning.
Imports
Each owl:imports
statement references another OWL ontology containing definitions
that apply to the current OWL resource.
Each reference consists of a URI specifying from where the
ontology is to be imported from. See the example above.
Imports
statements are transitive, that is, if ontology A imports B, and B
imports C, then A imports both B and C. Importing an ontology into
itself is considered a null action, so if ontology A imports B and B
imports A, then they are considered to be equivalent.
See issue #5.6-daml:imports-as-magic-syntax.
Note that namespaces only provide a mechanism for creating unique names for elements, and do not actually include definitions in the way that imports does. Similarly, imports statements do not set up a shorthand notation for names. Therefore, it is common to have imports statements that correspond to each namespace. However, additional imports may be used for ontologies that provide definitions without introducing any new names.
See issue #4.4-Extra-logical-feature-set.
Objects and datatype values
OWL divides the universe into two disjoint parts. One part consists of the values that belong to XML Schema datatypes. This part is called the datatype domain. The other part consists of (individual) objects that are considered to be members of classes described within OWL (or RDF). This part is called the object domain.
OWL is mostly concerned with the creation of classes that describe (or define) part of the object domain. Such classes are called object classes and are elements of owl:Class, a subclass of rdfs:Class. OWL also allows the use of XML Schema datatypes to describe (or define) part of the datatype domain. These datatypes are used within OWL simply by including their URIs within an OWL ontology. They are (implicitly) elements of owl:Datatype. Datatypes are not OWL individual objects. See issue #5.8-Datatypes.
Class elements
A class element, owl:Class, contains (part of) the definition
of an object class.
A class element refers to a class name (a URI) (we will refer to this class
as C) and contains
- zero or more
rdfs:subClassOfelements (each containing a class-expression).
Each rdfs:subClassOf element asserts that C is a subclass of the class-expression mentioned in the element. (Each class-expression defines a (possibly anonymous) class). RDFS and OWL allow cycles of subclass relationships as a means to assert equality between classes. - zero or more
owl:disjointWithelements (each containing a class-expression).
Each owl:disjointWith element asserts that C is disjoint with the class-expression in the element (ie. C must have no instances in common with it);
- zero or more
owl:sameClassAselements (each containing a class-expression).
Each owl:sameClassAs element asserts that C is equivalent to the class-expression in the element (ie. C and all the class-expression must have the same instances);
- zero or more
owl:sameAselements (each containing a class expression)
When applied to a class, the owl:sameAs element has the same semantics as the owl:sameClassAs element.
Warning: the use of owl:sameClassAs is favoured over the use of owl:sameAs, since owl:sameClassAs is declared as a subproperty of rdfs:subClassOf, while owl:sameAs is not. This makes the meaning of owl:sameClassAs at least partly available to an RDF Schema-only agent, while the meaning of owl:sameAs is completely opaque to such an agent. owl:sameAs is typically used when it is not known that the expression denotes a class.
- zero or more boolean combinations of class
expressions.
The class C must be equivalent to the class defined by each of the boolean class expression,
and - zero or more enumeration elements.
Each enumeration element asserts that C contains exactly the instances enumerated in the element (i.e: no more, no less). Although it is formally allowed to have multiple such assertions about C, as soon as two of the enumerations are not equivalent, the class C immediately becomes inconsistent (since C cannot be equivalent to both of these enumerations at once).
Notice that the first two elements state necessary but not sufficient
conditions for class membership. The final four elements state both necessary
and sufficient conditions.
Class expressions
A class expression is the name used in this document for either
- a class name (a URI), or
- an enumeration, enclosed in
<owl:Class>...</owl:Class>tags, or - a property-restriction, or
- a boolean combination of class expressions,
enclosed in
<rdfs:Class>...</rdfs:Class>tags
Each class expression either refers to a named class, namely the class that is identified by the URI, or implicitly defines an anonymous class, respectively the class that contains exactly the enumerated elements, or the class of all instances which satisfy the property-restriction, or the class that satisfies the boolean combination of such expressions.
Two class names are already predefined, namely the classes
owl:Thing
and owl:Nothing. Every
object is a member of owl:Thing, and no object is a member of
owl:Nothing. Consequently, every class is a subclass of
owl:Thing and owl:Nothing is a subclass of
every class.
Enumerations
An enumeration is a
owl:oneOf element, containing a list of the objects
that are its instances.
This enables us to define a class by exhaustively enumerating its elements.
The class defined by the oneOf element contains exactly the enumerated
elements, no more, no less. For example:
<owl:oneOf rdf:parseType="Collection"> <owl:Thing rdf:about="#Eurasia"/> <owl:Thing rdf:about="#Africa"/> <owl:Thing rdf:about="#North_America"/> <owl:Thing rdf:about="#South_America"/> <owl:Thing rdf:about="#Australia"/> <owl:Thing rdf:about="#Antarctica"/> </oneOf>
Property restrictions
A property restriction is a special kind of class expression. It implicitly defines an anonymous class, namely the class of all objects that satisfy the restriction. There are two kinds of restrictions. The first kind, ObjectRestriction, works on object properties, i.e., properties that relate objects to other objects. The second kind, DatatypeRestriction, works on datatype properties, i.e., properties that relate objects to datatype values. Both kinds of restrictions are created using the same syntax, with the usual difference being whether a class element or a datatype reference is used. It is also possible to create restrictions that are neither object restrictions nor datatype restrictions, but these restrictions are not handled within OWL.
An owl:Restriction element contains an
owl:onProperty element, which refers to a property name (a
URI) (we will refer to this property as P) and one or more of the
following
- elements indicating the type of restriction:
- an
owl:allValuesFromelement (which contains a class expression ).
An owl:allValuesFrom element defines the class of all objects for whom the values of property P all belong to the class expression. In other words, it defines the class of object x for which it holds that if the pair (x,y) is an instance of P, then y is an instance of the class-expression or datatype;
- an
owl:hasValueelement (which contains (a reference to) an individual object or a datatype value).
An owl:hasValue element defines the class of all objects for whom the property P has at least one value equal to the named object or datatype value (and perhaps other values as well). In other words, if we call the instance y, then it defines the class of objects x for which (x,y) is an instance of P;
- an
owl:someValuesFromelement (which contains a class expression or a datatype references).
An owl:someValuesFrom element defines the class of all objects for which at least one value of the property P is a member of the class expression or datatype. In other words, it defines the class of objects x for which there is at least one instance y of the class-expression or datatype such that (x,y) is an instance of P. This does not exclude that there are other instances (x,y') of P for which y' does not belong to the class expression or datatype.
Also notice that the correspondence of owl:allValuesFrom with the universal quantifier means that an owl:allValuesFrom restriction for a property P is trivially satisfied for an instance that has no value for property P at all. To see why this is so, observe that the owl:allValuesFrom restriction demands that all values of P belong to class P, and if no such values exist, the restriction is trivially true.
- an
- elements containing a non-negative integer (to which we will refer as N)
indicating a cardinality restriction:
- an
owl:cardinalityelement.
This defines the class of all objects that have exactly N distinct values for the property P, i.e. x is an instance of the defined class if and only if there are N distinct values y such that (x,y) is an instance of P;
- an
owl:maxCardinalityelement.
This defines the class of all objects that have at most N distinct values for the property P;
- an
owl:minCardinalityelement.
This defines the class of all objects that have at least N distinct values for the property P.
An owl:cardinality constraint is simply shorthand for a pair of owl:minCardinality and owl:maxCardinality constraints with equal values of N.
Warning: in order to avoid "exposed content" (i.e., to hide OWL annotations from browsers), it is necessary to write cardinality constraints in an alternative RDF format. See Cardinality Syntax Note for an example of this. - an
The OWL syntax currently allows restrictions that are malformed. Restrictions with missing components (e.g., an owl:Restriction element with no owl:onProperty element) have no semantic impact, even though treating them as RDF would indicate that there should be some semantic impact. Restrictions with extra components (e.g., an owl:Restriction element with multiple different owl:onProperty elements) have unusual and misleading semantic impact (in general equating the extensions of two or more well-formed restrictions). Use of such constructs should be avoided. See issue #5.9-Malformed-DAML+OIL-Restrictions.
Boolean combination of class expressions
A boolean combination of class expressions can be constructed from:
- an
owl:intersectionOfelement, containing a list of class expressions.
This defines the class that consists of exactly all the objects that are common to all class expressions from the list. It is analogous to logical conjunction;
- an
owl:unionOfelement, containing a list of class expressions.
This defines the class that consists exactly of all the objects that belong to at least one of the class expressions from the list. It is analogous to logical disjunction; - an
owl:complementOfelement, containing a single class expression.
This defines the class that consists of exactly all objects that do not belong to the class expression. It is analogous to logical negation, but restricted to objects only.
Note that arbitrarily complex combinations of these expressions can be formed. See Boolean Note for an example of this.
Property elements
An rdf:Property element refers to a property name (a URI)
(to which
we will refer as P).
Properties that are used in property restrictions should be either
object properties, which relate objects to other objects, and are instances of
owl:ObjectProperty;
or
datatype properties, which relate objects to datatype
values, and are instances of
owl:DatatypeProperty.
A property element contains:
- zero or more
rdfs:subPropertyOfelements, each containing a property name.
Each subPropertyOf element states that P is a subproperty of the property named in the element. This means that every pair (x,y) that is an instance of P is also an instance of the named property;
- zero or more
rdfs:domainelements (each containing a class expression).
Each domain element asserts that the property P only applies to instances of the class expression of the element. More formally: if a pair (x,y) is an instance of P, then x is an instance of the class expression. This implies that multiple domain expressions restrict the domain of P to the intersection of the class expressions.
Note that unlike any of the property restrictions mentioned above, these domain restrictions are global. The property restrictions above are part of a class element, and are only enforced on the property when applied to that class. In contrast, domain restrictions apply to the property irrespective of the Class to which it is applied. This is by virtue of their semantics in RDF Schema;
Because of this, domain elements should be used with great care in OWL. - zero or more
rdfs:rangeelements (each containing a class expression).
Each range element asserts that the property P only assumes values that are instances of the class expression of the element. More formally: a pair (x,y) can only be an instance of P if y is an instance of the class expression.
Multiple range restrictions are interpreted as saying that the range of P must be the intersection of all the class expressions. Furthermore, as with domain restrictions, range restrictions are global, by virtue of RDF Schema;
Because of this, range elements should be used with great care in OWL. - zero or more
owl:samePropertyAselements (each containing a property name).
Each samePropertyAs element asserts that P is equivalent to the named property (i.e. they must have the same instances),
- zero or more
owl:sameAselements (each containing a property name).
When applied to a property, theowl:sameAselement has the same semantics as the owl:samePropertyAs element;
Warning: the use of owl:samePropertyAs is favoured over the use of owl:sameAs, since owl:samePropertyAs is declared as a subproperty of rdfs:subPropertyOf, while owl:sameAs is not. This makes the meaning of owl:samePropertyAs at least partly available to an RDF Schema-only agent, while the meaning of owl:sameAs is completely opaque to such an agent. owl:sameAs is typically used when it is not known that the name denotes a property.
and
- zero or more
owl:inverseOfelements (each containing a property name), for properties only.
Each inverseOf element asserts that P is the inverse relation of the named property. More formally: if the pair (x,y) is an instance of P, than the pair (y,x) is an instance of the named property.
Instead of an object property or datatype property element, it is also possible to use any of the following elements, each of which assert additional information about the property:
- an
owl:TransitivePropertyelement, which is a subclass of owl:ObjectProperty.
This asserts that P is transitive, i.e. if the pair (x,y) is an instance of P, and the pair (y,z) is an instance of P, then the pair (x,z) is also an instance of P;
- an
owl:SymmetricPropertyelement, which is a subclass of owl:ObjectProperty.
This asserts that P is symmetric, i.e. if the pair (x,y) is an instance of P, then the pair (y,x) is also an instance of P;
- an
owl:FunctionalPropertyelement.
This asserts that P can only have one (unique) value y for each instance x, i.e. there cannot be two distinct instances y1 and y2 such that the pairs (x,y1) and (x,y2) are both instances of P. Of course, this is a shorthand notation for the owl:maxCardinality restriction of 1.
or - an
owl:InverseFunctionalPropertyelement.
This asserts that an instance y can only be the value of P for a single instance x, i.e. there cannot be two distinct instances x1 and x2 such that both (x1,y) and (x2,y) are both instances of P. In OWL DL, an owl:InverseFunctionalProperty must also explicitly be an owl:ObjectProperty. In OWL Full, an owl:InverseFunctionalProperty may be either an owl:ObjectProperty or an owl:DatatypeProperty.
Notice that
owl:FunctionalProperty
and
owl:InverseFunctionalProperty
specify global cardinality restrictions. That is, no matter what class the
property is applied to, the cardinality constraints must hold, unlike the
various cardinality properties used in property
restrictions, which are part of a
class element, and are only enforced on the property when applied to that
class.
A property is a binary relation that may or may not be defined in the
ontology. If it is not defined, then it is assumed to be a binary relation
with no globally applicable constraints, i.e. any pair with first element
an object and second element an object or datatype value
could be an instance of the property.
Warning: If an
owl:TransitiveProperty
(or any of its
superproperties) is used in a cardinality constraint, then class consistency
is no longer necessarily decidable. Of course,
owl:FunctionalProperty
is a particular case of a
cardinality constraint.
Instances
Instances of both classes
(i.e., objects) and of properties (i.e., pairs) are written in
RDF/XML syntax.
See the
RDF/XML Syntax Specification(Revised)
for more details on the various
syntactic forms that are allowed. Here we list just some of the most common
notations:
<Continent rdf:ID="Africa"/>
<rdf:Description rdf:ID="Asia">
<rdf:type>
<rdfs:Class rdf:about="#Continent"/>
</rdf:type>
</rdf:Description>
<rdf:Description rdf:ID="India">
<isPartOf rdf:resource="#Asia"/>
</rdf:Description>
There is no unique name assumption for objects in OWL.
To state that objects are the same, an
owl:sameIndividualAs element
is used.
(Note that owl:sameAs can be also used here, but
owl:sameIndividualAs is preferred.)
To state that objects are distinct,
an owl:differentFrom
element is used.
See issue #I5.18-Unique-Names-Assumption-Support-in-OWL.
The situation is different for datatype values, where XML Schema Datatype
identity is used.
Datatype values
Datatype values are written in a manner that is valid RDF syntax, but which is given a special semantics in OWL. The preferred method is to give a lexical representation of the value as a string, along with an XML Schema datatype that is used to provide the type of the value as well as the parsing mechanism to go from the string to the value itself. The XML Schema datatype is the rdf:type of the value, and the lexical representation is the rdf:value of the value. So the decimal 10.5 could be input as <xsd:decimal rdf:value="10.5"/> provided that xsd was defined as the URI of the XML Schema Datatype specification.
As a nod to backward compatability, literals that occur outside this sort of construction are interpreted as any of the XML Schema Datatype values with this lexical representation. These values are mostly unusable unless some typing information is available, such as a range for a property.
The question of whether any XML Schema datatype can be used in such constructions, or whether only certain XML Schema dataypes can be so used (such as only the predefined datatypes), remains open. See issue #4.3-Structured-Datatypes. See issue #5.7-Range-restrictions-should-not-be-separate-URIs.
Appendix A. Index of all language elements
- owl:allValuesFrom
- owl:cardinality
- owl:Class
- owl:complementOf
- owl:Datatype
- owl:DatatypeProperty
- owl:DatatypeRestriction
- Datatype value
- owl:differentFrom
- owl:disjointWith
- rdfs:domain
- owl:sameAs
- owl:FunctionalProperty
- owl:hasValue
- owl:imports
- owl:intersectionOf
- owl:InverseFunctionalProperty
- owl:inverseOf
- owl:maxCardinality
- owl:minCardinality
- owl:ObjectClass
- owl:ObjectProperty
- owl:ObjectRestriction
- owl:oneOf
- owl:onProperty
- owl:Ontology
- rdf:Property
- rdfs:range
- owl:Restriction
- owl:sameClassAs
- owl:sameIndividualAs
- owl:samePropertyAs
- owl:someValuesFrom
- rdfs:subClassOf
- rdfs:subPropertyOf
- owl:SymmetricProperty
- owl:TransitiveProperty
- owl:unionOf
- owl:versionInfo
Appendix B. Notes
- Syntax Note:
- As a simple example of an alternative syntactic
form resulting in the same set of RDF triples, consider the statement in
this document that "an OWL class definition consists at least of an
rdfs:class element", which suggests the following syntactic form:
<rdfs:Class rdf:ID="Continent"/>
However, the following RDF statement:
<rdf:Description rdf:ID="Continent"> <rdf:type resource="https://www.w3.org/2000/01/rdf-schema#Class"/> </rdf:Description>
results in exactly the same set of RDF triples, and is therefore perfectly allowed as a class definition.Another example is the two notations that we discuss for cardinality constraints below. Again, both these forms result in the same set of RDF triples, and are thus equivalent.
- Mixing Note:
- For example, given
<owl:Class rdf:ID="Person"/>
and then adding<rdf:Description rdf:about="#Person"> <dc:Creator>Ora Lassila</dc:Creator> </rdf:Description>
the semantics don't say what this means or what it would imply for instances of Person. (Beyond of course the minimal Subject-Verb-Object semantics of RDF). See issue #I5.19-Classes-as-instances.
- Cardinality Syntax Note:
- As an example of content-hiding syntax for
cardinality expressions, instead of the standard notation:
<owl:Restriction> <owl:onProperty rdf:resource="#father"/> <owl:cardinality>1</cardinality> </owl:Restriction>
we would have to write
<owl:Restriction owl:cardinality="carview.php?tsp=1"> <owl:onProperty rdf:resource="#father"/> </owl:Restriction>
to avoid any exposed content. The cardinality elements are the only ones for which this alternative notation is required to avoid exposed content. (See [Ed: identify link] the section on abbreviated syntax in the RDF specification for more details on this notation).
- Boolean Note:
- As an example of a combination of boolean
operators, the expression "neither meat nor fish" could be written
as:
<owl:complementOf> <owl:Class> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:resource="#Meat"/> <owl:Class rdf:resource="#Fish"/> </owl:unionOf> </owl:Class> </owl:complementOf>
Appendix C. https://www.w3.org/2002/07/owl
See https://www.w3.org/2002/07/owl.Appendix D. Changes from DAML+OIL
This section summarizes the changes from DAML+OIL [DAML+OIL] to OWL.
- The namespace was changed to https://www.w3.org/2002/07/owl.
- Various updates to RDF and RDF Schema from the
RDF Core Working Group were incorporated,
including
- cyclic subclasses are now allowed
- multiple rdfs:domain and rdfs:range properties are handled as intersection
- rdf:parseType="Collection" replaces rdf:parseType="daml:collection"
- RDF Model Theory
- datatypes?
- Qualified restrictions were removed from the language,
resulting in the removal of the following properties:
- daml:cardinalityQ
- daml:hasClassQ
- daml:maxCardinalityQ
- daml:minCardinalityQ
- Various properties and classes were renamed,
as shown in the following table:
DAML+OIL OWL daml:differentIndividualFrom owl:differentFrom daml:hasClass owl:someValuesFrom daml:toClass owl:allValuesFrom daml:UnambiguousProperty owl:InverseFunctionalProperty daml:UniqueProperty owl:FunctionalProperty - owl:SymmetricProperty was added.
- An owl:DatatypeProperty may be an owl:InverseFunctionalProperty in OWL Full.
-
Synonyms for RDF and RDF Schema classes and properties were removed from the language,
resulting in the removal of:
- daml:comment
- daml:domain owl:domain may still be required as non-synonym
- daml:label
- daml:isDefinedBy
- daml:Literal
- daml:Property
- daml:range owl:range may still be required as non-synonym
- daml:seeAlso
- daml:subClassOf
- daml:subPropertyOf
- daml:type
- daml:value
- daml:disjointUnionOf was removed from the language, since it can be effected using owl:unionOf or rdfs:subClassOf and owl:disjointWith.
- daml:equivalentTo was renamed to owl:sameAs, and is no longer a superproperty of owl:sameClassAs, owl:samePropertyAs, and owl:sameIndividualAs
References
- [DAML+OIL]
- DAML+OIL (March 2001) Reference Description. Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Note 18 December 2001. Latest version is available at https://www.w3.org/TR/daml+oil-reference.
- [OWL Abstract Syntax]
- Web Ontology Language (OWL) Abstract Syntax and Semantics. Peter F. Patel-Schneider, Ian Horrocks, and Frank van Harmelen. W3C Working Draft 29 July 2002. Latest version is available at https://www.w3.org/TR/owl-absyn/.
- [OWL Features]
- Web Ontology Language (OWL Lite and OWL) Feature Synopsis Version 1.0. Deborah L. McGuinness and Frank van Harmelen. W3C Working Draft 29 Jul 2002. Latest version is available at https://www.w3.org/TR/owl-features/.
- [OWL Guide]
- Web Ontology Language (OWL) Guide Version 1.0. Michael K. Smith, Raphael Volz, and Deborah McGuinness. W3C Working Draft 4 November 2002. Latest version is available at https://www.w3.org/TR/owl-guide/.
- [OWL Issues]
- Web Ontology Issue Status. Michael K. Smith, ed. 30 Oct 2002. Latest version is available at https://www.w3.org/2001/sw/WebOnt/webont-issues.
- [OWL Test Cases]
- Web Ontology Language (OWL) Test Cases. Jeremy J. Carroll and Jos De Roo. W3C Working Draft 24 October 2002. Latest version is available at https://www.w3.org/TR/owl-test/.
- [RDF Schema]
- RDF Vocabulary Description Language 1.0: RDF Schema. Dan Brickley and R.V. Guha, eds. W3C Working Draft 30 April 2002. Latest version is available at https://www.w3.org/TR/rdf-schema/.
- [RDF/XML Syntax]
- RDF/XML Syntax Specification (Revised). Dave Beckett, ed. W3C Working Draft 25 March 2002. Latest version is available at https://www.w3.org/TR/rdf-syntax-grammar/.