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

Re: use/mention and reification

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Fri, 25 Jan 2002 14:16:10 +0200
To: Dan Connolly <connolly@w3.org>
CC: "jos.deroo.jd@belgium.agfa.com ext" <jos.deroo.jd@belgium.agfa.com>, RDF Core <w3c-rdfcore-wg@w3.org>
Message-ID: <B877192A.C50F%patrick.stickler@nokia.com>
On 2002-01-25 2:04, "ext Dan Connolly" <connolly@w3.org> wrote:

> On Thu, 2002-01-24 at 08:52, Patrick Stickler wrote:
>> On 2002-01-24 2:47, "ext jos.deroo.jd@belgium.agfa.com"
>> <jos.deroo.jd@belgium.agfa.com> wrote:
>> 
>>> 
>>>> Here are the options I find acceptable:
>>>> 
>>>> (a) Shoot reification on the grounds that
>>>> there isn't consensus about what it means
>>>> nor how to use it.
>> 
>> I don't see how we can do this, as reification is at present
>> the most straightforward way to qualify statements.
> 
> ?!?!?
> 
> This must be some use of the word "straightforward" with
> which I am not familiar. All the feedback I hear
> about reification is "run away! run away!"
> 
> I'm interested to hear about deployment of refication
> used in this manner, and some user community
> that found it to be straightforward.
> 
> [...]

Let me give one example from my own work, which while still
being in the design/build phase and is not yet deployed,
is the result of alot of exploration about the optimal
way to achieve the desired end result.

That end result is the qualification of assertions (or
statements in general). The key types of qualifications
that I have myself been looking at (while still attempting
a solution that works for any arbitrary qualifications)
are scope, source, and authority.

The two "idioms" for expressing such qualifications that
are the most accessible, given the present state of RDF
and RDF tools, are

1. Reified statement, e.g.

   <rdf:Description rdf:about="#productA">
      <name>Product A</name>
   </rdf:Description>

   <rdf:Statement>
      <rdf:subject rdf:resource="#productA"/>
      <rdf:predicate rdf:resource="&rdf;label"/>
      <rdf:object>Product A</rdf:object>
      <scope rdf:resource="tdl:(&xsd:lang)en"/>
   </rdf:Statement>

   <rdf:Description rdf:about="#productA">
      <name>Tuote A</name>
   </rdf:Description>

   <rdf:Statement>
      <rdf:subject rdf:resource="#productA"/>
      <rdf:predicate rdf:resource="&rdf;label"/>
      <rdf:object>Tuote A</rdf:object>
      <scope rdf:resource="tdl:(&xsd:lang)fi"/>
   </rdf:Statement>

2. Qualified Object

   <rdf:Description rdf:about="#productA">
      <name>
         <QValue>
            <rdf:value>Product A</rdf:value>
            <scope rdf:resource="tdl:(&xsd:lang)en"/>
         </QValue>
      </name>
      <name>
         <QValue>
            <rdf:value>Tuote A</rdf:value>
            <scope rdf:resource="tdl:(&xsd:lang)fi"/>
         </QValue>
      </name>
   </rdf:Description>

where QValue is a type that indicates a qualified value.

Now, the latter idiom is unnatractive because it
introduces variation in the representation of
assertions which means that query engines or
query writes have to know about the variant graph
forms for qualified and unqualified values.

It also requires an interpretation that the anonymous
node object equates to the "reification" of the statement
(or at least the occurrence of a given value).

If the first reification based "idiom" is used, then
the representation of the assertion remain
unaffected by the qualification, and most importantly,
qualifications can be made separately from the
actual assertions -- which I consider to be essential.

Now, if the reified form was instead expressed as

   <rdf:Statement>
      <rdf:subject>#productA</rdf:subject>
      <rdf:predicate>&rdf;label</rdf:predicate>
      <rdf:object>Product A</rdf:object>
      <rdf:scope rdf:resource="tdl:(&xsd:lang)en"/>
   </rdf:Statement>

then, although it could be made to work, it is more
work because rather than, for a given triple, being
able to just plug in the subject, predicate, and
object as-is, to retrieve all statement reification
nodes having those members, one has to map all URIs
to strings. This also makes optimization more difficult
by requiring all statements to be scanned for
the matching strings rather than simply being able
to traverse (implementation specific) bidirectional
links from resources to referring reifications.

Thus, the intersection of actual nodes shared by
both assertion triples and refied statement triples
is beneficial from an implementational standpoint,
though I also consider it to be "correct" from a
philosophical standpoint as well.

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 Friday, 25 January 2002 07:26:06 EST

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