On Combining Description Logic Ontologies and
Nonrecursive Datalog Rules
Riccardo Rosati
Dipartimento di Informatica e Sistemistica
Sapienza Universit`a di Roma, Italy
rosati@dis.uniroma1.it
Abstract. Reasoning in systems integrating Description Logics (DL) ontologies
and Datalog rules is a very hard task, and previous studies have shown undecid-
ability of reasoning in systems integrating (even very simple) DL ontologies with
recursive Datalog. However, the results obtained so far constitute a very partial
picture of the computational properties of systems combining DL ontologies and
Datalog rules. The aim of this paper is to contribute to complete this picture, ex-
tending the computational analysis of reasoning in systems integrating ontologies
and Datalog rules. More precisely, we first provide a set of decidability and com-
plexity results for reasoning in systems combining ontologies specified in DLs
and rules specified in nonrecursive Datalog (and its extensions with inequality
and negation): such results identify, from the viewpoint of the expressive abil-
ities of the two formalisms, minimal combinations of Description Logics and
Datalog in which reasoning is undecidable. Then, we present new results on the
decidability and complexity of the so-called restricted (or safe) integration of DL
ontologies and Datalog rules. Our results show that: (1) the unrestricted interac-
tion between DLs and Datalog is computationally very hard even in the absence
of recursion in rules; (2) surprisingly, the various ”safeness” restrictions, which
have been defined to regain decidability of reasoning in the interaction between
DLs and recursive Datalog, appear as necessary restrictions even when rules are
not recursive.
1 Introduction
Background The problem of adding rules to ontologies is currently a hot research
topic, due to the interest of Semantic Web applications towards the integration of rule-
based systems with ontologies. Most of the approaches in this field concern the study
of Description Logic (DL) knowledge bases [3] augmented with rules expressed in
Datalog and its nonmonotonic extensions [9].
DLs are currently the most used formalisms for building ontologies, and have been
proposed as standard languages for the specification of ontologies in the Semantic
Web [26]. DLs are a family of knowledge representation formalisms based on first-order
logic (FOL). In fact, almost all DLs coincide with decidable fragments of function-free
first-order logic with equality, and the language of a DL can be seen as a restricted FOL
language over unary and binary predicates and with a controlled form of quantification
(actually, DLs are equipped with a special, variable-free syntax). Notably, DLs have
been designed to optimize the trade-off between expressive abilities and complexity of
reasoning, hence the computational properties of DLs have been extensively studied
[3].
From the knowledge representation viewpoint, Datalog is somehow “complemen-
tary” to DLs. Indeed, with respect to DLs, Datalog allows for using predicates of ar-
bitrary arity, the explicit use of variables, and the ability of expressing more powerful
queries. Moreover, its nonmonotonic features (in particular, the negation-as-failure op-
erator not ) allow for expressing default rules and forms of closed-world reasoning.
Problem studied Unfortunately, reasoning in systems integrating DLs and Datalog is
a very hard task, and well-known previous results have shown undecidability of reason-
ing in systems fully integrating (even very simple) DL ontologies with Datalog rules.
In fact, in general this combination does not preserve decidability, i.e., starting from a
DL knowledge base in which reasoning is decidable and a set of rules in which rea-
soning is decidable, reasoning in the knowledge base obtained by integrating these two
components may not be a decidable problem.
To avoid undecidability of reasoning, practically all decidable approaches to inte-
grating ontologies and rules impose (either at the syntactic or at the semantic level)
specific conditions which restrict the interaction between the rules and the ontology.
Such restrictions were mainly introduced to keep reasoning decidable in the presence
of recursion in Datalog rules.
However, the results obtained so far [20,11, 18,23,27, 28,10] actually constitute a
very partial picture of the computational properties of systems combining DL ontolo-
gies and Datalog rules. In particular, the computational properties of systems combin-
ing DL ontologies and the class of nonrecursive Datalog rules are mostly unknown.
The only known studies related to this topic are the work on CARIN [20], which has
shown decidability of nonrecursive positive Datalog with the DL ALCN R, and the
studies on conjunctive query answering in DLs (see e.g. [7, 24, 25, 14, 15]), which are
indirectly related to integrating Datalog and DLs (since conjunctive queries can be seen
as nonrecursive Datalog programs consisting of a single rule).
Contribution The aim of this paper is to contribute to fill this gap, extending the com-
putational analysis of reasoning in systems integrating ontologies and Datalog rules.
More precisely, our contributions can be summarized as follows:
– We first provide a set of decidability and complexity results for reasoning in sys-
tems combining ontologies specified in (different classes of) DLs and rules speci-
fied in (different classes of) nonrecursive Datalog (and its extensions with inequal-
ity or negation). Such results identify, from the viewpoint of the expressive abili-
ties of the two formalisms, minimal combinations of Description Logics and (non-
monotonic) Datalog in which reasoning is undecidable. A summary of the results
obtained is reported in Figure 2 (Section 4).
– Then, we present new results on the decidability and complexity of the restricted
integration of DL ontologies and Datalog rules. In particular, we consider the so-
called “weakly DL-safe” interaction between rules and DL ontologies [28], which
is currently one of the most expressive decidable combinations of DLs and rules:
we extend the framework of [28] to deal with both negation of DL predicates and
the presence of inequality, and provide new decidability and complexity results for
such a class of weakly DL-safe Datalog rules.
Besides constituting one of the first refined computational analyses taking into ac-
count the expressive power of both the DL language and the rule language (the only
similar study which we are aware of is [20]), the above results imply the following
consequences:
– the unrestrictedinteraction of DLs and Datalog is computationallyvery hard evenin
the absence of recursion in rules. Thiscontrasts with the general opinion (suggested
by the results in [20]) that the presence of recursion in rules is necessary in order to
rise the undecidability issue in their combination with DL ontologies;
– surprisingly, the “safeness” restrictions, which have been defined to regain decid-
ability in the interaction between DLs and recursive Datalog, appear as necessary
restrictions even when rules are not recursive.
Structure of the paper In Section 2, we briefly recall the basics of Description Logics
and Datalog. In Section 3, we formally define syntax and semantics of systems integrat-
ing DLs and Datalog. In Section 4, we consider the full integration of DLs and rules,
and present a set of undecidability and hardness results for reasoning in systems fully
combining DLs and Datalog rules. In Section 5, we focus on weakly DL-safe systems,
which are based on a restricted form of interaction between DLs and rules, extend them
to the presence of inequality atoms, and present a computational analysis of reasoning
in such systems. Finally, we conclude in Section 6. Due to space limits, in the present
version of the paper we provide proof sketches of the theorems.
2 Description Logics and Datalog
In this section we briefly introduce Description Logics and Datalog.
Description Logics We now briefly recall the basics of Description Logics (DLs) and
introduce the following DLs: (i) three prominent tractable DLs, i.e., DL-Lite
RDFS
,
DL-Lite
R
and EL; (ii) the “classical” and moderately expressive DL ALC; (iii) two very
expressive DLs, i.e., SHIQ and DLR. We refer to [3] for a more detailed introduction
to DLs.
We start from an alphabet of concept names, an alphabet of role names and an
alphabet of constant names. Concepts correspond to unary predicates in FOL, roles
correspond to binary predicates, and constants corresponds to FOL constants.
Starting from concept and role names, concept expressions and role expressions
can be constructed, based on a formal syntax. Different DLs are based on different
languages concept and role expressions. Details on the concept and role languages for
the DLs considered in this paper are reported below.
A concept inclusion is an expression of the form C
1
⊑ C
2
, where C
1
and C
2
are
concept expressions. Similarly, a role inclusion is an expression of the form R
1
⊑ R
2
,
where R
1
and R
2
are role expressions.
DL concept expressions role expressions TBox axioms
DL-Lite
RDFS
C
L
::= A | ∃R R ::= P | P
−
C
L
⊑ C
R
C
R
::= A R
1
⊑ R
2
DL-Lite
R
C
L
::= A | ∃R R ::= P | P
−
C
L
⊑ C
R
C
R
::= A | ¬C
R
| ∃R R
1
⊑ R
2
EL C ::= A | C
1
⊓ C
2
| ∃P .C R ::= P C
1
⊑ C
2
ALC C ::= A | C
1
⊓ C
2
| ¬C | ∃P .C R ::= P C
1
⊑ C
2
C
1
⊑ C
2
SHIQ C ::= A | ¬C | C
1
⊓ C
2
| (≥ n R C) R ::= P | P
−
R
1
⊑ R
2
Trans(R)
Fig.1. Abstract syntax of the DLs studied in the paper.
An instance assertion is an expression of the form A(a) or P (a, b), where A is
a concept name, P is a role name, and a, b are constant names. We do not consider
complex concept and role expressions in instance assertions, since in this paper we are
interested in data complexity of reasoning (see Section 4).
A DL knowledge base (KB) is a pair hT , Ai, where T , called the TBox, is a set of
concept and role inclusions, and A, called the ABox, is a set of instance assertions.
The DLs mainly considered in this paper are the following:
– DL-Lite
RDFS
, which corresponds to the “DL fragment” of RDFS [1], the schema
language for RDF (see also [16]);
– DL-Lite
R
[5], a tractable DL which is tailored for efficient reasoning and query
answering in the presence of very large ABoxes;
– EL [2], a prominent tractable DL;
– ALC, a very well-known DL which corresponds to multimodal logic K
n
[3];
– SHIQ, a very expressive DL which constitutes the basis of the OWL family of
DLs adopted as standard languages for ontology specification in the Semantic Web
[26].
The syntax of the above DLs is summarized in Figure 1, in which the symbol A
denotes a concept name and the symbol P denotes a role name (in addition to concept
and role inclusions, SHIQ also allows for TBox axioms of the form Trans(R), which
state transitivity of the role R).
We will also mention the DL DLR [7], which informally extends SHIQ (without
transitive roles) through the use of n-ary relations, and for which decidability results on
query answering are known (we refer to [7] for details on the syntax of DLR, which is
quite different from the other DLs due to the usage of relations of arbitrary arity).
The above mentionedDLs verify the following orderingwith respect to their relative
expressive power (see [3] for details): DL-Lite
RDFS
⊂ DL-Lite
R
⊂ SHIQ ⊂ DLR;
and EL ⊂ ALC ⊂ SHIQ.
We give the semantics of DLs throughthe well-known translation ρ
fol
of DL knowl-
edge bases into FOL theories with counting quantifiers (see [3]).
ρ
fol
(hT , Ai) = ρ
fol
(T ) ∪ ρ
fol
(A)
ρ
fol
(C
1
⊑ C
2
) = ∀x.ρ
fol
(C
1
, x) → ρ
fol
(C
2
, x)
ρ
fol
(R
1
⊑ R
2
) = ∀x, y.ρ
fol
(R
1
, x, y) → ρ
fol
(R
2
, x, y)
ρ
fol
(Trans(R)) = ∀x, y, z.ρ
fol
(R, x, y) ∧ ρ
fol
(R, y, z) → ρ
fol
(R, x, z)
ρ
fol
(A, x) = A(x)
ρ
fol
(¬C, x) = ¬ρ
fol
(C, x)
ρ
fol
(C
1
⊓ C
2
, x) = ρ
fol
(C
1
, x) ∧ ρ
fol
(C
2
, x)
ρ
fol
(∃R, x) = ∃y.ρ
fol
(R, x, y)
ρ
fol
(∃R.C, x) = ∃y.ρ
fol
(R, x, y) ∧ ρ
fol
(C, y)
ρ
fol
((≥ n R C), x) = ∃
≥n
y.ρ
fol
(R, x, y) ∧ ρ
fol
(C, y)
ρ
fol
(P, x, y) = P (x, y)
ρ
fol
(P
−
, x, y) = P (y, x)
An interpretation of K is a classical FOL interpretation for ρ
fol
(K), where constants
and predicates are interpreted over a non-empty interpretation domain which may be
finite or countably infinite. Actually, in this paper we adopt the standard names as-
sumption, i.e.: (i) we assume a countably infinite set of constant symbols Γ ; (ii) the
interpretation domain ∆ is countably infinite and is the same for every interpretation;
(iii) the interpretation of constants in Γ is the same in every interpretation and is given
by a one-to-one correspondence between Γ and ∆. Such an assumption is necessary
for the nonmonotonic semantics defined in Section 3: however, we point out that all
the results presented in this paper under the first-order semantics (i.e., the results for
FOL-satisfiability) also hold in the absence of the standard names assumption.
A model of a DL KB K = hT , Ai is a FOL model of ρ
fol
(K). We say that K is
satisfiable if K has a model.
Disjunctive Datalog In this section be briefy recall disjunctive Datalog [9], denoted by
Datalog
¬∨
, which is the well-known nonmonotonic extension of Datalog with negation
as failure and disjunction.
We start from a predicate alphabet, a constant alphabet, and a variable alphabet. An
atom is an expression of the form p(X), where p is a predicate of arity n and X is
a n-tuple of variables and constants. If no variable symbol occurs in X, then p(X) is
called a ground atom (or fact). A Datalog
¬∨
rule R is an expression of the form
α
1
∨ . . . ∨ α
n
← β
1
, . . . , β
m
, not γ
1
, . . . , not γ
k
, t
1
6= t
′
1
, . . . , t
h
6= t
′
h
(1)
where each α
i
, β
i
, γ
i
is an atom, each t
i
, t
′
i
, is either a variable or a constant, and
every variable occurring in R must appear in at least one of the atoms β
1
, . . . , β
m
. This
last condition is known as the Datalog safeness condition for variables. The variables
occurring in the atoms α
1
, . . . , α
n
are called the head variables of R. If n = 0, we call
R a constraint.
A Datalog
¬∨
program is a set of Datalog
¬∨
rules. If, for all R ∈ P, k = 0 and
h = 0, P is called a positive disjunctive Datalog program. If, for all R ∈ P, n ≤ 1,
k = 0 and h = 0, P is called a positive Datalog program. If there are no occurrences
