W3C home > Mailing lists > Public > www-tag@w3.org > July 2003

Re: New issue - Meaning of URIs in RDF documents

From: pat hayes <phayes@ihmc.us>
Date: Thu, 17 Jul 2003 15:45:41 -0500
Message-Id: <p06001227bb3c6748d2c3@[10.0.100.23]>
To: Tim Berners-Lee <timbl@w3.org>
Cc: www-tag@w3.org
>On Wednesday, Jul 16, 2003, at 12:56 US/Eastern, pat hayes wrote:
>
>>There are several statements made in the following proposal which 
>>should not be made by any WG. To make authoritative assertions of 
>>propositions which are clearly or provably false does not make them 
>>true; it only destroys public trust in the source making the silly 
>>assertions.
>
>I don't know whether these things are easily done in email in 
>www-tag, as the misunderstandings are often about use of words, and 
>so if endeavour to use yours, we may find other people get other 
>misunderstandings.

Fair enough, and BTW I apologize for the acerbic tone of my email, 
written in a hurry with a headache.

>Note I was using english, not model theory.  You use MT words, but 
>it may be that MT can't express the english talking about for 
>example the real world.

I was also using english. You know, model theory is only semantics 
done mathematically. But you ought not to confuse the manner of its 
being done with the substance: semantic analysis applies to english 
just as well as to formal languages. Its more complicated because the 
language is more complicated, but the essentials are the same. 
Tarski, Quine and Montague all describe model theories in terms of 
the truth of English (or German) sentences. So although its true my 
points are made as it were from the perspective of formal semantics, 
I am still talking about natural language; just as an engineer might 
use mathematical language to talk about the stresses in a bridge: the 
use of mathematics doesnt make the bridge unreal.

>
>>1. " each URI
>>identify one thing ("Resource": concept, etc)."
>>
>>Exactly what is meant by "identify" here is not exactly clear, but 
>>if this means something  close to what it usually means then it is 
>>simply untenable to claim that all names identify one thing.
>
>I am making the claim only for RDF statements in a global context, 
>in for example an email sent between two people who don't know each 
>other but both access to the web.

So am I: and I insist that this stipulation of identifying one thing 
isn't sensible or even desireable. Well, at least, unless that word 
"identify" means something different from "refer to" or "name" or 
"denote" .  What might indeed be true is that in many circumstances, 
a URI somehow provides access to information which is sufficient to 
enable someone or something to uniquely identify a particular thing 
(that the representation accessed via that URI is in some sense 
about), but even there the thing identified might vary between 
contexts (such as when we use someones email address to refer to the 
person) without harm. This kind of ambiguity resolved by context is 
at the very basis of human communication: it works in human life, it 
works on the Web, it will work on the semantic Web. Why do you want 
to try to legislate it out of existence? You will not be able to, any 
more than you will be able to stop people falling in love.  All that 
your 'ideal design' will accomplish is to make the architectural 
pronouncements of the W3C more and more out of line with the way that 
the Web is actually being used by real people.

Take your example of person A emailing person B, who A does not know. 
What is actually going on here, described precisely, is surely that A 
knows that 'B@Bsplace.org' is a character string which when used in a 
certain way will  (by some occult technical means about which A need 
know very little) act as an address, so that email sent to that 
address will arrive in the inbox of, and likely be read by, someone 
called 'B'.  I phrase it thus because it might be potentially 
misleading to just say 'read by B' since that could be understood as 
saying that A knows the referent of that name 'B'; but we are 
assuming that A doesn't. So what A knows is in fact an existential: 
that a person called 'B' *exists* who will get the email.  Since A 
knows that the email exists and is unique - A has direct acquaintance 
with the email, having written it - this is enough for A to know that 
there is a single person out there who will get the email.  But it is 
still misleading to say that the email address "identifies" B: if 
that really were true, then A could find out who B was just by 
looking at the email address.

>And I am describing, if you like, a perfect platonic design, to 
>which we can aspire, though social and engineering factors limit our 
>ability to implement it perfectly.

