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

Re: Reject change to rdf:value

From: <Patrick.Stickler@nokia.com>
Date: Mon, 5 Nov 2001 10:21:45 +0200
Message-ID: <2BF0AD29BC31FE46B78877321144043114C05C@trebe003.NOE.Nokia.com>
To: w3c-rdfcore-wg@w3.org

> Well, if that were indicated by a decimal then the 
> string "10" would do it, but if it were represented by an octal then 
> you need "12" and if you use a binary then you need "1010". There is 
> no way to say what THE value of rdf:value is for any particular 
> integer, until you specify what datatyping scheme is being used. 

No. Data type does not define lexical representation, and base is
just another issue of representation, not an inherent quality of
the value itself. I.e. (taking the lexical representations defined
for the Scheme programming language simply to illustrate):

  [ rdf:value "10";     rdf:type xsd:integer ].  (decimal)
  [ rdf:value "#o10";   rdf:type xsd:integer ].  (octal)
  [ rdf:value "#xA";    rdf:type xsd:integer ].  (hexidecimal)
  [ rdf:value "#b1010"; rdf:type xsd:integer ].  (binary)

In each case, the data type itself is the same, as is the value.
Only the lexical representation changes, and in each case, the
interpretation of that lexical representation within the context
of that data type is explicit and reliable.

Thus, while it is likely true that one cannot interpret a literal
value without knowledge of its data type, and a given VALUE (as
opposed to rdf:value) may have multiple lexical representations,
the data type itself has little if anything to do with determining
whether any two rdf:value's correspond to the same VALUE, apart
from expecting them to belong to equivalent or related data types.

The issue of whether "10" "#o10" and "#xA" are the same "thing" is
precisely the same issue as to whether "5" or "00005" are the
same "thing" or further, if "5" "00005" "5.0" "0005" or "5.0000000"
are the same "thing". It is IMO beyond the scope of RDF proper,
and should be left to the interpretation of specific systems,
based on the data type information that is provided -- and it
is imperative that regardless of typing and other qualifications
associated with a given rdf:value in the graph, that the rdf:value
itself be clearly identifiable, and not hidden behind any 
specialized properties such as eg:hexidecimal or xsd:integer, etc.


   In all cases of qualified anonymous node constructs, the value of
   the property should IMO always and without exception be the 
   object of an rdf:value property defined for that anonymous node.
   Otherwise, we turn the graph into a much more complex puzzle than
   it need be for generalized operations based solely on RDF and
   RDFS semantics.

And as an aside, a "good" lexical representation specification will
disallow semantically vacuous variants such as "00005" or "5.0000".
It is interesting that, insofar as the prose provided by XML Schema,
it defines a "good" lexical representation for data types such
as integers, disallowing such vacuous representations; however, 
no actual regular expressions defining those representations are
provided in the normative schema, and hence, no system using the 
"official" schema definitions can validate against any lexical
representation, much less such vacuous representations, without
a static, built-in knowledge of those base types -- which imparts
a very heavy implementational burden for systems which are not
XML Schema parsers/validators but wish to easily validate XML
Schema simple data types according to their lexical forms. Pity...

It is also important to note that XML Schema does *not* allow the
expression of xsd:integer in anything but base 10. Hence the examples
above such as [ rdf:value "#xA"; rdf:type xsd:integer ]. are in fact
invalid and erroneous, as "#xA" is not a valid lexical form as defined 
by XML Schema for the integer type -- presuming that the assigning of a
type xsd:integer to a literal string "#xA" is to considered equivalent
to an XML serialized representation <xsd:integer>#xZ</xsd:integer> such
that all of the constraints and properties of the data type xsd:integer
(including lexical constraints) apply. Whether or not the use of
xsd:integer as an rdf:type can transcend those lexical constraints and
represent only the abstract numerical type for 'integers', and how
that would be achieved, is a very interesting (though different) question.



Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: patrick.stickler@nokia.com
Received on Monday, 5 November 2001 03:21:59 EST

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