A Parameterized Complexity View on Description Logic Reasoning
Ronald de Haan
Institute for Logic, Language and Computation University of Amsterdam
Abstract
Description logics are knowledge representation languages that have been designed to strike a balance between expressiv-ity and computational tractabilexpressiv-ity. Many different description logics have been developed, and numerous computational problems for these logics have been studied for their com-putational complexity. However, essentially all complexity analyses of reasoning problems for description logics use the one-dimensional framework of classical complexity theory. The multi-dimensional framework of parameterized complex-ity theory is able to provide a much more detailed image of the complexity of reasoning problems.
In this paper we argue that the framework of parameterized complexity has a lot to offer for the complexity analysis of description logic reasoning problems—when one takes a pro-gressive and forward-looking view on parameterized complex-ity tools. We substantiate our argument by means of three case studies. The first case study is about the problem of con-cept satisfiability for the logicALCwith respect to nearly acyclic TBoxes. The second case study concerns concept sat-isfiability forALCconcepts parameterized by the number of occurrences of union operators and the number of occurrences of full existential quantification. The third case study offers a critical look at data complexity results from a parameter-ized complexity point of view. These three case studies are representative for the wide range of uses for parameterized complexity methods for description logic problems.
Introduction
Description logics have been designed as knowledge repre-sentation formalisms that have good computational properties (Baader et al. 2003). Correspondingly, there has been a lot of research into the computational complexity of reasoning problems for different description logics. This research has, however, focused entirely on the framework of classical com-plexity theory to study the computational comcom-plexity (see, e.g., Baader et al. 2003; Baader, Horrocks, and Sattler 2008). The more fine-grained and multi-dimensional framework of parameterized complexity theory has hardly been applied to study the complexity of reasoning problems for descrip-tion logics. Only a few works used the framework of pa-rameterized complexity to study description logic problems Copyright c2018, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
(Bienvenu et al. 2017a; 2017b; Ceylan and Pe˜naloza 2014; Kikot, Kontchakov, and Zakharyaschev 2011; Motik 2012; Simanˇc´ık, Motik, and Horrocks 2014; Simanˇc´ık, Motik, and Kr¨otzsch 2011). Moreover, these works all use the frame-work in a traditional way, focusing purely on one commonly used notion of tractability (namely that of fixed-parameter tractability).
Parameterized complexity is designed to address the down-side of classical complexity theory that it is largely ignorant of structural properties of problem inputs that can potentially be exploited algorithmically. It does so by distuinguishing a problem parameterk, in addition to the input sizen, and measuring running times in terms of both of these. The pa-rameterkcan be used to measure various types of structure that are present in the problem input. Parameterized com-plexity theory has grown into a large and thriving research community over the last few decades (see, e.g., Bodlaender et al. 2012; Downey 2012; Downey and Fellows 2013). Most results and techniques in parameterized complexity theory revolve around the notion offixed-parameter tractability—a relaxation of polynomial-time solvability based on running times of the formf(k)·nO(1), for some computable
func-tionf (possibly exponential or worse).
Due to the fact that reasoning problems related to descrip-tion logics are typically of high complexity (e.g., complete for classes like PSPACE and EXPTIME), it is unsurpris-ing that one would need very restrictive parameters to ob-tain fixed-parameter tractability results for such problems. It has been proposed recently that the investigation of prob-lems that are of higher complexity can also benefit from the parameterized complexity point of view (De Haan 2016; De Haan and Szeider 2014a; 2014b; 2016; 2017)—using tools and methods that overstep the traditional focus on fixed-parameter tractability as positive results.
In this paper, we show how the complexity study of descrip-tion logic problems can benefit from using the framework of parameterized complexity and all the tools and methods that it offers. We do so using three case studies: (1) parameter-ized results for concept satisfiability forALCwith respect to nearly acyclic TBoxes, (2) parameterized results for concept satisfiability for fragments ofALC that are close toALE,
results that we obtain are summarized in Tables 1, 3 and 4—at the end of the sections where we present the case studies. Outline. We begin by giving an overview of the theory of parameterized complexity—including commonly used (and more traditional) concepts and tools, as well as more pro-gressive notions. Then we present our three case studies in three separate sections, before sketching directions for future research and concluding.
Parameterized Complexity Theory
We begin by introducing relevant concepts from the the-ory of parameterized complexity. For more details, we re-fer to textbooks on the topic (Downey and Fellows 2013; Flum and Grohe 2006). We introduce both concepts that are used commonly in parameterized complexity analyses in the literature and less commonly used concepts, that play a role in this paper.FPT and XP. The core notion in parameterized complexity is that of fixed-parameter tractability, which is a relaxation of the traditional notion of polynomial-time solvability. Fixed-parameter tractability is a property of Fixed-parameterized prob-lems. Aparameterized problemQis a subset ofΣ∗×N, for some finite alphabetΣ. An instance of a parameterized prob-lem is a pair(x, k)wherexis the main part of the instance, andkis the parameter. Intuitively, the parameter captures some type of structure of the instance that could potentially be exploited algorithmically—the smaller the value of the pa-rameterk, the more structure there is in the instance. (When considering multiple parameters, we take their sum as a sin-gle parameter.) A parameterized problem isfixed-parameter tractableif instances(x, k)of the problem can be solved by a deterministic algorithm that runs in timef(k)|x|O(1),
wheref is a computable function ofk. Algorithms running within such time bounds are calledfpt-algorithms. FPT de-notes the class of all parameterized problems that are fixed-parameter tractable.
Intuitively, the idea behind fixed-parameter tractability is that whenever the parameter value kis small, the overall running time is reasonably small—assuming that the con-stant hidden behindO(1)is small. In fact, for every fixed parameter valuek, the running time of an fpt-algorithm is polynomial (where the order of the polynomial is constant). A related parameterized complexity class is XP, which con-sists of all parameterized problems for which instances(x, k) can be solved in timenf(k), for some computable functionf.
Algorithms running within such time bounds are called xp-algorithms. That is, a parameterized problemQis in XP if there is an algorithm that solvesQin polynomial time for each fixed valuekof the parameter—where the order of the polynomial may grow withk. It holds that FPT(XP. In-tuitively, if a parameterized problem is in XP\FPT, it is not likely to be efficiently solvable in practice. Suppose, for example, that a problem is solvable in timenkin the worst case. Then already forn= 100andk = 10, it could take ages to solve this problem (see, e.g., Downey 2012). Completeness Theory. Parameterized complexity also of-fers a completeness theory, similar to the theory of
NP-completeness, that provides a way to obtain evidence that a parameterized problem is not fixed-parameter tractable. Hardness for parameterized complexity classes is based on fpt-reductions, which are many-one reductions where the parameter of one problem maps into the parameter for the other. More specifically, a parameterized problemQis fpt-reducible to another parameterized problemQ0if there is a mappingRthat maps instances ofQto instances ofQ0such that (i)(I, k) ∈ Qif and only ifR(I, k) = (I0, k0) ∈ Q0, (ii)k0≤g(k)for a computable functiong, and (iii)Rcan be computed in timef(k)|I|cfor a computable functionfand a
constantc. A problemQishardfor a parameterized complex-ity class K if every problemQ0∈K can be fpt-reduced toQ. A problemQiscompletefor a parameterized complexity class K ifQ∈K andQis K-hard.
Central to the completeness theory are the classes W[1]⊆
W[2]⊆. . . ⊆W[P] ⊆XP of the Weft hierarchy. We will not define the classes W[t] in detail (for details, see, e.g., Flum and Grohe 2006). It suffices to note that it is widely believed that W[1]6=FPT.1Thus, showing that a problemQ is W[1]-hard gives evidence thatQis not fpt-time solvable. An example of a W[1]-complete parameterized problem is CLIQUE (Downey and Fellows 1995; 2013). Instances for this problem consist of(G, k), whereG= (V, E)is an undirected graph, andk ∈N. The parameter isk, and the question is to decide whetherGcontains a clique of sizek. Para-K. For each classical complexity class K, we can construct a parameterized analogue para-K (Flum and Grohe 2003). Let K be a classical complexity class, e.g., NP. The parameterized complexity class para-K is then defined as the class of all parameterized problems L ⊆ Σ∗×Nfor which there exist a computable function f : N → Σ∗ and a problem Q0 ⊆ Σ∗ ×Σ∗ inK, such that for all in-stances (x, k) ∈ Σ∗×Nit holds that(x, k) ∈ Qif and only if(x, f(k))∈Q0. Intuitively, the class para-Kconsists
of all problems that are in K after a precomputation that only involves the parameter. A common example of such pa-rameterized analogues of classical complexity classes is the parameterized complexity class para-NP. Another example is para-P=FPT.
If (the unparameterized variant of) a parameterized prob-lem Qis in the class K, thenQ ∈ para-K. Also, if Qis already K-hard for a finite set of parameter values, thenQis para-K-hard (Flum and Grohe 2003).
Using the classes para-K and the notion of fpt-reductions, one can also provide evidence that certain parameterized problems are not fixed-parameter tractable. If a para-K-hard parameterized problem is fixed-parameter tractable, then K= P. For example, a para-NP-hard parameterized problem is not fixed-parameter tractable, unless P=NP.
Para-NP and para-co-NP. The classes para-NP and para-co-NP are parameterized analogues of the classes NP and co-NP. The class para-NP can alternatively be defined as the class of parameterized problems that are solvable
1
In fact, it holds that W[1] 6=FPT, assuming thatn-variable 3SAT cannot be solved in subexponential time, that is, in time2o(n)
in fpt-time by a non-deterministic algorithm (Flum and Grohe 2003). Similarly, para-co-NP can be defined using fpt-algorithms using universal nondeterminism—i.e., nonde-terministic fpt-algorithms that reject the input if at least one sequence of nondeterministic choices leads the algorithm to reject. It holds that W[1]⊆W[2]⊆ · · · ⊆W[P]⊆para-NP. Another alternative definition of the class para-NP—that can be motivated by the amazing practical performance of SAT solving algorithms (see, e.g., Biere et al. 2009)—is us-ing the followus-ing parameterized variant of the propositional satisfiability problem (De Haan 2016; De Haan and Szeider 2014a; 2014b; 2017). Let SAT1 = {(ϕ,1) : ϕ ∈ SAT}
be the problem SAT with a constant parameterk= 1. The class para-NP consists of all problems that can be fpt-reduced to SAT1. In other words, para-NP can be seen as the class
of all parameterized problems that can be solved by (1) a fixed-parameter tractable encoding into SAT, and (2) using a SAT solving algorithm to then decide the problem. The class para-co-NP can be characterized in a similar way, using UN-SAT instead of UN-SAT. Consequently, problems in para-co-NP can also be solved using the combination of an fpt-time en-coding and a SAT solving algorithm.
Para-PSPACE. The class para-PSPACE can alternatively be defined as the class of all parameterized problemsQfor which there exists a (deterministic or nondeterministic) algo-rithm deciding whether(x, k)∈Qusing spacef(k)|x|O(1),
for some computable function f. It holds that para-NP∪
para-co-NP⊆para-PSPACE.
Another alternative characterization of para-PSPACE is using a parameterized variant of TQBF—the problem of deciding whether a given quantified Boolean formula is true. Let TQBF1 = {(ϕ,1) : ϕ ∈ TQBF} be the
prob-lem TQBF with a constant parameter k = 1. The class para-PSPACE consists of all problems that can be fpt-reduced to TQBF1. In other words, para-PSPACE can be seen as the
class of all parameterized problems that can be solved by (1) an fpt-time encoding into TQBF, and (2) using a TQBF solver to then decide the problem (see, e.g., Biere et al. 2009). Yet another characterization of para-PSPACE uses alter-nating Turing machines (ATMs). An ATM is a nondetermin-istic Turing machine where the states are partitioned into existential and universal states (see, e.g., Flum and Grohe 2006, Appendix A.1). A configuration of the ATM with an existential state is accepting if at least one successor con-figuration is accepting, and a concon-figuration with a universal state is accepting if all successor configurations are accepting. Intuitively, an ATM can alternate between existential and universal nondeterminism. The class para-PSPACE consists of all parameterized problems that can be decided by an ATM in fixed-parameter tractable time.
Para-EXPTIME. The class para-EXPTIME can be de-fined as the class of all parameterized problems Q for which there exists a deterministic algorithm deciding whether (x, k) ∈ Q in time f(k)2|x|O(1), for some computable function f. It holds that para-PSPACE ⊆
para-EXPTIME and that XP⊆para-EXPTIME.
For an overview of all parameterized complexity classes
that feature in this paper—and their relation—see Figure 1.
FPT
W[1] co-W[1]
para-NP XP para-co-NP
[image:3.612.346.532.79.185.2]para-PSPACE para-EXPTIME
Figure 1: An overview of the landscape of parameterized complexity classes that play a role in this paper.
Case Study 1: Concept Satisfiability for
ALC
with respect to Nearly Acyclic TBoxes
In this section, we provide our first case study to illustrate how parameterized complexity can be used to obtain a more de-tailed image of the computational complexity of description logic reasoning. In particular, we consider the problem of con-cept satisfiability for the description logicALCwith respect to general TBoxes. This problem is EXPTIME-complete in general. We consider two parameters for this problem. One of these parameters does not help to reduce the complexity of the problem—that is, for this parameter the problem is para-EXPTIME-complete. The other of the two parameters does help to reduce the complexity of the problem—that is, for this parameter the problem is para-PSPACE-complete.We begin by revisiting the description logic ALC, the problem of concept satisfiability with respect to acyclic and general TBoxes, and classical complexity results for this prob-lem. We then discuss our parameterized complexity results, and how to interpret these results.
The Description Logic
ALC
LetNC,NRandNObe sets ofatomic concepts,roles, and
individuals, respectively. The triple(NC, NR, NO)is called
thesignature. (We will often omit the signature if this is clear from the context.)
Concepts C are defined by the following grammar in Backus-Naur form, forR∈NRandA∈NC:
C:=A| > | ⊥ | ¬C|CuC|CtC| ∃R.C| ∀R.C.
An interpretation I = (∆I,·I) over a signa-ture(NC, NR, NO)consists of a non-empty set∆I called
thedomain, and an interpretation function·Ithat maps (1)
ev-ery individuala∈ NO to an elementaI ∈ ∆I, (2) every
conceptCto a subset of∆I, and (3) every roleR∈NRto a
subset of∆I×∆I, such that:
• >I= ∆I;⊥I=∅; • (¬C)I= ∆I\CI;
• (C1uC2)I= (C1)I∩(C2)I;
• (C1tC2)I= (C1)I∪(C2)I;
• (∃R.C)I ={x∈∆I : there exists somey ∈CIsuch that(x, y)∈RI }; and
• (∀R.C)I ={x∈∆I: for eachysuch that(x, y)∈RI
Ageneral concept inclusion (GCI)is a statement of the formC v D, where C, D are concepts. We writeI |=
C vD(and say thatIsatisfiesC vD) ifCI ⊆ DI. A
(general) TBoxT is a finite set of GCIs. Aconcept definition
is a statement of the formA ≡ C, whereA ∈ NC is an
atomic concept, andCis a concept. We writeI |=A≡C
(and say thatI satisfiesA ≡ C) ifAI =CI. Anacyclic TBoxT is a finite set of concept definitions such that (1)T
does not contain two different concept definitionsA≡C1
andA≡C2for anyA∈NC, and (2)T contains no (direct
or indirect) cyclic definitions—that is, the graphGT with
vertex setNCthat contains an edge(A, B)if and only ifT
contains a concept definitionA≡CwhereBoccurs inC
is acyclic. An interpretationIsatisfies a (general or acyclic) TBoxT ifIsatisfies all GCIs or concept definitions inT.
A concept assertion is a statement of the form C(a), wherea∈NOandCis a concept. Arole assertionis a
state-ment of the formR(a, b), wherea, b∈NOandR∈NR. We
writeI |=C(a)(and say thatIsatisfiesC(a)) ifaI∈CI. Moreover, we write I |= R(a, b) (and say that I satis-fiesR(a, b)) if(aI, bI) ∈ RI. AnABoxA is a finite set
of concept and role assertions.
Classical Complexity Results
An important reasoning problem for description logics is the problem ofconcept satisfiability. In this decision problem, the input consists of a conceptCand a TBoxT, and the question is whetherCis satisfiable with respect toT—that is, whether there exists an interpretationIsuch thatI |=T andCI6=∅. The problem of concept satisfiability is PSPACE-complete, both for the case whereT is empty and for the case whereT
is an acyclic TBox. For the case whereT is a general TBox, the problem is EXPTIME-complete.
Proposition 1 (Donini and Massacci 2000; Schild 1991).
Concept satisfiability for the logicALCwith respect to gen-eral TBoxes isEXPTIME-complete.
Proposition 2 (Baader et al. 2005; Schmidt-Schauß and Smolka 1991). Concept satisfiability for the logicALCwith respect to acyclic TBoxes isPSPACE-complete.
Parameterized Complexity Results
We consider a parameterized variant of the problem of con-cept satisfiability forALCwhere the parameter captures the distance towards acyclicity for the given TBox. That is, for this parameterized problem, the input consists of a conceptC, an acyclic TBoxT1, and a general TBoxT2. The parameter
isk=|T2|, and the question is whetherCis satisfiable with
respect toT1∪ T2—that is, whether there exists an
interpre-tationIsuch thatI |=T1,I |=T2, andCI 6=∅.
Parameterizing by the size ofT2 does not offer an
im-provement in the complexity of the problem—that is, this parameter leads to para-EXPTIME-completeness.
Theorem 3. Concept satisfiability for ALC with respect to both an acyclic TBox T1 and a general TBox T2 is
para-EXPTIME-complete when parameterized by|T2|.
Proof. Membership in para-EXPTIME follows from the fact that the unparameterized version of the problem is in
EXPTIME. To show para-EXPTIME-hardness, it suffices to show that the problem is already EXPTIME-hard for a con-stant value of the parameter (Flum and Grohe 2003). We do so by giving a reduction from the problem of concept satisfiability forALCwith respect to general TBoxes.
LetCbe a concept and letT be a general TBox. More-over, letT = {C1 vD1, . . . , Cm v Dm}. We construct
an acyclic TBoxT1and a general TBoxT2 such thatCis
satisfiable with respect toT if and only if it is satisfiable with respect toT1∪ T2. LetAbe a fresh atomic concept. We
letT1={A≡
dm
i=1(¬CitDi)}, and we letT2={> vA}.
It is straightforward to verify thatCis satisfiable with respect toT if and only if it is satisfiable with respect toT1∪ T2.
Moreover,|T2|is constant. From this, we can conclude that
the problem is para-EXPTIME-hard.
Intuitively, restricting only the number (and size) of the general TBox T2does not restrict the problem, as we can
encode a general TBox of arbitrary size in the acyclic TBox (together with a small general TBox). If we restrict the num-ber of concepts impacted by the general TBox, however, we do get an improvement in the complexity of the problem.
LetT1be an acyclic TBox and letT2be a general TBox.
We define the set ofconcepts impacted byT2(w.r.t.T1)as
the smallest setIof concepts that is closed under (syntactic) subconcepts and that satisfies that (A) wheneverC vD∈ T2, thenC, D∈I, and (B) wheneverA∈IandA≡C∈
T1, thenC∈I. If we parameterize the problem of concept
satisfiability with respect to both an acyclic TBoxT1and a
general TBoxT2by the number of concepts impacted byT2,
the complexity of the problem jumps down to para-PSPACE. Theorem 4. Concept satisfiability for ALC with respect to both an acyclic TBox T1 and a general TBox T2 is
para-PSPACE-complete when parameterized by the num-berkof concepts that are impacted byT2(w.r.t.T1).
Proof. Hardness for para-PSPACE follows directly from the fact that the problem is already PSPACE-hard whenT2 is
empty (Proposition 2)—and thus the number of concepts impacted byT2is0. We show membership in para-PSPACE
by exhibiting a nondeterministic algorithm to solve the prob-lem that runs in space f(k)·nO(1), for some computable functionf. LetCbe a concept, letT1be an acyclic TBox,
and letT2be a general TBox. We may assume without loss
of generality that all concepts occurring inT1are in
nega-tion normal form—that is, neganega-tions occur only directly in front of atomic concepts. If this were not the case, we could straightforwardly transform T1 to a TBox that does have
this property in polynomial time, by introducing new atomic conceptsA0for any negated concept¬A.
The algorithm that we use is the usual tableau algorithm (with static blocking) forALC—see, e.g., (Baader and Sattler 2001). That is, it aims to construct a tree that can be used to construct an interpretation satisfyingC,T1andT2. For
each node in the tree, it first exhaustively applies the rules for thetanduoperators, the rules for the concept definitions inT1, and the rules for the GCIs inT2(for eachCvD∈ T2
exhaustively to one node of the tree before moving to another node. Additionally, the algorithm uses the following usual blocking condition (subset blocking): the rule for the∃ oper-ator cannot be applied to a nodexthat has a predecessory
in the tree that is labelled with all concepts thatxis labelled with (and possibly more). It is straightforward to verify that this tableau algorithm correctly decides the problem.
We argue that this algorithm requires space2k ·nO(1),
where kis the number of concepts impacted byT2 andn
denotes the input size. It is straightforward to verify that there is a polynomialpsuch that each node in the tree constructed by the tableau algorithm that is more thanp(n)steps away from the root of the tree is only labelled with concepts that are impacted byT2. Since there are onlykconcepts that are
impacted byT2, we know that in each branch of the tree, the
blocking condition applies at depth at most2k·p(n), and
thus that each branch is of length at most2k·p(n). From this,
it follows that this algorithm requires space2k·nO(1), and thus that the problem is in para-PSPACE.
Interpretation of the Results
The results in this section are summarized in Table 1. The parameterized results of Theorems 3 and 4 show that parame-terized complexity theory can make a distinction between the complexity of the two variants of the problem that classical complexity theory is blind to. Classically, both variants are EXPTIME-complete, but one parameter can be used to get a polynomial-space algorithm (when an additional2kfactor for the parameterk), whereas the other parameter requires exponential space, no matter what additionalf(k)factor is allowed. The para-PSPACE result of Theorem 4 also yields an algorithm solving the problem using (1) an fpt-time en-coding into the problem TQBF, and then (2) using a TQBF solver to decide the problem (see, e.g., Biere et al. 2009).
parameter complexity ofALCconcept satisfiability w.r.t.T1andT2
– EXPTIME-c (Proposition 1)
|T2| para-EXPTIME-c (Theorem 3)
# of concepts impacted byT2(w.r.t.T1)
para-PSPACE-c (Theorem 4)
Table 1: The parameterized complexity ofALCconcept satis-fiability w.r.t. both an acyclic TBoxT1and a general TBoxT2,
for different parameters.
Case Study 2: Concept Satisfiability for
ALC
,
ALE
,
ALU
and
AL
In this section, we provide our second case study to illustrate how parameterized complexity can be used to obtain a more detailed image of the computational complexity of descrip-tion logic reasoning. In particular, we consider the problem of concept satisfiability for the description logicALC. This problem is PSPACE-complete in general. We consider several parameters that measure the distance to the logicsALEand
ALU. The logicsALEandALUare obtained fromALCby
disallowing concept union and full existential qualification, respectively. The parameters that we consider both help to reduce the complexity of the problem. One parameter renders the problem para-co-NP-complete. The other parameter ren-ders the problem para-NP-complete. The combination of both parameters renders the problem fixed-parameter tractable.
We begin by revisiting the description logicsALE and
ALU(and their intersectionAL), and classical complexity results for the problem of concept satisfiability for these logics. We then discuss our parameterized complexity results, and how to interpret these results.
The Description Logics
ALE
,
ALU
and
AL
In order to obtain the description logicsALE,ALUandAL, we consider a (syntactic) variant of the logicALCwhere all concepts are innegation normal form. That is, negations only occur immediately followed by atomic concepts. Put differ-ently, we consider conceptsCthat are defined as follows, forR∈NRandA∈NC:
C:=A| ¬A| > | ⊥ |CuC|CtC| ∃R.C| ∀R.C.
One can transform anyALCconcept into negation normal form in linear time (see, e.g., Baader, Horrocks, and Sattler 2008). The semantics of this variant ofALC is defined ex-actly as described in the previous section. Throughout this section, we will only consider this variant ofALC.
The description logicALEis obtained from the logicALC
by forbidding any occurrence of the operatort. The descrip-tion logicALUis obtained from the logicALCby requiring that for every occurrence∃R.Cof the existential quantifier it holds thatC=>; that is, only limited existential quantifi-cation∃R.>is allowed. The description logicALcontains those concepts that are concepts in bothALE andALU— that is,ALis the intersection ofALEandALU.
Thus, the logicsALE andALUare obtained fromALC
by means of two orthogonal restrictions: disallowing concept union and replacing full existential qualification by limited existential quantification, respectively. The logicALis ob-tained fromALCby using both of these restrictions.
Classical Complexity Results
In this section, we consider the problem ofconcept satisfia-bilitywith respect to empty TBoxes. In this decision prob-lem, the input consists of a conceptC, and the question is whether C is satisfiable—that is, whether there exists an interpretationIsuch thatCI6=∅. This problem is PSPACE-complete forALC, co-NP-complete forALE, NP-complete forALU, and polynomial-time solvable forAL.
Proposition 5(Schmidt-Schauß and Smolka 1991). Concept satisfiability for the logicALCisPSPACE-complete.
Proposition 6(Donini et al. 1992). Concept satisfiability for the logicALEisco-NP-complete.
Proposition 7(Donini et al. 1997). Concept satisfiability for the logicALUisNP-complete.
Theu-rule
Condition Acontains(C1uC2)(x), but it does not contain bothC1(x)andC2(x).
Action A0 =A ∪ {C1(x), C2(x)}.
Thet-rule
Condition Acontains(C1tC2)(x), but neitherC1(x)norC2(x).
Action A0 =A ∪ {C
1(x)},A00=A ∪ {C2(x)}.
The∃-rule
Condition Acontains(∃R.C)(x), but there is no individualzsuch thatC(z)andR(x, z)are inA.
Action A0 =A ∪ {C(y), R(x, y)} \ {(∃R0.C0)(x0)∈ A:x0 =x,(∃R0.C0)6= (∃R.C)},
whereyis an arbitrary individual not occurring inA. The∀-rule
Condition Acontains(∀R.C)(x)andR(x, y), but it does not containC(y).
Action A0 =A ∪ {C(y)}.
The⊥-rule
Condition AcontainsA(x)and(¬A)(x), but it does not contain⊥.
[image:6.612.92.521.57.259.2]Action A0 =A ∪ {⊥}.
Table 2: Transformation rules of the tableau algorithm forALCconcept satisfiability.
Parameterized Complexity Results
In order to conveniently describe the parameterized complex-ity results that we will establish in this section, we firstly describe an algorithm for deciding concept satisfiability for
ALCin polynomial space (see, e.g., Baader et al. 2003, Chap-ter 2). To use this algorithm to prove the parameChap-terized com-plexity results in this section, we describe a variant of the algorithm that can be implemented by a polynomial-time alternating Turing machine—i.e., a nondeterministic Turing machine that can alternate between existential and universal nondeterminism.
The algorithm uses ABoxes A as data structures, and works by extending these ABoxes by means of several trans-formation rules. These rules are described Table 2—however, not all rules are applied in the same fashion. Theu-rule, the
∀-rule and the⊥-rule are used as deterministic rules, and are applied greedily whenever they apply. Thet-rule and the
∃-rule are nondeterministic rules, but are used in a different fashion. Thet-rule transforms an ABoxAinto one of two different ABoxesA0orA00nondeterministically. Thet-rule
is implemented using existential nondeterminism—i.e., the algorithm succeeds if at least one choice ofA0andA00
ulti-mately leads to the algorithm accepting. (For more details on existential and universal nondeterminism and alternat-ing Turalternat-ing machines, see, e.g., Flum and Grohe 2006, Ap-pendix A.1.) The∃-rule, on the other hand, transforms an ABoxAinto a unique next ABoxA0, but it is a
nonmono-tonic rule that can be applied in several ways—the condition can be instantiated in different ways, and these instantiations are not all possible anymore after having applied the rule. The∃-rule is implemented using universal nondeterminism— i.e., the algorithm succeeds if all ways of instantiating the condition of the∃-rule (and applying the rule accordingly) ultimately lead to the algorithm accepting.
The tableau algorithm works as follows. LetC0 be an
ALCconcept for which we want to decide satisfiability. We construct an initial ABoxA0={C0(x0)}, wherex0∈NO
is an arbitrary individual. We proceed in two alternating phases: (I) and (II)—starting with phase (I).
In phase (I), we apply the deterministic rules (theu-rule, the∀-rule and the⊥-rule) and the nondeterministict-rule exhaustively, until none of these rules is applicable anymore. For thet-rule we use existential nondeterminism to choose which ofA0 andA00 to use. When none of these rules is
applicable anymore, we proceed to phase (II). In phase (II), we apply the∃-rule once, using universal nondeterminism to choose how to instantiate the condition (and we apply the rule accordingly). Then, we go back to phase (I).
Throughout the execution of the algorithm, there is always a single current ABoxA. Whenever it holds that⊥ ∈ A, the algorithm rejects. If at some point no rule is applicable anymore—that is, if at some point we are in phase (II) and the∃-rule is not applicable—the algorithm accepts.
This algorithm essentially works the same way as known tableau algorithms forALCconcept satisfiability (see, e.g., Baader et al. 2003, Chapter 2). The only difference is that in the algorithm described above the implementation of the
t-rule using existential nondeterminism and the implemen-tation of the∃-rule using universal nondeterminism is built in. In the literature, typically descriptions of tableau algo-rithms leave freedom for different implementations of the way in which the search tree is traversed. One can think of the algorithm described above as traversing a search tree that is generated by the different (existential and universal) non-deterministic choices that are made in the execution of the algorithm. This search tree is equivalent to the search tree of the usual tableau algorithm forALCconcept satisfiabil-ity. Thus, we get that the algorithm is correct. In fact, this algorithm is a reformulation of the standard algorithm known from the literature (Baader et al. 2003).
We will now consider several parameterized variants of the problem of concept satisfiability forALC. These parameters, in a sense, measure the distance of anALCconcept to the logicsALE,ALUandAL, respectively. We will make use of the tableau algorithm described above to establish upper bounds on the complexity of these problems. Lower bounds follow directly from Propositions 6–8.
We begin with the parameterized variant ofALCconcept satisfiability where the parameter measures the distance to
ALE.
Theorem 10. Concept satisfiability for the logicALC, pa-rameterized by the number of occurrences of the union oper-atortinC, ispara-co-NP-complete.
Proof. Hardness for para-co-NP follows from the fact that
ALE concept satisfiability is co-NP-complete (Proposi-tion 6). AnyALE concept is an ALC concept with zero occurrences of the union operatort. Therefore, the problem ofALCconcept satisfiability parameterized by the numberk
of occurrences of the union operatortinCis already co-NP-hard for the parameter valuek = 0. From this, it follows that the parameterized problem is para-co-NP-hard (Flum and Grohe 2003).
To show that the parameterized problem is also contained in para-co-NP, we describe an algorithm that can be imple-mented by an alternating Turing machine that only makes use of universal nondeterminism and that runs in fixed-parameter tractable time. This algorithm is similar to the tableau algo-rithm forALCdescribed above, with the only difference that thet-rule is now not implemented using existential nondeter-minism. Instead, we deterministically iterate over all possible choices that can be made in executions of thet-rule. That is, whenever thet-rule is applied, resulting in two possible next ABoxesA0 andA00, we firstly continue the algorithm
with A0, and if the continuation of the algorithm withA0
failed, we then continue the algorithm withA00instead.
Letkbe the number of occurrences of the union operatort
inC. For each occurrence, thet-rule is applied at most once. Therefore, the total number of possible choices resulting from executions of thet-rule is at most2k. Therefore, this
modifi-cation of the algorithm can be implemented by an alternating Turing machine that only uses universal nondeterminism and that runs in time2k· |C|O(1). In other words, the problem is
in para-co-NP, and thus is para-co-NP-complete.
Theorem 11. Concept satisfiability for the logicALC, pa-rameterized by the number of occurrences of full existential qualification∃R.CinC, ispara-NP-complete.
Proof. Hardness for para-NP follows from the fact thatALU
concept satisfiability is NP-complete (Proposition 7). Any
ALUconcept is anALCconcept with zero occurrences of full existential qualification∃R.C. Therefore, the problem ofALCconcept satisfiability parameterized by the number of occurrences of full existential qualification∃R.CinCis already NP-hard for the parameter valuek= 0. From this, it follows that the parameterized problem is para-NP-hard (Flum and Grohe 2003).
To show membership in para-NP, we modify the tableau algorithm forALC, similarly to the way we did in the proof
of Theorem 10. In particular, we describe an algorithm that can be implemented by an alternating Turing machine that only makes use of existential nondeterminism and that runs in fixed-parameter tractable time. We do so by executing the
∃-rule deterministically, instead of using universal nondeter-minism. That is, instead of using universal nondeterminism to choose which instantiation of the condition of the∃-rule to use, we iterate over all possibilities deterministically.
Let k be the number of occurrences of full existential quantification∃R.CinC. At each point, there are at mostk
different ways of instantiating the∃-rule. Moreover, after hav-ing applied the∃-rule for at mostktimes, the∃-rule is not applicable anymore. Therefore, the total number of possible choices to iterate over is at mostkk. Therefore, this
modifica-tion of the algorithm can be implemented by an alternating Turing machine that only uses existential nondeterminism and that runs in timekk·|C|O(1). In other words, the problem
is in para-NP, and thus is para-NP-complete.
Theorem 12. Concept satisfiability for the logicALC, pa-rameterized by both (i) the number of occurrences of the union operatortinCand (ii) the number of occurrences of full existential qualification∃R.CinC, is fixed-parameter tractable.
Proof (sketch). We can modify the alternating polynomial-time tableau algorithm forALCconcept satisfiability to work in deterministic fpt-time by implementing both thet-rule and the∃-rule deterministically, iterating sequentially over all possible choices that can be made for these rules. That is, we combine the ideas behind the proofs of Theorems 10 and 11. We omit the details of this fpt-time algorithm.
Interpretation of the Results
The results in this section are summarized in Table 3. Simi-larly as for the first case study, the results for the second case study show that parameterized complexity theory can make distinctions that classical complexity theory does not see. The problems studied in Theorems 10, 11 and 12 are all PSPACE-complete classically, yet from a parameterized point of view their complexity goes down to para-NP, para-co-NP and FPT. The para-NP- and para-co-NP-completeness results of Theo-rems 10 and 11 also yield algorithms that (1) firstly use an fpt-encoding to an instance of SAT and (2) then use a SAT solver to decide the problem (see, e.g., Biere et al. 2009).
parameter complexity ofALC concept satisfiability
– PSPACE-c (Proposition 5)
[image:7.612.321.554.577.658.2]# of occurrences oft para-co-NP-c (Theorem 10) # of occurrences of∃ para-NP-c (Theorem 11) # of occurrences oftand∃ FPT (Theorem 12)
Case Study 3: A Parameterized Complexity
View on Data Complexity
In this section, we provide our third case study illustrating the use of parameterized complexity for the analysis of descrip-tion logic reasoning. This third case study is about refining the complexity analysis for cases where one part of the input is much smaller than another part. Typically, these cases oc-cur where there is a small TBox and a small query, but where there is a large database of facts (in the form of an ABox). What is often done is that the size of the TBox and the query are seen as fixed constants—and the complexity results are grouped under the name of “data complexity.”
In this section, we will look at two concrete polynomial-time data complexity results for the description logicELI. Even though the data complexity view gives the same out-look on the complexity of these problems, we will use the viewpoint of parameterized complexity theory to argue that these two problems in fact have a different complexity. One of these problems is more efficiently solvable than the other. We chose the example ofELI to illustrate our point be-cause it is technically straightforward. More intricate fixed-parameter tractability results for conjunctive query answer-ing in description logics have been obtained in the literature (Bienvenu et al. 2017a; 2017b; Kikot, Kontchakov, and Za-kharyaschev 2011).
We begin by reviewing the description logicELI, and the two reasoning problems for this logic that we will look at (instance checking and conjunctive query entailment). We will review the classical complexity results for these two problems, including the data complexity results. We will then use results from the literature to give a parameterized com-plexity analysis for these two problems, and argue why the parameterized complexity perspective gives a more accurate view on the complexity of these problems.
The Description Logic
ELI
To define the logicELI, we first consider the logicEL. The description logicELis obtained from the logicALCby for-bidding any use of the negation operator (¬), the empty con-cept (⊥), the union operator (t), and universal quantification (∀R.C). The description logicELIis obtained from the logic
ELby introducinginverse roles. That is,ELI concepts are defined by the following grammar in Backus-Naur form, forR∈NRandA∈NC:
C:=A| > |CuC| ∃R.C| ∃R−.C.
InterpretationsI= (∆I,·I)forELIare defined as
interpre-tations forELwith the following addition:
• (∃R−.C)I ={x∈∆I: there exists somey∈CIsuch that(y, x)∈RI }.
Classical Complexity Results
We consider two reasoning problems for the logicELI. The first problem that we consider is the problem ofinstance checking. In this problem, the input consists of an ABoxA, a (general) TBoxT, an individual nameaand a conceptC, and the question is whetherA,T |=C(a)—that is, whether
for each interpretationI such thatI |= AandI |= T it holds thatI |=C(a).
The second problem that we consider is the problem of
conjunctive query entailment(which can be seen as a gener-alization of the problem of instance checking). Aconjunctive query is a setq of atoms of the formC(v) and R(u, v), where C is a concept, where R ∈ NR, and where u, v
arevariables. Let Var(q)denote the set of variables occur-ring inq. LetI = (∆I,·I)be an interpretation and letπ
be a mapping from Var(q)to ∆I. We write I |=π C(v) ifπ(v)∈CI, we writeI |=πR(u, v)if(π(u), π(v))∈RI,
we write I |=π q if I |=π α for all α ∈ q, and we
writeI |= qifI |=π qfor someπ : Var(q) → ∆I. For
any ABoxAand TBoxT, we writeA,T |= qifI |= q
for each interpretationIsuch thatI |= AandI |=T. In the problem of conjunctive query entailment, the input con-sists of a (general) TBoxT, an ABoxA, and a conjunctive queryq, and the question is to decide whetherA,T |=q.
Both the problem of instance checking and the problem of conjunctive query entailment for ELI are EXPTIME-complete in general.
Proposition 13(Baader, Brandt, and Lutz 2005; 2008). In-stance checking forELIisEXPTIME-complete.
Corollary 14(Baader, Brandt, and Lutz 2005; 2008). Con-junctive query entailment forELIisEXPTIME-complete.
The results of Propositions 13 and Corollary 14 are typi-cally called “combined complexity” results—meaning that all elements of the problem statement are given as inputs for the problem. To study how the complexity of these problems increases when the size of the ABoxAgrows—and when the size of the TBoxT and the size of the queryqremain the same—often different variants of the problems are studied. In these variants, the TBoxT and the queryqare fixed (and thus not part of the problem input), and only the ABoxA
is given as problem input. That is, there is a variant of the problem for each choice ofT andq. The computational com-plexity of these problem variants are typically called the “data complexity” of the problem.
From a data complexity perspective, the problems of in-stance checking and conjunctive query entailment for the logicELIare both polynomial-time solvable. In other words, from a data complexity point of view these problems are of the same complexity.
Claim 15(Krisnadhi 2007). Instance checking forELI is polynomial-time solvable regarding data complexity.
Claim 16 (Krisnadhi and Lutz 2007). Conjunctive query entailment forELI is polynomial-time solvable regarding data complexity.
Parameterized Complexity Results
We begin by observing that the algorithm witnessing polynomial-time data complexity for the problem of instance checking forELI corresponds to an fpt-algorithm for the problem when parameterized by the size of the TBoxT. Observation 17. Instance checking for ELI is fixed-parameter tractable when fixed-parameterized by|T |.
Proof. The algorithm to solve the problem of instance check-ing forELIdescribed by Krisnadhi (2007, Proposition 4.3) runs in time2|T |O(1)· |A|O(1).
The polynomial-time data complexity algorithm for the problem of conjunctive query entailment, on the other hand, does not translate to an fpt-algorithm, but to an xp-algorithm instead—when the parameter is (the sum of) the size of the TBoxT and the size of the queryq.
Observation 18. Conjunctive query entailment forELI is inXPwhen parameterized by|T |and|q|.
Proof. The algorithm to solve the problem of conjunc-tive query entailment forELI described by Krisnadhi and Lutz (2007, Theorem 4) runs in time(|A|+|T |)|q|O(1).
For this parameter, the problem of conjunctive query en-tailment forELIis in fact W[1]-hard—and thus not fixed-parameter tractable, assuming the widely believed conjecture that FPT6=W[1]. This follows immediately from the W[1]-hardness of conjunctive query answering over databases when parameterized by the size of the query (Papadimitriou and Yannakakis 1999, Theorem 1).
Corollary 19(Papadimitriou and Yannakakis 1999). Con-junctive query entailment forELIisW[1]-hard when param-eterized by|T |and|q|.
Interpretation of the Results
The results in this section are summarized in Table 4. Obser-vation 17 and Corollary 19 show that parameterized complex-ity can give a more accurate view on data complexcomplex-ity results than classical complexity theory. From a classical complexity perspective, the data complexity variants of both problems are polynomial-time solvable, whereas the parameterized data complexity variants of the problems differ in complexity. Both problems are solvable in polynomial time when only
instance checking
conjunctive query entailm.
combined complexity
EXPTIME-c (Prop 13)
EXPTIME-c (Cor 14)
data complexity in P (Claim 15) in P (Claim 16)
combined complexity with parameter|T |+|q|
in FPT
(Obs 17)
in XP (Obs 18) W[1]-h (Cor 19)
Table 4: (Parameterized) complexity results for instance checking and conjunctive query entailment forELI.
the ABoxAgrows in size. However, for instance checking the order of the polynomial is constant (Observation 17), and for conjunctive query entailment the order of the polyno-mial grows with the size of the queryq(Corollary 19). This is a difference with enormous effects on the practicality of algorithms solving these problems (see, e.g., Downey 2012).
Directions for Future Research
The results in this paper are merely an illustrative exposition of the type of parameterized complexity results that are pos-sible for description logic reasoning problems when using less commonly studied concepts (e.g., the classes para-NP, para-co-NP and para-PSPACE). We hope that this paper sparks a structured investigation of the parameterized com-plexity of different reasoning problems for the wide range of description logics that have been studied. For this, it would be interesting to consider a large assortment of different param-eters that could reasonably be expected to have small values in applications. It would also be interesting to investigate to what extent, say, para-NP-membership results can be used to develop practical algorithms based on the combination of fpt-time encodings into SAT and SAT solving algorithms.
Conclusion
We showed how the complexity study of description logic problems can benefit from using the framework of parameter-ized complexity and all the tools and methods that it offers. We did so using three case studies. The first addressed the problem of concept satisfiability forALC with respect to nearly acyclic TBoxes. The second was about the problem of concept satisfiability for fragments ofALCthat are close toALE,ALU andAL, respectively. The third case study concerned a parameterized complexity view on the notion of data complexity for instance checking and conjunctive query entailment forELI. Moreover, we sketched some directions for future research, applying (progressive notions from) pa-rameterized complexity theory to the study of description logic reasoning problems.
Acknowledgments. This work was supported by the Aus-trian Science Fund (FWF), project J4047.
References
Baader, F., and Sattler, U. 2001. An overview of tableau algorithms for description logics. Studia Logica69(1):5–40. Baader, F.; Calvanese, D.; McGuinness, D. L.; Nardi, D.; and Patel-Schneider, P. F. 2003. The Description Logic Handbook: Theory, Implementation and Applications. Baader, F.; Lutz, C.; Miliˇci´c, M.; Sattler, U.; and Wolter, F. 2005. Integrating description logics and action formalisms for reasoning about web services.
Baader, F.; Brandt, S.; and Lutz, C. 2005. Pushing theEL
envelope. InProceedings of the 19th International Joint Conference on Artificial Intelligence (IJCAI 2005), 364–369. Baader, F.; Brandt, S.; and Lutz, C. 2008. Pushing theEL
Baader, F.; Horrocks, I.; and Sattler, U. 2008. Description logics. InHandbook of Knowledge Representation, volume 3 ofFoundations of Artificial Intelligence. Elsevier. 135–179. Bienvenu, M.; Kikot, S.; Kontchakov, R.; Podolskii, V. V.; Ryzhikov, V.; and Zakharyaschev, M. 2017a. The complexity of ontology-based data access with OWL 2 QL and bounded treewidth queries. InProceedings of the 36th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Sys-tems (PODS 2017), 201–216. ACM.
Bienvenu, M.; Kikot, S.; Kontchakov, R.; Ryzhikov, V.; and Zakharyaschev, M. 2017b. On the parameterised complexity of tree-shaped ontology-mediated queries in OWL 2 QL. In
Proceedings of the 30th International Workshop on Descrip-tion Logics (DL 2017).
Biere, A.; Heule, M.; van Maaren, H.; and Walsh, T., eds. 2009.Handbook of Satisfiability, volume 185 ofFrontiers in Artificial Intelligence and Applications. IOS Press.
Bodlaender, H. L.; Downey, R.; Fomin, F. V.; and Marx, D., eds. 2012. The Multivariate Algorithmic Revolution and Beyond. Springer Verlag.
Ceylan, I. I., and Pe˜naloza, R. 2014. The Bayesian descrip-tion logic BEL. In Proceedings of the 7th International Joint Conference on Automated Reasoning (IJCAR 2014), 480–494.
Chen, J., and Kanj, I. A. 2012. Parameterized complex-ity and subexponential-time computabilcomplex-ity. In Bodlaender, H. L.; Downey, R.; Fomin, F. V.; and Marx, D., eds.,The Multivariate Algorithmic Revolution and Beyond, 162–195. Chen, J.; Chor, B.; Fellows, M.; Huang, X.; Juedes, D.; Kanj, I. A.; and Xia, G. 2005. Tight lower bounds for certain param-eterized NP-hard problems. Information and Computation
201(2):216–231.
Donini, F. M., and Massacci, F. 2000. Exptime tableaux for
ALC.Artificial Intelligence124(1):87–138.
Donini, F. M.; Lenzerini, M.; Nardi, D.; Hollunder, B.; Nutt, W.; and Spaccamela, A. M. 1992. The complexity of existen-tial quantification in concept languages. 53(2-3):309–327. Donini, F. M.; Lenzerini, M.; Nardi, D.; and Nutt, W. 1997. The complexity of concept languages.Information and Com-putation134(1):1–58.
Downey, R. G., and Fellows, M. R. 1995. Fixed-parameter tractability and completeness. II. On completeness forW[1].
Theoretical Computer Science141(1-2):109–131.
Downey, R. G., and Fellows, M. R. 2013.Fundamentals of Parameterized Complexity. Springer Verlag.
Downey, R. 2012. A basic parameterized complexity primer. In Bodlaender, H. L.; Downey, R.; Fomin, F. V.; and Marx, D., eds.,The Multivariate Algorithmic Revolution and Beyond, 91–128.
Flum, J., and Grohe, M. 2003. Describing parameterized com-plexity classes. Information and Computation187(2):291– 319.
Flum, J., and Grohe, M. 2006. Parameterized Complexity Theory. Springer Verlag.
de Haan, R., and Szeider, S. 2014a. Fixed-parameter tractable reductions to SAT. In Egly, U., and Sinz, C., eds., Proceed-ings of the 17th International Symposium on the Theory and Applications of Satisfiability Testing (SAT 2014), 85–102. de Haan, R., and Szeider, S. 2014b. The parameterized complexity of reasoning problems beyond NP. In Baral, C.; De Giacomo, G.; and Eiter, T., eds.,Proceedings of the 14th International Conference on the Principles of Knowledge Representation and Reasoning (KR 2014). AAAI Press. de Haan, R., and Szeider, S. 2016. Parameterized complexity results for symbolic model checking of temporal logics. In
Proceedings of the 15th International Conference on the Principles of Knowledge Representation and Reasoning (KR 2016), 453–462. AAAI Press.
de Haan, R., and Szeider, S. 2017. Parameterized complexity classes beyond para-NP.J. of Computer and System Sciences
87:16–57.
de Haan, R. 2016.Parameterized Complexity in the Polyno-mial Hierarchy. Ph.D. Dissertation, Technische Universit¨at Wien.
Kikot, S.; Kontchakov, R.; and Zakharyaschev, M. 2011. On (in)tractability of OBDA with OWL 2 QL. InProceedings of the 24th International Workshop on Description Logics (DL 2011).
Krisnadhi, A., and Lutz, C. 2007. Data complexity in theEL
family of description logics. InProceedings of the 14th In-ternational Conference on Logic for Programming, Artificial Intelligence, and Reasoning (LPAR 2007), 333–347. Krisnadhi, A. A. 2007. Data complexity of instance check-ing in theELfamily of description logics. Master’s thesis, Technische Universit¨at Dresden, Germany.
Motik, B. 2012. Parameterized complexity and fixed-parameter tractability of description logic reasoning. In Bjørner, N., and Voronkov, A., eds.,Proceedings of the 18th International Conference on Logic for Programming, Artifi-cial Intelligence, and Reasoning (LPAR 2012), 13–14. Papadimitriou, C. H., and Yannakakis, M. 1999. On the complexity of database queries.J. of Computer and System Sciences58(3):407–427.
Schild, K. 1991. A correspondence theory for terminological logics: Preliminary report. In Mylopoulos, J., and Reiter, R., eds.,Proceedings of the 12th International Joint Conference on Artificial Intelligence (IJCAI 1991), 466–471.
Schmidt-Schauß, M., and Smolka, G. 1991. Attributive con-cept descriptions with complements.Artificial Intelligence
48(1):1–26.
Simanˇc´ık, F.; Motik, B.; and Horrocks, I. 2014. Consequence-based and fixed-parameter tractable reasoning in description logics. Artificial Intelligence209:29–77.
Simanˇc´ık, F.; Motik, B.; and Kr¨otzsch, M. 2011. Fixed pa-rameter tractable reasoning in DLs via decomposition. In
