Semantic Web 0 (0) 1 1IOS Press

An Infrastructure for Probabilistic Reasoningwith Web OntologiesEditor(s): Pascal Hitzler, Wright State University, USAOpen review(s): Jie Tang, Tsinghua University, China; Jing Zhang, Tsinghua University, China; one anonymous reviewer

Jakob Huber a Mathias Niepert b Jan Noessner c Joerg Schoenfisch a Christian Meilicke a

Heiner Stuckenschmidt a

a Data- and Web Science Group, University of Mannheimb Department of Computer Science, University of Washingtonc Semanticsoftware, Sydney

Abstract. We present an infrastructure for probabilistic reasoning with ontologies based on our Markov logic engine ROCKIT.Markov logic is a template language that combines first-order logic with log-linear graphical models. We show how to translateOWL-EL as well as RDF schema to Markov logic and how to use ROCKIT for applying MAP inference on the given set offormulas. The resulting system is an infrastructure for log linear logics that can be used for probabilistic reasoning with bothextended OWL-EL and RDF schema. We describe our system and illustrate its benefits by presenting experimental results for twotypes of applications. These are ontology matching and knowledge base verification, with a special focus on temporal reasoning.Moreover, we illustrate two further use cases which are Activity Recognition and Root Cause Analysis. Our infrastructure hasbeen applied to these use cases in the context of a cooperation with industry partners. The experiments indicate that our system,which is based on a well-founded probabilistic semantics, is capable of solving relevant problems as good as or better than stateof the art systems that have specifically been designed for the respective problem. Moreover, the heterogeneity of the presenteduses cases illustrates the wide applicability of our infrastructure.

Keywords: Ontologies, Reasoning, Markov Logic, RDF Schema, Log-linear Logics

1. Motivation

Originally, the idea of the Semantic Web was builton formal ontologies and logical reasoning leading tothe development of description logic-based ontologylanguages, in particular the Web Ontology LanguageOWL. The advantages of logical reasoning on the webhas been argued by many researchers in terms of veri-fying information models and extending query resultsto implicit information. While in particular, the devel-opment of light-weight ontology languages and the useof database techniques for ontology-based data accesshas given another boost to the use of logical models(e.g. [7]), it has also become more and more clear thatlogical reasoning alone is not enough for many Seman-tic Web applications. In particular, use cases that re-

quire a combined processing of structured and unstruc-tured data (i.e. free text) can often not be adequatelyhandled by logical methods alone. On the other hand,abandoning logical reasoning and completely relyingon machine learning techniques for handling unstruc-tured data seems like throwing out the child with thebathwater. Therefore, research on the (Semantic) Webhas focused on methods that combine structured repre-sentations with statistical inference. One possible ap-proach is the extension of machine learning methods tocomplex structural features [11], the other is to extendlogical reasoning in Semantic Web languages towardsstatistical inference. In this paper, we present a soft-ware infrastructure that implements the second way- an extension of logical reasoning in Semantic Weblanguages with statistical inference [32]. In particular,

1570-0844/0-1900/$27.50 c© 0 – IOS Press and the authors. All rights reserved

2 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

we focus on the task of computing the most probableconsistent ontology from a set of possibly inconsis-tent axioms some of which are not certain and have aweight attached that can be used to resolve inconsis-tencies given a probabilistic interpretation. This corre-sponds to the maximum a posteriori (MAP) inferencein statistical relational models as opposed to marginalinference, which aims at computing the probability ofa certain assertion given evidence in terms of a knowl-edge base. Our approach is based on an encoding ofdescription logics into Markov logic networks that en-ables reasoning about description logics that supportconsequence-driven reasoning.

Related Work The extension of web languages to-wards statistical inference has been addressed by anumber of researchers leading to various extensions ofthe OWL language with notions of probability usingdifferent approaches including non-monotonic reason-ing, probabilistic logic programming, Bayesian net-works and Markov logic. The probabilistic descrip-tion logic P − SROIQ [31] is an expressive de-scription logic that combines conditional probabili-ties about concepts and statements expressing uncer-tain knowledge about instances. The logic supportsprobabilistic knowledge base consistency checkingand lexicographic entailment. Both are probabilisticversions of non-monotonic reasoning where consis-tency can be achieved by preferring more specific as-sertions over less specific ones and calculating upperand lower bounds for the probabilities of the result-ing statements. The corresponding methods have beenimplemented in the PRONTO system [27]. Riguzziand others adapt the semantics of probabilistic logicprograms as introduced in [12] to description logicsdefining the DISPONTE approach for probabilistic on-tologies. DISPONTE can answer queries over prob-abilistic ontologies using binary decision diagrams.The corresponding methods have been implementedin the BUNDLE reasoner [41,5]. Both reasoners havebeen integrated into the Pellet description logic sys-tem. DISPONTE clearly aims at computing probabilis-tic query answers which corresponds to marginal in-ference rather than MAP inference. PR-OWL [8,9] isa language based on the multi-entity Bayesian net-work (MEBN) logic [29]. MEBNs specify a first-orderlanguage for modeling probabilistic knowledge basesas parametrized fragments of Bayesian networks. PR-OWL adds new elements to the OWL standard whichenables to create MEBNs as part of an ontological

model and thus supporting probabilistic reasoning, al-though providing only a limited integration of logi-cal and probabilistic reasoning. Parts of the PR-OWLlanguage were implemented in the tool UNBBAYES-MEBN [10] which provides a GUI and a translationof MEBN to classical Bayesian networks. Based onthe translation to Bayesian networks, PR-OWL canin principle compute both MAP and marginal infer-ence. To the best of our knowledge, INCERTO1 isthe only reasoner which uses Markov logic for proba-bilistic description logics. It directly translates the de-scription logic axioms to Markov logic so that con-cepts correspond to unary predicates, roles correspondto binary predicates, and individuals to constants. Thedescription logic axioms are translated to first-orderlogic formulas. The objective of INCERTO is to learnthe weights of axioms through the analysis of indi-viduals. Furthermore, they provide exact and approx-imate marginal inference. However, computing themost probable coherent ontology is not supported.Due to the direct translation of the logical model intoMarkov logic and the implicit closed world assump-tion introduced on the Markov logic level, it is unclearwhether the system can guarantee complete reasoningwith respect to the description logic used.

In this paper, we first provide a comprehensiveoverview of our Markov logic engine ROCKIT, whichto be best of our knowledge currently is the most per-formant and scalable Markov logic reasoner with re-spect to MAP inference. We give a brief introductionto Markov logic as an underlying formalism and ex-plain how ROCKIT computes the most probable modelby an efficient encoding of the problem as a linear inte-ger program (see Section 3). After providing some de-tails about the optimized implementation of ROCKIT,we introduce the notion of log-linear logics which pro-vides the formal foundation for a sound and completeencoding of description logics and related formalismsinto Markov logic, and describe two concrete logicsthat corresponds to probabilistic versions of OWL-ELand RDFS (see Section 4). We then present success-ful applications of the approach to relevant SemanticWeb problems, in particular knowledge base verifica-tion and ontology matching (see Section 5). Further-more, we demonstrate the impact of the system in tworeal-world use cases in Section 6. We close with a dis-cussion of the benefits and limitations of our infras-tructure in Section 7.

1https://code.google.com/p/incerto/

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 3

Cutting Plane Aggregation Metainference

GurobiMySQL

RDF Schema Interface

OWL-EL Interface

Ro

ckIt

Mar

kov

Logi

cEn

gin

eSe

m. W

eb

Inte

rfac

e

Website REST API

We

bIn

terf

ace

Fig. 1. Overview of the system architecture

2. System Architecture

We present a software architecture (see Figure 1)that bundles a series of systems which enable proba-bilistic reasoning in the context of the Semantic Web.The system is available at http://executor.informatik.uni-mannheim.de/. The core ofthe presented system is the ROCKIT Markov logic en-gine. It is specialized for executing maximum a poste-riori (MAP) inference in Markov Logic Networks. Forthis purpose, it takes advantage of a database (MySQL)and an integer linear program solver (Gurobi) (see Sec-tion 3). Based on this core system, we provide inter-faces for specific probabilistic reasoning tasks. In par-ticular, the "Semantic Web Interface" supports prob-abilistic reasoning for OWL-EL and RDFS (see Sec-tion 4). The web interface has the purpose to bundledifferent reasoning interfaces and to make them avail-able in a convenient way, i.e., through a user interfaceand an API.

