An Overview of Tableau Algorithms for Description Logics

An Overview of Tableau Algorithms for Description Logics  Franz Baader ([email protected]) and Ulrike Sattler ([email protected]) LuFG Theoretical Computer Science, RWTH Aachen, Germany May 19, 2000 Abstract. Description logics are a family of knowledge representation formalisms that are descended from semantic networks and frames via the system K L - ONE . During the last decade, it has been shown that the important reasoning problems (like subsumption and satisfiability) in a great variety of description logics can be decided using tableau-like algorithms. This is not very surprising since description logics have turned out to be closely related to propositional modal logics and logics of programs (such as propositional dynamic logic), for which tableau procedures have been quite successful. Nevertheless, due to different underlying intuitions and applications, most description logics differ significantly from run-of-the-mill modal and program logics. Consequently, the research on tableau algorithms in description logics led to new techniques and results, which are, however, also of interest for modal logicians. In this article, we will focus on three features that play an important rôle in description logics (number restrictions, terminological axioms, and role constructors), and show how they can be taken into account by tableau algorithms. Keywords: Description Logics, Tableau Algorithms 1. Introduction Description logics (DLs) are a family of knowledge representation languages which can be used to represent the terminological knowledge of an application domain in a structured and formally well-understood way. The name description logics is motivated by the fact that, on the one hand, the important notions of the domain are described by concept descriptions, i.e., expressions that are built from atomic concepts (unary predicates) and atomic roles (binary predicates) using the concept and role constructors provided by the particular DL. On the other hand, DLs differ from their predecessors, such as semantic networks and frames (Quillian, 1967; Minsky, 1981), in that they are equipped with a formal, logic-based semantics, which can, e.g., be given by a translation into first-order predicate logic. Knowledge representation systems based on description logics (DL systems) provide their users with various inference capabilities that deduce implicit knowledge from the explicitly represented knowledge. For instance, the subsumption algorithm allows one to determine subconcept-superconcept relationships: C is subsumed by D iff all instances of C are also instances  This is an extended version of a paper published in the proceedings of Tableaux 2000 (Baader and Sattler, 2000). c 2001 Kluwer Academic Publishers. Printed in the Netherlands. studia--final-complete.tex; 14/08/2001; 13:30; p.1 2 Franz Baader and Ulrike Sattler D of , i.e., the first description is always interpreted as a subset of the second description. In order to ensure a reasonable and predictable behaviour of a DL system, the subsumption problem for the DL employed by the system should at least be decidable, and preferably of low complexity. Consequently, the expressive power of the DL in question must be restricted in an appropriate way. If the imposed restrictions are too severe, however, then the important notions of the application domain can no longer be expressed. Investigating this trade-off between the expressivity of DLs and the complexity of their inference problems has been one of the most important issues in DL research. Roughly, the research related to this issue can be classified into the following four phases. Phase 1: First system implementations. The original K L - ONE system (Brachman and Schmolze, 1985) as well as its early successor systems (such as BACK (Peltason, 1991), K-R EP (Mays et al., 1991), and L OOM (MacGregor, 1991)) employ so-called structural subsumption algorithms, which first normalise the concept descriptions, and then recursively compare the syntactic structure of the normalised descriptions (see, e.g., (Nebel, 1990a) for the description of such an algorithm). These algorithms are usually very efficient (polynomial), but they have the disadvantage that they are complete only for very inexpressive DLs, i.e., for more expressive DLs they cannot detect all the existing subsumption relationships (though this fact was not necessarily known to the designers of the early systems). Phase 2: First complexity and undecidability results. Partially in parallel with the first phase, the first formal investigations of the subsumption problem in DLs were carried out. It turned out that (under the assumption P = NP) already quite inexpressive DLs cannot have polynomial subsumption algorithms (Brachman and Levesque, 1984; Nebel, 1990b), and that the DL used by the K L - ONE system even has an undecidable subsumption problem (Schmidt-Schauß, 1989). In particular, these results showed the incompleteness of the (polynomial) structural subsumption algorithms. One reaction to these results (e.g., by the designers of BACK and L OOM) was to call the incompleteness of the subsumption algorithm a feature rather than a bug of a DL system. The designers of the C LASSIC system (Patel-Schneider et al., 1991; Brachman, 1992) followed another approach: they carefully chose a restricted DL that still allowed for an (almost1 ) complete polynomial structural subsumption algorithm (Borgida and Patel-Schneider, 1994). 6 Phase 3: Tableau algorithms for expressive DLs and thorough complexity analysis. For expressive DLs (in particular, DLs allowing for disjunction and/or negation), for which the structural approach does not lead to complete subsumption algorithms, tableau algorithms have turned out to be quite 1 The incompleteness is caused by individuals introduced by the one-of constructor; however, the algorithm is complete w.r.t. a non-standard semantics. studia--final-complete.tex; 14/08/2001; 13:30; p.2 3 Tableau Algorithms for Description Logics useful: they are complete and often of optimal (worst-case) complexity. The first such algorithm was proposed by Schmidt-Schauß and Smolka (1991) for a DL that they called (for “attributive concept description language with complements”).2 It quickly turned out that this approach for deciding subsumption can be extended to various other DLs (Hollunder et al., 1990; Hollunder and Baader, 1991; Baader and Hanschke, 1991; Baader, 1991; Hanschke, 1992) and also to other inference problems such as the instance problem (Hollunder, 1990). Early on, DL researchers started to call the algorithms obtained this way “tableau-based algorithms” since they observed that , as well as the original algorithm by Schmidt-Schauß and Smolka for subsequent algorithms for more expressive DLs, could be seen as specialisations of the tableau calculus for first-order predicate logic (the main problem to solve was to find a specialisation that always terminates, and thus yields is a syntactic a decision procedure). After Schild (1991) showed that variant of multi-modal K, it turned out that the algorithm by Schmidt-Schauß and Smolka was actually a re-invention of the known tableau algorithm for K. At the same time, the (worst-case) complexity of various DLs (in particular also DLs that are not propositionally closed) was investigated in detail (Donini et al., 1991a; Donini et al., 1991b; Donini et al., 1992). The first DL systems employing tableau algorithms (K RIS (Baader and Hollunder, 1991) and C RACK (Bresciani et al., 1995)) demonstrated that (in spite of their high worst-case complexity) these algorithms lead to acceptable behaviour in practice (Baader et al., 1994). Highly optimised systems such as FaCT (Horrocks, 1998b), DLP (Patel-Schneider, 1999), and Race (Haarslev and Möller, 1999) have an even better behaviour, also for benchmark problems in modal logics (Horrocks, 1998a; Horrocks and Patel-Schneider, 1999; Haarslev and Möller, 2000a; Horrocks, 2000; Patel-Schneider, 2000). ALC ALC ALC Phase 4: Algorithms and efficient systems for very expressive DLs. Motivated by applications (e.g., in the database area), DL researchers started to investigate DLs whose expressive power goes far beyond the one of (e.g., DLs that do not have the finite model property). First decidability and complexity results for such DLs could be obtained from the connection between propositional dynamic logic (PDL) and DLs (Schild, 1991). The idea of this approach, which was perfected by De Giacomo and Lenzerini, is to translate the DL in question into PDL. If the translation is polynomial and preserves satisfiability, then the known EXPTIME-algorithms for PDL can be employed to decide subsumption in exponential time. Though this approach has produced very strong complexity results (De Giacomo and Lenzerini, ALC 2 Actually, at that time the authors were not aware of the close connection between their rule-based algorithm working on constraint systems and tableau procedures for modal and first-order predicate logics. studia--final-complete.tex; 14/08/2001; 13:30; p.3 4 Franz Baader and Ulrike Sattler 1994; De Giacomo, 1995; De Giacomo and Lenzerini, 1996), it turned out to be less satisfactory from a practical point of view. In fact, first tests in a database application (Horrocks et al., 1999) showed that the PDL formulae obtained by the translation technique could not be handled by existing efficient implementations of satisfiability algorithms for PDL (Patel-Schneider, 1999). To overcome this problem, DL researchers have started to design “practical” tableau algorithms for very expressive DLs (Horrocks and Sattler, 1999; Horrocks et al., 1999).3 The purpose of this article is to give an impression of the work on tableau algorithms done in the DL community, with an emphasis on features that, though they may also occur in modal logics, are of special interest to description logics. After introducing some basic notions of description logics in Secin Section 3. Although, tion 2, we will describe a tableau algorithm for from the modal logic point of view, this is just the well-known algorithm for multi-modal K, this section will introduce the notations and techniques used in description logics, and thus set the stage for extensions to more interesting DLs. In the subsequent three sections we will show how the basic algorithm can be extended to one that treats number restrictions, terminological axioms, and role constructors of different expressiveness, respectively. An overview of reasoning techniques in description logics with more emphasis on complexity results and on results for less expressive DLs can be found in (Donini et al., 1996). Reasoning in very expressive DLs with an emphasis on results obtained via the translation approach is treated in (Calvanese et al., 2001). ALC 2. Description logics: basic definitions The main expressive means of description logics are so-called concept descriptions, which describe sets of individuals or objects. Formally, concept descriptions are inductively defined with the help of a set of concept constructors, starting with a set NC of concept names and a set NR of role names. The available constructors determine the expressive power of the DL in question. In the next two sections, we consider concept descriptions built from the constructors shown in Table I, where C; D stand for concept descriptions, r for a role name, and n for a nonnegative integer. In the description logic , concept descriptions are formed using the constructors negation, conjunction, disjunction, value restriction, and existential restriction. The description logic additionally provides us with (qualified) at-least and at-most number restrictions. ALC ALCQ 3 In contrast to PDL, these DLs allow for transitive roles, but not for the transitive closure operator. studia--final-complete.tex; 14/08/2001; 13:30; p.4 5 Tableau Algorithms for Description Logics Table I. Syntax and semantics of concept descriptions. Constructor negation conjunction disjunction existential restriction value restriction at-least restriction at-most restriction Syntax Semantics :
I n I I\ I u I[ I t 9 f 2
I j 9 : ( ) 2 I ^ 8 f 2
I j 8 : ( ) 2 I ! (> ) f 2
I j #f 2
I j ( ) 2 I ^ (6 ) f 2
I j #f 2
I j ( ) 2 I ^ C C C D C D C D C D r:C x r:C y x y x; y r x; y y r y 2 Ig 2 Ig 2 Ig  g 2 Ig  g C C nr:C x y x; y r y C n nr:C x y x; y r y C n The semantics of concept descriptions is defined in terms of an interpreI ;
I . The domain I of I is a non-empty set of individuals tation I and the interpretation function
I maps each concept name P 2 NC to a set P I  I and each role name r 2 NR to a binary relation rI  I  I . The extension of
I to arbitrary concept descriptions is inductively defined, as shown in the third column of Table I. From the modal logic point of view, roles are simply names for accessibility relations, and existential (value) restrictions correspond to diamonds (boxes) indexed by the respective accessibility relation. Thus, any ALC description can be translated into a multi-modal K formula and vice versa. For example, the description P u 9r:P u 8r::P corresponds to the formula p ^ hr ip ^ r :p, where p is an atomic proposition corresponding to the concept name P . As pointed out by Schild (1991), there is an obvious correspondence between the semantics of ALC and the Kripke semantics for multi-modal K, which satisfies d 2 C I iff the world d satisfies the formula C corresponding to C in the Kripke structure corresponding to I . Number restrictions also have a corresponding construct in modal logics, so-called graded modalities (Van der Hoek and De Rijke, 1995), which are, however, not as well-investigated as the modal logic K. One of the most important inference services of DL systems is computing the subsumption hierarchy of a given finite set of concept descriptions. = (

)


[℄ DEFINITION 1. The concept description D subsumes the concept description C (written C v D ) iff C I  D I for all interpretations I ; C is satisfiable iff there exists an interpretation I such that C I 6 ;; and C and D are equivalent iff C v D and D v C . = studia--final-complete.tex; 14/08/2001; 13:30; p.5 6 Franz Baader and Ulrike Sattler In the presence of negation, subsumption can obviously be reduced to satisfiability: C v D iff C u :D is unsatisfiable.4 Vice versa, satisfiability can be reduced to subsumption: C is satisfiable iff not C v P u :P , where P is an arbitrary concept name. Given concept descriptions that define the important notions of an application domain, one can then describe a concrete situation with the help of the assertional formalism of description logics. DEFINITION 2. Let NI be a set of individual names. An ABox is a finite set of assertions of the form C a (concept assertion) or r a; b (role assertion), where C is a concept description, r a role name, and a; b are individual names. An interpretation I , which additionally assigns elements aI 2 I to individual names a, is a model of an ABox A iff aI 2 C I ( aI ; bI 2 r I ) holds for all assertions C a (r a; b ) in A. The Abox A is consistent iff it has a model. The individual a is an instance of the description C w.r.t. A iff aI 2 C I holds for all models I of A. () ( ) ( () ( ) )
Satisfiability (and thus also subsumption) of concept descriptions as well as the instance problem can be reduced to the consistency problem for ABoxes: (i) C is satisfiable iff the ABox fC a g for some a 2 NI is consistent; and (ii) a is an instance of C w.r.t. A iff A [ f:C a g is inconsistent. Usually, one imposes the unique name assumption on ABoxes, i.e., requires the mapping from individual names to elements of I to be injective. Here, we dispense with this requirement since it has no effect for ALC , and for DLs with number restrictions we will explicitly introduce inequality assertions, which can be used to express the unique name assumption. () ()
3. A tableau algorithm for ALC Given an ALC -concept description C0 , the tableau algorithm for satisfiability tries to construct a finite interpretation I that satisfies C0 , i.e., contains an element x0 such that x0 2 C0I . Before we can describe the algorithm more formally, we need to introduce an appropriate data structure in which to represent (partial descriptions of) finite interpretations. The original paper by Schmidt-Schauß and Smolka (1991), and also many other papers on tableau algorithms for DLs, introduce the new notion of a constraint system for this purpose. However, if we look at the information that must be expressed (namely, the elements of the interpretation, the concept descriptions 4 This was the reason why Schmidt-Schauß and Smolka (1991) introduced a DL with negation in the first place. studia--final-complete.tex; 14/08/2001; 13:30; p.6 Tableau Algorithms for Description Logics 7 they belong to, and their role relationships), we see that ABox assertions are sufficient for this purpose. It will be convenient to assume that all concept descriptions are in negation normal form (NNF), i.e., that negation occurs only directly in front of concept names. Using de Morgan’s rules and the usual rules for quantifiers, any ALC concept description can be transformed (in linear time) into an equivalent description in NNF. ! The u -rule Condition: contains (C1 C2 )(x), but not both C1 (x) and C2 (x). 0 Action: := C1 (x); C2 (x) . ! A u A A[f The t -rule contains (C1 Condition: Action: 0 := C1 (x) , ! A A A[f g t gA C2 )(x) 00 := , but neither C1 (x) nor C2 (x). C2 (x) . A[f g The 9 -rule Condition: contains ( r:C )(x), but there is no individual name z such that C (z ) and r (x; z ) are in . Action: 0 := C (y ); r (x; y ) where y is an individual name not occurring in . ! A A A[f A 9 A g The 8 -rule Condition: contains ( r:C )(x) and r(x; y ), but it does not contain C (y ). Action: 0 := C (y ) . A 8 A A[f g Figure 1. Transformation rules of the satisfiability algorithm for ALC . Let C0 be an ALC -concept in NNF. In order to test satisfiability of C0 , the algorithm starts with A0 := fC0 (x0 )g, and applies consistency preserving transformation rules (see Fig. 1) to this ABox. The transformation rule that handles disjunction is nondeterministic in the sense that a given ABox is transformed into two new ABoxes such that the original ABox is consistent iff one of the new ABoxes is so. For this reason we will consider finite sets of ABoxes S = fA1 ; : : : ; Ak g instead of single ABoxes. Such a set is consistent iff there is some i, 1  i  k , such that Ai is consistent. A rule of Fig. 1 is applied to a given finite set of ABoxes S as follows: it takes an element A of S , and replaces it by one ABox A0 or by two ABoxes A0 and A00. DEFINITION 3. An ABox A is called complete iff none of the transformation rules of Fig. 1 applies to it. The ABox A contains a clash iff fP (x); :P (x)g  A for some individual name x and some concept name P . An ABox is called closed if it contains a clash, and open otherwise. studia--final-complete.tex; 14/08/2001; 13:30; p.7 8 Franz Baader and Ulrike Sattler The satisfiability algorithm for ALC works as follows. It starts with the singleton set of ABoxes ffC0 x0 gg, and applies the rules of Fig. 1 (in arbitrary order) until no more rules apply. It answers “satisfiable” if the set Sb of ABoxes obtained this way contains an open ABox, and “unsatisfiable” otherwise. Correctness of this algorithm is an easy consequence of the following lemma. ( ) LEMMA 1. Let C0 be an ALC -concept in negation normal form. 1. There cannot be an infinite sequence of rule applications ( ) ffC0 x0 gg ! S1 ! S2 !


: 2. Assume that S 0 is obtained from the finite set of ABoxes S by application of a transformation rule. Then S is consistent iff S 0 is consistent. 3. Any closed ABox A is inconsistent. 4. Any complete and open ABox A is consistent. The first part of this lemma (termination) is an easy consequence of the facts that (i) all concept assertions occurring in an ABox in one of the sets Si are of the form C x were C is a sub-description of C0 ; and (ii) if an ABox in Si contains the role assertion r x; y , then the maximal role depth (i.e., nesting of value and existential restrictions) of concept descriptions occurring in concept assertions for y is strictly smaller than the maximal role depth of concept descriptions occurring in concept assertions for x. A detailed proof of termination (using an explicit mapping into a well-founded ordering) for a set of rules extending the one of Fig. 1 can, e.g., be found in (Baader and Hanschke, 1991). The second and third part of the lemma are quite obvious, and the fourth part can be proved by defining the canonical interpretation IA of A: () 1. The domain ( )
A of I IA consists of the individual names occurring in A. := () A := ( ) ( ) 2. For all concept names P we define P IA 3. For all role names r we define r I fx j P x f x; y j r x; y 2 Ag . 2 Ag . By definition, IA satisfies all the role assertions in A. By induction on the structure of concept descriptions, it is easy to show that it satisfies the concept assertions as well, provided that A is complete and open. It is also easy to show that the canonical interpretation has the shape of a finite tree whose depth is linearly bounded by the size of C0 and whose branching factor is bounded by the number of different existential restrictions in C0 . Consequently, ALC has the finite tree model property, i.e., any studia--final-complete.tex; 14/08/2001; 13:30; p.8 Tableau Algorithms for Description Logics 9 satisfiable concept C0 is satisfiable in a finite interpretation I that has the shape of a tree whose root belongs to C0 . To sum up, we have seen that the transformation rules of Fig. 1 reduce satisfiability of an ALC -concept C0 (in NNF) to consistency of a finite set Sb of complete ABoxes. In addition, consistency of Sb can be decided by looking for obvious contradictions (clashes). THEOREM 1. It is decidable whether or not an ALC -concept is satisfiable. 3.1. C OMPLEXITY ISSUES The satisfiability algorithm for ALC presented above may need exponential time and space. In fact, the size of the complete and open ABox (and thus of the canonical interpretation) built by the algorithm may be exponential in the size of the concept description. For example, consider the descriptions Cn (n  1) that are inductively defined as follows: 1 Cn+1 C := := 9 9 r:A r:A u9 u9 r:B ; r:B u8 n r:C : Obviously, the size of Cn grows linearly in n. However, given the input description Cn , the satisfiability algorithm generates a complete and open ABox whose canonical interpretation is a binary tree of depth n, and thus consists of 2n+1 1 individuals. Nevertheless, the algorithm can be modified such that it needs only polynomial space. The main reason is that different branches of the tree model to be generated by the algorithm can be investigated separately, and thus the tree can be built and searched in a depth-first manner. Since the complexity class NPSPACE coincides with PSPACE (Savitch, 1970), it is sufficient to describe a nondeterministic algorithm using only polynomial space, i.e., for the nondeterministic !t -rule, we may simply assume that the algorithm chooses the correct alternative. In principle, the modified algorithm works as follows: it starts with fC0 (x0 )g and 1. applies the !u - and !t -rules as long as possible and checks for clashes; 2. generates all the necessary direct successors of x0 using the !9 -rule and exhaustively applies the !8 -rule to the corresponding role assertions; 3. successively handles the successors in the same way. Since the successors of a given individual can be treated separately, the algorithm needs to store only one path of the tree model to be generated, together with the direct successors of the individuals on this path and the information which of these successors must be investigated next. Since the length of the studia--final-complete.tex; 14/08/2001; 13:30; p.9 10 Franz Baader and Ulrike Sattler path is linear in the size of the input description C0 , and the number of successors is bounded by the number of different existential restrictions in C0 , the necessary information can obviously be stored within polynomial space. This shows that the satisfiability problem for -concept descriptions is in PSPACE. PSPACE-hardness can be shown by a reduction from validity of Quantified Boolean Formulae (Schmidt-Schauß and Smolka, 1991; Halpern and Moses, 1992). ALC THEOREM 2. Satisfiability of lete. 3.2. T HE CONSISTENCY ALC-concept descriptions is PSPACE-comp- PROBLEM FOR ALC -ABOXES The satisfiability algorithm described above can also be used to decide con-ABoxes. Let 0 be an -ABox such that (w.l.o.g.) all sistency of concept descriptions in 0 are in NNF. To test 0 for consistency, we simply apply the rules of Fig. 1 to the singleton set 0 . It is easy to show that Lemma 1 still holds. Indeed, the only point that needs additional consideration is the first one (termination). Thus, the rules of Fig. 1 yield a decision procedure for consistency of -ABoxes. Since now the canonical interpretation obtained from a complete and open ABox need no longer be of tree shape, the argument used to show that the satisfiability problem is in PSPACE cannot directly be applied to the consistency problem. In order to show that the consistency problem is in PSPACE, one can, however, proceed as follows: In a pre-completion step, one applies the transformation rules only to old individuals (i.e., individuals present in the original ABox 0 ). Subsequently, one can forget about the role assertions, i.e., for each individual name in the pre-completed ABox, the satisfiability algorithm is applied to the conjunction of its concept assertions (see (Hollunder, 1996) for details). ALC A A ALC A fA g ALC A THEOREM 3. Consistency of ALC ALC -ABoxes is PSPACE-complete. Since is closed under negation, this also implies that the instance . The consistency and the instance problem is PSPACE-complete in problem for DLs not allowing for negation has been investigated in (Schaerf, 1993; Donini et al., 1994). ALC 4. Number restrictions Before treating the qualified number restrictions introduced in Section 2, we consider a restricted form of number restrictions, which is the form present studia--final-complete.tex; 14/08/2001; 13:30; p.10 11 Tableau Algorithms for Description Logics in most DL systems. In unqualified number restrictions, the qualifying concept is the top concept >, where > is an abbreviation for P t :P , i.e., a concept that is always interpreted by the whole interpretation domain. Instead of (>nr:>) and (6nr:>), we write unqualified number restrictions simply as (>nr ) and (6nr ). The DL that extends ALC by unqualified number restrictions is denoted by ALCN (Hollunder et al., 1990; Donini et al., 1991a). Obviously, ALCN - and ALCQ-concept descriptions can also be transformed into NNF in linear time. 4.1. A TABLEAU ALGORITHM FOR ALCN The main idea underlying the extension of the tableau algorithm for ALC to ALCN is quite simple. At-least restrictions are treated by generating the required role successors as new individuals. At-most restrictions that are currently violated are treated by (nondeterministically) identifying some of the role successors. To avoid running into a generate-identify cycle, we introduce explicit inequality assertions that prohibit the identification of individuals that were introduced to satisfy an at-least restriction. Inequality assertions are of the form x = 6 : y for individual: names x; y, with 6 y iff: xI 6= yI . the obvious semantics that an interpretation I satisfies x = These assertions are assumed to be symmetric, i.e., saying that x 6= y belongs 6 : x belongs to A. to an ABox A is the same as saying that y = The satisfiability algorithm for ALCN is obtained from the one for ALC by adding the rules in Fig. 2, and by considering a second type of clashes: f(6  j g[f ( + 1g  A for nr )(x) n integer n. r x; yi ) j1  1 i x; y ; : : : ; yn g [ f 6= j 1  2 , 2 , and a nonnegative +1 n +1 NI r yi : yj i < NR The nondeterministic ! -rule replaces the ABox A by finitely many new ABoxes Ai;j . Lemma 1 still holds for the extended algorithm (see e.g. (Baader and Sattler, 1999), where this is proved for a more expressive DL). This shows that satisfiability (and thus also subsumption) of ALCN -concept descriptions is decidable. 4.1.1. Complexity issues The ideas that lead to a PSPACE algorithm for ALC can be applied to the extended algorithm as well. The only difference is that, before handling the successors of an individual (introduced by at-least and existential restrictions), one must check for clashes of the second type and generate the necessary identifications. However, this simple extension only leads to a PSPACE algorithm if we assume the numbers in at-least restrictions to be written in base 1 representation (called unary notation in the following). Here, the size studia--final-complete.tex; 14/08/2001; 13:30; p.11 12 Franz Baader and Ulrike Sattler The ! -rule Condition: A contains (>nr)(x), and there are no individual names z1 ; : : : ; zn such that r(x; zi ) (1  i  n) and zi = 6 : zj (1  i < j  n) are in A. Action: A0 := A [ fr(x; yi ) j 1  i  ng [ fyi = 6 : yj j 1  i < j  ng, where y1 ; : : : ; yn are distinct individual names not occurring in A. The ! -rule Condition: A contains distinct individual names y1 ; : : : ; yn+1 such that (6nr )(x) and r (x; y1 ); : : : ; r (x; yn+1 ) are in A, and yi = 6 : yj is not in A for some i; j; 1  i < j  n + 1. Action: For each pair yi ; yj such that 1  i < j  n + 1 and yi = 6 : yj is not in A, the ABox Ai;j := [yi =yj ℄A is obtained from A by replacing each occurrence of yi by yj . Figure 2. The transformation rules handling unqualified number restrictions. of the representation coincides with the number represented. For bases larger than 1 (e.g., numbers in decimal notation), the number represented may be exponential in the size of the representation. Thus, we cannot introduce all the successors required by at-least restrictions while only using space polynomial in the size of the concept description if the numbers in this description are not written in unary notation. It is not hard to see, however, that most of the successors required by the at-least restrictions need not be introduced at all. If an individual x obtains at least one r -successor due to the application of the !9 -rule, then the ! -rule need not be applied to x for the role r . Otherwise, we simply introduce one r -successor as representative. In order to detect inconsistencies due to conflicting number restrictions, we need to add another type of clashes: f(6nr)(x); (>mr)(x)g  A for nonnegative integers n < m. The canonical interpretation obtained by this modified algorithm need not satisfy the at-least restrictions in C0 . However, it can easily be modified to an interpretation that does, by duplicating r -successors (more precisely, the whole subtrees starting at these successors). THEOREM 4. Satisfiability of ALCN -concept descriptions is PSPACE-complete, even if numbers are not represented in unary notation. 4.1.2. The consistency problem for ALCN -ABoxes Just as with ALC , the extended rule set for ALCN can also be applied to arbitrary ABoxes. Unfortunately, the algorithm obtained this way need not terminate, unless one imposes a specific strategy on the order of rule studia--final-complete.tex; 14/08/2001; 13:30; p.12 13 Tableau Algorithms for Description Logics applications. For example, consider the ABox A0 := f ( ) (9 )( ) (61 )( ) (8 9 )( )g By applying the !9 -rule to , we can introduce a new -successor of : A1 := A0 [ f ( ) ( )g The !8 -rule adds the assertion (9 )( ), which triggers an application of the !9 -rule to . Thus, we obtain the new ABox A2 := A1 [ f(9 )( ) ( ) ( )g Since has two -successors in A2 , the ! -rule is applicable to . By r a; a ; r:P a ; r a ; r: a r:P r r a; x ; P x r:P a : x a : x x r:P a x ; r x; y ; P y r : a replacing every occurrence of x by a, we obtain the ABox A3 := A0 [ f g P (a); r (a; y ); P (y ) : Except for the individual names (and the assertion P (a), which is, however, irrelevant), A3 is identical to A1 . For this reason, we can continue as above to obtain an infinite chain of rule applications. We can easily regain termination by requiring that generating rules (i.e., the rules !9 and ! ) may only be applied if none of the other rules is applicable. In the above example, this strategy would prevent the application of the !9 -rule to x in the ABox A1 [ f(9r:P )(x)g since the ! -rule is also applicable. After applying the ! -rule (which replaces x by a), the !9 -rule is no longer applicable since a already has an r -successor that belongs to P . In order to obtain a PSPACE algorithm for consistency of ALCN -ABoxes, the pre-completion technique sketched above for ALC can also be applied to ALCN (Hollunder, 1996). THEOREM 5. Consistency of ALCN -ABoxes is PSPACE-complete, even if numbers are not represented in unary notation. 4.2. A TABLEAU ALGORITHM FOR ALCQ An obvious idea when attempting to extend the satisfiability algorithm for ALCN to one that can handle ALCQ is the following (see (Van der Hoek and De Rijke, 1995)): Instead of simply generating n new r -successors y1 ; : : : ; yn in the ! rule, one also asserts that these individuals must belong to the qualifying concept C of (>nr:C ) by adding the assertions C (yi ) to A0 . The ! -rule only applies to (>nr:C ) if A also contains the assertions C (yi ) (1  i  n + 1). studia--final-complete.tex; 14/08/2001; 13:30; p.13 14 Franz Baader and Ulrike Sattler ! The choose -rule Condition: contains (6nr:C )(x) and r(x; y ), but neither C (y ) nor 0 00 Action: := C (y ) , := C (y ) . A A A[f Figure 3. The gA A [ f: g : C (y ) . !choose-rule for qualified number restrictions. ALCQ Unfortunately, this does not yield a correct algorithm for satisfiability in . In fact, this simple algorithm would not detect that the concept description (>3r ) (61r:P ) (61r: P ) is unsatisfiable. The (obvious) problem is that, for some individual a and concept description C , the ABox may neither contain C (a) nor C (a), whereas in the canonical interpretation constructed from the ABox, one of the two must hold. In order to overcome this problem, the nondeterministic choose -rule of Fig. 3 must be added (Hollunder and Baader, 1991). Together with the choose -rule, the simple modification of the  - and  -rule described above yields a correct algorithm for (Hollunder and Baader, 1991). satisfiability in u ! : u ! ALCQ : ! ! ALC ALCN 4.2.1. Complexity issues The approach that leads to a PSPACE-algorithm for can be applied to as well. However, as with , this yields a the algorithm for PSPACE-algorithm only if the numbers in number restrictions are assumed , the idea that leads to a PSPACEto be written in unary notation. For algorithm for with non-unary notation does no longer work: it is not sufficient to introduce just one successor as representative for the role successors required by at-least restrictions. Nevertheless, it is possible to design a also w.r.t. non-unary notation of numbers (ToPSPACE-algorithm for , this algorithm treats the bies, 1999). Like the PSPACE-algorithm for successors separately. It uses appropriate counters (and a new type of clashes) to check whether qualified number restrictions are satisfied. By combining the pre-completion approach of (Hollunder, 1996) with this algorithm, we -ABoxes. also obtain a PSPACE-result for consistency of ALCQ ALCN ALCQ ALCQ ALCQ ALC ALCQ ALCQ THEOREM 6. Satisfiability of -concept descriptions as well as con-ABoxes are PSPACE-complete problems, even if numbers sistency of are not represented in unary notation. 5. Terminological axioms DL systems usually provide their users also with a terminological formalism. In its simplest form, this formalism can be used to introduce names for studia--final-complete.tex; 14/08/2001; 13:30; p.14 Tableau Algorithms for Description Logics 15 complex concept descriptions. More general terminological formalisms can be used to state connections between complex concept descriptions. DEFINITION 4. A TBox is a finite set of terminological axioms of the form : C = D , where C; D are concept descriptions. The terminological axiom : C = D is called concept definition iff C is a concept name. An interpretation I is a model of the TBox T iff C I = D I holds for all : terminological axioms C = D in T . The concept description D subsumes the concept description C w.r.t. the TBox T (written C vT D ) iff C I  D I for all models I of T ; C is satisfiable w.r.t. T iff there exists a model I of T such that C I 6= ;. The Abox A is consistent w.r.t. T iff it has a model that is also a model of T . The individual a is an instance of C w.r.t. A and T iff aI 2 C I holds for each model I of A and T . In the following, we restrict our attention to terminological reasoning (i.e., the satisfiability and subsumption problem) w.r.t. TBoxes; however, the methods and results also apply to assertional reasoning (i.e., the instance and the consistency problem for ABoxes) (see, e.g., (Buchheit et al., 1993)). 5.1. ACYCLIC TERMINOLOGIES The early DL systems provided TBoxes only for introducing names as abbreviations for complex descriptions. This is possible with the help of acyclic terminologies. DEFINITION 5. A TBox is an acyclic terminology iff it is a set of concept definitions that neither contains multiple definitions nor cyclic definitions. : : Multiple definitions are of the form A = C; A = D for distinct concept : : descriptions C; D , and cyclic definitions are of the form A1 = C1 ; : : : ; An = Cn , where Ai occurs in Ci 1 (1 < i  n) and A1 occurs in Cn . If the acyclic : terminology T contains a concept definition A = C , then A is called defined name and C its defining concept. Reasoning w.r.t. acyclic terminologies can be reduced to reasoning without TBoxes by unfolding the definitions: this is achieved by repeatedly replacing defined names by their defining concepts until no more defined names occur. Unfortunately, unfolding may lead to an exponential blow-up, as the following acyclic terminology (due to Nebel (1990b)) demonstrates: f A0 = 8r:A1 u 8s:A1 ; : : : ; An : 1 = 8r:An u 8s:An g: : This terminology is of size linear in n, but unfolding applied to A0 results in a concept description containing the name An 2n times. Nebel (1990b) also studia--final-complete.tex; 14/08/2001; 13:30; p.15 16 Franz Baader and Ulrike Sattler shows that this complexity can, in general, not be avoided: for the DL F L0 , which allows for conjunction and value restriction only, subsumption between concept descriptions can be tested in polynomial time, whereas subsumption w.r.t. acyclic terminologies is coNP-complete. For more expressive languages, the presence of acyclic TBoxes may or may not increase the complexity of the subsumption problem. For example, subsumption of concept descriptions in the language ALC is PSPACEcomplete, and so is subsumption w.r.t. acyclic terminologies (Lutz, 1999). Of course, in order to obtain a PSPACE-algorithm for subsumption in ALC w.r.t. acyclic terminologies, one cannot first apply unfolding to the concept descriptions to be tested for subsumption since this may need exponential space. The main idea is to use a tableau algorithm like the one described in Section 3, with the difference that it receives concept descriptions containing defined names as input. Unfolding is then done on demand: if the tableau algorithm encounters an assertion of the form A x , where A is a defined name and C its defining concept, then it adds the assertion C x . However, it does not further unfold C at this stage. It can be shown that this really yields a PSPACE-algorithm for satisfiability (and thus also for subsumption) of concepts w.r.t. acyclic terminologies in ALC (Lutz, 1999). () () THEOREM 7. Satisfiability w.r.t. acyclic terminologies is PSPACE-complete in ALC . Although this technique also works for many extensions of ALC (such as and ALC Q), there are extensions for which it fails. One such example is the language ALC F , which extends ALC with functional roles as well as agreements and disagreements on chains of functional roles. More precisely, in ALC F , a set NF  NR of feature names is fixed, and a feature chain u f1


fn is defined to be a non-empty sequence of feature names fi 2 NF . An interpretation I maps each f 2 NF to a functional role I I implies y f , i.e., x; y ; x; z 2 f z . The interpretation of a feature I ! I . For name can thus also be viewed as a partial function f I I I this reason, we will usually write f x y instead of x; y 2 f . The f1


fn is interpreted as the composition of its features, feature chain u I I i.e., uI x fn


f1 x


. The DL ALC F is obtained from ALC by allowing for feature names in value and existential restrictions, and for additional concept descriptions of the form u # v (agreement) and u " v (disagreement), where u; v are feature chains. These new descriptions are interpreted as follows: ALC N = ( )( ) = ( ) := ( ( ( u # v u " v )I = )I = fx 2 fx 2 = ()= :

( ) () )
I
I j j
I with I ( ) = = I ( ) there are 1 2
I with 1 = 2 I( ) = I( ) = 1 and 2 there is a y 2 y ;y u x y u 2 v x y x 6 y v x g y ; y g studia--final-complete.tex; 14/08/2001; 13:30; p.16 Tableau Algorithms for Description Logics 17 The tableau-based satisfiability algorithm for ALC can easily be extended to ALC F (Hollunder and Nutt, 1990). Both agreements and disagreements are handled by rules that generate the feature successors required by the semantics. To ensure that features are interpreted as functional roles in the canonical interpretation, one uses an identification rule (similar to the ! rule): if f (x; y ); f (x; z ) occurs in the ABox, then the rule replaces every occurrence of y by z , unless the ABox also contains an inequality assertion : y = 6 z . This second case leads to a new type of clashes. Inequality assertions are introduced by the rule that handles disagreements: the final individuals reached by the feature chains are explicitly asserted to be distinct. It can easily be seen that this algorithm can again be realised within polynomial space. There is, however, a significant difference between the PSPACEalgorithm for ALC and the one for ALC F . Due to identifications caused by agreements, the canonical interpretation built by the algorithm need no longer have tree shape. For example, an application of the agreement rule to (f1 f2 # g1 g2 )(x) leads to assertions g1 (x; y1 ); g2 (y1 ; z ); f1 (x; y2 ); f2 (y2 ; z ). In particular, this means that the successors y1 and y2 of x cannot be handled independently since they lead to a common successor. However, this problem is restricted to individuals connected by feature chains. It is easy to show that each such feature-connected component is polynomial in the size of the concept description to be tested for satisfiability (if identification of feature successors is done eagerly). Thus, it is unproblematic to generate the whole feature-connected component issuing from a given individual. In the presence of acyclic terminologies, this is no longer true. In fact, by : using a sequence of terminological axioms of the form Cn+1 = 9f :Cn u 9g:Cn , one can enforce feature-connected components of size exponential in the size of the given terminology and concept description. In (Lutz, 1999), this fact is used to show that satisfiability of ALC F -concept descriptions w.r.t. acyclic terminologies is NEXPTIME-complete. THEOREM 8. Satisfiability of ALC F -concept descriptions is PSPACE-complete, but satisfiability w.r.t. acyclic terminologies is NEXPTIME-complete in ALC F . 5.2. G ENERAL TB OXES : For general terminological axioms of the form C = D , where C may also be a complex description, unfolding is obviously no longer possible. Instead : : of considering finitely many such axioms C1 = D1 ; : : : ; Cn = Dn , it is : sufficient to consider the single axiom Cb = >, where b C := (:C1 1 ) u (C1 t :D1 ) u


u (:Cn t Dn ) u (Cn t :Dn ) tD and > is an abbreviation for P t :P . studia--final-complete.tex; 14/08/2001; 13:30; p.17 18 Franz Baader and Ulrike Sattler = The axiom Cb > just says that any individual must belong to the concept b C . The tableau algorithm for ALC introduced in Section 3 can easily be modified such that it takes this axiom into account: all individuals are simply asserted to belong to Cb . However, this modification may obviously lead to nontermination of the algorithm. For example, consider what happens if this algorithm is applied to test consistency of the ABox A0 f 9r:P x0 g w.r.t. the axiom 9r:P : >: the algorithm generates an infinite sequence of ABoxes A1 ; A2 ; : : : and individuals x1 ; x2 ; : : : such that Ai+1 Ai [fr xi; xi+1 ; P xi+1 ; 9r:P xi+1 g. Since all individuals xi (i  ) receive the same concept assertions as x1 , we may say that the algorithm has run into a cycle. Termination can be regained by using a mechanism that detects cyclic computations, and then blocking the application of generating rules: the application of the rule !9 to an individual x is blocked by an individual y in an ABox A iff fD j D x 2 Ag  fD 0 j D 0 y 2 Ag. The main idea underlying blocking is that the blocked individual x can use the role successors of y instead of generating new ones. For example, instead of generating a new r successor for x2 in the above example, one can simply use the r -successor of I x1 . This yields an interpretation I with fx0 ; x1 ; x2 g, P I fx1 ; x2 g, I f x0 ; x1 ; : x1; x2 ; x2 ; x2 g. Obviously, I is a model of both A0 and r and the axiom 9r:P >. Since the set of concepts asserted for the blocked individual is a subset of the set of those asserted for the blocking individual, we call this blocking condition subset blocking. To avoid cyclic blocking (of x by y and vice versa), we consider an enumeration of all individual names, and define that an individual x may only be blocked by individuals y that occur before x in this enumeration. This, together with some other technical assumptions, makes sure that a tableau algorithm using this notion of blocking is sound and complete as well as terminating both for ALC and ALCN (see (Buchheit et al., 1993; Baader et al., 1996) for details). In the algorithm we have just described, we do not impose any order or strategy on the application of the transformation rules. This leads to what is called dynamic blocking (Horrocks and Sattler, 1999), where blocks can be established and then broken. For example, suppose an individual x is blocked by an individual y . Then, the application of the !8 -rule to x’s predecessor may add C x to A. If C y is not present in A, then x is no longer blocked by y . However, using a strategy that (basically) applies generating rules only if no non-generating ones can be applied, blocks that are established once will never be broken again. Thus, when employing this strategy, we can block statically. Note that implementations of tableau-based algorithms usually employ this strategy anyway. It should be noted that the algorithm we have described above is no longer in PSPACE since it may generate role paths of exponential length before : := ( := 1 )( ) ( ) ( () := ( )( () )( = () = )( ) )( )
:= := () studia--final-complete.tex; 14/08/2001; 13:30; p.18 19 Tableau Algorithms for Description Logics Table II. Syntax and semantics of role constructors and restrictions. Constructor/Restriction intersection union complement composition transitive closure inverse transitive roles role hierarchy Syntax r u s r u s :r r Æs R + R + R 2 N R r Semantics I r I \ sI r u s I r I [ sI r t s I I n rI :r I f x; z j there is a y such that I I x; y 2 r and y; z 2 s g ( ) = ( ) = ( ) =
( Æ ) = ( ) ( ) ( ) + )I = ( I )+ ( ( )I = f( ) j ( ) 2 r s R R vs R y; x x; y I R is transitive I  sI r R Ig blocking occurs. In fact, even for the language ALC , satisfiability w.r.t. general terminological axioms is known to be EXPTIME-complete (Schild, 1994). The tableau-based algorithm sketched above is a NEXPTIME algorithm. However, using the translation technique mentioned in the introduction, it can be shown (De Giacomo and Lenzerini, 1994) that ALCN -ABoxes and TBoxes can be translated into PDL. THEOREM 9. Consistency of ALCN -ABoxes w.r.t. TBoxes is EXPTIMEcomplete. Blocking does not work for all extensions of ALC that have a tableau-based satisfiability algorithm. An example is again the DL ALCF , for which satisfiability is decidable, but satisfiability w.r.t. general TBoxes undecidable (Nebel, 1991; Baader et al., 1993). 6. Expressive roles The DLs considered so far allowed for atomic roles only. There are two ways of extending the expressivity of DLs w.r.t. roles: adding role constructors and constraining the interpretation of roles. An overview of the syntax and semantics of both are given in Table II, where the first part refers to role constructors and the second to role constraints. Role constructors can be used to build complex roles from atomic ones. In the following, we will mostly restrict our attention to the inverse constructor, which makes it possible to “use a role in both directions”. For example, using inverse roles, we can describe both parents of nice children by 8has hild:Ni e as well as children of nice parents by 8has hild :Ni e. The other role constructors have also been considered in the literature (e.g., Boolean operators in (De Giacomo, 1995; Lutz and Sattler, 2000), and composition, union, and transitive closure in (Baader, 1991; Schild, 1991)). studia--final-complete.tex; 14/08/2001; 13:30; p.19 20 Franz Baader and Ulrike Sattler Constraining the interpretation of roles is very similar to imposing frame conditions in modal logics. One possible such constraint has already been mentioned in the previous section: in ALCF the interpretation of roles f 2 NF  NR is required to be functional. Here, we will consider transitive roles and role hierarchies. In a DL with transitive roles, a subset NR+ of the set of all role names NR is fixed (Sattler, 1996). Elements of NR+ must be interpreted by transitive binary relations. (This corresponds to the frame condition for the modal logic K4.) A role hierarchy is given by a finite set of role inclusion axioms of the form r v s for roles r; s. An interpretation I satisfies the role hierarchy H iff r I  sI holds for each r v s 2 H. For example, we can use the role inclusion axiom has son v has hild to express that every son of a person is also her child. 6.1. E XPRESSIVE ROLES IN NUMBER RESTRICTIONS In DLs with expressive roles and number restrictions, the roles that are allowed to occur in the number restrictions are usually of a restricted form (see, e.g., (De Giacomo and Lenzerini, 1994; De Giacomo and Lenzerini, 1996; Horrocks et al., 1999; Haarslev and Möller, 2000b)). Whereas tableaubased algorithms that respectively handle number restrictions on conjunctions of roles (Donini et al., 1991a), on compositions of roles (Baader and Sattler, 1999), on inverse roles (see Section 6.2.3), and on roles occurring in a role hierarchy (Horrocks and Sattler, 1999; Haarslev and Möller, 2000b) are known from the literature, other role constructors and restrictions appear to be more problematic when used within number restrictions. Let us illustrate this with two examples. First, transitive closure of roles, transitive roles, or roles having a transitive sub-role (with respect to a role hierarchy) are usually not allowed inside number restrictions. In fact, a tableaubased algorithm for a DL containing such number restrictions would need to differ significantly from the algorithms we have described until now. Intuitively, this is due to the fact that transitivity (in one of the forms mentioned above) can yield situations where, for a transitive role r , a long r -path starting at an individual x would need to be collapsed into a single r -successor of x, due to the presence of an assertion ( 1r )(x). This destroys the tree shape of the canonical interpretation to be generated, which (for example) means that the usual arguments for showing termination can no longer be applied. At least in the case where roles having transitive sub-roles are allowed to occur in number restrictions, these problems cannot be overcome: the extension of ALCN that allows roles having transitive sub-roles to occur in number restrictions has an undecidable subsumption problem (Horrocks et al., 1999). Second, the combination of role composition with Boolean role constructors and inverse roles in number restrictions usually causes undecidability. In (Baader and Sattler, 1999), the tableau-based algorithm for ALCN is first studia--final-complete.tex; 14/08/2001; 13:30; p.20 Tableau Algorithms for Description Logics 21 extended to composition of roles in number restrictions, and then to union and intersection of role compositions of the same length. It is also shown that most of the other combinations lead to an undecidable DL. 6.2. ROLE HIERARCHIES , INVERSE ROLES , AND TRANSITIVE ROLES Before considering different extensions of ALC and ALCN by these role constructors, a general remark is in order. For most of the DLs considered in this subsection, satisfiability and subsumption of concept descriptions are EXPTIME-complete problems. The reason for these DLs to be EXPTIMEhard is that they can simulate general TBoxes within concept descriptions (see below). The fact that they are in EXPTIME follows from results for PDL and converse-PDL (Pratt, 1979; Harel, 1984). The tableau-based algorithms that will be sketched below are NEXPTIME-algorithms. The point in designing these algorithms was not to prove worst-case complexity results, but rather to obtain “practical” algorithms, i.e., algorithms that are easy to implement and optimise, and which behave well on realistic knowledge bases. Nevertheless, the fact that “natural” tableau algorithms for such EXPTIMEcomplete logics are usually NEXPTIME-algorithms is an unpleasant phenomenon. In contrast, automata-based algorithms (Vardi and Wolper, 1986) often yield optimal worst-case complexity results, but do not behave well in practice (since they are also best-case exponential). Attempts to design EXPTIME-tableaux for such logics (De Giacomo et al., 1996; De Giacomo and Massacci, 1996; Donini and Massacci, 1999) usually lead to rather complicated (and thus not easy to implement) algorithms, which (to the best of our knowledge) have not been implemented yet. 6.2.1. DLs with transitive roles and role hierarchies In the DL SH, i.e., the extension of ALC with transitive roles and role hierarchies, reasoning w.r.t. (general) TBoxes can be reduced to reasoning without TBoxes using a standard technique from modal logics, which is called internalisation in the DL literature (Schild, 1991; Baader et al., 1993). As mentioned in Section 5.2, we may assume that TBoxes consist of a single : axiom of the form Cb = >. Internalisation of this axiom introduces a new transitive role u, and asserts in the role hierarchy that u is a super-role of all roles occurring in Cb and the concept description C0 to be tested for satisfia: bility. Then, C0 is satisfiable w.r.t. fCb = >g iff C0 u Cb u 8u:Cb is satisfiable with respect to the role hierarchy. With respect to expressive power, this is a nice property of SH. However, it also shows that satisfiability and subsumption of concept descriptions in SH is EXPTIME-hard.5 The tableau algorithm for SH presented in (Horrocks, 1998b) handles role hierarchies by an appropriate definition of 5 More precisely, reasoning in SH is EXPTIME-complete (Horrocks et al., 2000a). studia--final-complete.tex; 14/08/2001; 13:30; p.21 22 Franz Baader and Ulrike Sattler A 2A 2A ! ! A 8 8 2A r -successors: an individual y is called an r -successor of an individual x in iff s(x; y ) for some sub-role s of r . Then, the condition an ABox r (x; y ) in the 9 - and the 8 -rule is replaced by the condition “if y is an r -successor of x in ”. Transitive roles are taken care of by a new rule, the + 8 -rule, which, basically, adds ( r:C )(y) to iff y is an r-successor and r is a transitive sub-role of s. (Note that of x such that ( s:C )(x) this corresponds to the treatment of K4-modalities in tableau algorithms from modal logics (Halpern and Moses, 1992).) Obviously, this shifting of value restrictions along transitive roles makes for a non-terminating algorithm, unless one employs an appropriate blocking technique. The blocking strategy used in (Horrocks, 1998b) coincides with the one we have presented in Section 5.2, i.e., subset-blocking. ! SH A SHI 6.2.2. DLs with transitive and inverse roles, and role hierarchies with inverse roles is called . In this DL, TBoxes The extension of . can be internalised in a way similar to the one we have described for The only difference is that now u is not only specified as a (transitive) superrole of all roles occurring in the input concept and the TBox, but also of the inverses of these roles (Horrocks and Sattler, 1999). is obtained In (Horrocks and Sattler, 1999), a tableau algorithm for sketched above by extending the notion of r -successors from the one for to r -neighbours, and modifying the transformation rules accordingly. Modulo some technical details, an individual y is called an r -neighbour of an individual x in iff s(x; y ) or s (y; x) for some sub-role s of r . Obviously, using r -neighbours instead of r -successors in the new 8 rule implies that the rule can now be applied in both direction. For example, if r (x; y ); ( r:C )(y ) , then the rule adds C (x). The main technical problem is to find an appropriate blocking condition, i.e., a condition that still ensures termination, but does not compromise correctness of the algorithm. The blocking strategy introduced in (Horrocks and Sattler, 1999) differs in . two points from blocking for First, one can no longer use subset blocking as described in Section 5.2. Consider the example shown in Fig. 4 (where, for the sake of legibility, not all concepts necessary for generating this situation are explicitly given). If subset blocking is used, then y is blocked by x. However, when building the canonical interpretation , the r -successor x1 of x is used to satisfy ( r:A)(y ), i.e., (y; x1 ) r I . This violates the value restriction for x1 , which shows that the interpretation obtained this way is not a model of the complete and open ABox. This problem can be overcome by using equality blocking, i.e., an = D0 individual y is blocked by an individual x iff D D (x) 0 D (y ) . Second, blocking is now dynamic, even if rules are applied according to the strategy that applies non-generating rules with higher priority. This is SHI SH A 2A 8 SH 2A ! 2A SH 2 2 Ag I 9 f j 2 Ag f j studia--final-complete.tex; 14/08/2001; 13:30; p.22 23 Tableau Algorithms for Description Logics (8s x :A)(x); r A(x1 ); x1 r x2 (8r (9r:A)(x); : : : 8s : :A)(x1 ); : : : (:A)(x2 ); : : : s y (9r:A)(y ) Figure 4. A situation where subset blocking fails for SHI . ! due to the fact that the 8 -rule can be applied back and forth on a chain of individuals. Alternatively to the approach described until now, which goes back and forth in the interpretation to be generated, one could have chosen to guess (nondeterministically) all those assertions C (x) that could be propagated “back” from an r -successor y of x due to value restrictions ( r :C )(y ). In the case of a wrong guess, one has a new type of clashes. The analytic cut rule in (De Giacomo and Massacci, 1996) does this for a well-chosen, relatively small set of sub-descriptions of the input description. In this setting, blocking would again become static. However, in an actual implementation (and its extensions it is preferable to avoid this “blind” guessing. For treated in the following subsections), avoiding this source of nondeterminism is indeed possible. This does not appear to be the case for the extension of with transitive closure and inverse of roles. This DL is closely related to converse-PDL, for which a tableau algorithm is presented in (De Giacomo and Massacci, 1996) using the analytic cut rule. (In Section 6.2.4, we will comment in more detail on tableau algorithms for DLs with transitive closure of roles.) , we obtain the logic . ObBy dropping role hierarchies from viously, the internalisation of TBoxes sketched above does no longer work since we cannot specify super-roles of roles. It can be shown that is or . Using a rather sophisticated blocking indeed less complex than technique, a tableau algorithm can be designed that decides satisfiability of concept descriptions in using space polynomial in the size of the input description (Spaan, 1993; Horrocks et al., 1999). This implies that satisfiability of concept descriptions in is PSPACE-complete, i.e., of the same . worst-case complexity as 8 SHI ALC SHI SH SHI SI SI ALC SI SI studia--final-complete.tex; 14/08/2001; 13:30; p.23 24 Franz Baader and Ulrike Sattler 6.2.3. DLs with transitive and inverse roles, role hierarchies, and number restrictions Things become even more complicated for the DL SHIN , which extends SHI with unqualified number restrictions on simple roles. A role r is called simple iff r is an atomic role or its inverse such that r does not have a transitive sub-role (Horrocks and Sattler, 1999). In contrast to SHI , the DL SHIN no longer has the finite model property. For example, if the role hierarchy contains the axiom s v r for a transitive role r 2 NR+ , then the following concept is obviously satisfiable, but each of its models has an infinite s-path: :A u9s:A u8r:(9s:A u (61s )): Thus, instead of directly trying to construct a (possibly infinite) interpretation that satisfies C0 , the tableau algorithm for SHIN introduced in (Horrocks and Sattler, 1999; Horrocks et al., 1999) first tries to construct a so-called pre-model, i.e., a structure that can be “unravelled” to a (possibly infinite) canonical (tree) interpretation. In principle, this algorithm is obtained by extending the algorithm for SHI with the rules that handle number restrictions. The main technical problem to be solved is again to design the appropriate blocking condition. Unravelling is also known in modal logic (see, for example, (Stirling, 1992)), and works as follows. To construct a model from a pre-model, we define elements of the model’s domain to be paths in the pre-model that follow edges r (x; y ) where, instead of going to a blocked individual, the path goes to its blocking individual. Thus, if blocking occurs, we may obtain an infinite model (e.g., if the blocking individual is a predecessor of the blocked individual)—even though the input concept might have a finite one. Before describing the blocking condition introduced in (Horrocks and Sattler, 1999; Horrocks et al., 1999), let us point out a new phenomenon that can occur when running the tableau algorithm for SHIN . Due to the interaction of role hierarchies and number restrictions, the algorithm can generate an ABox A with fr (x; y ); s(x; y )g  A where r; s are not subroles of each other. This situation can be caused by an assertion (61t)(x), where t is a common super-role of r and s, and x already has an r - and an s-successor. These two successors are then merged into the single successor y . Note, however, that each individual generated by the algorithm still has a unique predecessor, though it may be related with more than one role to this predecessor. The new blocking condition for SHIN is called pair-wise blocking. It extends the one for SHI as follows. In order for an individual y to be blocked by an individual x, the predecessors of x and y must also have identical assertion attached to them, and x and y must be related by the same roles to their respective predecessors. More precisely, assume that x; y are individuals in A that respectively have the predecessors x0 ; y 0 in A. For y to be blocked by x, the following conditions must be satisfied: (i) for each role r , x is an studia--final-complete.tex; 14/08/2001; 13:30; p.24 25 Tableau Algorithms for Description Logics C0 (x); x : ( A)(x); s y z 1 D (y ); A(y ); ( D (z ); A(z ); ( s 9 ( 1 s:D )(x); 8 9 ( s:D )(x) r: 9 : A)(y ); ( 9 : A)(z ); ( s )(y ); ( s )(z ); ( s : s : 9 s:D )(y ); ( 8 9 9 s:D )(z ); ( s:D )(y ) r: 8 9 r: s:D )(z ) Figure 5. A situation where pair-wise blocking is crucial. is an r -successor of y 0 ; (ii) fD j D (x) 2 Ag = fD0 j D0(y) 2 Ag; and (iii) fD j D(x0) 2 Ag = fD0 j D0(y0 ) 2 Ag. The following example should give a better intuition for why this complex blocking condition is needed. In Fig. 5, we show relevant parts of an ABox that was generated to decide the satisfiability of the concept C0 , where r -successor of 0 iff x y C0 := : u (9 A s:D ) u (8 9 r: s:D ); is a sub-role of the transitive role r , and D := A u (61s ) u (9s ::A). Using equality blocking, z would be blocked by y . When constructing the canonical interpretation, we cannot re-use y ’s s-successor as z ’s successor: this would make z an s-successor of itself, and thus z would have itself and y as s -successors, contradicting the assertion (61s )(z ). Thus, unravelling is really necessary in this example. As explained above, unravelling the ABox to an interpretation would generate as elements of the interpretation the path [x℄ (corresponding to x), the path [x; y ℄ (corresponding to y ), the path [x; y; y ℄ (which is used instead of the blocked individual z ), the path [x; y; y; y ℄ etc. However, in this interpretation the element [x; y; y ℄ and its successors do not belong to the concept description 9s ::A, which shows that this interpretation does not satisfy C0 . With respect to pair-wise blocking, z is not blocked by y since the predecessor x of y has a concept assertion (:A)(x) that the predecessor y of z does not have. Hence the tableau algorithm generates an ssuccessor to satisfy (9s:D )(z ) and an s -successor to satisfy (9s ::A)(z ). It should be noted that the problems that lead to the need for pair-wise blocking do not depend on the presence of “large” numbers in number restrictions. In fact, the above example used only functional restrictions, i.e., number restrictions of the form ( 1 r ). The tableau-based satisfiability algorithm for SHIN described until now can also be extended to decide the consistency of ABoxes (Horrocks et al., 2000b). Recall that, for ALCN , the naive extension of the satisfiability algorithm to a consistency algorithm ran into termination problems. This problem can be overcome by applying the pre-completion technique, which reduces ABox consistency to satisfiability of concept descriptions (see Section 4.1.2). Pre-completion does not work for SHIN due to the presence of inverse roles. For example, the inconsistency of the ABox fr (x; y ); A(x) s studia--final-complete.tex; 14/08/2001; 13:30; p.25 26 Franz Baader and Ulrike Sattler (9s:8s :8r ::A)(y )g cannot be detected if, after the application of nongenerating rules only, x and y are treated in unrelated ABoxes. However, the termination problem pointed out for ALCN is not relevant for SHIN since the algorithm employs blocking to ensure termination. Basically, the only difference between the satisfiability and the consistency algorithm for SHIN is that one must be a bit more careful when the block involves old individuals, i.e., individuals present in the input ABox. 6.2.4. DLs with the transitive closure of roles Finally, let us briefly comment on the difference between transitive roles and transitive closure of roles. The transitive closure of roles is more expressive, but it appears that one has to pay dearly for this. In fact, whereas there exist quite efficient implementations for very expressive DLs with transitive roles, inverse roles, and role hierarchies (see above), no such implementations are known (to us) for closely related logics with transitive closure, such as converse-PDL (which is a notational variant of the extension of ALC by transitive closure, union, composition, and inverse of roles (Schild, 1991)). One reason could be that the known tableau algorithm for converse-PDL (De Giacomo and Massacci, 1996) requires an analytic cut rule (see Section 6.2.2), which is massively nondeterministic, and thus very hard to implement efficiently. Another problem with transitive closure is that a blocked individual need no longer indicate “success”, as is the case in DLs with transitive roles. In the presence of transitive closure, when blocking occurs, one must check whether this block is due to a harmless, cyclic repetition of the same assertions (as is always the case for SHIN ), or whether the block is caused by the repeated unsuccessful attempt to satisfy an assertion of the form (9r + :C )(x), where C is unsatisfiable or in conflict with an assertion (8r + :D )(x). The former case is called a “good” cycle and the latter a “bad” cycle in (Baader, 1991). To satisfy an assertion of the form (9r + :C )(x) (often called “eventuality” in the modal or temporal logic literature), one has two possibilities: (i) satisfy it now, i.e., generate an r -successor that belongs to C ; or (ii) defer it till later on, i.e., generate an r -successor that belongs to 9r + :C . However, one must ensure that the (9r + :C )(x) is satisfied eventually, i.e., one does not always choose the second alternative. To ensure termination, the algorithm in (Baader, 1991) basically uses equality blocking, together with a rather strict strategy on the application of rules. A block (called cycle in (Baader, 1991)) can now indicate two things: either it is good, which corresponds to the situation encountered in logics like SHIN , or it is bad, which corresponds to infinitely deferring to satisfy an eventuality. Since good cycles can be distinguished from bad cycles, the algorithm can stop with success in the first case, and it must backtrack in the second. Note that the algorithm in (Baader, 1991) is very similar to the satisfiability algorithm for DPDL sketched in Section 5.3 of studia--final-complete.tex; 14/08/2001; 13:30; p.26 27 Tableau Algorithms for Description Logics (Ben-Ari et al., 1982). The main difference is that Ben-Ari et al. (1982) first treat all cycles as good, but then detect bad cycles by checking whether the generated interpretation really satisfies the input formula. Automata-based methods (Vardi and Wolper, 1986) elegantly treat the problems caused by eventualities by employing appropriate acceptance conditions (e.g., Büchi acceptance). However, as mentioned above, a direct implementation of these methods is also best-case exponential. To the best of our knowledge, there is no efficient implementation of these methods, and we conjecture that an attempt to optimise them would lead to an algorithm that is very similar to a tableau algorithm. 7. Conclusion Though many of the tableau-based algorithms sketched in this paper are of optimal worst-case complexity, and thus provide complexity results for subsumption and satisfiability in DLs, theoretical complexity results never were the main focus of this line of DL research. The design of these algorithms was strongly motivated by the goal to obtain practical algorithms, i.e., algorithms that are easy to implement and optimise, and which behave well on realistic knowledge bases. In particular, for the logics treated in Section 6.2, the exact worst-case complexity (EXPTIME) was known before the (NEXPTIME) tableau algorithms sketched above were designed. The claim that these algorithms really are “practical” must still be supported by more empirical evaluations, but the first results are rather encouraging (see below). The notion of what is thought to be a practical subsumption algorithm in description logics has gone through a remarkable evolution in the last 15 years. Throughout the eighties and up to the early nineties, anything nonpolynomial was deemed to be impractical. Consequently, when the first complexity results showed that all of the DLs used in systems had subsumption problems of a higher complexity, the proposed solution was either to restrict the expressive power or to employ incomplete algorithms. The first tableau algorithms for more expressive DLs (with PSPACE-complete subsumption problems) were widely considered to be of (complexity) theoretic interest only, though not by their designers. In fact, it turned out that implementations of these algorithms were amenable to optimisation techniques and behaved quite well in practice (Baader et al., 1994; Bresciani et al., 1995). Following this lead, Ian Horrocks implemented the first system, FaCT, based on an EXPTIME-complete DL. The satisfiability algorithm of FaCT is sketched a highly optimised implementation of the tableau algorithm for above. FaCT was originally designed to represent medical terminology (where the whole expressive power of is needed), and it has behaved very well on the large medical knowledge base it was designed for (Horrocks, 1998b). SH SH studia--final-complete.tex; 14/08/2001; 13:30; p.27 28 Franz Baader and Ulrike Sattler In addition, FaCT performed equally well on randomly generated benchmarks for formulae in (PSPACE) modal logics designed for system comparisons (Horrocks, 1998a; Patel-Schneider and Horrocks, 1999; Horrocks, 2000). These formulae do not use the whole expressive power of SH, but to the best of our knowledge there are no benchmark formulae available for EXPTIME-complete logics. Encouraged by these experiences, other DL systems were designed that use (optimised) implementations of the tableau algorithms described in Section 6.2, and they also proved to behave quite well, both in realistic applications, and on the available (PSPACE) benchmarks (Horrocks and Patel-Schneider, 1999; Haarslev and Möller, 2000b; Horrocks et al., 2000a). This shows that, at the beginning of the new millennium, even an EXPTIME-algorithm is no longer automatically considered to be impractical in the DL community. Databases have turned out to be a very interesting application area for DLs, which needs the expressive power offered by logics such as SHIN . Indeed, such expressive DLs can be viewed as a unifying formalism for classbased representation systems such as object-oriented or frame-based systems, and they capture the semantics of conceptual modelling formalisms such as Entity-Relationship diagrams (Calvanese et al., 1999b). DL systems can be used to support the design and evolution of database schemata or to optimise queries (Calvanese et al., 1998a; Calvanese et al., 1998c); to support the integration of sources in heterogeneous databases/data warehouses (Calvanese et al., 1998b; Calvanese et al., 1999a); and to support the conceptual modelling of multidimensional aggregation (Franconi and Sattler, 1999). A first tool that provides an interface for the above mentioned database applications is i om (Franconi and Ng, 2000). Its graphical user interface supports the design of conceptual models using enhanced Entity-Relationship diagrams. The underlying inference engine is the new version of the DL system FaCT which implements SHIQ, i.e., the extension of SHIN with qualified number restrictions. Once the user has finished a modelling step, she can ask the system to translate the conceptual model into a SHIQ knowledge base. This knowledge base is then given to FaCT, which checks for implicit IS-A (i.e., subsumption) relationships between entities/relations and tests entities/relations for inconsistencies. In case of an inconsistency or an unexpected IS-A link, the user can then modify her conceptual model appropriately. References Baader, F.: 1991, ‘Augmenting Concept Languages by Transitive Closure of Roles: An Alternative to Terminological Cycles’. In: Proc. of the 12th Int. Joint Conf. on Artificial Intelligence (IJCAI-91). A long version appeared as DFKI-Research-Report RR-90-13, Kaiserslautern, Germany. studia--final-complete.tex; 14/08/2001; 13:30; p.28 Tableau Algorithms for Description Logics 29 Baader, F., M. Buchheit, and B. Hollunder: 1996, ‘Cardinality Restrictions on Concepts’. Artificial Intelligence Journal 88(1–2), 195–213. Baader, F., H.-J. Bürckert, B. Nebel, W. Nutt, and G. Smolka: 1993, ‘On the Expressivity of Feature Logics with Negation, Functional Uncertainty, and Sort Equations’. Journal of Logic, Language and Information 2, 1–18. Baader, F., E. Franconi, B. Hollunder, B. Nebel, and H. Profitlich: 1994, ‘An Empirical Analysis of Optimization Techniques for Terminological Representation Systems or: Making KRIS get a move on’. Applied Artificial Intelligence. Special Issue on Knowledge Base Management 4, 109–132. Baader, F. and P. Hanschke: 1991, ‘A Schema for Integrating Concrete Domains into Concept Languages’. Technical Report RR-91-10, Deutsches Forschungszentrum für Künstliche Intelligenz (DFKI), Kaiserslautern, Germany. An abridged version appeared in Proc. of the 12th Int. Joint Conf. on Artificial Intelligence (IJCAI-91). Baader, F. and B. Hollunder: 1991, ‘A Terminological Knowledge Representation System with Complete Inference Algorithm’. In: Proc. of PDK’91, Vol. 567 of Lecture Notes In Artificial Intelligence. pp. 67–86, Springer-Verlag. Baader, F. and U. Sattler: 1999, ‘Expressive Number Restrictions in Description Logics’. Journal of Logic and Computation 9(3), 319–350. Baader, F. and U. Sattler: 2000, ‘Tableau Algorithms for Description Logics’. In: R. Dyckhoff (ed.): Proc. of the Int. Conf. on Automated Reasoning with Tableaux and Related Methods (Tableaux 2000), Vol. 1847 of Lecture Notes in Artificial Intelligence. pp. 1–18, SpringerVerlag. Ben-Ari, M., J. Y. Halpern, and A. Pnueli: 1982, ‘Deterministic Propositional Dynamic Logic: Finite Models, Complexity, and Completeness’. Journal of Computer and System Science 25, 402–417. Borgida, A. and P. F. Patel-Schneider: 1994, ‘A Semantics and Complete Algorithm for Subsumption in the CLASSIC Description Logic’. Journal of Artificial Intelligence Research 1, 277–308. Brachman, R. J.: 1992, ‘“Reducing” CLASSIC to Practice: Knowledge Representation Meets Reality’. In: Proc. of the 3rd Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-92). pp. 247–258, Morgan Kaufmann. Brachman, R. J. and H. J. Levesque: 1984, ‘The Tractability of Subsumption in Frame-Based Description Languages’. In: Proc. of the 4th Nat. Conf. on Artificial Intelligence (AAAI84), pp. 34–37, AAAI Press. Brachman, R. J. and H. J. Levesque (eds.): 1985, Readings in Knowledge Representation. Morgan Kaufmann. Brachman, R. J. and J. G. Schmolze: 1985, ‘An Overview of the KL-ONE Knowledge Representation System’. Cognitive Science 9(2), 171–216. Bresciani, P., E. Franconi, and S. Tessaris: 1995, ‘Implementing and Testing Expressive Description Logics: Preliminary Report’. In: A. Borgida, M. Lenzerini, D. Nardi, and B. Nebel (eds.): Working Notes of the 1995 Description Logics Workshop. pp. 131–139. Buchheit, M., F. M. Donini, and A. Schaerf: 1993, ‘Decidable Reasoning in Terminological Knowledge Representation Systems’. Journal of Artificial Intelligence Research 1, 109– 138. Calvanese, D., G. De Giacomo, and M. Lenzerini: 1998a, ‘On the Decidability of Query Containment under Constraints’. In: Proc. of the Seventeenth ACM SIGACT SIGMOD Sym. on Principles of Database Systems (PODS-98). pp. 149–158. Calvanese, D., G. De Giacomo, M. Lenzerini, D. Nardi, and R. Rosati: 1998b, ‘Description Logic Framework for Information Integration’. In: Proc. of the 6th Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-98). pp. 2–13, Morgan Kaufmann. studia--final-complete.tex; 14/08/2001; 13:30; p.29 30 Franz Baader and Ulrike Sattler Calvanese, D., G. De Giacomo, and R. Rosati: 1999a, ‘Data Integration and Reconciliation in Data Warehousing: Conceptual Modeling and Reasoning Support’. Network and Information Systems 4(2). Calvanese, D., G. D. Giacomo, M. Lenzerini, and D. Nardi: 2001, ‘Reasoning in Expressive Description Logics’. In: A. Robinson and A. Voronkov (eds.): Handbook of Automated Reasoning. Amsterdam, NL: Elsevier Science Publishers. Calvanese, D., M. Lenzerini, and D. Nardi: 1998c, ‘Description Logics for Conceptual Data Modeling’. In: J. Chomicki and G. Saake (eds.): Logics for Databases and Information Systems. Kluwer Academic Publisher, pp. 229–264. Calvanese, D., M. Lenzerini, and D. Nardi: 1999b, ‘Unifying Class-Based Representation Formalisms’. Journal of Artificial Intelligence Research 11, 199–240. De Giacomo, G.: 1995, ‘Decidability of Class-Based Knowledge Representation Formalisms’. Ph.D. thesis, Dipartimento di Informatica e Sistemistica, Università di Roma “La Sapienza”. De Giacomo, G., F. Donini, and F. Massacci: 1996, ‘EXPTIME tableaux for ALC ’. In: Proc. of the 1996 Description Logic Workshop (DL’96). De Giacomo, G. and M. Lenzerini: 1994, ‘Boosting the Correspondence between Description Logics and Propositional Dynamic Logics’. In: Proc. of the 12th Nat. Conf. on Artificial Intelligence (AAAI-94). pp. 205–212, AAAI Press/The MIT Press. De Giacomo, G. and M. Lenzerini: 1996, ‘TBox and ABox Reasoning in Expressive Description Logics’. In: L. C. Aiello, J. Doyle, and S. C. Shapiro (eds.): Proc. of the 5th Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-96). pp. 316–327, Morgan Kaufmann. De Giacomo, G. and F. Massacci: 1996, ‘Tableaux and algorithms for propositional dynamic logic with converse’. In: Proc. of the 13th Conf. on Automated Deduction (CADE-96), Vol. 1104 of Lecture Notes In Artificial Intelligence. pp. 613–628, Springer-Verlag. A long versioned will appear in Information and Computation. Donini, F. M., B. Hollunder, M. Lenzerini, A. M. Spaccamela, D. Nardi, and W. Nutt: 1992, ‘The Complexity of Existential Quantification in Concept Languages’. Artificial Intelligence Journal 2–3, 309–327. Donini, F. M., M. Lenzerini, D. Nardi, and W. Nutt: 1991a, ‘The Complexity of Concept Languages’. In: J. Allen, R. Fikes, and E. Sandewall (eds.): Proc. of the 2nd Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-91). pp. 151–162, Morgan Kaufmann. Donini, F. M., M. Lenzerini, D. Nardi, and W. Nutt: 1991b, ‘Tractable Concept Languages’. In: Proc. of the 12th Int. Joint Conf. on Artificial Intelligence (IJCAI-91). pp. 458–463. Donini, F. M., M. Lenzerini, D. Nardi, and A. Schaerf: 1994, ‘Deduction in Concept Languages: From Subsumption to Instance Checking’. Journal of Logic and Computation 4(4), 423–452. Donini, F. M., M. Lenzerini, D. Nardi, and A. Schaerf: 1996, ‘Reasoning in Description Logics’. In: G. Brewka (ed.): Principles of Knowledge Representation, Studies in Logic, Language and Information. CSLI Publications, pp. 193–238. Donini, F. M. and F. Massacci: 1999, ‘EXPTIME Tableaux for ALC’. Technical Report 32/99, Dipartimento di Ingegenria dell’Informazione, Universita degli studi di Siena, Italy. To appear in Artificial Intelligence. Franconi, E. and G. Ng: 2000, ‘The i om Tool for Intelligent Conceptual Modelling’. In: Working Notes of the ECAI2000 Workshop on Knowledge Representation Meets Databases (KRDB2000), CEUR Electronic Workshop Proceedings. Franconi, E. and U. Sattler: 1999, ‘A Data Warehouse Conceptual Data Model for Multidimensional Aggregation: a preliminary report’. Italian Association for Artificial Intelligence AI*IA Notizie 1, 9–21. studia--final-complete.tex; 14/08/2001; 13:30; p.30 Tableau Algorithms for Description Logics 31 Haarslev, V. and R. Möller: 1999, ‘RACE System Description’. In: Proc. of the 1999 Description Logic Workshop (DL’99). pp. 130–132, CEUR Electronic Workshop Proceedings. Haarslev, V. and R. Möller: 2000a, ‘Consistency Testing: The RACE Experience’. In: R. Dyckhoff (ed.): Proc. of the Int. Conf. on Automated Reasoning with Tableaux and Related Methods (Tableaux 2000), Vol. 1847 of Lecture Notes in Artificial Intelligence. pp. 57–61, Springer-Verlag. Haarslev, V. and R. Möller: 2000b, ‘Expressive ABox Reasoning with Number Restrictions, Role Hierarchies, and Transitively Closed Roles’. In: Proc. of the 7th Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-00). Morgan Kaufmann. Halpern, J. Y. and Y. Moses: 1992, ‘A Guide to Completeness and Complexity for Modal Logics of Knowledge and Belief’. Artificial Intelligence Journal 54, 319–379. Hanschke, P.: 1992, ‘Specifying Role Interaction in Concept Languages’. In: Proc. of the 3rd Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-92). pp. 318–329, Morgan Kaufmann. Harel, D.: 1984, ‘Dynamic Logic’. In: Handbook of Philosophical Logic, Vol. 2. Dordrecht, Holland: D. Reidel, pp. 497–640. Hollunder, B.: 1990, ‘Hybrid Inferences in KL-ONE-based Knowledge Representation Systems’. In: Proc. of GWAI’90, Vol. 251 of Informatik-Fachberichte. pp. 38–47, Springer-Verlag. Hollunder, B.: 1996, ‘Consistency Checking Reduced to Satisfiability of Concepts in Terminological Systems’. Annals of Mathematics and Artificial Intelligence 18(2–4), 133–157. Hollunder, B. and F. Baader: 1991, ‘Qualifying Number Restrictions in Concept Languages’. In: Proc. of the 2nd Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-91). pp. 335–346, Morgan Kaufmann. Hollunder, B. and W. Nutt: 1990, ‘Subsumption Algorithms for Concept Languages’. Technical Report RR-90-04, Deutsches Forschungszentrum für Künstliche Intelligenz (DFKI), Kaiserslautern, Germany. Hollunder, B., W. Nutt, and M. Schmidt-Schauß: 1990, ‘Subsumption Algorithms for Concept Description Languages’. In: Proc. of the 9th European Conf. on Artificial Intelligence (ECAI-90). pp. 348–353, Pitman. Horrocks, I.: 1998a, ‘The FaCT System’. In: H. de Swart (ed.): Proc. of the Int. Conf. on Automated Reasoning with Tableaux and Related Methods (Tableaux-98), Vol. 1397 of Lecture Notes in Artificial Intelligence. pp. 307–312, Springer-Verlag. Horrocks, I.: 1998b, ‘Using an Expressive Description Logic: FaCT or Fiction?’. In: Proc. of the 6th Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-98). pp. 636–647, Morgan Kaufmann. Horrocks, I.: 2000, ‘Benchmark Analysis for FaCT’. In: R. Dyckhoff (ed.): Proc. of the Int. Conf. on Automated Reasoning with Tableaux and Related Methods (Tableaux 2000), Vol. 1847 of Lecture Notes in Artificial Intelligence. pp. 62–66, Springer-Verlag. Horrocks, I. and P. F. Patel-Schneider: 1999, ‘Optimizing Description Logic Subsumption’. Journal of Logic and Computation 9(3), 267–293. Horrocks, I. and U. Sattler: 1999, ‘A Description Logic with Transitive and Inverse Roles and Role Hierarchies’. Journal of Logic and Computation 9(3), 385–410. Horrocks, I., U. Sattler, and S. Tobies: 1999, ‘Practical Reasoning for Expressive Description Logics’. In: Proc. of the 6th Int. Conf. on Logic for Programming and Automated Reasoning (LPAR’99), Vol. 1705 of Lecture Notes In Artificial Intelligence. Springer-Verlag. Horrocks, I., U. Sattler, and S. Tobies: 2000a, ‘Practical Reasoning for Very Expressive Description Logics’. Logic Journal of the IGPL 8(3), 239–264. studia--final-complete.tex; 14/08/2001; 13:30; p.31 32 Franz Baader and Ulrike Sattler Horrocks, I., U. Sattler, and S. Tobies: 2000b, ‘Reasoning with Individuals for the Description Logic SHIQ’. In: D. MacAllester (ed.): Proc. of the 13th Conf. on Automated Deduction (CADE-17). Springer-Verlag. Lutz, C.: 1999, ‘Complexity of Terminological Reasoning Revisited’. In: Proc. of the 6th Int. Conf. on Logic for Programming and Automated Reasoning (LPAR’99), Vol. 1705 of Lecture Notes In Artificial Intelligence. Springer-Verlag. Lutz, C. and U. Sattler: 2000, ‘The Complexity of Reasoning with Boolean Modal Logic’. In: Advances in Modal Logic 2000 (AiML 2000). Leipzig, Germany. MacGregor, R.: 1991, ‘The Evolving Technology of Classification-Based Knowledge Representation Systems’. In: J. F. Sowa (ed.): Principles of Semantic Networks. Morgan Kaufmann, pp. 385–400. Mays, E., R. Dionne, and R. Weida: 1991, ‘K-REP System Overview’. SIGART Bulletin 2(3). Minsky, M.: 1981, ‘A Framework for Representing Knowledge’. In: J. Haugeland (ed.): Mind Design. The MIT Press. Republished in (Brachman and Levesque, 1985). Nebel, B.: 1990a, Reasoning and Revision in Hybrid Representation Systems, Vol. 422 of Lecture Notes In Artificial Intelligence. Springer-Verlag. Nebel, B.: 1990b, ‘Terminological Reasoning is Inherently Intractable’. Artificial Intelligence Journal 43, 235–249. Nebel, B.: 1991, ‘Terminological Cycles: Semantics and Computational Properties’. In: J. F. Sowa (ed.): Principles of Semantic Networks. Morgan Kaufmann, pp. 331–361. Patel-Schneider, P.: 2000, ‘TANCS-2000 Results for DLP’. In: R. Dyckhoff (ed.): Proc. of the Int. Conf. on Automated Reasoning with Tableaux and Related Methods (Tableaux 2000), Vol. 1847 of Lecture Notes in Artificial Intelligence. pp. 72–76, Springer-Verlag. Patel-Schneider, P. F.: 1999, ‘DLP’. In: Proc. of the 1999 Description Logic Workshop (DL’99). pp. 9–13, CEUR Electronic Workshop Proceedings. Patel-Schneider, P. F. and I. Horrocks: 1999, ‘DLP and FaCT’. In: Proceedings of the International Conference on Automated Reasoning with Analytic Tableaux and Related Methods (TABLEAUX-99), Vol. 1397 of Lecture Notes In Artificial Intelligence. pp. 19–23, Springer-Verlag. Patel-Schneider, P. F., D. L. McGuiness, R. J. Brachman, L. A. Resnick, and A. Borgida: 1991, ‘The CLASSIC Knowledge Representation System: Guiding Principles and Implementation Rational’. SIGART Bulletin 2(3), 108–113. Peltason, C.: 1991, ‘The BACK System – an Overview’. SIGART Bulletin 2(3), 114–119. Pratt, V. R.: 1979, ‘Models of Program Logic’. In: Proc. of the 20th Annual Sym. on the Foundations of Computer Science (FOCS-79). pp. 115–122. Quillian, M. R.: 1967, ‘Word Concepts: A Theory and Simulation of Some Basic Capabilities’. Behavioral Science 12, 410–430. Republished in (Brachman and Levesque, 1985). Sattler, U.: 1996, ‘A Concept Language Extended with Different Kinds of Transitive Roles’. In: G. Görz and S. Hölldobler (eds.): Proc. of the 20th German Annual Conf. on Artificial Intelligence (KI’96), Vol. 1137 of Lecture Notes In Artificial Intelligence. Springer-Verlag. Savitch, W. J.: 1970, ‘Relationship between Nondeterministic and Deterministic Tape Complexities’. Journal of Computer and System Science 4, 177–192. Schaerf, A.: 1993, ‘On the Complexity of the Instance Checking Problem in Concept Languages with Existential Quantification’. Journal of Intelligent Information Systems 2, 265–278. Schild, K.: 1991, ‘A Correspondence Theory for Terminological Logics: Preliminary Report’. In: Proc. of the 12th Int. Joint Conf. on Artificial Intelligence (IJCAI-91). pp. 466–471. Schild, K.: 1994, ‘Terminological Cycles and the Propositional -Calculus’. In: J. Doyle, E. Sandewall, and P. Torasso (eds.): Proc. of the 4th Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-94). pp. 509–520, Morgan Kaufmann. studia--final-complete.tex; 14/08/2001; 13:30; p.32 Tableau Algorithms for Description Logics 33 Schmidt-Schauß, M.: 1989, ‘Subsumption in KL-ONE is Undecidable’. In: R. J. Brachman, H. J. Levesque, and R. Reiter (eds.): Proc. of the 1st Int. Conf. on the Principles of Knowledge Representation and Reasoning (KR-89). pp. 421–431, Morgan Kaufmann. Schmidt-Schauß, M. and G. Smolka: 1991, ‘Attributive Concept Descriptions with Complements’. Artificial Intelligence Journal 48(1), 1–26. Spaan, E.: 1993, ‘The Complexity of Propositional Tense Logics’. In: M. de Rijke (ed.): Diamonds and Defaults. Kluwer Academic Publishers, pp. 287–307. Stirling, C.: 1992, ‘Modal and Temporal Logic’. In: S. Abramsky, D. M. Gabbay, and T. S. E. Maibaum (eds.): Handbook of Logic in Computer Science. Clarendon Press, pp. 477–563. Tobies, S.: 1999, ‘A PSPACE Algorithm for Graded Modal Logic’. In: Proc. of the 13th Conf. on Automated Deduction (CADE-16), Vol. 1632 of Lecture Notes in Computer Science. Springer-Verlag. Van der Hoek, W. and M. De Rijke: 1995, ‘Counting Objects’. Journal of Logic and Computation 5(3), 325–345. Vardi, M. Y. and P. Wolper: 1986, ‘Automata-theoretic Techniques for Modal Logics of Programs’. Journal of Computer and System Science 32, 183–221. A preliminary version appeared in Proc. of the 16th ACM SIGACT Symp. on Theory of Computing (STOC’84). studia--final-complete.tex; 14/08/2001; 13:30; p.33 studia--final-complete.tex; 14/08/2001; 13:30; p.34