an api for distributed reasoning on ...zimmermann/papers/keod2010.pdfan api for distributed...

AN API FOR DISTRIBUTED REASONING ON NETWORKEDONTOLOGIES WITH ALIGNMENTS

Chan Le Duc, Myriam LamolleIUT Montreuil, LIASD-University Paris 8, 140 rue de la Nouvelle France, 93100 Montreuil, France

Antoine ZimmermannDigital Enterprise Research Institute, IDA Business Park, Lower Dangan, Galway, Ireland

Keywords: Distributed reasoning, Ontology, Alignment, Networked ontologies, OWL.

Abstract: In this paper, we describe design and implementation of a Java interface for distributed reasoning on networkedontologies with alignments. This API is built over the standard OWLlink interface which is a communicationprotocol between OWL2 components. It is compatible with usual reasoners based on OWL such as Pelletand FaCT++ in centralized contexts. In this API, we have implemented an optimized distributed reasoningalgorithm which, on the one hand requires specific primitives to manipulate OWL ontologies and alignmentsbetween them, and on the other hand, provides services to check local and global consistency of networkedontologies with alignements. The main feature of this API is that it can be easily integrated in various editorsand tools dedicated to ontology manipulation.

1 INTRODUCTION

The Semantic Web is founded on technologies relatedto ontologies. An ontology can be built by using alanguage whose semantics is formal, e.g. OWL (On-tology Web Language1). This allows us to define un-ambiguously the meaning of new terms from a set ofatomic terms which can be concepts, relations or indi-viduals. Such an OWL ontology enables new knowl-edge to be inferred by using reasoners such as Pel-let (Sirin et al., 2007), FaCT++ (Tsarkov and Hor-rocks, 2006). In addition, an application domain canbe described by several ontologies which are relatedin some way. In this context, a reconciliation be-tween such ontologies can yield new pieces of knowl-edge which establish correspondences between enti-ties of two ontologies. A set of such correspondencesis called an alignment. (Borgida and Serafini, 2003)proposed a formalism, namely DDL (Distributed De-scription Logics), to represent a system of ontologieswith alignments. DRAGO reasoner 2 resulting fromthis work allows to check consistency of such systemand provides other applications related to alignment

1http://www.w3.org/TR/owl-features/2http://drago.itc.it/download.html

manipulations, e.g., alignment debugging and mini-mization.

The most of these reasoners have been integratedwithin ontology editors such as Protg, Swoop, etc.However, they are only usable through interfaces(API). These API are more and more numerous. Theyare often specific to reasoners (e.g. KAON2 API).The proliferation of APIs leads to two issues. Onthe one hand, a change of environment can imply tomodify source codes of an application and recom-pile them in order to be able to use a given rea-soner. On the other hand, there exist several rea-soners supporting different semantics such as stan-dard Description Logics (DL), Distributed Descrip-tion Logics (DDL) (Borgida and Serafini, 2003), Inte-grated Distributed Description Logics (IDDL) (Zim-mermann and Le Duc, 2008), etc.. This fact impliesthat specific APIs offer the same services, but withdifferent syntaxes. Developers must make efforts tolearn APIs on which their application depends.

To address this issue, a W3C working group pro-poses a new protocol, namely, OWLlink (Liebig et al.,2009). The main goal is to facilitate (i) the specifi-cation of reasoners with knowledge bases associated,(ii) the axiom specification, and (iii) the manner ofasking inferred results. This protocol seems to be par-

295Le Duc C., Lamolle M. and Zimmermann A. (2010).AN API FOR DISTRIBUTED REASONING ON NETWORKED ONTOLOGIES WITH ALIGNMENTS.In Proceedings of the International Conference on Knowledge Engineering and Ontology Development, pages 295-304DOI: 10.5220/0003101002950304Copyright c© SciTePress

ticularly interesting since it is extensible. This enablesus to add functionalities adequate to different kinds ofcurrent and future reasoners.

The main functionalities of the proposed API arecreation and checking consistency of a network ofOWL ontologies with alignments. In addition, it al-lows users to select a semantics associated to a givenontology network (e.g. DL, DDL, IDDL), and thusreasoner corresponding to the selected semantics isdetermined as well (Horridge et al., 2007). In thispaper, we focus on the IDDL reasoner3 which imple-ments the algorithm presented in (Zimmermann andLe Duc, 2008). This reasoner supports distributedreasoning services that allow us :• to deal with ontologies and ontology alignments

(i.e. an ontology network constituted of localOWL ontologies and their alignments),

• to check local and global consistency of a networkof OWL ontologies with alignments.Roughly speaking, the IDDL reasoner performs

