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

On Friday, Jan 24, 2003, at 21:31 US/Eastern, Jonathan Borden wrote:

> 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.
>
> <http://foo.org/bar> log:uri "http://foo.org/bar" .
>
> 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
> http://www.w3.org/TR/owl-ref/#FunctionalProperty-def
>
> 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
>>> http://www.w3.org/TR/rdf-mt/#intro 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
>> URI
>> 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.
>

It is true that there is no formal semantics for URIs in the URI spec
or the specs in invokes such as HTTP.

HOWEVER, it in not true that there is no spec.  The semantics ARE
specified they ARE a standard, and they are to a large part well 
understood.
You are right that there is work to be done in writing a formal
specification, and see Dan Connolly's mail for his work in that area
which does cover the ground but was pre-OWL.


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

It has been implemented a bunch of times.  It just hasn't been attached 
to OWL.


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

Well, I'm sorry, but the URI spec indicates a 1:1 relationship between
URI and "resource"  and the HTTP a one to many relationship between
"resource" and a representation of that resource.

Roy and I dispute where that HTTP resource fits in the ontology - for me
life is only really manageable if we say that is is the 
cyc:ConceptualWork,
which I equate with HTTP's  "network Information object".
But we agree -- and I thought the W3C TAG agreed - that a URI 
identifies on thing.


> 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:
>
> <http://example.org/foo#Car> rdf:type myOnt:Car .
>
> then I know that this URIref identifies a "Car". Just so,
>
> <http://example.org/Car> 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.

But it is. It is part of the definition of what a URI is.
Sorry, It is in the spec.  We can argue the details about the
ontology, but the fundamental fact is that the constraints
of the existing and future Internet specs which are
hooked indirectly in by the URI spec all apply to the
semantic web, to any OWL document.
That doesn't mean every system has to take them into
account, of course.  But if you use URIs in a way
inconsistent with the specs you will have data which
is inconsistent with the specs, in other words which is
in error.


> My OWL reasoners still work
> fine. Why do I _need_ this?

Because you communicate with other people.
The Web works because of a certian set of inftrastructure
definitions which everyone agrees to (see
http://www.w3.org/DesignIssues/Stack
) which are great enablers of communication.

"The unyielding medium's not only endured,
  It's that upon which art depends:
For who can perform on a tightrope secured
At only one of its ends?" - Piet Hein

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

Yes, we don't agree on the details. But we will! It is really important.


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

I agree completely that you can work with your owl reasoner.
Just as you can write messages to yourself using words
do mean different things than the dictionary uses.
I can write OWL documents in which I use owl:TransitiveProperty
to mean  owl:Class and vice-versa. It will work fine.

>>
>> If you want to see an example in which this sort of
>> thing is used, look at
>> http://www.w3.org/2000/10/swap/test/crypto
>> 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.

:) Aye... let me talk some more with young Fielding... :)

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

Indeed.  In my humble opinion,  whilst it is wonderful that the group
is thinking about something very close to log:semantics,
because it is really important. But it does belong in a different 
module.
If it is put into the same ontology as the rest of owl, posterity will 
wonder
why on earth it was.   The clean way do this is to make a module
which interfaces to the web. I imagine that that would have to have a 
concept
of formula, or quoted set of statements, which RDF doesn't have yet.

> 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

Then when you dereference it, you have information about the document.
You have a formula which is a representation of the car.

> Jonathan

Received on Tuesday, 28 January 2003 22:00:43 UTC