RE: Literals (Re: model theory for RDF/S)

> -----Original Message-----
> From: ext jos.deroo.jd@belgium.agfa.com
> [mailto:jos.deroo.jd@belgium.agfa.com]
> Sent: 05 October, 2001 14:36
> To: phayes@ai.uwf.edu
> Cc: Stickler Patrick (NRC/Tampere); www-rdf-logic@w3.org
> Subject: RE: Literals (Re: model theory for RDF/S)
> 
> 
> 
> [...]
> > I may simply have not been following the point properly. Coming from
> > logic, I have an acute sense of the difference between information
> > which is conveyed as part of the very syntax of a language, and that
> > conveyed by making assertions in the language. This seems 
> like a very
> > sharp and important distinction to me. My understanding of the
> > proposal was that the syntactic encoding of, say, integers implicit
> > in the notion of literal was to be abandoned and replaced by an
> > assertional encoding in RDF triples. That may be a good idea, but it
> > does potentially throw away a lot of valuable properties implicit in
> > the syntactic typing of literals. However, if this proposal 
> is better
> > thought of as one to introduce a more uniform notion of syntactic
> > typing for URIs in general, then I'm all for it. Sorry if my
> > ignorance is a barrier to communication.
> 
> that is indeed the crucial point!
> let me refer to our "tangent point" testcase
>   http://www.agfa.com/w3c/euler/tpoint.n3
>   http://www.agfa.com/w3c/euler/tpoint-facts.n3
> which is making use of "an assertional encoding in RDF triples"
> (think about log:implies as an entailment between graphs)
> I think this example should make use of some (primitive)
> datatypes, but only to a certain extent, because when
> the granularity is too big, I don't see straightforward
> inferincing capability to have answers to such questions as
>   http://www.agfa.com/w3c/euler/tpoint-query.n3
> especially while having a given point within the circle
> (2 complex solutions) which is later maybe "ruled" out by
> the inference engine (using further rules of course).


It must be due to my ignorance of formal logic, but I just
don't see where there is any "syntactic encoding of integers 
implicit in the notion of literal" which is specific to
a data type 'integer', or any other specific data type.

A string is a string is a string and the only thing we can
deduce from it is that it is a sequence of bytes. Whether
that sequence of bytes corresponds to a lexical representation
of a numerical magnitude which we wish to classify as 'integer'
is a matter of interpretation of the string. No such knowledge
exists 'inherent' in the string itself, explicitly or
implicitly.

So, any data type knowledge about a given literal value *must*
be asserted in one way or another externally from that literal
itself. Either by an anonymous node construct such as

   <rdf:Description>
      <rdf:value>5</rdf:value>
      <rdf:type rdf:resource="#integer"/>
   </rdf:Description>

or by some other means, such as, e.g. an alternate URI 
representation  'int:5' where the data type knowledge 
can either remain implicit in the semantics of the specific
URI scheme, or can be asserted based on that URI scheme,
e.g. 

   <rdf:Description aboutEachPrefix="int:">
      <rdf:type rdf:resource="#integer"/>
   </rdf:Description>

In either case, one has to take deliberate steps to define
the data typing in a way that can be utilized as knowledge
explicit within the graph. And only in the case of the
URIs is such knowledge inherent, implicitly, in the label.

Perhaps I'm just not following what is being meant here by
"syntactic typing" of either URIs or literals.

??? 

Patrick

--
Patrick Stickler                      Phone:  +358 3 356 0209
Senior Research Scientist             Mobile: +358 50 483 9453
Nokia Research Center                 Fax:    +358 7180 35409
Visiokatu 1, 33720 Tampere, Finland   Email:  patrick.stickler@nokia.com

Received on Friday, 5 October 2001 07:01:43 UTC