the following tasks : (i) checking consistency ofalignments by using a global reasoner (e.g. Pellet),(ii) propagating knowledge from alignments to eachlocal ontology and asking consistency of the local on-tology with respect to the propagated knowledge, and(iii) collecting the consistency result from each localontology and deciding consistency of the whole sys-tem.

According to this schema, checking consistencyof each local ontology with respect to the knowledgepropagated from alignments can be carried out in-dependently by local reasoners. By consequent, thecomputation for deciding consistency of the wholesystem is performed in a distributed way.

In the following, we present the main features ofdifferent reasoners in Section 2. We introduce in Sec-tion 3 the new protocol OWLlink which facilitatescommunication between reasoners. We propose inSection 4 different ways to use the IDDL reasonerby our own Java API based on OWLlink. Section 5provides details on an optimized implementation ofthe algorithm presented in (Zimmermann and Le Duc,2008). Section 6 presents how to integrate the IDDLreasoner within the NeOn Toolkit 4. We conclude andpresent future work in Section 7.

2 EXISTING REASONERS

Reasoning on ontologies is essentially aimed to infernew knowledge. Reasoners can be also used to check

3http://gforge.inria.fr/projects/iddl4http://neon-toolkit.org/wiki

ontology consistency and to classify terms (classes orrelations) in an ontology.

2.1 Reasoners for Simple Ontology

Amongst existing reasoners, which have a Java in-terface and use OWL API, Pellet and FaCT++ arethe most common. Therefore, we claim that an APIused in distributed reasoners must be compatible withthem. We choose Pellet to experiment the integrationof new reasoners in a transparent way to end-user.The tested interface with Pellet remains identical toother open reasoners. In the context of distributed rea-soning supported by the IDDL reasoner, Pellet is usedto deal with reasoning at global level with alignments.

The OWL API has a standard interfaceorg.semanticweb.owl.inference.OWLReasonerwith several methods such as isConsistent(), is-Satisfiable(OWLClass), isEquivalent(OWLClass,OWLClass), etc. Pellet provides an implementationof these methods. In terms of interoperability withexisting reasoners, Pellet can be used with Jena asfollows:

import org.mindswap.pellet.jena.PelletReasonerFactory;

import com.hp.hpl.jena.rdf.model.InfModel;

import com.hp.hpl.jena.rdf.model.Model;

import com.hp.hpl.jena.rdf.model.ModelFactory;

import com.hp.hpl.jena.reasoner.Reasoner;

// creating Pellet reasoner

Reasoner reasoner =

PelletReasonerFactory.theInstance().create();

// creating empty model

Model emptyModel = ModelFactory.createDefaultModel();

// creating inference engine

// using Pellet reasoner

InfModel model = ModelFactory.createInfModel(reasoner,

emptyModel);

This interoperability ability makes Pellet easier tobe integrated within systems based on RDF ontolo-gies.

2.2 Reasoners for NetworkedOntologies

Another reasoners support distributed reasoning onontologies and alignments such as DRAGO5. Thepeer-to-peer DRAGO system uses a procedure basedon distributed tableau algorithm for reasoning withseveral ontologies interconnected by semantic map-pings. This distributed reasoner is built on the topof standard tableau reasoner as Pellet or FaCT++.The algorithm for distributed reasoning as describedin (Serafini and Tamilin, 2005) builds a distributed

5http://drago.itc.it/download.html

KEOD 2010 - International Conference on Knowledge Engineering and Ontology Development

296

tableau and consults the consistency of other localontologies. If there is a local ontology participatingto bridge rules (mappings) the algorithm consults an-other distributed reasoner at the peer where the localontology is located. This process may be propagatedin the whole network.

The major disadvantage of this algorithm is thatit requires a tableau-based reasoning for every peer.Therefore, the heterogeneity of reasoning mecha-nisms is impossible.

Moreover, DRAGO adopts the Pellet API byadding “D” to method signatures to dedicate dis-tributed reasoning (e.g., isDconsistent(), isDSatisfi-able()). However, this interface does not satisfy oneof our criteria (see Section 4) which says that thename of services (e.g. consistency, satisfiability) de-finable in two different semantics must not be differ-ent.

ContentMap6 is a tool supporting the integrationof independently designed ontologies by using map-pings. This tool uses the standard reasoners to gener-ate semantic consequences of integrated ontologies.It can help users to detect potential errors and toevaluate mappings. This work is comparable to thatof (Meilicke et al., 2009), who proposed a methodto help human experts to check automatically align-ments created. They used DDL to formalize map-pings as bridge rules, which exploit Drago to reasonwith alignments.

3 OWLlink PROTOCOL

