Re: KR, meet WWW. was: Clarifying what a URL identifies (Four Uses of a URL)

Tim Berners-Lee wrote:

> On Thursday, Jan 23, 2003, at 21:49 US/Eastern, Jonathan Borden wrote:
> > [..]
> > It is not accepted practice to consider a URI to identify 4 things.
> I agree.  David Booth was using the term "identify" loosely and
> if he uses Larry's "indicates" term for thee of them then he won't
> seem to be upsetting the applecart to the same extent.

Certainly, of course this discussion is not one to use loose terms in, as
many people already seem to have different ideas about what a URI may or may
not identify.

If we want to use 'indicates' I also totally agree that this is akin to an
RDF property value relationship e.g.

<> log:uri "" .

so the relationship URI _identifies_ a resource is the same as URI _labels_
a resource (This should necessarily be a 1:1 relationship) whereas a URI may
have many properties. Now if we consider log:uri to be a property whose
rdfs:range is a string, it can also be considered an owl:FunctionalProperty

on the other hand if we consider the relationship between a URI and a
document obtained by dereferencing the URI, there may be many such documents
(varying with time and request properties) and this relationship is not a
functional property.

The point I am trying to make, and will continue below, is that OWL is an
excellent mechanism to describe the relationship between URIs and things
related somehow to URIs i.e. their name, types of resources, types of
representations etc.

> > If we
> > are considering the Semantic Web, the RDF model theory
> > is reasonably precise in stating
> > how URIs
> > are used in RDF -- at least in the formal definition of RDF as
> > captured by
> > the model theoretic semantics. Read this paragraph: "There are several
> > aspects of meaning in RDF which are ignored by this semantics; in
> > particular, it treats URI references as simple names..."
> >
> > What this says is that a URI *is* a simple name, *not* that a URI
> > denotes a
> > simple name. A URI is a simple name. The name is treated as a logical
> > constant in the same fashion that when you might say
> >
> > x = 1
> > xx = 2
> >
> Yes, exactly.    The other thing the RDF spec does is to call out the
> spec, indicating that the x used by RDF identifies the same thing as
> the x
> as is identified by the URI specifications.  This is what makes
> OWL+RDF a semantic web language as opposed to just a KR language.

Yes, although the formal interface between RDF + OWL and the URI spec needs
a bit of work. Both RDF and OWL are formally specified by model theoretic
semantics, but URIs are not and so we get lots of imprecision in properly
stating what we intend URIs to mean.

> >
> > TimBL's issue is well known, yet I've not seen a concrete example
> > where this
> > is a real issue for something like an OWL reasoner (as a concrete
> > example of
> > 'Semantic Web' software).
> >
> That is because the OWL reasoners  you have used have only
> implemented part of the semantic web functionality. They have
> implemented
> the OWL spec but not the URI spec.

And how is the URI spec to be implemented? This is the crux of the problem.
If the URI spec had a formal semantics then we wouldn't have so much leeway
in arguing about how it is intended to be interpreted. Indeed there are a
number of folks who intend the relationship of a URI to resource be many to
many! Now I say 1:1 and if the spec doesn't at the very least constrain this
relationship then people seem to be free to interpret it in any way they
please. Perhaps that is why these arguments appear never ending.

> >>
> >>> The issue only arises when, in the semantic web, [. . .] we ask
> >>> ourselves
> >>> what exactly is the thing we should say is identified by some http
> >>> URI -
> >>> the picture of the car, or the car? [. . .] I want to use the URI to
> >>> identify the picture. Roy has always felt it identifies the car.
> >
> > Shrug, shrug, shrug. I can say:
> >
> > #foo a #Car .
> > #foo a #Picture
> >
> > #Car owl:disjointWith #Picture
> >
> > and I have a contradiction, so what?
> >
> Well, of course most reasoners either stop with an error at that
> point, or allow you to prove anything. So "so what" means that
> you don't care? Or it means that you don't expect to find yourself
> in that situation?  A system which allows you to deduce a
> contradiction from its axioms isn't much use.

