W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > February 2002

Re: around the table on datatypes [ was: Re: datatyping draft 3 (for telecon)]

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Tue, 19 Feb 2002 08:24:13 +0200
To: Pat Hayes <phayes@ai.uwf.edu>, Dan Connolly <connolly@w3.org>
CC: RDF Core <w3c-rdfcore-wg@w3.org>
Message-ID: <B897BC2D.EE9A%patrick.stickler@nokia.com>
On 2002-02-19 1:34, "ext Pat Hayes" <phayes@ai.uwf.edu> wrote:

> OK, let me try to fix this.
> ...
> (What we really want to be able to say is that the range of
> otherProperty is a subset of the range of ex:integer, ...

I'm not sure I follow. What we want to say, in Dan's case, is that
the range of some property is the lexical space of ex:integer
(which, from a particular point of view, is of course some kind
of subset of the "totality" that is ex:integer, leaving out the
value space and mapping.

Is that what you meant by "subset of the range of ex:integer"?

> Still, we do need something. So how about using drange to do it. In
> other words, lets make the following extra specification on drange:
> when ddd is a datatype property,
> ddd rdfs:drange aaa .
> means that (the class extension of) aaa is *precisely* the range of
> ddd, ie precisely the lexical space of the datatype,

But the above rdfs:drange statement implies that

  aaa rdf:type rdfs:Datatype .

and a datatype is *not* a lexical space, it is both a lexical
space and value space.

And now your back to multiple URIs for datatypes, which we spent
ages getting past. 

We don't need (and should avoid) any explicit statements about
the range of a datatype property. It should be understood (and
mandated) from the MT or other specese that the implicit range
of a datatype property is the lexical space of the property
and the implicit domain of a datatype property is the value space
of the property. If someone wants to mint their own URI that
is meant to denote the lexical space of a datatype, and then say

   ddd rdfs:range aaa .  (note rdfs:range, *not* rdfs:drange)

then fine, but they are likely going to be the only ones that
recognize that lexical space URI -- and it's needless anyway
since that semantics is provided "for free".

I think the real issue here was being able to use inline idioms
and assert that those literals were members of the lexical space
of a datatype, which seems to require one more (final) range
property. C.f.


This works in conjunction with the interpretation of rdfs:drange as
being the union of the lexical space and value space -- and using
rdfs:lrange to constrain a property to members of the value space.
It's clean, generic, explicit, and says exactly what we mean to say.



> We already have 
> a name for the precise value space of the datatype,


If you're talking about URIs, we only have a single name for
the totality that is a datatype -- value space + lexical space + mapping
(+ optional canonical lexical space). We have no name for the precise
value space of any datatype.

Or do you mean, via rdfs:range we already have a way to precisely
constrain a property to the value space of a datatype? (which I agree)

> This means drange exerts an extra kind of semantic magic, but only
> when applied to a datatype property.

Right. And since it's magic ;-) the explicit statement defining the
range of a datatyping property to its lexical space is not needed.

> Happy with that? 

Yes, if it is combined with the union interpretation of rdfs:drange
and the datatype property range statements are left implicit without
requiring actual URIs to denote the lexical spaces.
> Pat
> PS  Patrick S, I think you maybe already suggested this??? I didn't
> grok it at the time.

There were two things I suggested recently to try to work out
the mysteries of ranges, both of which are touched upon above,
but which I'll recap here just to be clear (if I can ;-)

a) that for any datatype property, it is understood (though does
   not require any explicit statements) that the range of a datatype
   property is the lexical space of the datatype and the domain of
   a datatype property is the value space of the datatype -- which
   I think is intuitively what datatype properties are all about,
   and I expect that this is evident in numerous earlier sources,
   such as Sergey's S proposal materials and lots of postings, etc.

b) that the interpretation of rdfs:range is to constrain only to
   the value space of a datatype, that the interpretation of rdfs:drange
   is to constrain to the union of the value space and the lexical space
   of a datatype, and that the interpretation of rdfs:lrange is to
   constrain to the lexical space of a datatype; where both rdfs:drange
   and rdfs:lrange automatically imply that their object is a datatype.

Both of these, I think, are needed to clarify the behavior and meaning
of range constraints when used with datatype classes.



Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: patrick.stickler@nokia.com
Received on Tuesday, 19 February 2002 01:22:44 EST

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:45:16 EDT