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

Profile review

From: Jeff Z. Pan <jpan@csd.abdn.ac.uk>
Date: Wed, 24 Sep 2008 10:39:48 +0100
Message-ID: <48DA0AE4.3000709@csd.abdn.ac.uk>
To: Ian Horrocks <ian.horrocks@comlab.ox.ac.uk>, OWL Working Group WG <public-owl-wg@w3.org>

This is a review of the Profiles document, based on discussions
with colleagues from Aberdeen. I apologise for not being able to
deliver this review any earlier, as requested by the chairs. Given
the limited time that we have, the following comments are mainly
based on our discussions so far. For such a rich document, more
comments are likely to be available in next round of review. To
make the comments easier to follow, we include all the comments in this
email, rather than adding them across the wiki document. We would
be happy to add the comments online if needed.

Section 1
In general, some references are needed to support some of the
claims, such as those about useful application scenarios for the
three profiles. Also, after a quick check, we didn't find any
complexity results about instance checking in OWL 2 EL in the
references [EL++, EL++ Update]. Also, these two references are
only given in Section 2.

The OWL 2 EL bulletin point in Section 1 says

Dedicated reasoning algorithms for this profile are available
and have been demonstrated to be implementable in a highly
scalable way.

However, we could not find algorithms (that can be followed by
implementors who are not logicians) for the full OWL 2 EL from
[EL++, EL++ Update].

The OWL 2 RL bulletin point in Section 1 says

OWL 2 RL reasoning systems can be implemented using relatively
simple technology, ...conjunctive query answering can be implemented by
extending a
standard relational database system with rules.

We could not find any further discussions about using relational
database systems to implement OWL 2 RL; thus, the sentence is not
very helpful in the Introduction. We should either delete this
sentence or provide some reference to provide further details.

Section 2

The design principle for OWL 2 EL seems to be a bit confusing. The
first sentence of Section 2 says

The OWL 2 EL profile [EL++,EL++ Update] is designed as a maximal subset
of OWL 2 that
     * captures the expressive power used by many large-scale ontologies and
     * for which the following reasoning problems can be decided in
polynomial time:
     satisfiability, subsumption, classification, and instance checking.

Being a maximal subset of OWL 2 seems to indicates OWL 2 EL is a
superset of OWL 2 QL and OWL 2 RL, which is not the case at all.
For example, OWL 2 QL provides inverse roles that OWL 2 EL does
not support, and OWL 2 QL still enjoys polynomial time complexity
for the mentioned reasoning problems. As for OWL 2 RL, it supports
some form of number restrictions that OWL 2 EL does not support,
and OWL 2 RL also enjoys polynomial time complexity for these
reasoning problems. To some extent, all the three profiles are
maximal subsets of OWL 2, and the above design principle does not
really distinguish OWL 2 EL from the other profiles.

The sentence before Section 2.1, a reference should be provided
for SNOMED CT. On the other hand, it is good that some specific
applications are mentioned here, while we need to provide similar
kind of information for OWL 2 QL and OWL 2 RL.

Section 2.2.6 is a bit difficult to follow. If it is hard to be
followed by WG members, it is likely to be hard to be followed for
other readers. To make it more readeable, we should at least
provide a reference here, i.e., [EL++ Update]. There are two
points that we should further clarify here:

1) It seems that in order to have PropertyRange (OP1 CE) we need
to have some super property OPk or OP1 with the following axiom
PropertyRange (OPk CE) appearing in the ontology. One might ask
how we could have PropertyRange (OPk CE) in the first place, does
it require a further super property OPk+1 with a range axiom?

2) According to {EL++ Update], the condition is vacuously true for
role hierarchy statements, but in Section 2.2.6, even for
SubProperty (OP1 OPk), we still need to have the restriction,
i.e., having PropertyRange (OPk CE) in the ontology to allow the
use of PropertyRange (OP1 CE).

At the end of Section 2.2.1, a list of datatypes that must not be
used in OWL 2 EL are provided. This is unclear what are the
rationale of disallowing them. Is that because of the complexity?
Some references would be helpful here. Disallowed datatypes in OWL
2 QL and OWL 2 RL should be treated in a similar manna.

Section 3
It is worth mentioning the applications (with references) of OWL 2
QL in the beginning part of Section 3, like what was done in
Section 2 for OWL 2 EL.

Near the end of Section 3, the draft says