No, what I mean is that using such assertions we can remove any ambiguity
about what the range of a URI is. Indeed if I assert:

<> rdf:type myOnt:Car .

then I know that this URIref identifies a "Car". Just so,

<> rdf:type myOnt:Car .

asserts that URI to identify a "Car" -- there is no ambiguity. Indeed if
later there is some other assertion which asserts that the URI identifies a
"Web Page", we know there is a problem because we've said that "Car"s and
"Web Page"s are owl:disjointWith. So what is the _problem_ in having such
URIs identify things that aren't web pages? The system will quite easily
pick up a contradiction if anyone gets confused about what the URI is
intended to identify.

> If you like, it is as though there is an axiom
> { ?x log:uri ?u.  ?u  string:match "^http://[^#]$" } => { ?x rdf:type
> doc:Work }.

Right, but suppose this axiom isn't present. My OWL reasoners still work
fine. Why do I _need_ this?

> (where string:match is a regexp matcher)
> This axioms comes from the URI spec and the specs it references.
> Any semantic web engine can conclude it.  It is not authorized
> by the OWL spec, it is authorized by the URI spec.

Err, that is the crux of the argument. You assert that the URI spec makes
this an axiom. Roy and others assert that this is _not_ an axiom. The URI
spec is not apparently written crisply enough to us to definatively
determine whether or not this is _necessarily_ an axiom.

> This means that any use of such a URI to identify a car will
> indeed lead automatically to a contradiction the moment the
> ontologies are available and the power is turned on.

Only if your formula is present. If the formula is not present then there is
no contradiction, and I see no problem that will _necessarily_ arise from
its absense. If you can show me a problem (specifically one that will arise
when using an OWL reasoner) when this formula is not present then I would
agree it is needed, but so far I remain unconvinced -- I am also stating in
a very precise fashion what will convince me otherwise.

> If you want to see an example in which this sort of
> thing is used, look at
> in which an inference engine makes a trust decision based on
> the information in various signed documents.
> There are lots of much simpler examples, where
> a rule looks inside a document to check whether
> is says soemthing.
> KR, this is WWW. WWW, this KR.
> Or more strictly, OWL, this is URI. URI, this is OWL.
> Neither an owl reasoner nor libwww has the whole story.

Except that Roy Fielding argues against this interpretation of libwww -- so
now I have 2 extremely credible people telling me different things, this
makes my reasoner spot a contradiction.
> > The TAG might decide something, for sure. On the other hand there is
> > the RDF
> > model theory/semantics and the upcoming OWL model theory/semantics
> > which
> > define a reasonably precise way for processing documents (ontologies
> > and
> > knowledge bases) that contain URIs. There is software that implements
> > OWL
> > reasoners. It works. I see ***no problem here***
> Indeed, Roy sees no problem when he just implements a libwww.
> Do you see the problem now, though, when they are connected?

This is what I am missing. I am missing the problem that occurs when they
are connected. I am really trying to see it, but I just don't get it.

> When connected, they are very powerful.

Oh yes. I agree wholeheartedly.

> > I really wish folks would stop pointing to the "Semantic Web" as
> > evidence
> > that there exists some deep problem with URI ambiguity, because the
> > "Semantic Web" as incarnated by working software that implements the
> > upcoming sets of working drafts, actually works.
> Alas, each half works when tested separately!  And in fact they work
> when
> connected together.   Each side does need to be aware of the other,
> through, and preserve the interface.  I hoped I have explained the
> problem
> is important when you build the whole thing.

Perhaps we are getting close. What we are trying to do with owl:imports is
essentially a description of log:semantics as far as I can tell. Now clearly
I would use a URI-without-the-# to identify an owl:Ontology. I would also
use a URI-reference-with-the-# to identify an owl:Class (although this is
just so I can use rdf:ID to name it, I can also use rdf:about to describe a
class labelled by a plain URI). I just don't grok the problem that would
occur if I used a URI-without-the-# to identify a :Car


Received on Friday, 24 January 2003 21:54:18 UTC