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

   [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?

   Consider

   #Susan #favorite-integer int:05 .
   #Susan #favorite-integer int:5 .

   how is an RDF query system supposed to respond when asked about Susan's
   favorite integers?

   ...

   It is true that you can make a consistent view of all this from this
   ``RDF'' viewpoint, but you do have to be a bit careful.  In particular, if
   you want to allow RDF to be consistent with different URI schemes, you have
   to modify the "one-URI, one-Resource" philosophy to a "one-URI, possibly
   one-Resource".  

   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.

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 all may contradict RDF Schema in some way.  I hope not.

                                             -- Drew McDermott

Received on Tuesday, 2 October 2001 10:10:27 UTC