Re: Issue-130 (conformance)

On 8 Sep 2008, at 19:25, Ivan Herman wrote:

> Sandro Hawke wrote:
>> 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.
> But the down side is that we, sort of, require to modify all relevant
> SPARQL implementations to return this information. This also means  
> that
> one is supposed to use SPARQL in a particular way when using such a
> store. I am not sure this is realistic or worth pushing...

I agree. Currently we don't say anything about what kind of query  
interface an implementation could or should support, much less how  
they should report errors and exceptions. I don't think that it would  
be appropriate for us to specify this.

> To go back to the original issue and Ian's proposal: I actually do not
> have a problem with the current formulation for entailement checkers.
> Yes, implementation may simply say that they return UNKNOWN if they do
> not want to go down the path of the theorem 1 checking, and that is  
> fine
> with me.
> Unless we go along with the extra stuff above, I'm still not fully  
> sure
> what this whole thing means for the implementation pattern where a,  
> say,
> forward chaining engine like Oracle's expands the graph (that include
> the ontology) and then SPARQL queries are issued on the result. After
> all, SPARQL queries do not usually return True or False, they either
> bindings to patterns or they do not return any binding. My rough  
> reading
> is that applications should interpret an empty binding return as
> 'unknown', and that is it; the underlying OWL-RL implementation  
> does not
> necessarily have anything else to do. (I know implementation may
> implement more rules than those listed in our document, but that is
> another issue.)
> Is that correct? It does not feel 100% right, but I cannot put my  
> finger
> on it...

I don't think that this is correct -- an empty answer might be the  
correct answer.

Answering a query amounts, in theory, to checking for every possible  
answer tuple if that tuple is entailed by the ontology. E.g., if the  
query simply asks for C(?x) (i.e., for all the instances of C), then  
we can think of this as checking for every URI name u in an ontology  
O if O entails C(u). Thus, we can guarantee that the answer is sound  
and complete only if we can guarantee that checking such entailments  
will never return Unknown. Theorem 1 indicates when this is the case  
for implementations based on the RL/RDF rules -- i.e., when the  
ontology and query satisfy the relevant conditions. If these  
conditions are not satisfied, or if the conditions have not been  
checked, then only returning answers for which the relevant  
entailment check returns "True" will ensure that query answers are  
still sound, but completeness cannot be guaranteed.


> Ivan
>>      -- Sandro
> -- 
> Ivan Herman, W3C Semantic Web Activity Lead
> Home:
> PGP Key:

Received on Monday, 8 September 2008 19:08:21 UTC