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

Frank Manola wrote:
[...]
> It seems to me that what's going on is this:  There is a distinction in
> RDF between anonymous resources and those with URIs, and Brian's folks
> use that as a coding scheme for distinguishing references to templates
> from references to specific things.

Yup.

>  However, I don't think there there
> is any built-in support for this specific interpretation in RDF.

Within the constraints of the charter, that is for us to decide.  We are
formalizing the model theory.

>  So,
> while I suppose people could use that coding scheme, they wouldn't be
> wise to assume that everyone else was using URIs and anonymous resources
> to make the same distinctions.  It seems to me that the distinction in
> RDF is mostly "syntactic" in a sense;  that is, anonymous nodes are
> provided as a way to, in certain cases, avoid the need to explicitly
> specify a URI in the RDF.  It doesn't necessarily mean that there wasn't
> one that couldn't have been provided.  The original "Ora Lassila"
> example wasn't really describing the creator of the home page as a
> template which matched any of a number of people who happened to be
> named "Ora Lassila" and had a specified email address (they might have
> meant that, and in fact a given description may actually match several
> people, but I claim that wasn't the intent here).  The writer of the RDF
> was referring to a specific person.  The immediately following example
> in the M&S showed how, if a URI for Ora Lassila existed (and if you
> wanted to provide it), you could do so without using an anonymous
> resource.

What you say of m&s is true.  However, this is an argument by ommission.
One can't expect M&S to have provided examples of every possible use
of RDF.  Is the interpretation suggested in the use case inconsistent
with M&S?

You are suggesting an interpretation of RDF
where the binding of an anonymous node to a specific resources occurs say 
"at the time of writing" of the RDF/XML.  Is that right?   An anonymous
resource denotes a specific object - yes.  Is that consistent with
the interpreting them as existentially qualified.

> 
> Looking at this the other way, it seems to me that the specific offer in
> Brian's example could just as easily have been expressed using an
> anonymous resource, e.g.:
> 
> #offer890 :inResponseTo #advert123;
>           :instanceOf   #advert456;
>           :description  [:product :roses;
>                          :quantity [:units :kg; :value "200"]];
>                          :deliveryTime [:units :days; :value "2"];
>                          :deliveryMethod "TNT";
>                           etc ]
> 
> which translated is:
> 
> <#offer890>  <foo:inResponseTo>  <#advert123>
> <#offer890>  <foo:instanceOf>    <#advert456>
> <#offer890>  <foo:service>       _:service
> _:service    <foo:product>       <foo:roses>
> _:service    <foo:quantity>      _:q .
> _:q          <foo:units>         <foo:kg>
> _:q          <foo:value>         "200"
> _:service    <foo:deliveryTime   _:t .
> _:t          <foo:units>         <foo:days>
> _:t          <foo:value>         "2"
> _:service    <foo:deliveryMethod "TNT"
> etc.
> 
> This conveys exactly the same information, with the exception of an
> explicit URI for the service.  But the buyer doesn't really need to know
> the URI of the service;

That's scenario dependent, e.g. the buyer might want to seek independent
references about the the specific service offered.

This is an interesting distinction.  If the seller provides an independently
verifiable URI for the service, then the seller is not free to switch
the actual service which delivers.  If the seller provides a anon node
or a skolemized name, then they can 'cheat'.

Is that another use case?  I promise to provide a service matching your
requirments, but I'm not going to tell you which one yet - I reserve
the right to decide that later.  Which is different from service123
meets your requirements, where service123 is a name that is publicly
defined so I can do credit/quality checks on it, and maybe use that
name to access it.

>  all he needs to do is reply with an "accept" to
> the specific offer, and the seller would understand exactly which
> service was meant.   The point is that the offerer in this case might
> reply with an anonymous node for the service, but still be referring to
> (or at least, able to provide) a specific service.
> 
> Conversely, when you have a specific URI, you know that it is the unique
> identifier that someone has assigned to identify something, but you
> don't necessarily know what kind of a "something" that is.  For example,
> your advert placed by a seller who can sell roses in quantities upto 500
> could just as easily been expressed in RDF using a specific URI, as:
> 
> #advert456 :role "seller" ;
>            :description  #service456
> 
> #service456 :product :roses;
>             :quantity [:units :kg; :maxValue "500"]].
> 
> which translates to:
> 
> <#advert456>   <foo:role>        "seller" .
> <#advert123>   <foo:description> <#service456> .
> <#service456>  <foo:product>     <foo:roses> .
> <#service456>  <foo:quantity>    _:q .
> _:q            <foo:units>       <foo:kg> .
> _:q            <foo:maxValue>    "500" .
> 
> The seller in this case has chosen to identify a *service description*
> with a URI, but that's perfectly OK as far as RDF is concerned (a URI
> can denote anything), and in a given application that might be a
> perfectly sensible thing to do. 

I agree there are other ways to model the use case.


> The seller might also have specific
> services with their own URIs.  Each kind of resource (service offers and
> services) could be defined (say in RDFS) as being of different classes
> (so you'd tell them apart by class, not by whether they were URIs vs.
> anonymous).  Seller applications dealing with services and service
> offers would know how to deal with the differences appropriately;  and
> buyers might not have to worry about it, if the service identities
> didn't need to be exported.  Even if they did, it seems to me that, in
> general, we'd do well to determine what kind of thing was represented by
> a URI (or other identifier) on the basis of explicit metadata (e.g., in
> RDFS class definitions), rather than on the basis of anonymous resource
> vs. URI (after all, there are lots more distinctions than "specific
> resource" vs. "variable" that we have to be able to make).
> 
> The bottom line here is that while anonymous nodes can certainly be used
> (at least in some cases) to make the distinction Brian's example
> illustrates, I don't think it's *necessary* for that purpose,

That is true.

> and they
> aren't necessarily going to be used uniformly by everybody to make those
> sorts of distinctions.

That depends on what the WG decides on the abstract syntax and semantics.

Brian

Received on Friday, 20 July 2001 05:47:25 UTC