Re: Literals

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Tue, 02 Oct 2001 12:55:24 -0400

Message-Id: <20011002125524X.pfps@research.bell-labs.com>
```From: Sandro Hawke <sandro@w3.org>
Subject: Re: Literals
Date: Tue, 02 Oct 2001 10:18:02 -0400

> And how else could we address this?  I see at least two clear and
> simple approaches:
>
> 1) Have only byte-string literals in the RDF graph, as nodes denoting
>    finite sequences of integers in the range 0...255.  Staying away
>    from characters makes equality clear.  If you want to encode a date
>    or a number or a character string in a byte-string-literal, you
>    must say so in the RDF graph.  For example
>
>       :ThirdAnnualMeetingOfPhilosophersGuild time:startTime _:t
>       _:t time:EncodingAsUnixTimeOrderedInDecendingSignificance 0x3bb9acbf
>
> Alternatively, we can take avoid literals in the RDF graph:
>
> 2) Say that "literals" are a technique which RDF encoding languages
>    can use to convey some kinds of information in a compact manner,
>    but that the RDF graph only represents information with agreed-upon
>    symbols.  For example in some RDF language with integer literals,
>    we might say
>
>        :Jim :ageInYears 3
>
>    That would parse to an RDF graph without literals: the graph would
>    express the number 3 in terms of some standard RDF symbols, such as
>    the Peano-style "numbers:zero" and "numbers:nextGreaterInteger":
>
>        :Jim :ageInYears _:x
>        numbers:zero numbers:nextGreaterInteger _:one
>        _:one numbers:nextGreaterInteger _:two
>        _:two numbers:nextGreaterInteger _:x
>
>    Obvious, this technique isn't a great way to communicate integers,
>    but it does allow communication using integers between agents who
>    shared only an RDF encoding language without integers.
>
>    You can argue that any decent standard language would allow integer
>    literals, but where do you draw the line?  This basic technique of
>    encoding the information of the literal in the RDF graph allows us
>    to communicate clearly about objects which are not so likely to be
>    literals, like numbers greater than 2^32, or dates, or all sorts of
>    more domain-specific information.  It works for character strings
>    and XML infosets, too.
>
>    You can view an API as a language, and as such, one would expect
>    native types and possibly all serializable classes to be treated as
>    literals (ie passed around much like symbols, but in an
>    RDF-interoperable way).
>
>     -- sandro

The only change that I see here is pushing the problem one level deeper.

If you want to have a (partial) theory of something like integers in RDF or
RDFS or DAML+OIL, i.e., a formalism that does not include general-purpose
axioms, then you have to provide the capabilities by extending the
formalism.  There are lots of different ways of doing this, but they ALL
need to extend the formalism, either directly or parametrically.  There is
no such thing as a free lunch, and because we have decided (so far) not to
pay the price of a general purpose reasoning system we need to pay these
extension prices.

Peter F. Patel-Schneider
```
Received on Tuesday, 2 October 2001 12:56:02 GMT

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