THE DESCRIPTION LOGIC HANDBOOK: Theory, implementation, and applications Edited by Franz Baader Deborah L McGuinness Daniele Nardi Peter F Patel-Schneider Contents List of contributors page 1 An Introduction to Description Logics D Nardi, R J Brachman 1.1 Introduction 1.2 From networks to Description Logics 1.3 Knowledge representation in Description Logics 16 1.4 From theory to practice: Description Logics systems 20 1.5 Applications developed with Description Logics systems 24 1.6 Extensions of Description Logics 34 1.7 Relationship to other fields of Computer Science 40 1.8 Conclusion 43 Part one: Theory 45 2.1 2.2 2.3 2.4 Basic Description Logics F Baader, W Nutt Introduction Definition of the basic formalism Reasoning algorithms Language extensions 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 Complexity of Reasoning F M Donini Introduction OR-branching: finding a model AND-branching: finding a clash Combining sources of complexity Reasoning in the presence of axioms Undecidability Reasoning about individuals in ABoxes Discussion A list of complexity results for subsumption and satisfiability iii 47 47 50 78 95 101 101 105 112 119 121 127 133 137 138 iv 4.1 4.2 4.3 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 Contents Relationships with other Formalisms vanese, R Molitor AI knowledge representation formalisms Logical formalisms Database models 142 142 154 166 Expressive Description Logics D Calvanese, G De Giacomo 184 Introduction 184 Correspondence between Description Logics and Propositional Dynamic Logics 185 Functional restrictions 192 Qualified number restrictions 200 Objects 204 Fixpoint constructs 207 Relations of arbitrary arity 211 Finite model reasoning 215 Undecidability results 222 Extensions to Description Logics F Wolter 6.1 Introduction 6.2 Language extensions 6.3 Non-standard inference problems Part two: Implementation U Sattler, D Cal- F Baader, R Kă usters, 226 226 227 257 269 7.1 7.2 7.3 7.4 7.5 7.6 7.7 From Description Logic Provers to Knowledge Representation Systems D L McGuinness, P F Patel-Schneider 271 Introduction 271 Basic access 273 Advanced application access 276 Advanced human access 280 Other technical concerns 286 Public relations concerns 286 Summary 287 8.1 8.2 8.3 8.4 8.5 oller, V Haarslev Description Logics Systems R Mă New light through old windows? The first generation Second generation Description Logics systems The next generation: Fact , Dlp and Racer Lessons learned 289 289 290 298 308 310 Contents Implementation and Optimisation Techniques 9.1 Introduction 9.2 Preliminaries 9.3 Subsumption testing algorithms 9.4 Theory versus practice 9.5 Optimisation techniques 9.6 Discussion Part three: Applications 10 v I Horrocks 313 313 315 320 324 330 354 357 A Borgida, 10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9 10.10 Conceptual Modeling with Description Logics R J Brachman Background Elementary Description Logics modeling Individuals in the world Concepts Subconcepts Modeling relationships Modeling ontological aspects of relationships A conceptual modeling methodology The ABox: modeling specific states of the world Conclusions 11 11.1 11.2 11.3 11.4 11.5 Software Engineering Introduction Background Lassie CodeBase CSIS and CBMS 12 12.1 12.2 12.3 12.4 Configuration D L McGuinness Introduction Configuration description and requirements The Prose and Questar family of configurators Summary 397 397 399 412 413 13 13.1 13.2 13.3 13.4 13.5 13.6 Medical Informatics A Rector Background and history Example applications Technical issues in medical ontologies Ontological issues in medical ontologies Architectures: terminology servers, views, and change management Discussion: key lessons from medical ontologies 415 416 419 425 431 434 435 C Welty 359 359 361 363 365 368 371 373 378 379 381 382 382 382 383 388 389 vi 14 Contents 14.1 14.2 14.3 14.4 Digital Libraries and Web-Based Information I Horrocks, D L McGuinness, C Welty Background and history Enabling the Semantic Web: DAML OIL and DAML+OIL Summary Systems 15 15.1 15.2 15.3 15.4 Natural Language Processing E Franconi Introduction Semantic interpretation Reasoning with the logical form Knowledge-based natural language generation 16 16.1 16.2 16.3 16.4 16.5 Description Logics for Data Bases A Borgida, M Lenzerini, R Rosati 472 Introduction 472 Data models and Description Logics 475 Description Logics and database querying 484 Data integration 488 Conclusions 493 A1.1 A1.2 A1.3 A1.4 Description Logic Terminology F Baader Notational conventions Syntax and semantics of common Description Logics Additional constructors A note on the naming scheme for Description Logics 436 436 441 443 457 460 460 461 465 470 495 495 496 501 504 An Introduction to Description Logics Daniele Nardi Ronald J Brachman Abstract This introduction presents the main motivations for the development of Description Logics (DL) as a formalism for representing knowledge, as well as some important basic notions underlying all systems that have been created in the DL tradition In addition, we provide the reader with an overview of the entire book and some guidelines for reading it We first address the relationship between Description Logics and earlier semantic network and frame systems, which represent the original heritage of the field We delve into some of the key problems encountered with the older efforts Subsequently, we introduce the basic features of Description Logic languages and related reasoning techniques Description Logic languages are then viewed as the core of knowledge representation systems, considering both the structure of a DL knowledge base and its associated reasoning services The development of some implemented knowledge representation systems based on Description Logics and the first applications built with such systems are then reviewed Finally, we address the relationship of Description Logics to other fields of Computer Science We also discuss some extensions of the basic representation language machinery; these include features proposed for incorporation in the formalism that originally arose in implemented systems, and features proposed to cope with the needs of certain application domains 1.1 Introduction Research in the field of knowledge representation and reasoning is usually focused on methods for providing high-level descriptions of the world that can be effectively used to build intelligent applications In this context, “intelligent” refers to the abil5 D Nardi, R J Brachman ity of a system to find implicit consequences of its explicitly represented knowledge Such systems are therefore characterized as knowledge-based systems Approaches to knowledge representation developed in the 1970’s—when the field enjoyed great popularity—are sometimes divided roughly into two categories: logicbased formalisms, which evolved out of the intuition that predicate calculus could be used unambiguously to capture facts about the world; and other, non-logic-based representations The latter were often developed by building on more cognitive notions—for example, network structures and rule-based representations derived from experiments on recall from human memory and human execution of tasks like mathematical puzzle solving Even though such approaches were often developed for specific representational chores, the resulting formalisms were usually expected to serve in general use In other words, the non-logical systems created from very specific lines of thinking (e.g., early Production Systems) evolved to be treated as general purpose tools, expected to be applicable in different domains and on different types of problems On the other hand, since first-order logic provides very powerful and general machinery, logic-based approaches were more general-purpose from the very start In a logic-based approach, the representation language is usually a variant of first-order predicate calculus, and reasoning amounts to verifying logical consequence In the non-logical approaches, often based on the use of graphical interfaces, knowledge is represented by means of some ad hoc data structures, and reasoning is accomplished by similarly ad hoc procedures that manipulate the structures Among these specialized representations we find semantic networks and frames Semantic Networks were developed after the work of Quillian [1967], with the goal of characterizing by means of network-shaped cognitive structures the knowledge and the reasoning of the system Similar goals were shared by later frame systems [Minsky, 1981], which rely upon the notion of a “frame” as a prototype and on the capability of expressing relationships between frames Although there are significant differences between semantic networks and frames, both in their motivating cognitive intuitions and in their features, they have a strong common basis In fact, they can both be regarded as network structures, where the structure of the network aims at representing sets of individuals and their relationships Consequently, we use the term network-based structures to refer to the representation networks underlying semantic networks and frames (see [Lehmann, 1992] for a collection of papers concerning various families of network-based structures) Owing to their more human-centered origins, the network-based systems were often considered more appealing and more effective from a practical viewpoint than the logical systems Unfortunately they were not fully satisfactory because of their usual lack of precise semantic characterization The end result of this was that every system behaved differently from the others, in many cases despite virtually identical- An Introduction to Description Logics looking components and even identical relationship names The question then arose as to how to provide semantics to representation structures, in particular to semantic networks and frames, which carried the intuition that, by exploiting the notion of hierarchical structure, one could gain both in terms of ease of representation and in terms of the efficiency of reasoning One important step in this direction was the recognition that frames (at least their core features) could be given a semantics by relying on first-order logic [Hayes, 1979] The basic elements of the representation are characterized as unary predicates, denoting sets of individuals, and binary predicates, denoting relationships between individuals However, such a characterization does not capture the constraints of semantic networks and frames with respect to logic Indeed, although logic is the natural basis for specifying a meaning for these structures, it turns out that frames and semantic networks (for the most part) did not require all the machinery of first-order logic, but could be regarded as fragments of it [Brachman and Levesque, 1985] In addition, different features of the representation language would lead to different fragments of first-order logic The most important consequence of this fact is the recognition that the typical forms of reasoning used in structurebased representations could be accomplished by specialized reasoning techniques, without necessarily requiring first-order logic theorem provers Moreover, reasoning in different fragments of first-order logic leads to computational problems of differing complexity Subsequent to this realization, research in the area of Description Logics began under the label terminological systems, to emphasize that the representation language was used to establish the basic terminology adopted in the modeled domain Later, the emphasis was on the set of concept-forming constructs admitted in the language, giving rise to the name concept languages In more recent years, after attention was further moved towards the properties of the underlying logical systems, the term Description Logics became popular In this book we mainly use the term “Description Logics” (DL) for the representation systems, but often use the word “concept” to refer to the expressions of a DL language, denoting sets of individuals; and the word “terminology” to denote a (hierarchical) structure built to provide an intensional representation of the domain of interest Research on Description Logics has covered theoretical underpinnings as well as implementation of knowledge representation systems and the development of applications in several areas This kind of development has been quite successful The key element has been the methodology of research, based on a very close interaction between theory and practice On the one hand, there are various implemented systems based on Description Logics, which offer a palette of description formalisms with differing expressive power, and which are employed in various application do- D Nardi, R J Brachman mains (such as natural language processing, configuration of technical products, or databases) On the other hand, the formal and computational properties of reasoning (like decidability and complexity) of various description formalisms have been investigated in detail The investigations are usually motivated by the use of certain constructors in implemented systems or by the need for these constructors in specific applications—and the results have influenced the design of new systems This book is meant to provide a thorough introduction to Description Logics, covering all the above-mentioned aspects of DL research—namely theory, implementation, and applications Consequently, the book is divided into three parts: • Part I introduces the theoretical foundations of Description Logics, addressing some of the most recent developments in theoretical research in the area; • Part II focuses on the implementation of knowledge representation systems based on Description Logics, describing the basic functionality of a DL system, surveying the most influential knowledge representation systems based on Description Logics, and addressing specialized implementation techniques; • Part III addresses the use of Description Logics and of DL-based systems in the design of several applications of practical interest In the remainder of this introductory chapter, we review the main steps in the development of Description Logics, and introduce the main issues that are dealt with later in the book, providing pointers for its reading In particular, in the next section we address the origins of Description Logics and then we review knowledge representation systems based on Description Logics, the main applications developed with Description Logics, the main extensions to the basic DL framework and relationships with other fields of Computer Science 1.2 From networks to Description Logics In this section we begin by recalling approaches to representing knowledge that were developed before research on Description Logics began (i.e., semantic networks and frames) We then provide a very brief introduction to the basic elements of these approaches, based on Tarski-style semantics Finally, we discuss the importance of computational analyses of the reasoning methods developed for Description Logics, a major ingredient of research in this field 1.2.1 Network-based representation structures In order to provide some intuition about the ideas behind representations of knowledge in network form, we here speak in terms of a generic network, avoiding references to any particular system The elements of a network are nodes and links Description Logics for Data Bases 491 • According to the so-called global-as-view approach, a query over the source relations is associated to each concept in the Domain Conceptual Schema Every such concept is thus seen as a view over the sources • In the alternative local-as-view approach, one associates with each source relation a query that describes its content in terms of the Domain Conceptual Schema In other words, the logical content of a source relation is described in terms of a view over the Domain Conceptual Schema In [Levy, 2000], it is argued that the local-as-view approach has several advantages, and we will follow this approach in the rest of the chapter To describe the content of the sources through views, one needs a notion of query such as the union of conjunctive queries over the Domain Conceptual Schema Specifically, a source relation is described in terms of a query of the form q(x) ← conj (x, y1 ) ∨ · · · ∨ conj m (x, ym ) where: • The head q(x) defines the schema of the relation in terms of a name, and the number of columns • The body describes the content of the relation in terms of the Domain Conceptual Schema In [Calvanese et al., 2001c], conj i (x, yi ) is a conjunction of atoms, and x, yi are all the variables appearing in the conjunct (we use x to denote a tuple of variables x1 , , xn , for some n) Each atom is of the form E(t), R(t), or A(t, t ), where t, t, and t are variables in x, yi or constants, and E, R, and A are respectively entities, relationships, and attributes appearing in the Domain Conceptual Schema The semantics of queries is as follows Given a database that satisfies the Domain Conceptual Schema, a query q of arity n is interpreted as the set of n-tuples (d1 , , dn ), with each di an object of the database, such that, when substituting each di for xi , the formula ∃y1 conj (x, y1 ) ∨ · · · ∨ ∃ym conj m (x, ym ) evaluates to true Analogously to the case of the conceptual level, it is interesting to perform several reasoning tasks on the DL representation of the sources, for example for inferring redundancies and/or inconsistencies among data stored in different sources Since queries that include atoms from the Conceptual Schema are more expressive, new algorithms are required to answer the following problems: • Query containment Given two queries q1 and q2 (of the same arity n), check whether q1 is contained in q2 , i.e., check if the set of tuples denoted by q1 is 492 A Borgida, M Lenzerini, R Rosati contained in the set of tuples denoted by q2 in every database satisfying the Conceptual Schema Papers that contain results relating to this question include [Levy and Rousset, 1998; Calvanese et al., 1998a; Goasdoue and Rousset, 2000] • Query consistency Check if a query q over the Conceptual Schema is consistent, i.e., check if there exists a database satisfying the Conceptual Schema in which the set of tuples denoted by q is not empty • Query disjointness Check whether two queries q1 and q2 (of the same arity) over the Conceptual Schema are disjoint, i.e., check if the intersection of the set of tuples denoted by q1 and the set of tuples denoted by q2 is empty, in every database satisfying the Conceptual Schema 16.4.2 Query answering The ultimate goal of a data integration system is to allow the user to pose queries over the global view, and to answer the queries by accessing the sources in a transparent way The mechanism for answering queries differs depending on the approach adopted for specifying the sources The possibility of reasoning about queries can provide useful support in both the global-as-view and the local-as-view approaches As in the previous section, here we focus on the local-as-view approach, that is the one in which query answering is most complex In the local-as-view approach, relations at the sources are modeled as views over the virtual database represented by the Domain Conceptual Schema Since the database is virtual, in order to answer a query Q formulated over the Domain Conceptual Schema, we can only use the source views In other words, query processing cannot simply be done by looking at a set of relations, as in traditional databases, but requires reasoning on both the form of the query, and the content of the source views This motivates the idea that query answering in data integration becomes the problem of view-based query processing There are two approaches to view-based query processing, called query rewriting and query answering, respectively In the former approach, we are given a query Q and a set of view definitions, and the goal is to reformulate the query into an equivalent expression that refers only to the views available, and provides the answer to Q In the latter approach, besides Q and the view definitions, we also take into account the extensions of the views, and the goal is to compute the set of tuples that are implied by these extensions, i.e., the set of tuples t such that t satisfies Q in all the databases that are consistent with the views Notice the difference between the two approaches In query rewriting, query processing is divided in two steps, where the first re-expresses the query in terms of a given query language over the alphabet of the view names, and the second step evaluates the rewriting over the view extensions In query answering, we Description Logics for Data Bases 493 not pose any limit on query processing, and the only goal is to exploit all possible information, including view extensions, to compute the answer to the query View-based query processing has been extensively investigated by the database community [Levy, 2000] Only recently has the problem been studied for the case where the Domain Conceptual Schema is expressed in DLs For example, [Baader et al., 2000] addresses the problem of rewriting queries that are concepts in terms of concepts in the conceptual schema Query rewriting for to more general queries (e.g., ones involving conjunctions of atoms) has been studied in [Beeri et al., 1997; Levy and Rousset, 1998; Goasdoue et al., 2000; Calvanese et al., 2001c], in some cases taking into consideration complex constraints expressed in DL as part of the Conceptual Schema One issue that must be addressed here is that the original query Q may not be rewritable as an expression over the views because of limitations of the language for combining views In this case, one must find heuristic besteffort approximations Another issue is finding a minimum-cost rewriting (e.g., by eliminating unnecessary look-ups in some of the views) Finally, we mention that Goasdoue et al [2000] describe an implemented information integration system, which uses a combination of global-as-view and limited local-as-view approach applied to the ALN DL and non-recursive Horn rules Among the pioneering attempts at solving the query answering problem is the Information Manifold system [Levy et al., 1996; 1995], which has detailed algorithms for query rewriting In the context of heterogeneous databases, Mena et al [2000] propose that each source has its own conceptual schema/ontology expressed in a DL, and these are inter-related by adding “hyponym” (subsumption) relationships between concepts in each (This is reminiscent of the approach in [Catarci and Lenzerini, 1993].) One of the interesting features of this system is that it takes seriously the approximations resulting from the fact that some queries may not be expressible in terms of the combined ontologies Among others, they study the notions of “precision” and “accuracy” of recall to quantify this approximation A solution to the query answering approach is presented in [Calvanese et al., 2000a], which, among others, illustrates the relationship between view-based query answering and ABox reasoning in DLs 16.5 Conclusions We have reviewed a number of ways in which DLs can be useful in the development and utilization of databases Probably the most successful applications are in areas where the conceptual model of the UofD is required This includes the initial development stage, as well as access to heterogeneous data sources Concerning the initial conceptual modeling: First, DLs are powerful enough to 494 A Borgida, M Lenzerini, R Rosati capture the domain semantics represented by various entity-relationship data models, as well as other data models introduced in the database literature In fact, with most DLs, one can represent additional constraints Second, because DLs have a clear semantics, the meaning of the DL model is unambiguous and precise Third, not only can information be represented, but it can also be reasoned with: one can look for inconsistent class/entity definitions (ones that cannot have any individual instances) and more generally, one can check for the consistency of the entire model Both of these are signs to the developer that there are modeling errors Arguably, it is this third aspect, concerning reasoning with the model, that is the greatest advantage of DL models DL descriptions can be viewed as necessary and sufficient conditions, and hence as queries (or views!) for a database DLs are somewhat less successful in this regard (at least in their pure form), because they have limited expressive power compared to the standard calculi known from relational databases, and because they cannot generate new objects—only select subsets of existing objects However, if one accepts a DL as a data model, then DL queries can be classified with respect to schema concepts and previous queries, supporting query by refinement and data exploration The subsumption relationship can also be used for semantic query optimization Combining DLs with Datalog rules, or at least supporting conjunctive queries from concepts, is a promising way to obtain a more expressive query language The evaluation of the resulting queries appears to be decidable with a wide range of DLs if the rules are not recursive The addition of recursion appears to lead to undecidability relatively quickly However, full recursion is not an necessity for practical applications, such as information integration, so further research in the possible combinations of DLs and Datalog restrictions is warranted The ability to represent the semantics of a UofD is also the reason why DLs are useful in situations where information is to be integrated from various sources, such as heterogeneous or federated databases It is widely agreed that the integration needs to be achieved at the conceptual level The DL can be used to define the ontology of each site, and then these ontologies are inter-related; alternatively, a global ontology is specified, and then the sites are described as views over it Appendix Description Logic Terminology Franz Baader Abstract The purpose of this appendix is to introduce (in a compact manner) the syntax and semantics of the most prominent DLs occurring in this handbook More information and explanations as well as some less familiar DLs can be found in the respective chapters For DL constructors whose semantics cannot be described in a compact manner, we will only introduce the syntax and refer the reader to the respective chapter for the semantics Following Chapter on Basic Description Logics, we will first introduce the basic DL AL, and then describe several of its extensions Thereby, we will also fix the notation employed in this handbook Finally, we will comment on the naming schemes for DLs that are employed in the literature and in this handbook A1.1 Notational conventions Before starting with the definitions, let us introduce some notational conventions The letters A, B will often be used for atomic concepts, and C, D for concept descriptions For roles, we often use the letters R, S, and for functional roles (features, attributes) the letters f, g Nonnegative integers (in number restrictions) are often denoted by n, m, and individuals by a, b In all cases, we may also use subscripts This convention is followed when defining syntax and semantics and in abstract examples In concrete examples, the following conventions are used: concept names start with an uppercase letter followed by lowercase letters (e.g., Human, Male), role names (also functional ones) start with a lowercase letter (e.g., hasChild, marriedTo), and individual names are all uppercase (e.g., CHARLES, MARY) 495 496 F Baader A1.2 Syntax and semantics of common Description Logics In this section, we introduce the standard concept and role constructors as well as knowledge bases For more information see Chapter A1.2.1 Concept and role descriptions Elementary descriptions are atomic concepts and atomic roles (also called concept names and role names) Complex descriptions can be built from them inductively with concept constructors and role constructors Concept descriptions in AL are formed according to the following syntax rule: C, D −→ A | | ⊥| ¬A | C D| ∀R.C | ∃R (atomic concept) (universal concept) (bottom concept) (atomic negation) (intersection) (value restriction) (limited existential quantification) Following our convention, A denotes an atomic concept and C, D denote concept descriptions The role R is atomic since AL does not provide for role constructors An interpretation I consist of a non-empty set ∆I (the domain of the interpretation) and an interpretation function, which assigns to every atomic concept A a set AI ⊆ ∆I and to every atomic role R a binary relation RI ⊆ ∆I × ∆I The interpretation function is extended to concept descriptions by the following inductive definitions: I ⊥I I (C ¬A D)I (∀R.C)I (∃R )I = ∆I = ∅ = ∆I \ A I = C I ∩ DI = {a ∈ ∆I | ∀b (a, b) ∈ RI → b ∈ C I } = {a ∈ ∆I | ∃b (a, b) ∈ RI } There are several possibilities for extending AL in order to obtain a more expressive DL The three most prominent are adding additional concept constructors, adding role constructors, and formulating restrictions on role interpretations Below, we start with the third possibility, since we need to refer to restrictions on roles when defining certain concept constructors For these extensions, we also introduce a naming scheme Basically, each extension is assigned a letter or symbol For concept constructors, the letters/symbols are written after the starting AL, for role Description Logic Terminology 497 Table A1.1 Some Description Logic concept constructors Name Syntax Symbol ∆I Top Bottom Semantics ⊥ ∅ Intersection C D Union C D I AL C ∩D I C I ∪ DI I ∆ \C I Negation ¬C Value restriction ∀R.C Existential quant ∃R.C Unqualified number restriction nR nR =nR Qualified number restriction n R.C n R.C = n R.C Role-valuemap {a ∈ ∆I | ∀b.(a, b) ∈ RI → (a, b) ∈ S I } {a ∈ ∆I | ∀b.(a, b) ∈ RI ↔ (a, b) ∈ S I } Agreement and disagreement R⊆S R=S u1 = u2 u1 = u2 Nominal I I I ⊆ ∆I with |I I | = {a ∈ ∆I | ∀b (a, b) ∈ RI → b ∈ C I } {a ∈ ∆I | ∃b (a, b) ∈ RI ∧ b ∈ C I } {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI }| ≥ n} {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI }| ≤ n} {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI }| = n} {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI ∧ b ∈ C I }| ≥ n} {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI ∧ b ∈ C I }| ≤ n} {a ∈ ∆I | |{b ∈ ∆I | (a, b) ∈ RI ∧ b ∈ C I }| = n} {a ∈ ∆I | ∃b ∈ ∆I uI1 (a) = b = uI2 (a)} {a ∈ ∆I | ∃b1 , b2 ∈ ∆I uI1 (a) = b1 = b2 = uI2 (a)} AL AL U C AL E N Q F O constructors, we write the letters/symbols as superscripts, and for restrictions on the extends AL interpretation of roles as subscripts As an example, the DL ALCQ−1 R+ with the concept constructors negation (C) and qualified number restrictions (Q), the role constructor inverse (−1 ), and the restriction that some roles are transitive (R+ ) Restrictions on role interpretations These restrictions enforce the interpretations of roles to satisfy certain properties, such as functionality and transitivity We consider these two prominent examples in more detail Others would be symmetry or connections between different roles.1 (i) Functional roles Here one considers a subset NF of the set of role names NR , whose elements are called features An interpretation must map features One could also count role hierarchies as imposing such restrictions Here we will, however, treat role hierarchies in the context of knowledge bases 498 F Baader Table A1.2 Concrete syntax of concept constructors Name Concrete syntax Abstract syntax Top TOP Bottom BOTTOM ⊥ Intersection (and C1 · · · Cn ) C1 ··· Cn Union (or C1 · · · Cn ) C1 ··· Cn Negation (not C) ¬C Value restriction (all R C) ∀R.C Limited existential quantification (some R) ∃R Existential quantification (some R C) ∃R.C At-least number restriction (at-least n R) nR At-most number restriction (at-most n R) nR Exact number restriction (exactly n R) =nR Qualified at-least restriction (at-least n R C) n R.C Qualified at-most restriction (at-most n R C) n R.C Qualified exact restriction (exactly n R C) Same-as, agreement (same-as u1 u2 ) = n R.C u1 = u2 Role-value-map (subset R1 R2 ) R1 ⊆ R2 Role fillers (fillers R I1 · · · In ) ∃R.I1 One-of (one-of I1 · · · In ) I1 ··· ··· ∃R.In In f to functional binary relations f I ⊆ ∆I × ∆I , i.e., relations satisfying ∀a, b, c.f I (a, b)∧f I (a, c) → b = c Sometimes functional relations are viewed as partial function, and thus one writes f I (a) = b rather than f I (a, b) AL extended with features is denoted by ALf (ii) Transitive roles Here one considers a subset NR+ of NR Role names R ∈ NR+ are called transitive roles An interpretation must map transitive roles R ∈ NR+ to transitive binary relations RI ⊆ ∆I × ∆I AL extended with transitive roles is denoted by ALR+ Concept constructors Concept constructors take concept and/or role descriptions and transform them into more complex concept descriptions Table A1.1 shows the syntax and semantics of common concept constructors In order to have them all in one place, we also repeat Description Logic Terminology 499 Table A1.3 Some Description Logic role constructors Name Syntax Semantics Symbol Universal role U ∆I × ∆I U Intersection R S Union C D Complement ¬R R− Inverse Composition R◦S Transitive closure R+ Reflexive-transitive closure R∗ Role restriction R|C Identity id (C) RI ∩ S I RI ∪ S I ∆I × ∆I \ RI {(b, a) ∈ ∆I × ∆I | (a, b) ∈ RI } I R ◦S I ¬ −1 ◦ n≥1 (R I n ) + n≥0 (R I n ∗ ) RI ∩ (∆I × C I ) {(d, d) | d ∈ C I } r id the ones from AL, minus atomic negation and limited existential quantification since they are special cases of negation and existential quantification Some explanatory remarks are in order The symbols u1 , u2 in the agreement constructor stand for chains of functional roles, i.e., u1 = f1 · · · fm and u2 = g1 · · · gn where n, m ≥ and the fi , gj are features The semantics of such a chain is given by the composition of the partial functions interpreting its components, i.e., u1I (a) = fnI (· · · f1I (a) · · ·) Nominals (or individuals) in concept expression are interpreted as singleton sets, consisting of one element of the domain We assume that names for individuals come from a name space disjoint from the set of concept and role names Since role-value-maps cause undecidability and thus are no longer used in DL systems, there is no special symbol for them in the last column of Table A1.1 Many DL systems employ a Lisp-like concrete syntax Table A1.2 introduces this syntax and gives a translation into the abstract syntax introduced in Table A1.1 Role constructors Role constructors take role and/or concept descriptions and transform them into more complex role descriptions Table A1.3 shows the syntax and semantics of common role constructors The symbol ◦ denotes the usual composition of binary relations, i.e., RI ◦ S I = {(a, c) | ∃b (a, b) ∈ RI ∧ (b, c) ∈ S I } 500 F Baader Table A1.4 Concrete syntax of role constructors Name Concrete syntax Abstract syntax Universal role top U Intersection (and R1 · · · Rn ) R1 ··· Rn Union (or R1 · · · Rn ) R1 ··· Rn Complement (not R) ¬R Inverse (inverse R) R− Composition (compose R1 · · · Rn ) R1 ◦ · · · ◦ Rn Transitive closure (transitive-closure R) R+ Reflexive-transitive closure (transitive-reflexive-closure R) R∗ Role restriction (restrict R C) R|C Identity (identity C) id (C) Iterated composition is denoted in the form (RI )n To be more precise, (RI )0 = {(d, d) | d ∈ ∆I } and (RI )n+1 = (RI )n ◦ RI Transitive and reflexive-transitive closure are the only constructors among the ones introduced until now that cannot be expressed in first-order predicate logic The Lisp-like concrete syntax for role constructors can be found in Table A1.4 A1.2.2 Knowledge bases A DL knowledge base usually consists of a set of terminological axioms (often called TBox) and a set of assertional axioms or assertions (often called ABox) Syntax and semantics of these axioms can be found in Table A1.5 An interpretation I is called a model of an axiom if it satisfies the statement in the last column of the table An equality whose left-hand side is an atomic concept (role) is called concept (role) definition A finite set of definitions is called a terminology or TBox if the definitions are unambiguous, i.e., no atomic concept occurs more than once as lefthand side Axioms of the form C D for a complex description C are often called general inclusion axioms A set of axioms of the form R S where both R and S are atomic is called role hierarchy Such a hierarchy obviously imposes restrictions on the interpretation of roles Thus, the fact that the knowledge base may contain a role hierarchy is sometimes indicated by appending a subscript H to the name of the DL (see “Restrictions on role interpretations” above) Description Logic Terminology 501 Table A1.5 Terminological and assertional axioms Name Syntax Semantics Concept inclusion C D C I ⊆ DI Role inclusion R S Concept equality C≡D Role equality R≡S RI = S I Concept assertion C(a) aI ∈ C I Role assertion R(a, b) RI ⊆ S I C I = DI (aI , bI ) ∈ RI Table A1.6 Concrete syntax of axioms Name Concrete syntax Abstract syntax Concept definition (define-concept A C) A≡C Primitive concept introduction (define-primitive-concept A C) A C General inclusion axiom (implies C D) C D Role definition (define-role R S) R≡S Primitive role introduction (define-primitive-role R S) R Concept assertion (instance a C) C(a) Role assertion (related a b R) R(a,b) S The concrete Lisp-like syntax distinguishes between terminological axioms with atomic concepts as left-hand sides and the more general ones Following the convention mentioned at the beginning of this appendix, A denotes an atomic concept In the table, R is also meant to denote an atomic role A1.3 Additional constructors Here we mention some of the additional constructors that occur somewhere in the handbook For most of them, the semantics cannot be described in a compact manner, and thus we refer to the respective chapter for details A1.3.1 Concept and role constructors Many additional constructors are introduced in Chapter In DLs with concrete domains one can us concrete predicates to constrain fillers of feature chains, similarly to the use of the equality predicate in feature agreements For example, if hasAge is 502 F Baader a feature and ≥18 the unary concrete predicate consisting of all nonnegative integers greater than or equal to 18, then ∃hasAge.≥18 describes the individuals whose age is greater than or equal to 18 In general, an existential predicate restriction is of the form ∃(u1 , · · · , un ).P, where P is an n-ary predicate of the underlying concrete domain and u1 , , un are feature chains One can also use concrete domain predicates to define new roles For example, ∃(hasAge)(hasAge).> consists of all pairs of individuals having an age such that the first individual is older than the second one The general form of such a complex role is ∃(u1 , , un )(v1 , , vm ).P, where P is an (n + m)-ary predicate of the underlying concrete domain and u1 , , un , v1 , , vm are feature chains In modal extensions of description logics, one can apply modal operators to concepts and/or roles, i.e., if ✷ is such a modal operator, C is a concept, and R is a role, then ✷C and ✷R is a concept and a role, respectively Similarly, one can also use diamond operators ✸ to obtain new concepts and roles A special such modal operator is the epistemic operator K, which can be used to talk about things that are known to the knowledge base Chapter introduces several additional constructors Least and greatest fixpoint semantics for cyclic terminologies (see Chapter 2) can be generalized by introducing fixpoint constructors directly into the description language Let X be a concept name and C a concept description containing the name X Then µX.C and νX.C is a new concept description respectively obtained by applying the least and the greatest fixpoint constructor to C To ensure that the least and the greatest fixpoint exist, one must restrict C to be syntactically monotonic, i.e., every occurrence of X in C must be in the scope of an even number of complement operators For example, given an interpretation ManI of Man and hasChildI of hasChild, the concept νMomo.(Man ∀hasChild.Momo) looks for the greatest interpretation MomoI of Momo such that MomoI = (Man ∀hasChild.Momo)I It is easy to see that this is the set of all men having only male offspring (see Chapter for the corresponding example with a cyclic TBox) Chapter also considers the DL DLR, in which the restriction to at most binary Description Logic Terminology 503 predicates is no longer enforced If R is an n-ary predicate, i ∈ {1, , n}, and k is a nonnegative integer, then ∃[$i]R denotes the concept collecting those individuals that occur as ith component in some tuple of R, and ≤ k [$i]R denotes the concept collecting those individuals d for which the predicate R contains at most k tuples whose ith component is d Conversely, if C is a concept, n a nonnegative integer, and i ∈ {1, , n}, then ($i/n : C) denotes the n-ary predicate consisting of the tuples whose ith component belongs to C The DL DLR also allows for Boolean operators on both concepts and predicates.1 A1.3.2 Axioms In addition to the semantics for terminological axioms introduced above, Chapter also considers fixpoint semantics for cyclic TBoxes Chapter introduces several ways of extending the terminological and the assertional component of a DL system In DLs with concrete domains one can use concrete predicates also in the ABox in assertions of the form P (x1 , , xn ), where P is an n-ary predicate of the underlying concrete domain and x1 , , xn are names for concrete individuals In some modal extensions of description logics, one can apply modal and Boolean operators also to terminological and assertional axioms: if ϕ, ψ are axioms, then so are ϕ ∧ ψ, ¬ϕ, ✷ϕ In probabilistic extensions of description logics, one can use probabilistic terminological axioms of the form P(C|D) = p, which state that the conditional probability for an object known to be in D to belong to C is p Note, however, that negation on predicates has a non-standard semantics (see Chapter for details) 504 F Baader The integration of Reiter’s default logic into DLs yields terminological defaults of the form C(x) : D(x) , E(x) where C, D, E are concept descriptions (viewed as first-order formulae with one free variable x) Intuitively, such a default rule can be applied to an ABox individual a, i.e., E(a) is added to the current set of beliefs, if its prerequisite C(a) is already believed for this individual and its justification D(a) is consistent with the set of beliefs Rules of the form C⇒E (as introduced in Chapter 2) can be seen as a special case of terminological defaults where the justification is empty Their intuitive meaning is: “if an individual is known to be an instance of C, then add the information that it is also an instance of E.” A1.4 A note on the naming scheme for Description Logics In Section A1.2 we have introduced a naming scheme for DLs, which extends the naming scheme for the AL-family introduced in Chapter by writing letters/symbols for role constructors as superscripts, and for restrictions on the interpretation of roles as subscripts The reason was that this yields a consistent naming scheme, which distinguishes typographically between the three different possibilities for extending the expressive power of AL In the literature, and also in this handbook, other naming schemes are employed as well One reason for this, in addition to the fact that such schemes have evolved over time, is that it is very hard to pronounce a name like ALCQ−1 We will here R+ point out the most prominent such naming schemes The historically first scheme is the one for the AL-family introduced in Chapter 2, and extended in this appendix However, in the literature the typographical distinction between role constructors, concept constructors, and restrictions on the interpretation of roles is usually not made For example, many papers use I to denote inverse of roles, R to denote intersection of roles, and H to denote role hierarchies Thus, ALCRI denotes the extension of ALC by intersection and inverse of roles, and ALCH denotes the extension of ALC by role hierarchies In some cases, the letter F, which we employed to express the presence of feature agreements and disagreements, is used with a different meaning Its presence states that number restrictions of the form R can be used to express functionality of roles.1 The Unlike the restriction of R to be functional, which we express with a subscript f , this allows for local Description Logic Terminology 505 subscript “trans” (or “reg”) is often employed to express the presence of union, composition, and transitive closure of roles (sometimes also including the identity role) The Greek letter µ in front of a language name, like in µALC, usually indicates the extension of this DL by fixpoint operators All members of the AL-family include AL as a sublanguage In some cases on does not want all the constructors of AL to be present in the language The DL FL− is obtained from AL by disallowing atomic negation, and FL0 is obtained from FL− by, additionally, disallowing limited existential quantification If these languages are extended by other constructors, one can indicate this in a way analogous to extensions of AL For example, FL− U denotes the extension of FL− by union of concepts All the DLs mentioned until now contain the concept constructors intersection and value restriction as a common core DLs that allow for intersection of concepts and existential quantification (but not value restriction) are collected in the EL-family The only constructors available in EL are intersection of concepts and existential quantification Extensions of EL are again obtained by adding appropriate letters/symbols In order to avoid very long names for expressive DLs, the abbreviation S was introduced for ALC R+ , i.e., the DL that extends ALC by transitive roles Prominent members of the S-family are SIN (which extends ALC R+ with number restrictions and inverse roles), SHIF (which extends ALC R+ with role hierarchies, inverse roles, and number restrictions of the form R), and SHIQ (which extends ALC R+ with role hierarchies, inverse roles, and qualified number restrictions) Actually, the DLs SIN , SHIF, and SHIQ are somewhat less expressive than indicated by their name since the use of roles in number restrictions is restricted: roles that have a transitive subrole must not occur in number restrictions The DL DLR mentioned in the previous section also gives rise to a family of DLs, with members like DLRreg , which extends DLR with union, composition, and transitive closure of binary relations obtained as projections of n-ary predicates onto two of their components functionality statements, i.e., R is functional at a certain place, but may be non-functional at other places ... (the subsumer ) is considered more general than the one denoted by C (the subsumee) In other words, subsumption checks whether the first concept always denotes a subset of the set denoted by the. .. representation language and the difficulty of reasoning over the representations built using that language In other words, the more expressive the language, the harder the reasoning They also provided... Description Logics systems The third component in the picture of the development of Description Logics is the implementation of applications in different domains Some of the applications created over the