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

Re: Answer to the question: What is a "value" to RDF

From: Graham Klyne <Graham.Klyne@MIMEsweeper.com>
Date: Sat, 17 Nov 2001 16:57:27 +0000
Message-Id: <5.1.0.14.2.20011117164450.04330740@joy.songbird.com>
To: Pat Hayes <phayes@ai.uwf.edu>
Cc: w3c-rdfcore-wg@w3.org
At 12:41 PM 11/16/01 -0600, Pat Hayes wrote:
>>I'd like to consider a simple example:
>>
>>     ex:foo ex:property "10" .
>>     ex:property rdfs:range xsd:integer .
>>
>>Can this be legitimate?
>
>In S, I don't think so, since xsd:integer has to be a property rather than 
>a class.
>
>Even if we allow it to be used in both ways at once, I cannot see any way 
>in which range information on the asserting property (ie the property that 
>occurs in the triple which has the bNode as object in the S idiom) can 
>possibly constrain the datatype used in the second triple (the one that 
>has the bNode as subject and the literal as object.), or indeed even have 
>any interaction with it. The triple
>_:x xsd:integer "10" .
>can be, at best, only constrained to be false by a class restriction of 
>the form
>_:x rdf:type <someClass> .
>It cannot be forced to be true.

I think I didn't state my query clearly enough.  The above example is 
exactly the case I wanted to test (because I think it corresponds to some 
current usage).  But I was not clear that the xsd:integer is *not* intended 
to be the property used in the S scheme to indicate an integer value.

Consider this slightly enlarged example:

     ex:foo ex:property "10" .
     ex:property rdfs:range xsd:integer .
     ex:foo s:property _:a .
     _:a s:inDecimal "10" .

where it is the node labeled _:a that denotes the integer value 10.  (This 
entails the smaller example above, right?)

I think it *can* be legimitate if the xsd:... URIs are considered to be RDF 
class names whose value space is strings that conform to the corresponding 
xsd:... lexical space.  In this interpretation, the xsd:... URIs would not 
be used to label properties;  some other label would be required for that 
(s:property and s:inDecimal in the above example).

>>  If so, what can we say about it?
>>
>>Could we, for example, allow rdf:type values like xsd:integer to be 
>>subclasses of rdfs:literal, so that the members of the value space are 
>>still just strings, but having a restricted lexical form?
>
>But that would not specify the datatype, since "10" might be a decimal or 
>a binary or an octal or whatever.

I agree that it wouldn't specify the datatype of the value denoted by 
intermediate node (_:a in the example above, or _:int10node in the example 
below).  I don't see that as a problem.

But it does mean that the denotation of the literal node has a restricted 
form per the value space of xsd:integer (by externally defined 
interpretation for the class xsd:integer), which in turn would place limits 
on the satisfiable literal values in that position.

I'm not trying to say that the simple two-line example is equivalent to the 
expanded form with an intermediate node denoting the integer value, just 
consistent with it.  In this way, I think there is a migration path from 
what I claim to be current usage to the more complete description given by 
the idiom that Sergey/Dan are promoting.

>>  Any interpretation of the string as (say) an integer would be outside 
>> the scope of RDF, but we could still have some inference from the above like:
>>
>>     ex:foo ex:integerProperty _:int10node .
>>     _:int10node rdf:type xsdv:integer .
>>     _:int10node rdf:value "10" .
>
>Yes, but that is more the DC style than the S style.

That thought did cross my mind;  I'm not hung up on S vs DC here...

>Howrya gonna get the xsd: name into a property position??

I'm not.  That wasn't my intention.

Note that my enlarged example above has two properties that are specific to 
the case at hand:  ex:property (whose range is a string value) and 
s:property (whose range is an integer value).  I think these would be 
"similar" properties, in the sense that:

     <x,y> in IEXT(I(ex:property))
=>
     <x,int(y)> in IEXT(I(s:property))

where int(y) maps a decimal integer string to the corresponding integer value.

[Later]

It also occurs to me that we could have three parallel namespaces; e.g.

    xsd:integer a rdf:Class.     (Lexical space of decimal integers, per 
XML schema)
    xsdv:integer a rdf:Class.    (Value space of integers, per XML schema)
    xsdp:integer a rdf:Property.

The last a property such that:
    <x,y> in IEXT(I(xsdp:integer))
  <=>
    string y is a decimal string representation of integer x.

Therefore:
    _:a xsdp:integer "10".
is true when _:a denotes the integer 10.

#g
--


------------------------------------------------------------
Graham Klyne                    MIMEsweeper Group
Strategic Research              <http://www.mimesweeper.com>
<Graham.Klyne@MIMEsweeper.com>
       __
      /\ \
     /  \ \
    / /\ \ \
   / / /\ \ \
  / / /__\_\ \
/ / /________\
\/___________/
Received on Saturday, 17 November 2001 13:49:53 EST

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