Distributed Reasoner for Aligned Ontologies (DRAOn)
DRAOn is a reasoner which offers inference services for a network of aligned ontologies. It uses the OWL API to manipulate ontologies, the Alignment API to manipulate alignments, and HermiT reasoner for checking locally consistency of ontologies and alignments. The main feature of DRAOn is to perform reasoning in a distributed way over a network of aligned ontologies. The distributed behavior implemented in DRAOn is founded on IDDL (Integrated Distributed Description Logics). Details on this formalism can be found in Technical Report, Paper and first API.
DRAOn implements the following inferences:
- Checking consistency of a network that consists of a set of OWL ontologies connected by alignments. In this setting, DRAOn creates a unique OWL ontology, namely global ontology, that is obtained by merging the axioms of all ontologies and the correspondences of alignments. The underlying semantics of the global ontology is founded on standard Description Logics (DL);
- Checking entailment of an OWL axiom by a network of aligned ontologies whose axioms are merged into a global OWL ontology;
- Checking consistency of a network of aligned ontologies based on the IDDL semantics;
- Checking entailment of some kinds of OWL axioms by a network of aligned ontologies based on the IDDL semantics;
- DRAOn allows for reasonning with a network of aligned ontologies. In this context, DRAOn considers alignments as knowledge fragments independent from ontologies. If alignments would result from ontology reconciliation for establishing interoperability, reasoning with a network of aligned ontologies allows us to check whether this reconciliation process guarantees consistency of the whole network under a certain semantics.
- DRAOn supports reasoning on a network of aligned ontologies based on IDDL. The IDDL semantics is weaker that the DL semantics, that means, there is an IDDL consistent network of aligned ontologies that is not DL consistent. This results from the fact that IDDL considers alignments as "meta-knowledge" with respect to ontologies, that means, knowledge about ontologies. This would be more plausible in several cases where disjointness relationships between entities should not be propagated from an ontology to another one through alignments. Thanks to IDDL, we can define and check global consistency of a network of aligned ontologies without requiring that all formalisms used in ontologies are the same.
- DRAOn supports a distributed reasoning under the IDDL semantics that makes possible to distribute reasoning tasks over local ontologies to different locations (local reasoners). Although the number of messages exchanged between local reasoners and a global reasoner (that calls local reasoners) may be very high, an implementation taking advantage of parallelization and offline computation can improve dramatically response time to user's requests.
The current version (1.5)
In this version we implement optimizations for reducing the number of configurations to be considered and for improving communication protocol between global and local reasoners.
In addition, entailment services for the IDDL semantics are available for some kinds of concept axioms.
We have developed and implemented in this version new techniques whose behaviour is more goal-oriented than those implemented in early versions. The main ideas are:
- Configurarions (corresponding to sets of axioms that should be propagated) are built in an incremental way, and reused if possible results obtained from previous checks.
- For each configuration, we check entailment rather than consistency. This allows for putting forward eventual backtracking points.
- Communication protocole between global and local reasoners is parallelized, that means, requests are sent to local reasoners in a broadcasting way rather than the sequential one.
The inference services supporting the IDDL semantics are parallelized and implemented in a distributed way in this version. When defining a network of aligned ontologies, a global reasoner and several remote local reasoners are created. The global reasoner uses threads to manage communication between the remote reasoners and itself. We have to use sockets to establish the communication between global and local reasoners instead of OWLLink. This is due to effciency question and an intrinsic characteristic of IDDL. The readers can find more details about this here.
Instead of allowing for disjointness axioms in alignments, we implement entailment services by using the fact that the entailments $O_i \cup A \models C(a)$ and $O_i \cup A \models C \sqsubseteq D$ (we use $O_i$ to denote a set of ontologies, $A$ to denote a set of alignments, C(a) to denote that individual $a$ is an instance of class $C$, $C \sqsubseteq D$ to denote that $C$ is a subclass of $D$) can be achieved by propagating disjointness axioms to alignments and non-emptiness axioms to local ontologies. We refer the readers, who are interested in technical details, to this document where a deeper discussion can be found.
You can download DRAOn, uncompress the file DRAOn.zip obtained and execute the following command from a command line (Linux, Windows or Mac):
$ ant compileall
You can use directly iddl.jar from a Java programme.
How to call inference services offered by DRAOn from a Java programme
The most important reason for which we implement DRAOn in Java is portability. A Java programme can call directly the inference services implemented in DRAOn via its native interface. A tutorial is avaiable to show how to use this interface via examples.
$IUT de Montreuil, Universite de Paris8 $