RE: exploring ambiguity via the "something-which-has" URI scheme

>> I think there is one real point of disagreement, though:
> 
>     You are saying that all communicating parties (using RDF on the
>     SW) MUST agree which one thing is denoted by each URI they use (at
>     least for many of the URIs they are using).
> 
>     Pat is saying that while all parties MUST agree that each name
>     denotes one thing, it is not practical or necessary for them to
>     agree on which thing each name denotes.  Instead, it is sufficient
>     for some knowledge to be shared which constrains the possible
>     denotations for each name.  The amount of knowledge which can and
>     needs to be shared depends on the situation.  Sometimes it may
>     seem that you can share enough knowledge to uniquely pin down the
>     denotation of all the names you use, but (if I'm understanding
>     right) this is an illusion.   I don't follow the theory there, but
>     my intuition agrees that, whether or not it's theoretically
>     possible, truly nailing down the terms is neither practical nor
>     necessary. [more below]

I think that Pat and I actually are in more agreement about this
than disagreement, and in fact the disagreement reflected above
does not exist but arose out of my misuse of the terminology.

My key point is that, for the SW (and not any application using RDF
that is not considered to participate in the SW) all parties must
agree upon denotations of a given URI which are compatible, even if
not identical.
 
> ...My scheme *allows* bad URIs, but no one
> can really prevent them anyway.   

Well, one could consider your scheme as *promoting* bad URIs rather
than just allowing them  ;-)

> They have to agree (as with the words I put in Pat's mouth above),
> that each URI is being used to name one thing, but they don't have to
> agree that anyone really knows what one thing happens to be named.
> 
> For instance, an RDFS processor doesn't need to know what class is
> named by some URI, it just needs to know some of its subclass
> relationships, right?  Going out on a limb here, it doesn't even
> really need to know EXACTLY what rdfs:subclassOf means -- some nuance
> of meaning may appear down the road -- it just needs to know what
> logically valid things it can do with rdfs:subclassOf.  The test cases
> give many formal test points for what rdfs:subclassOf could mean; the
> prose may give humans additional fuzzyier constraints on its meaning.

I think I agree with this. It seems to reflect what I said above that,
even if different agents have different interpretations of a given URI,
those interpretations should be compatible.

> In an oddly self-referential way, it seems to me like the way out of
> this debate is via test cases, but I can't think of any which matter,
> so it kind of proves the point that you can have wildly different
> interpretations and nothing will break.  But please -- do give a test
> case, sketching out where something will break if it follows the view
> I ascribe to Pat, but not if it follows your view....

I gave a few test cases that show how overloading of URIs leads to
a breakdown in communication between people *using* the SW to
exchange knowledge, but I can't think how one would be able to
define a use case that would show a breakdown in the machinery of
the SW itself, since that machinery is incapable of identifying
any such overloading.

Patrick

--
Patrick Stickler, Nokia/Finland, (+358 40) 801 9690, patrick.stickler@nokia.com

Received on Wednesday, 7 May 2003 04:48:10 UTC