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

From: Drew McDermott <drew.mcdermott@yale.edu>
Subject: Re: Literals (Re: model theory for RDF/S)
Date: Tue, 2 Oct 2001 10:10:19 -0400 (EDT)

> 
>    [Peter Patel-Schneider]
>    Yes, in DAML+OIL you can equate two different URIs, via equivalentTo.
>    However, that is certainly not how DAML+OIL handles datatypes, like
>    integers.  A DAML+OIL (March 2001) processor has to understand a portion of
>    XML Schema, not just the syntax but also the semantics.
> 
> This is a basic difference between DAML and RDF, correct?

Well not actually between DAML+OIL and RDF but between the datatype
extension (also called the March 2001 version) of DAML+OIL and RDF.

[...]

>    This has consequences with respect to the *meaning* of answers returned by
>    an RDF query system.  In particular, the notion of cardinality becomes more
>    than a little suspect.  (Consider asking how many favorite integers Susan
>    has.  If an RDF query system answers two, then it is not just incomplete,
>    it is wrong.  This can be fixed by some rather technical means, but must be
>    done carefully.)
> 
> I thought that these issues all had a standard answer on the wide-open
> world-wide semantic web: you *can't* answer cardinality questions just
> by enumerating the answers you get back.  If an RDF query system
> responds with "int:05, int:5" as an answer to the query about Susan's
> favorite integers, it isn't wrong; what would be wrong is concluding
> that 'int:05' and 'int:5' are different objects from the fact that
> they both occur in such a query answer.

Agreed, for some things.  However, for integers, a DAML+OIL (March 2001)
processor needs to know that the integers 5 and 6 are different, and, similarly,
that the literals "5" and "05" both map to the integer 5, and thus are the
same when considered as integers.

> Still, I appreciate the point that literals name objects that are
> "manipulable" by the computer in a way that the object named by
> 'famouscriminals:JackTheRipper' is not.  What if we adopt a pragmatic
> scheme that does one of the following with a literal (in order from
> less to more manipulability):
> 
>    * Treat it as an uninterpretable URI
> 
>    * As Patrick suggested, view the "hostname" in the literal as a
>      "literal server" for the characters in it.  The server can be
>      asked questions such as, "Do these two strings denote the same
>      object?" and "Is the object denoted by this literal convertable
>      to an object of type 'dt:int' and if so what would its
>      representation as an int be?"
> 
>    * Transform it into an object that the RDF parser knows how to
>      handle.  Numbers, strings, and such would presumably fall into
>      this category.

This is one way to go, but may have certain other consequences. In
particular, the second choice may require more power from the ``literal
server'' to support reasoners for formalisms that are more expressive than
RDF(S).  It may not even be possible to provide ``literal servers'' for
some formalisms.  (Consider the problems with combining multiple theories
that have been partially addressed by theory resolution or concrete
domains for description logics.)

> This all may contradict RDF Schema in some way.  I hope not.

Who knows?

>                                              -- Drew McDermott


Peter F. Patel-Schneider

Received on Tuesday, 2 October 2001 12:49:31 UTC