Allowing - no, admitting the existence of - referential ambiguity is 
not an imperfection: it is a basic property of communications of 
belief using language, one that is recognized and even described 
quite well (to a first approximation) by the model theory that you 
dismiss.

>Like with all technical specs, the fact of imperfect adherence in 
>some cases does not detract from the importance of having made the 
>perfect idealistic design which has provable properties. One deals 
>with deviations from the perfect in a form of perturbation theory.

We seem to be at cross purposes. Im not saying that the 'unique 
identification' condition is an unattainable ideal: Im saying that it 
doesn't make sense, that it isn't true, and that it could not 
possibly be true. Im saying that it is *crazy*.

>
>>  Existing W3C standards already provide counterexamples: what 
>>single thing is identified by the URI reference 
>>http://www.w3.org/2000/01/rdf-schema#Class? This is supposed to 
>>*denote* the class of all RDFS classes; but that is not a single 
>>well-defined notion, by the very nature of formal semantics: it 
>>varies from interpretation to interpretation.
>
>You say "by the very nature of formal semantics".  The formal 
>systems we are using are not capable of defining such a thing?  This 
>is in fact true, as the logics like OWL light  which we like to use 
>can't handle classes of classes being classes.  So maybe we have a 
>single thing, imperfectly (from your point of view) defined.

Actually I didn't use the word 'defined'.

>
>And there is the problem that MT systems consider all possible 
>interpretations of the data, in any possible worlds.

That is not a PROBLEM; it is how semantics works. When you 
communicate something to me, you send me some language (or more 
generally some representations). I have to try to interpret this 
language and make of it what I can.  But you cannot POSSIBLY send me 
a single interpretation: interpretations are not the kind of thing 
that can get communicated. Only language gets communicated. So yes, 
OF COURSE there are many possible interpretations of what you say, 
even when I have used all my resources of interpretation. This isn't 
a problem of the theory, it is a FACT ABOUT COMMUNICATION which the 
theory recognizes and tries - in admittedly a crude way, but we have 
to start somewhere - to deal with and come to terms with.

>  If you take the  case of an identifier for  pat hayes 
><phayes@ihmc.us>, for example, the non-logician would consider that 
>it identified one person and get on with their lives

The logician can say that also: it is the assertion that a single 
person exists who has that name. But (1) that is not the same as 
saying that the name - all by itself - "identifies" a single person 
(or, well, maybe it is: but if so, then other things said about URIs 
and resources are wrong) and (2) in fact, they don't assume that and 
get on with their lives. Sometimes they assume it indicates a person, 
sometimes a mailbox, sometimes a computer: it depends on the context. 
Which is fine, let me quickly add, provided some 
bull-in-the-china-shop authority doesnt keep insisting that all URIs 
must by fiat always identify a single resource. Then we get 
interminable arguments and discussions about what 'the' resource is 
in this very case, and the people who are insisting on this doctrine 
so firmly tend to be the ones who get exasperated earliest and tell 
us that it doesnt really matter what the "resource" actually *is*; 
apparently missing the irony of the fact that the only reason we are 
having this argument is because of this insane ruling that they are 
so insistent upon not budging from. Grrrr.

