W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > July 2002

Re: test case: Test case A and reification

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Tue, 02 Jul 2002 10:45:51 +0300
To: ext Brian McBride <bwm@hplb.hpl.hp.com>, RDF Core <w3c-rdfcore-wg@w3.org>
Message-ID: <B94734DF.17B7F%patrick.stickler@nokia.com>


On 2002-07-01 20:12, "ext Brian McBride" <bwm@hplb.hpl.hp.com> wrote:

> 
> The discussion at Friday's telecon reminded me why I was keen to have test
> case A still in.  I've tried to raise this point a couple of times and just
> wanted to put it more formally.
>
> It is suggested that, even with untidy literals:
> 
>  _:a <p> "lit" .
>  _:b <p> "lit" .
> 
> entails:
> 
>  _:a <p> _:l .
>  _:b <p> _:l .
> 
> Consider a statement and its reification:
> 
>  <s> <p> "a" .                       (1)
>  _:s rdf:subject <s> .
>  _:s rdf:predicate <p> .
>  _:s rdf:object "a" .                (2)
>  _s: rdf:type rdf:Statement.

How are reifications of statements with blank node objects
handled?

Seems to me like the same problem (or non-problem) exists
for both blank nodes and untidy literals.

Consider

   <s> <p> _:x .

if reified (e.g. by rdf:bagID) do we get

  _:s rdf:subject <s> .
  _:s rdf:predicate <p> .
  _:s rdf:object _:x .
  _:s rdf:type rdf:Statement.

or

  _:s rdf:subject <s> .
  _:s rdf:predicate <p> .
  _:s rdf:object _:y .
  _:s rdf:type rdf:Statement.

???

If the former, then it would be reasonable also
to expect to have for untidy literals

  <s> <p> _:x"a" . 
  _:s rdf:subject <s> .
  _:s rdf:predicate <p> .
  _:s rdf:object _:x"a" .
  _:s rdf:type rdf:Statement.

But even with 

  <s> <p> _:x"a" . 
  _:s rdf:subject <s> .
  _:s rdf:predicate <p> .
  _:s rdf:object _:y"a" .
  _:s rdf:type rdf:Statement.

there's still no problem. See below...

> Does the object of statement (1) denote the same thing as the object of
> statement (2)?
> 
> Given the model theory as it stands (Pat - is this right?) the answer to
> this question is yes.

I would agree that the two objects should denote the same thing, otherwise
there would not be any true 'stating' captured by the rdf:Statement.

Whether or not the two objects are the same syntactic node is a separate
question. They could very well be different syntactic nodes yet still
denote the same 'thing'.

> Now consider:
> 
>  <jenny> foo:age "10" .                   (3)
>  <film>  dc:title "10" .                  (4)
>  foo:age  rdfs:range xsdr:decimal .
>  dc:title rdfs:range xsdr:string .
> 
> and two reifications:
> 
>  _:a rdf:subject <jenny> .
>  _:a rdf:predicate foo:age .
>  _:a rdf:object "10" .                    (5)
>  _:a rdf:type rdf:Statement .
> 
>  _:b rdf:subject <film> .
>  _:b rdf:predicate dc:title .
>  _:b rdf:object "10" .                    (6)
>  _:b rdf:type rdf:Statement .
> 
> 
> Then the objects of statements (5) and (6) cannot denote the same thing as
> the objects of statements (3) and (4) respectively.

They can.

The solution is simply to include reifications into the scope of global
datatyping so that the object of the triple and the object of the
reification are interpreted as having the same datatyping context. I.e.

  <p> rdfs:range ?d .

  <s> <p> _:x"a" . 

  _:s rdf:subject <s> .
  _:s rdf:predicate <p> .
  _:s rdf:object _:y"a" .         (note not same node)
  _:s rdf:type rdf:Statement.

gives us (?d, "a") in both cases, which evaluates to the same
datatype value and hence they denote the same 'thing'.

Thus, there is no problem.

Even with having different literal nodes in the triple and
reification, their meaning is unambiguous and identical.


> I confess I find this rather bizarre.  In the case where the object of a
> statement is a literal, then the value of the rdf:object property of the
> reification of that statement denotes a syntactic entity, otherwise it
> denotes a semantic one.  (Sorry that doesn't sense to a logician, but Pat'l
> know what I mean.)
> 
> Is that what we mean to say?
> 
> If the answer to test case A is yes, then we need an non-entailment test:
> 
>  <s> <p> "a" .
>  _:s rdf:subject <s> .
>  _:s rdf:predicate <p> .
>  _:s rdf:object "a" .
>  _s: rdf:type rdf:Statement .
> 
> where _:s is a reification of the first statement
> 
> does not entail:
> 
>  <s> <p> _:o .
>  _:s rdf:object _:o .

If the answer to test A is 'yes', then that is a vote for
tidy literals, right? And if literals are tidy, then there
is no issue.

If we have untidy literals, the answer to A can never
be a solid yes in the absence of a global datatyping
constraint for the property, as is demonstrated by
your analog to test A using rdf:_N properties. Thus,
to be absolutely sure of the meaning of an untidy
literal, you must have a datatype context explicitly
associated *somewhere*. The property alone is insufficient.
Literal nodes without an associate datatype are like
blank nodes. You just don't know if two such nodes
denote the same thing. They might. They might not.

Yet even so, if literals are untidy, and we extend the scope of
datatyping interpretation to reification, then again,
there is no need for the non-entailment test since
in fact, the entailment holds since the datatyping context
for both the triple and the reification is taken to be
the same.

So everything is well and good with literal objects of
reifications, no matter whether we choose tidy or untidy.

Eh?

Patrick

--
               
Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: patrick.stickler@nokia.com
Received on Tuesday, 2 July 2002 03:45:52 EDT

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:49:48 EDT