W3C home > Mailing lists > Public > public-webont-comments@w3.org > May 2003

RDFCore Comments on OWL Reference

From: Brian McBride <bwm@hplb.hpl.hp.com>
Date: Fri, 02 May 2003 17:48:11 +0100
Message-Id: <>
To: public-webont-comments@w3.org

The RDFCore WG has reviewed the Owl Reference last call WD at


RDFCore congratulates the WEBONT WG and particularly the authors and 
editors of the reference document for its quality and clarity.

For the convenience of WEBONT we have given an ID to each 
comment.  Comments not specific to RDFCore's interests will be sent 
separately by the reviewer.



We particularly admire the clarity of this note in 8.1 and request that a 
similarly worded sentence be added to 1.2 para 2 and that the note in 1.4 
be phrased in the same or similar manner.

NOTE: RDF documents will generally be in OWL Full, unless they are 
specifically constructed to be in OWL DL or Lite.



It has been suggested to RDFCore that owl:Class is not needed.  RDFCore 
requests the creation of test cases to clearly illustrate the differences 
between owl:Class and rdfs:Class.



3.1 Class descriptions

A class description is the term used in this document (and in the OWL 
Semantics and Abstract Syntax) for the basic building blocks of class 
axioms (informally called class definitions in the Overview and Guide 
documents). OWL distinguishes six types of class descriptions:

    1. a class identifier (a URI reference)
    2. an exhaustive enumeration of individuals that together form the 
instances of a class
    3. a property restriction
    4. the intersection of two or more class descriptions
    5. the union of two or more class descriptions
    6. the complement of a class description

Its not clear from the text what a class description is.  We take it to be 
an RDF Graph (a set of triples) describing a class.  The above seems to say:

   a class identifier (a URI reference) is a type of RDF graph

which doesn't make sense.  Similarly, the meaning of

   the compliment of an RDF graph

isn't clear.

Whilst this is just wordsmithing, the concept of a class description is of 
prime importance to the rest of the spec and should be clear.


NOTE: If one provides an RDF identifier for class descriptions of the type 
2-6, this has the extra effect of providing a way of referring to the class 
description by its name, i.e., as a class description of type 1. See 
Section 3.2.3 for details.

Does this name identify the class description, or the class described by 
the description?  We suspect the latter, in which case:

NOTE: If one provides an RDF identifier for class descriptions of the type 
2-6, this has the extra effect of providing a way of referring to the class 
so described by its name. See Section 3.2.3 for details.

There are other instances of this confusion: e.g. in 3.1.2

A value constraint puts constraints on the value range of the property when 
applied to this particular class description.

The constraint is on the property when applied to an instance of the class 
described by this particular class description.

In 3.2

* rdfs:subClassOf allows one to say that the class extension of a class 
description is a subset of the class extension of another class description.

and 3.2.1

A class description is by definition a subclass of itself.

which seems to confuse the notion of class and class description.



"Human rdf:type owl:Class .".

In the interests of inter-spec consistency we request that WEBONT docs use 
the same abbreviated form of n-triples as the RDF docs, which would make 
the above

"base:Human rdf:type owl:class ."
with some appropriate explanation of what base is.


#owlref-rdfcore-domain-range-value terminology

Throught the documents various terms, such as "value range", "range value", 
"range", "domain", "domain value" are use to talk about the values of 
properties.  Several of these terms are undefined, they often are used 
inconsistently and there seems to be unnecessary duplication in the use of 
the terms.

The term "value range" is used in the document and is not defined.  We 
suggest the meaning of this term be clearly defined if it is to be 
used.  However, it seems to mean the same thing as the term 'range' defined 
in RDFS, so the definition of a new term may be redundant.

Confusingly, the term "range value" is also used in the document and is not 
defined.  We suggest the meaning of this term be clearly defined if it is 
to be used.  However, it seems to mean the same thing as the term 'value' 
as used in RDFS, so the definition of a new term may be redundant.

We also note that it is used inconsistently.

In 3.1.2

Property restrictions can be applied both to datatype properties 
(properties for which the range value is a data literal) and object 
properties (properties for which the range value is an individual).

it appears to be used to refer to thing denoted by the object of a triple.

In it is used to state a syntactic constraint on OWL Lite documents.

NOTE: In OWL Lite the range value of owl:allValuesFrom must be a class 

Here it refers to the object of the triple, not the thing the object denotes.

And further that the term 'value' seems to suffice elsewhere, e.g.

To see why this is so, observe that the owl:allValuesFrom constraint 
demands that all values of P belong to class P, and if no such values 
exist, the constraint is trivially true.


Syntactically, owl:equivalentProperty is a property with as both domain and 
range an instance of rdf:Property.

The domain of a property is a class, as is the range.  And domain and range 
aren't about syntax (occurs elsewhere also).  Suggest:

owl:equivalentProperty is a property.  Its rdfs:domain is rdf:Property, as 
is its rdfs:range.

or less formally

owl:equivalentProperty is a property is a property that relates two properties.

In owl:backwardCompatibleWith

The owl:backwardCompatibleWith construct is a property with an instance of 
the class owl:Ontology as its domain and range.

This is further confusion over the use of the terms domain and 
range.  Domains and Ranges of properties are classes, not instances.  Nor 
is the construct a property!

owl:backwardCompatibleWith is a property.  Its domain is owl:Ontology as is 
its range.

