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

Re: Issue-130 (conformance)

From: Ian Horrocks <ian.horrocks@comlab.ox.ac.uk>
Date: Thu, 4 Sep 2008 16:50:24 +0100
Message-Id: <B683DD1B-C28D-43D9-AB45-80068639C8EB@comlab.ox.ac.uk>
Cc: W3C OWL Working Group <public-owl-wg@w3.org>
To: Sandro Hawke <sandro@w3.org>

On 4 Sep 2008, at 01:49, Sandro Hawke wrote:

>> The idea we came up with on the teleconf was to say that
>> implementations MUST issue a warning when they can't be sure about a
>> False answer, and to add that implementations not wanting to check
>> the conditions could simply return Unknown instead of False. On
>> closer examination, this doesn't make total sense and/or seems
>> unnecessarily complicated.
>> In the first place, it is strange to say that implementations MUST do
>> something, and then say that they can do something else instead. In
>> the second place, it doesn't seem to make much sense to return False
>> with a warning that this answer can't be trusted -- surely it would
>> be much more sensible to return Unknown under these circumstances.
>> This would allow the conformance conditions on OWL RL checkers to be
>> greatly simplified, i.e., to say that they can only return False when
>> the entailment doesn't hold (just like for the other checkers). We
>> could then add a note for implementers pointing out that Theorem 1
>> tells them just when it is safe for rule-based implementations to
>> return False (when the conditions are satisfied and the entailment
>> isn't found by the rules). The note can also say that if they don't
>> want to implement the check they can simply avoid returning False.
>> To make this clearer/more concrete, I implemented this in the
>> Conformance document [1].
> ...
>> [1] http://www.w3.org/2007/OWL/wiki/Conformance
> I agree with all this.  But I see there's no longer a difference  
> between
> OWL Full and OWL RL entailment checking.   Hmmm.

This isn't too surprising: they both take RDF graphs as input, check  
entailment based on the RDF-based semantics, and must be sound w.r.t.  
both entailment (True) and non-entailment (False).

> Maybe the difference is that OWL 2 RL entailment checkers SHOULD  
> return
> True if FO(O1) <union> R entails FO(O2)?    I guess that's what I'd
> expect them to do.

OWL 2 Full entailment checkers should do this as well of course. The  
difference is that for some inputs, OWL 2 RL entailment checkers will  
return Unknown. In principle, an OWL 2 Full entailment checker SHOULD  
NOT do so (modulo pragmatics). We could emphasise this point by  
adding something like:

"An OWL 2 RL entailment checker MAY return Unknown if FO(O1) ∪ R  
does not entail FO(O2) under the standard first-order semantics,  
where R denotes the OWL 2 RL/RDF rules [OWL 2 Profiles], and FO(O)  
denotes the FO theory corresponding to O in which triples are  
represented using the T predicate — that is, T(s, p, o) represents  
an RDF triple with the subject s, predicate p, and the object o."

I.e., Unknown is a possible answer when the entailment wouldn't be  
found by the rule set.

>> Still to do: add something about what this would mean in the case of
>> query answering, to the effect that a warning MAY/SHOULD/MUST be
>> issued if "Unknown" would be the answer to any relevant entailment
>> problem.
> To phrase it more positively, maybe:
>     Systems which do query answering using OWL SHOULD return an
>     indication of whether the performed OWL reasoning was complete or
>     incomplete.
> Is this practical?    I'm not sure.

A sufficiency condition for complete reasoning may not be too  
difficult to check -- reasoning will be complete in case the "schema/ 
Tbox" part of the ontology satisfies the syntactic constrains and the  
data consists only of "simple" RDF triples (no fancy OWL stuff); it  
*may* be incomplete otherwise.


> I personally like query interfaces to provide this information, but I
> realize they often don't.   (It comes up without inference when you  
> use
> something like a LIMIT clause.)
> In SPARQL (which doesn't provide this information), we can do an in- 
> band
> query for reasoner metadata like this:
>    SELECT ?completeness [...your vars...]   {
>         ?g1 { [...your pattern...] }
>         { ?g1 owlq:completenessLevel ?completeness }
>    }
> I think this works (thanks to Eric Prud'hommeaux for working it out  
> with
> me), but it would require standardizing one RDF predicate (written  
> here
> as owlq:completenessLevel).  It's kind of an outlier -- it's certainly
> not part of the OWL language -- but we could be defined in some  
> normative
> appendix.
>      -- Sandro
Received on Thursday, 4 September 2008 15:51:07 UTC

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