Re: [jena-dev] Re: Use cases for Reification in RDF Triplestores

>Some conclusions are in order.
>
>I certainly have a better understanding of some of the issues
>in RDF regarding reification and nested statements.  Below,
>I've listed a number of conclusions that summarize my interpretation
>of the current state of affairs.  Within that list are a couple
>of technical questions for which I still lack answers.
>I get the feeling that only a portion of the WG has understood
>the full import of some of the decisions that have been made.
>
>However, the net result is disappointing.  It seems like the
>WG Charter may be impeding progress on RDF (and the Semantic
>Web), but that's just a guess.

Well, the WG charter was indeed very limiting: it was to clarify and 
standardize the existing state of RDF, not to extend or improve it. 
Other WGs have more extended charters, of course, eg Webont.

>
>
>(1) There are some fairly simple things that one would like
>to say in RDF that are not expressible.  Here are some examples:
>
>Suppose we start with a triple that states
>"Fred Martin is 52 (years old)".  Assume that 'S1' is that triple,
>in the abstract sense, not in the sense of a stating.
>
>Here are some things I would like to be able to say about S1:
>
>"The probability of S1 is P"
>"S1 is true at time T1"
>"I disagree with S1"
>"The object value of S1 is wrong.  The correct value is 53
>   (i.e., retract S1 and assert 'Fred Martin is 53')"
>"S1 is important (take note of it)"

Most of these go way beyond what almost any KR formalism is able to 
say. They are, for example, not expressible in full FOL, and note 
even in full ANSI-KIF 3.0. I think it is hardly fair to criticise RDF 
for being unable to say things like this. To invent a formalism 
capable of saying all this stuff would in fact be a major research 
problem, in my view.

Also, I think that in fact what you really want to be able to say in 
many cases is not what you have cited here, but more limited 
propositional forms, eg not that S1 is true at time t, but that Fred 
Martin is 52 years old at time t, which is not the same thing and 
doesn't mention truth. The latter *can* be said in RDF, with some 
awkwardness admittedly, if you invent an RDF ontology for times (or 
use an existing one)

>
>(2) Some of the WG members appear to be unaware of this defect.
>
>Here is a quote by Seth Russell to that effect (I imagine he is
>not alone): "But I really don't know any practical case where we
>would want to say something about a jena:Triple" (here I'm
>assuming that 'jena:Triple' means 'statement').
>
>(3a) One means for alleviating the problem in (1) with regard
>to examples I've listed would be to permit statements to
>be nested.

I disagree: as far as I can see, these two topics - being able to 
make meta-assertions on the one hand, and allowing more complex 
statement syntax on the other - have almost nothing to do with one 
another. Certainly, allowing a more complex syntax (which can be 
simulated in RDF by the use of the collection vocabulary, see the OWL 
spec for examples of how to do it) doesnt enable to you make 
meta-assertions like your examples above.

>  Nested statements are explicitly forbidden
>(apparently by the WG charter).

They would be an extension to RDF syntax which we considered but 
decided was beyond our charter, yes.  We expect that other (and 
future) WGs will extend RDF, as Webont has already done, and have 
been working with them to provide tools to make this easier to do 
(notably the collection syntax).

>
>(3b) A second means for alleviating the problem in (1) would
>be to admit reified statements (using the traditional sense
>of that phrase) into RDF.

The widespread opinion, which I share, is that this is not a good way 
to allow for the expression of meta-assertions, and in any case that 
meta-assertions are not in fact of wide utility.

>Although that appears to have
>been sanctioned in the original RDF, it has now been forbidden.

The original M&S was simply confused on what reification was supposed 
to mean. Our job was to sort out the confusion. Most users, it seems, 
who have actually made practical use of reification, had opted for 
the 'statings' interpretation, so we decided to go with that, 
particularly as it avoids the potentially paradoxical consequences 
arising from the other interpretation.

>
>(4a) KIF provides an existence proof of a logic language
>that explicitly allows nested statements and does not
>introduce paradoxes.  Question: Is the Charter the only
>reason for forbidding nested statements, or are there
>technical reasons as well?

You seem to be confusing two distinct issues. Of course one can have 
nested syntax without invoking a meta-theory, but RDF wasnt set up 
with nested syntax - a charter issue - and an overwhelming number of 
RDF users tell us that the simple triples-store model is crucial, so 
we decided not to alter that.  Several people have observed that 
extending the RDF syntactic model (for example to quads rather than 
triples) would enable more efficient ways to encode nested syntax, 
but DAML and OWL appear to get by with LISP-style collections, so we 
are sticking with that for now.  That has nothing to do with 
reification, paradoxes or or the ability to express meta-level 
assertions.

KIF is paradox-free, but the reason has nothing to do with nesting, 
but comes from KIF's use of the 'weakly true' truth-predicate (wtr). 
This has a rather arcane and tricky semantic condition which defuses 
the classical liar-style paradoxes. But all of this is way more 
complicated than anything in RDF.

>
>(4b) Allowing unfettered use of reified statements would
>make it very easy to introduce paradoxes.  Taking (4a)
>into account, if reified statements were constrained
>by the same semantics as nested statements, then I'm guessing
>that the possibility for self-reference, and therefore
>paradox, might be eliminated.

I have no idea what you are talking about here, Im afraid.