We request:

   o A global check throughout the document of all uses of all terms 
involving the words 'domain' and  'range'

   o that wherever possible the terminology used in the RDFCore specs be 

   o where RDFCore does not provide appropriate terminology, that any new 
terms be defined and used consistently

   o RDFCore would be willing to help discuss appropriate terminology




The cardinality constraint owl:maxCardinality is a built-in OWL property 
that links a restriction class to a data value belonging to the range of 
the XML Schema datatype nonNegativeInteger.

We believe the correct term is "the value space of the XML Schema datatype 

Similarly in minCardinality.



5.2 Individual Identity

This section should include some words about URIREF comparison, probably 
with a reference to rdf concepts where we say how URIREFS are compared.



6.1 Datatypes

A typed literal needs to have an XML attribute rdf:datatype ...

Its not the literal that has an XML attribute - that is the way it is 
written in rdf/xml.


In RDF/XML, the type of a literal is specified by an "rdf:datatype" attribute.


When using datatypes, please note that even if the range of a property is 
declared to be of a certain datatype, RDF still requires a rdf:datatype 
attribute in a statement about this property, otherwise it is treated as a 
plain literal.


When using datatypes, please note that even if a property is defined to 
have a range of a certain datatype, RDF/XML still requires that the 
datatype be specified each time the property is used.



A typed literal needs to have an XML attribute rdf:datatype of which the 
value is recommended to be one of the following:

# The RDF datatype rdfs:Literal  which is the class of literals, typed and 

rdfs:Literal is not a datatype.



In 6.2 we see:

            <rdf:first rdf:datatype="xsd:integer">0</rdf:first>

A qname is not allowed as the value of an rdf:datatype property.  This 
should be:

            <rdf:first rdf:datatype="&xsd;integer">0</rdf:first>



6.2 Enumerated datatype

We suggest the following form for writing the syntax of lists with literal 
values, which we believe is more slightly more readable and better suited 
to longer lists.

<owl:DatatypeProperty rdf:ID="tennisGameScore">

           <rdf:first rdf:datatype="&xsd;integer">0</rdf:first>
           <rdf:rest rdf:nodeID="l2"/>

         <rdf:List rdf:nodeID="l2">
           <rdf:first rdf:datatype="&xsd;integer">15</rdf:first>
           <rdf:rest rdf:nodeID="l3"/>

         <rdf:List rdf:nodeID="l3">
           <rdf:first rdf:datatype="&xsd;integer">30</rdf:first>
           <rdf:rest rdf:nodeID="l4"/>

         <rdf:List rdf:nodeID="l4">
           <rdf:first rdf:datatype="&xsd;integer">30</rdf:first>
           <rdf:rest rdf:resource="&rdf;nil"/>




7.1 Annotations

     * Annotation properties must not be used in property axioms (e.g., no 
subproperties are allowed).

We believe there may be an editorial error here, and that this restriction 
is not intended to apply to OWL Full.

As stated, since rdfs:domain and rdfs:range are property axioms, this means 
that we can't define a domain and range for an annotation property in 
Owl.  Further rdfs defines rdfs:isDefinedBy to be a subproperty of 
rdfs:seeAlso.  That would mean that not all RDF graphs are legal OWL Full, 
and that in fact the graph for RDF Schema is not legal OWL Full.



RDFCore makes this point with some trepidation, not wishing to cause WEBONT 
to waste time and energy on a discussion with little practical impact.

In 7.2

An ontology header component is represented with an instance of the class 
owl:Ontology, which typically identifies the containing document with a 
same-document reference [section 4.2 of RFC2396], and which may optionally 
contain, in any order, any number of import and/or versioning statements.

This seems to say that instances of the class owl:Ontology are 
documents.  RDFCore suggests that the text be modified to be less 
specific.  There are also potential difficulties with the reference to RFC 
2396; it would be better to refer to the RDF specs and let them take the 
heat on any 'interpretation' of RFC 2396.

We suggest:

A document describing an ontology typically contains information about the 
ontology itself.  An ontology is a resource, so may be described using 
properties from the OWL and other namespaces, e.g.

<owl:Ontology rdf:about="">
   <owl:versionInfo> ... </owl:versionInfo>
   <owl:imports rdf:resource='...'/>

This is commonly called the ontology header and is typically found near the 
beginning of the RDF/XML document.  The line

   <owl:Ontology rdf:about="">

states that this block describes the current ontology.  More precisely, it 
states the current base URI identifies an instance of the class 
owl:Ontology.  As noted earlier, it is recommended that the base URI be 
defined using an xml:base attribute in the <rdf:RDF> element at the 
beginning of the document.


In 8.1

Although from the semantics point of view it is not forbidden in OWL Full 
to declare datatype properties to be inverse, transitive, or symmetric, in 
practice this does not make much sense. (RDF does not allow data values as 
the subject of a statement).


eg:lessThan rdf:type   owl:TransitiveProperty .
eg:lessThan rdf:type   owl:DatatypeProperty .
eg:size     rdf:type   owl:DatatypeProperty .
eg:size     rdfs:range xsd:decimal .

_:a eg:size _:sa .
_:b eg:size _:sb .
_:c eg:size _:sc .

_:sa eg:lessThan _:sb .
_:sb eg:lessThan _:sc .


_:sa eg:lessThan _:sc .

This is potentially useful and does make sense.

Received on Friday, 2 May 2003 12:47:27 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 19:06:33 UTC