Error-Tolerance and Error Management in Lightweight Description Logics

The construction and maintenance of ontologies is an error-prone task. As such, it is not uncommon to detect unwanted or erroneous consequences in large-scale ontologies which are already deployed in production. While waiting for a corrected version, these ontologies should still be available for use in a “safe” manner, which avoids the known errors. At the same time, the knowledge engineer in charge of producing the new version requires support to explore only the potentially problematic axioms, and reduce the number of exploration steps. In this paper, we explore the problem of deriving meaningful consequences from ontologies which contain known errors. Our work extends the ideas from inconsistency-tolerant reasoning to allow for arbitrary entailments as errors, and allows for any part of the ontology (be it the terminological elements or the facts) to be the causes of the error. Our study shows that, with a few exceptions, tasks related to this kind of reasoning are intractable in general, even for very inexpressive description logics.


Introduction
Description logics (DLs) [4] are a family of knowledge representation formalisms, which have been successfully applied to build large ontologies modelling different application domains. Among the members of this large family, two subfamilies of lightweight DLs known as DL-Lite [2,11] and EL [3,6] are of particular interest due to the low complexity of their standard reasoning tasks. Unfortunately, building and maintaining large ontologies in these or other languages is error-prone, and one often encounters errors, even after a careful pre-publication verification step. In addition, wellmaintained ontologies usually stick to specific production cycles; for example, Snomed CT [26] produces a new version every 6 months. In the meantime, it should still be possible to use this ontology, although applying a "safe" mode that tries to avoid the (potential) causes for the known error.
In order to tackle this goal, we follow the original ideas from inconsistency-tolerant query answering first developed in the database realm [7] and then studied also for DLs [8,15,19], except that instead of focusing on inconsistencies as the sole proxy of erroneous modelling, we allow arbitrary consequences to be considered erroneous. For example, EL ontologies are always consistent, but earlier versions of Snomed (which is modelled in this logic) wrongly entailed that every amputation of a finger is an amputation of a hand. Analogously to previous work, we consider error-tolerant consequences to be those which can avoid the errors, in three levels of generality: brave (if there is one way to avoid the error and entail the consequence), cautious (if any correction of the ontology entails the consequence) and the intersection of all repairs, where a repair refers to a maximal subset of the ontology which avoids the error. We study the complexity of reasoning with these three variants, and show that in most cases the problems become intractable.
At the end of the paper, we study the extra-logical problem of helping the knowledge engineer in finding the wrong axioms which caused the error in the first place. We suggest finding an axiom that divides the number of potential repairs in half according to its membership in them, but show that even this task is hard for very simple logics. This paper collects, corrects, and improves results which have been previously presented at conferences [20,22,23].