The reasoners are made available by a web inter-face that allows executing different tasks. Hence, theycan be used without installing them on a local ma-chine which would involve setting up a database man-agement system as well as an integer linear programsolver. We offer a web site and REST interfaces to ac-cess the services. The web site provides a description,usage examples of the different reasoners and forms toupload files and to initiate the reasoning process. Ad-ditionally, the REST interfaces support the most im-portant features and allow developers of other applica-tions to use our services and to integrate them in their

Fig. 2. View of a terminated process.

systems. As the infrastructure can be accessed by mul-tiple users at the same time, we implemented a wait-ing line that ensures that the system processes at mostone reasoning task at a time. This is necessary as it de-creases the chance of overloading but it also makes theruntimes comparable.

The system creates a unique identification key foreach added process that can be used to identify a spe-cific process in the process database. For each processwe keep track of relevant statistics and useful informa-tion. Therefore, we record the time and the date when aprocess was added to the waiting list, when the execu-tion was started and when it terminated. Moreover, westore the input information which includes the selectedreasoning method as well as the chosen parameter set-tings and input files (see Figure 2). We also presentthe console output of the underlying reasoning systemduring the execution in real-time which helps to keeptrack of the execution of a process.

The web interface is written in Python and uses theweb application framework "Pylons"2. Its internal ar-chitecture allows integrating other (reasoning) system.In fact, it is possible to add any system that is compat-ible with the Linux distribution Debian.

3. The ROCKIT Engine

The foundation of our system is the ROCKIT rea-soning engine [37], a state of the art reasoning enginefor Markov logic networks. ROCKIT is specialized on

2www.pylonsproject.org/projects/pylons-framework

4 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

performing maximum a posteriori (MAP) inference.Each MAP query corresponds to an optimization prob-lem with linear constraints and a linear objective func-tion and, hence, ROCKIT formulates and solves theproblem as an instance of integer linear programming(ILP). This is done in several iterations where the novelcutting plane aggregation approach (CPA) is tightly in-tegrated with cutting plane inference (CPI) which is ameta-algorithm operating between the grounding algo-rithm and the ILP solver [40]. Instead of immediatelyadding one constraint for each concrete instantiationof a general formula to the ILP formulation, the ILP isinitially formulated so as to enforce the given evidenceto hold in any solution. Based on the solution of thismore compact ILP one determines the violated con-straints, adds these to the ILP, and resolves. This pro-cess is repeated until no constraints are violated by anintermediate solution. In the following, we provide abrief introduction to Markov logic as well as RockIt’sapproach to efficient maximum a posteriori (MAP) in-ference.

3.1. Markov Logic

Markov logic is a first-order template language com-bining first-order logic with log-linear graphical mod-els. We first review function-free first-order logic [16].Here, a term is either a constant or a variable. An atomp(t1, ..., tn) consists of a predicate p/n of arity n fol-lowed by n terms ti. A literal ` is an atom a or its nega-tion ¬a. A clause is a disjunction `1 ∨ ... ∨ `k of liter-als. The variables in clauses are always assumed to beuniversally quantified. The Herbrand base H is the setof all possible ground (instantiated) atoms. A groundatom is an atom where every variable is replaced by aconcrete value. Every subset of the Herbrand base is aHerbrand interpretation.

A Markov logic network M is a finite set of pairs(Fi, wi), 1 ≤ i ≤ n, where each Fi is a clause infunction-free first-order logic and wi ∈ R [39]. To-gether with a finite set of constants C = {c1, ..., cn}it defines the ground Markov logic networkMC withone binary variable for each grounding of predicatesoccurring in M and one feature for each groundingof formulas in M with feature weight wi. Hence, aMarkov logic network defines a log-linear probabil-ity distribution over Herbrand interpretations (possibleworlds)

P (x) =1

Zexp

(∑i

wini(x)

)(1)

where ni(x) is the number of satisfied groundings ofclause Fi in the possible world x and Z is a normal-ization constant.

In order to answer a MAP query given evidence E =e, one has to solve the maximization problem

arg maxx

P (X = x | E = e)

where the maximization is performed over possibleworlds (Herbrand interpretations) x compatible withthe evidence.

3.2. ILP Formulation of Markov Logic Networks

Since we are employing cutting plane inference(CPI), ROCKIT retrieves in each iteration the groundclauses violated by the current solution. Hence, in eachiteration of the algorithm, ROCKIT maintains a set ofground clauses G that have to be translated to an ILPinstance. RockIt associates one binary ILP variable x`

with each ground atom ` occurring in some g ∈ G.For a ground clause g ∈ G let L+(g) be the set ofground atoms occurring unnegated in g and L−(g) bethe set of ground atoms occurring negated in g. Now,we encode the given evidence by introducing linearconstraints of the form x` ≤ 0 or x` ≥ 1 dependingon whether the evidence sets the corresponding groundatom ` to false or true. For every ground clause g ∈ Gwith weight w > 0, w ∈ R, we add a novel binaryvariable zg and the following constraint to the ILP:∑

`∈L+(g)

x` +∑

`∈L−(g)

(1− x`) ≥ zg.

Please note that if any of the ground atoms ` in theground clause is set to false (true) by the given evi-dence, we do not include it in the linear constraint.

For every g with weight wg < 0, w ∈ R, we adda novel binary variable zg and the following constraintto the ILP:∑`∈L+(g)

x`+∑

`∈L−(g)

