Re: RDFS compatibility information in OWL-DL documents

On 19 Apr 2007, at 13:44, Xiaoshu Wang wrote:

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

[snip]

That may have been an argument for what you would *prefer* to be the  
case, but it is not an argument for what's actually specified or, I  
would say, common practice. I would go farther to say that that is  
undesirable practice.

> "owl:imports" cannot be used here because I don't think the given  
> statement is an ontology.

That also is specious, IMHO. First it conflates two things, 1)  
whether there is an autoinclude or a explicit include mechanism and  
2) whether owl:imports can be legally used in this case.

In point of fact, it can with no discernable difficulty. And even if  
it couldn't, that doesn't preclude an explicit model. Indeed, it  
strongly supports it (i.e., merging graphs is outside standard RDF).

So you are free to follow your nose in your tools, but if I am using  
your tools I shall complain unless there is an opt out by default.

> (If it is, then what isn't?)

I'm fine with every rdf graph being an owl:Ontology. In point of  
fact, they are (at least owl full). So that's fine.

Second, your example contains a subclass statement which is generally  
an ontology statement. So this is a *good* example of an ontology (if  
small).

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

Far from being the *only* logical conclusion, it's a non sequitur  
(that is, not even logical).

> This also makes sense since one of the essential features of the  
> web is "self-descriptive" and a "nose" model fits in satisfactorily.

Non sequitur number 2!

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

No.

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

Not true. That's certainly not how I think of it.

> But it is up to the readers to decide if s/he needs to follow.

If they *want* 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.

Now you're being prescriptive. A conforment reasoner *must not*, in  
it's conforming behavior, do what you claim it has to. That doesn't  
preclude a larger *system* from doing this, to my mind, typically  
useless, behavior.
[snip]

Please distinguish your arguments for desired behavior from those  
about sanctioned and actual behavior. The RDF specs do not require  
strong ontological closure, that is, inclusion of all the documents  
spiderable from uris appearing in a graph. The only mechanism defined  
in those specs for producing a base graph is by parsing an RDF/XML  
file. RDF/XML parsing clearly does not *permit* such spidering.

Secondly, I do not believe that any generic RDF toolkit does such  
spidering on either parsing an RDF document or inserting a triple. I  
would regard such behavior as broken beyond belief.

Some special application spider the values of certain properties,  
e.g., foaf spiders and seeAlso. Note how they do not spider *all*  
mentioned URIs.

Finally, if your position were correct then there would be no OWL DL  
documents as they would have to include the owl.owl file which would  
make them OWL Full.

If I use an URI in an RDF or OWL document I publish, I intend nothing  
more to get into that document than the what's in the imports  
closure. If you add extra stuff that's your look out.

Cheers,
Bijan.

Received on Thursday, 19 April 2007 13:43:06 UTC