Preliminaries
For this paper we focus on the lightweight families of description logics, which are known as the DL-Lite and EL families, using a meaningful representative of each family.
Consider three mutually disjoint sets N C , N R , and N I of concept-, role-, and individual names, respectively. The class of EL concepts is built by the grammar rule C ∶∶= A | ⊤ | C ⊓ C | ∃r.C , where A ∈ N C and r ∈ N R . The classes of DL-Lite concepts and DL-Lite roles are defined through the grammar rules B ∶∶= A | ∃s | ⊤ | ⊥ and s ∶∶= r | r − , where A ∈ N C and r ∈ N R . An EL TBox is a finite set of general concept inclusions (GCIs) of the form C ⊑ D , where C and D are EL concepts. A DL-Lite Horn TBox is a finite set of Horn concept inclusions (HCIs) of the form B 1 ⊓ ⋯ ⊓ B n ⊑ B , where n ≥ 1 , and each B, B i is a DL-Lite concept, and role inclusions (RIs) of the form s 1 ⊑ s 2 , where r 1 and r 2 are DL-Lite roles. An ( EL or DL-Lite Horn ) ABox is a finite set of assertions of the form A(a) (concept assertion) or r(a, b) (role assertion), where A ∈ N C , r ∈ N R , and a, b ∈ N I . A knowledge base (sometimes also called an ontology) is a pair (T, A) where T is a TBox and A is an ABox.
In the following, we will handle DL-Lite and EL cases simultaneously, and hence often avoid the prefix in the name, speaking of e.g. a TBox. If there are several elements, we are implicitly assuming that they all belong to the same logical language. We sometimes use the term axiom to refer to GCIs, HCIs, RIs, and assertions as a whole, when it is not relevant what kind of element of an ontology we are referring to. In that case, an ontology becomes simply a finite set of axioms.
As an important special case, we will also consider the sublogic HL , in which a TBox is a finite set of HCIs formed using concept names exclusively. We note that HL is a notational variant of propositional Horn logic, and that it lies at the intersection of EL and DL-Lite. That is, every HL ontology is also an EL and a DL-Lite ontology.
The semantics of these logics, as all DLs, is based on first-order semantics, where concepts correspond to unary predicates, and roles are binary predicates. Formally, an interpretation is a pair I = ( I , ⋅ I ) , where I is a non-empty set called the domain, and ⋅ I is the interpretation function, which maps every individual name a ∈ N I to an element a I ∈ I , every concept name A ∈ N C to a set A I ⊆ I , and every role name r ∈ N R to a binary relation r I ⊆ I × I . The interpretation function is extended to cover all other constructors of DL-Lite and EL-and hence interpret arbitrary EL and DL-Lite concepts and roles-as follows: and -(∃s) I ∶= (∃s.⊤) I .
The interpretation I satisfies the GCI or HCI C ⊑ D iff C I ⊆ D I ; the RI s 1 ⊑ s 2 iff s I 1 ⊆ s I 2 ; the concept assertion A(a) iff a I ∈ A I ; and the role assertion r(a, b) iff (a I , b I ) ∈ r I . I is a model of the TBox T , the ABox A or the ontology O iff it satisfies all the axioms in T , A , or O , respectively. We denote this as I ⊧ T, I ⊧ A , and I ⊧ O , respectively. The ontology O is consistent iff there is a model of O . Given an ontology O and an axiom , we say that O entails (denoted as O ⊧ ) iff every model of O also satisfies .
One of the main reasoning tasks in DLs is entailment checking; that is, deciding whether a given ontology entails an axiom. In EL and DL-Lite, entailments can be checked in polynomial time. In some cases, the axiom that is tested for entailment is not a wanted consequence, but rather an error that one tries to avoid. For example, if we want to check whether an ontology is consistent, we might test whether O ⊧ ⊥(a) , which holds only in the case the O has no models. When this entailment holds, it is a signal of an error in the ontology. In these situations, if this unwanted entailment holds, then one may be interested in identifying the axioms that cause this consequence-in an attempt to place the blame -or a candidate sub-ontology which excludes it, giving rise to the following definitions. In words, a justification is a minimal (w.r.t. set inclusion) sub-ontology that entails the consequence, while a repair is a maximal (w.r.t. set inclusion) sub-ontology that avoids it. It is well known that there might exist exponentially many justifications or repairs for a given consequence. In the following, (O, ) and (O, ) denote the sets of all justifications and repairs for w.r.t. O . If the specific ontology used is irrelevant, we often remove the first argument, and write simply e.g.
( ). An interesting property of HL ontologies, which we will use throughout this paper, is that they can be represented as directed hypergraphs. Under this view, nodes represent concept names or individual names, and a hyperedge corresponds to an axiom in the ontology. Hence, entailment checking corresponds to the task of deciding reachability between nodes. More importantly, a justification is nothing more than a simple hyperpath. If we further restrict HL to disallow conjunctions on the left-hand side of axioms, then this representation collapses to classical graphs and the exploration of simple paths determines justifications.
The (hyper)graph representation can be extended to DL-Lite Horn ontologies by allowing nodes to represent also the complex concepts provided in this language; that is, ∃s and ⊥ . However, reasoning becomes more complex from the need to handle role inclusions, inverse roles, and in particular, the special semantics of ⊥ which represents a contradiction. For example, to derive O ⊧ A ⊑ B from a DL-Lite Horn ontology O , it suffices to derive O ⊧ A ⊑ ⊥.

Error-Tolerant Reasoning
If an unwanted consequence or error is entailed by an ontology, then we know that this ontology must contain some errors. That means, in particular, that we cannot directly trust the consequences derived from it. Still, we do not want to throw the whole ontology away and start from scratch, or wait until a human expert has fixed all the issues to use it. Alternatively, we want to be able to derive some consequences that may still be trusted. Intuitively, these are consequences that can be derived using axioms which do not play a role in the error. This intuition gives rise to three main semantics.