>, whereas in MT one would consider all possible interpretations of 
>all the data one had in store and consider the possible things the 
>identifier might denote in each in interpretation. And that would be 
>an essential exercise, and could be useful when looking at phrases 
>about Pat in quoted material (She thought "Pat Hayes was a pirate of 
>the early seventeenth century"), etc.  But these excercise blur the 
>usefulness of being able to use a URI to refer to a person in our 
>day to day communication.

Not, they make it more precise. They actually help to *explain* why 
names work in day to day communication in the way that they do.

>So, there is no "single, well-defined" thing denoted by rdfs:Class? 
>I didn't say it was well defined, by your definition of well 
>defined. However, the goal is to be single, in some sense.

So it can be ill-defined, as long as it is single? OK, that's easy. 
Take the set of all the things that anyone might want a URI to mean, 
and for each such set invent something called an 'exemplar' of the 
URI. For example, an exemplar of an email address might correspond to 
a set containing a person or persons, an email inbox, a set of email 
messages (the log of the emails sent to and from) and a computer 
email client, say.  The URI identifies the exemplar, which is unique, 
by fiat. What that means, of course, isn't well-defined, because 
there is more than one thing in the set: but that is OK, right?

  BTW, if you feel that this notion of exemplar is a bit too etherial, 
you can use the set itself as the exemplar, and then it is but a 
short step to doing some formal semantics.

>That is, as we add information about it, that information should not 
>be inconsistent.

Right. MT helps you there by providing a crisp notion of consistency. 
It also gives you an important insight: if you know enough to 
uniquely identify the referent of a name, then *any* further 
information is either redundant or inconsistent. Basically, this 
follows from the observation that the only proper subset of a 
singleton set is the empty set.

>You can thing of it denoting different things in different systems, 
>but how are those things "different" apart from the fact they are in 
>different systems?

Well, how are they the same? That is, what gives us a licence to 
claim that rdfs:Class and owl:Class, for example, are the same class? 
(In fact, there is a good reason in this case to say they are not the 
same.) Maybe you have a more direct acquaintance with abstractions 
like the class of all classes than I do, but I sure wouldn't know how 
to decide things like this in general, and I *know* that no 
computable decision procedure could decide it for me.

>  We say and every owl:class is an rdfs:Class. That allows us to 
>deduce things about some classes. Suppose we make other assertions 
>about rdfs:classes, is it allowable for us to be able to make a 
>contradiction? I would say not.  Currently, different logical 
>systems can deduce different things, but the important point is that 
>they are talking about the same thing when they use the same URI.

You need to be careful what you mean by 'same thing'. Sure, if 
reasoner A uses 'rdfs:Class' and reasoner B uses the same URI, then 
they ought to both be using the name in the same way, so that they 
can communicate.  Nobody is disagreeing with that.  But that is not 
the same as saying that there must be a single thing that this URI is 
naming.  Analogy: if we hold hands then we are walking the same way. 
But that does not mean there is only one way we can possibly walk. I 
think you mean the former, but you are saying the latter.

>The OWL pat hayes and the OWL light Pat Hayes are in different 
>worlds from the point of view of logic,

No, Pat Hayes is in the actual world; I can personally attest to 
that. OWL and OWL lite are ways of describing that world; but like 
all other ways of describing it, they are imperfect: they allow other 
interpretations.  In some of those other interpretations "Pat Hayes" 
might denote, say,  the lead singer in a rock band, or a sprinter, or 
a distinguished public figure in Austin, Texas, or a caterpillar. 
I'm not saying that different languages describe different worlds: 
I'm saying that *all* languages describe the world only partially, 
which is just another way of saying that they have other 
interpretations.

>  but we are using
>
>>Perhaps 'identify' doesn't mean 'denote' or 'refer to'. What does 
>>it mean, then? Note that if we were to say that 'identify' means 
>>MORE than simply 'denote' or 'refer to' - if, say, it also has a 
>>connotation that the URI can be somehow used to retrieve some 
>>information about the referent - then the claim would become even 
>>more false.
>>
>
>Well, you can't be more false than false, can you? :)  Eh, but I 
>wouldn't put it past you ;-)

I do my best.

>
>When one retrieves a document, one gets information which its 
>publisher says, and one can believe or not.  But using a term does 
>(modulo social things such as fraud and engineering things such as 
>broken cables) commit you to the term owner's definition of it, and 
>the document they publish at its URI is taken by design to be 
>information deemed shared by those using the term.  That's the 
>contract.

Im happy with that contract, though with a slight hair-tingle at the 
use of the word 'definition'. But nothing in there says that URIs 
must uniquely identify resources: in fact, you didn't even use the 
words "resource" or "identify" , which I am very happy to see were 
also missing from Tim Bray's down-to-the-wire summary of the 
essential core of things.

>If you don't like it, don't use too many terms.
>
>>See 6 below also.
>>
>>2."  An RDF statement "S P O" means that a given binary relation
>>identified by P holds between to things identified by S and O. (S, P
>>and O are URIs)"
>>
>>This would be true if "identified" meant "denoted"; but then it 
>>should, if stated strictly, have the qualification "in a given 
>>interpretation", illustrating the reason why the first claim is 
>>false.
>>
>>3. " The OWL specification is a vocabulary of properties allowing an RDF
>>document to say things about RDF Properties"
>>
>>First, OWL is more than an RDF vocabulary: it is an RDF vocabulary 
>>with a particular semantics applied to it.
>
>Like every RDF vocabulary.  What is interesting about OWL is that 
>for some of the vocabulary the properties of the Properties can be 
>defined in math.  But basically OWL isn't any different from the 
>calendar event vocabulary.  The only reason that an RDF calendar 
>event has meaning is the semantics of that vocabulary.

As you know, I disagree profoundly with you on this issue. The 
semantics of an calendar event described in RDF is given by the RDF 
vocabulary. It is axiomatized in RDF. You can write as much as you 
like about it and what you think it ought to mean: all that is merely 
commentary and does not change the meaning *of the RDF* one iota. 
That follows from the RDF specs themselves.

>
>(For you, this may seem perturbing or to say that the logic itself, 
>the thing you tend to define first, is actually only defined in the 
>data language. But it works.

No, it doesn't, which is why I insist on my point.

>You end up where you wanted to be, with OWL and its semantics, I'm 
>just explaiing to you how, from RDF's point of view, you got there.)
>
>>It is the semantics which allows the document (strictly, the RDF 
>>graph) to make nontrivial assertions, most of which cannot be made 
>>in RDF;
>
>Excuse me you *are* making them in RDF.

You are using RDF syntax to make them - a fact which as you know has 
been the cause of enormous problems and will continue to be - but you 
are not making them in RDF as you are not using the RDF semantics. If 
you use OWL-Full you are in an RDF semantic extension, but a semantic 
extension is not RDF itself. I know this is right, by the way, 
because I can *prove* it.

>By "make non-trivial assertions" you mean "make assertions which 
>actually mean something".  It is indeed true that the assertions 
>only have meaning because of the semantics associated with the OWL 
>vocabulary.  What is misleading is if you fondly image that *other* 
>people's vocabularies are different, and have no meaning.  OWL is 
>wonderful, but not special. To RDF.

Of course, an RDF vocabulary may be assigned any meaning whatsoever 
by some other spec: any set of strings can be assigned any meaning 
whatsoever. If this is all you mean, then I concede the point but 
observe that it is vacuous, and adding the codicil "in RDF" is 
misleading, since now this means nothing at all.

>>so it is the OWL document making the assertions, not the RDF 
>>document (true, an OWL document can be described as an RDF document 
>>with an OWL semantics, but it is misleading to use the syntactic 
>>criterion when we use phrases like "say things about".)
>
>In the big wide world, an OWL document is, at base an RDF document 
>and only an RDF document.

Think again. Many OWL processors are likely to begin by completely 
eliminating all traces of RDF, and only using it for output as a 
dialect of XML. But in any case, surely you would agree that any 
reasonable person - not just "a logician" - would not, on looking at 
the OWL specs, conclude that an OWL document is at base only an RDF 
document.

>  It only has its semantics because of the OWL semantics, and the OWL 
>semantics only apply because the owners of the vocabulary have 
>defined those semantics, and made it clear (by publication of 
>specifications, and increasingly with machine-readable stuff 
>accessible from the URIs concerned) what those semantics are.
>
>>Second, it is misleading to claim that the assertions made in an 
>>OWL document are about RDF properties. They may be: but they may 
>>also be about classes or individuals (ie anything); in most cases 
>>it will be impossible to say what particular thing they are 
>>'about'. (The use of this phraaseology, by the way, is odd: most 
>>texts in most languages, formal or informal, cannot be said to be 
>>'about' any one thing.)
>
>For and RDF statement, there is a clear subject, and we say that the 
>statement is (loosely) about the subject, (or the referent of the 
>subject, depending on the way you use "subject", which nitpick we 
>nee not get into now.)
>
>Absolutely true. Many OWL statements are about classes, for example.

OK, you can always say that a triple is 'about' its subject, true. 
Now, consider a document with, say, 1000 triples, not all with the 
same subject. What is the document 'about'? What if some of those 
triples have blank nodes as their subjects?

>
>>4.  "The combination of these architectural parts allows information to be
>>published so that the recipient of an RDF statement  "S P O" can, by
>>dereferencing P, get information about the relation being asserted. "
>>
>>Wrong. First, there is no particular semantic importance attached 
>>to the P part of the triple.
>
>Excuse me.  p is associated with the relation.  I had understood 
>that the semantics of s p o were the relation R(s,o) where R is 
>identified by p.
>Did I get it the wrong way around?

No.

OK, I see what you meant.  My point was that the meaning of the 
triple depends kind of equally on all three of its parts: the 
property has  no particular semantic priority.

>
>
>>  Properties have no special status in RDF. Second, the relation is 
>>not being asserted: the triple is.
>
>Wordmongery. Fie on you.   The fact that the relation holds, or that 
>a statement of the relation is true is being asserted?  The 
>semantics of the triple are consistent only with  interpretations in 
>which the relationship corresponding to p holds between the 
>resources corresponding to s and o.
>
>>Third, there is no particular reason why dereferencing P will get 
>>you to the information you might require in order to draw the 
>>appropriate conclusions; and indeed most RDF applications would not 
>>work if this were an architectural requirement.
>
>No one said "will"  and no one said "require".
>(You are arguing by exaggeration of claim.)
>IF a representation of a document is retrieved the there is an 
>argument that you MAY use it.
>There is no argument that you MUST.

OK, I mis-read your claim here. Sorry.

>
>>Finally, this conclusion does not follow from the architectural 
>>points made previously.
>
>It obviously does.
>;-)

Well, no, I don't see that it does. Why would this follow from the 
earlier stuff in the message? The property URI is required to 
identify a unique resource, which I would presume would be the 
property itself (needed for the semantics to work); so how can it 
also identify a document?

>>5. "This information, directly or indirectly acquired, may be
>>human-readable and/or machine readable, the latter including for
>>example ontological statements in OWL, or rules, or other logical
>>expressions."
>>
>>This is an extremely contentious and potentially confusing claim. 
>>It is *impossible* for software agents to respond to or utilize 
>>"information" which is only human-readable: it must be 
>>machine-readable.
>
>However, it is possible for human agents to us that information. 
>Classically what happens is that a human looks up the document, gets 
>the hang of what is happening, and writes software which processed 
>information correctly.  This is the way most OWL software is 
>written:  by humans reading the spec.

This is information about the meaning of a particular relation in a 
particular OWL triple, right? So the SW is going to work by people 
finding OWL triples, dereferencing the URIs in them, reading the 
specs they find and then writing software to read the OWL? Seems kind 
of slow to me.  And I presume you know that this isn't in fact how 
the current W3C URIs work:

http://www.w3.org/2002/07/owl gets you a file of RDFS  (unreadable by 
most browsers because it has OWL as its document type)
http://www.w3.org/1999/02/22-rdf-syntax-ns gets you a page of RDFS in XML
http://www.w3.org/2000/01/rdf-schema gets you a similar page of RDFS in XML