(1−x`) ≤ (|L+(g)|+|L−(g)|)zg.

For every g with weight wg = ∞, that is, a hardclause, we add the following linear constraint to theILP: ∑

`∈L+(g)

x` +∑

`∈L−(g)

(1− x`) ≥ 1

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 5

Table 1A set of ground clauses that can be aggregated.

g `i c w

g1 x1∨ ¬y1 ∨ y2 1.0g2 x2∨ ¬y1 ∨ y2 1.0g3 ¬x3∨ ¬y1 ∨ y2 1.0g4 ¬x4∨ ¬y1 ∨ y3 1.0g5 x5∨ ¬y1 0.5

`i c w

x1∨¬y1 ∨ y2 1.0x2∨

¬x3∨¬x4∨ ¬y1 ∨ y3 1.0x5∨ ¬y1 0.5

Finally, the objective of the ILP is:

max∑g∈G

wgzg,

where we sum over weighted ground clauses only, wg

is the weight of g, and zg ∈ {0, 1} is the binary vari-able previously associated with ground clause g. Wecompute a MAP state by solving the ILP whose solu-tion corresponds one-to-one to a MAP state x wherexi = true if the corresponding ILP variable is 1 andxi = false otherwise.

3.3. Constraint Aggregation

The ILP defined in the previous section can be sim-plified by aggregating groups of similar constraints.The resulting ILP has fewer variables, fewer con-straints, and its context-specific symmetries are moreexposed to the ILP solver’s symmetry detection heuris-tics. We present the general idea implemented inROCKIT and illustrate it by an example. Formal detailscan be found in [37].

First we define which subsets G of G can be aggre-gated to a single constraint.

Definition 1. Let G ⊆ G be a set of n weighted groundclauses and let c be a ground clause. We say that Gcan be aggregated with respect to c if (a) all groundclauses in G have the same weight and (b) for everygi ∈ G, 1 ≤ i ≤ |G|, we have that gi = `i∨c where `iis a (unnegated or negated) literal for each i, 1 ≤ i ≤|G|.

Table 1 illustrates an example. The subset G ={g1, g2, g3} can be aggregated with respect to ¬y1∨y2,while g4 and g5 can be aggregated only as singletonsets, which does not yield in an advantage over thestandard way of generating the ILP. The standard wayof translating g1, g2 and g3, ignoring the possibility of

an aggregation, would result into the following ILP.

max 1.0z1 + 1.0z2 + 1.0z3 subject to

x1 + (1− y1) + y2 ≥ z1

x2 + (1− y1) + y2 ≥ z2

(1− x3) + (1− y1) + y2 ≥ z3

Note that z1, z2, and z3 are binary variables within thisILP. By using instead of that a single integer variablez, all ground clauses in G can be taken into account asa whole within the following ILP.

max 1.0z subject to

x1 + x2 + (1− x3) + 3((1− y1) + y2) ≥ z

z ≤ 3

This translation follows a general pattern for positiveweights and a similar pattern for negative weights. Asa result of this simplification the number of constraintscan be reduced significantly resulting in a notably im-proved runtime behavior of the system. The generalapproach is called cutting plane aggregation (CPA).

3.4. Implementation

Figure 3 depicts the computational pipeline of thesystem. After pre-processing the input MLN and load-ing it into the relational database system, ROCKIT per-forms CPI iterations until no new violated constraintsare found. The violated constraints are computed withjoins in the relational database system where each ta-ble stores the predicate groundings of the intermedi-ate solutions. In each CPI iteration, ROCKIT performsCPA on the violated constraints. We can parallelizethe aggregation steps by processing each first-orderformula in a separate thread. To this end, each first-order formula is initially placed on a stack S. ROCKITcreates one thread per available core and, when idle,makes each of the threads (i) pop a first-order formulafrom the stack S, (ii) compute the formula’s violatedgroundings, and (iii) perform CPA on these ground-ings. The aggregated groundings are compiled into ILPconstraints and added to the ILP formulation. Whenthe stack S is empty and all threads idle we solve thecurrent ILP in parallel, obtain a solution, and begin thenext CPI iteration.

There are different possible strategies for finding theground clauses c that minimize the number of countingconstraints per first-order formula which is required

6 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

Preprocessing

Add aggregated constraints to ILP

Return MAP state

core

1

core

n

...

New violated constraints found?

yes

no

Find violated constraints and perform CPA

Parallel branch & bound

Fig. 3. ROCKIT parallelizes constraint finding, constraint aggrega-tion, and ILP solving.

for CPA. This problem can be solved optimally, how-ever, we implemented a greedy algorithm that onlyestimates the optimal aggregation scheme, since ex-periments showed that optimal algorithms dominatethe ILP solving itself. The algorithm stores, for eachfirst-order clause, the violated groundings of the form`1 ∨ . . . ∨ `n in a table with n columns where eachcolumn represents one literal position of the clause.For each column k, ROCKIT computes the set of dis-tinct rows Rk of the table that results from the pro-jection onto the columns {1, ..., n} \ {k}. Let d =arg mink{|Rk|}. The clause groundings are then ag-gregated with respect to the rows in Rd.

ROCKIT employs MYSQL’s in-memory tables forthe computation of violated constraints and the ag-gregation. Most tables are hash indexed to facilitatehighly efficient join processing. We use GUROBI3 asROCKIT’s internal ILP solver due to its ability to paral-lelize its branch, bound, and cut algorithm, its remark-able performance on standard ILP benchmarks [28],and its symmetry detection heuristics.

We have tested the efficiency of ROCKIT and com-pared it against other state of the art Markov Logicsolvers on several benchmarks. These benchmarksstem from different applications like Entity Resolu-tion, Information Extraction and Protein Interaction.The Protein Interaction dataset, which is the largestdataset, has 40,234,321 ground clauses. In most test-cases ROCKIT was able to generate the correct results

3http://www.gurobi.com/

in a few seconds. For the Protein Interaction datasetROCKIT required 13 seconds, while the other systemswere 30 times slower or failed completely to generateany results. The details of this evaluation are availablein Section 6 in [36].

4. The Semantic Web Interface

The ROCKIT system introduced in the previous sec-tion is a generic Markov logic engine that does not di-rectly target languages relevant for the Semantic Webcommunity. In this section we show how SemanticWeb languages, in particular description logics andRDF Schema based formalisms, can be transformed toMarkov logic while preserving their original seman-tics. This translation approach, to which we refer aslog-linear logics, makes the power of the ROCKIT sys-tem available for Semantic Web applications.

4.1. Log-Linear Logics

Log-linear (description) logics have been introducedby Niepert and others as a framework for encodingnon-trivial logics into probabilistic reasoning using thenotion of log-linear models [35]. A log-linear logicknowledge base KB consists of a deterministic knowl-edge base CD and an uncertain knowledge base CU.CD contains axioms in some logic L that supports avalid entailment relation |=L and notion of contradic-tion ⊥L. The uncertain knowledge base is defined asCU = {(c, wc)} where c is also an axiom in L andwc is a real-valued weight assigned to c. CD representsdefinite knowledge about the world, whereas CU con-tains axioms for which only a degree of confidence isavailable. The certain knowledge base is assumed to benon-contradictory, i.e. CD 6|=L ⊥L. The semantics of alog-linear logic is based on joint probability distribu-tions over the uncertain knowledge base. In particular,the weights of the axioms in CU determine a log-linearprobability distribution in a similar way as it is the casefor Markov logic models introduced earlier.

For a given log-linear knowledge base (CD, CU) andsome (certain) knowledge base C′ over the same sig-nature, the probability of C′ is defined as

P (C′)=

1Zexp

(∑{(c,wc)∈CU:C′|=c} wc

)if C′ 6|=L ⊥L

and C′ |=L CD;0 otherwise

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 7

where Z is the normalization constant of the log-linear probability distribution P .

The notion of a log-linear logic provides a means forinterfacing Semantic Web languages with the ROCKIT

engine in the following way:

– We define a Markov logic predicate for each typeof axiom supported by the language. For this pur-pose, the axioms in the knowledge base typicallyhave to be normalized in an appropriate way.

– We encode the entailment relation |=L usingMarkov logic rules over the predicates represent-ing the different axiom types.

– We define the notion of contradiction ⊥L byadding a set of first order rules that results into aninconsistent set of first-order formulas whenever,with respect to the semantics of L, a logically un-desired behavior occurs.

This approach naturally limits the applicability ofthe framework to languages that can be normalized to afinite set of axiom types and whose entailment relationcan be modeled using Markov logic rules. In SemanticWeb research such languages have been studied in con-nection with the notion of consequence-driven reason-ing [26], providing us with a set of possible languageswe can extend towards probabilistic reasoning. In thefollowing, we discuss two of these languages that wehave implemented in our infrastructure.

4.2. The OWL-EL Interface

Computing the MAP state for a log-linear knowl-edge base that contains OWL-EL axioms requires firstto map the different axioms to a first-order repre-sentation. As it has been shown that any OWL-ELknowledge-base can be normalized into an equivalentknowledge base that only contains 6 types of axioms,we can map it into Markov logic predicates using thefollowing set of mapping rules.

C1 v D 7→ sub(C1, D)C1 u C2 v D 7→ int(C1, C2, D)C1 v ∃r.C2 7→ rsup(C1, r, C2)∃r.C1 v D 7→ rsub(C1, r,D)r v s 7→ psub(r, s)r1 ◦ r2 v r3 7→ pcom(r1, r2, r3).

The first-order predicates in this listing are typed,meaning that r, s, ri, (1 ≤ i ≤ 3), are role names,

Table 2Completion rules for OWL-EL.

F1 ∀c : sub(c, c)

F2 ∀c : sub(c,>)

F3 ∀c, c′, d : sub(c, c′) ∧ sub(c′, d)⇒ sub(c, d)

F4 ∀c, c1, c2, d : sub(c, c1) ∧ sub(c, c2) ∧ int(c1, c2, d)

⇒ sub(c, d)

F5 ∀c, c′, r, d : sub(c, c′) ∧ rsup(c′, r, d)⇒ rsup(c, r, d)

F6 ∀c, r, d, d′, e : rsup(c, r, d) ∧ sub(d, d′) ∧ rsub(d′, r, e)

⇒ sub(c, e)

F7 ∀c, r, d, s : rsup(c, r, d) ∧ psub(r, s)⇒ rsup(c, s, d)

F8 ∀c, r1, r2, r3, d, e : rsup(c, r1, d) ∧ rsup(d, r2, e)

∧pcom(r1, r2, r3)⇒ rsup(c, r3, e)

F9 ∀c : ¬sub(c,⊥)

C1, C2 basic concept descriptions, and D basic con-cept descriptions or the bottom concept. Note that ax-ioms involving complex concept descriptions can betransformed into a normalized representation by apply-ing a finite set of normalization rules introducing newconcept and role names [3].

The translation of CD and CU results in unweighted(hard) and weighted first order formulas. The hard for-mulas are used, together with the completion rules de-scribed in the following paragraph, to decide whetherfor a potential MAP state C′ we have C′ 6|=EL ⊥EL andC′ |=EL CD. To our knowledge there exists no com-monly accepted proposal related to adding weights orprobabilities to OWL axioms. In our implementationwe are using annotation properties to add weights toaxioms.

The completion rules of the formalism, in this caseOWL-EL, which corresponds to the description log-ics EL++, are listed in Table 2. By adding these rulesas constraints to the Markov logic formalization, weare able to support complete reasoning mechanisms forEL++, i.e., we re-define |=EL by adding the respectivereasoning rules as first-order formulas in our Markovlogic formalization. Given a concrete reasoning prob-lem, the resulting MAP state will always contain themost probably non contradictory subset of CU that en-tails the previously known axioms CD.

Note that rule F9 does not belong to the completionrules for EL++. This rule takes the notion of incoher-ence into account. An incoherent ontology is an ontol-ogy that contains an unsatisfiable concept, i.e., a con-cept that is subsumed by ⊥. Usually, an unsatisfiableconcept indicates that the ontology contains a contra-dictory set of axioms. An incoherent ontology is notnecessarily inconsistent, Thus, we added rule F9 which

8 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

allows us to extend the notion of contradiction ⊥EL

from inconsistency to incoherence.For more technical details on applying the princi-

ple of log-linear logic to OWL-EL, we refer the readerto [35]. The reasoner that we have implemented fol-lowing the described approach is called ELog.4

4.3. The RDF Schema Interface

While the OWL-EL interface was mainly designedfor terminological reasoning, the focus of the RDFSinterface is rather on reasoning tasks related to theA-Box. A RDF [20] knowledge base contains state-ments of the form (subject, predicate, object).Such statements can be seen as the only axiom typepresent in an RDF Schema knowledge base. Thus, weonly need to define one general first-order logic predi-cate to which all RDF statements can be transformed:

(s, p, o) 7→ triple(s, p, o)

We decided to use this modeling as it is flexible andcovers all possible RDF statements. In order to at-tach weights to RDF statements, we rely in our im-plementation on the concept of reification and annota-tion properties. Our system relies on the RDF(S) en-tailment rules [6] as a standard rule set. Using thepredicate triple(s, p, o), we define the entailment rela-tion |=RDFS by mapping the RDF(S) entailment rulesto first-order formulas. For instance, we state the rulerdfs11 which expresses the transitivity of the propertyrdfs:subclassOf as follows:

triple(x, rdfs:subClassOf, y) ∧

triple(y, rdfs:subClassOf, z) ⇒

triple(x, rdfs:subClassOf, z).

We define formulas for the other RDF(S) completionrules in the same way. Moreover, it is possible to ex-tend the basic set of completion rules by defining ad-ditional rules and constraints in order to cover a widerange of application scenarios. In partiuclar, pure RDFSchema reasoning does not have a notion of contra-diction. We therefore introduce notions of contradic-tion by adding special rules. For example, if one mightwant the reasoner to cover the semantics of the prop-

4http://executor.informatik.uni-mannheim.de/systems/elog/

erty owl:disjointWith, the rule set can be extended:

triple(c1, owl : disjointWith, c2) ∧

triple(x, rdf : type, c1) ⇒

¬triple(x, rdf : type, c2).

This is only one of the required rules to cover the se-mantics of owl : disjointWith. Our formalism canbe extended by such rules depending on the require-ments of a specific use case. By executing the MAPinference, the reasoner determines for each poten-tial MAP state C′ if C′ 6|=RDFS+ ⊥RDFS+ andC′ |=RDFS+ CD holds. Thereby, the system resolvesnot only the detected inconsistencies but is also ableto infer new facts. Hence, the MAP state correspondsto the most probable consistent subset of facts and allassertions that can be entailed from that subset.

We adapted our reasoning system to the specialcase of probabilistic temporal reasoning. Addition-ally to adding weights to RDF statements, it is pos-sible to assign a temporal interval, which consists ofa start point and end point, resulting in statements ofthe form 〈triple(s, p, o)[start , end ]〉. The interval ex-presses the validity time of a fact [18,19]. Consideringthe temporal relations of events, it is possible to extendthe set of constraints in order to detect inconsistencies.For this purpose, the reasoning system incorporates thetemporal predicates (e.g. before, during, . . . ) of Allen’sinterval algebra [1] that can be used to express suchconstraints. The proposed approach is implemented bythe reasoner T-RDFS-LOG.5

5. Applications

In [38] we have applied the OWL-EL interface toimprove automatically generated ontology alignments,while in [23] we have shown how to use the meth-ods available via the RDF schema interface to debug aprobabilistic temporal knowledge base. Within the fol-lowing two sections we summarize these applicationsand the experimental results to illustrate the generalapplicability of our framework.

5http://executor.informatik.uni-mannheim.de/systems/t-rdfs-log/

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 9

5.1. Ontology Matching

Ontology matching is concerned with the task ofconstructing an alignment A between two ontologiesO1 and O2. An alignment is a set of mappings usu-ally interpreted as equivalence axioms between con-cepts and properties ofO1 andO2. Most matching sys-tems annotate mappings with a confidence value thatexpresses the trust in the correctness of the generatedmapping. Thus, we have a perfect setting for apply-ing ELog: The alignment A can be interpreted as a setof uncertain, weighted equivalence axioms CU, whileO1 ∪ O2 comprises the certain axioms CD.

Some of the concepts in O1 or O2 might becomeunsatisfiable due to the axioms of A. A is called anincoherent alignment if this happens. The following isan example for an incoherent alignment.

O1 ={Jaguar1 v Cat1, Cat1 v Animal1},

O2 ={Jaguar2 v Brand2, Animal2 v ¬Brand2}

A ={〈Jaguar1 ≡ Jaguar2, 0.9〉,

〈Animal1 ≡ Animal2, 0.95〉}

In this example the concepts Jaguar1 and Jaguar2are unsatisfiable in the merged ontology. There are sev-eral possible ways to resolve this incoherence by re-moving different subsets fromA. Applying the formal-ism introduced in Section 4.2 results in computing thecoherent subset O1 ∪O2 ∪ {Animal1 ≡ Animal2} asMAP state. The alignment {Animal1 ≡ Animal2} isthus the must probable alignment given the informa-tion available in O1 and O2.

Several systems and algorithms have been devel-oped to deal with the problem of debugging incoher-ent alignments. We present experiments comparing ourgeneric approach to two of these system which areLogMap [25] and Alcomo [34]. LogMap is a match-ing system that consists beside other components of analgorithm for generating (nearly) coherent alignments.Alcomo is a system that has specifically been devel-oped for the purpose of debugging ontology align-ments. It can be used with different settings that differwith respect to completeness and runtime efficiency.

We have used the testcases of the well known OAEIconference track together with the alignments submit-ted by the OAEI 2013 participants [17]. We mergedthese alignments (details can be found in [38]) andconducted experiments for different thresholds. Forlow thresholds the input alignments were large andhighly incoherent while high thresholds resulted in

Fig. 4. Mapping quality and runtime for different debugging ap-proaches.

precise and small input alignments. We applied ourgeneric approach as well as LogMap and Alcomo (intwo settings) to these alignments. The results of ourexperiments are depicted in Figure 4.

On the left side of the figure we have shown the F-measure of the debugged alignments for different in-put thresholds. ELog achieves for all thresholds thebest f-measure. In some cases the results of the othersystems are similar, however, ELog outperforms theother systems with respect to the threshold range thatresults into the best f-measure. Only Alcomo (optimalsetting) can achieve the same result in one case. ELogcan debug the given alignments in acceptable time (seeright side of the figure), however, Alcomo (greedy set-ting) and LogMap are significantly faster for large in-put alignments. This is mainly related to the fact thatboth systems do not solve the underlying optimiza-tion problem, but generate an approximate solution byapplying a greedy algorithm. This explains also whyboth algorithms generate results that are slightly worsecompared to the results of ELog. Only Alcomo in theoptimal setting, using a search tree to find the optimalsolution, is an exception. However, Alcomo (optimalsetting) does not terminate for larger testcases. Moredetails related to the scalability of our approach can befound in [36]. We conclude that our generic approachcan be applied successfully to the problem of align-ment debugging and, even more, outperforms existingsystems that have specifically been designed for thegiven problem.

10 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

5.2. Knowledge Base Verification

Knowledge base verification is concerned with thetask of identifying erroneous statements in a knowl-edge base. In the context of a probabilistic knowledgebase, this scenario is essentially an optimization prob-lem. This means that a reasoner must identify the mostprobable consistent subset of facts given a set of con-straints. This corresponds to the computation of theMAP state. The following example illustrates a incon-sistent knowledge base F = {f1, f2, f3}:

f1 = 〈triple(Einstein, birthYear, 1879), 0.5〉

f2 = 〈triple(Einstein, birthYear, 1955), 1.0〉

f3 = 〈triple(Einstein, deathYear, 1955), 0.8〉

For this knowledge base, we define the following con-straint setR = {r1, r2}:

r1 = A person has at most one birth date.

r2 = The birth of a person happens before

her death.

Given the constraint set R, it is possible to detect in-consistencies in F . r1 causes a clash between the factsf1 and f2 while r2 causes a clash between the facts f2and f3. Hence, f2 has to be removed in order to obtaina consistent knowledge base despite having the highestweight of all facts.

Different approaches have been proposed to solvesuch problems. In [4,2] OWL 2.0 is extended in orderto enable temporal reasoning for supporting temporalqueries. The authors define SWRL rules that are com-patible with a reasoner that supports DL-safe rules inorder to detect inconsistencies. However, their systemcan only detect if a knowledge base is consistent butcannot resolve the existing conflicts. [45,13,14] pro-posed different approaches to resolve temporal con-flicts at query time. In particular, they define temporalconstraint as Datalog rules. However, these approachesdo not incorporate terminological knowledge while re-solving the conflicts and do also not support weightedconstraints.

Contrary to this, our reasoner T-RDFS-LOG (seeSection 4.3) is well-suited for verifying probabilis-tic temporal knowledge bases as it allows extendinga standard rule set, i.e., the RDFS entailment rules,by defining domain-specific constraints. Hence, it is aflexible system that can be adapted to many domains.Based on rules and constraints, the reasoner is able to

Table 3Precision (P), Recall (R) and F-measure (F) for the repaired dataset.We apply the RDFS reasoner to the input datasets that contain differ-ent fractions of erroneous statements. The reasoner removes thosestatements with a high precision as the loss of recall is reasonablewith respect to the gain of precision.

Input Repaired Dataset∆F

P P R F

0.99 1.00 1.00 1.00 0.002

0.91 0.97 0.98 0.97 0.022

0.80 0.92 0.96 0.94 0.050

0.67 0.84 0.93 0.88 0.084

0.57 0.78 0.90 0.83 0.106

0.50 0.72 0.87 0.79 0.119

cleanse a knowledge base by removing the statementsthat do not belong to the MAP state.

In [23] we have evaluated this application scenarioin an artificial setting that is based on DBPedia [30]data. Therefore, we extracted over 150k facts (RDFtriples) describing entities of the domain of academics.For this domain, we define a set of specific constraintsthat are used to detect and to resolve inconsistencies inthe knowledge base. We also generate erroneous factsand add them to the knowledge base in order to inves-tigate the influence of the percentage of wrong state-ments in the knowledge base on the precision of ourapplication. Hence, we create multiple datasets whoserecall is 1.0 while its precision depends on the numberof added statements. In order to obtain a probabilis-tic knowledge base, we assign to all statements a ran-dom weight in the range from 0.0 to 1.0. The resultsof the experiments indicate that our approach is ableto remove erroneous statements with a high precision.Table 3 shows that the F-measure of the knowledgebase increases independently of the share of added er-roneous statements which is depicted in the column∆F . The precision of the debugging process is≈ 80%while the recall is ≈ 65% which means the at least 4out of 5 are proper removals while more than half ofthe wrong statements get detected and removed.

With respect to the runtime, we measured that ittakes ≈7 minutes for the initial dataset (150k facts,precision = 1.0) and ≈18 minutes for the largest ex-tended dataset (300k facts, precision = 0.5) to deter-mine the consistent subset. We executed our experi-ments on a virtual machine running Ubuntu 12.04 thathas access to two threads of the CPU (2.4 GHz) and 16GB RAM. Hence, T-RDFS-LOG is capable to verifyknowledge bases by exploiting terminological knowl-edge and temporal relations of events.

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 11

6. Impact

By presenting the applications and experiments ofthe previous sections we illustrated the benefits of ourinfrastructure in the context of data integration prob-lems. Our infrastructure has been applied in two fur-ther scenarios that require the combination of an onto-logical representations and efficient probabilistic rea-soning. These two tasks are activity recognition androot cause analysis. We give a brief summary in thefollowing two sections.

6.1. Activity Recognition

In [21,22] Helaoui et al. identified the acquisitionand modeling of rich and heterogeneous context dataas a major challenge of ubiquitous computing. This in-cludes also the identification of ongoing human activ-ities at different degrees of granularity. To tackle thechallenge of identifying activities at different levels(from atomic gestures over manipulative gestures andsimple activities up to complex activities) the authorsuse log-linear description logics (DLs) in a multilevelactivity recognition framework.

The approach was applied to a real-life dataset col-lected in highly rich networked sensor environment.This dataset is part of the EU research project Activ-ity and Context Recognition with Opportunistic SensorConfiguration. In a smart room simulating a studio flat,a total of 72 sensors with 10 modalities are deployedin 15 wireless and wired networked sensor systems inthe environment [33]. Several users participated in anaturalistic collection process of a morning routine.

Obviously the sensor data gathered are closely re-lated to the manipulative gestures (e.g. Open Fridge orFetch Salami), while it is hard to derive complex activ-ities (e.g., Clean Up or Sandwich Time). For that rea-son Helaoui et al. defined a probabilistic ontology dodescribe the inter-dependencies between the activitiesand other relevant context features in the appropriateway. Some of the core elements of this ontology areshown in Figure 5. The following two weighted ax-ioms are examples from this ontology.

〈FetchMilk v ManipulativeGesture t

∃hasActor.(∃hasAtomicGesture.ReachMilk), w1〉

〈FetchMilk v ManipulativeGesture t

∃hasActor.(∃hasAtomicGesture.MoveMilk), w2〉

Fig. 5. Core activities and their dependencies as shown in [22]

The second axiom, e.g., says that FetchMilk isan activity that is a manipulative gesture performed byan actor who performs (at the same time) the atomicgesture MoveMilk. Note that MoveMilk, in turn, isdefined via the measurement of sensor data that mightbe related to the movement of the milk carton. Withthe help of the whole ontology it is thus possible to de-rive also higher level activities from given sensor data.The simultaneity of the activities is implicitly takeninto account by reasoning over time windows. Notethat many of these axioms are weighted (w1 and w2

are the weights in our example), which means the theseaxioms will be contained in CU . The weights can bespecified by domain experts or can be learned fromtraining data. Our infrastructure does not yet containa learning component as official core component. Forthat reason Helaoui et al. added the weight manuallybased on expert judgments.

With this application of our infrastructure to ac-tivity recognition, which was motivated by a coop-eration with an industry partner, Helaoui et al. pro-posed a tightly-coupled hybrid system for human ac-tivity recognition that unites both symbolic and prob-abilistic reasoning. The experimental results validatethe viability of this approach to address multilevel ac-tivities for user independent scenarios. Depending onthe granularity level of the activities a F-measure be-tween 70% and 90% has been achieved. The bene-fits of the proposed approach are manifold. Unlike themajority of related works, it supports the inherent un-certain nature of human activities without sacrificingthe advantages of ontological modeling and reasoning.

12 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

These advantages include the ability of integrating richbackground knowledge and the simultaneous recogni-tion of coarse and fine-grained activities. The use ofa standard description formalism enhances the porta-bility and reusability of the proposed system, and sup-ports the representation of heterogeneous and uncer-tain context data.

6.2. Risk Assessment and Root Cause Analysis

Risk Assessment and Root Cause Analysis are twoimportant aspects of IT management in modern in-frastructures. Risk Assessment identifies the impactof potential threats (e.g. power failure, or hacker at-tack), whereas Root Cause Analysis finds the under-lying source of the observed symptoms of a problem(e.g. failing e-mail deliveries, inaccessible websites, orunresponsive accounting systems). Today’s IT infras-tructures are getting increasingly complex with diverseexplicit and implicit dependencies. A high availabilityand short response times to failures are crucial [24].Therefore, identifying the impact of a threat or thesource of a failure or outage as fast as possible is im-portant to achieve a high service level [15].

In the context of an industry project we integratedour system as a module in an application for IT infras-tructure management. Therein a general ontology forIT infrastructure captures the dependencies betweencomponents and threats affecting them. An examplefor such a dependency graph is depicted in Figure 6which shows an Email service relying on two redun-dant servers, each connected to its own router, andan access point providing WiFi, depending on one ofthose routers. Using an ontology to model IT infras-tructure and risk for example has the benefit of easilydefining threats that are common for types of compo-nents, e.g. mean time between failure (MTBF) for aspecific brand of hard disks.

In [44,43] it was demonstrated how the system canbe used to assess the general impact of a threat onthe availability of components. After adding threatsto the modeled dependency graph, the user can runan inference step that propagates the impact of allthreats through all dependencies and calculates avail-ability for every single component. In an extension,the MLN is also used to check the modeled infrastruc-ture for inconsistencies. For example threats like "fire"can be categorized to have a local influence and thus ifone component is affected by it, all components in itsvicinity should also be checked for it.

Email

Server 1Server 2

Router 1Router 2

AP 1

WiFi

Fig. 6. Example for a small dependency network. Solid arrows indi-cate specific dependencies, dashed arrows symbolize generic depen-dencies and the dotted line represents a redundancy.

Furthermore, we proposed and implemented an ap-proach for root cause analysis in [42]. The approachextends the MLN with generic rules for abductive rea-soning, which is not inherently supported by the stan-dard inference for MLN. Abduction aims to find an ex-planation for a given observation in the light of somebackground knowledge, i.e an ontology in our case. Inroot cause analysis, the explanation corresponds to theroot cause (it will be a component that is offline or anactive threat in the MAP state), the observation of thefailure of a component, and the background knowledgeof the dependency graph extended by potential risks.The dependency graph is encoded in CD, while risksand their probabilities are encoded in CU . Observationsare added as deterministic facts to CD.

We developed a dialog-based system, using our in-frastructure as reasoning component, which supportsa sequence of interactions between our system and anadministrative user (Figure 7). Note that a fully auto-matic workflow would be desirable, however, not ev-ery information can be retrieved directly and some-times manual investigation of log files or on the statusof components is necessary.

Fig. 7. Process flow for our approach on root cause analysis. Rectan-gles denote automated processes. Trapezoids require manual inter-action by an administrative user.

In its normal state, without any hard evidence aboutavailabilities or unavailabilities, all components are

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 13

assumed to be available. Thus, when calculating theMAP state, it contains all components as available.When a problem occurs the user is required to provideobservations as evidence for the MLN (1). These ob-servations include any certain information about avail-able and unavailable components. For example, theuser can enter that printing over the network is not pos-sible, although the network is functional as browsingthe internet still works. This results in hard evidencefor the printing service being unavailable and networkservices and hardware required for internet access be-ing available.

Our approach extends the Markov Logic Networkwith the new evidence (2) and uses RockIt to run in-ference on it (3). The calculated state contains the ev-idence provided by the user (this must be always ful-filled), components being unavailable due to a director indirect dependency on components observed as notavailable, and (at least) one root cause that explains theunavailabilities. Components which are not affected byspecified observations or the calculated root cause arelisted as available.

The application was evaluated in multiple businessuse cases and proven to generate valuable insightsabout the infrastructure in general and the nature of in-cidents. It proved to be especially useful when the rea-sons for the failure are not obvious to the administra-tor that is in charge of resolving the problem. Thus,the applications is most beneficial in IT infrastructures,where competences are scattered over the members ofdifferent organizational units.

7. Conclusions

We presented an infrastructure for probabilistic rea-soning about Semantic Web data. The infrastructureis based on the state of the art Markov logic engineROCKIT that supports very efficient MAP inference.We presented the ROCKIT system and showed how theconcept of log-linear logics can be used to translate Se-mantic Web data into Markov logic and use ROCKIT

to solve relevant problems on the web. We also demon-strated the benefits of specific probabilistic extensionsof Semantic Web languages. In particular a temporalextension of RDFS as well as the EL fragment of theWeb Ontology language for verifying extracted infor-mation from the web and for matching heterogeneousweb ontologies. The reasoning infrastructure presented

is available for download6 and can also be accessedthrough a web interface that we provide for testing andsmaller reasoning problems.7

We have already used the infrastructure for the ex-periments described in the paper. Moreover, we alsopresented two further uses cases illustrating the impactand the wide applicability of our infrastructure. How-ever, there is still a lot of potential for improving thesystem. First of all, we have only experimented with arestricted set of logical languages that do not fully ex-ploit all possibilities of the concept of log-linear log-ics. There is a need for a more systematic investigationof the concept of log-linear logics and their possibleuse in the context of Semantic Web applications andbeyond.

So far, our infrastructure only provides efficient rea-soning support for MAP inference. Other importantproblems, in particular marginal inference and weightlearning are only supported to a limited extent. WhileMAP inference can be used to solve a number of im-portant problems, the restriction to this particular kindof reasoning limits the applicability of the infrastruc-ture. In particular, there is a lack of support for answer-ing probabilistic queries over Semantic Web data. Wewill address these limitations in future work.

References

[1] James F. Allen. Maintaining knowledge about temporal in-tervals. In Peter J. Denning, editor, Communications of theACM, volume 26, pages 832–843. ACM, New York, NY, USA,November 1983. . URL http://doi.acm.org/10.1145/182.358434.

[2] Eleftherios Anagnostopoulos, Sotiris Batsakis, and Euripi-des G.M. Petrakis. CHRONOS: A reasoning engine for qual-itative temporal information in OWL. In Junzo Watada,Lakhmi C. Jain, Robert J. Howlett, Naoto Mukai, and KoichiAsakura, editors, Procedia Computer Science, volume 22,pages 70 – 77. Elsevier, Philadelphia, Pennsylvania, USA,2013. . URL http://www.sciencedirect.com/science/article/pii/S1877050913008752.

[3] Franz Baader, Sebastian Brandt, and Carsten Lutz. Pushingthe EL envelope. In Leslie Pack Kaelbling and AlessandroSaffiotti, editors, Proceedings of the 19th International JointConference on Artificial Intelligence (IJCAI), pages 364–369.Morgan Kaufmann, Palo Alto, CA, USA, 2005. URL http://www.ijcai.org/papers/0372.pdf.

[4] Sotiris Batsakis, Kostas Stravoskoufos, and EuripidesG.M. Pe-trakis. Temporal reasoning for supporting temporal queries in

6https://code.google.com/p/rockit/7http://executor.informatik.uni-mannheim.

de/

14 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

OWL 2.0. In Andreas König, Andreas Dengel, Knut Hinkel-mann, Koichi Kise, Robert J. Howlett, and Lakhmi C. Jain,editors, Knowledge-Based and Intelligent Information and En-gineering Systems, volume 6881 of Lecture Notes in Com-puter Science, pages 558–567. Springer, Berlin Heidelberg,Germany, 2011. ISBN 978-3-642-23850-5. . URL http://dx.doi.org/10.1007/978-3-642-23851-2_57.

[5] Elena Bellodi, Evelina Lamma, Fabrizio Riguzzi, and SimoneAlbani. A distribution semantics for probabilistic ontologies.In Fernando Bobillo, Rommel Carvalho, Paulo C. G. da Costa,Claudia d’Amato, Nicola Fanizzi, Kathryn B. Laskey, Ken-neth J. Laskey, Thomas Lukasiewicz, Trevor Martin, MatthiasNickles, and Michael Pool, editors, Proceedings of the 7th In-ternational Workshop on Uncertainty Reasoning for the Se-mantic Web (URSW 2011), volume 778 of CEUR WorkshopProceedings, pages 75–86. RWTH Aachen, Germany, 2011. .

[6] Dan Brickley and Ramanathan Guha. RDF vocabulary de-scription language 1.0: RDF schema. W3C, February 2004.http://www.w3.org/TR/2004/REC-rdf-schema-20040210/.

[7] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo,Maurizio Lenzerini, Antonella Poggi, Mariano Rodriguez-Muro, and Riccardo Rosati. Ontologies and databases: TheDL-Lite approach. In Sergio Tessaris, Enrico Franconi,Thomas Eiter, Claudio Gutierrez, Siegfried Handschuh, Marie-Christine Rousset, and Renate A. Schmidt, editors, ReasoningWeb, Semantic Technologies for Information Systems, volume5689 of Lecture Notes in Computer Science, pages 255–356.Springer, Berlin Heidelberg, Germany, 2009. ISBN 978-3-642-03753-5. . URL http://dx.doi.org/10.1007/978-3-642-03754-2_7.

[8] Paulo CG Costa. Bayesian semantics for the Semantic Web.PhD thesis, School of Science, George Mason University, Fair-fax County, Virginia, USA, 2005.

[9] Paulo Cesar G. da Costa and Kathryn B. Laskey. PR-OWL:A framework for probabilistic ontologies. In Brandon Ben-nett and Christiane Fellbaum, editors, Proceedings of the 2006conference on Formal Ontology in Information Systems: Pro-ceedings of the Fourth International Conference (FOIS 2006),volume 150 of Frontiers in Artificial Intelligence and Appli-cations, pages 237–249. IOS Press, Amsterdam, The Nether-lands, 2006. ISBN 1-58603-685-8. URL http://dl.acm.org/citation.cfm?id=1566079.1566107.

[10] Paulo Cesar G. da Costa, Marcelo Ladeira, Rommel N. Car-valho, Kathryn B. Laskey, Laecio L. Santos, and Shou Mat-sumoto. A first-order bayesian tool for probabilistic ontolo-gies. In David C. Wilson and H. Chad Lane, editors, Proceed-ings of the Twenty-First International Florida Artificial Intel-ligence Research Society Conference, pages 631–636. AAAIPress, Palo Alto, CA, USA, Palo Alto, California, USA, 2008.

[11] Claudia d’Amato, Nicola Fanizzi, Marko Grobelnik, Ag-nieszka Lawrynowicz, and Vojtech Svatek. Inductive reason-ing and machine learning for the semantic web. In Claudiad’Amato, editor, Semantic Web Journal, volume 5, pages 3–4. IOS Press, Amsterdam, The Netherlands, 2014. . URLhttp://dx.doi.org/10.3233/SW-130103.

[12] Luc De Raedt, Angelika Kimmig, and Hannu Toivonen.ProbLog: A probabilistic prolog and its application in link dis-covery. In Proceedings of the 20th International Joint Confer-ence on Artificial Intelligence IJCAI 2007, pages 2462–2467.AAAI Press, Palo Alto, CA, USA, 2007. URL www.ijcai.org/papers07/Papers/IJCAI07-397.pdf.

[13] Maximilian Dylla, Mauro Sozio, and Martin Theobald. Re-solving temporal conflicts in inconsistent rdf knowledge bases.In Theo Härder, Wolfgang Lehner, Bernhard Mitschang, Har-ald Schöning, and Holger Schwarz, editors, 14. GI-FachtagungDatenbanksysteme für Business, Technologie und Web (BTW2011), volume 180 of Lecture Notes in Informatics, pages474–493. Bonner Köllen Verlag, Bonn, Germany, 2011. URLhttp://dbis.eprints.uni-ulm.de/1227/.

[14] Maximilian Dylla, Iris Miliaraki, and Martin Theobald. Atemporal-probabilistic database model for information extrac-tion. In Christoph Koch Michael Böhlen, editor, Proceedingsof the VLDB Endowment, volume 6, pages 1810–1821. ACM,New York, USA, 2013. . URL http://dx.doi.org/10.14778/2556549.2556564.

[15] Ernst & Young. Managing IT risk in a fast-changingenvironment. Technical report, Ernst & Young, 2013.http://www.ey.com/Publication/vwLUAssets/Managing_IT_risk_in_a_fast_changing_environment/\protect\T1\textdollarFILE/IT_Risk_Management_Survey.pdf.

[16] Michael R. Genesereth and Nils J. Nilsson. Logical founda-tions of artificial intelligence. Morgan Kaufmann, Palo Alto,CA, USA, 1988. ISBN 978-0-934613-31-6.

[17] Bernardo Cuenca Grau, Zlatan Dragisic, Kai Eckert, JérômeEuzenat, Alfio Ferrara, Roger Granada, Valentina Ivanova,Ernesto Jiménez-Ruiz, Andreas Oskar Kempf, Patrick Lam-brix, Andriy Nikolov, Heiko Paulheim, Dominique Ritze,François Scharffe, Pavel Shvaiko, Cássia Trojahn dos Santos,and Ondrej Zamazal. Results of the ontology alignment eval-uation initiative 2013. In Pavel Shvaiko, Jérôme Euzenat,Kavitha Srinivas, Ming Mao, and Ernesto Jiménez-Ruiz, edi-tors, Proceedings of the 8th International Workshop on Ontol-ogy Matching, pages 61–100. RWTH Aachen, Germany, 2013.

[18] Claudio Gutierrez, Carlos Hurtado, and Alejandro Vaisman.Temporal RDF. In Jérôme Euzenat Asunción Gómez-Pérez,editor, The Semantic Web: Research and Applications, volume3532 of Lecture Notes in Computer Science, pages 93–107.Springer, Berlin Heidelberg, Germany, 2005. ISBN 978-3-540-26124-7. . URL http://dx.doi.org/10.1007/11431053_7.

[19] Claudio Gutierrez, Carlos A Hurtado, and Alejandro Vais-man. Introducing time into RDF. In Xindong Wu and Chris-tos Faloutsos, editors, IEEE Transactions on Knowledge andData Engineering, volume 19, pages 207–218. IEEE Com-puter Society, New York, NY, USA, 2007. . URL http://dx.doi.org/10.1109/tkde.2007.34.

[20] Patrick Hayes. RDF semantics. W3C recommendation,W3C, February 2004. http://www.w3.org/TR/2004/REC-rdf-mt-20040210/.

[21] Rim Helaoui, Daniele Riboni, Mathias Niepert, Claudio Bet-tini, and Heiner Stuckenschmidt. Towards activity recognitionusing probabilistic description logics. In Activity Context Rep-resentation: Techniques and Languages, AAAI Technical Re-port WS-12-05, volume 12, pages 26–31. AAAI Workshops,Toronto, Canada, 2012.

[22] Rim Helaoui, Daniele Riboni, and Heiner Stuckenschmidt. Aprobabilistic ontological framework for the recognition of mul-tilevel human activities. In Friedemann Mattern, Silvia Santini,John F. Canny, Marc Langheinrich, and Jun Rekimoto, editors,Proceedings of the 2013 ACM International Joint Conferenceon Pervasive and Ubiquitous Computing, UbiComp ’13, pages

Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies 15

345–354. ACM, New York, NY, USA, 2013. ISBN 978-1-4503-1770-2. . URL http://doi.acm.org/10.1145/2493432.2493501.

[23] Jakob Huber, Christian Meilicke, and Heiner Stuckenschmidt.Applying markov logic for debugging probabilistic temporalknowledge bases. In Proceedings of the 4th Workshop on Au-tomated Knowledge Base Construction (AKBC). ACM, NewYork, NY, USA, 2014.

[24] IBM X-Force. Mid-Year Trend and Risk Report 2013. Techni-cal report, IBM X-Force, 2013.

[25] Ernesto Jiménez-Ruiz and Bernardo Cuenca Grau. Logmap:Logic-based and scalable ontology matching. In Lora Aroyo,Chris Welty, Harith Alani, Jamie Taylor, Abraham Bernstein,Lalana Kagal, Natasha Noy, and Eva Blomqvist, editors, TheSemantic Web – ISWC 2011, volume 7031 of Lecture Notes inComputer Science, pages 273–288. Springer Heidelberg Dor-drecht London New York, 2011. . URL http://dx.doi.org/10.1007/978-3-642-25073-6.

[26] Yevgeny Kazakov. Consequence-driven reasoning for hornSHIQ ontologies. In Proceedings of the 21st InternationalJoint Conference on Artificial Intelligence, IJCAI 2009, pages2040–2045. AAAI Press, Palo Alto, CA, USA, Pasadena, Cal-ifornia, USA, 2009.

[27] Pavel Klinov. Practical reasoning in probabilistic descriptionlogic. PhD thesis, School of Computer Science, The Universityof Manchester, Manchester, UK, 2011.

[28] Thorsten Koch, Tobias Achterberg, Erling Andersen, OliverBastert, Timo Berthold, RobertE. Bixby, Emilie Danna, Ger-ald Gamrath, AmbrosM. Gleixner, Stefan Heinz, Andrea Lodi,Hans Mittelmann, Ted Ralphs, Domenico Salvagnin, DanielE.Steffy, and Kati Wolter. Miplib 2010. In Mathematical Pro-gramming Computation, volume 3, pages 103–163. Springer,Berlin Heidelberg, Berlin, 2011. . URL http://dx.doi.org/10.1007/s12532-011-0025-9.

[29] Kathryn B. Laskey. MEBN: A language for first-orderbayesian knowledge bases. In C.R. Perrault, S. Kraus,R. Dechter, R. López De Mántaras, J. De Kleer, A.G.Cohn, S. Mcilraith, and P. Doherty, editors, Artificial Intelli-gence, volume 172, pages 140–178. Elsevier, Amsterdam, TheNetherlands, 2008. . URL http://dx.doi.org/10.1016/j.artint.2007.09.006.

[30] Jens Lehmann, Robert Isele, Max Jakob, Anja Jentzsch, Dim-itris Kontokostas, Pablo Mendes, Sebastian Hellmann, Mo-hamed Morsey, Patrick van Kleef, Sören Auer, and Chris Bizer.DBpedia - a large-scale, multilingual knowledge base extractedfrom wikipedia. In Pascal Hitzler and Krzysztof Janowicz, ed-itors, Semantic Web Journal, volume 6, pages 167–195. IOSPress, Amsterdam, The Netherlands, 2015. . URL http://dx.doi.org/10.3233/SW-140134.

[31] Thomas Lukasiewicz. Expressive probabilistic description log-ics. In C.R. Perrault, S. Kraus, R. Dechter, R. López De Mán-taras, J. De Kleer, A.G. Cohn, S. Mcilraith, and P. Doherty,editors, Artificial Intelligence, volume 172, page 852–883. El-sevier, Amsterdam, The Netherlands, 2008. . URL http://dx.doi.org/10.1016/j.artint.2007.10.017.

[32] Thomas Lukasiewicz and Umberto Straccia. Managing un-certainty and vagueness in description logics for the seman-tic web. In Web Semantics: Science, Services and Agents onthe World Wide Web, volume 6, pages 291–308. Elsevier, Am-sterdam, The Netherlands, 2008. . URL http://dx.doi.org/10.1016/j.websem.2008.04.001.

[33] Paul Lukowicz, Gerald Pirkl, David Bannach, Florian Wagner,Alberto Calatroni, Kilian Förster, Thomas Holleczek, MattiaRossi, Daniel Roggen, Gerhard Tröster, et al. Recording a com-plex, multi modal activity data set for context recognition. In23rd International Conference on Architecture of ComputingSystems (ARCS), pages 1–6. IEEE, 2010.

[34] Christian Meilicke. Alignment incoherence in ontology match-ing. PhD thesis, School of Business Informatics and Mathe-matics, University of Mannheim, Germany, 2011.

[35] Mathias Niepert, Jan Noessner, and Heiner Stuckenschmidt.Log-linear description logics. In Toby Walsh, editor, Pro-ceedings of the Twenty-Second International Joint Confer-ence on Artificial Intelligence (IJCAI 11), pages 2153–2158.AAAI Press, Menlo Park, CA, USA, Barcelona, Spain,2011. . URL http://dx.doi.org/10.5591/978-1-57735-516-8/IJCAI11-359.

[36] Jan Noessner. Efficient Maximum A-Posteriori Inference inMarkov Logic and Application in Description Logics. PhD the-sis, School of Business Informatics and Mathematics, Univer-sity of Mannheim, Germany, 2014.

[37] Jan Noessner, Mathias Niepert, and Heiner Stuckenschmidt.Rockit: Exploiting parallelism and symmetry for map infer-ence in statistical relational models. In Proceedings of the 27thConference on Artificial Intelligence (AAAI). AAAI Press, PaloAlto, CA, USA, 2013. URL http://www.aaai.org/ocs/index.php/AAAI/AAAI13/paper/view/6240.

[38] Jan Noessner, Heiner Stuckenschmidt, Christian Meilicke, andMathias Niepert. Completeness and optimality in ontologyalignment debugging. In Pavel Shvaiko, Jérôme Euzenat, MingMao, Ernesto Jiménez-Ruiz, Juanzi Li, and Axel Ngonga, ed-itors, Proceedings of the 9th International Workshop on On-tology Matching, volume 1317, pages 25–36. RWTH Aachen,Germany, 2014.

[39] Matthew Richardson and Pedro Domingos. Markov logicnetworks. In Hendrik Blockeel, David Jensen, and StefanKramer, editors, Machine Learning, volume 62, pages 107–136. Springer, 2006. . URL http://dx.doi.org/10.1007/s10994-006-5833-1.

[40] Sebastian Riedel. Improving the accuracy and efficiency ofmap inference for markov logic. In David McAllester andPetri Myllymaki, editors, Proceedings of the 24th Conferencein Uncertainty in Artificial Intelligence, pages 468–475. AUAIPress, Corvallis, Oregon, 2008. ISBN 0-9749039-4-9.

[41] Fabrizio Riguzzi, Elena Bellodi, Evelina Lamma, and RiccardoZese. Bundle: A reasoner for probabilistic ontologies. InWolfgang Faber and Domenico Lembo, editors, Reasoning andRule Systems - 7th International Conference, RR 2013, volume7994 of Lecture Notes in Computer Science, pages 183–197.Springer Heidelberg Dordrecht London New York, Mannheim,Germany, 2013. . URL http://dx.doi.org/10.1007/978-3-642-39666-3_14.

[42] Joerg Schoenfisch, Janno von Stülpnagel, Jens Ortmann, Chris-tian Meilicke, and Heiner Stuckenschmidt. Using abductionin markov logic networks for root cause analysis. CoRR,abs/1511.05719, 2015. URL http://arxiv.org/abs/1511.05719.

[43] Janno von Stülpnagel and Willy Chen. Risk Assessment andRisk-Driven Testing. In Fredrik Seehusen, Michael Felderer,Jürgen Großmann, and Marc-Florian Wendland, editors, RiskAssessment Risk-Driven Testing, volume 9488 of Lecture Notesin Computer Science, pages 34–48. 2015. ISBN 978-3-319-

16 Huber et al. / An Infrastructure for Probabilistic Reasoning with Web Ontologies

26415-8. . URL http://link.springer.com/10.1007/978-3-319-26416-5.

[44] Janno von Stülpnagel, Jens Ortmann, and Joerg Schoenfisch.IT Risk Management with Markov Logic Networks. InM. Jarke, J. Mylopoulos, C. Quix, C. Rolland, Y. Manolopou-los, H. Mouratidis, and J. Horkoff, editors, Proceedings of the26th International Conference on Advanced Information Sys-tems Engineering, volume 8484 of Lecture Notes in ComputerScience, pages 301–315. Springer Cham Heidelberg New YorkDordrecht London, 2014. . URL http://dx.doi.org/

10.1007/978-3-319-07881-6_21.[45] Yafang Wang, Mohamed Yahya, and Martin Theobald. Time-

aware reasoning in uncertain knowledge bases. In Anderde Keijzer and Maurice van Keulen, editors, Proceedings of theFourth International VLDB workshop on Management of Un-certain Data (MUD 2010), volume WP10-04 of CTIT Work-shop Proceedings Series, pages 51–65. Centre for Telemat-ics and Information Technology (CTIT), University of Twente,The Netherlands, 2010.