If ontologies are expressed in OWL, it is necessaryalso to use standard communication to make easierinteractions between reasoners and different services,mainly in distributed ontology context. OWLlink(Liebig et al., 2009), successor of DIG protocol, isa Java implementation-neutral communication inter-face for OWL (Figure 1). It follows the new W3C rec-ommendations about extensible communication pro-tocols for systems based on OWL2 (Motik et al.,2009), which allows one to add new functionalities re-quired by specific applications. OWLlink overcomesdrawbacks of DIG protocol (Bechhofer et al., 2003)(Dickinson, 2004) since it relies on DIG2 proposi-tions (Turhan et al., 2006). OWLlink consists of twoparts: (i) structural protocol specification, and (ii) linkmechanism to transport protocols.

6http://krono.act.uji.es/people/Ernesto/contentmap

3.1 OWLlink Specification

OWLlink manages client/server communication (withHTTP protocol) by message through session (Wes-sel and Luther, 2009). Each message of re-quest type (requestMessage()) on ontology corre-sponds a response message (requestResponse()).These two message types embed respectively aset of objects Request and Response. Associ-ated with these messages, a mechanism of errormanagement informs the client about errors aris-ing from syntactic problems (SyntaxError), seman-tic problems (SemanticError) or ontology man-agement (KBError). Clients can get also infor-mation about server itself (GetDescription() andConfiguration()).

Moreover, OWLlink server can manage simulta-neously several ontologies by their IRI or by ontologyname. It can check axioms about classes, properties,or individuals. To do that, client must make a request(tell) embedding axioms to be checked.

In terms of interoperability, OWLlink provides amechanism enabling to encapsulate existing OWL-based reasoners (Pellet, FaCT++, etc.). This facili-tates system design which needs to deal with severalontologies associated with local reasoners. This abil-ity with client/server communication gives fundamen-tal elements on which a API dedicated to distributedreasoning can be elaborated.

3.2 Basic Primitives

OWLlink provides a set of basic primitives7 to accessontologies to obtain information about entities,status, schema and individual. For instance, theprimitive isKBDeclaredConsistent() checksontology consistency. Regarding the schema of on-tologies, the primitive isClassSatisfiable()and isClassSubsumedBy() allow to askwhether a class is satisfiable or a class is sub-sumed by another one. Finally, knowledgeabout individuals can be obtained by usingisInstanceOf(), areIndividualsRelated()or getEquivalentIndividuals(), etc.

4 IDDL REASONER INTERFACE

Zimmermann (Zimmermann, 2007) has introducedIDDL (Integrated Distributed Description Logics) as

7http://owllink-owlapi.sourceforge.net/documentation.html

AN API FOR DISTRIBUTED REASONING ON NETWORKED ONTOLOGIES WITH ALIGNMENTS

297