None of them even have a URL chain which ends at the spec documents. 
Like with most documents, you have to search for them in order to 
find them: you don't find them by dereferencing the URIs in the 
triples.

>Machine-readable information about vocabularies is fairly limited. 
>With RDFS, there is not much one can say, though what one can say is 
>useful. With OWL, there is more.
>
>
>>So to lump these categories under the single heading of 
>>'information' is an architectural disaster, if 'recipient' in the 
>>previous sentence is supposed to refer to an architectural element 
>>(such as an agent of some kind). This point is not new, of course: 
>>it has been made already in many intense discussions and debates, 
>>many of them archived.
>
>There are indeed as many people (like Tim Bray) arguing that the 
>most important thing is human-readable information as there are 
>people (like you) who really can't see the point of it and only 
>think of automated agents.

Oh, I can see the *point* of it, being human myself. But if we are 
going to talk about putting agents on the Web, then we had better be 
clear about what counts as information that they can use, is all I 
mean.  After all, this decision has *architectural* consequences. 
Also, I note that Tim Bray is quite open about the fact that he isn't 
talking about the semantic web and doesn't consider it an important 
part of the actual web.

>  But lumping it together in fact is useful

I fail to see how.  Distinguishing them more carefully would be a lot 
more use even in informal discussions: and lumping them together is 
actively harmful to clarity and software design issues.

