Re: Abstract syntax: an attempt

>Hi Sergey,
>
>Sergey Melnik wrote:
> >
> > Brian,
> >
> > I'd just like to reiterate some of the arguments for making reification
> > a built-in feature (possibly as an optional layer):
>
>I wasn't sure what you meant by 'built in' but I guess you mean specifically
>called out in the abstract syntax.
>
> >
> > - in M&S, reified statements need to have a URI. It looks like they
> > should be unique, but nobody wants to deal with uniqueness, but still
> > some sort of URIs need to be assigned, so we end up having to deal with
> > different URIs denoting the same statement etc.
>
>I have the same question as Danbri here - why do they have to have a URI.
>M&S allows there construction without.
>
> > - in M&S, we need a specific vocabulary to express/use reification.
> > Reification could be defined without relying on vocabularies.
>
>I'm wondering what you mean here by 'relying' on vocabularies.  Reification
>is currently defined using rdf:type, rdf:subject etc.  Those are
>vocabularies.
>
> >
> > - as defined in M&S, reification is extremely verbose and clumsy both in
> > APIs and in the syntax, and very few people are using it as suggested.
> > However, I personally believe it is a useful feature when introduced
> > correctly and compactly, and it can be easily handled in APIs and
> > databases as an intrinsic model feature.
>
>Absolutely.

Not sure I agree. There are various senses of 'reification'. We need 
to be able to 'point to' sets of RDF assertions and label them and 
refer to them.  But we don't need to be able to *describe* them.

> >
> > Finally, (s1 p1 (s2 p2 o2)) looks nicer in the abstract syntax...
>
>Right.  Much neater and simpler.  However ...
>
>There has been a bunch of discussion lately on www-rdf-logic about this.
>It would be very helpful if one someone who understands these issues
>(far) better than I (Pat, FrankM, ?  please) could summarize the key points -
>and
>straighten me out if what I'm about to say is wrong.
>
>The upshot of that discussion is that there are (at least) two different
>concepts floating about, distinguished by the ideas of 'use' and 'mention'.
>
>The simplest examples to distinguish these I have seen are:
>
>  London is a city.
>  'London' is a word.
>
>The first of these is use, the second is mention of the name 'London'.
>
>A logical language needs both mechanisms.  Reification, as described in
>M&S is an example of mention e.g. Ralph said 'the sky is blue'.
>
>My working assumption at the moment is that reification is a different
>mechanism from nested expressions.  If we use nested expression syntax
>to represent reification, then a future working group can't use it
>to represent nested statements.

Right, an excellent summary, except that Im not sure that a logical 
language needs reification at all. Most logical languages don't use 
it. On the other hand, most logical langauges don't have to deal with 
issues like provenance, attribution and so on. On the other other 
hand, reification seems like a very clunky way to do that. The Navy 
has a better system; one says "Now hear this:...." and then says the 
sentence you want to be heard, which, like quotation, uses ostention 
to simply exhibit the statement being cited. If the Navy used RDF 
reification, it would come out as "Now hear a sentence with subject 
.... and object ......and verb......".

Things like provenance and attribution (this sentence came from this 
source, this sentence is part of this collection of sentences, 
whatever) are best handled by a very simple kind of ostensive 
reification, eg some kind of explicit labelling scheme (this set of 
sentences is called 'PatsBasicTheory') or some kind of quotation 
convention. In RDF this can probably be best handled using 
namespaces, or at any rate needs to be integrated with the namespace 
machinery. For these kind of purposes, full reification (ie where the 
syntax of the assertion is explicitly described) is overkill, as 
Sergey suggests (I think). On the other hand, as Brian says, 
reification is not the same as allowing more complex syntax which 
uses subexpressions. So I am left wondering quite what RDF 
reification is actually useful for.

In KIF, reification is used in rather a LISP-like way, to allow the 
language to quantify over sets of expressions in terms of their 
syntactic structure, and then assert the contents of the resulting 
sets. So for example you could define a predicate on expressions 
which was true, say, of any conjunction of relations which used the 
name "Brian" and then say that any such expression entailed a similar 
expression in which "Brian" was changed to "Joanna". But this kind of 
syntactic cleverness seems to go beyond anything being contemplated 
for RDF; and as far as I know, nobody has ever made practical use of 
this KIF cleverness.

Pat Hayes

---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes

Received on Monday, 25 June 2001 10:43:44 UTC