Re: completeness

I have just looked through the whole thread and got a bit lost.

I thought I would return to Uli's original question.

My understanding is that we are going to have a clearly specified set of 
requirements on reasoners for OWL Prime that defeats a trivial 
implementation.

Specifically I am imaging a specification that approximates to:

- a definition of OWL Full 1.1 semantics
- an OWL Prime reasoner MAY always answer a question correctly by 
answering it with in the terms of OWL Full.
- a definition of a weaker semantics for OWL Prime (this may be defined 
in terms of a set of rules or axioms, or may be by a model theory that 
is weaker than the OWL Full model theory)
- an OWL Prime system MUST find entailments by this weaker semantics.

(all sort of).
e.g. there are obviously system limitations in terms of resource limits ....

Am I on a different page from other people?
(I guess this is different from Jim's "we are trying to help people find 
'useful' information")

Is it different from what Zhe or Michael are expecting?

I think it is conceivable, but undesirable, to have a 'faster' mode for 
OWL Prime which methodically computes fewer entailments (e.g. certain 
known to be difficult rules get switched off). I guess I would see that 
as the sort of thing that implementors might enable themselves but 
wouldn't be standardized.

Jeremy




Ulrike Sattler wrote:
> 
> Hi,
> 
> I thought I'd share some of my thoughts regarding completeness, 
> scalability, & interoperability that might explain why I keep shouting 
> "what do you mean by *scalable*"?
> 
> 1) Even I can write a very scalable OWL DL query answering engine if it 
> doesn't have to be complete: when asked to retrieve instances of a class 
> C, it simply always only returns nothing...wait, I can even do better by 
> returning "told" instances of C!
> 
> 2) If we agree that (1) is sort of cheating, then we need to be more 
> precise what "completeness" means: now, if we say "my engine will 
> retrieve as many instances of C as it can manage in the given time", 
> then we might get more than the told instances, but we could be  in 
> trouble regarding interoperability: your engine could return a very 
> different answer set from mine, since they have different strengths or 
> optimisation techniques or,e.g., rule orderings.
> 
> So, what I would like to see as a clarification of "we can trade a bit 
> of completeness for some scalability" is a description what *kind* of 
> completeness we give up for (ideally) how much gain in performance.
> 
> Cheers, Uli
> 
> 
>

Received on Friday, 22 February 2008 16:43:43 UTC