>, particularly as much information be in both camps, such as when I 
>read an OWL ontology myself.

Even then, if a reader fails to keep the categories distinct, they 
might get a completely wrong idea of what the OWL will do, or how 
best to write OWL or to use it.

>>6. "-  the architecture is that a single meaning is given to each URI "
>>and
>>"- the architecture does not permit the meaning of a URI to be changes
>>by consistent misuse by others"
>>
>>These are IMPOSSIBLE architectural requirements
>
>Just as the architectural requirement that for any link with href=x 
>there exists a document web(x).

No, more impossible than that. I don't mean just impractical to 
engineer it this way, I mean it is *logically incoherent* to ask for 
this.

>>There are no precise theories of meaning which make such statements 
>>other than fatuous (except when we are talking about programming 
>>languages: but the universe as whole does not satisfy the second 
>>recursion theorem.)
>
>We will always be a challenge for those of you who make these 
>precice theories.

Well, those who build the software and write the specs have to be 
somewhat precise.

>>  There isn't a 'single meaning' for the addition sign, or the 
>>multiplication sign;
>
>Exactly not.  These are NOT URIs. They are overloaded rather short symbols.

YOu missed my point, I think. It would be trivial to provide a URI 
for addition, such as 'mathsym:plus'. The point is that if there were 
ever a symbol that was thought to have a single clear unique globally 
fixed meaning, addition on the natural numbers might be a good 
candidate. Anyone up to around 1930 would have said that it had a 
single fixed meaning.  Mathematicians said it was given by God, and 
they were only partly joking.  But since Goedel, that position has 
been trickier to maintain. If we now understand that even the 
primitives of integer arithmetic are in a sense ambiguous, surely it 
is silly to try to make things like URIs be unambiguous. And besides, 
where is the justification for this claim? What is it about the Web 
that gives it this superhuman power to fix the single referent of all 
names, when we know that the entire resources of every human mind are 
not sufficient to lock down the meaning of 2+2=4 that securely? After 
all, wonderful as it is and all, the Web is just a load of old RAM, 
optical fiber and video screens. How does *that* anchor meanings more 
securely than they could have been anchored before?