Figure 1: OWLlink Architecture (source http://owllink-owlapi.sourceforge.net/).

a new formalism enabling to represent a set of on-tologies with their alignments, i.e. networked on-tologies interconnected by alignments. Such a net-work consists of ontologies expressed by OWL, andalignments considered as a set of subsumption ordisjunction relations between ontology entities (con-cept/role/individual). This formalism is adapted par-ticularly to reason with OWL ontology alignment au-tomatically generated by tools as Alignment Server8.The differences between IDDL and other formalismsare:

1. In IDDL, alignments are considered as knowl-edge pieces independent from ontology knowl-edge. As a result, when knowledge is propagatedfrom alignments to local ontologies, new seman-tic consequences can be entailed.

2. IDDL does not make any expressiveness hypoth-esis over used formalisms in local ontology apartfrom decidability. This enables the heterogeneityof reasoning mechanisms and formalisms that areused in local ontologies. For instance, a local rea-soner uses a tableaux-based algorithm while an-other reasoner can decide consistency with helpof an automata-based algorithm.

3. IDDL supports a real distributed reasoning, i.e. allreasoning on local ontologies can be carried outindependently.

Like the most of reasoners, IDDL gives two mainservices: consistency checking and entailment. IDDLreasoner provides the two following interfaces:

1. “standalone” interface compatible with classicalreasoners (Pellet, FaCT++). The IDDL rea-soner consists of main class IDDLReasoner,which implements standard interfaceorg.semanticweb.owl.inference.OWLReasoner,

2. interface for distributed reasoning which is basedon OWLlinkReasoner presented in section 3.

It is important to note that the services availablein the IDDL API must have the same signature thatshould not depend on which reasoner associated with

8http://aserv.inrialpes.fr/

a semantics is used. Moreover, from users’ pointof view, this feature facilitates changes from a rea-soner to another, and corresponds to the fact that wecan talk about (the) consistency of a system includ-ing several logics in condition that the notion of con-sistency is generally definable for each one. This isthe case for a system consisting of DL (OWL), DDL,IDDL, etc.. Besides, distributed reasoners depend onAPIs for manipulating correspondences between on-tologies. For this purpose, the IDDL reasoner cur-rently uses the Alignment API (Euzenat, 2004). Itmay arise an issue if users replace a distributed rea-soner by another and they use different AlignmentAPIs.

4.1 Classical Reasoning with aStandalone Interface

Regarding classical reasoning, the IDDL reasonermerges all local ontologies and their alignments, thenapplies reasoning on the unique ontology. To do so,the IDDL reasoner provides the following primitives(where <domain>=fr.inrialpes.exmo.iddl):<domain>.IDDLReasoner.isConsistent() returnstrue if and only if the resulting ontology is consistent,<domain>.IDDLReasoner.isEntailed(OWLAxiom)returns true if and only if the axiom can be entailedfrom the resulting ontology,<domain>.IDDLReasoner.isEntailed(Alignment)returns true if and only if each axiom belongingto Alignment can be entailed from the resultingontology.

From this point of view, the OWLlink interface(presented in section 3) can be used to encapsulate theIDDL reasoner in the same way as classical reasoner(i.e. OWLReasoner). In this case, the IDDL reasonerwith the OWLlink protocol is comparable to a localIDDL system with regard to the global IDDL system.


298

4.2 Distributed Reasoning withOWLlinkReasoner

In distributed reasoning context, the IDDL reasonerconsists of global reasoner using also Pellet. More-over, the IDDL reasoner needs to know consistencyof each local extended ontology (Zimmermann andLe Duc, 2008) with the help of local associated rea-soners. The local reasoners can be Pellet, FaCT++,DRAGO, IDDL itself, etc., and they can be located indifferent sites. OWLlinkReasoner interface providesnecessary elements that the IDDL reasoner needs toensure communication between local and global rea-soners. Indeed, in order to define the method:

IDDLReasoner.addOntology(OWLOntology onto1,URL localReasoner);

the following code can be used:

URL reasonerURL = new URL( ... );OWLlinkReasoner reasoner =

new OWLlinkHTTPXMLReasoner(OWLOntologyManager manager,URL reasonerURL);

CreateKB createKB = new CreateKB();KB kb = reasoner.answer(createKB);IRI kbIRI = kb.getKB();// configuration : a set of global axiomsTell tell = new Tell(kbIRI,

OWLAxioms[] configuration);OK ok = reasoner.answer(tell);...

Roughly speaking, a configuration is a set of axiomspropagated from alignments to local ontologies. Thisnotion will be clarified in Section 5.

This code enables to associate a local ontol-ogy (createKB) to a local reasoner (reasonerwhich is responsible for deciding and transmit-ting the result (consistency) to the global reasoner(reasoner.answer(tell)) whether the localontology is consistent with respect to the con-figuration (new Tell(kbIRI, OWLAxioms[]configuration) ). The following code shows howto use the IDDL reasoner.

import fr.inrialpes.exmo.iddl.IDDLreasoner;import fr.inrialpes.exmo.iddl.types.Semantics;import org.semanticweb.owl.model.OWLAxiom;import org.semanticweb.owl.align.Alignment;...

IDDLReasoner reasoner = new IDDLReasoner();reasoner.addAlignment(URI onto1);reasoner.addAlignment(URI align1);reasoner.setSemantics(Semantics.DL);//check consistency of DL systemreasoner.isConsistent();//check entailment of an OWL axiom

reasoner.isEntailed(OWLAxiom ax);//check entailment of an alignmentreasoner.isEntailed(Alignment al);...

reasoner.addOntology(onto1);//associate a local reasoner to an ontology.reasoner.addOntology(URI onto1,

URL localReasoner1);reasoner.addAlignment(URI align1);reasoner.setSemantics(Semantics.IDDL);//check consistency of IDDL systemreasoner.isConsistent();

5 OPTIMIZATION ANDIMPLEMENTATION

This section briefly presents the principle of the algo-rithm for distributed reasoning and its implementationin the IDDL reasoner. This version does not allowdisjointness correspondences to occur in alignments.This restriction does not lead to a serious drawback ofthe expressiveness since alignments generated by themajority of matching algorithms do not often includedisjointness correspondences.

5.1 Algorithm and Optimization

