W3C home > Mailing lists > Public > public-sw-meaning@w3.org > April 2004

Re: How does RDF/OWL formalism relate to meanings?

From: Pat Hayes <phayes@ihmc.us>
Date: Tue, 6 Apr 2004 20:53:32 -0500
Message-Id: <p06001f1fbc98ff65cf82@[10.0.100.76]>
To: "John Black" <JohnBlack@deltek.com>
Cc: <public-sw-meaning@w3c.org>

>  > From: Pat Hayes [mailto:phayes@ihmc.us]
>>  Sent: Tuesday, April 06, 2004 1:22 PM
>>  To: John Black
>[snip]
>
>>  The entire business of
>>  handling formal ontologies and asking about their meaning is quite
>>  unlike the business of communication between speakers of a natural
>>  language. If its like anything, it would be more like a kind of
>>  primitive telepathy but between intellects about the size of a
>>  dormouse.
>
>>  Pat Hayes
>>
>
>I'm not getting this.  How do you use this formalism to make
>statements about particular things?

Good question.

>Does the formalism get
>involved here?  If I want to make assertions about my specific
>company and its employees, and have my assertions understood to
>refer to them and none other, how do I go about that?

Well, we need anchoring techniques for names. You can refer to me 
using my homepage or my email address or my SS number, and there are 
semi-formal but probably good-enough-in-practice conventions about 
owners of homepages and so on, and people use things like dc:creator 
and foaf:mail to relate things in ways that use one anchoring system 
to connect to another. But its harder for some things, of course, and 
you have to do it less directly. You could refer to my dad by saying 
he was my father: that gets him exactly even though he never had an 
email address or a SS number, given that fatherOf is an 
owl:inverseFunctionalProperty.

Old analogy: its like trying to attach a piece of fabric to a surface 
with a stapler.  You can't staple every stitch, but if you staple it 
reasonably often in enough places then the tension in the fabric 
itself will keep it close to the surface. How many staples you need 
depends on how hard the wind is blowing. The SW formalisms are all 
fabric.  What the SW itself can do is to make the fabric stiffer by 
supplying more ontologies relating anchored referential systems to 
one another, but the actual stapling requires something other than 
fabric.

But the direct answer to your question is that we don't really have a 
way to do that, actually, yet. Not a fixed, standard way. And IMO, 
until the TAG group gets its communal head out of the sand, or 
whereever it has it located,  we never will, because the TAG group 
thinks that URIs are already anchored to "resources" which they 
uniquely "identify", and so refuses to think about the fact that they 
aren't, and what to do about it.

>  Isn't it
>true that until an association is made between the URIs in a
>document and some real (or abstract) things, that the formalism
>is not about anything? except perhaps logical forms?

Well, its better to say that it is ambiguous what it is about. That 
is, *any* piece of OWL (or RDF, etc) constrains meanings to some 
extent, so the 'abstract' answer is that you get to the meaning you 
want when you say enough to constrain the possible meanings down 
close enough to your intended meaning. But to be honest, for 
referents of names, about the only way to do that is to relate the 
name somehow to a set of 'anchored' names that are understood to have 
fixed denotations. There are lots of these around, and I expect that 
the SW will evolve more of them as it needs them. Just as the 
geographers have come up with very precise coordinate systems in 
order to handle GPS data.

But look: does it really matter that a name in some sense REALLY 
denotes your company? Take an analogous case: does it matter that 
"37" denotes thirty-seven? In that case the answer is yes, because 
software actually performs arithmetic. So it really matters about the 
company name if software is going to do something with that name 
which actually involves your company, eg submit orders or move money 
between bank accounts or send reports to the IRS. So its here where 
the rubber meets the road where we may have to worry about correct 
reference seriously. And usually, it seems to me, in actual 
applications like this there are usually all kinds of anchoring 
systems to hand: bank routing numbers, registered names, IRS taxpayer 
numbers, things like that. This is how we humans do it, after all, 
when things really matter: we invent special anchoring codes. (Our 
own family names are a form of anchoring code, in fact: time was when 
people were named for where they lived or what they did for a 
living.)  So in practice this is not usually a problem, though 
admittedly it might be done in an ad-hocish way. As long as it is 
*possible* to do the anchoring, it will get done. All that RDF and 
OWL ask is that the anchoring points can be written as URirefs or 
literals, which seems to allow a wide range of options.