>  It is maybe from working with these, and with the well-known and 
>quite non-URI-like properties of natural language words,  that you 
>may have become blind to the advantages of an architecture where we 
>say "This system is different from natural languge: we design it 
>such that each URI identifes  (doenotes?) one and only one concrete 
>thing in the real world or one and only one globally shared concept".

You can say that until you are blue in the face, but that doesn't 
make it true.  It seems to me to be obviously false of the current 
Web, which gets along just fine without this assumption.  It isn't 
designed that way right now: it never was.  And as far as I can see, 
every time this claim has been challenged, it has dissolved into 
meaninglessness.

For the advantages of having unique global identifying names - "true 
names" - by the way, read the Ursula LeGuin "Earthsea" novels. I am 
not blind to the advantages, but I can see the impossibility.

>
>>and the 'not changed by others' condition is either clearly false 
>>(in some views of 'social meaning') or completely irrelevant (on 
>>referential theories of meaning); either way, it isnt much use 
>>insisting on it as an architectural condition.
>
>Pat, we are not analyzing a world, we are building it.

Maybe this is the essential difference. If you think you are building 
a *world*, then I guess I should stop arguing with you.  Being an 
atheist, I won't offer to pray, but will just suggest that you might 
keep a weather eye out for rebel angels.

>We are not experimental philosophers, we are philosophical 
>engineers.  We declare "this is the protocol".

Making assertions about meaning isn't setting a protocol.  I used a 
URI ambiguously last month. What are you going to sue me for?

