[Pellet-users] Pellet performance w.r.t. the DL used to express an ontology

[Bijan Parsia]

On Tuesday, July 8, 2008 9:14am, "Alexandre RICHARD" <richard at newb6.u-strasbg.fr> said:

> Hi
> 
> I have been working on ontology-based tools dealing with astronomical
> objects and I am facing results that I find kind of puzzling in terms
> of performance. I can guess possible reasons but I am unable to
> conclude on one.
> 
> My main source of amazement is that to some extent Pellet generally
> performs much better with quite complex DLs like SHIQ than simpler ones
> like ALCIN.

Hrm. It's hard to compare performance on *DLs* as a whole. It's certainly the case that you can have nominally SHIQ kbs that are trivial and nominally ALCIN kbs which are impossible.

(ALCIN is strictly easier than SHIQ (PSPACE vs. EXPTIME)).

One thing to keep in mind is that Pellet (at the moment) isn't so great with inverses (it's performance varies a lot). So having a role heirarchy and qualified number restrictions with gentle use of inverses might be way easier than heavy duty inverse use.

(Also depends on your expressivity checker :))

> But then again my use case has its specificities.
> 
> To make it short I do consistency checks on a TBox-only ontology
> featuring object properties and annotations, no datatype properties.
> The ontology can be expressed using ALCIN but I find that Pellet is
> quite faster with SIN (just a transitivity constraint added on a
> property which could be transitive, except than I don't need
> transitivity for my use-cases and I tend to avoid unnecessary
> constraints by habit of avoiding higher complexity and overdefinition).
> Basically, my tests lead me to: SIN / SIQ > SHIN / SHIQ >> ALCHIQ >
> ALCIQ / ALCIN

That's interesting. Would you mind sending the ontology?

There are several reasons why performance might vary here (including triggering different blocking conditions).

> Certainly it may be the case for implementation reasons. Perhaps
> transitivity allows some kind of pruning, hence limiting the number of
> checks, but I have no means of being sure. And after reading
> publications on Pellet and its strategies, I am still not sure about it.
> 
> So I was wondering if anyone could give me a hint about why I get such
> results

My first guess would be something about different blocking conditions. A more expensive blocking conditions could end up blocking earlier and thus being, overall, faster. Just a guess.

> and/or could give me pointers, even rather broad ones, on which
> logic(s) is likely to give me the best performance.

The polynomial fragments are likely to rule the roost. But those algorithms are starting to be blended in to more expressive reasoners.

Cheers,
Bijan.