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

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.

> 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.

>> On the other hand, ambiguity about what a URI denotes is a Bad Thing, 
>> as
>> the TAG has stated[3].  To prevent ambiguity, it is necessary to 
>> either
> use
>> "different names"[4] or "different context"[5].
> This is your assertion. By 'different names' if you mean that different
> constants may have different values, then this is certainly true.
>> These observations have helped me (at least) mentally reconcile the
>> positions that I think I've heard on the httpRange-14 issue[6], so I'm
>> hoping they will help others.  Tim Berners-Lee describes[6] the issue
> using
>> an example in which a URL is used to identify an actual car, but the
>> document instance that can be retrieved from that URL is a picture of 
>> the
> car:
> 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 
the OWL spec but not the URI spec.

>>> 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.

The RDF spec and the URI spec very properly address
the independent parts of the system independently. These parts are the
logic of the ontology system and the engineering of the web.
But they meet at the URI and must use it consistently.

cwm is a system which is specifically designed to prototype
this whole idea and make sure it works.  It uses both
a (very simple, forward chaining) reasoner and a (pretty basic)
web engine -- what Roy calls "libwww".

It introduces RDF properties for the "level breakers" - the things
which let you connect the levels.  Things which mess up the purity of
each side but allow the whole to be built.

A log:uri B     , for example, means  the string b is the URI of 
resource A.

A log:semantics B  means that B is the RDF triple set  which can
  be obtained by looking up the resource A on the web.  Its domain is
  Conceptual Work  (doc:Work) and its range is N3 formula (log:Formula).

These functions are built-in. The  log:semantics is calculated 
for resources whose URI starts with "http:" and happen to be available 
the web at the time.

If you like, it is as though there is an axiom

{ ?x log:uri ?u.  ?u  string:match "^http://[^#]$" } => { ?x rdf:type 
doc:Work }.

(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.

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.

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.

> 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 
> 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?
When connected, they are very powerful.

> 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 
connected together.   Each side does need to be aware of the other,
through, and preserve the interface.  I hoped I have explained the 
is important when you build the whole thing.

Tim BL

> Jonathan

cwm linked from

@prefix log: <>.
@prefix string: <>.
@prefix doc: <>.

Received on Friday, 24 January 2003 09:23:22 UTC