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