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

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

From: Thomas B. Passin <tpassin@comcast.net>
Date: Thu, 08 Apr 2004 15:57:47 -0400
Message-ID: <4075AEBB.6060602@comcast.net>
To: public-sw-meaning@w3c.org

John Black wrote:

>>From: Thomas B. Passin
> If you are saying that the Resource and my meaning are equivalent, and 
> thus that the URI stands for my meaning, this would make sense.  

 From rfc 2396 -

"A Uniform Resource Identifier (URI) is a compact string of characters
    for identifying an abstract or physical resource."

RDF does not change this.  Now an abstract resource could be a 
"concept", and so a URI can be used to identify a concept.  This is much 
like a key in a hash table, and in fact that could be an actual method 
of implementing a lookup in an application.

As to the "meaning" of one of those concepts, well, of course, that is 
much trickier.  You probably can never quite get your notion of what the 
concept "means" to me in all its full glory, even if you explain for 
hours.  So you have to tailor how much of that "meaning" you need 
someone or something to work with.

For Web (and Semantic Web) use, we may try to go farther and hook up the 
URI to some information that attempts to explain it.

So I would say that the URI stands for (really: identifies) your 
_concept_, but the "meaning" of the concept is another question.  The 
URI is there to try to give a globally unique name or label, and with 
luck or by design to be more useful by pointing to more information.

> Otherwise, 
> this doesn't work.  I want my URIs to stand for what I intend to mean by 
> them. 

Fine - you publish the URI, it stands for whatever concept you want - 
but now you have to impart to the user (human or otherwise) enough about 
that concept so that it can be used correctly.  But people always end up 
using things differently or misunderstanding, and you can't stop that 
altogether, no matter what you say or publish.  You can just hope to 
keep it under control when your purposes are involved.

> But even so, I also want to know how the intelligent agents that 
> receive the URIs in my RDF messages will correctly interpret my URIs 
> and understand what I intended to signify by them.  How do I do that?

With general purpose code?  Maybe you can't.  Depends on what you what 
the agents to do, doesn't it?  What's different from the work you said 
you did - say the Prolog work - is not RDF, OWL, or URIs, but the open 
nature of the Web.  Otherwise, everything you already know still 
applies.  You know how to get a Prolog program to "understand" certain 
data in the sense that it will do the intended processing.  That hasn't 

WIth RDF/OWL/etc we have some ability to get beyond the specific design 
of a single program, which is a step beyond a Prolog or C or whatever 
program doing custom parsing or reasoning.  But if you expect a computer 
to turn on a light because you issued an RDF statement saying that the 
state of the light is ON, obviously that won't happen unless you write 
code to make it happen (and interface the machine to the light). The RDF 
acts as a generalized way to capture state, so you don't need custom 
code to learn what the state is, but to use it, you probably still need 
custom code.

> Now we are implementing a system that does not have that condition.  
> It is created by vast numbers of different people from around the 
> world. And we are planning to have lots of nodes on this wide network 
> share documents with each other.  

Right, that is the open world nature of the beast.  Nasty, and exhilarating.

This is where the logicians on the RDF team got clever - or where they 
came up with a way to try to dance around the issues, take your pick.  I 
mean the matter of "interpretation".  Plain folks like me tend to think 
of an RDF data set as being pretty much like a database, where you know 
what each field is for.  But in reality, every concept requires a heck 
of a lot of context to really grasp and apply.

That context is likely to be missing much of the time.  So now we have 
the notion of "interpretation" in which a "fact" could be regarded in 
many ways, as long as they are all consistent with the state of the 
world as it is known.

Example -

"John in standing in front of his house."

John could be a male human, but also a female human or a male dog, or 
many other things.  If we know nothing else, we cannot figure out which 
one is "meant".  We can only know that the RDF representing the sentence 
is consistent with any of the above.  Similarly, "house" might actually 
mean a dog hous in the back yard, a doll house in he basebent, or who 
knows what else.  All perfectly good interpretations, all consistent 
with the data we have which in the case is just the one sentence.

Now add a new sentence -

"John is a dog."

Assume that we have used a URI for "John" so we know the same "John" is 
meant in both cases.  If we also know that a "dog" is not a "human", we 
can remove some of those previously tenable interpretations, since they 
would no longer be consistent with the data set.

The point?  Instead of worrying about the "meaning", the art seems to be 
to wittle away at the set of feasible interpretations until the 
surviving set is consistent with what you intend, or at least with what 
you need to accomplish.  The more data built into your code, the less 
whittling you have to do in the RDF/OWL/whatever.  If your code knows 
nothing, you have to do a lot of whittling.

This is pretty foreign thinking for me, and I have not really digested 
it yet in a working (as opposed to a conceptual) way.

I think it is time for someone who knows this stuff better than I to 
give some fairly concrete illustrations of how it might work in practice.

Anyone?  Pat?


Tom P
Received on Thursday, 8 April 2004 15:54:10 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 19:56:02 UTC