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

Re: a test case for "literals must be self-evident"

From: Dan Connolly <connolly@w3.org>
Date: Mon, 10 Dec 2001 14:02:09 -0600
Message-ID: <3C1514C1.534AC3D9@w3.org>
To: Pat Hayes <phayes@ai.uwf.edu>
CC: w3c-rdfcore-wg@w3.org
Pat Hayes wrote:
> Sorry this reply is delayed.
> >OK, I blathered on about this requirement in...
> >
> >   literals must be self-evident
> >   Dan Connolly (Wed, Oct 17 2001)
> >   http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Oct/0338.html
> >
> >but recent discussion with Peter S. and Jeremy made me realize
> >I can reduce this to a real simple entailment test:
> >
> >Does dte-blunt.nt entail dte-pointy.nt?
> >
> >dte-blunt.nt:
> >
> >   <http://example/x> <http://example/y> "abc".
> >
> >dte-pointy.nt:
> >
> >   <http://example/x> <http://example/y> "abc".
> >
> >i.e. does an RDF document entail itself?
> >Surely the answer is yes, right?
> >I suggest that P/P++ do not guarantee this entailment;
> >they fail to specify that the answer to this
> >test is "yes".
> >
> Well wait a minute. Are those the SAME graph, or two different but
> isomorphic graphs?

I wasn't very clear; they're supposed to be the same RDF/xml
document. The problem with the P++ scheme (as I understand it)
is that an RDF/xml document doesn't pin down the graph.

Let's use this as the test input:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  <rdf:Description rdf:about="http://www.w3.org/">
    <dc:title>World Wide Web Consortium</dc:title> 

> Do you mean, does a document entail *itself*, or
> does it entail any other document with the same lexical form?

I think I mean
	does a document ential itself?

or, in other words:

	does a document completely determine the graph?

> In the
> P++ scheme, distinct literal nodes are treated as syntactically
> distinct entities, so the answer matters.
> For example, suppose that we were to merge these two graphs. Would
> the result contain two triples or one?

Yes, that's another way to phrase the question. If parse
the RDF/xml document above, and then parse it again,
will I ever get more than just the one triple?

This self-evident idea requires that you get just one.

> If the answer is one, then
> they are the same document and this document entails itself (of
> course). If the answer is two, then they are two distinct but similar
> documents, and the answer then is, indeed, no in the P++ scheme,
> since those two different literal occurrences might be typed
> differently.

Then perhaps I misunderstood. I understood that the
very same document could end up with different graphs in P++.

For example, take:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  <rdf:Description rdf:about="http://www.w3.org/">

now one minute, I get some schema info from
http://example/vocab that says the range
of ex:orgDirectorShoeSize is a numeral.
I parse that into my knowledge base, then I parse
the document above. In the P++ scheme, the
object of the triple I get from parsing is an integer,
if I understand correctly.

The next minute, somebody edits the example vocabulary;
I restart my program and grab the schema; now
it says the range of ex:orgDirectorShoeSize is numeral
(a string constrained to [0-9]+, say). Then I parse
the above document again. Now the object is a string.

So I've parsed the same document twice, and the two
formulas I got don't entail each other.

Another related test case, using RDFS: does this

  _:somebody ex:leftShoeSize "10".

  ex:leftShoeSize s:subPropertyOf ex:showSize.

RDFS-entail this?

	_:somebody ex:shoeSize "10".

since there are relevant issues related to the syntax
of n-triples (and since I've used N3 QNames to abbreviate
full n-triples), here are the documents in RDF/xml:


<rdf:RDF xmlns="http://example/vocab#"


    <rdf:Description rdf:about="http://example/vocab#leftShoeSize">
        <s:subPropertyOf rdf:resource="http://example/vocab#showSize"/>


<rdf:RDF xmlns="http://example/vocab#"


> But this, seems to me, does not violate the guidelines you enunciated
> in
> http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Oct/0338.html
> since there you talk about an interpretation being CHANGED -
> redefined - by the addition of information. Here, nothing is being
> changed; if you add datatyping information, you are simply
> disambiguating the bare literal by adding more information about it,
> by removing some of its (datatyped) interpretations. This is just
> like normal RDF inference, right? The only difference is that every
> occurrence of a bare literal has to be treated as a separate
> syntactic entity. That gives inference a slightly unusual 'feel' on
> bare literals, perhaps, but it isn't anything disastrous. There is no
> nonmonotonicity, if you stick to the rules.

Maybe I don't understant how P++ works, then. I got the impression
that in P++, the RDF/xml form of a document didn't completely
nail down the graph; that a parser decided between different
graphs based on information from other places/documents.

Dan Connolly, W3C http://www.w3.org/People/Connolly/
Received on Monday, 10 December 2001 15:02:12 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:07 UTC