W3C home > Mailing lists > Public > public-owl-wg@w3.org > July 2008

Re: Detection, where? How? (was Re: Allowed types of punning (ISSUE-114))

From: Bijan Parsia <bparsia@cs.man.ac.uk>
Date: Thu, 10 Jul 2008 16:34:23 +0100
Message-Id: <774088C4-E80B-424A-9976-149929EA4516@cs.man.ac.uk>
Cc: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>, Alan Ruttenberg <alanruttenberg@gmail.com>, OWL Working Group WG <public-owl-wg@w3.org>
To: Rob Shearer <rob.shearer@comlab.ox.ac.uk>

On 10 Jul 2008, at 14:36, Rob Shearer wrote:

> I think Bijan substantially over-characterizes the extent to which  
> lint-like tools solve problems.

I don't see that I characterized their extent. I just pointed out  
that they're one place you can put things. How well it works depends  
substantively on the problem at hand. It's a fairly complex system  
with different parts being able to handle different aspects to  
different effect.

But, I think, for example, that they can play a useful role in  
warning about punning. Actually, in effect, that's what we'll have  
since (at the moment) we still have OWL Full and (no matter what)  
we'll still have RDF graphs.

There's a strong bias in many Web and Semantic Web circles against  
catastrophic "error" handling.

The question for *this feature* is whether the benefit is worth the  
cost, overall. After all, from a user perspective, any dangerous bits  
happen *when* they pun. So why is it better for them for a reasoner  
to refuse to deal with a punned ontology? Why is it a better user  
experience if they've happened to use a name as a class and as a  
property, or they merge two ontologies which used the names variant,  
to throw either a syntax error or a contradiction? Those two states  
mean, generally, at the moment, that they can't use that tool *at  
all* with the ontology without munging it. Perhaps it happens seldom  
enough to be ok.

> Among other things, lint-like tools only really work when, for each  
> "suspicious" construct flagged, there is an "unsuspicious"  
> construct with the exact same meaning. In other words, users need  
> to be able to avoid lint warnings if they really know what they're  
> doing and they're clear in their intent. You shouldn't just cordon  
> off whole features and say "if you use any of this stuff, which we  
> considered useful enough to require implementors to support, then  
> you're making a mistake".

Well, that's not how I would design one.

> But really this just strikes me as a silly road to go down. We  
> could allow just about any syntax and say that most of it produces  
> unsatisfiable expressions or inconsistent ontologies.

Of course, but it's a matter of trade offs. We also have some legacy  
and other dialects to consider.

> Such an approach would be nothing but punting on the spec: the  
> working group will have failed to decide what a reasonable OWL  
> fragment is, so OWL will be de facto defined by lint-like tools.

If you took it to an extreme, maybe. But I don't feel it's useful to  
characterize the considerations I brought forth by such an extreme.  
(Though I know people in the community who have put that forth.)

> This would have some appeal to the largest tool vendors, but I feel  
> quite strongly that it is not an approach the working group should  
> endorse.
>
> (I also think it would be a huge waste of time for the working  
> group to define *two* OWL-DL standards: one of syntactically valid  
> ontologies and one of semantically sensible ontologies. The OWL- 
> Full/OWL-DL split is already headache enough.)

You misunderstand my point here. First, I personally think punning is  
fine. I can see some circumstances where it's useful, even. I  
generally prefer to minimize multiple use of terms, but sometimes  
it's quite handy. It's not a make or break feature for me,  
personally, of course.

But we already have an OWL-DL, all rdf graphs split. I personally  
prefer to narrow that gap. That's a major reason for having  
systematic rather than selective punning. My point for people who  
think it's bad practice or potentially confusing is that one needn't  
go so far to forbid it from a language or dialect of that language. I  
spent a lot of time working to make the OWL-S ontologies OWL DL  
compliant and a bunch of the changed I made weren't strictly  
necessary (in the sense that an extended OWL DL reasoner could handle  
them). Including a data-object property punning situation.

> On 10 Jul 2008, at 13:16, Bijan Parsia wrote:
>
>> Forbidding object/data, class/type punning seems reasonable to me
>
> Then, as far as I can tell, Alan is the only one who finds it  
> unreasonable.

I believe Alan finds it reasonable, but then believes that if we do  
that, we should only allow the minimal "amount" of punning possible.  
My position is the opposite.

Cheers,
Bijan.
Received on Thursday, 10 July 2008 15:32:09 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:42:05 UTC