[[OWL 2 QL disallows negative object property assertions and
equality axioms. ... Equality and inequality axioms and
property assertions are the same as in OWL 2.

This is confusing - on the one hand, equality axioms are
disallowed, while on the other hand, equality axioms are the same
as in OWL 2.

Section 4
The first sentence of Section 4 says

The OWL 2 RL profile is aimed at applications that require
scalable reasoning without sacrificing too much expressive power.

This seems to be a bit vague and not very helpful - it makes OWL 2
RL sounds like OWL 2 EL, which is claimed to be the maximal subset
of OWL 2 to provide scalable reasoning (see Section 2).
Furthermore, it is unclear how much sacrifice of expressive power
is not too much.

There seems to be a big jump between Section 4.2 and Section 4.3.
After the former section, readers would expect to see how OWL 2 RL
ontologies can be translated into logic programs. Instead, Section
4.3 is about RDF rules rather than the above translation. The big
picture isn't clear until Theorem 1 at the end of Section 4.3. The
would be more readable if RDF rules are explicitly mentioned at
the beginning of Section 4.

The first sentence of Section 4.1 says

[[ Restricting the way in which OWL 2 constructs are used makes it
possible to implement reasoning systems using relatively simple
technology  in particular, rule-based reasoning engines  while
still providing desirable computational guarantees. ]]

This unclear why rule-based reasoning engines are relatively
simpler. Some justifications are needed.

Section 4.2.3, there is only one subClassExpression (with
maxCardinality for ObjectPropertyExpression) used in the
production of superClassExpression. Is it a typo? Otherwise, some
explanations are needed.

In Section 4.2.5, it would be helpful to explicitly state that OWL
2 RL disallows both negative class assertions and negative
property assertions.

After Table 8 in Section 4, the draft says

Note that the rules relating to rdfs:domain and rdfs:range
reflect the IFF semantic conditions of the OWL 2 RDF-Based
semantics [OWL 2 RDF-Based Semantics] rather than the weaker
ONLY-IF semantics of RDFS [RDF Semantics].

More explanations are needed here: What do the rules look like if
we use the weaker ONLY-IF semantics of RDFS? With the weaker
semantics, will Theorem still hold?

The next paragraph, the draft says

OWL 2 RL/RDF rules include neither the axiomatic triples and
entailment rules of RDF and RDFS [RDF Semantics] nor the axiomatic
triples for the relevant OWL vocabulary [OWL 2 RDF-Based
Semantics], as these might cause performance problems in practice.

However, the current RDF rules don't seem to very scalable either.
For example, the third RDF rule in Table 7 adds

T(lt1, owl:differentFrom, lt2)

for all literals lt1 and lt2 with different data values. If we
have 10^x different data values, we will then need to add 10^2x
generalised triples of the above form.

Section 5

The first paragraph of Section 5 is redundant; the same idea is
repeated in the third paragraph.

It seems to be better to move the second paragraph after the
introduction of the reasoning problems. Also, this paragraph says

None of the described profiles, however, is propositionally
closed, so these reasoning problems thus can have different
complexity and require different algorithmic solutions.

This seems to indicate in Table 8, for some profiles, that the
problems of ontology consistency, class expression satisfiability,
class expression subsumption and instance checking, could have
different complexity, which is not the case at all in Table 8.
This sentence thus does not seem to be very helpful in the

After Table 8 in Section 5, the DL Handbook and the Description Logic
Complexity Navigator are mentioned. Again, they don't seem to be
very helpful here. For the DL Handbook, we are not sure if all (or
any) the new results about the profiles are included. For the
Navigator, it is mainly based on the assumption that the supported
constructors can be used on both sides of concept inclusions;
hence, it is not obvious how to check the complexity results for
the profiles, in which there are detailed restrictions on where
certain constructors can appear.

Section 3.2, 1st paragraph, 2nd line: restriction -> restrictions

Section 3.2, 1st paragraph, 2nd line: DL-lite -> DL-Lite

Section 3.2.3, 1st paragraph, 4th line: can occur -> occur

Section 3.2.5, 1st paragraph, 3rd line: remove "them"?

Section 3.2.5, the paragraph before the following production, 2nd
line: "object property" should be "data property"?

DataPropertyDomain := 'PropertyDomain' '(' { annotation }
DataPropertyExpression superClass ')'

Section 4.2.1, 1st paragraph, 1st line: EL -> RL

Table 1: "a class descriptions" appears twice

There are two Table 8 in the draft

The University of Aberdeen is a charity registered in Scotland, No SC013683.
Received on Wednesday, 24 September 2008 09:40:37 UTC

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