Re: RDFS compatibility information in OWL-DL documents

Hi, Bijan,
> Most ontology engineers that I know do not want to take a follow your 
> nose approach. I certainly don't. We had quite the dust up about it a 
> few years back. Try searching for "strong ontological closure", or see:
>     <http://www.cs.bell-labs.com/cm/cs/who/pfps/publications/meaning-long.ps> 
>
>
> However, an unspecified idiosyncratic property of RDF most certainly 
> does not trump a reasonably specified, compatibly implemented feature 
> like owl:imports. You may *prefer*, and reasonably so, your model, but 
> I think from the perspective of current *standards* you are incorrect 
> and current *practice*, in the minority (for some value of minority :))
To make it easy to write, let me dub the "follow your nose" approach as 
the "nose model". And follow the instruction (such as the explicit 
owl:imports) as "mouth" model.  The reason that I think RDF uses a "nose 
model" is via the following logic.

Consider the following case.  There is an ontology at 
http://example.com/o1, where it states

http://example.com/o1#A rdfs:subClassOf http://example.com/o2#B.

Now, if a reasoner is given a statement of

_:x a http://example.com/o1#A .

and is asked: is _:x a http://example.com/o2#B?

What would be the answer?

Certainly, a "nose model" reasoner would say "yes" and a "mouth" model 
would say "not sure". 

But, by what means will a "mouth model" reasoner also be able to give 
the "yes" answer? The only option seems to repeat what is said at 
http://example.com/o1 to the reasoner.  But I think this defeats the 
basic communication model of the web, i.e., to communicate via sharing.

"owl:imports" cannot be used here because I don't think the given 
statement is an ontology.  (If it is, then what isn't?) And since there 
is no RDF/RDFS vocabularies that are given an "import/include" role, the 
only logical conclusion is that RDF must be using a "nose" model. This 
also makes sense since one of the essential features of the web is 
"self-descriptive" and a "nose" model fits in satisfactorily.

Nevertheless, in either case, the current definition of owl:imports and 
RDF specs seems either redundant or inconsistent.  If RDF is a "nose" 
model, owl:imports is redundant.  On the other hand, if RDF is a "mouth" 
model, there should exists a vocabulary that carries the function of 
"owl:imports", though none is clearly specified.  But whatever the 
vocabulary is, it must cover what "owl:imports" does. 

My point was whether RDF takes a "nose" or "mouth" model needs to be 
clarified before inventing more vocabularies.

> As an analogy, consider the difference between how a web browser 
> treats hrefed uris and how a web spider does. Compare with how uris in 
> <img src= works. Compare with uris in namespaces in XHTML documents.
This actually supports a "nose" model right?  A human reads an HTML 
document until s/he thinks s/he has get it. S/he does not have to follow 
all the links, but the intent of the author is meant for all the text + 
all the links.  But it is up to the readers to decide if s/he needs to 
follow.

Similarly, if the task of a reasoner is to answer a query, then the 
reasoner has to follow its nose to get the knowledge until it either 
gets a positive answer or exhausts all its smells.  For instance, in the 
above given example, if a reasoner can get the answer by importing the 
statements from http://example.com/o1.  There is no need for the 
reasoner to further import the statements from http://example.com/o2 or 
whatever is probably ensued (since RDF model is monotonic).  But HOW to 
implement a "nose" model (lazy or not) is a totally different issue than 
IF we should use a "nose model".  Of course, I can understand the 
difficulties of implementing a nose model. But should we let an 
implementation issue influence the decision on a right model for 
meaning? I am not sure that we should.

Cheers,

Xiaoshu

Received on Thursday, 19 April 2007 12:48:49 UTC