Robustness of Constraint Automata for Description Logics with Concrete Domains
Abstract
Decidability or complexity issues about the consistency problem for description logics with concrete domains have already been analysed with tableaux-based or type elimination methods. Concrete domains in ontologies are essential to consider concrete objects and predefined relations. In this work, we expose an automata-based approach leading to the optimal upper bound ExpTime, that is designed by enriching the transitions with symbolic constraints. We show that the nonemptiness problem for such automata belongs to ExpTime if the concrete domains satisfy a few simple properties. Then, we provide a reduction from the consistency problem for ontologies, yielding ExpTime-membership. Thanks to the expressivity of constraint automata, the results are extended to additional ingredients such as inverse roles, functional role names and constraint assertions, while maintaining ExpTime-membership, which illustrates the robustness of the approach.
Keywords and phrases:
Description logics, concrete domains, constraint automata, complexityCopyright and License:
2012 ACM Subject Classification:
Theory of computation LogicAcknowledgements:
We thank the reviewers for their numerous suggestions that help us to improve the quality of the document, in particular to have spotted an error in the submitted version.Editors:
Stefano Guerrini and Barbara KönigSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Landmark results for description logics with concrete domains.
In description logics with concrete domains, the elements of the interpretation domain are enriched with tuples of values from the concrete domain, see e.g. [4, 25, 26, 27, 6], enabling reasoning about concrete information. The first decidability result for a large class of concrete domains can be traced back to [27] in which the decidability of the consistency problem with -admissible concrete domains is established using tableaux-based decision procedures (apart from the very first decidability result in [4, Theorem 4.3]). Though this was a genuine breakthrough in understanding with concrete domains, a few restrictions were required: the set of binary relations is finite; satisfies the patchwork property [27, Definition 3] which corresponds to the amalgamation property; and it satisfies compactness, see e.g. [8, Section 6.1] and [27, Definition 4] which corresponds to homomorphism -compactness. Furthermore, CD-restrictions are of the form [27, Definition 6], where and the ’s are binary predicates. Moreover, no ABoxes in the consistency problem are handled in [27]. Among the concrete domains captured by [27], it is worth mentioning Allen’s interval algebra and RCC8, see more details in [27, Section 2].
Though the works [27, 15] mainly focus on decidability, a recent remarkable breakthrough was achieved in [13], which shows that the knowledge base consistency problem for with -admissible concrete domains belongs to ExpTime, refining the decidability results; see also [3]. This complexity result nicely extends the type elimination algorithm for that leads already to ExpTime, based on the technique using elimination of Hintikka sets established in [29], see also [12, Section 6.8], [28, Section 2.3] and [30, Section 4.2].
Our motivations.
The well-known automata-based approach, see e.g. [14, 35, 36], consists of reducing logical problems to automata-based problems to take advantage of results and decision procedures from automata theory. Among the expected properties, the reduction should be conceptually simple even if showing its correctness requires some substantial work. Ideally, the complexity of the automata-based target problems should be well-understood, so that the reduction yields a tight upper bound on the complexity of the logical problem. Herein, we would like to follow an automata-based approach for reasoning in the description logics with concrete domains and regain the ExpTime-membership from [13] (see also the recent work [3]) based on the approach from [19, 20]. Type elimination and tableaux-based techniques are definitely worth being developed but we would like to expose an alternative approach with comprehensively developed formal methods that are equally accessible to a wide audience. Our motivations definitely rest on the use of concrete domains as the automata-based approach for description logics (without concrete domains) with automata over finite alphabets is already advocated in [2, Section 3.2], see also [5] and [7, Section 3.6.1]. This is the research agenda we wish to pursue with constraint automata, see also [19].
Our contributions.
Our first task is to introduce a class of constraint automata parameterised by concrete domains that accept infinite data trees and the scope of the constraints slightly extends the scope involved in the constraint automata in [19, 20] (Section 3). The constraints involved in the transitions have a simple and natural form (constraints between siblings are allowed) that shall lead to a forthcoming smooth reduction from the consistency problem, though technical difficulties still arise. In order to get -ExpTime-membership of the nonemptiness problem, the concrete domains satisfy (C1.1) the completion property [18, 11] (resp. (C1.1.1) the amalgamation property and (C1.1.2) homomorphism -compactness [13]), (C2) the arity of predicates is bounded, (C3.) the constraint satisfaction problem for the concrete domain is in -ExpTime and (C4) equality is part of the relations. We provide a parameterised complexity analysis that is helpful to characterise then the complexity of the consistency problem for the description logic . More precisely, we design a reduction to the nonemptiness problem for Büchi tree automata, known to be solved in quadratic time, see e.g. [16]. Along the paper, we are particularly interested in determining which conditions are really needed for each part of our investigations.
Then, we design a reduction from the consistency problem for with concrete domains satisfying the above conditions into the nonemptiness problem for constraint automata parameterised by , leading to ExpTime-membership if (C3.1) holds, which is known to be optimal, see e.g. [13, 3]. We mix standard ingredients to translate modal/temporal/description logics into tree automata with a quite natural handling of CD-restrictions. A few complications arise to handle nominals (see e.g. [34] and the notion of guess in [32, Definition 6] about the -calculus with converse, universality modality and nominals), and the fact that concrete features admit partial interpretations. It is notable that we allow slightly more general classes of concrete domains than those in [13] (see Section 2.1 for a brief discussion about the differences). By way of example, we allow more general concrete domain restrictions and finiteness of the set of relations is not always required. Furthermore, we are a bit more liberal with the set of CD-restrictions, which allows us to get rid of the condition JEPD (jointly exhaustive pairwise disjoint), see e.g. [13]. Often, we introduce notions that have counterparts in [13, 3] but tailored to our approach.
Constraint automata allow us to add ingredients and to adapt smoothly the translation, for instance by adding inverse roles while giving up the nominals (as hinted possible in [13, Section 5]), functional role names and predicate assertions (see Section 2.3 and Section 5). The extension with inverse roles, though technically challenging, perfectly illustrates the versatility of our approach. In short, we revisit the complexity results about description logics with concrete domains from [13, 3] by advocating an automata-based approach, while slightly refining some results (use of the completion property) and establishing a few new ones (inverse roles). A forthcoming arXiv report shall contain the missing proofs.
2 Preliminaries: Towards the Consistency Problem for Ontologies
In this section, we introduce the concrete domains and the few assumptions involved in this document. Then, we define the description logics parameterised by .
2.1 Concrete Domains Under Scrutiny
A concrete domain is a relational structure where is a nonempty set and each interprets a predicate symbol of arity . Elements of are written . Let be a countably infinite set of variables. A (Boolean) constraint is an expression following the grammar below:
with a predicate symbol of arity and (repetitions allowed). A valuation is a total function . Satisfaction of atomic formulas is defined by , and extended to Boolean combinations in the usual way. A constraint system is a set of literals of the form either or . We write to denote the set of variables occurring in . Given , we write to denote the subset of made of literals using only variables from the set . A valuation satisfies the system , written , if it satisfies every literal in . The constraint satisfaction problem for , denoted , takes as an input a finite constraint system and asks whether there is a valuation such that .
We assume that the concrete domains satisfy a few properties to guarantee at least decidability of the logical decision problems, and -ExpTime-membership if possible. The concrete domain satisfies the completion property for every finite constraint system and for every valuation with , if satisfies the restriction and is satisfiable, then there is an extension such that and .
A constraint system is complete with respect to some set of predicate symbols and some set of variables no other predicate symbol or variable occurs in and for all of arity and , we have either or (but not both). A concrete domain satisfies the amalgamation property
-
either has a finite set of predicate symbols and for all finite constraint systems , such that and is complete w.r.t. and , we have and are satisfiable (separately) iff is satisfiable,
-
or has an infinite set of predicate symbols and for all finite sets , for all finite constraint systems , built over such that and is complete w.r.t. and , we have ().
Similar definitions about amalgamation can be found in [27, 31, 9, 13, 3]. Note that the involved constraint systems are finite, and unlike [27, 31], we do not assume completeness of the constraint systems, see also the related notion of symbolic type in Section 3.2. Finally, is homomorphism -compact (see e.g. [13]) if every finite of a countable constraint system is satisfiable, then itself is satisfiable.
We are ready to define the main properties satisfied by concrete domains involved herein.
- (C1)
-
The concrete domain satisfies the completion property or (it satisfies the amalgamation property and is homomorphism -compact). (from local to global)
- (C2)
-
There is such that all the relations in have arity bounded by . (bounded arity)
- (C3.)
-
is in -ExpTime (). (-ExpTime CSP problem)
- (C4)
-
contains the equality relation. (equality in the concrete domain)
The condition (C4) is a bit less general than the condition JD (jointly diagonal) from [13, 9] but simpler to check. The completion property has been already considered in the literature [10, 18, 11], sometimes under the term “global consistency”, see e.g. [17, Definition 2.3] and [27]. By way of example, concrete domains satisfying the completion property include , and for some infinite set . The concrete domain RCC8 with space regions in equipped with topological relations between spatial regions [37] also satisfies the completion property, see e.g. [27, Section 2.1] and [18]. This applies also to the Allen’s temporal concrete domain , where is the set of closed intervals and is the family of 13 Allen’s relations [1], see also [27, Section 2]. Observe that RCC8 and Allen’s interval algebra also satisfy (C2), (C3.1) and (C4), see e.g. [27, Section 2]. The completion property being one alternative in the condition (C1) is a natural condition that happens to be sufficient for our needs. However, this excludes that is handled in [15, 23, 22, 20]. A simple property can be already established.
Lemma 1.
If satisfies the completion prop., then it satisfies the amalgamation prop.
The converse implication is not known to hold in general; that is, whether the amalgamation property (or some variant) implies the completion property remains open. More broadly, the exact relationships between the completion property, the amalgamation property, and -compactness are not fully understood. By contrast with [13, 3], observe that the satisfaction of (C1), (C2), (C3.1) and (C4) allows the concrete domains to have an infinite set of relations as in . The condition JEPD from [13] is not required in our framework and (C4) implies JD (jointly diagonal) from [13]. Unlike the completion property in (C1), the second disjunct of (C1) is often assumed in the literature, see e.g. [27, 31] and the ExpTime--admissible concrete domains in [13, 3].
2.2 Reasoning about Ontologies with Concrete Objects
In this section, we define (over the concrete domain ) defined as the description logic from [13, Section 2] (see also [3]) except that the assumptions about may differ and the concrete domain restrictions (a.k.a. CD-restrictions) are defined in a slightly more general way. Let , , , and be countable sets of concept names, role names, individual names and concrete features, respectively. Following the assumptions from [13], a role path is either a concrete feature or the concatenation of a role name and a concrete feature . The set of complex concepts in is defined as follows.
where , , , and is a -constraint built over the variables (not necessarily an atomic formula). The variables bind values retrieved via the paths . The expression is known as a nominal and is interpreted by a singleton, namely the one containing the interpretation of the individual name . For instance, let , and suppose , , and . The concept describes patients younger than 18, while captures individuals older than at least one of their brothers.
A general concept inclusion (GCI) is an expression , where , are concepts. A role assertion (resp. concept assertion) is an expression (resp. ). An ontology is a pair , where is a finite set of GCIs and is a finite set of assertions. As we shall provide complexity analyses, let us briefly describe how the size of ontologies is defined. The size of , written , is defined as the sum of the size of , written , and the size of , written . The size of a TBox is the sum of the sizes of its GCIs, whereas the size of an ABox is defined as the sum of the sizes of its assertions. Assuming that the size of a concept , written , is defined as the sum between the number of its subconcepts and the number of its subconstraints occurring in CD-restrictions, the size of a GCI is the sum of the size of its two concepts. Moreover, the size of a role assertion is defined as one, and the size of a concept assertion is defined as the size of its concept.
An interpretation consists of a nonempty (interpretation) domain (its elements are written ) and an interpretation function such that
-
for all ; for all , for all .
-
is a partial function, for all .
-
Given , denotes either for or for . Such sets might be empty in case is undefined for the involved elements of .
The semantics below is standard, except CD-restrictions admit arbitrary constraints, see also [31, Definition 1].
.
An interpretation satisfies the ontology (written ) for all , for all and for all . The consistency problem for consists in determining for some ontology whether there exists some interpretation that satisfies it. Recall that (resp. ) can be encoded by (resp. ). Herein, we design an automata-based decision procedure for solving the fundamental consistency problem of with a concrete domain satisfying the conditions (C1), (C2), (C3.1), (C4), and get ExpTime-membership. The consistency problem for (without concrete domains) can take advantage of the finite model property, see e.g. [6, Section 4.2], but this property does not hold for . For instance, within , the GCI can be satisfied only by interpretations with infinite domains . As usual, we write to denote without nominals. We find it natural to handle nominals in the language of complex concepts as ontologies admit ABoxes (see also [3]). However, there is a price to pay. It is challenging to handle nominals with an automata-based approach as only one node of the accepted trees should correspond to the interpretation of each nominal. Furthermore, infinite interpretations (see the example above for ) and satisfying lead to interpretations such that has an infinite amount of incoming -edges.
Given a set of individual names, an interpretation satisfies the unique name assumption (UNA) w.r.t. iff for all distinct individual names , we have . Below, we state a standard result that allows us to deal with interpretations satisfying (UNA) only, as we are interested in complexity classes equal or above ExpTime. Indeed, suppose that and be the equivalence relation on (individual names in ) such that iff . We write to denote the equivalence class of . We can build a new ontology as the quotient of by the equivalence relation : in each concept, the nominal is replaced by and each individual name in assertions is replaced by . One can show that is consistent iff there is some equivalence relation on such that can be satisfied by an interpretation satisfying (UNA) w.r.t. . The equivalence classes are viewed as new individual names.
2.3 Beyond with Concrete Domains
We briefly present several ingredients that can be found in description logics, see e.g. [6]. Section 5 is dedicated to showing how the approach developed in Section 4 can be adapted. We write to denote the extension of (without nominals) with inverse roles. The roles are either or where and is equal to the converse of . Herein, inverse roles can be found in restrictions as in and in CD-restrictions as in . We write to denote the extension of with functional role names, see e.g. [24]. We introduce the set of functional role names (a.k.a. abstract features) and the roles in are the role names from . If and is an interpretation of , then is weakly functional. Functional role names can be used anywhere. We may also enrich the set of assertions by allowing in ontologies, expressions stating constraints between the concrete feature values of (predicate assertions are usually restricted to atomic constraints).
3 Tree Global Constraint Automata
In this section, we introduce a class of tree constraint automata parameterised by concrete domains that accept infinite data trees in which every node is labelled by a finite tuple of data values from . This is slightly more general than the automata models from [19], not only because the definition does not assume a fixed concrete domain but more importantly because constraints between siblings are allowed unlike what is done in [19, 20].
3.1 Definitions
Unless otherwise stated, in the rest of this section, we assume that the concrete domain satisfies the conditions (C1) and (C3.) for some (meaning that (C2) and (C4) are not needed). We introduce the class of tree global constraint automata that accept sets of labelled trees of the form for some finite alphabet , for some and . The transition relation of such automata expresses constraints between the values at a node and the values at its children. The automaton is equipped with a Büchi acceptance condition. Formally, a tree global constraint automaton (in short, TGCA) over is a tuple where:
-
is a finite set of locations, are initial locations, are accepting locations, is a finite alphabet;
-
is the branching degree, and the number of registers (a.k.a. variables);
-
is the transition relation where denotes the set of -constraints built over the distinguished registers in . The expression refers to the th register of the th child. Arbitrary registers in are also referred to by .
Runs.
Let be a data tree, with at each node . A run of on is a mapping that maps each node to a transition such that:
-
(i)
The source location of is for all .
-
(ii)
Let be the valuation defined by for all . Then .
-
(iii)
The source location of .
Given a path in starting from , we define to be the set of locations that appear infinitely often as the source locations of the transitions in A run is accepting if all paths in starting from , we have We write to denote the set of data trees for which there exists some accepting run of on . The nonemptiness problem for TGCA, written NE(TGCA), asks whether for some TGCA . Herein, we use Büchi acceptance conditions but such conditions play no essential role in our investigations because we shall always assume that (as in looping tree automata, see e.g. [7, Section 3.6.1]).
3.2 Reduction to Nonemptiness for Büchi Tree Automata
To analyse the complexity of NE(TGCA), we construct a reduction to the nonemptiness problem for Büchi tree automata (BTA), known to be in PTime [35]. Büchi tree automata are TGCA with and no -constraints. Given , we write to denote either the full set of predicate symbols of if finite, or the finite set of predicate symbols from occurring in .
Symbolic types.
We abstract concrete values by symbolic types, following the standard notion of types in first-order languages, see e.g. [30, Section 3.1] and [33]. These are sets of literals that capture all atomic constraints relevant to the current node and its children. A forthcoming notion of projection compatibility ensures the coherence between parent and child types across the tree. Let be the set of atomic formulae of the form for some and . Similarly, let be the set of all literals over , i.e., atomic formulae or their negations. A symbolic type is a set s.t. for every , either or , but not both. Let denote the set of all symbolic types. Symbolic types can be understood as constraints made of conjunctions of its elements built over the registers in . A symbolic type is satisfiable if there is such that . Let denote the set of all satisfiable symbolic types. The properties of satisfiable types that we mainly use are stated in Lemma 2 where means that for the valuation such that and , for all .
Lemma 2 (Three properties about types).
(I) Let . There is a unique satisfiable type such that . (II) For every constraint built over the predicate symbols in and the registers , there is a disjunction logically equivalent to and each belongs to (empty disjunction stands for ). (III) For all distinct types , is not satisfiable.
The proof of Lemma 2 is by an easy verification. We write to denote that for all valuations , if , then . If and satisfies the properties of Lemma 2(II), then can be checked in polynomial time. Let . We say that is projection-compatible with for each and every predicate symbol of arity , and for all tuples , we have: iff . We recall that in a type , registers associated to the values of the children nodes are also present. Hence, projection-compatibility simply reflects the fact that the constraints for such registers in must be compatible with the constraints of the registers in the children types.
Construction of Büchi tree automata.
We now define the Büchi tree automaton that simulates the TGCA using symbolic types. The basic idea consists in abstracting data values in by satisfiable types from . Moreover, the type at a node needs to be compatible with the children’s types since a type expresses constraints between the values at a node and those at its children. This is where projection compatibility plays a crucial role. In this way, an infinite tree accepted by the Büchi tree automaton can be viewed as an infinite constraint system (each node has its own variables coming from local registers) for which satisfiability is required. Generally, additional conditions are needed to guarantee satisfiability, see e.g. [23, 22, 19]. In the case of concrete domains satisfying the condition (C1), importantly, this is all we need as shown below. First, let us define the Büchi tree automaton with the remarkably simple construction below.
-
, , ,
-
contains the transition if (a) , (b) and (c) is projection-compatible with .
To build effectively from , we only need the decidability of to determine the satisfiable symbolic types. We can establish that this construction preserves nonemptiness. Again, apart from the decidability of , only the condition (C1) is required.
Lemma 3 (Soundness).
implies .
The proof does not require much about the concrete domain since it mainly rests on the construction of satisfiable types from tuples made of data values in .
Lemma 4 (Completeness).
implies .
In its proof, essential for our investigations, each disjunct of (C1) leads to a way to construct the valuation on which the data values for the data trees accepted by are defined. If satisfies the completion property, then the valuation is built incrementally while visiting with a breadth-first search. By contrast, assuming the second disjunct of (C1) allows us to define an infinite chain of constraint systems (thanks to the amalgamation property) and then to obtain the existence of as is homomorphism -compact. Today, it is unclear to us what are the exact relationships between these two options; it is not excluded that model-theoretical developments from [31, Chapter 4] could be helpful but we were unable to draw conclusive arguments.
It remains to perform a parameterised analysis of the complexity of the nonemptiness problem for TGCA. We warn the reader that the analysis is rather standard but this needs to be performed with care. Assuming that can be solved in time and the nonemptiness problem for Büchi tree automata can be solved in time for some polynomials and , the nonemptiness problem for TGCA can be solved in time
where is the maximal arity of predicates in and is the maximal size of constraints occurring in . The use of the polynomials ’s is convenient for the above expression.
Theorem 5.
Let be a concrete domain satisfying (C1), (C2) and (C3.1). The nonemptiness problem for TGCA over is in ExpTime.
4 Constraint Automata for Checking Consistency
Below, we reduce the consistency problem for to the nonemptiness problem for TGCA over . Correctness of the reduction only requires that the concrete domain satisfies the condition (C4). As shown in Section 3, the translation from TGCA to BTA requires the satisfaction of (C1) and is decidable. In order to get ExpTime-membership of the consistency problem for , the condition (C2) and (C3.1) are further assumed.
4.1 Preliminaries
Given an ontology , we shall build a TGCA over , such that is consistent iff . Below, we introduce the notions of concept types (similar to Hintikka sets), and (local/global/contextual) abstractions that are finite pieces of information about elements in some interpretation domain . The construction of is finalised in Section 4.2 and the correctness is postponed to Section 4.3.
Normalisation.
A concept is in negation normal form (NNF) if the negation occurs only in front of concept names or nominals. Every concept is logically equivalent to a concept in NNF. In particular, , where , and . This is valid since the constraints in CD-restrictions are closed under negations. Also, every GCI is equivalent to . Hence, we assume a fixed ontology such that all the concepts are in NNF and the GCIs are of the form . This normalisation is standard and harmless for complexity. We write to denote the set of subconcepts occurring in the ontology augmented with the concepts and for all individual names occurring in in assertions and nominals (details omitted). We introduce the following sets: is the set of individual names occurring in assertions/nominals in , is the set of concrete features in and the set of role names in .
Abstractions.
Consistency of the ontology asks for the existence of an interpretation such that . In the automata-based approach, this reduces to the existence of an infinite data tree such that . Such a witness tree represents an interpretation (nodes in roughly correspond to elements of ), so is designed to accept such representations. An accepting run on thus ensures that , viewed as an interpretation, satisfies . In an accepting run on , each node is labelled by a transition , where the location contains some finite symbolic abstraction about the node viewed as an element from the interpretation domain. This is where local, global and contextual abstractions enter into play.
Given an element for some interpretation , the local abstraction of the element in , written , is a triple defined as follows.
-
is the concept type and ,
-
is the activity vector in s.t. is defined, for all ,
-
is the set of symbolic links in such that .
It is not immediate that this notion of local abstraction suffices, but we shall show that it does. Of course, in the forthcoming TGCA , we also make use of the registers to encode the concrete features from interpretations of . By contrast, the global abstractions act as persistent memories relevant for the whole interpretation. Unsurprisingly, they assign to each individual name in a local abstraction; due to a technical reason, we can restrict these to just the concept type and activity vector. Since runs of the automaton cannot revisit nodes, the global abstraction enables to recover the local abstraction of the individual names from from any node. We use a standard notion of types to represent locally consistent sets of subconcepts, similarly to Hintikka sets to prove completeness of propositional logic for tableaux-style calculi, see also [6, Section 5.1.2]. The set of concept types, denoted , consists of all subsets such that
-
1.
; for all concept names , if then ,
-
2.
for all , either or (but never both),
-
3.
if , then and ; if , then or ,
-
4.
for every GCI , we have .
An anonymous concept type is such that . An -type is such that and for all with distinct from , we have (see e.g. the named states in [21, Section 5] and the named types in [13, Section 4]).
An activity vector is a tuple in where the -th component indicates whether the concrete feature (from ) is defined () or not (). The set of activity vectors is written . Since the interpretation of each concrete feature is a partial function, only the registers corresponding to positions where represent meaningful feature values. While the data tree assigns values to all registers uniformly, entries with are ignored when encoding interpretations. A symbolic link is a pair intended to represent that the current element is related to the interpretation of via the interpretation of . The set of symbolic link sets is the powerset . A local abstraction is a triple in . A global abstraction is a function . A location of the forthcoming automaton is structured in such a way that it contains a local abstraction (related to the associated node) and a global abstraction that records a fixed knowledge about the individual names. Such pairs are called contextual abstractions .
Branching degree .
We need to determine a branching degree that allows us to satisfy all kinds of existential restrictions. To do so, we introduce the following values.
-
.
-
.
-
.
The rationale to define is based on the following requirements. For each , one needs one direction to have a witness individual. Similarly, for each , directions are sufficient to get witness values in . Finally, the tree interpretation property for is based on the representation of a forest such that each of its trees corresponds to the unfolding of the interpretation from some individual name in . As this is encoded at the root of the data tree accepted by , the degree should be also at least . So, it makes sense to define as the value ; the soundness proof of Lemma 6 shall confirm this formally.
Correspondence between directions, role names and restrictions.
Once the degree is defined, one needs to establish a discipline to put in correspondence directions in , role names and restrictions. To do so, below, we define the maps and . Indeed, a standard approach consists in booking directions in for each role name in . The map takes care of assigning directions to existential restrictions and to role paths in existential CD-restrictions. By contrast, the map is uniquely determined by and returns a set of directions among to each role name. Such a discipline is required to construct the transitions in as one needs to agree on the directions that are relevant for getting witnesses of a given restriction. We introduce the following sets.
-
contains all the existential restrictions from .
-
contains all the existential CD-restrictions from .
We define the labeling domain as: The global labeling function , that is designed as a bijection, is defined as:
-
, for ,
-
, for .
The definition of the map is provided below. Let .
Dimension and conventions about registers.
The forthcoming automaton accepts infinite data trees and it remains to define before moving to the final steps of the construction. Since contains concrete features, we require at least registers. Though global abstractions are persistent memories, this is not sufficient to handle the values returned by the concrete features for the individual names. This is useful to consider the satisfaction of CD-restrictions requiring as witness individuals those interpreting some individual name in . That is why, we augment the dimension by so that it is possible to carry all over the runs the values of the concrete features for such individuals. Consequently, we set . To use the registers in , we follow conventions that happen to be handy and that diverge slightly from the general notations introduced in Section 3. The distinguished registers referring to values at the current node shall be represented by . Hence, implicitly refers to the value of the concrete feature , if any. Similarly, refers to the value of for the interpretation of the individual name . Furthermore, we use (resp. ) to refer to the value of for the th child (resp. for the individual name ). However, by construction of , we require that is enforced to be equal to as such registers are dedicated to store global values.
4.2 Definition of the Constraint Automaton
Now, we define the TGCA . Each non-root node in a run of the automaton may represent an element of the interpretation domain, but this is not systematic. A node represents a domain element if its location is not the designated sink location – a special marker to identify inactive nodes. In the active case, the location encodes a contextual abstraction as previously defined. By contrast, the root node does not correspond to any domain element. It serves as a technical device to assemble a forest-shaped model into a single data tree: its immediate children within encode the interpretations of the individual names in the ABox (recall we can safely assume (UNA)). The transitions are designed to enforce the semantical properties of the description logic based on the contextual abstractions. Below, we present the definition of the constraint automaton based on the definitions in Section 4.1.
Set of locations and alphabet.
The set is defined as and , where
-
is the set of contextual abstractions, where is the set of global abstractions and the set of local abstractions;
-
\(\varepsilon\)⃝ is a distinguished location used only at the root (root location) and ,
-
is a sink location used to label nodes that represent no domain elements.
The alphabet is ; the automaton does not rely on input symbols – only the structure of the tree and the tuples in matter.
Transition relation.
Before providing the formal definition, let us briefly explain its main principles. Each non-root node in a run is either associated with a contextual abstraction representing a candidate element of the interpretation domain, or is labelled with the sink location . If a node is associated with a contextual abstraction, its concept type encodes the concepts it must belong to in any corresponding interpretation: if a concept appears in the concept type of a node, then the interpreted element is required to satisfy that concept and this creates obligations (see the conditions for general transitions). Role names are interpreted with the help of two kinds of links: (i) direct links to the children, where each direction in is possibly attached to a role name; and (ii) symbolic links connecting a node to the interpretation of individual names from the ABox. These links are used to satisfy CD-restrictions, existential restrictions and value restrictions.
Constraints are evaluated using register values drawn from the current node and its children (as determined by ). The current node stores its own concrete feature values via the registers and also the concrete feature values for the interpretation of the individual names via the registers . These latter values must remain constant during the run, and this is explicitly enforced by the transition relation with the help of the constraints. Activity vectors determine which concrete feature values are defined and guarantee that only the defined values are referred to in the constraints. The global abstraction – common to all nodes labelled by non-sink locations – must remain constant too. Formally, the transition relation is a subset of and contains three kinds of transitions.
- (a) Padding transition.
-
There is a unique padding transition .
- (b) Root transitions.
-
From the root location \(\varepsilon\)⃝, the automaton performs an initialization step by assigning contextual abstractions to the first children, each of which represents the interpretation of an individual name from the ABox. Each such contextual abstraction is of the form . For each individual name , the local abstraction assigned to the -th child must match the corresponding entry in the global abstraction: specifically, the concept type and activity vector must coincide with . In addition, the value of each concrete feature for must be consistently stored in the register at each node, which is treated as a constant throughout the run. This value originates from the local register of the -th child, which represents the interpretation of . Therefore, the consistency condition must hold at that node. These requirements together form the global information consistency check. Beyond this, the local abstraction must correctly reflect the ABox assertions involving .
Formally, root transitions are of the form , where each is a contextual abstraction and is an -type. The constraint is equal to the expression .
The transition must also satisfy the following structural conditions: and for all , , and . From now on, for each individual name , we let , where denotes the concept type and the activity vector associated to via the global abstraction . This notation is well-defined due to the global information consistency check performed by the root transition.
- (c) General transitions.
-
From a location , we need to find witness individuals for the existential restrictions and CD–restrictions occurring in . Each witness can be realized in two ways: either through a child, determined via the branch labeling function , or via a symbolic link in pointing to an individual name. As for value restrictions, the transition must verify that all possible witnesses satisfy the required concept or constraint. For universal CD–restrictions, the constraint must hold across all applicable combinations of registers extracted from those directions and links. General transitions also maintain some global information and are of the form , where satisfies the conditions below.
-
1.
Existential restrictions. For all , there is such that or , is of the form and .
-
2.
Value restrictions. For all , for all with of the form , we have and for all , we have .
-
3.
CD-restrictions. Let and be the sets of existential and universal CD-restrictions in . Let be such a CD-restriction with . For each , we define a set of registers as follows:
-
If , then if , then , otherwise .
-
If , then consists of the values of the feature taken from nodes reachable via the role name , provided the corresponding feature is defined.
Let . If , then , otherwise . The constraint is defined below:
The constraint is uniquely determined by the sequence .
-
-
4.
Global abstraction preservation. For each with , we require .
-
5.
Inactive children. For , if and or and ( or ), then .
-
6.
Anonymity. For such that is of the form , is an anonymous concept type.
Such general transitions are reminiscent of the augmented types in [13, Section 3].
-
1.
4.3 Correctness of the Reduction
It remains to establish that iff the ontology is consistent. Forthcoming Lemma 6 states the left-to-right direction and its proof amounts to design an interpretation from a data tree in with its accepting run. Elements of the interpretation domain are non-root nodes that are not labelled by the sink location, interpretation of the concept names can be read from the concept types, and the interpretation of the concrete features are read from values in the tuples from in the data tree. Requirements on the transitions complete the analysis to guarantee that an interpretation satisfying the ontology is indeed produced.
Lemma 6.
implies is consistent.
Lemma 7.
is consistent with an interpretation satisfying (UNA) implies .
The construction of the TGCA can be done in exponential-time in , since all components – locations, transitions, and constraints – can be generated and assembled in exponential time. By substituting these parameters into the general complexity expression for the nonemptiness check of TGCA yields the main result below.
Theorem 8.
The consistency problem for is in -ExpTime if satisfies the conditions (C1), (C2), (C3.k) and (C4), for any .
As a corollary of the combination of Lemma 6 and Lemma 7, if is consistent, then it admits a forest-like interpretation satisfying it with branching degree bounded by . This provides an alternative to the tree unfolding of the interpretations. Besides, the concrete domain for which the consistency problem is shown undecidable in [31, Proposition 1], has an infinite set of predicate symbols but does not satisfy the notion of amalgamation used in Section 2.1 (see also [31, Example 3]).
5 Extensions
In this section, we consider the additional ingredients described in Section 2.3 and we show how our automata-based approach can be adapted, preserving the ExpTime-membership. Due to lack of space, we only state their main results about functional role names (resp. constraint assertions).
Theorem 9.
The consistency problem for augmented either with constraint assertions or with functional role names is in -ExpTime if satisfies the conditions (C1), (C2), (C3.k) and (C4), for any .
Note that nothing prevents us from using constraint assertions and functional role names in the same logic. Now, let us consider in more detail , see Section 2.3. The roles in are either role names or their inverses . Role assertions involve only role names because inverse role names add no expressivity in such assertions. By convention, we write to denote that the role assertion belongs to . Given a role , we write to denote its inverse, i.e. if and if . Given an ontology for , we write to denote the set of roles occurring in . In the definition of , we remove the parts about nominals. To extend the automaton construction to , the transitions for need to encode access to new witnesses by considering also the edge to the parent node.
Parent abstractions and new contextual abstractions.
A parent abstraction is either a pair with and (encoding unknown parent, incoming direction and activity vectors of the individual names) or a triple . As expected, encodes the role to reach a node from its parent node, is the parent’s concept type and is the parent’s activity vector. The set of contextual abstractions is now defined as the product , where denotes the set of parent abstractions. Contextual abstractions no longer include global abstractions since we gave up the nominals (but the pair contains a bit of global information). Similarly, the local abstractions have no more symbolic links.
Automaton construction for .
We define the TGCA from some ontology as follows, extending the construction in Section 4.2.
-
, where is the number of existential restrictions in . To support the reasoning on the concrete feature values of the parent nodes, the new registers are dedicated to the parent nodes. Consequently, . Unlike what happens in the automata for , the registers dedicated to the individual names are not maintained constant along the run but only used at the nodes (labelled by some location of the form ).
-
(suitable definition for ), , and .
-
The relation is a subset of . As for , we distinguish three kinds of transitions but the general transitions have now two categories. There is still a unique padding transition . In the root transitions , each is of the form with the same requirements as for (except that there is no more global abstractions) but we require that . Furthermore, keeps the same value. There is nevertheless an additional requirement due to the absence of global abstractions: for all , for all and , we have and . The main changes are for the general transitions satisfying the following conditions with .
- (Existential restrictions)
-
For all , , of the form and or and if (new option).
- (Value restrictions)
-
For all , for all with , we have , and if , then if (new requirement).
- (Back-propagation)
-
If , and , then . This is a new condition due to inverse roles.
- (CD-restrictions)
-
Let and be the sets of existential and universal CD-restrictions in . Let be such a CD-restriction with . For each role path , we define as follows.
-
–
If , then if , then else .
-
–
If , then is defined as follows. If , then
Otherwise is of the form , we need to take advantage of the registers dedicated to individual names: .
Let . If , then , otherwise . The constraint is defined below, where the new part expresses the consistency of the registers dedicated to the parent node ( denotes the register at the th child for the parent’s value of ).
-
–
- (Inactive children)
-
Same condition as for .
- (Parent information propagation)
-
For each such that is a contextual abstraction , we require and .
Soundness is shown as for Lemma 10 by extending the interpretation of role names.
Lemma 10.
implies is consistent.
Similarly, completeness is also shown along the lines of the proof of Lemma 7.
Lemma 11.
is consistent with an interpretation satisfying (UNA) implies .
As far as complexity is concerned, the main differences with the construction of for include still bilinear in and , and the presence of parent abstractions. All of this causes no harm and we can establish Theorem 12.
Theorem 12.
The consistency problem for is in -ExpTime if satisfies the conditions (C1), (C2), (C3.k) and (C4), for any .
As shown herein, our developments for can be naturally adapted to , witnessing the robustness of our approach. It is open whether there is an adaptation for the extension with inverse role names and nominals. Indeed, in , the ontology , can be made consistent and for any interpretation satisfying it, has an infinite amount of -successors, which cannot be captured currently with the finite sets . It is not so much the combination of inverse roles and nominals that is problematic, see e.g. the handling of the -calculus with converse and nominals in [32], but the additional presence of CD-restrictions.
6 Conclusion
We have considered a class of concrete domains for which the consistency problem for can be reduced to the nonemptiness problem for constraint automata parameterised by , leading to the ExpTime-membership of the consistency problem (Theorem 8). This follows an automata-based approach, whose versatility allowed us to add ingredients such as inverse roles (while giving up nominals) and functional role names (Section 5). Furthermore, we carefully examined the conditions on the concrete domain to get the ExpTime upper bound. In particular, we have shown that the nonemptiness problem for constraint automata is in ExpTime whenever satisfies the conditions (C1), (C2) and (C3.1) (Theorem 5). The decidability/complexity status of the logics is left open (also evoked in [3, Section 7] for some extension).
References
- [1] J. Allen. Maintaining knowledge about temporal intervals. Communications of the ACM, 26(11):832–843, 1983. doi:10.1145/182.358434.
- [2] F. Baader. Description Logics. In Reasoning Web. Semantic Technologies for Information Systems, 5th International Summer School 2009, Tutorial Lectures, volume 5689 of LNCS, pages 1–39. Springer, 2009. doi:10.1007/978-3-642-03754-2_1.
- [3] F. Baader, S. Borgwardt, F. De Bortoli, and P. Koopmann. Concrete domains meet expressive cardinality restrictions in description logics. In CADE’25, volume 15943 of LNCS, pages 676–695. Springer, 2025. doi:10.1007/978-3-031-99984-0_35.
- [4] F. Baader and P. Hanschke. A scheme for integrating concrete domains into concept languages. In IJCAI’91, pages 452–457, 1991.
- [5] F. Baader, J. Hladik, C. Lutz, and F. Wolter. From Tableaux to Automata for Description Logics. Fundamenta Informaticae, 57(2–4):247–279, 2003. URL: http://content.iospress.com/articles/fundamenta-informaticae/fi57-2-4-08.
- [6] F. Baader, I. Horrocks, C. Lutz, and U. Sattler. An Introduction to Description Logic. Cambridge University Press, 2017.
- [7] F. Baader, I. Horrocks, and U. Sattler. Description logics. In F. van Harmelen, V. Lifschitz, and B.W. Porter, editors, Handbook of Knowledge Representation, volume 3 of Foundations of Artificial Intelligence, pages 135–179. Elsevier, 2008. doi:10.1016/S1574-6526(07)03003-9.
- [8] F. Baader and C. Lutz. Description logic. In P. Blackburn, J. van Benthem, and F. Wolter, editors, Handbook of Modal Logic, pages 757–819. Elsevier, 2006.
- [9] F. Baader and J. Rydval. Using model theory to find decidable and tractable description logics with concrete domains. Journal of Automated Reasoning, 66(3):357–407, 2022. doi:10.1007/S10817-022-09626-2.
- [10] Ph. Balbiani and J.F. Condotta. Computational complexity of propositional linear temporal logics based on qualitative spatial or temporal reasoning. In FroCoS’02, volume 2309 of LNAI, pages 162–173. Springer, 2002.
- [11] A. Bhaskar and M. Praveen. Realizability problem for constraint LTL. Information & Computation, 296:105126, 2024. doi:10.1016/J.IC.2023.105126.
- [12] P. Blackburn, M. de Rijke, and Y. Venema. Modal Logic. Cambridge University Press, 2001.
- [13] S. Borgwardt, F. De Bortoli, and P. Koopmann. The precise complexity of reasoning in with -admissible concrete domains. In DL’24, volume 3739 of CEUR Workshop Proceedings. CEUR-WS.org, 2024.
- [14] J.R. Büchi. On a decision method in restricted second-order arithmetic. In International Congress on Logic, Method and Philosophical Science’60, pages 1–11, 1962.
- [15] C. Carapelle and A.-Y. Turhan. Description Logics Reasoning w.r.t. General TBoxes is Decidable for Concrete Domains with the EHD-property. In ECAI’16, volume 285, pages 1440–1448. IOS Press, 2016. doi:10.3233/978-1-61499-672-9-1440.
- [16] K. Chatterjee and M. Henzinger. An time algorithm for alternating Büchi games. In SODA’12, pages 1386–1399. SIAM, 2012.
- [17] R. Dechter. From local to global consistency. Artificial Intelligence, pages 87–107, 1992.
- [18] S. Demri and D. D’Souza. An automata-theoretic approach to constraint LTL. Information & Computation, 205(3):380–415, 2007. doi:10.1016/J.IC.2006.09.006.
- [19] S. Demri and K. Quaas. First steps towards taming description logics with strings. In JELIA’23, volume 14281 of LNCS, pages 322–337. Springer, 2023. doi:10.1007/978-3-031-43619-2_23.
- [20] S. Demri and K. Quaas. Constraint automata on infinite data trees: From CTL(Z)/CTL*(Z) to decision procedures. Logical Methods in Computer Science, 21(2):16:1–16:79, 2025. doi:10.46298/LMCS-21(2:16)2025.
- [21] S. Demri and U. Sattler. Automata-theoretic decision procedures for information logics. Fundamenta Informaticae, 53(1):1–22, 2002. URL: http://content.iospress.com/articles/fundamenta-informaticae/fi53-1-01.
- [22] N. Labai. Automata-based reasoning for decidable logics with data values. PhD thesis, TU Wien, May 2021.
- [23] N. Labai, M. Ortiz, and M. Simkus. An Exptime Upper Bound for with integers. In KR’20, pages 425–436. Morgan Kaufman, 2020.
- [24] C. Lutz. NEXPTIME-complete description logics with concrete domains. In IJCAR’01, volume 2083 of LNCS, pages 46–60. Springer, 2001. doi:10.1007/3-540-45744-5_5.
- [25] C. Lutz. The Complexity of Description Logics with Concrete Domains. PhD thesis, RWTH, Aachen, 2002.
- [26] C. Lutz. Description logics with concrete domains—a survey. In Advances in Modal Logics Volume 4, pages 265–296. King’s College Publications, 2003.
- [27] C. Lutz and M. Milicić. A Tableau Algorithm for Description Logics with Concrete Domains and General Tboxes. Journal of Automated Reasoning, 38(1-3):227–259, 2007. doi:10.1007/S10817-006-9049-7.
- [28] M. Marx. Complexity of modal logic. In P. Blackburn, J. van Benthem, and F. Wolter, editors, Handbook of Modal Logic, pages 139–179. Elsevier, 2006.
- [29] V. Pratt. Models of program logics. In FoCS’79, pages 115–122, 1979.
- [30] I. Pratt-Hartmann. Fragments of First-Logic. Oxford University Press, 2023.
- [31] J. Rydval. Using Model Theory to Find Decidable and Tractable Description Logics with Concrete Domains. PhD thesis, Dresden University, 2022.
- [32] U. Sattler and M. Vardi. The hybrid mu-calculus. In IJCAR’01, volume 2083 of LNAI, pages 76–91. Springer, 2001.
- [33] L. Segoufin and S. Toruńczyk. Automata based verification over linearly ordered data domains. In STACS’11, pages 81–92, 2011.
- [34] S. Tobies. The complexity of reasoning with cardinality restrictions and nominals in expressive description logics. Journal of Artificial Intelligence Research, 12:199–217, 2000. doi:10.1613/JAIR.705.
- [35] M. Vardi and P. Wolper. Automata-theoretic techniques for modal logics of programs. Journal of Computer and System Sciences, 32:183–221, 1986. doi:10.1016/0022-0000(86)90026-7.
- [36] M.Y. Vardi. Automata-theoretic techniques for temporal reasoning. In P. Blackburn, J. van Benthem, and F. Wolter, editors, Handbook of Modal Logic, pages 971–989. Elsevier, 2006.
- [37] F. Wolter and M. Zakharyaschev. Spatio-temporal representation and reasoning based on RCC-8. In KR’00, pages 3–14, 2000.
