OWL Reference for F2F 4 from Mike Dean on 2002-09-27 (www-webont-wg@w3.org from September 2002)

From: Mike Dean <mdean@bbn.com>
Date: Fri, 27 Sep 2002 09:02:15 -0700
To: www-webont-wg@w3.org
Message-ID: <3D948107.6070706@bbn.com>

Attached is the current version of the OWL Reference for
discussion at F2F 4.  It includes the following substantive
changes from the last published Working Draft [1]:

   added Appendix D:  Changes from DAML+OIL

   added a reference to [OWL Guide]

   removed references to issues 3.4, 4.2, and 4.5 which were
   closed

   various small wording and typographical changes to address
   comments, as indicated in the attached owl-ref-comments-ftf4.html

Also, attached is an updated version of owl.owl, which
includes the dc:creator fix to [2] indicated in
owl-ref-comments-ftf4.html.

	Mike

[1] http://www.w3.org/TR/2002/WD-owl-ref-20020729/

[2] http://www.w3.org/2002/07/owl

<!-- $Revision: 1.11 $ of $Date: 2002/09/19 04:37:22 $. -->

<rdf:RDF
  xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xmlns:dc  ="http://purl.org/dc/elements/1.0/"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xmlns     ="http://www.w3.org/2002/07/owl#"
  xml:base  ="http://www.w3.org/2002/07/owl"
>

<Ontology rdf:about="">
  <versionInfo>$Id: owl.owl,v 1.11 2002/09/19 04:37:22 mdean Exp $</versionInfo>
  <imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
  <dc:title>OWL Web Ontology Language</dc:title>
  <dc:creator>W3C Web Ontology (WebOnt) Working Group</dc:creator>
  <dc:subject>OWL; Web Ontology Language; Semantic Web</dc:subject>
  <dc:description>Classes and Properties comprising the OWL Web Ontology Language</dc:description>
  <dc:publisher>W3C</dc:publisher>
  <dc:date>2002-07-17</dc:date>
  <dc:format>text/xml</dc:format>
  <dc:language>en</dc:language>
  <dc:identifier>http://www.w3.org/2002/07/owl</dc:identifier>
</Ontology>

<!-- (meta) classes of "object" and datatype classes  -->

<rdfs:Class rdf:ID="Class">
  <rdfs:label>Class</rdfs:label>
  <rdfs:comment>
    The class of all "object" classes
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdfs:Class>

<rdfs:Class rdf:ID="Datatype">
  <rdfs:label>Datatype</rdfs:label>
  <rdfs:comment>
    The class of all datatype classes
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdfs:Class>

<!-- Pre-defined top/bottom thing/nothing most/least-general (object) classes. -->

<Class rdf:ID="Thing">
  <rdfs:label>Thing</rdfs:label>
  <rdfs:comment>
    The most general (object) class in OWL.
    This is equal to the union of any class and its complement.
  </rdfs:comment>
  <unionOf rdf:parseType="Collection">
    <rdfs:Class rdf:about="#Nothing"/>
    <rdfs:Class>
      <complementOf rdf:resource="#Nothing"/>
    </rdfs:Class>
  </unionOf>
</Class>

<Class rdf:ID="Nothing">
  <rdfs:label>Nothing</rdfs:label>
  <rdfs:comment>the class with no things in it.</rdfs:comment>
  <complementOf rdf:resource="#Thing"/>
</Class>

<!-- Terms for building classes from other classes. -->

<Property rdf:ID="equivalentTo"> <!-- equals? equiv? renames? -->
  <rdfs:label>equivalentTo</rdfs:label>
  <comment>
    for equivalentTo(X, Y), read X is an equivalent term to Y.
  </comment>
</Property>

<Property rdf:ID="sameClassAs">
  <rdfs:label>sameClassAs</rdfs:label>
  <comment>
    for sameClassAs(X, Y), read X is an equivalent class to Y.
  </comment>
  <rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
  <rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</Property>

<Property rdf:ID="samePropertyAs">
  <rdfs:label>samePropertyAs</rdfs:label>
  <rdfs:comment>
    for samePropertyAs(P, R), read P is an equivalent property to R.
  </rdfs:comment>
  <rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
  <rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/>
</Property>

<Property rdf:ID="sameIndividualAs">
  <rdfs:label>sameIndividualAs</rdfs:label>
  <rdfs:comment>
    for sameIndividualAs(a, b), read a is the same individual as b.
  </rdfs:comment>
  <rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
  <rdfs:domain rdf:resource="#Thing"/>
  <rdfs:range rdf:resource="#Thing"/>