Definition 2 (error-tolerant semantics)
Let O be an ontology and , two axioms such that O ⊧ . We say that is a cau- Note that this definition considers the presence of one error only. While in practice one should expect to observe multiple errors, for the scope of this paper we focus on the simpler case and leave open the question of dealing with several errors. In any case, the notion of a repair, and by extension the error-tolerant semantics, can be easily generalised to the case with several errors in the obvious way: a repair is a maximal sub-ontology from which none of the known errors follows.
In Definition 2 we consider error-tolerant semantics based on the whole ontology. It is sometimes convenient to consider the more general cases where a portion of the ontology is fixed, and its axioms cannot be removed to form a repair. Thus, we can analogously define the notions of ABox error-tolerant semantics, where the TBox is fixed and repairs are defined only as subsets of the ABox, and dually TBox error-tolerant semantics where the ABox is fixed.
Note that there is a natural strength relationship between the three semantics from Definition 2: every IAR consequence is also a cautious consequence, and each cautious consequence is a brave consequence. It is easy to build examples showing that the converse implications do not hold in general, even for HL.
Recall that classical entailments in these logics can be decided in polynomial time. Unfortunately, as we will see shortly, the same cannot be said about the error-tolerant semantics in general. But first, we consider a tractable case. For the following proof we use the notion of a directed hypergraph. While there are many ways to define directed hypergraphs, are interested in those having singleton heads [16].
In words, a directed hyperedge connects a set of nodes (the sources) with one node (the head). The notion of a hyperpath generalises the idea of a path in a graph, by using hyperedges; that is, all the sources W of a hyperedge (W, v) need to be reached before this hyperedge can be followed. We sometimes see hyperpaths as sets of hyperedges, and hence treat them as hypergraphs.