>When people break the protocol, we lament, sue, and so on. But they 
>tend to stick to it because we show that the system has very 
>interesting and useful properties.
>
>Example: The Internet mail "From:" field is defined to assert the 
>relationship between the message and the email mailbox of the sender 
>of the message. Spammers start to screw the system up by using it to 
>put in whatever will get through filters. The system slowly reacts 
>socially by putting them in jail for identity theft.  They said that 
>the "From" field meant whatever they said it meant, as senders of 
>the message. The Internet spec said it meant a particular thing. The 
>courts sided with the spec.

Good example. I note that the courts decided the matter, however, not the spec.

>>(FWIW, this seems to me to confuse meaning with intended meaning. 
>>Intended meanings, however, are not the kind of thing that one can 
>>impose *architectural* conditions on; they are more a matter for 
>>courts and priests to decide.)
>
>The architecture, if you like, defines an "authoritative" or 
>"definitive" meaning, to which "meaning" in wittgensteinian sense 
>and "intended menaing" in a ethical or legal sense generally 
>approach as closely as they can, and close enough for the system to 
>work and be unbelievably useful to millions of people.

Actually, I don't think the *architecture* defines any *meaning* at 
all.  I guess most of my naggling on this issue arises from seeing 
semantic judgements and maxims mixed up with architectural ones. The 
architecture is what it is and it works: no argument.  But the 
semantics seems to me to be both factually wrong and muddleheaded. 
Again, don't get me wrong: I *know* the Web is useful and it works. 
Im not complaining about the Web, only about what y'all *say* about 
it.

>>Having a definitive ontology does not provide a unique meaning, by the way.
>>
>>7. "The community needs
>>1) A concise statement of the above architectural elements from
>>different specs in one place, written in terms which the ontology
>>community will understand, with pointers to the relevant specifications."
>>
>>Maybe, if I could make the suggestion without seeming to commit 
>>lese-majesty, it would be a good strategy for the W3C, rather than 
>>trying to render nonsense "in terms that the ontology community 
>>will understand", to ask if it might possibly learn something from 
>>actually *listening* to the ontology community; or at any rate, to 
>>anyone with a grasp of basic 20th-century results in linguistic 
>>semantics.
>
>We are building a new system.  We can design it differently from 
>existing linguistic systems.  Toto, we are not in Kansas any more.

Yes, but we are still in a place where some basic principles apply. 
It is still the case that we need to transmit/communicate partial 
descriptions expressed as assertions, where there are limits on the 
amount of information we can transmit and hence on the ability of 
this information to constrain the possible interpretations. We still 
do not have magical names that somehow carry their referent on their 
sleeve (because such things are *impossible*).

Also, I tend to think that although you as it were gave birth to the 
Web, it now has a kind of life of its own: it is whatever the world 
makes it into.  We can write specs out the wazoo but if people want 
to do something more useful they will do it, whatever we say about 
it. The W3C has a very strong influence over how the Web will evolve, 
of course, but only because the world in general considers the W3C to 
be useful and authoritative.  Rather than dispose on how the Web 
*ought to* be, I would prefer to ask how it in fact *is*.  Do URIs 
uniquely specify globally unique things, for example, in fact? Would 
one come to this conclusion from observing the actual Web? Or is this 
a doctrine that must be preserved at all costs, if necessary 
manipulating the terminology and idealizing the empirical data in 
order to keep it true? (It seems to me that the world is quite happy 
right now with, for example, email addresses being somewhat sloppy in 
their meaning, in fact.)

We probably have to agree to disagree about the methodology. Still, 
it might be a good idea to distinguish between architectural 
principles which are required in order for the software to work, and 
matters of what one might call good Web behavior or proper style. We 
do this in email, for example: there are manuals about how to use 
email 'properly' (don't CC to lists unless you are a member, be 
careful about inclusions, how to use BCC to avoid long CC lists, all 
that good stuff) which are important, to be sure, but aren't really 
part of the *architecture* of the internet. I wouldn't be complaining 
if y'all were to say that people *should* use URIs in a way that is 
consistent with the principle that each URI *should* identify a 
single resource, and to encourage people to think about what kinds of 
resource they want their URIs to identify, and so forth. That would 
be a style manual for Good Web Behaviour. We might have some 
constructive and useful discussions about principles like that; like 
most moral/social rules, there would probably be exceptions made in 
exceptional circumstances.  But that is not the same as saying that 
this *must* be true, for *architectural* reasons. There are no 
exceptions to theorems or scientific laws.

