RE: Resources and URIs

> >Implicitly, there is a single interpretation that defines the 
> >denotation of the URI.
> 
> People keep SAYING that, but I havn't seen a single ARGUMENT for it. 

Consider the following two use cases:

1. Overloading of denotation looks like disagreement, but isn't:

My graph:
x:J rdfs:label "Jane" .
x:J x:address "123 Main Street" .
x:address rdf:type owl:FunctionalProperty .

Your graph:
x:J rdfs:label "Judy" .
x:J x:address "345 Main Street" .
x:address rdf:type owl:FunctionalProperty .

Since the denotation of x:J has different interpretations, and 
hence its denotation is overloaded, if you syndicate my knowledge
into yours, it will appear that we disagree about Judy's address.
If I syndicate my knowledge into yours, it will appear that we
disagree about Jane's address. But it may very well be that we
both agree about both Judy's and Jane's addresses, yet we can't
see that because we are using the URI x:J inconsistently.

(and since rdfs:label is not a unique property
2. Overloading of denotation looks like agreement, but isn't:

My graph:
x:J rdfs:label "Jane" .
x:J x:address "123 Main Street" .
x:Ju rdfs:label "Judy" .
x:Ju x:address "345 Main Street" .
x:address rdf:type owl:FunctionalProperty .

Your graph:
x:J rdfs:label "Judy" .
x:J x:address "123 Main Street" .
x:Jn rdfs:label "Jane" .
x:Jn x:address "345 Main Street" .
x:address rdf:type owl:FunctionalProperty .

Here, even though the denotation of x:J is still overloaded,
if you syndicate my knowledge into yours, it will appear that
we agree about Judy's address (but we don't) and if I syndicate
your knowledge into mine, it will appear that we agree about
Jane's address (but we don't).

--

In either case, it is *impossible* for the reasoning engine
to determine that overloading has occurred, since URIs are
atomic primitives and it has no (formal and reliable) machinery 
at its disposal to inspect or test the actual denotations.
It can only presume that a given URI always has the same
interpretation, and that any syndication of knowledge from
multiple sources presumes agreement of denotation among all
of those sources.

(Well, of course, the above depends on whether there is also
agreement about the denotation of x:address, owl:FunctionalProperty,
rdf:type, etc. etc. ;-)

So, even though we can't ensure against overloading of 
denotation and differing interpretations of URIs, in actual
practice, overloading of denotation on the SW is always bad,
always detrimental, and furthermore, completely invisible
to SW agents.

SW agents can do anything *but* presume that URIs have
consistent interpretations, and it is up to the users (humans)
to monitor the behavior of our systems and identify and
correct overloading of denotation (disagreement in interpretation)
as much as possible.

Without this presumption, the entire SW is useless as a means
for *global* knowledge interchange.

> >If the URI being used to denote who the first lady
> >is, is being used ambiguously, then there is no way to actually
> >test for any disagreement. I.e., I may assert that _:a denotes
> >Jane and she lives at address X, but that _:b denotes Betty and
> >she lives at address Y. If you use _:a to denote Betty and assert
> >that Betty lives at address X, I will see no contradiction, because
> >according to my understanding of _:a you are saying that Jane lives
> >at address X!

> For most URIs, trying to insist that there is one thing they denote, 
> and then to argue about what exactly it is, has just given rise to 
> long, energetic and irreconcilable debates.  Meanwhile, 'ol man Web 
> keeps rolling along, and these debates are irrelevant to it.  How 
> does it DO that, I wonder? Does it know something that we don't know? 
> Or maybe it doesn't care? If so, why are WE arguing about it?

Because 'ol man Web doesn't care about such things -- or rather humans
using the Web are satisfied if they GET something useful given a 
particular URI and they either don't need to know what its actual
denotation is, or can live quite happily with ambiguous overloading,
since humans are kinda good at that sort of thing.

SW agents, on the other hand...

'young babe SW is going to choke and puke on the grub 'ol man Web's
been eatin...  

;-)

> >For most practical purposes, I really don't want to be concerned 
> >with interpretations other than the one I "know" I'm concerned with. 
> >On this basis, people have constructed a functioning Internet.
> 
> The fact that the Internet functions is an indication that even 
> though one person may be using a URI with one thing in mind, and 
> another person using it with another thing in mind, the variations in 
> these interpretations somehow do not matter. 

Of course it doesn't matter, on the *Web*, but we are talking here
about the SW, and the needs of the SW for non-overloaded, consistent
interpretations of URIs is far higher than that of the Web. Please don't
presume (as you seem to do) that the Web deeply cares about the issue now
being discussed. I don't think it does. 

The SW is a bright light shining on the present Web architecture 
showing things in dark corners where no'one before cared or dared to go.
So don't expect to see clear answers to these questions in the present Web
architecture specs, because they simply haven't been critical issues
to the practical, day to day operation of the Web.

Yes, there are hints here and there of these issues, but not really
in those parts of the Web architecture specs where the "rubber meets
the road".

The SW is now putting those sections to task, and not getting much
traction...  hence the need to revise, clarify, and expand the
specifications -- for the needs of the *SW*, not for the Web.

> The same thing happens 
> in normal language. This is a very interesting fact that deserves to 
> be analysed carefully.  But just DECLARING that 'URIs have a unique 
> denotation, and that is why it all works' isn't a theory.  In order 
> for this to explain why the Web works, 

Again, just because the *Web* works given the present architecture, 
does *not* mean the SW will work given the same architecture at the
same resolution of specification.