>  If I want
>to use RDF to assert that a particular employee is strong, not
>the English word but the concept of that property, how do I get
>a URI to serve as my sign for that concept and have it received
>that way so the final interpreter acts on the same concept?

Several answers. First, in a very tight sense of 'same concept' you 
can't: but that's OK, since you can't do that even in English. 
Second, in a better sense of 'same concept', you do it ultimately by 
somehow providing enough surrounding content to enable the recipient 
to draw whatever conclusions you want it to draw for the purpose in 
hand. This might be more or less depending on the task at hand, of 
course. If you want schedule a meeting, that's one thing: if you want 
to persuade the IRS auditor that it really was a *meeting*, then you 
might need to do more.  But basically, you need to transfer enough 
information to support enough inferences. In NL we rely on a huge set 
of information attached to words by native speakers (and even then it 
often goes wrong and needs corrections) and also implicitly on an 
extraordinary ability that all human speakers have to resolve 
ambiguity and use context. Software knows zilch and is dumb as dirt, 
so instead we have to actually convey the needed 'shared common 
knowledge' or whatever you call it in the form of explicit 
ontologies. Fortunately the global 'open' structure of the Web at 
least holds out the hope of a system of mutually used ontologies (and 
hence agreed-on, in effect, though its the mutual use that really 
matters)  providing this kind of shared background understanding of 
meanings. So OK, its like a global conversation in a sense: but only 
superficially. The kind of language is different - and I don't just 
mean formal instead of NL, but fundamentally different: less tolerant 
of ambiguity and contextual effects, but on the other hand much more 
capable of precise distinctions. And the kinds of reasoning involved 
are different: shallower, much less pattern-oriented, unable to deal 
with metaphor or allusion, but able to take incredible amounts of 
information into its scope, quite beyond human attention capacity. 
And in fact likely to be able to take advantage of the structure of 
the Web itself, once the SW begins to grow seriously. And it really 
is a bit more like telepathy than conversation, since the software 
'thinks' with the OWL directly: it doesn't need to understand it 
first and then think.

>   How
>do I make my URIs stand for my meanings?

Say enough about the meanings that you can be reasonably certain that 
whatever you want the reader to be able to conclude can be concluded. 
Its a lot easier if you can refer to some common ontologies that the 
reader can access.

>  Or when I receive a
>document, does the formalism help me to interpret the URIs? to
>determine what they signify?

Think of the URI s as just labels. The 'meaning' is in what is said 
about those labels. In NL, each word seems to carry a burden of 
meaning within it,  but that really is an illusion. NL words are just 
labels as well. The meanings are in our heads, and the words are just 
a kind of shared hash-code for these huge ontologies that we all 
carry around inside our heads (or at any rate that's what GOFAI 
people think is in there). It takes 5 years to learn the code and 
about another 10 or 20 to learn most of what is in the hash tables. 
Nobody knows how the hell people do it. (There's a period in kids 
lives where they are learning new words at an average of seven to ten 
words a DAY.)

>My questions are only a bit rhetorical, mostly I would really like
>to know if I have missed something important about the model theory.

The MT just gives a general framework for connecting actual 
ontologies - sentences - to a world. In my previous reply I said, 
rather snappily (sorry), that all the meaning in OWL was in the MT. 
But let me modify that. The really interesting meaning is in the OWL 
itself, in what the ontologies say. The MT just give you the rules 
for interpreting the OWL:its the lemon squeezer, and the OWL is the 
lemons. You get enough meaning when you have access to enough OWL. It 
might take a hell of a lot of OWL to capture the meaning of one 
little English word, but that's life.

Pat

>
>John Black


-- 
---------------------------------------------------------------------
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 Tuesday, 6 April 2004 21:53:36 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:42:16 GMT