W3C home > Mailing lists > Public > www-rdf-comments@w3.org > January to March 2003

Re: Use of datatyping

From: Frank Manola <fmanola@mitre.org>
Date: Tue, 18 Feb 2003 17:45:25 -0500
Message-ID: <3E52B785.9070707@mitre.org>
To: Roland Schwaenzl <roland@mathematik.uni-osnabrueck.de>
CC: www-rdf-comments@w3.org


Thanks for the comment.  I'm not sure exactly what if anything needs to 
be done to clarify this, or whether, if something does need to be done, 
it's the Primer, Concepts, or both that need clarifying (I think 
Semantics is OK).  Let me state what I think the situation is, and 
perhaps you could be more specific as to what you think should be changed.

Technically, all the bits of all the documents you've cited are correct, 
and they are not inconsistent (I think, though, that you've cited some 
of them without also citing relevant surrounding material).  As the 
Primer says, you can write any pair of URIref and literal you want as a 
typed literal *as far as RDF is concerned*.  I think the Primer is clear 
in saying that the definition of datatypes is done *outside* of RDF, and 
all RDF does is refer to them by URI.  So, while you could write an 
arbitrary pair like this in RDF, the validity of this pair would be 
opaque as far as an ordinary RDF processor was conccerned.  Only a 
processor built to recognize specific datatypes would be able to 
determine whether the URIref actually referred to a datatype, and if it 
did, whether the pair was valid according to that datatype.  I don't 
think there's any disagreement in the WG about this.

Now, since RDF per se has no way of knowing whether a given URIref 
refers to a datatype *at all*, it also has no way of knowing whether a 
URIref refers to a datatype "suitable" for use with RDF (that is, one 
that conforms to the abstraction defined in Concepts).  Concepts notes 
that some XML Schema datatypes are not suitable for use within RDF, but 
it doesn't say you can't write RDF typed literals involving them (you 
can).  That is, Concepts is *not* saying that an RDF processor would 
reject a typed literal involving an "unsuitable" data type.  Concepts 
can't say this because, in general, RDF doesn't know ahead of time 
whether a URIref, assuming it refers to a datatype at all, refers to a 
"suitable" one or not.  Concepts is merely pointing out that it's not 
clear, for various reasons, that you would be able to write a processor 
that correctly processed those datatypes if they were used within RDF. 
I could certainly add a sentence or two to the Primer noting that not 
all datatypes, and in particular not all XML Schema datatypes, are 
suitable for use within RDF, and point to the Concepts document for 
information.  Would that clear up part of the problem?  Are there also 
clarifications to Concepts you would suggest?

Also, the Primer didn't "change its mind" in the paragraph before Figure 
10.  How do you see saying (a) that RDF has no way of knowing whether or 
not a URIref in a typed literal identifies a datatype is inconsistent 
with saying (b) that RDF allows you to write any pair of URIref and 
literal you want?  The point is that these typed literals are opaque as 
far as RDF per se is concerned;  they have to be interpreted by a 
datatype processor (which might very well object to certain typed 
literals, either because they involve datatypes that are ill-defined, or 
because the particular literal is inconsistent with the datatype that is 

All this is also consistent with what the Semantics document says (and 
the meaning of a typed literal does *not* depend on the property it is 
used with.)  The first paragraph of Semantics Section 4.3 states some 
key assumptions about the rules that follow, specifically that "the 
rules need to refer to information supplied by the datatypes themselves; 
  and to state the rules it is necessary to assume syntactic conditions 
which can only be checked by consulting the datatypes sources."  As the 
Semantics document notes, the following rules are "for each kind of 
information which is available about a datatype", and that kind of 
information is beyond the scope of RDF.  A rule such as rdfD1 is an 
*example* or form of a rule that would have to effectively be defined by 
the datatype source for each string that is a legal lexical form for the 
specified datatype, and used by (actually, built into) the datatype 
processor designed to deal with that datatype.  Semantics is *not* 
saying that such rules are built into RDF for arbitrary datatypes.

Having said that, can you clarify what changes (in which documents) 
would clarify things?


Roland Schwaenzl wrote:

> Some remarks concerning the RDF primer:
> The RDF primer (second paragraph below Figure 9) has the sentence:
> "As far as RDF is concerned, you can write any pair of URIref and 
> literal you want as a typed literal."
> One could get the impression, that the normative part of RDF concepts on 
> datatypes
> is less liberal with respect to datatyping.
> There is an example given of an XML-schema-part2 datatype, which should 
> not be used.
> The Primer in the paragraph before Figure 10 seems to have changed it's 
> mind:
> "For one thing, RDF has no way of knowing whether or not a URIref in a 
> typed literal actually identifies a datatype."
> This assertion appears to live with some tension to
> RDF semantics rule "rdfD -1"
> Is it that the meaning of say "10"^^xsd:integer depends on the property, 
> the datatype is
> used with ?   
> rs

Frank Manola                   The MITRE Corporation
202 Burlington Road, MS A345   Bedford, MA 01730-1420
mailto:fmanola@mitre.org       voice: 781-271-8147   FAX: 781-271-875
Received on Tuesday, 18 February 2003 17:25:58 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:15:20 UTC