W3C home > Mailing lists > Public > www-webont-wg@w3.org > November 2002

Re: decisions about RDF semantics

From: pat hayes <phayes@ai.uwf.edu>
Date: Thu, 7 Nov 2002 11:06:15 -0600
Message-Id: <p05111b0ab9f048b5bd5f@[65.217.30.130]>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: www-webont-wg@w3.org

>From: pat hayes <phayes@ai.uwf.edu>
>Subject: decisions about RDF semantics
>Date: Wed, 6 Nov 2002 23:01:48 -0600
>
>>  The RDF core WG is rapidly converging to a final version of RDFS, and
>>  this is a heads-up of some of the things that are relevant to the
>>  webont semantics.
>>
>>  SubClassOf and subPropertyOf now have IFF semantics, but range and
>>  domain don't. The community seems to be about evenly divided on this
>>  one, so if anyone has a strong case to make, then please make it
>>  quickly.
>
>I don't care.  I believe that it is permissable for OWL to turn the one-way
>rdfs:domain and rdfs:range into IFF versions in OWL interpretations.
>
>>  The RDF list vocabulary has essentially no semantics, so OWL will
>>  have to provide one. (The only assumptions are that
>>  rdf:nil rdf:type rdf:List
>>  and the obvious domain and range conditions on rdf:first and rdf:rest.)
>
>I was expecting this all along, so the OWL model theory places its own
>conditions on the lists it cares about.
>
>>  There is very little datatyping provided. Literals can have datatypes
>>  attached, and when they do and when their string is a valid lexical
>>  form, they denote the appropriate value. Otherwise they are treated
>>  like opaque names, so OWL could impose its own interpretation on them
>>  in the absence of datatyping info. 
>
>This is not true.  Typed literals of the form "lll"^^ddd, where ddd is a
>known datatype but lll is not in the value space for ddd are given
>specific denotations, thus preventing them from being anything else.  For
>example, in an XML Schema-interpretation,
>"033333333333333333333"^^xsd:float is different from
>"0033333333333333333333"^^xsd:float.

There is a distinction between RDFS-interpretations and 
D-interpretations which take account of a set of datatypes (engines 
for which are presumed to have access to the datatype API). What I 
said applied to RDFS interpretations, for which there is no notion of 
'known datatype'. For D-interpretations, what you say is correct: but 
I am writing this part now, so if you have any strong feelings about 
what badly-formed typed literals should denote, let me know. I only 
require that they not denote a normal literal value, so that the 
inference

aaa ppp "sillynumber"^^xsd:number .
--->
aaa ppp _:xxx .
_:xxx rdf:type _:yyy .
_:yyy rdf:type rdfs:Datatype .

is blocked.

>  > Bare literals always denote
>>  themselves (they can be a string or a pair of strings) and this is
>>  not influenced by datatyping. Datatype names used as class names
>>  refer to the class of elements of the value space of the datatype.
>>  There is no range datatyping and no provision for linking a bnode to
>>  a literal with a datatyping property, but such usage would not
>>  violate RDF, if OWL wanted to impose it. RDF *never* assumes that two
>>  items in different value spaces are equal, even when they are.
>
>I believe that this contradicts both the current version of the RDF MT

Well, I'm writing the current version, so I hope it doesn't. But in 
any case I don't see how not making an assumption can possibly 
contradict anything. And RDF has no way to express equality, so this 
isnt much of an assertion.

>and
>clear wording in the XML Schema datatyping document.

I think you will find that that clear wording does not mean what you 
take it to mean. I was certainly surprised to find out what it means. 
XSD says that any two things in different basic datatype value spaces 
are unequal.  As far as I can tell, this uses a sense of 'equal' 
which is unknown outside the XSD literature, but whatever xsd-'equal' 
means, it does not mean 'identical'. Rather than try to unpick this 
confusion, I think it is best if RDF stays quietly on the sidelines 
and lets the XSD community try to make sense of their own pigsty.

In any case, I didnt say that they WERE unequal, I just said that RDF 
takes no stance on the matter.

>
>For example, suppose that I have two dataypes ex:D1 and ex:D2.  The L2V
>mapping of ex:D1 maps ddd^eee, where ddd is a signed numeral whose integer
>value has absolute value less than 2^24 and ee is a signed numeral whose
>integer value is between -149 and 104 inclusive, into the integer value of
>ddd times 2 raised to the power of the integer value of ddd.  The L2V
>mapping of ex:D2 maps ddd^eee, where ddd is a signed numeral whose integer
>value has absolute value less than 2^53 and ee is a signed numeral whose
>integer value is between -1075 and 970 inclusive, into the integer value of
>ddd times 2 raised to the power of the integer value of ddd.
>
>Then if ex:D1 and ex:D2 identify datatypes, the RDF model theory then makes
>"5^5"^^ex:D1 denote five times two to the fifth, i.e., one hundred and
>sixty, and "5^5"^^ex:D2 denote five times two to the fifth, also one
>hundred and sixty. 
>
>What are ex:D1 and ex:D2?  Well, they are just slight modifications of cut
>down versions of xsd:float and xsd:double.  The value spaces of xsd:float
>and xsd:double are definitely *not* disjoint.

According to Henry Thompson they definitely are, and this will be 
clarified and made explicit in the next round of XML Schema updates.

>
>All this actually has consequences for OWL.

I agree. Take the matter up with Henry, I have warned him already 
that there is a train wreck coming. He will say that the values in 
the spaces are identical but that the same values (he uses the plural 
in such a case to refer to one thing) in two different spaces are 
un*equal*. Can you make sense of that? Apparently to him is it as 
clear as glass.

>  It appears to me that in OWL
>plus XML Schema datatypes
>
>	<ex:foo> rdf:type owl:functionalProperty .
>	<ex:John> <ex:foo> "333333333333"^^xsd:float .
>	<ex:John> <ex:foo> "333333333333"^^xsd:double .
>
>would be a contradiction, but that
>
>	<ex:foo> rdf:type owl:functionalProperty .
>	<ex:John> <ex:foo> "5e-2"^^xsd:float .
>	<ex:John> <ex:foo> "10e-3"^^xsd:double .
>
>would *not* be a contradiction.
>
>Also, it appears to me that the denotations of datatypes that have
>different L2V mappings must be distinct individuals.  Therefore
>
>	xsd:float owl:sameIndividualAs xsd:decimal .
>
>would be a contradiction.

Right, it is, according to XML Schema. Get used to it, XML Schema is 
NOT based on extensional set-theoretic thinking: value spaces are not 
sets. They are more like categories. The 'same' thing in two 
different spaces is different from itself.

>
>>  If a
>>  datatype scheme wishes to make claims like this, it has to do so
>>  explicitly.
>
>This I don't understand at all.  How can a datatyping scheme make explicit
>claims that two items in different value spaces are equal?

Why not? XSD makes rulings on the matter.

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
Received on Thursday, 7 November 2002 12:05:57 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:57:55 GMT