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

action item on reification

From: Frank Manola <fmanola@mitre.org>
Date: Wed, 23 May 2001 14:06:00 -0400
Message-ID: <3B0BFC08.CF826D35@mitre.org>
To: w3c-rdfcore-wg@w3.org
from the minutes of the 2001-05-18 teleconference:
> ACTION ITEM: Ghram Klyne and Frank Manola agree to summarize www-rdf-logic
> perspective of reification as it applies to both logic and rdf and
> report back to rdfcore wg

The following hasn't been coordinated with Graham, but represents an
initial cut on my part at summarizing what the issues seem to be.  As
Graham (correctly) noted in a recent message, these issues are tightly
bound up with general questions about RDF semantics.

Background:
Reification is introduced into RDF because RDF statements (as they
stand) are not resources.  In order for RDF to be able to make
statements about statements (e.g., the "Ralph Swick" example), there
needs to be a way to turn RDF statements into resources.  Reification is
also used to model statement grouping (explicitly for purposes of
modeling Description elements;  however, presumably other syntactic
groupings of statements would need to use reification as well).  That
is, you want to be able to refer to a collection of statements, which
requires that the statements be reified into resources that can be put
into those collections.  It seems to me possible to lump these uses
together by saying RDF needs a way to refer to statements, either for
"semantic" purposes (making some assertion about an assertion someone
else has made), or for "syntactic" purposes (statement grouping).  Both
these uses are described in the M&S spec.  TBL and some others have also
suggested that reification provides a way to add power to RDF, by
describing the capabilities of the new facilities as they apply to
existing ones.  Thus, TBL's "Semantic ToolBox" design issues white paper
discussed introducing the concept of negation (NOT) by reification:

"Hence, to say "not(node, property, value)", you have to say, for
example, "there is something which is an RDF property and has a subject
of A and whose B property has value C and is false". So in RDF, not can
be introduced by a new property which associates a boolean truth value
with another node."   The example given is:

<quote id="foo" about="http://www.w3.org/">

    <w3c:member>http://www.soap.com/</w3c:member>

</quote>
<rdf:description about="#foo">
   <truth>0</truth>
</rdf:description>

rdf-logic issues:
The basic issues with reification discussed on rdf-logic seem to be (at
least!) as follows:

1.  The same RDF reification mechanism is used to provide both syntactic
capabilities (e.g., statement grouping) and semantic capabilities (e.g.,
assertions about assertions).  There may be reasons for wanting to
provide these different capabilities (these can be individually
debated;  see below), but the same mechanism can't be used for all of
them, since you then can't determine what the reification "means" in a
given usage.  Additionally on this issue:

a.  note that conventional logic languages provide *different*
mechanisms for describing set membership, lexical containment/nesting,
quoting, and so on. 

b.  this issue applies to using a single mechanism for referring to RDF
statements in RDF for multiple purposes, independently of what that
single mechanism is.  So, for example, finding some simpler way to refer
to RDF statements that didn't involve using the current modeling
mechanism, while it would be nice for many purposes, wouldn't resolve
this issue. 

2.  Some of the intended purposes for which RDF reification is proposed
are inappropriate (in some cases they may be appropriate in higher level
languages), or impossible.  For example:

a.  using reification to add power to RDF (e.g., add negation or
quantification) within RDF itself is impossible, because RDF isn't
powerful enough to describe those extended capabilities.  

b.  reification isn't the best mechanism for making statements about
statements (the Ralph Swick) example), or for describing statement
nesting.  

3.  The intended semantics of making statements about statements in RDF
aren't completely clear.  For example, in the Ralph Swick example, is
the intent really to make a statement about something (the reified
statement) that is only a piece of syntax, or is the intent really to
make a statement about something that at some point you want to be able
to treat as an assertion, with semantic meaning (e.g., I might want to
collect all the things Ralph Swick said, and determine if they were
consistent).

4.  To really handle some of the possible semantics of making statements
about statements, additional (often logically non-trivial) mechanism is
needed.  For example, to determine the consistency of all the things
Ralph Swick said, you need the ability to move between reified and
unreified statements in a controlled way.  Using a form of reification
to allow a language to extend its own syntax is also possible, but also
requires additional mechanism (the language itself must be sufficiently
powerful, for one thing).  
  
--Frank

-- 
Frank Manola                   The MITRE Corporation
202 Burlington Road, MS A345   Bedford, MA 01730-1420
mailto:fmanola@mitre.org       voice: 781-271-8147   FAX: 781-271-8752
Received on Wednesday, 23 May 2001 14:06:41 EDT

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