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

Re: rdfs:Datatype question

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Wed, 6 Nov 2002 13:37:33 +0300
To: "ext pat hayes" <phayes@ai.uwf.edu>, Patrick Stickler <patrick.stickler@nokia.com>
Cc: w3c-rdfcore-wg@w3.org
Message-ID: <HcvJVvfyKpJ0.mJ2k3tBj@mail.nokia.com>

_____________Original message ____________
Subject:	Re: rdfs:Datatype question
Sender:	ext pat hayes <phayes@ai.uwf.edu>
Date:		Wed,  6 Nov 2002 09:15:09 +0300

>IMO, we need rdfs:Datatype to define the set of classes which
>have the required characteristics for RDF datatyping, namely
>a lexical space, a value space, and an N:1 mapping from the
>lexical value space where N > 0.
>The term rdfs:Datatype is a means to give a name to the set
>of RDF Classes which exhibit those characteristics.

OK, I grok that, but I can't cash it out in anything in the MT; and 
also, I can't see what extra it adds to the use of the URI inside a 
typed literal. Doesnt that make exactly the same  assumptions? If I 
had a rule that took every uriref inside a typed literal and asserted 
that it was in this class, wouldn't that rule be an entailment?

Suppose someone asserts that <some:uriref> is a Datatype but in fact 
the engine knows nothing about that datatype. Is that an error? Or 
should we just conclude that its an unknown datatype?
Now, ask the same question about a uriref inside a typed literal. 
Don't you get the same answers??

	It's not an error, it's just an unknown class.

	I don't consider this to be strictly a datayping question. We
	can have

		some:thing rdf:type foo:Blargh .

	and an application may not know what a foo:Blargh
	actually is, but it does know that some:thing is one of them.
>[Patrick Stickler, Nokia/Finland, (+358 40) 801 9690, 
>----- Original Message -----
>From: "ext pat hayes" <phayes@ai.uwf.edu>
>To: <w3c-rdfcore-wg@w3.org>
>Sent: 02 November, 2002 04:25
>Subject: rdfs:Datatype question
>>  Er...guys, Something must have been decided over the summer that I
>>  missed somehow. As far as I can see, given the decisions we have made
>>  about datatyping, there simply is no useful role for rdfs:Datatype.
>>  We don't need it, so why have we got it?
>>  As I understand the current decision, the *only* place that a
>>  datatype URI can be used so as to exhibit, as it were, its datatyping
>>  potential , is inside a typed literal. We aren't going to have any
>>  special datatyping entailments which involve the use of a datatype
>>  URI as a property (checked in my last email: consensus apparently
>>  that have agreed not to do that); there are no long-range datatyping
>>  entailments, for sure, so that there is nothing that can be inferred
>>  about any interpretations of literals from any reference to a
>>  datatype class (that is, something can be said to be in the class, of
>>  course, but the fact that it is a *datatype* class has no particular
>>  semantic significance for anything else.) And as far as I can see,
>>  there is no way to infer that anything is in a datatype class, since
>>  the only things that we know are in those classes are literals, which
>>  can't be subjects. So we really don't need to impose any special
>>  datatyping conditions at all on the property or class extensions of
>>  datatype URIs in any interpretation, even in
>>  RDFS-with-datatype-entailment.
>>  Given this, I can't quite see what Im supposed to say about
>>  rdfs:Datatype in the model theory. Like, it's the class of datatypes.
>>  But that class isn't defined by RDF(S), and its not even known to
>>  RDF(S), so why has RDFS got a special syntax for it? I don't even
>>  have any way to refer to it in the MT metalanguage. Time was, when we
>>  had datatyping banners unfurled all over the place, that we needed
>>  RDFS to be able to 'declare' that some URIref was supposed to be a
>>  datatype label, so as to trigger all those range-datatype inferences
>>  and so on. But now its obvious from the syntax which urirefs are
>>  supposed to be datatypes: the ones inside the typed literals. Saying
>>  it in an explicit triple doesn't seem to add anything. And if we say
>>  it is, and in fact it isn't (or an RDF engine can't find it) then we
>>  are (or the engine is) in just the same pickle as if we had used it
>>  inside a typed literal and in fact it isn't. No amount of RDF
>>  triple-asserting is going to magically create a non-existent datatype.
>>  Unless Im missing something, therefore, I propose that we drop 
>>  PROPOSE: do not introduce rdfs:Datatype into the rdfs namespace.
>>  Then I can put our very simply boiled-down datatyping into the core
>>  RDF MT quite happily, since it won't involve the RDFS vocabulary in
>  > any way.  It will just be one extra line in the semantics of
>>  literals. And if we do keep it, then (unless I am warned of a mistake
>>  in the above), I am just going to say that it is like rdf:List,
>>  rdf:seeAlso, rdf:first, rdf:rest, rdf:nil and rdf:comment in having
>>  no semantics at all.
>>  Pat
>>  --
>>  ---------------------------------------------------------------------
>>  IHMC (850)434 8903   home
>>  40 South Alcaniz St. (850)202 4416   office
>>  Pensacola               (850)202 4440   fax
>>  FL 32501            (850)291 0667    cell
>>  phayes@ai.uwf.edu           http://www.coginst.uwf.edu/~phayes
>>  s.pam@ai.uwf.edu   for spam

IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola              			(850)202 4440   fax
FL 32501           				(850)291 0667    cell
phayes@ai.uwf.edu	          http://www.coginst.uwf.edu/~phayes
s.pam@ai.uwf.edu   for spam
Received on Wednesday, 6 November 2002 06:37:57 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:18 UTC