Re: ISSUE: OWL-DL compatibility

On Thu, 22 Oct 2009 11:00:52 +0200
Jos de Bruijn <debruijn@inf.unibz.it> wrote:

> 
> > In today's telecon I was asked to reanimate the issue of OWL compatibility,
> > which was discussed 1 month ago.
> > 
> > Here is the relevant message:
> > 
> > http://lists.w3.org/Archives/Public/public-rif-wg/2009Sep/0017.html
> > 
> > The current situation is a bug, IMO. If it isn't a bug then at least that part
> > of the document is very unsatisfactory and obscure. Jos proposed 3 solutions:
> > 
> > 1- leave things as they are, assuming that # and ## are not of interest
> >    to users of RIF-OWL DL combinations
> > 2- explain the use of # and ## in the document (this would certainly not
> >    be a substantive change, so we should not run into procedural problems)
> > 3- define the semantics of # and ## in RIF-OWL DL combinations in a
> >    similar fashion as in RIF-RDF combinations: a one-to-one correspondence
> >    between # and OWL class membership statements and implication between ##
> >    and OWL subclassing.
> > 
> > The easiest for him would be to do nothing (1), thus leaving things
> > unsatisfactory and obscure. His next choice is (3), which is also my choice and
> > the "right thing to do."  (3) stretches things a little, but it can be argued
> > that it is a simple fix.
> 
> In my earlier e-mail to Michael referred to I did not say what my
> preference is among the mentioned options.

You indicated which ones are easier for you to implement :-)

>  I guess arguments can be
> made for all three options, so in fact I do not have a strong
> preference, but I do have a concern about option (3): implementation
> might be harder.  If, for example, implementation is done through
> embedding in other rules system, like the embedding of RIF-OWL2RL
> combination in the appendix of the document, quite a few rules need to
> be added for the ## construct.
> In particular, for every pair of distinct class names (A,B), we need to
> add the rule:
> 
> Forall ?x (?x[rdf:type -> B] :- And(?x[rdf:type -> A] A##B))
> 
> This means adding a quadratic number of rules.

First, adding these rules is not hard -- just some additional work.
Second, we should do what's right. Third, the whole issue came up because the
current spec is somewhat cryptic and non-uniform w.r.t. the treatment of ##
in the sense that it does not match expectations. I am sure quite a number
of implementors would have problems understanding it as intended (just as I
had).

> Dealing with # is easy: in the mapping of RIF DL-document formulas to
> RIF documents [1] we simply map a#b to tr'(b)(a). Clearly, we would
> restrict b in formulas a#b to constant symbols.
> 
> 
> [1]
> http://www.w3.org/TR/rif-rdf-owl/#Embedding_RIF_DL-document_formulas_into_RIF_BLD
> 
> 
> > 
> > Solution (2) is more work. It fixes the obscurity aspect, not the
> > unsatisfactory aspect of the definitions. So, (3) seems like the best way to
> > proceed.
> > 
> > Solution (3) still leaves some problems, which are unrelated to the above
> > issues. In the current semantics, subclassing in RIF implies subclassing in
> > OWL/RDF, but not vice versa.
> > 
> > In this regard, I would like to point to my follow-up message
> > http://lists.w3.org/Archives/Public/public-rif-wg/2009Sep/0019.html
> > Here I proposed a stronger semantics, which fixes this non-entailment problem.
> 
> Michael proposed the following semantics:
> 
> {(A,B) | A rdfs:subclassOf B and A != B on the RDF side}
>                 = {(A,B) | A##B on the RIF side}
> 
> I feel that this would take us out of Horn, even when considering Simple
> entailment, because implementation would require (classical) negation.
> At least, that is the only way I current see how this could be
> implemented. As we know, classical negation in the body amounts to
> disjunction in the head, so we would end up adding the following rule to
> the embedding of RDF-RDF combinations:
> 
> Forall ?x, ?y (Or(?x##?y ?x=?y) :- ?x[rdfs:subClassOf -> ?y])
> 
> For RIF-OWL DL combinations such a semantics is even more problematic,
> because subclass in OWL DL means subset relation between class
> extensions, so the condition would look something like (X^C is the class
> extension of X):
> 
> {(A,B) | A^C subset B^C and A^C != B^C on the RDF side}
>                 = {(A,B) | A##B on the RIF side}
> 
> (Actually, we will need to apply some tricks here, since A and B are not
> constants on the OWL side, but I guess we can come up with a definition
> that kind-of achieves this semantics)
> 
> A formula implementing the => direction of the condition for a pair of
> class names A,B would look something like (again, negation in the body
> becomes disjunction in the head):
> 
> Forall ?x (
>   Or(A##B
>      And(Forall ?x(?x[rdf:type -> B] :- ?x[rdf:type -> A])
>          Forall ?x(?x[rdf:type -> A] :- ?x[rdf:type -> B])))
>   :-
>   Forall ?x(?x[rdf:type -> B] :- ?x[rdf:type -> A]))
> 
> 
> So, I would not be in favor of extending either the semantics of RDF or
> the semantics of OWL DL combinations with such a condition.

Yes, it is harder to implement and I was not proposing it for CR. I said that we
might consider it for the future. But it seems that there will be opposition to
that.

michael


> Best, Jos
> > 
> > This would certainly be a substantive change semantically (although not
> > significant textually). If we don't have the energy to do it this time,
> > maybe for RIF 1.1.
> > 
> > michael
> > 
>

Received on Sunday, 25 October 2009 00:21:54 UTC