The distributed algorithm implemented in the IDDLreasoner was presented in (Zimmermann and Le Duc,2008). However, the vocabulary used in (Zimmer-mann and Le Duc, 2008) differs from the one usedhere. According to the metamodel, wherever ontol-ogy is used in (Zimmermann and Le Duc, 2008), wecan replace it by module without loss of correctness.Where alignment is used in (Zimmermann and LeDuc, 2008), we use mapping here. Finally, a corre-spondence in (Zimmermann and Le Duc, 2008) is theequivalent of a mapping assertion here.

5.1.1 Preliminary Assumption

The IDDL reasoner works by having a module rea-soner communicate with imported modules’ reason-ers. The imported modules reasoners are supposedto be encapsulated so that their implementation is un-known but they can be used via an interface. Conse-quently, for each imported module mi, we assume thatthere exists an oracle Fi which takes a set of DL ax-ioms Ai as arguments and returns a boolean equal toConsistency(mi∪Ai).

Definition 1 (Reasoning oracle). Let O be an on-tology defined in a logic L. A reasoning oracle isa boolean function F : P L → Bool which returns


299

F(A) = ConsistencyL(O∪A), for all sets of axiomsA ∈ P L.

The term ontology in Defintion 1 is to be takenin a general sense. It can be a module or even a dis-tributed system, as long as the associated reasoner caninterpret DL axioms and offers correct and completereasoning capabilities. In practice, such oracles willbe implemented as an interface which encapsulates areasoner like Pellet, Fact++, or a module reasoner.

A module reasoner must call the oracles associ-ated with the imported modules with well chosen ax-ioms in order to determine consistency. The choice ofaxioms will be explained below. In addition, the mod-ule reasoner have access to the mappings that may ex-ist between imported modules. From the importingmodule’s point of view, these mappings are treatedlike local axioms. Therefore, we can consider thatthe mappings are equivalent to an ontology (calledthe alignment ontology in (Zimmermann and Le Duc,2008)).Definition 2 (Alignment ontology). Let A be a set ofmappings. The alignment ontology is an ontology Asuch that:

• for each mapping assertion i :C v←→ j : D with Cand D local concepts,– i :C and i :D;– i :C v i :D ∈ A;

• for each mapping assertion i : P v←→ j : Q with Pand Q local roles,– i :P and i :Q;– i :Pv i :Q ∈ A.In order to check the global consistency of the

module, we also assume that there is a reasoning or-acle FA associated to A. The algorithm consists inquestioning all the reasoning oracles with well cho-sen axioms that are detailed just below.

5.1.2 Algorithm Overview

In (Zimmermann and Le Duc, 2008), it is formallyproven that consistency checking of an IDDL systemwith only subsumption mapping assertions can be re-duced to determining the emptiness and non empti-ness of specific concepts. More precisely, we definethe notion of configuration, which serves to explic-itly separate concepts between empty concepts andnot empty concepts, among a given set of concepts.It can be represented by a subset of the given set ofconcepts, which contains the asserted non-empty con-cepts.Definition 3 (Configuration). Let C be a set of con-cepts. A configuration Ω over C is a subset of C .

In principle, a configuration Ω implicitly assertthat for all C ∈ Ω, C v ⊥ and for all C /∈ Ω, C(a) forsome individual a. A similar notion of role configu-ration is also defined in (Zimmermann and Le Duc,2008), but for the sake of simplicity we will onlypresent it for concepts.

The algorithm then consists in selecting a config-uration over the set of all concepts of the alignmentontology. The axioms associated with the configura-tion are then sent to the oracles to verify the consis-tency of the resulting ontologies. If they all return true(i.e., they are all consistency with these additional ax-ioms) then the modular ontology is consistent. Oth-erwise, another configuration must be chosen. If allconfigurations have been tested negatively, the mod-ular ontology is inconsistent, according to the proofin (Zimmermann and Le Duc, 2008). Since there is afinite number of configurations, this algorithm is cor-rect and complete.

The sets of axioms that must be used to query theoracles are defined according to a configuration Ω asfollows.Let A (resp. A1, . . . ,An) be the sets of axioms associ-ated with the oracles of the alignment ontology (resp.with the oracle of modules m1, . . . ,mn).For all imported modules mi,

• for all concepts i :C ∈Ω, i :C(a) ∈ A and C(aC) ∈Ai where a is a fixed individual and aC is a newindividual in mi.

• for all concepts i :C /∈ Ω, i :C v ⊥ ∈ A and C v⊥ ∈ Ai.

5.1.3 Optimization

We can identify, from the algorithm as describedabove, some situations that may lead to blow-up com-plexity.1. The algorithm will answer negatively if and only