Pat, you seem to be presuming that Web = SW, but that is not the case.

The SW is (IMO) a layer on top of the Web, and while it utilizes the
present Web architecture, it extends that architecture and inserts its
own additional requirements and behavior into the mix.

The present specs address the lower layer, but fail to sufficiently
address issues that are critical to the higher layer, such as the
consistent interpretation of URIs, because such things *aren't*
critical at the lower layer. This is fully understandable, and as
such, insofar as the Web is concerned, those specs do the job. But
we're now moving on to new things, and the specs need to evolve and
grow to cover this new territory.

Just because the Web has been successful, does not mean that the SW
will be so based on the present specs.

> >So how can we deal in terms of this "fiction" of a single 
> >interpretation in which URIs Identify (denote a single 
> >thing/concept) -- which I believe we must do if the specification is 
> >to have any traction with real developers
> 
> I don't believe this for a second.  In fact, I think that most 
> developers would say that it is a fantasy (or irrelevant), 

Well, I'm a developer, and I completely agree with Graham. Of course,
my wife frequently says I live in a fantasy world, so err maybe that
means nothing...  ;-)

> if the 
> notion of denotation were explained to them. Its a fantasy for any 
> program which claims to manipulate denoting expressions. Its like 
> saying that you can't wrote DB code unless you believe that all the 
> table entries are somehow magically bound to the things they are 
> being used to say things about.

No, it's about whether when you say in your schema rdfs:range
and I say in my schema rdfs:range that we *both* mean the same
particular property as defined by the RDF spec.

You seem to be arguing that there is no way that my SW agent can
presume that its interpretation of that URI actually corresponds
to your interpretation of that URI -- that our two SW agents can
in fact interpret them in entirely different, and possibly 
incompatible ways, and moreover, that such incompatible 
interpretations are perfectly OK.

If that is the case, then RDF, and the RDF MT, are complete
worthless for the global interchange of knowledge. We might as 
well just quit and go raise cows or something.

> >I don't know if this is just word-play, but my view is not to 
> >attempt to claim a URI has a single denotation in all possible 
> >interpretations, but to suggest that there exists a particular 
> >intended interpretation, which provides a denotation for all URIs, 
> >and hence that the thing "identified" by a URI is that which it 
> >denotes in this particular interpretation.
> 
> I agree that makes sense, but its just as fantastic, and just as 
> corrosive to semantic analysis. It means that A entails B just when B 
> is true in the single intended interpretation, for example, so that 
> inference engines should ignore any facts they may have been told, 
> and just read off their conclusions from the single True 
> Interpretation. That is like telling the inference engines to seek 
> enlightenment through prayer.

Pat, how can an inference engine *know* that B does not have a 
single interpretation? We're talking here about its denotation,
not what is said about the thing it supposedly denotes.

Even if a reasoner detects a contradiction in statements about B
it can't know whether (a) there is overloading and in fact the
statements may in fact not be contradictory but about different
resources, or (b) the intended interpretation for B in all 
statements is the same and there is in fact a contradiction. 
This is reflected in the two use cases above.

The only reasonable choice, IMO, is to *presume* that B has a globally
consistent interpretation and deal with the assertions "at face value"
so to speak.

I don't see *how* a given reasoner could detect much less deal
with multiple interpretations of a URI since the machinery for
defining the URI to resource mapping is below the atomic level
for the reasoner and it must accept all URIs as atomic primitives.

It may simply be that I am just woefully ignorant of such things
and that such determinations are child's play to a qualified
logician. If so, I'd would appreciate being set straight.

> >It seems clear that we don't know enough to completely specify this 
> >interpretation, but on the other hand there are demonstrably a 
> >useful number of things we do agree on for it to be of some 
> >practical use.
> 
> The current MT semantic framework expresses this perfectly. There are 
> a number of things we agree on.  Express those things somehow, and 
> they amount to some assertions which we both can agree to accept as 
> true. We have a "common ground", and we have agreed to limit the 
> interpretations to those that keep it true. The practical use arises 
> right here: we are both able to draw the same conclusions.  

Hmmm... you seem to be expressing here the point I've been trying to
make, that while the MT might allow for multiple interpretations,
the SW Architecture nevertheless purports a presumption that there
is a single interpretation shared by all SW agents, for the purpose
of consistent interchange of knowledge.

No?

> This is 
> how most communication works, maybe ALL communication, in fact.  But 
> we don't need to have so much agreement that between us that we have 
> managed to pin down a SINGLE interpretation. If we did need to do 
> that it would get in the damn way, we would be always arguing over 
> *exactly* what one another meant (just like we do on these mailing 
> lists, but all the time about everything) , we wouldnt be able to 
> move until we were SURE that the thing you were referring to was 
> EXACTLY what I was referring to, and so on. 

Well, we certainly would be able to move, even if we were not sure
if we agreed on our interpretations -- as our SW agents would presume
that we did, and if we seemed to be arriving at different conclusions,
or the conclusions we were arriving out did not reflect our view of
reality, then we would have to consider that we were not in agreement
and take steps to rectify the situation. That's how communication on
the SW will work. We presume we mean the same thing when we all use
the same URI, until and unless stuff blows up. Then, someone will have
to probably start using some other URI than the one they were using.

So even if we can formally prove agreement of interpretation, we *can*
specify as part of the SW architecture that SW agents may *presume*
that such agreement exists, and proceed accordingly.

Cheers,

Patrick

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

Received on Tuesday, 29 April 2003 03:54:50 UTC