</Property>

<rdf:Property rdf:ID="disjointWith">
  <rdfs:label>disjointWith</rdfs:label>
  <rdfs:comment>
    for disjointWith(X, Y) read: X and Y have no members in common.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</rdf:Property>

<Property rdf:ID="differentIndividualFrom">
  <rdfs:label>differentIndividualFrom</rdfs:label>
  <rdfs:comment>
    for differentIndividualFrom(a, b), read a is not the same individual as b.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Thing"/>
  <rdfs:range rdf:resource="#Thing"/>
</Property>

<rdf:Property rdf:ID="unionOf">
  <rdfs:label>unionOf</rdfs:label>
  <rdfs:comment>
    for unionOf(X, Y) read: X is the union of the classes in the list Y;
    i.e. if something is in any of the classes in Y, it's in X, and vice versa.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>
</rdf:Property>

<rdf:Property rdf:ID="disjointUnionOf">
  <rdfs:label>disjointUnionOf</rdfs:label>
  <rdfs:comment>
    for disjointUnionOf(X, Y) read: X is the disjoint union of the classes in
    the list Y: (a) for any c1 and c2 in Y, disjointWith(c1, c2),
    and (b) unionOf(X, Y). i.e. if something is in any of the classes in Y, it's
    in X, and vice versa.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>
</rdf:Property>

<rdf:Property rdf:ID="intersectionOf">
  <rdfs:label>intersectionOf</rdfs:label>
  <rdfs:comment>
    for intersectionOf(X, Y) read: X is the intersection of the classes in the list Y;
    i.e. if something is in all the classes in Y, then it's in X, and vice versa.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>
</rdf:Property>

<rdf:Property rdf:ID="complementOf">
  <rdfs:label>complementOf</rdfs:label>
  <rdfs:comment>
    for complementOf(X, Y) read: X is the complement of Y; if something is in Y,
    then it's not in X, and vice versa.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</rdf:Property>

<!-- Term for building classes by enumerating their elements -->

<rdf:Property rdf:ID="oneOf">
  <rdfs:label>oneOf</rdfs:label>
  <rdfs:comment>
     for oneOf(C, L) read everything in C is one of the
     things in L;
     This lets us define classes by enumerating the members.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#List"/>
</rdf:Property>

<!-- Terms for building classes by restricting their properties. -->

<rdfs:Class rdf:ID="Restriction">
  <rdfs:label>Restriction</rdfs:label>
  <rdfs:comment>
    something is in the class R if it satisfies the attached restrictions, 
    and vice versa.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="#Class"/>
</rdfs:Class>

<rdf:Property rdf:ID="onProperty">
  <rdfs:label>onProperty</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P), read:
    R is a restricted with respect to property P.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
</rdf:Property>

<rdf:Property rdf:ID="allValuesFrom">
  <rdfs:label>allValuesFrom</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and allValuesFrom(R, X), read:
    i is in class R if and only if for all j, P(i, j) implies type(j, X).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdf:Property>

<rdf:Property rdf:ID="hasValue">
  <rdfs:label>hasValue</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and hasValue(R, V), read:
    i is in class R if and only if P(i, V).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
</rdf:Property>

<rdf:Property rdf:ID="someValuesFrom">
  <rdfs:label>someValuesFrom</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and someValuesFrom(R, X), read:
    i is in class R if and only if for some j, P(i, j) and type(j, X).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdf:Property>

<!-- Note that cardinality restrictions on transitive properties, or     -->
<!-- properties with transitive sub-properties, compromise decidability. -->

<rdf:Property rdf:ID="minCardinality">
  <rdfs:label>minCardinality</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and minCardinality(R, n), read:
    i is in class R if and only if there are at least n distinct j with P(i, j).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
</rdf:Property>

<rdf:Property rdf:ID="maxCardinality">
  <rdfs:label>maxCardinality</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and maxCardinality(R, n), read:
    i is in class R if and only if there are at most n distinct j with P(i, j).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
</rdf:Property>

<rdf:Property rdf:ID="cardinality">
  <rdfs:label>cardinality</rdfs:label>
  <rdfs:comment>
    for onProperty(R, P) and cardinality(R, n), read:
    i is in class R if and only if there are exactly n distinct j with P(i, j).
  </rdfs:comment>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
</rdf:Property>