if it has tested all possible configurations. So, ev-ery time a module is inconsistent, the reasonermust call all the oracles 2n times, where n is thenumber of concepts in the alignment ontology.This situation is hardly acceptable in a practicalreasoner.However, optimizations can be carried out to im-prove this situation. In particular, backtrack algo-rithms can be applied to this procedure. Indeed,for each concept C appearing in a mapping, itmust be decided whether it is empty or not. Thereare cases where it can be deduced that C is empty(resp. not empty) immediately. In this case, itnot necessary to test configurations where C is notempty (resp. empty). This can be visualized inFigure 2.


300

. . .. . .

. . .

Ck

Ck+1

Ck+2

Ck+3

Ck+4

Ck+5

Ck v⊥ Ck(a)

at most n

FIG. 2: At each node, the left branch indicates that the concept Ck is asserted as an empty concept (Ck v ⊥), while the rightbranch indicates a non empty concept (Ck(a)). The thick path indicates a possible configuration for the distributed system.

FIG. 3: An IDDL consistent system.

Figure 2: At each node, the left branch indicates that the concept Ck is asserted as an empty concept (Ck v⊥), while the rightbranch indicates a non empty concept (Ck(a)). The thick path indicates a possible configuration for the distributed system.

2. Theoretically, there are 2n possible global config-urations where n is the number of terms occuringin alignments. Each configuration Ω is of the formΩ= (X1, · · · ,Xn) where Xi =C(a) asserts the non-emptyness of the concept C or Xi = (C v ⊥) as-serts the emptyness of the concept C. We denoteXi = C(a) if Xi = (C v ⊥) and Xi = (C v ⊥) ifXi =C(a). It holds that Oi∪Ω is not consistent ifthere is Xi ∈ Ω such that Oi ∪Xi is not consis-tent.This observation allows the global reasoner to re-duce dramatically the number of checks on con-sistency of local ontologies since the global rea-soner can reuse the inconsistency result of Oi ∪Xi for all Xi ∈Ω and for all configuration Ω.

6 INTEGRATION OF THE IDDLREASONER WITHINNEONTOOLKIT

In this section we describe the principle of the integra-tion of the IDDL reasoner within the NeOn Toolkit.This integration is performed by developing a plug-in,namely IDDL reasoner plug-in, which plays an inter-face role between the IDDL reasoner and the NeOn-Toolkit plug-ins, e.g. the module API, Ontology Nav-igator, Alignment Plugin, etc..

The NeOn toolkit is an environment for managingand manipulating networked ontologies developed. Itwas developed within the NeOn project as a plug-infor managing ontologies under Eclipse and extendsprevious products such as KAON2. The NeOn toolkitfeatures run time and design time ontology alignmentsupport. It can be extended through a plug-in mecha-nism, so it can be customized to the users needs. As adevelopment environment for ontology management,the NeOn Toolkit supports the W3C recommenda-tions OWL and RDF as well as F-Logic for processingrules. With the support of the integrated mapping-

tool, named OntoMap, heterogeneous data sources,e.g., databases, file systems, UML diagrams, can beconnected to ontologies quickly and easily.

The IDDL reasoner API for ontology modulesuses the module API to access to alignments and im-ported modules of an ontology module. In otherterms, the IDDL reasoner plug-in is developed suchthat it can get access to the alignments and importedmodules from an ontology module and pass them tothe IDDL reasoner with help of the IDDL reasonerAPI.

More precisely, from the NeOn toolkit environ-ment the IDDL reasoner plug-in gets URIs of the im-ported modules and the alignments from an ontologymodule. In the most of cases where alignments are notavailable from the ontology module, the plug-in canfetch available alignments from an alignment serverand use them as alignments. This feature allows usersto use alignments permanently stored on servers andselect the most suitable alignments for an intendedpurpose.

The IDDL reasoner plug-in relies on the IDDLreasoner, and the core module API which providesbasic operations to manipulate ontology modules andalignments. By using the core module API, the IDDLreasoner plug-in can get necessary inputs from an on-tology module. In the case where the alignmentsobtained from the ontology module in question arenot appropriate, the plug-in can connect to Align-ment Server9 to fetch alignments available. For thispurpose, the plug-in offers to users an interface al-lowing to visualize and select alignments. Figure 3is a screenshot of the plugin integrated within NeonToolkit.

From a determined input, the IDDL reasoner plug-in can obtain an answer for consistency from theIDDL reasoner. In the case where the answer is neg-ative the plug-in can obtain an explanation indicatingconfigurations and/or correspondences which are re-sponsible for that inconsistency.

9http://aserv.inrialpes.fr/


301

Figure 3: An IDDL consistent system.

The answer time of the IDDL reasoner depends onthe following elements which are taken into accountin the optimized algorithm design.