>One of the things which previous forays into this area have 
>demonstrated is that listening is necessary on both sides.

Well, amen to that.

>Another is that when it happens, we can actually se eye to eye. And 
>another is that you are one of the better people at being able to 
>listen, figure out what it is we mean, and close the gap.

You know, it would be a lot easier to argue with you if you weren't 
always so damnably charming and polite.

Pat

>Tim
>
>
>>Pat Hayes
>>
>>--------------
>>
>>Resent-From: tag@w3.org From: Tim Berners-Lee < timbl@w3.org >
>>Date: Mon Jun 30, 2003  15:05:02 US/Eastern
>>To: tag@w3.org Subject: New issue - Meaning of URIs in RDF documents
>>
>>
>>The Semantic Web Coordination group at its meeting of 2003-06-30  and
>>passed on to the Tag the issue which had been loosely described in RDF
>>circles as "social meaning".  As background,
>>- The URI specification defines URI syntax and explains that each URI
>>identify one thing ("Resource": concept, etc).
>>- RDF documents use URIs as identifiers for things including for
>>relations. An RDF statement "S P O" means that a given binary relation
>>identified by P holds between to things identified by S and O. (S, P
>>and O are URIs)
>>- The HTTP specification provides for a set of URIs which have (a)
>>delegated ownership (b) publication and retrieval of information
>>resources.
>>- The OWL specification is a vocabulary of properties allowing an RDF
>>document to say things about RDF Properties
>>- The TAG has written on the desirability of using dereferencable URIs,
>>and of actually publishing relevant and useful information.
>>The combination of these architectural parts allows information to be
>>published so that the recipient of an RDF statement  "S P O" can, by
>>dereferencing P, get information about the relation being asserted.
>>This information, directly or indirectly acquired, may be
>>human-readable and/or machine readable, the latter including for
>>example ontological statements in OWL, or rules, or other logical
>>expressions.
>>The community needs
>>
>>1) A concise statement of the above architectural elements from
>>different specs in one place, written in terms which the ontology
>>community will understand, with pointers to the relevant specifications.
>>
>>
>>2) Some outline guidance on specific questions brought up in email
>>questions
>>- Is a given inference engine expected to take into account a given
>>document under given circumstances?
>>- how does one avoid having to commit to things one does not trust?
>>- etc etc etc
>>
>>3) There may be some need to clarify frequent misunderstandings by
>>making some things clear.
>>-  the architecture is that a single meaning is given to each URI (such
>>as P), that the URI ownership system makes statements by owners
>>authoritative weight, despite what other documents may say.
>>- the architecture does not permit the meaning of a URI to be changes
>>by consistent misuse by others.
>>- that use of a URI in RDF implies a commitment to its ontology, and if
>>there is doubt as to what ontology that is, the web may be used to
>>resolve it.
>>- that the web is not the final arbiter of meaning, because URI
>>ownership is primary, and the lookup system of HTTP is though important
>>secondary. (That is, if you hack a web server's ontology files, you do
>>not change hat the URI means, you just break a machine for a while)
>>- etc etc.
>>
>>The proposal is that a draft finding be written which pulls this
>>together, with elaborations pointing into the various specs. Members of
>>the SWCG have volunteered and some members of members of the SWCG have
>>been volunteered to read early versions.
>>tim bl
>>
>>--
>>
>>---------------------------------------------------------------------
>>IHMC      (850)434 8903 or (650)494 3973   home
>>40 South Alcaniz St.      (850)202 4416   office
>>Pensacola              (850)202 4440   fax
>>FL 32501                  (850)291 0667    cell
>>phayes@ihmc.us       http://www.ihmc.us/users/phayes


-- 
---------------------------------------------------------------------
IHMC	(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.	(850)202 4416   office
Pensacola			(850)202 4440   fax
FL 32501			(850)291 0667    cell
phayes@ihmc.us       http://www.ihmc.us/users/phayes
Received on Thursday, 17 July 2003 16:45:46 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:32:38 UTC