Theorem 4 Brave entailment w.r.t. DL-Lite Horn ontologies can be decided in polynomial time.
Proof Let O be a DL-Lite Horn ontology. We construct the directed hypergraph H O = (V, E) by setting V to be the set of all DL-Lite Horn individual names and concept names appearing in O , together with the concepts ⊤, ⊥ , and ∃s , where s is a role name appearing in O or its inverse. The set E of hyperedges is defined by the axioms as follows: It is easy to verify (see also [24] For the rest of the proof we consider as axioms only HCIs, but all other cases are treated analogously. This can be verified in polynomial time (on the size of the ontology) through a generalisation of the usual reachability algorithm, which marks nodes with three potential values: unreachable, reachable, and safely reachable meaning that it is reachable through a path that does not contain the undesired subpath. These labels are forward propagated through the edges of the hypergraph, until all nodes have been adequatedly marked. ◻ This theorem extends the previous tractability result known for HL [20] which is a sublogic of DL-Lite Horn . It is also in contrast with the hardness result by [9], who show that under the ABox error-tolerant semantics, brave entailments in this same logic are nP-complete, even if limited to the special case of being an inconsistency check and an instance query (that is, a concept assertion). Note that this latter result does not contradict Theorem 4 since for the ABox semantics no axioms from the TBox may be removed. In terms of the proof of the theorem, this means that several hyperedges of H O are always present and the construction of a path avoiding some nodes does not suffice to guarantee the existence of an adequate repair.
If we consider EL , even brave entailment checking is nP-hard, as stated next.
Proof The upper bound is obtained by considering the following non-deterministic algorithm: first guess a sub-ontology M ⊆ O and then verify that M ⊧ and M ̸ ⊧ . If this is true, then there exists a repair of , which extends M , that entails .
For the lower bound, we present a reduction from the more minimal valuations (mmv) problem for monotone Boolean formulas, which is known to be nP-hard [5,14]: given a monotone Boolean formula and a set of minimal valuations satisfying , decide whether there exists a valuation satisfying which does not contain any valuation from . The reduction is based on an idea previously used in the context of the enumeration of justifications in [24].
Let , be an instance of mmv, and let ( ) and ( ) denote the sets of all subformulas of and of all complex subformulas of , respectively. That is, csub excludes all propositional variables. For every ∈ ( ) , we introduce three concept names B , C , D , and two role names r , s . For every V ∈ , we similarly introduce B V , C V , D V , r V , and s V . In addition, we introduce the concept names A, E, D, and F. Each ∈ ( ) defines a TBox T as follows: if is the propositional variable p, then T ∶= {A ⊑ B p } ; if = 1 ∧ 2 , then and if = 1 ∨ 2 , then Following the same method, we construct for every V ∈ the TBox Finally, we set Notice that, for every It is easily seen, exploring the axioms in T , that Thus, a valuation W satisfies iff the TBox The next step is to show that the two remaining semantics are intractable as well, in general. In this case, we show that the problems are conP-complete and that hardness holds already for HL , even if we disallow conjunctions on the left of HCIs. For the lower bound, we reduce the conP-complete no-path-through-node (nPTn) problem: given a graph G = (V, E) and nodes s, t, m ∈ V , decide if there is no simple path from s to t that passes through m. Given an instance of nPTn, we introduce a concept name A v for every v ∈ (V⧵{m}) ∪ {m 1 , m 2 } , where m 1 , m 2 ∉ V , and construct the HL TBox There is no path from s to t passing through m iff every In the literature, the higher complexity observed for the error-tolerant semantics has been often attributed to the fact that the number of repairs may be exponential on the size of the ontology. While there is some truth in this argument, it is also incomplete; for example, it fails to explain why brave consequences in DL-Lite Horn remain polynomial, even though the number of repairs remains unchanged. As we will see next, the reasons for hardness are more subtle. In fact, we can guarantee the existence of EL ontologies having a sub-exponential number of repairs w.r.t. a given consequence, for which error-tolerant entailments are still intractable (unless P = NP). Assume by contradiction that there exists an algorithm that decides cautious entailments in polynomial time on |T| and | (T, A ⊑ E)| ; that is, there exists an algorithm with runtime bounded by some polynomial p(t, r), where t is the size of the ontology and r the number of repairs, which decides cautious entailment. Using this algorithm, we can decide mmf as follows: run on T for the cautious entailment A ⊑ F and stop after at most p(|T|, | | + 5| ( )|) steps. If the answer is yes, then is the set of all falsifying valuations, and so there is no new one. If it answers no, or the execution of did not terminate until this time bound, then there must be at least one more falsifying valuation. This means that can be used to decide mmf in polynomial time, contradicting the fact that mmf is nP-complete.
The proof for brave entailments is analogous, but using a construction closer to that of Theorem 5. We leave the details as an exercise to the reader. ◻ All kinds of error-tolerant entailments can be decided in exponential time on the size of the ontology in all the logics that we consider here. In fact, one can simply enumerate all the 2 |O| sub-ontologies of O , and for each of them check in polynomial time on |O| that (i) it is a repair of and (ii) whether it entails . This means that whenever a consequence has exponentially many repairs, brave and cautious entailments can always be decided in polynomial time on the size of | (O, )| . Hence, the hardness from Theorem 7 must arise from a situation with less than exponentially many repairs.

Corollary 8 It is intractable to decide cautious and brave consequences of EL ontologies, even if the number of repairs is sub-exponential.
Obviously, we cannot have an analogue of Theorem 7 for DL-Lite Horn , since brave entailments are already known to be decidable in polynomial time. However, if we restrict to ABox repairs (that is, where the TBox is fixed, and only assertions from the ABox can be removed to avoid an error) then hardness arises again. In the following theorem, we call ABox-cautious and ABox-brave the error-tolerant semantics obtained by restricting to ABox repairs only.
where p is a polynomial, then we can solve mmf by running this algorithm for time p(|O|, | |).
For brave entailments, we reduce mmv. Given an instance , of mmv, construct T and A as in the previous part of the proof and define Then, A (a) is a brave consequence of O = (T, A) w.r.t. ⊤ ⊑ ⊥ iff there is a valuation satisfying that does not contain any V ∈ . Using the same argument from the case of cautious consequences, this shows that brave entailments cannot be decided in polynomial time on the number of ABox repairs. ◻

IAR Repairs
For the hardness results presented at the end of the previous section, we did not consider the IAR semantics. In this section we show that, despite the complexity of the problem in general, some practical approaches can still be implemented for DL-Lite Horn . To achieve this, we exploit the duality between repairs and justifications, and results on enumeration complexity. It was previously shown that the simple hyperpaths of a directed hypergraph can be enumerated with polynomial delay [24]; that is, through a method that requires only polynomial time (on the size of the hypergraph) between the output of successive answers [17]. This fact was used to prove that all justifications for a DL-Lite Horn TBox (when the ABox is empty) can be enumerated in polynomial delay, using the reduction to hypergraphs sketched before. The result (and its proof) trivially extends to general ontologies by including the hyperedges that represent assertions from the ABox. From the duality between justifications and repairs, we know that the union of all justifications and the intersection of all repairs complement each other. In other words, to compute the intersection of all repairs, as a step to deduce IAR entailments, it suffices to remove from the ontology the union of all justifications. From our complexity results (Theorem 6), it follows immediately that the latter task-finding the union of all justificationsis also intractable. Still, we can devise an anytime algorithm, which iteratively computes one justification at a time-over-approximating the intersection of all repairsand stop when either the consequence does not follow, or no more justifications are available. This approach is described in Algorithm 1, where more-juSTifiCaTionS is a Boolean function that verifies whether there are still more justifications for w.r.t. O that have not yet been enumerated, and nexT-juSTifiCaTion in that case outputs the next justification in the enumeration.
Note that Algorithm 1 stops as soon as it is obvious that cannot be entailed by the intersection of all repairs: at each iteration of the while loop, the set U monotonically decreases, hence further iterations would only remove more consequences, but never adds new ones. When the loop finishes, we know that we have enumerated all justifications, and hence U is exactly the intersection of all repairs, which guarantees the correctness of the algorithm. An important property of this algorithm is that the order of the enumeration can be manipulated to try to add justifications with previously unseen axioms first, so that the set U shrinks as fast as possible. However, one can only guarantee that the IAR entailment holds after all justifications have been found.
The practical benefit of Algorithm 1 resides not only in its anytime nature, but also in the fact that it deals with the enumeration of justifications, rather than repairs. Indeed, although in theory an entailment may also have exponentially many justifications, it has been empirically verified that in human-developed ontologies the number of justifications, and their size, tends to be small [18,27,29]. In contrast, the number of repairs does grow exponentially in well-maintained ontologies [20].
As an alternative to over-approximating the intersection of all repairs, one can try to under-approximate it. One way to do this is to use modularisation techniques to efficiently compute a so-called justification-preserving module. In essence, these modules are sub-ontologies that contain the union of all justifications. Different techniques balancing the computation time and the quality of the approximation have been proposed [12,13,25,28], but in general the methods based on a syntactic analysis of the ontology tend to behave better.
As a final remark on this aspect, we note that the computation of a justification preserving module M is also useful to improve the efficiency of Algorithm 1: during the while loop, rather than computing the justification w.r.t. the original ontology O , one can restrict to the axioms in the module M . This allows the execution to avoid paths that will not lead to a justification, reducing the time and space required during runtime.

Correcting Errors
So far in this paper, we have considered the problem of dealing automatically with ontologies that are known to contain some errors by trying to avoid the causes of these errors during reasoning. Beyond this, there is not much that can be achieved in a fully automated manner. Indeed, from the purely logical point of view, all possible repairs are equal in the sense that they all remove the undesired consequence. From the knowledge representation point of view, however, we expect only one of them to be correct in the sense that their axioms all represent truths from the domain being modelled. Note that this is true even if multiple errors occur: there is one maximal sub-ontology that avoids all the known errors; and this is the one we are interested in finding.
Following approaches from belief revision, considering the postulate of minimal change, one could propose to focus on repairs of maximum cardinality. Alternatively, one could associate a degree of trust or preference to each axiom, and focus on the most trusted or preferred repairs. These, and other similar solutions that have been proposed, not only still suffer from the problem of a multiplicity of solutions (in the worst case, still exponentially many), but in addition cannot guarantee that the correct repair is among those selected; e.g., the correct repair might in fact be one with minimal cardinality. The issue is that correctness is an extra-logical property, which does not depend on the shape or interrelation of axioms, but rather on the domain that the ontology is modelling. In fact, the only way to know whether an axiom-and by extension, an ontology-is a correct representation of the domain knowledge is to ask a domain expert.
The process of consulting with a domain expert is the most expensive part of the process of error resolution in an ontology. Not only are these experts a limited resource, but they need to understand what the axioms say before they can make a determination on their correctness. For that reason, one would like to provide the expert with as few questions as possible in order to find the repair that resolves the error. To achieve this goal, one potential idea is to find an axiom , called cut axiom, that partitions the space of repairs into two halves according to whether they contain or not.
Note that this definition allows a flexibility in that the set of repairs might not be partitioned in half, but the cut axiom gets as close to it as possible. The idea behind the cut axiom is that, by verifying its correctness, we can immediately cut the search space (almost) in half. Specifically, if is correct, then we know that the right repair is among R + , and if it is wrong, we should focus only on R − . Hence, the first question is how to compute such an axiom. Unfortunately, it turns out that deciding whether an axiom is a cut axiom is conP-hard already for the very simple sublogic of HL which disallows conjunctions.

Theorem 12
Let O be an HL ontology, ∈ O an axiom, and an unwanted consequence of O . Deciding whether is a cut axiom is co NP-hard.
Proof We prove this by a reduction from the conP-complete repair without edge (rwe) problem [22]: given a graph G = (V, E) , nodes s, t ∈ V , and an edge (v, w) ∈ E , decide if there is a maximal subgraph G � = (V, F) of G such that t is not reachable from s and (v, w) ∉ F.
Let n ∶= |E| . Note that there can exist at most 2 n−1 maximal subgraphs of the form we seek that contain (v, w) and at most 2 n−1 that do not contain this edge. Assuming w.l.o.g. that there are at least two maximal subgraphs, we construct an ontology M , which simulates an extension of G obtained by adding 2n new vertices z 1 , … , z 2n , and the edges Formally, for every u ∈ V ∪ {z 1 , … , z 2n } , we create a concept name A u , and construct the TBox Clearly, the size of M is linear on the size of G. For a subgraph (V, F) of G, we define M F to be the sub-ontology of M restricted to edges appearing in F. This ontology has the following property. For every maximal subgraph (V, F) of G where t is not reachable from s, M that contains all edges from F; that is, there is a oneto-one correspondence between the maximal subgraphs of G that remove reachability and the repairs of M that con- repairs of A s ⊑ A t w.r.t. M that contain all edges in F; in particular, exactly 2 2n−1 of them contain the axiom A v → A z 1 .
In particular, if G has m maximal subgraphs that contain (v, w) and that do not contain this edge, then M will have m + ⋅ 2 2n−1 repairs containing A v ⊑ A z 1 and ⋅ 2 2n−1 repairs not containing the axiom. Moreover, every other edge of G will appear in at most 2 n−1 repairs of M , and all the edges in E ′ will be in exactly the same number of repairs as A v ⊑ A z 1 . Thus, A v ⊑ A z 1 is a cut axiom w.r.t. M iff ≥ 1 ; that is, iff there is at least one maximal subgraph of G avoiding the paths from s to t which does not contain (v, w). ◻ In summary, this theorem tells us that it is not possible to efficiently construct a decision tree about the axioms proposed to the domain expert for analysis, which minimises the overall number of questions needed to guarantee that a repair is obtained. Still, as explained already, the most expensive resources are exactly those of the domain expert. The decision tree could, in fact, be constructed in advance, as a preprocessing step, or even in parallel as the expert is understanding and verifying the first proposed culprits.

Conclusions
We have studied the problem of dealing with and managing errors in lightweight description logic ontologies. For the former problem, we extend the idea of inconsistencytolerant reasoning-defining different kinds of semantics depending on the use of the repairs-to deal with arbitrary errors that may, or may not, be connected to inconsistency. Analysing the complexity of three error-tolerant semantics, we have shown that in most cases this kind of reasoning becomes intractable, although we identified a few tractable cases and provided effective algorithms for handling them. Interestingly, we have shown that the cause for intractability is more subtle than just the number of potential repairs as previously argued.
For the second problem, we proposed to partition the space of all repairs as closely as possible in halves, to help a knowledge engineer (KE) to find the correct repair through a binary search-like process. While a decision plan can be constructed offline before being presented to the KE, just deciding whether an axiom produces an adequate partition of the repairs is nP-hard.
One issue that was not considered in this paper is the multiplicity of errors. Indeed, it is likely that more than one unwanted consequence is detected between two consecutive versions of an ontology. We note that the notions of justification and repair can be easily extended to consider several consequences, and all the hardness results still apply to the more general situation. Whether the tractable cases remain so is still to be verified.
As future work we want to pursue two different goals. On the one hand, we plan to extend our study to more complex entailments (e.g., conjunctive queries), while searching for conditions to regain tractability. On the other hand, we will develop methods for dealing efficiently with these errortolerant reasoning tasks, despite their computational complexity. One potential approach to achieve this is to exploit the properties of very efficient SAT solvers. We note that SAT-based techniques have already shown promising results in the areas of axiom pinpointing and inconsistent query answering [1,10,27].