W3C home > Mailing lists > Public > www-rdf-interest@w3.org > December 2001

Re: RDF speficiations (was RE: Cutting the Patrician datatype knot)

From: Jonathan Borden <jborden@mediaone.net>
Date: Mon, 3 Dec 2001 10:58:11 -0500
Message-ID: <009b01c17c13$52c06d50$0a2e249b@nemc.org>
To: <Patrick.Stickler@nokia.com>, "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: <www-rdf-interest@w3.org>
Peter F. Patel-Schneider wrote:

> I think that we are in the midst of a disagreement over what (an
> implementation of) RDF is.
> My view is that an implementation of RDF, or RDF Schema or RDF plus
> datatypes, is supposed to implement the specification of RDF, or RDF
> or RDF plus datatypes.  The implementation is free to do this in any
> effective way that it chooses, but it is not free to deviate from the
> specification either by removal or by addition.

Well that depends on what you mean by "addition"

> Now along comes datatypes, and the whole point of this note.

I think we all understand the issue, but we need to realize that RDF as it
currently stands is effectively silent on the issue of datatypes. The only
core "types" appear to be "resource" (whatever that really is) and
"literal". One can compare literals by string comparison operators but there
is _nothing_ which describes an _RDF_ mechanism to compare literal values
using other/overloaded comparison operators, nor what such operators would
be useful for. Of note, realize that the XML Namespaces recommendation
states that _XML Namespace names_ (which are URI references according to RFC
2396) must be compared as _literal strings_, so that even reasonable URI
comparison operators (such as those that expand relative URI references into
absolute URIs before string comparison) may not be used to equate XML
Namespace names. For example:

http://www.w3.org/foo and

name _different_ XML Namespaces.

given this draconian (yet well specified) definition what makes anyone think
that "10" and "010" would be equated under RDF itself?

> The datatype model theory is going to end up saying quite a lot about
> datatypes.  It will provide a meaning for the datatype constructions,
> including which datatype constructions make sense and which don't.  This
> will mean that entailment has to take into account the meaning of such
> constructions.
> For example, the datatype model theory is going to have to answer under
> what conditions
> <John> <age> "10".
> entails
> <John> <age> "010".
> Any RDF implementation that does not produce the answers demanded by the
> model theory will not be in compliance with the model theory's
> specification of RDF.  (Note that an RDF implementation is free to use any
> means to implement this entailment, such as passing all its input through
> an XML Schema validator that produces native, canonical representations
> typed literals.)

He he. But suppose I create my own datatypes using XML Schema, including
myxsd:integer which derives entirely from the lexical space (i.e. is defined
by which characters are allowed in each position in the string). Now I
submit that there is a clear and unambiguous 1:1 mapping from

myxsd:integer <=> xsd:integer

that is that the instance sets of tokens that form each type are identical.
XML Schema provides no way to define this (I choose in this case _not_ to
derive myxsd:integer from the builtin, i.e. value space derived,

In such cases an XML Schema validator will correctly validate the _XML_
input, but derive a unique post-Schema validation Infoset (psvi) according
to which schema was used to validate. Are you are suggesting that ? the
datatype model theory operate on the "psvi" graph rather than the input XML
character stream?

> For example, for XML Schema, the interface could pass a pair like
> <integer,10> or even <integer,"10"> instead of <decimal with 0
> fractionDigits union string,"010">.  This would be much easier for
> applications to handle than requiring them to understand all of XML Schema
> constructed datatypes.

This is exactly the problem. It turns out that for XML Schema, whose
formalism operates on lexical tokens, passing the pair <integer, 10> is not
the same as <"decimal with 0 fractionDigits union string, "010">. Of course
you may wish to limit your model theory to operate on the specific set of
builtin XML Schema datatypes, but I suspect that you will eventually find
that limiting, i.e. I would _like to_ be able to state:

<xsd:integer, 10> == <myxsd:integer, "010">

which might require something like daml:EquivalentTo unless the XML Schema
formalism is changed to base _all_ the builtin datatypes on the lexical
rather than the value space.

Received on Monday, 3 December 2001 10:58:48 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:07:38 UTC