Re: A use case for anon nodes - action from telecon

>Hi Frank,
>
>Frank Manola wrote:
> >
> > Brian--
> >
> > I wonder if you could resend your example, annotating it with which
> > things are supposed to be the anonymous resources, and which aren't?  I
> > frankly (how else can I talk?) found it difficult to properly interpret
> > it.  Some of the comments below may be based on the resulting
> > misinterpretation.
>
>Good point.  This is how the use case came to me and I just passed it
>straight on.  I should have included a translation.  Here is one now:
>
>#advert123 :role "buyer";
>           :description [:product :roses;
>                         :quantity [:units :kg; :minValue "100"]].
>
>translates to:
>
><#advert123> <foo:role>        "buyer" .
><#advert123> <foo:description> _:service .
>_:service    <foo:product>     <foo:roses> .
>_:service    <foo:quantity>    _:q .
>_:q          <foo:units>       <foo:kg> .
>_:q          <foo:minValue>    "100" .
>
>i.e this is advert placed by a purchaser who wishes to buy roses in
>minimum quantities of 100.
>
>and
>
>#advert456 :role "seller";
>           :description [:product :roses;
>                         :quantity [:units :kg; :maxValue "500"]].
>
>translates to:
>
><#advert456> <foo:role>        "seller" .
><#advert123> <foo:description> _:service .
>_:service    <foo:produce>     <foo:roses> .
>_:service    <foo:quantity>    _:q .
>_:q          <foo:units>       <foo:kg> .
>_:q          <foo:maxValue>    "500" .
>
>i.e. this is an advert placed by a seller who can sell roses in
>quantities upto 500.
>
>I've checked with my source and this is the correct.

OK, though you really shouldnt have used the same '-:q' as in the 
first example. BUt now, how is any matching done between these? 
Rewrite the second example using a different anon-name:

><#advert456> <foo:role>        "seller" .
><#advert123> <foo:description> _:service .
>_:service    <foo:produce>     <foo:roses> .
>_:service    <foo:quantity>    _:qq.
>_:qq          <foo:units>       <foo:kg> .
>_:qq          <foo:maxValue>    "500" .

and put it all together and we have a total of 12 triples which refer 
to two anonymous things called _:q and _:qq which have no obvious 
connection to one another. No variables, nothing to 'match', no 
obvious consequences. Certainly it doesnt follow that _:q  equals 
_:qq; they might be respectively 256 and 483, say.

> >
> > For example, there seems to be this assumption that an anonymous
> > resource represents a variable in a query or template that is to be
> > bound to specific instances (e.g., in the book seller example).
>
>Err, I'm not sure why this is being raised in the context of this use
>case.  I see no queries in this use case.  I see only assertions
>about advertisments.
>
> > However, I don't think this is the proper interpretation of any of the
> > uses of anonymous resources in the M&S, the first one being "The
> > individual whose name is Ora Lassila, email <lassila@w3.org>, is the
> > creator of http://www.w3.org/Home/Lassila."  Rather, I think the basic
> > interpretation of RDF statements is that of being assertions, and in
> > some cases you wind up asserting the existence of something that you
> > don't have a URI for, so you generate an identifier for it (e.g., the
> > "individual" in the previous statement).  I amplified on this in one of
> > my earlier messages [and I'm using the present message as a stake in the
> > ground;  I'm composing a longer dissertation on this that I'll send
> > later, since I have an action item on anonymous resources].
>
>That seems plausible to me.
>
> >
> > Your comment above about a URI only representing one thing suggests
> > looking at the problem from the opposite direction too.  That is, while
> > sometimes you may want to use an anonymous resource to refer to a "real
> > thing" (like the "individual" whose name is Ora Lassila), in other cases
> > you may want to use a genuine URI to refer to a template, or one of its
> > parameters.  These are, after all, real things that you want to be able
> > to talk about (particularly in the context of Web applications).  The
> > fact is that there isn't really any built-in interpretation (at least
> > not that I can see) that URIs only identify things that "really exist"
>
>I'm not sure how to decide what really exists and what doesn't - I hope
>we can stay away from that question.  I personally would be happy to have
>a URI to denote a unicorn in some fairy story.

