Re: declaredAs

I don't have a huge personal interest either way, but I have a few, I  
hope, helpful remarks, both procedurally and substantively.

On 7 Aug 2007, at 16:13, Michael Schneider wrote:

>
> [forgot the subject]
>
> Hi, Boris!
>
> I still try to find out what declarations should be good for, and  
> what they provide.

This is good. One thing I've liked about how the HTML and WHAT WGs  
work is that they often ask that issues be framed in terms of the  
*problem*, independently of any particular solution. This seems esp.  
helpful for contentious issues. Describe the problem clearly, then  
one can separate the debates about whether it *is* a problem, or a  
significant problem, or whether this or that solution solves the  
problem in a useful way, or introduces more problems, or consider  
alternatives, etc..

> In all your posts, including those you posted some months ago to  
> this topic here in the group, and in a paper you wrote (forgot its  
> name, but you will probably know what I mean), I think I always saw  
> these two main lines of argumentation:
>
> 1) We need some means for doing "structural consistency" checking  
> for OWL files, and declarations provide such a means. Structural  
> consistency is defined in
>
>     http://webont.org/owl/1.1/owl_specification.html#8
>
> the following way:
>
>     "An ontology O is structurally consistent
>     if each entity occurring in an axiom from the axiom closure of O
>     is declared in O."
[snipped the mistyping problem...I'm not interested in that at all]

> Now to the first point:
>
> I strongly agree that it is a good thing to have an ontology, which  
> allows me for every name (i.e. URI) used within this ontology to  
> determine, if this name denotes either a class, or an individual,  
> or an object property, or a datatype property (I will call this the  
> "resource kind" of a named entity from now on). I really want to  
> have this property of an OWL file, because otherwise my modeling  
> tool gets into problems, if it isn't able to determine the resource  
> kind for each named entity in the ontology. So what I like to see  
> from a good tool will be some means to check an ontology at read  
> time, if for each name the resource type can be detected. If the  
> resource kind cannot be detected for some named entity, than I  
> expect a warning from my tool. Of course, this check should be  
> efficient enough to not bother me as a user by making me wait too  
> long.

This seems like a great statement of a real problem. In fact,  
something like this is pretty much what OWL DL species  
identification, or rather, the explicit typing criterion, is trying  
to solve. It, frankly, does a pretty crap job. The repair tools  
haven't really kept up, either, though they were helpful. Part of the  
problem there, of course, is there was a lot more complexity in the  
species validation, but also people wanted to get "around" species  
validation in some cases (i.e., structural consistency and species  
validation are *not* quite the same...you can pun and be structurally  
consistent).

So we have a feature in owl, partially designed to address a problem.  
It's not a very well designed feature, but it is there and we have  
various obligations to backwards compatibility.

> What I do not get is why I should want to use declarations for this  
> purpose. I think that OWL already has everything included to allow  
> a parser or whatever tool to do such a check. Let's see:
>
> 1) Classes:
>
> AFAICS from OWL's abstract syntax, it can always be determined,  
> from each single axiom in an ontology containing a name N, if N  
> denotes a class or not. A few examples:

[snip]

I just want to point out that this conflates two things: Determining  
the "in use" or inferred resource kind, and determining the  
*intended* resource kind. In the functional (and XML) syntax, these  
are handled by *different* constructs: the former by explicit typing  
while the latter are handled by (optional) declarations.

Explicit typing:

<ObjectPropertyDomain>
     <ObjectProperty owll:URI="#eats"/>
     <OWLClass owl:URI="#animal"/>
   </ObjectPropertyDomain>

ObjectPropertyDomain(eats, animal)

(Note here that the typing is fundamentally in the constructor. The  
typing inside the constructer in the XML seems to me to be a feature  
of icky XML syntax, and the decision to parallel the functional  
syntax as much as possible.)

 From these, we can indeed determine the resource kind of each *use*  
of the name (which isn't always possible in OWL 1.0; just consider  
domain axiom (made up syntax):

	Domain(eats, animal)

is "eats" an object or datatype property? It depends on whether  
animal is a class or a datatype :))

Now from use, you can derived all the "implied" resource kinds in a  
ontology by inspecting all the (fully typed) axioms. What you can't  
do is put *checks* in  your ontology for being of a certain (set of)  
resource kinds. Some patterns are easy enough: If you want to always  
enforce the OWL DL separated vocabulary criterion, then implicit  
declarations are enough since *any* "duel use" is a violation.

But what if an author wants to distinguish between intended and  
accidental punning? E.g., some classes I want to be usable as  
individuals and some not, and I don't want any class to be a  
property? Use along *cannot* tell me this, and there is *no* way to  
have this canned in advance (though there may be several well defined  
canned versions we could use).

And it's not the case that this is something you'd need to do  
manually. Consider the case where you are merging two ontologies  
(after having mapped things with the same label to the same URI). You  
could run an analyzer over each of them separately, generate  
declarations which make explicit their use resource kinds, *then*  
merge. Structural consistency will then let you find puns that were  
introduced *solely* by the mapping.

(So, the *problem* is determining whether a pun is incidental or  
intended, or signalling to users and extenders whether the original  
author intended this class to be used as an individual. If we want to  
*publish* our intent, we need to write it down. Declarations let us  
write it down. Hard to see any other way (although you could imagine  
a declaration language that used patterns the way aboutEachPrefix  
could, or other macro like things; but these are implementation  
details almost))

Oops, this ended up being longer than I'd hoped. One other point: too  
much debate is pointless now, since there really is no point in  
making a big change in the current specs given the imminence of the  
WG. I think the various positions are reasonably clear. If someone  
hasn't already, someone should file an issue, preferably pointing  
back to this thread, and even more preferably succinctly summarizing  
the issue and the alternatives. This will make it easy for the WG to  
get back up to speed and (we hope) make a good, consensus building  
decision.

That someone won't be me, though :)

If you'd like to make a wiki page for this on the google code site,  
I'll happily make you a project member for that purpose. The issue  
could then link to that.

Cheers,
Bijan.

Received on Tuesday, 7 August 2007 16:05:20 UTC