>  Has this been explored?
>
>(5) Some of the WG members appear not to be aware that
>ordinary reification is not merely unsupported, but is
>actively discouraged.
>
>Brian McBride: "there are two concepts - statements and statings and only one
>bit of vocabulary.  The WG, for reasons that Pat Hayes has explained picked
>one for the existing vocabulary, and as Pat also mentioned,  that
>does not preclude you, or anyone else, from defining new vocabulary
>for the missing concept."
>
>My guess is that Pat explicitly does not want me or anyone else
>to define vocabulary for the missing concept, i.e., for statements,
>because "its too dangerous" (which I translate as "it might
>allow for paradoxes").

My dear fellow, I want everyone to do whatever they want to do. My 
point about danger only arises when your axioms fail to live up to 
your expectations, and you come to complaining to the WG. If you find 
yourself wrestling with paradoxes, don't blame us.

>
>(6) Its very easy to write statements about statements and
>never introduce paradoxes (freeways are dangerous, but its
>easy to walk beside them without crossing them).

Actually it is suprisingly tricky to do this. Its easy in toy 
examples, but when you start combining information from various 
sources, the risk of a paradoxical/contradictory loop arising 
increases. The question you should be asking is, how hard is it to 
KNOW that you have not accidentally stepped onto the freeway? There 
arent any boundary fences or lane markers in logical reasoning.

>  Users have
>the option to pretend that statings are in fact statements,
>and then use the RDF statings machinery to make assertions
>about them.  In my case, we appear to have no choice; our
>application requires the ability make assertions like those
>listed in the beginning, and no alternatives have yet been
>offered up.  I'm not worried about the so-called 'danger',
>but its disappointing that no legitimate alternative
>has been suggested.

I really think that your aspirations for RDF are *way* beyond the 
reality, and that this hasnt really got anything directly to do with 
reification. RDF isn't a general-purpose universal KR language, its 
just a very simple, basic way of expressing large numbers of simple 
facts. most of them ground facts. It doesnt even have disjunction or 
implication in it.

>
>(7) The RDF Semantics Document
>     http://www.w3.org/TR/2002/WD-rdf-mt-20021112/
>contains a section on Reification that is quite difficult
>to read.  This is not a criticism per se, because the
>subject itself is relatively difficult.  However, it is
>not reasonable to think that many readers could make a
>pass through it and know what they had just read.

It isnt meant to be a first introduction.

>
>On my first pass through, I noted that the term 'token' is
>used repeatedly but never defined.  That made things tougher.
>The term 'stating' never occurs.  It took several readings to
>determine that what was said did in fact seem to jibe with
>the notion of stating that has appeared in the discussion groups.
>That also made things more difficult.

The word 'token' has been in standard use now (in the type/token 
contrast) since before I was a grad student, and can be looked up in 
a dictionary. But I will put it into the glossary. We invented the 
'statings' terminology in the email discussion ourselves, so it 
doesnt seem appropriate to use it in a standards reference.

>
>(8) Parts of the OWL document
>    http://www.w3.org/TR/2002/WD-owl-semantics-20021108/
>are even more abstruse (c.f., the very short section
>on OWL-FULL).  I can't tell from scanning it
>whether any of my examples can be expressed in OWL.  If
>OWL indeed is the solution to some of our problems, I
>would like to see some examples.
>
>(9) The triple stores that have emerged in conjuction with
>RDF could in principle solve all of my current problems.

I very much doubt that, frankly.

>However, the restriction that they conform to RDF semantics
>means that they can't handle the examples I've listed.  Since
>Jena currently allows one to include statements as arguments
>to other statements

Just as a matter of interest, HOW does Jena do that using a 
triples-store format?

>and RDF does not, for my purposes one
>of Pat's claims is exactly backwards:
>
>    Pat Hayes: But the fact is that triple stores are a limited tool,
>    and RDF is committed to the use of this very restricted tool.
>
>Jena 1.6 already gives me what I need except for some tiny
>tweeks to the API.

On the one hand, what you say above sounds like you are shooting for 
the moon, but you say that all you need is a go-cart. Something is 
wrong somewhere. Either you don't really need the expressiveness you 
say you need, or else you need a much more powerful notation than you 
say you would be happy with.

>  My guess is that Jena's current representation
>(ignoring unbridled reification, which I don't use) can be
>embedded as a subset of KIF, thereby making it logically
>sound.

KIF is way more expressive than RDF, however. Even full OWL is less 
expressive than FOL with is less expressive than KIF.

IM interested in how you propose to 'bridle' reification, by the way. 
If you can make that explicit then I might be bale to show you haw to 
do it in RDF.

>  However, owing to its commitment to RDF,
>Jena 2.0 is scheduled eliminate the statements-as-arguments feature
>(replacing it with statings as arguments?).  This is, to say
>the least, disappointing.

Well, I am not a Jena maven, but I think that if it was committed to 
achieving such a rich expressive power just by making assertions 
about sentences in triple stores, then it was probably never going to 
work properly in any case. But look, if you were going to use 
reifiation to do this, then you were committed to using four triples 
per reified triple to express the meta-level. (If you started doing 
this with nesting, the numbers would go exponential very quickly.) As 
I already pointed out, even in the worst case, you only have a factor 
of 5 instead of 4. And in practice, you could probably just ignore 
the distinction and treat reifications as statements in any case if 
you are willing to semantically a bit careless. The only problem that 
would arise would be that you might get two distinct entities with 
the same structure and RDF wouldn't be able to infer they were two 
statings of the same statement; but RDF can't express identity in any 
case, so if you were going to use RDF this shouldn't bother you.

Pat


Pat
-- 
---------------------------------------------------------------------
IHMC					(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola              			(850)202 4440   fax
FL 32501           				(850)291 0667    cell
phayes@ai.uwf.edu	          http://www.coginst.uwf.edu/~phayes
s.pam@ai.uwf.edu   for spam

Received on Tuesday, 14 January 2003 15:16:00 UTC