Right. Say 'really exists' means 'is in the universe of discourse', 
without taking a stance on what that universe consists of.

>
> > (in some sense) and anonymous resources only identify variables to be
> > matched.  Rather, these are interpretations we assign to them in
> > specific uses.  I can easily imagine a "template" (e.g., a specific
> > purchase order form) having a URI, with each of its component items also
> > having a URI (I might want to describe its format and semantics, for
> > example).  A specific instance of that form, partially or totally filled
> > in with specific values, might have a separate URI.  There would
> > probably be machinery for relating the template to the filled in
> > instance, but it would be part of some application semantics, not
> > necessarily built into the semantics of RDF.
>
>I'm not following the point you are trying to make here, but the
>thought in my head is that we need to take care to distinguish
>between the name of a 'variable' and the name of the thing
>the variable is bound to.

Agreed, though that isnt the key issue here. What matters is what 
kind of process is allowed to 'bind' a value to a variable, and the 
(sad but true) fact that whatever is doing that had better not claim 
to be doing anything that is valid in RDF1.0.

>
>[...]
> > > I'm not sure that standard FOL captures this.  FOL is built
> > > around a conceptual model where there can be many interpretations
> > > for statements in the FOL.  But that is not the situation we
> > > are in here.  We have one interpretation - its a mapping to
> > > the world out there.

WHICH mapping? How can I possibly know, when reading your RDF, which 
mapping you have in mind? All I can know is that whatever it was, it 
presumably made all your RDF sentences true, otherwise you wouldn't 
have asserted them. But look: if I already know your intended 
interpretation, you wouldnt *need* to send me any RDF. I could 
generate it myself and it would magically mean what you intended it 
to mean, by a kind of semantic resonance. If there is only one 
interpretation, then we all already know what sentences are true and 
false, and there is no point in telling one another what we already 
know.

>Intuitively I feel that makes a difference.
> > > That makes naming special.
> > >
> >
> > I'm not sure what you mean here.
>
>Neither am I :(  I said to express and intution that isn't well formed
>in the hope that someone might shed some light.
>
> > If you mean that FOL statements can
> > refer to both real things and "conceptual" things like templates or
> > queries, that's true (e.g., I can describe the contents of a query in
> > FOL), but, as I tried to argue above, so can URIs.  What seems to be
> > happening in these examples, though, is that we're taking some syntax,
> > and interpreting it in slightly different ways depending on whether we
> > think we're talking about a query, or about a set of assertions.
>
>I see no queries in the use case - only assertions.

The key issue is whether something is allowed to bind variables to 
new values during processing. If they are, and if this is considered 
valid, then those variables that get bound must be either universal 
variables in an assertion, or existential variables in a query. 
Either way that takes us outside the RDF 1.0 M&S, seems to me.

>
>What I'm getting at that traditional logic is about designing formal
>systems that are true under any interpretation.  That's not what we
>are dealing with here.

No. Logic is about characterising how truth is preserved. The idea 
isnt that formal systems are true (actually that doesnt mean 
anything), but that the formal systems *preserve* truth: it the 
antecedents are true (in I) then the consequents must be true (in I). 
That 'if..then' is what has to be true for any I if the reasoning is 
valid. The point being that if I have no idea what your intended 
interpretation is (which in general I don't, in fact, other than 
knowing that it makes your assertions true), then that doesnt matter; 
I can still draw valid conclusions from your sentences since 
*whatever* your intended interpretation was, my conclusions will be 
true in it.

> >  I
> > discussed this in
> > http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Jun/0559.html
> > I think we need to be very careful about this.
> >
> > This isn't to say that there might not be a place for variables in RDF.
> >   I just don't think that that's automatically the appropriate
> > interpretation of anonymous resources.

The key issue is who is doing the binding. If an RDF engine can bind 
values to variables at run time (ie at inference time), then it's 
going beyond the M&S.

Pat

---------------------------------------------------------------------
(650)859 6569 w
(650)494 3973 h (until September)
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes

Received on Monday, 23 July 2001 23:38:47 UTC