<!-- Classes and Properties for different kinds of Property -->

<rdfs:Class rdf:ID="ObjectProperty">
  <rdfs:label>ObjectProperty</rdfs:label>
  <rdfs:comment>
    if P is an ObjectProperty, and P(x, y), then y is an object.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="DatatypeProperty">
  <rdfs:label>DatatypeProperty</rdfs:label>
  <rdfs:comment>
    if P is a DatatypeProperty, and P(x, y), then y is a data value.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
</rdfs:Class>

<rdf:Property rdf:ID="inverseOf">
  <rdfs:label>inverseOf</rdfs:label>
  <rdfs:comment>
    for inverseOf(R, S) read: R is the inverse of S; i.e.
    if R(x, y) then S(y, x) and vice versa.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#ObjectProperty"/>
  <rdfs:range rdf:resource="#ObjectProperty"/>
</rdf:Property>

<rdfs:Class rdf:ID="TransitiveProperty">
  <rdfs:label>TransitiveProperty</rdfs:label>
  <rdfs:comment>
    if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>

<rdfs:Class rdf:ID="SymmetricProperty">
  <rdfs:label>SymmetricProperty</rdfs:label>
  <rdfs:comment>
    if P is a SymmetricProperty, then if P(x, y) then P(y, x).
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>

<rdfs:Class rdf:ID="FunctionalProperty">
  <rdfs:label>FunctionalProperty</rdfs:label>
  <rdfs:comment>
    compare with maxCardinality=1; e.g. integer successor:
    if P is a FunctionalProperty, then if P(x, y) and P(x, z) then y=z.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="InverseFunctionalProperty">
  <rdfs:label>InverseFunctionalProperty</rdfs:label>
  <rdfs:comment>
    if P is an InverseFunctionalProperty, then if P(x, y) and P(z, y) then x=z.
    aka injective. e.g. if firstBorne(m, Susan)
    and firstBorne(n, Susan) then m and n are the same.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>

<!-- A class for ontologies themselves... -->

<rdfs:Class rdf:ID="Ontology">
  <rdfs:label>Ontology</rdfs:label>
  <rdfs:comment>
    An Ontology is a document that describes
    a vocabulary of terms for communication between
    (human and) automated agents.
  </rdfs:comment>
</rdfs:Class>

<rdf:Property rdf:ID="versionInfo">
  <rdfs:label>versionInfo</rdfs:label>
  <rdfs:comment>
    generally, a string giving information about this
    version; e.g. RCS/CVS keywords
  </rdfs:comment>
</rdf:Property>

<!-- Importing, i.e. assertion by reference -->

<rdf:Property rdf:ID="imports">
  <rdfs:label>imports</rdfs:label>
  <rdfs:comment>
    for imports(X, Y) read: X imports Y;
    i.e. X asserts the* contents of Y by reference;
    i.e. if imports(X, Y) and you believe X and Y says something,
    then you should believe it.
  </rdfs:comment>
</rdf:Property>

<!-- Importing terms from RDF/RDFS -->

<rdf:Property rdf:ID="subPropertyOf">
  <samePropertyAs  rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/>
</rdf:Property>

<rdfs:Class rdf:ID="Literal">
  <sameClassAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/>
</rdfs:Class>

<rdfs:Class rdf:ID="Property">
  <sameClassAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
</rdfs:Class>

<rdf:Property rdf:ID="type">
  <samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#type"/>
</rdf:Property>

<rdf:Property rdf:ID="value">
  <samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/>
</rdf:Property>

<rdf:Property rdf:ID="subClassOf">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/>
</rdf:Property>

<rdf:Property rdf:ID="domain">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#domain"/>
</rdf:Property>

<rdf:Property rdf:ID="range">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#range"/>
</rdf:Property>

<rdf:Property rdf:ID="label">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#label"/>
</rdf:Property>

<rdf:Property rdf:ID="comment">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#comment"/>
</rdf:Property>

<rdf:Property rdf:ID="seeAlso">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#seeAlso"/>
</rdf:Property>

<rdf:Property rdf:ID="isDefinedBy">
  <samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#isDefinedBy"/>
  <rdfs:subPropertyOf rdf:resource="#seeAlso"/>
</rdf:Property>

</rdf:RDF>

Attachments

text/html attachment: owl-ref-proposed.html
text/html attachment: owl-ref-comments-ftf4.html

Received on Friday, 27 September 2002 12:03:11 UTC