1. If there are more unsatisfiable or non-empty con-cepts occurring in correspondences, the answertime is shorter,

2. If there are more equivalent concepts or proper-ties occurring in correspondences, the reasoneranswers faster,

3. If ontology module is inconsistent, the reasonerhas to check likely all configurations. Therefore,the answer time would be long.

In Example 4, we have two imported ontologies: Geopolitics and Geography with a mapping be-tween them. The axioms of the ontologies and map-ping are expressed in a description logic and they canbe directly coded in OWL. We consider the followingcases:

1. If these imported modules are merged with thecorrespondences of the mapping, we obtain anOWL ontology which is not consistent. The rea-son is that the mapping allows one to deduce thattwo classes ”EuropeanRegion” and ”SouthAmeri-canRegion” are not disjoint, which contradicts thedisjointness axiom in Geography.

2. However, in the context of ontology modules theIDDL reasoner can check consistency of the mod-

ule and answer that the module is consistent (Fig-ure 3).

3. If we now add to the following mapping1 : Guyana ∈↔ 2 : SouthAmericanRegion uEuropeanRegion, the IDDL reasoner answers thatthe module is no longer consistent.

7 CONCLUSIONS AND FUTUREWORK

In this paper, we argued that it is necessary to intro-duce a generic API for reasoners to facilitate envi-ronment changes without upgrading the current APIversion. Moreover, we suggested to use the same sig-nature of the reasoning services independently fromreasoners associated with a given semantics.

Then, we proposed a design and implementationof such an API which meets these two criteria. Fi-nally, we optimized and implemented in this APIa distributed algorithm for checking consistency ofnetworked ontologies with alignments based on theIDDL semantics.

Comparing to other approaches, e.g. the dis-tributed reasoning based on DLL, the IDDL dis-tributed reasoning is more modular and heteroge-neous, i.e., what global reasoner needs about a localontology is whether it is consistent. Thus, local on-tologies can use different logics in condition that they


302

Geopolitics(1)Woman(Cindy)Region(Guyana)

Geography(2)

Countryv RegionEuropeanRegion≡ Regionu∃partOf .EuropeSouthAmericanRegion≡ Regionu∃partOf .SouthAmericaEuropeanRegionv ¬SouthAmericanRegionTrans(partOf )Country(France)partOf (France,Europe)

1:Region ≡↔2:Region

1:Guyana ∈↔2:∃partOf .France

1:Guyana ∈↔2:SouthAmericanRegion

FIG. 4: An example of an ontology module with mappings

7 Conclusion and Future Work

In this paper, we argued that it is necessary to in-troduce a generic API for reasoners to facilitate envi-ronment changes without upgrading the current APIversion. Moreover, we suggested to use the same si-gnature of the reasoning services independently fromreasoners associated with a given semantics.

Then, we proposed a design and implementationof such an API which meets these two criteria. Fi-nally, we optimized and implemented in this APIa distributed algorithm for checking consistency ofnetworked ontologies with alignments based on theIDDL semantics.

Comparing to other approaches, e.g. the distribu-ted reasoning based on DLL, the IDDL distributedreasoning is more modular and heterogeneous, i.e.,what global reasoner needs about a local ontology iswhether it is consistent. Thus, local ontologies can usedifferent logics in condition that they remain to be de-cidable. This feature of IDDL provides possibility touse different algorithms for reasoning on local onto-logies.

The current version of the IDDL reasoner providesonly explanations for inconsistencies which are cau-sed by correspondences propagated from mappings tolocal ontologies. A future version of the IDDL reaso-ner should take advantages of explanations from localreasoners to give more details about how propagatedcorrespondences impact on a local ontology.

As mentioned at the beginning of the present sec-tion, the current version of the IDDL reasoner doesnot allow disjointness correspondences to occur in ali-gnments. This limitation prevents us from supportingaxiom entailment since it is equivalent to inconsis-tency of an IDDL system including disjointness cor-respondences. For instance, the current IDDL reaso-ner does not know whether 〈O,A〉 |= i:Cv j :D whereO, A are the sets of imported ontologies and map-pings from an ontology module.

In a future version, we plan to extend the reaso-ner such that it takes into account only disjointnesscorrespondences translated from entailment but notthose initially included in alignments. Allowing dis-jointness correspondences in this controlled way maynot lead to a complexity blow-up.

REFERENCES

Bechhofer, S., Moller, R., and Crowther, P. (2003). The DIGDescription Logic Interface. In Calvanese, D., editor,Proceedings of the International Workshop on Des-cription Logics (DL03), Volume 81 of CEUR., Rome,Italy.

