OWL and backward chaining rules

Dear All,

I've been thinking about this for a while, but haven't made much 
progress, and was wondering if other people had some thoughts.

As people know, there has been much work done on integrating rules and 
ontologies. Much of the previous work on using rules allows one to 
control the direction of use, either in a forward or backward chaining 
direction. Although the closure of the inferences may be identical in 
both cases, they often have different practical uses.

In the examples below, I'm assuming that rules are unified with a set of 
facts from some ontology (i.e. Prolog style rules). I'm not clear on 
how/ whether one can incorporate backward chaining rules with an 
expressive DL (e.g. OWL-DL/ OWL1.1). My problem is that if we have some 
set of rules:

A(x) -> B(x)
B(x) -> C(x)
E(x) -> F(x)

where A,B,C,D,E are classes in the ontology, and C(x) is a subclass of E(x)

If we pose a query: ?C(x) then we can see that we should table B(x) as a 
query, and then (if that isn't satisfied) table A(x) as a query.

However, if we pose a query: ?F(x), then we can table E(x). But to know 
that we should then table C(x) as a query, we need some ontological 

In this case, we can reduce it to simply looking at the sub/super class 
relationships. However, given the nature of OWL-DL/OWL1.1, the T-Box 
defintion of E(x) could potentially be very complex, and each of those 
in turn could prompt many queries, etc., not all of which seem to be 
trivial to describe (for example, some cardinality constraints).

The reason I have chose OWL-DL/OWL1.1 is that for OWL-Lite and RDFS, it 
seems that we can use rules to make the inferences (e.g. in Jena) and so 
we could use these in a backward fashion, whereas there is no equivalent 
example for OWL-DL/OWL1.1

Any thoughts gratefully received.

+44 (0)7834 899570

Received on Friday, 18 January 2008 09:10:14 UTC