W3C home > Mailing lists > Public > public-rdf-wg@w3.org > February 2013

Re: datatype maps in Semantics and Concepts

From: Peter F. Patel-Schneider <pfpschneider@gmail.com>
Date: Tue, 26 Feb 2013 19:09:11 -0800
Message-ID: <512D78D7.3000004@gmail.com>
To: Pat Hayes <phayes@ihmc.us>
CC: RDF WG <public-rdf-wg@w3.org>, Richard Cyganiak <richard@cyganiak.de>

On 02/26/2013 06:34 PM, Pat Hayes wrote:
> On Feb 26, 2013, at 7:48 PM, Peter F. Patel-Schneider wrote:
>
>> If we want to have the standard datatypes fixed to their usual meaning, then why not just say that?
> I think that "the datatype conventionally identified by" an IRI does say that. I'm open to a change of phrasing if you prefer something different. Suggestions?

We can't just say conventionally identified in a normative part of our 
documents.   We can say "If you use xsd;string, ... then you must use them as 
defined in Concepts or in XSD Datataypes", and normatively point to the 
appropriate documents.  However, what document are you going to point to for 
the convention?
>> The current document talks about "the datatype conventionally identified by aaa".  What does this end up meaning?  How are new datatypes set up?  How does "recognition" interact with "conventional indentification"? This just seems like magic to me.
> Its how the Web works. People define datatypes and assign them a URI, and then other people use that URI to refer to the datatype. How did http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral get to refer to the datatype we all know and love,

It got to be so because a buch of people got together and fought over it.  It 
got to be so so because they convinced W3C to put out a REC.  RDF 1.1 can now 
use rdf:PlainLiteral by normatively pointing to that document.  RDF systems 
and applications can say that they implement rdf:PlainLiteral by saying that 
their datatype map includes the mapping for rdf:PlainLiteral from that 
document.  They could, if they wanted, say that they implement a different 
datatype with name rdf:PlainLiteral.  I wouldn't recommend it, but they could.

Appealing to an undefined convention is much worse.  Whose convention?  I 
could just make up a convention on the spot!  OK, here's one:  an XS datatype 
IRI conventionally indentifies the next datatype  in XSD 1.0, but interpreted 
as in XSD 1.1.  What in the current Semantics document is the convention 
violating?  From now a system conforms to the current Semantics if it uses 
this convention, even without mentioning it.

Yes, yes, I know this is being really stupid, but that's the point. Our 
documents have to rule out *this* kind of stupidity (as opposed to the 
stupidity of building a system that does the above but says so in its 
documentation).

>   the Edsel of the datatype world? It does so because http://www.w3.org/TR/rdf-plain-literal/ says it does. It does *not* do so because the pair
>
> <"http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral", [the datatype described in http://www.w3.org/TR/rdf-plain-literal/] >
>
> is in some datatype map.

Well, in RDF 1.0 this is definitely the way for systems and applications to go.
>   
>
> In any case, how is a new datatype set up in the current D-semantics? This is just as mysterious and magical.

Not at all.  Appplications and systems say what their datatype map is.  (Yes, 
yes, lots of them don't say so so explicitly, but that is the mechanism.)
> At least the new way of stating admits that it is just using the normal conventions of the Web to determine what datatype IRIs denote, instead of confusing things with some impressive-looking but essentially meaningless pseudo-mathematics.

But what are the normal conventions?  Where is the W3C REC (or equivalent) 
that these conventions are written in?
>
> BTW, for more on this, see this exchange between Richard and Antoine (which I only just discovered):
>
> (from  http://answers.semanticweb.com/questions/9781/regarding-plain-literal-and-rdfplainliteral-equality )
>
> ===
>
> The semantics of "foo" and "foo"^^xs:string is the same only if you assume a datatype map which maps xsd:string to the corresponding XML Schema datatype. In any other situation, nothing mandates these two things to be the same (i.e., to have the same interpretation). In particular, the RDF and RDFS semantics do not mandate that (though it's likely to change in RDF 1.1, yes).
> (23 May '11, 08:37)Antoine Zimm... ♦
>
> You pedant! That's true of course, but I submit that talking about the value of a typed literal obviously assumes that the datatype is in the datatype map, and mapping xsd:string to anything but XSD's string type would be nuts.
> (23 May '11, 09:05)cygri ♦
>
> You're right, it would be nuts! Yet it is allowed in RDF 2004, hopefully not in RDF 2013.
> (23 May '11, 12:02)Antoine Zimm... ♦
>
> ===

RDF 1.1 can simply say that any datatype map must conform to [some mixture of 
Concepts and XSD and whatever].  In fact, I would be happy saying that 
RDF-entailment includes xsd:string and several other datatypes.  (Which 
Semantics says is the case, but needs to be accepted by the WG, if there is 
not already a resolution so saying.)

>
> Pat
>
>

peter
Received on Wednesday, 27 February 2013 03:09:44 GMT

This archive was generated by hypermail 2.3.1 : Tuesday, 26 March 2013 16:25:54 GMT