Borgida, A. and Serafini, L. (2003). Distributed descriptionlogics : Assimilating information from peer sources.Journal Of Data Semantics, 1(1) :153–184.

Dickinson, I. (2004). Implementation experience with theDIG 1.1 specification. Technical report, Hewlett-Packard.

Figure 4: An example of an ontology module with mappings.

remain to be decidable. This feature of IDDL pro-vides possibility to use different algorithms for rea-soning on local ontologies.

The current version of the IDDL reasoner pro-vides only explanations for inconsistencies which arecaused by correspondences propagated from map-pings to local ontologies. A future version of theIDDL reasoner should take advantages of explana-tions from local reasoners to give more details abouthow propagated correspondences impact on a localontology.

As mentioned at the beginning of the present sec-tion, the current version of the IDDL reasoner doesnot allow disjointness correspondences to occur inalignments. This limitation prevents us from support-ing axiom entailment since it is equivalent to inconsis-tency of an IDDL system including disjointness corre-spondences. For instance, the current IDDL reasonerdoes not know whether 〈O,A〉 |= i:Cv j :D where O,A are the sets of imported ontologies and mappingsfrom an ontology module.

In a future version, we plan to extend the reasonersuch that it takes into account only disjointness corre-spondences translated from entailment but not thoseinitially included in alignments. Allowing disjoint-ness correspondences in this controlled way may notlead to a complexity blow-up.

REFERENCES

Bechhofer, S., Moller, R., and Crowther, P. (2003). The DIGDescription Logic Interface. In Calvanese, D., edi-tor, Proceedings of the International Workshop on De-scription Logics (DL03), Volume 81 of CEUR., Rome,Italy.

Borgida, A. and Serafini, L. (2003). Distributed descriptionlogics : Assimilating information from peer sources.Journal Of Data Semantics, 1(1):153–184.

Dickinson, I. (2004). Implementation experience with theDIG 1.1 specification. Technical report, Hewlett-Packard.

Euzenat, J. (2004). An API for Ontology Alignment. InThe Semantic Web - ISWC 2004: Third InternationalSemantic Web Conference,Hiroshima, Japan, Novem-ber 7-11, 2004. Proceedings, volume 3298 of LNCS,pages 698–712. Springer.

Horridge, M., Bechhofer, S., and Noppens, O. (2007). Ignit-ing the OWL 1.1 Touch Paper: The OWL API. In 3rdOWL Experienced and Directions Workshop, OWLED2007, Innsbruck, Austria.

Liebig, T., Luther, M., and Noppens, O. (2009). The owllinkprotocol. In OWLED.

Meilicke, C., Stuckenschmidt, H., and Tamilin, A. (2009).Reasoning support for mapping revision. In Journalof Logic and Computation.

Motik, B., Patel-Schneider, P., and Parsia, B. (2009). OWL2Web Ontology Language: Structural Specification andFunctional-Style Syntax. Technical report, WorldWide Web Consortium.

Serafini, L. and Tamilin, A. (2005). DRAGO: Distributedreasoning architecture for the semantic web. In Lec-ture Notes in in computer science, S., editor, Proceed-


303

ing of the 2nd European Semantic Web Conference,pages 361–376.

Sirin, E., Parsia, B., Grau, B. C., Kalyanpur, A., and Katz,Y. (2007). Pellet: a pratical owl-dl reasoner. Journalof Web Semantics, 5(2):51–53.

Tsarkov, D. and Horrocks, I. (2006). FaCT++ Descrip-tion Logic Reasoner: System Description. In LectureNotes in Artificial Intelligence, S., editor, Proceedingof the International Joint Conference on AutomatedReasoning.

Turhan, A.-Y., Bechhofer, S., Kaplunova, A., Liebig, T.,Luther, M., Noppens, O., Patel-Schneider, P., Sun-tisrivaraporn, B., and Weithner, T. (2006). DIG 2.0: Towards a Flexible Interface for Description LogicReasoners. In Proceedings of the OWL Experiencesand Directions Workshop (OWLED06) at the ISWC06,Athens, Georgia, USA.

Wessel, M. and Luther, M. (2009). OWLlink:HTTP/Functional Binding, Version 1.0. Technical re-port, W3C.

Zimmermann, A. (2007). Integrated distributed descriptionlogics. In Proceedings of the 20th International Work-shop on Description Logics (DL 2007), pages 507–514.

Zimmermann, A. and Le Duc, C. (2008). Reasoning with anetwork of aligned ontologies. In Proceedings of the2nd International Conference on Web Reasoning andsystem rules, LNCS 5341, pages 43–75.


304

an api for distributed reasoning on ...zimmermann/papers/keod2010.pdfan api for distributed...

Documents