Stream-based reasoning systems process data stemming from different sources that are received over time. In this kind of applications, reasoning needs to cope with the temporal dimension and should be resilient against inconsistencies in the data. Motivated by such settings, this paper addresses the problem of handling inconsistent data in a temporal version of ontology-mediated query answering. We consider a recently proposed temporal query language that combines conjunctive queries with operators of propositional linear temporal logic (LTL), and consider these under three inconsistency-tolerant semantics that have been introduced for querying inconsistent description logic knowledge bases. We investigate their complexity for temporal and knowledge bases. In particular, we consider two different cases, depending on the presence of negations in the query. Furthermore, we complete the complexity picture for the consistent case. We also provide two approaches toward practical algorithms for inconsistency-tolerant temporal query answering.
For applications that rely on sensor data, such as context-aware applications, ontologies can enrich and abstract the (numerical) stream data by means of background knowledge. This richer view on the data often results in more query results than over the data alone. Since the collected data usually provides an incomplete description of the observed system, the closed world assumption employed by database systems, where facts not present are assumed to be false, is not appropriate. Most applications that rely on sensor streams observe some kind of running system over time. In order to be able to react to the behaviour of the observed system, they need to employ some representation of temporal information and a query mechanism that can reference this temporal information. If the sources of the collected data are not reliable, as it might be in case of faulty sensors, the internal representation of the observations may contain inconsistencies. In such cases, query mechanisms that rely on logical reasoning are effectively useless, as everything would follow from an inconsistent knowledge base. As a counter measure to this effect, inconsistency-tolerant semantics for answering ontology-mediated queries have been devised. In this paper, we investigate combinations of inconsistency-tolerant and temporal query answering w.r.t. ontologies. This setting is fairly abstract and deliberately neglects implementation details as it provides foundations on the combination of three aspects vital to most stream reasoning applications. First, stream reasoning requires background knowledge either on the streams used or on the context in which the information provided by the streams is to be handled. Both kinds of background knowledge can be represented by ontologies and be exploited by ontology reasoning systems. Second, stream reasoning inherently has to cope with the temporal dimension. This dimension is given by the sequence of observations that individual items in the streams provide. Thus, traditional reasoning services that are oblivious of the temporal dimension are hardly of use to stream reasoning applications. Naive combinations of such atemporal reasoning services can compute some forms of temporal consequences, but these combinations need not be complete and thus could miss consequences. To stream reasoning applications relying on such ad-hoc systems, it is not discernible when the naive reasoner does or does not provide a reliable answer. Third, and most importantly, the different streams or data sources need not be free of errors due to the methods by which the data is gathered or provided to the system. Moreover, an automatic combination of open stream sources to which a stream reasoning system can subscribe simply cannot guarantee a consistent combination of such sources. Thus, in general, the combination of the data used by a stream reasoning system can simply contain contradictory information. The combination of these three aspects is so far not investigated in the literature. This is why our setting abstracts from many application specific details and variations of stream reasoning systems, in order to concentrate on the combination of the three fundamental conditions inherent to most such systems. Our goal is to provide an initial orientation for selecting between the many design choices by which each of these factors can be addressed in a stream reasoning system, such as expressivity of the ontology and query language, treatment of temporal information, and different inconsistency-tolerant semantics. To this end we map out the landscape of the computational complexity for many combinations of the three design factors for stream reasoning systems in this paper. In preparation for this, we examine the three design aspects in more detail.
In many stream reasoning systems, the collected data is transformed into an abstract logical representation, and situation recognition is performed by some kind of logical inference over the abstract logical representation. There are stream reasoning approaches based on rules, such as answer set programming [8,10,31], (datalog) rules and approaches based on ontology languages [6,19,24,47]. The ontology-based approaches mostly employ the framework of ontology-mediated queries, where forms of conjunctive queries are answered over data that is enriched by an ontology, to perform situation recognition. The ontology languages that are investigated for situation recognition are usually those where reasoning is of lower computational complexity in order to obtain systems with low execution times.
In this paper, we investigate the lightweight description logics (DLs) and , for which answering conjunctive queries is tractable (respectively in P and w.r.t. the size of the data). The low complexity for query answering in made it the choice for the OWL 2 QL profile [45] in the latest version of OWL [46], the W3C-standardized ontology language for the Semantic Web. For similar reasons, the logic was picked as the core of the OWL 2 EL profile. Both and admit to use database systems to answer conjunctive queries and are thus good candidates for implementing ontology-based stream reasoning. In , the query can be rewritten using the information from the ontology such that the resulting query can be evaluated directly on the data, i.e. stored in a database [26]. For query answering in , there are several approaches. In the combined approach [41] the data is augmented in a query-independent way to build a canonical model by adding information form the terminology. The query is then evaluated over this model and unsound answers are filtered out. Alternatively, a translation to datalog variants can be used [50] for query answering in dialects.
In stream reasoning approaches in general, the temporal information is often represented by associating data with the time point at which it was collected. Regarding the language in which queries can be formulated, many variations that capture the temporal aspect have been studied in recent research [8–10,47]. Window-based approaches admit to concentrate on recent continuous substreams when answering queries over the data, and are the most prominent in implemented systems [8,10,47]. Ontology-based approaches mostly cover classical temporal logics such as linear temporal logic (LTL) [48] (see [2,4,6,18,34]) or metric variants of temporal logics [5,23] to enrich the query language. For a recent overview on temporal ontology-mediated querying see [3,5]. Note that window-based and ontology-based approaches can be combined. For example, it might often be convenient to first extract a time window of interest and then apply ontology-based query answering to its content. Or alternatively, it is possible to refer to subsequences of the time line using LTL operators, though with a semantics that differs from a standard window operator (see Section 2 for an example).
Ontology-based approaches for stream reasoning often admit the use of temporal operators only in the query language and use classical ontologies without any temporal operators together with sequences of datasets. Each dataset in such a sequence contains data collected at the same time point. The ontology together with the sequence of datasets constitute the temporal knowledge base. Queries can then refer to the different time points by means of temporal operators. This kind of setting has been intensively investigated for temporal conjunctive queries, that is, queries with temporal operators from LTL appearing in front of Boolean combinations of atoms, for expressive DLs in [6,7], for in [19], and for in [20]. We base our study in this paper on this general setting.
For stream reasoning systems, erroneous data can be a severe problem, as for instance pointed out in [43]. If inconsistencies arise in the knowledge base, the logical reasoning mechanisms are rendered useless. There are several directions of research to cope with this problem. While some employ non-monotonic reasoning techniques [44,49], others try to resolve the inconsistencies directly [36] or perform reasoning with respect to inconsistency-tolerant semantics (see [13] for a recent overview). We follow the latter road, since the techniques developed there are tailored to ontology-mediated queries and often of lower complexity than the other approaches for resolving inconsistencies.
A prominent approach for inconsistency-tolerant reasoning is to consider repairs of the knowledge base, i.e., maximal consistent subsets of the data, and then to perform query answering with respect to these subsets. Arguably the most natural and well-known inconsistency-tolerant semantics is the AR semantics [37,39], inspired by consistent query answering in the database setting [11], which considers the queries that hold in every repair. However, AR query answering is intractable even for very simple ontologies [12], which leads the authors of [37,39] to propose an approximation of AR tractable for , namely the IAR semantics, which queries the intersection of the repairs. Beside its better computational properties, this semantics is more cautious, since it provides answers supported by facts that are not involved in any contradictions. It may therefore be interesting in our setting when the observed system should change its behaviour only if some situation has been recognized with a very high confidence. Finally, the brave semantics [16] returns every answer that holds in some repair, so is supported by some consistent set of facts. This less cautious semantics may be relevant for context recognition, when critical situations must imperatively be handled.
For the two DLs to be investigated in this paper, answering of (atemporal) conjunctive queries under these inconsistency-tolerant semantics has already been investigated for in [16,37–39] and for in [13,51]. Attention has then turned to the problem of designing algorithms and implementing these alternative semantics. Most work has focused on the IAR semantics and dialects of DL-Lite, due to the aforementioned tractability result [39,52,54]. A notable exception is the system, which implements all three mentioned semantics—AR, IAR and brave—for knowledge bases [14,15].
So far, inconsistency-tolerant semantics have not been investigated in combination with temporal reasoning. In this paper, we lift inconsistency-tolerant semantics to the case of answering temporal conjunctive queries over lightweight DL temporal knowledge bases.
Contributions
This article extends the conference paper [21] on temporal query answering in over inconsistent data, where the complexity of answering queries with LTL operators, but without negation, over temporal knowledge bases was investigated. The considered ontologies admit the use of rigid predicates, which are predicates that do not change their interpretation over time. The initial results were obtained for the three inconsistency-tolerant semantics AR, IAR and brave and with respect to three cases of rigid predicates: no rigid predicates, rigid concepts only, and rigid concepts together with rigid roles.
Compared to the conference version, the present article includes new complexity results (all results for , as well as some results for ). It also extends the set of temporal operators, distinguishing bounded and unbounded variants of the future LTL operators, in order to cover the two different settings that have been investigated for temporal query answering in the literature, where temporal knowledge bases are interpreted w.r.t. finite or infinite sequences of interpretations. Furthermore, we investigate both cases: the one where negation is admitted in the query language and the one where it is not.
The complexity upper bounds are often obtained by non-deterministic procedures that require, for instance, to guess the right repairs which may not be feasibly computed in practice. Thus algorithms that lend themselves to implementation are still to be devised. We make two contributions toward practical algorithms for temporal inconsistency-tolerant query answering. The first is a polynomial reduction of reasoning in the presence of rigid predicates to reasoning without such predicates by propagating the rigid facts in the sequence of datasets. The second is to identify cases where in the absence of rigid predicates the well-known methods for classical temporal query answering and (atemporal) inconsistency-tolerant query answering can straightforwardly be combined. We show that for the IAR semantics, this yields a sound and complete algorithm. For the AR semantics, such a combination of the algorithms always yields a sound approximation, and additionally yields a sound and complete procedure if the query contains only a restricted set of operators.
This paper is structured as follows. In the next section, we introduce the basic notions of DLs, query answering, inconsistency-tolerant semantics for atemporal knowledge bases and the temporal setting. Furthermore, we discuss known complexity results for both inconsistency-tolerant and temporal query answering in the logics considered. In Section 3, we lift the introduced inconsistency-tolerant semantics to temporal query answering over inconsistent data. Section 4 gives an overview over the complexity results obtained. General versions of algorithms for testing (non-)entailment of temporal conjunctive queries under the different semantics are described in Section 5 in preparation of the complexity analysis. Section 6 shows data and combined complexity of inconsistency-tolerant temporal query answering for and for the case where the query language admits negation. In Section 7, we complete the complexity picture of temporal query answering under classical semantics by investigating the case where the query does not contain negation. We then built on these results to provide the complexity of inconsistency-tolerant temporal query answering for queries without negation in Section 8. Finally, Section 9 investigates two approaches for practical implementations that allow to employ well-known methods. The article finishes with a section on conclusions and future work.
To improve readability, some of the proofs have been moved to the appendix and are only sketched in the main text.
Preliminaries
We briefly recall the syntax and semantics of DLs and the three inconsistency-tolerant semantics that we consider, and then we introduce our setting of temporal query answering.
Syntax. A DL knowledge base (KB) consists of an ABox and a TBox , both constructed from three countably infinite sets: a set of concept names (unary predicates), a set of role names (binary predicates), and a set of individual names (constants). The ABox (dataset) is a finite set of concept assertions and role assertions, where , , . The TBox (ontology) is a finite set of axioms whose form depends on the particular DL.
In , TBox axioms are either concept inclusions or role inclusions, built according to the following syntax, where and :
Inclusions of the form or are called positive inclusions (PI), those of the form or are called negative inclusions (NI).
In , the TBox contains concept inclusions of the form , where and are built according to the following syntax, where and :
An inclusion of the form can also be written in the form of a negative inclusion .
Semantics. An interpretation is a tuple of the form , where is a non-empty set and maps each to , each to , and each to . We adopt the unique name assumption, i.e., for all , we require if . The function is straightforwardly extended to general concepts and roles, e.g., , , , , , .
An interpretation satisfies an inclusion if ; it satisfies (resp. ) if (resp. ). We call a model of a KB if satisfies all axioms in and all assertions in . A KB is consistent if it has a model, and we say that an ABox is -consistent (or simply consistent if is clear from the context), if the KB is consistent.
Queries. A conjunctive query (CQ) takes the form , where ψ is a conjunction of atoms of the form or , with individual names or variables from . We call the variables in the free variables in q. A CQ is called Boolean (BCQ) if it has no free variables (i.e., ). A BCQ q is satisfied by an interpretation , written , if there is a homomorphism π mapping the variables and individual names of q into such that: for every , for every concept atom in ψ, and for every role atom in ψ. A BCQ q is entailed from , written , iff q is satisfied by every model of . Given a CQ q with free variables and a tuple of individuals , is a certain answer to q over if , where is the BCQ resulting from replacing each in q by .
Inconsistency-tolerant semantics. A repair of is an inclusion-maximal subset of that is -consistent. We consider three semantics based on repairs that have been previously introduced in the literature [16,37,39]. A tuple is an answer to q over under
AR semantics, written ,
iff for every repair of ;
IAR semantics, written ,
iff where is the intersection of all repairs of ;
brave semantics, written ,
iff for some repair of .
Figure 1 summarizes the complexity of BCQ entailment under the different semantics for and . Data complexity is measured in the size of the ABox only, while combined complexity is measured in the size of the whole KB and the query. When complexity is measured w.r.t. the size of the KB (ABox and TBox), it is called KB complexity. For and , CQ answering under the classical semantics is in P w.r.t. KB complexity. We refer to Section 4 for a reminder on the definitions of the different complexity classes that appear in this work.
Complexity of BCQ entailment in [16,37] and [13,51].
Temporal query answering. We now present our temporal framework inspired from [6] and [18].
(TKB).
A temporal knowledge base (TKB) consists of a TBox and a finite sequence of ABoxes . An infinite sequence of interpretations over a fixed non-empty domain Δ (constant domain assumption) is a model of iff for every , is a model of , for every , is a model of , and for every and all , (rigidity of individual names). Rigid predicates are elements from the set of rigid concepts and the set of rigid roles. A sequence of interpretations respects rigid predicates iff for every and all , . A TKB is consistent if it has a model that respects rigid predicates. A sequence of ABoxes is -consistent, or simply consistent, if the TKB is consistent.
The following TKB gives information useful to monitor a cluster of servers. The TBox defines that a server is overloaded when it executes a process with an increasing workload while its CPU is already maximally utilized. The sequence of ABoxes records information on a server s. The set of rigid roles is , which models the fact that the CPU of a server does not change over time.
It is sometimes convenient to represent a sequence of ABoxes as a set of assertions associated with timestamps, which we call timed assertions: then becomes .
A rigid concept is a concept which only uses rigid predicates. A rigid assertion is of the form with or with . We distinguish three cases depending on which predicates can be rigid: in the first case, we have no rigid predicates ( and ), in the second case, we do allow only for rigid concepts ( and ), and in the last case, we have both, rigid concepts and rigid roles ( and ). Because rigid concepts can be simulated with rigid roles using a pair of concept inclusions of the form , , these three cases cover all interesting combinations.
In the remainder of the paper, we always use n to denote the maximal timestamp of a TKB.
(TCQ).
Temporal conjunctive queries (TCQs) are built from CQs as follows: each CQ is a TCQ, and if and are TCQs, then so are (negation), (conjunction), (disjunction), (next), (bounded next), (strong previous), (weak previous), (always), (bounded always), (always in the past), (eventually), (bounded eventually), (some time in the past), (until), (bounded until), and (since). We further may use as a shortcut for .
We impose the constraint that the past operators , , and cannot be nested under the unbounded future operators , □, ♢ and (in second position) (see discussion later in this section).
The following TCQ returns the list of servers which have been overloaded at least twice.
Note that we can modify our query to speak about a window of 10 time units as follows:
where abbreviates a sequence of ten operators. Differently to window operators found in other settings however, subexpressions within such a window can refer to time points outside this window.
Given a TCQ ϕ, we refer to the TCQs that occur in ϕ as subformulas of ϕ. We sometimes use the notion of the propositional abstraction of a Boolean TCQ ϕ, which is the propositional LTL formula obtained by replacing each BCQ in ϕ by a propositional variable (e.g., the propositional abstraction of is the propositional LTL formula ).
(Choice of operators).
The additional LTL operators (weak until), (weak since), (release), and (past release) can be expressed by our set of operators as follows:
We will consider in Sections 7, 8 and 9 a special setting where TCQs do not contain negation symbols, which sometimes leads to a lower computational complexity. For this reason, we did not introduce as a shortcut for , as it is often done in the literature, but instead treat the operators □ and as native members of our query language. Similarly, since the top and bottom concepts ⊤ and ⊥ are not allowed in every DL, ♢ (resp. ) cannot be defined using (resp. ) as usual in LTL (), unless we allow for negation (where we can express using ). We thus keep all these operators in the set we consider.
Note also that since disjunctions are allowed, TCQs could be defined with unions of conjunctive queries (UCQs) instead of CQs. We use CQs for simplicity.
(TCQ answering).
Given a TCQ ϕ with free variables and a tuple of individuals , denotes the Boolean TCQ (BTCQ) resulting from replacing each by . A tuple is an answer to ϕ in a sequence of interpretations at time point p iff , where the satisfaction of a BTCQ ϕ by a sequence of interpretations is defined by induction on its structure as shown in Table 1. A tuple is a certain answer to ϕ over at time point p, written , iff for every model of that respects rigid predicates.
Satisfaction of BTCQs by a sequence of interpretations
It follows from the semantics of TKBs and TCQs that s is a certain answer to the TCQ ϕ of Example 2.4 over the TKB of Example 2.2 at time point 2 and at time point 1, but not at time point 0. Note that the rigidity of the role is crucial to get this answer.
In addition to the standard LTL past and unbounded future operators, we introduce four bounded future operators that mimic the semantics based on finite sequences of interpretations used in [18] and similar to that of LTL on finite traces (see e.g., [29]). Indeed, while the standard way of interpreting TKBs is based on infinite sequences of interpretations, it can be relevant to limit the scope of querying to the known time points, especially in the context of data streams. For instance, a user may want to ask whether a server has been running some process since it started (), rather than whether it will continue to run this process forever. Moreover, we will see in Section 9.1 that using the bounded semantics can be of practical interest, since it allows us to reduce TCQ answering in the presence of rigid predicates to TCQ answering without rigid predicates. We choose to keep both unbounded and bounded versions of future operators to cover the two settings that have been previously studied for TCQ answering.
The constraint that TCQs should not contain past operators in the scope of unbounded future operators allows us to take advantage of the fact that a TKB entails the same BCQs for every time point to get a lower complexity in the case where there is no negation in the query. Indeed, in this case, the unknown future () can be entirely summarized in one time point . This will also be useful to obtain the data complexity upper bound of brave semantics in the case where there are neither rigid predicates present nor negation in the queries. Moreover, it turns out that for some cases in our analysis, this restriction has no impact on our results. Indeed, [18] shows that Gabbay’s separation theorem [30] can be used to rewrite an LTL formula ϕ containing bounded operators into a logically equivalent LTL formula that is a Boolean combination of pure-past and pure-future formulas, although with an exponential blow-up. It follows that the restriction we impose does not have any influence over the data complexity of BTCQ entailment, as long as negation is allowed in the query. Moreover, since past operators can still appear in the scope of bounded future operators, all time points that refer to observations having been made sofar () can be referenced by the query language. This query language can thus still express most situations that might be meaningful to detect.
It follows from the definition of certain answers that TCQ answering can be straightforwardly reduced to BTCQ entailment (using polynomially many tests w.r.t. data complexity and exponentially many tests w.r.t. combined complexity). For this reason, we focus on the latter problem.
Figure 2 summarizes the complexity of BTCQ entailment for and in the different cases depending on which kind of predicates are rigid. Our setting is slightly different from those of [19] and [20], because we have additional bounded operators and the restriction that past operators cannot be nested under unbounded future operators. However, the results shown in those papers apply to our setting. Indeed, the proofs for the lower bounds do not use past operators nested under future operators, and for the upper bounds, we argue that it is possible to reduce the entailment of a BTCQ ϕ that contains bounded operators to the entailment of a BTCQ without bounded operators independently from the size of the TKB and linearly w.r.t. the query size. To do that, we add an assertion to the last ABox of the sequence, where and a are both fresh names, and rewrite the query without unbounded operators using the following equivalences:
We extend the three inconsistency-tolerant semantics to temporal query answering. The main difference to the atemporal case is that in the presence of rigid concepts or roles, a TKB may be inconsistent even if each KB is consistent. Indeed, in this case, there may not be a sequence of interpretations such that is a model of for every and which also respects rigid predicates. That is why we have to consider as repairs the -consistent sequences of subsets of the initial ABoxes that are component-wise maximal.
(Repair of a TKB).
A repair of a TKB is a sequence of ABoxes such that is a maximal -consistent subset of . We denote the set of repairs of by .
The next example illustrates the impact which rigid predicates can have on repairs.
Consider the TKB . The TBox expresses that web servers and application servers are two distinct kinds of servers, and the ABoxes provide information about a server a that executes two processes b and c.
Assume that no predicate is rigid. The TKB is inconsistent because the timed assertions and violate the negative inclusion in . Specifically, and cannot both be true at time point 1. It follows that has two repairs that correspond to the two different ways of restoring consistency: and , where
Now assume that is rigid. There is then a new reason for being inconsistent: the timed assertions and violate the negative inclusion of due to the rigidity of , which implies that and should be both entailed at time point 0. Therefore, has now the two repairs and , where
Note that even though is maximal (adding to renders the TKB inconsistent), is not a repair of , because it is not maximal.
We extend the semantics AR, IAR, and brave to the temporal case in the natural way by regarding sequences of ABoxes.
(AR, IAR, brave semantics for TCQs).
A tuple is an answer to a TCQ ϕ over a TKB at time point p under
AR semantics, written ,
iff for every repair of ;
IAR semantics, written ,
iff ,
with for all ;
brave semantics, written ,
iff for some repair of .
The following relationships between the semantics, which already hold in the atemporal case, are implied by their definition:
In the following example, we illustrate the effect of the different semantics in the temporal case.
Consider the following three temporal conjunctive queries.
If there are no rigid predicates, the intersection of the repairs is , with and . We have , because in every model of the intersection of the repairs a executes b at time point 0 and c at time point 1. For , , since every model of every repair assigns a to at time point 0 and to either (in models of ) or (in models of ) at time point 1. However, . Finally, , because no repair entails at time point 0.
If is rigid, the intersection of the repairs is with and . So, still . Since every model of every repair assigns a to at time points 0 and 1 (either because a is a web server or because a is an application server), , but . Finally, , because every model of assigns a to at any time point by rigidity of , but .
We conclude this section by pointing out some characteristics of the case without rigid predicates that will be useful later. If there are no rigid predicates, the interpretations of a model of that respects rigid predicates are independent, besides the interpretation of the individual names. We thus obtain the following proposition.
If, then a TKBis consistent iff everyis consistent. Moreover, ifis consistent, for every,is a model ofiff there exists a modelofsuch that.
If , a sequence of interpretations is a model of that respects rigid predicates iff it is a model of . It follows that is consistent iff there exists such that for every , is a model of , for every , is a model of , and for every and all , . This already establishes one direction of the proposition. We show that also the other direction holds.
Assume that every is consistent, i.e., every has a model. Let be any fixed index and be a model of . Since we adopt the unique name assumption and is unbounded, is an infinite set. Moreover, for every , since is finite, by the Löwenheim–Skolem theorem, there exists a model of such that is countable. Thus can be mapped to by an injective function . For every i, we can then build a model of such that . For this, let and select some domain element . We define a mapping by setting for and . It remains to set for all , , and . Since for every , there exists a bijection such that for all , .
Using these bijections, we can construct a model of based on the interpretations as follows. For every , , , and for every such that , , where is defined by for every , for every , and . Note that this construction ensures for all . Furthermore, one easily establishes that for all , is a model of , and for , is a model of . We obtain that is a model of such that . □
It follows that, if , CQs can be answered at time point p by answering them over the KB .
If, then for every BCQand,iff.
iff for every model of that respects rigid predicates, . By Proposition 3.5, this is the case iff for every model of , , which is equivalent to . □
Complexity analysis overview
In the next four sections, we investigate the complexity of inconsistency-tolerant BTCQ entailment in and . Apart from the different DLs, we also consider two settings of query languages: in the first setting, all TCQs as defined in Section 2 are considered, in the second setting, we analyze the complexity for TCQs that do not use the negation operator. Furthermore, we investigate complexity depending on whether rigid symbols are present or absent and which of the 4 semantics are used (classical, AR, IAR or brave). All these investigations are carried out for combined or data complexity.
For classical semantics, some complexities have been investigated earlier for the different settings we consider. For the case where negations are allowed in the queries, the complexity of BTCQ entailment under the classical semantics has been studied in [19] for and in [20] for (cf. Section 2, Fig. 2). Furthermore, it has also been shown in [17,18] that in , TCQs without negation (and with a bounded future semantics) can be rewritten into FO-queries for temporal databases, but this was shown only in a restricted setting without rigid names and only for rooted TCQs. In this case, rootedness of a CQ means that it contains at least a constant or an answer variable and all its terms are connected via chains of role atoms. A TCQ is rooted if every CQ in it is rooted.
Most of our complexity upper bounds are based on a set of general algorithms for BTCQ entailment under the different inconsistency-tolerant semantics, which we present in Section 5. Those allow us to obtain complexity upper bounds for the different settings based on the complexity of BTCQ entailment under classical semantics, on the complexity of recognizing repairs, and on the complexity of consistency checking. In Section 6, we establish the complexity of these basic tasks, and give complexity results for our two DLs of interest, and , regarding both data and combined complexity. In the cases where the general algorithms are insufficient to give tight bounds, we try to provide specialized algorithms.
We then restrict the query language and study the complexity of the entailment of BTCQs without negation. In Section 7, we first investigate this case under classical semantics, and observe that in some cases, disallowing negation leads to lower worst case complexities, even if we alleviate the limitations imposed in [17,18]. In Section 8 these lower complexities allow us to also improve the complexity bounds for inconsistency-tolerant reasoning when there is no negation in the TCQs. Furthermore, we take advantage of the absence of negation to tighten an upper bound for brave semantics without rigid predicates.
Synopsis of complexity classes. We recall the definitions of the complexity classes that appear in the following sections.
P: problems solvable in polynomial time.
NP: problems solvable in non-deterministic polynomial time.
coNP: problems whose complement is in NP.
: problems solvable in polynomial time with at most logarithmically many calls to an NP oracle.
: problems solvable in non-deterministic polynomial time with an NP oracle.
: problems whose complement is in .
: problems that can be solved by a uniform family of circuits of constant depth and polynomial size, with unbounded-fanin AND and OR gates. We have .
ALogTime: problems solvable in logarithmic time by a random access alternating Turing machine. We have .
PSpace: problems solvable in polynomial space.
ExpTime: problems solvable in exponential time.
NExpTime: problems solvable in non-deterministic exponential time.
coNExpTime: problems whose complement is in NExpTime.
For the remainder of this paper, is a DL which is interpreted w.r.t. standard interpretations, as defined in Section 2. We will consider in particular the cases = and = . Furthermore, we assume to be the TKB we evaluate our query against, and ϕ to be the considered query.
General algorithms for inconsistency-tolerant BTCQ entailment
Our complexity bounds are based on a set of general algorithms for deciding BTCQ entailment under the different semantics, which are inspired from known algorithms for inconsistency-tolerant BCQ entailment in the atemporal case (see e.g., [51]). Depending on the semantics under consideration, it might be more natural to describe either a procedure for entailment or one for non-entailment, which is why these algorithms focus on different directions of the problem.
Non-entailment under AR semantics. The procedure decides whether ϕ is not entailed by at time point p under AR semantics, and is defined as follows.
Guess a sequence of ABoxes.
Verify that is a repair of and that .
It is common to focus on non-entailment when studying the complexity of AR semantics, since this procedure needs to consider only one repair instead of all of them.
Entailment under brave semantics. The procedure decides whether ϕ is entailed by at time point p under brave semantics, and is defined as follows.
Guess a sequence of ABoxes.
Verify that is a repair of and that .
Non-entailment under IAR semantics. The procedure decides whether ϕ is not entailed by at time point p under IAR semantics, and is defined as follows.
Guess
a set of timed assertions, together with
m subsets of the data such that for every , .
Verify that
for every , is a repair of , and
.
Note that , Step 2(a) therefore has to verify only a linear number of repairs. We show that the algorithm decides non-entailment under IAR semantics. Indeed, if for every there exists a repair of that does not contain , then is not in the intersection of the repairs of . Thus is a superset of the intersection of the repairs of . It follows that if , then . For the other direction, assume that , and let . For each , there exists a repair of that does not contain the timed assertion , and , .
Similarly to the AR case, we use this procedure for non-entailment instead of a procedure for entailment. Deciding non-entailment allows us to consider a linear number of repairs instead of all of them, which can be exponentially many. However, for the IAR semantics, a direct procedure for IAR entailment is useful for showing combined complexity results for the DLs we consider. This procedure is based on the computation of the set of timed assertions that belong to some minimal inconsistent subset of the TKB.
Data [left] and combined [right] complexity of BTCQ entailment for BTCQs with negations. All complexities are tight, except those preceded by “in”, which are upper bounds. the results for the classical semantics are shown in [20] for and in [19] for .
Entailment under IAR semantics. We give an alternative procedure for IAR, , which decides whether ϕ is entailed under IAR semantics at time point p.
For every , check whether belongs to a minimal inconsistent subset of by asking an oracle whether there exists a -inconsistent set of timed assertions such that is consistent.
Call the oracle to determine whether ϕ is entailed at time point p by the TKB from which all timed assertions that belong to some minimal inconsistent subset have been removed.
We show that the intersection of the repairs of is obtained by removing the minimal inconsistent subsets of . Let be a minimal inconsistent subset of and . Since is consistent, is not in the repairs that contain . In the other direction, if a timed assertion does not appear in some repair of , since the repairs are maximal, is inconsistent, and occurs in some minimal inconsistent subset of .
Complexity of inconsistency-tolerant BTCQ entailment with negation in the query
In this section, we investigate the complexity of BTCQ entailment for general BTCQs, that is, BTCQs that may contain negation. For this, we first establish the complexities of consistency checking and repair recognition, i.e., the task of deciding whether a sequence of ABoxes is a repair of . We then build on these results to prove the complexity of inconsistency-tolerant temporal query entailment using the general algorithms described in the last section, while showing matching lower bounds. We thus obtain the following theorem.
Consistency checking and repair recognition for TKBs
We reduce these tasks to the atemporal case by defining an atemporal KB based on . For , is defined in Fig. 4. We first show a correspondence between the models of that respect rigid predicates and the models of .
KB representing .
is consistent iffis consistent.
(⇐) We construct a function from the models of to those of that respect rigid predicates. Assume is consistent, and let be a model of . We define as follows. For every , we set
for every ,
for every ,
for every ,
for every , and
for every ,
and for every , we set
for every ,
for every ,
for every ,
for every , and
for every .
We show that the sequence of interpretations is a model of that respects rigid predicates.
For every time-point , is a model of . If , then either and , or and . In both cases, . The same argument holds for the role assertions in .
For every , is a model of . Slightly abusing notation and viewing an interpretation as an infinite set of assertions, we denote by the interpretation obtained from by renaming every non-rigid predicate X by . The interpretations of all rigid predicates and of all and are the same in and . Since is a model of , and does not contain any axiom that involves two non-rigid predicates and with , is a model of . Moreover , and therefore is a model of . Hence, is a model of .
For every , is a model of .
For every , for every , , and for every , . Therefore, respects rigid predicates.
We obtain that is a model of that respects rigid predicates.
(⇒) For the other direction, we construct a function from the models of that respect rigid predicates to those of . Assume is consistent, and let be a model of that respects rigid predicates. We define as follows.
( for every ) for every ,
for every ,
for every ,
for every and , and
for every and .
Again, we show that is a model of by considering the ABox and the TBox separately.
is a model of . If with , then , and if for some , then and . The situation is the same for the role assertions in .
is a model of . If we rename the non-rigid predicates, coincides with on the interpretation of all rigid predicates and all and . Since each is a model of , each interpretation is a model of , and since does not contain any axiom that involves two non-rigid predicates and with , each is a model of . It follows that is a model of .
We thus obtain a direct correspondence between the models of and those of , and that is satisfiable iff is satisfiable. □
It follows that consistency checking of TKBs can be polynomially reduced to consistency checking of KBs.
If for a DL, consistency checking of-KBs is inP, then consistency checking of-TKBs is inPas well.
By Lemma 6.2, the TKB is consistent iff the KB is consistent. If consistency checking is in P for -KBs, the consistency of can then be checked in time polynomial in the size of and . Since the size of is polynomial in and n, and the size of is at most the size of , we obtain that TKB consistency checking is in P. □
We next show that repair recognition can be done with a polynomial number of consistency checks.
If for a DL, consistency checking of-TKBs is inP, then repair recognition, i.e., deciding whether a sequence of ABoxesis a repair of, is inP.
Assume consistency checking of -TKBs is in P. Then, we can verify in P whether a sequence of ABoxes is a repair of as follows.
We are now ready to establish the complexity of BTCQ entailment under inconsistency-tolerant semantics. We start with the combined complexity. The following upper bounds follow straightforwardly from the procedures described in Section 5.
If repair recognition is inPand BTCQ entailment under the classical semantics is inPSpacew.r.t. combined complexity, then BTCQ entailment under AR, IAR, and brave semantics is inPSpacew.r.t. combined complexity.
If verifying that a sequence of ABoxes is a repair is in P and verifying the entailment, and thus also verifying the non-entailment, of a BTCQ is in PSpace, then the procedures , and all run in NPSpace=PSpace. □
Proposition 6.5 applies to and in all cases except for with rigid roles, for which BTCQ entailment under classical semantics is coNExpTime-hard [20].
BTCQ entailment from an-TKB under AR, IAR, and brave semantics is incoNExpTimew.r.t. combined complexity, even if.
For the AR and IAR semantics, we modify the procedures and described in Section 5 so that they also guess a certificate of the non-entailment of ϕ in the first step. Then, in the second step, the non-entailment of ϕ can be decided by simply verifying this certificate. The certificate can be checked in ExpTime, since the non-entailment of ϕ can be decided in NExpTime.
For the brave semantics’ upper bound, we give a NExpTime procedure to decide . For every subset of , guess either “not a repair” or a certificate of the non-entailment of ϕ from at time point p. Note that there are such subsets. For every such subset, verify in ExpTime whether it is indeed not a repair, or whether . □
The matching PSpace and coNExpTime combined complexity lower bounds for and follow from the consistent case (cf. Section 2).
Data complexity for -TKBs
We now prove the data complexity results, starting with . We first consider the case without rigid predicates.
BTCQ entailment from an-TKB withis
coNP-complete w.r.t. data complexity under AR and IAR semantics, and
NP-complete w.r.t. data complexity under brave semantics.
The upper bounds follow from the procedures described in Section 5: since verifying that a sequence of ABoxes is a repair as well as verifying the non-entailment and entailment of a BTCQ take polynomial time w.r.t. data complexity, the procedures , , and run in NP w.r.t. data complexity. The lower bounds follow from the atemporal case. □
Next, we prove the complexity of BTCQ entailment with rigid predicates. The following proposition establishes the upper bounds for the case where both rigid concepts and rigid roles are allowed.
BTCQ entailment from an-TKB withandis
in coNPw.r.t. data complexity under AR and IAR semantics, and
inw.r.t. data complexity under brave semantics.
For AR and IAR semantics, we modify the procedures described in Section 5 to also guess a certificate for the non-entailment of ϕ. This certificate can be checked in P, since the non-entailment of ϕ can be decided in NP. The upper bound for brave semantics is obtained using the procedure described in Section 5. □
We show that these results are tight even if we only have rigid concepts.
BTCQ entailment from an-TKB withis
coNP-hard w.r.t. data complexity under AR and IAR semantics, and
-hard w.r.t. data complexity under brave semantics.
The lower bounds for AR and IAR semantics follow from the atemporal case. For brave semantics, we show that the complement of brave TCQ entailment is -hard by reduction from .
Let be a -formula, where is a 3-CNF formula over the propositional variables . Based on Φ, define the TKB and the TCQ ϕ as follows, where .
For each clause , i.e., for every , we define the following three ABoxes ():
where
We use the following claim, which we prove in detail in the appendix, and give the intuition behind the construction here.
Φ is valid iff.
Recall that (i) Φ is valid iff for every valuation of the , there exists a valuation of the that satisfies φ, and that (ii) iff every repair of has a model in which ϕ does not hold. The correspondence between valuations of variables of Φ and models of repairs of is ensured by . Intuitively, the rigid concept is used to encode that a variable is true. The disjoint concept encodes that a variable is false and is used to enforce that the repairs of correspond to the valuations of the . The role connects every pair of , which ensures together with the inclusion that no model of a repair of assigns both and to the rigid concept . As a consequence, each model of a repair of corresponds to a valuation of the .
Each clause is represented by the three consecutive ABoxes and , which each encode a literal of the clause in the part. The concept is used to indicate that the literal represented is not the first of the clause. The concept encodes the satisfaction of a clause, and the query expresses that it is not the case that every clause is satisfied (the disjunction is true iff the clause is satisfied by at least one of its three literals). Finally, the TBox expresses the conditions under which a clause is satisfied. In particular, the first two inclusions enforce that a clause is always satisfied if it contains a literal (resp. ) assigned to true (resp. to false) in the repair, and the next three inclusions ensure that a clause is satisfied only if it contains a literal which is assigned to true (for the , since the literals and are represented with only one individual , the condition is that is assigned to false). □
Data complexity for -TKBs
It remains to show the data complexity results for . For AR and brave semantics, the upper bounds follow from the guess and check procedures described in Section 5. (Recall that the complexity of BTCQ entailment under classical semantics is ALogTime-complete for this DL, and thus in P.)
The lower bound for AR follows from the atemporal case, which establishes a tight coNP-bound even if .
In contrast, for brave semantics, BCQ entailment is tractable in the atemporal setting. However, we cannot directly extend this result to the temporal case. Indeed, the data complexity upper bound for brave CQ answering in relies on the fact that the size of the minimal sets of assertions that support the query is bounded by the query size. This is not true in the temporal setting, as can already be seen by the query , whose entailment at time point p can depend on p assertions in the TKB. In fact, we show that in the presence of rigid concepts, brave BTCQ entailment becomes NP-hard.
If, then brave BTCQ entailment from-TKBs isNP-hard w.r.t. data complexity. This already holds for BTCQs that do not contain negation.
We show NP-hardness of brave BTCQ entailment from -TKBs by reduction from SAT. Let be a CNF formula over variables . We define the following problem of BTCQ entailment under brave semantics, with two rigid concepts and . Let be such that:
Let . We show that is satisfiable iff . Note that ϕ does not contain negation. Indeed, since and are rigid, a repair of is such that each has either only or only incoming edges in , i.e., occurs either only in assertions of the form or only in assertions of the form . We can thus define a valuation ν of the variables such that if does not contain a timed assertion of the form , and otherwise. The clause is satisfied by ν iff there exists such that either and or and , that is, iff there exists such that either or , which holds exactly iff . It follows that is satisfiable iff there exists a repair of that entails ϕ at time point n. □
For the case , we have an ALogTime lower bound from the classical semantics, and it is open whether the NP upper bound for brave semantics can be improved. The challenge in obtaining a polynomial upper bound for BTCQ entailment under brave semantics lies intuitively in the non-trivial interaction between the brave semantics and the negation in the query (see also end of Section 8). While under brave semantics, it is more natural to focus on the positive problem of query entailment (one has to construct some subset of a repair), for entailment of BTCQs, it is more natural to focus on the negative problem of query non-entailment (one tries to find some counter-example for the entailment of the query [19]). While for both problems polynomial algorithms have been found, naive combinations of these approaches are not possible. However, since we did not manage to prove an NP lower bound either, it might still be possible to solve this problem in polynomial time.
In contrast, for IAR semantics, we can give a tractable upper bound even if . The reason is that, in -TKBs, the size of a minimal inconsistent subset is at most two, as in the atemporal case.
Due to the syntax, the following holds: for every TBox , the size of a minimal -inconsistent set of (timed) assertions is at most two.
Therefore, we can always compute the intersection of all repairs in polynomial time.
BTCQ entailment from a-TKB under IAR semantics is inPw.r.t. data complexity, even ifand.
The size of the minimal -inconsistent subsets of is bounded by 2. We can thus skip the first step of the procedure described in Section 5 and compute the minimal inconsistent subsets in P by checking the consistency of every timed assertion and pair of timed assertions (with a quadratic number of consistency checks), and then verify the entailment of the query in P w.r.t. data complexity over the TKB from which they have been removed. □
BTCQ entailment under classical semantics without negation in the query
This section completes the complexity picture for BTCQ entailment under the classical semantics by investigating the case where TCQs do not use negation. We show that the absence of negation in the query induces a complexity drop in several cases. These results are based on a more general property: we show that for any DL , if has the canonical model property for CQ answering over KBs, then has also the canonical model property for TCQ answering over TKBs for TCQs without negation. We use the canonical model to prove that for the classical semantics, the complexity upper bounds of the atemporal case transfer to the temporal case.
We first show that BCQ entailment from a TKB can be reduced to BCQ entailment from the KB defined Section 6, Fig. 4. For this, we define a similar transformation for BCQs as we did for TKBs. Let be a BCQ and be a time point. Consider
where replaces every non-rigid predicate X in q by if , and by otherwise.
iff.
The following proof is written for the case where . For the case , p is replaced by in the predicates names.
Assume that , and let be a model of . Let be the corresponding model of that respects rigid predicates, as defined in the proof for Lemma 6.2. For any BCQ ψ without existential variables, we denote by the set of (ground) atoms of ψ. Since , there then exists a mapping π from the set of constants and variables that appear in ψ into Δ such that for every , where is the BCQ obtained by replacing the terms of ψ by their image by π, we have . It follows that for every , if X is rigid then , and otherwise . Thus, , i.e., . Hence .
For the other direction, assume that and let be a model of that respects rigid predicates. Let be as defined in the proof for Lemma 6.2. Since , there exists a mapping π from the set of constants and variables that appear in ψ into Δ such that for every , we have . It follows that for every such that X is rigid, . Furthermore, we have for every such that X is not rigid. Thus, , and we obtain . □
Moreover, the size of is the same as q. We thus obtain the following lemma.
If BCQ entailment from an-KB is inPw.r.t. KB complexity, respectively inNPw.r.t. combined complexity, then so is BCQ entailment from an-TKB.
If deciding whether is polynomial both in and in , then it is polynomial in and . It follows that deciding whether is in P w.r.t. KB complexity.
Moreover, if deciding whether is in NP w.r.t. , and , then verifying a certificate that can be done in polynomial time w.r.t. , and , so in polynomial time w.r.t. , n, and . It follows that deciding whether is in NP w.r.t. combined complexity. □
Next, we define the notion of canonical model property for BCQ entailment and for entailment of BTCQs without negation.
(Canonical model property).
A DL has the canonical model property for BCQ entailment iff for every consistent -KB , there exists a model such that for every BCQ q, iff . We call the canonical model of KB .
A DL has the canonical model property for entailment of BTCQs without negation iff for any -TKB , there exists a model such that for every BTCQ without negation ϕ and every time point p, holds that
We call this model the canonical model of TKB .
Note that it is justified to speak of the canonical model of a KB or TKB because such a model can be homomorphically mapped into any other model of . Indeed, for every assertion α built over , and , if α holds in the canonical model of then it also holds in every model of .
The following theorem gives the relation between the canonical model property for BCQ entailment and the one for BTCQ entailment, and shows why the presence or absence of negation in the query matters.
Ifhas the canonical model property for BCQ entailment, thenalso has the canonical model property for entailment of BTCQs without negation.
Let be the canonical model of and . We show that is the canonical model of for BTCQs without negation, that is, for every BTCQ ϕ that does not contain any negation, iff .
Since is a model of that respects rigid predicates, if then . For the other direction, we show in the appendix by induction on the structure of ϕ that if , then . The interesting case is when ϕ is a BCQ. For a BCQ q, by Lemma 7.1, iff , which is exactly the case iff . By construction of , it follows that iff . □
If ϕ contains negation, the preceding argument fails and is not a canonical model for TCQ answering, i.e., does not guarantee that for every model that respects rigid predicates. As an example, consider the empty TKB, i.e. and for every . We have , but we can easily construct a model for such that , so that .
The following proposition is a direct consequence of the existence of a canonical model for entailment of BTCQs without negation.
Assumehas the canonical model property for BCQ entailment. Then, for every-TKBsand, ifandcoincide for BCQ entailment, thenandcoincide for entailment of BTCQs without negation. I.e., if for every time point p and BCQ q,iff, then for every time point p and BTCQ ϕ without negation,iff.
We show this result in the appendix by induction on the structure of ϕ. We use the fact that by Theorem 7.4, has the canonical model property for entailment of BTCQs without negation, to apply the definitions of BTCQ satisfaction of Table 1 to the canonical models of and . □
We now prove a central proposition for TCQ answering over TKBs in DLs that have the canonical model property for entailment of BTCQs without negation. It amounts to reducing the entailment of BTCQs with unbounded future operators to the entailment of BTCQs with only bounded future operators. These can then be answered by considering only a finite number of time points.
Entailment under classical semantics for DLs with the canonical model property for BCQ entailment
ϕ
iff iff
and
or
implies
and
implies
, ,
, ,
, ,
, ,
, ,
, ,
, ,
and ,
, , and ,
, , and ,
Let be the following TKB:
Ifhas the canonical model property for BCQ entailment, the relations in Table
2
hold for any-TKB.
It is easy to see that holds by construction. We obtain that iff for every BTCQ without negation ϕ.
All relations in Table 2 but those for the operators □, ♢ and are straightforwardly obtained by applying the definitions of BTCQ satisfaction of Table 1 to this canonical model. To show the three remaining relations, we rely on the fact that is such that for every , , and there are no past operators nested under unbounded future operators by definition of TCQs. Indeed, if a BTCQ does not contain any past operators and , iff . Hence we can show the following, from which the relations from Table 2 then follow straightforwardly.
iff for every , . Hence iff , , and .
iff there exists , . Hence iff , , or .
iff , and , . Hence iff , , and , , or and , .
□
In the next theorem, we transfer complexity upper bounds from the atemporal case to the temporal case, even with rigid predicates, for queries without negation and DLs that have the canonical model property for BCQ entailment. We consider DLs for which BCQ entailment is in P w.r.t. KB complexity and in NP w.r.t. combined complexity, such as and .
Ifhas the canonical model property for BCQ entailment and is such that BCQ entailment from KBs is inPw.r.t. KB complexity, respectively inNPw.r.t. combined complexity, then the entailment of BTCQs without negation from-TKBs is inPw.r.t. KB complexity, respectively inNPw.r.t. combined complexity.
By Lemma 7.2, it is possible to decide whether in P w.r.t. KB complexity for any BCQ q. Based on this, we can show by induction on the structure of ϕ that can be decided in P w.r.t. KB complexity. Assume that for two BTCQs and any , it is possible to decide in P whether . Using the relations in Table 2, we can prove the following.
iff and . Therefore, deciding whether can be done in P by checking that and .
iff or . Therefore, deciding whether can be done in P by deciding whether and and checking that at least one is true.
iff . Therefore, deciding whether can be done in P by checking whether .
iff implies . Therefore, deciding whether can be done in P by checking whether or .
We show in the same way that we can decide in P whether and whether .
iff for every k, , . Therefore, deciding whether can be done in P by checking for each that .
We show in the same way that we can decide in P whether and whether .
iff there exists k, , . Therefore, deciding whether can be done in P by deciding for each whether , and checking that this is true for at least one k.
We show in the same way that we can decide in P whether and whether .
iff there exists k, , , and for every j, , . Therefore, deciding whether can be done in P by deciding for each whether and whether , and checking that the condition holds.
We show in the same way that we can decide in P whether and whether .
The number of subqueries in ϕ is linear w.r.t. the size of ϕ, and independent from the TKB size. It follows that the total number of polynomial checks is also polynomially bounded. Therefore, we obtain that for every BTCQ ϕ without negation, can be decided in P w.r.t. the size of . Since iff and the size of is polynomial in the size of , deciding whether is in P w.r.t. KB complexity.
For the NP membership of entailment of BTCQs without negation w.r.t. combined complexity, we describe how to guess a certificate that that can be checked in P. This certificate consists of:
a sequence of functions that associate to each BCQ q of ϕ true or false, and
for each BCQ q of ϕ and time point such that : a certificate that is entailed from .
There are polynomially many pairs of a time point and a BCQ, and the certificate that is entailed from can be checked in polynomial time, since BCQ entailment is in NP. Moreover, we can show that, since ϕ contains neither negation nor past operators nested under unbounded future operators, deciding whether the propositional abstraction of ϕ is satisfied by the sequence of truth assignments that assign the propositional abstraction of q to for every and to for every can be done in polynomial time w.r.t. the size of the query and the length of the sequence of ABoxes. Indeed, identify ϕ and the BCQs in ϕ with their propositional abstractions, and denote by the trace over , where denotes the set of BCQs of ϕ, such that for , and for . Since , for , we can show similar relations as those in Table 2 for the entailment of LTL formulas without past operators nested under unbounded future operators or negations from w. We can then use a similar induction as we used in the proof for the data complexity to show that can be decided by checking which queries are in . For this, the number of queries to be tested is polynomial in n and the size of ϕ. □
As a consequence of Theorems 7.4 and 7.8, and since and have the canonical model property for BCQ entailment (cf. [41] for , and [40] for ), we obtain the following theorem.
Forand, entailment of BTCQs without negation is inPw.r.t. KB complexity and inNPw.r.t. combined complexity, even if.
Besides these results for and , Theorems 7.4 and 7.8 hold for all Horn-DLs satisfying the complexity constraints in the precondition of Theorem 7.8. For instance, they also hold for [35].
Complexity of inconsistency-tolerant BTCQ entailment without negation in the query
The following proposition gives general complexity upper bounds for BTCQ entailment under the AR, IAR, and brave semantics. By Theorem 7.9, they hold in particular for and , provided no negation is used in the TCQs.
Ifis such that consistency checking of a-TKB is inPand BTCQ entailment from a-TKB is inPw.r.t. data complexity and inNPw.r.t. combined complexity, then BTCQ entailment from a-TKB
under AR semantics is in coNPw.r.t. data complexity and inw.r.t. combined complexity;
under IAR semantics is in coNPw.r.t. data complexity and inw.r.t. combined complexity;
under brave semantics is inNPw.r.t. data complexity and inNPw.r.t. combined complexity.
The data complexities follow from the procedures described in Section 5: since verifying that a sequence of ABoxes is a repair as well as non-entailment and entailment of a BTCQ can be decided in polynomial time, , and take non-deterministic polynomial time.
For the combined complexity of brave BTCQ entailment, a certificate that can be guessed together with , and verified in P.
For the combined complexity of IAR, we use the procedure from Section 5 with an NP oracle to decide whether a timed assertion belongs to some minimal inconsistent subset in the first step, and to decide the entailment of ϕ in the last step. Since the oracle calls can be structured as a tree, this procedure gives membership in [32]. □
For , matching lower bounds for all semantics follow from the atemporal case [13,51].
For , we can obtain matching lower bounds from the atemporal case for the combined complexity of all semantics as well as for the data complexity of the AR semantics [16,37]. Regarding IAR semantics, entailment of BTCQs with negations under IAR semantics is already in P (see Fig. 3), so this better upper bound applies. Finally, we show that for brave semantics and , in the case where there are no rigid predicates, we can improve the NP upper bound of Fig. 3 to a P bound. Recall that the lower bound established by Proposition 6.10 for brave semantics with rigid predicates already applies to BTCQs without negations, which means that no improvement of our bounds is possible in the presence of rigid predicates. The only remaining case is entailment under brave semantics where .
We describe a method for brave entailment of BTCQ without negation when . Our procedure proceeds by type elimination over a set of tuples built from the query and that represent the TCQs that are entailed at each time point.
First, we define the structure on which the method operates. We consider the set of leaves of ϕ, that is, the set of all BCQs in ϕ, and the set of subformulas of ϕ. In what follows, we identify the BCQs of and the BTCQs of with their propositional abstractions as defined in Section 2: if we write that a KB or a TKB entails some elements of or , we consider them as BCQs or BTCQs, and if we write that some elements of or entail others, we consider the elements of as propositional variables and those of as propositional LTL formulas built over these variables.
A brave-justification structure J for the BTCQ without negation ϕ in the TKB is a set of tuples of the form , where , , , , and .
Note that the size of a brave-justification structure for ϕ in is linearly bounded in n and independent of the size of the ABoxes. A tuple is justified in J iff it fulfils all of the following conditions.
.
If , there exists such that and .
If , there exists such that and .
For every , if , then .
For every , if , then .
For every , if , then .
For every :
if , then either or ,
if , then either or ,
if , then either or ,
if , then either or ,
if , then either or and ,
if , then either or and ,
if , then either or and , and
if ψ is of the form , then either or .
If , then
for all that are of the form , ,
for all that are of the form and such that , we have ,
for all that are of the form or , iff ,
for all that are of the form and such that , iff .
If , then
for all that are of the form , ,
for all that are of the form , , and
for all that are of the form , , , iff .
We give the intuition behind the elements of the tuples that fulfil these conditions. The first element i is the time point we are considering, is a set of BCQs whose conjunction is entailed under brave semantics by (Condition 1), and is the set of formulas that can be entailed together with , depending on what is entailed in the previous and next time points, this information being stored in and respectively (Condition 6). Conditions 2 and 3 ensure that there is a sequence of tuples representing every time point from 0 to n such that this information is coherent between consecutive tuples. Condition 4 expresses that is exactly the set of BCQs contained in and Condition 5 that is maximal in the sense that it contains its consequences. Condition 7 enforces that , and respect the semantics of LTL operators and Conditions 8 and 9 enforce this semantics at both ends of the finite sequence. (Note that we use here the fact that past operators cannot be nested under unbounded future operators, and that no BCQ can be entailed under brave semantics after time point n in the absence of rigid predicates.)
Data [left] and combined [right] complexity of BTCQ entailment for BTCQs without negation. All results are tight but those preceded by “in” which are upper bounds. The complexities lower than in the case of BTCQs with negation are in bold.
A brave-justification structure J is correct if every tuple is justified, and ϕ is justified at time point p by J if there is such that . We show that ϕ is entailed from at time point p under brave semantics iff there is a correct brave-justification structure for ϕ in that justifies ϕ at time point p. The main idea of the proof is to link the tuples of a sequence to a consistent TKB such that for every i, we have and . We show in the appendix that there is such a such that iff there is such a sequence of tuples that is a correct brave-justification structure for ϕ in and justifies ϕ at time point p.
The data complexity of brave entailment of BTCQ without negation when there are no rigid predicates follows from the characterization of brave BTCQ entailment with brave-justification structures.
For, if, then entailment of BTCQs without negation under brave semantics is inPw.r.t. data complexity.
We describe a polynomial procedure that decides the existence of a brave-justification structure for ϕ in that justifies ϕ at time point p. We start with a brave-justification structure J for ϕ in that contains all possible tuples. Note that the size of this initial structure J is linearly bounded in the number n of ABoxes, and otherwise independent of the data size. The reason is that, except for the time point, the elements of each justification tuple, namely the sets , , and , only depend on the query.
From the initial, maximal, brave-justification structure, we remove the unjustified tuples one after the other as follows. (i) Remove every tuple that does not satisfy Conditions 1, 4, 5, 6, 7, 8 or 9, and (ii) repeat the following steps until a fix-point has been reached: iterate over the tuples from time point 0 to n, eliminating those which do not satisfy Condition 3, and then iterate from n to 0 eliminating those which do not satisfy Condition 2. For the resulting brave-justification structure, we check whether it contains a tuple such that . If yes, we return “entailed at time point p”, otherwise, we return “not entailed at time point p”. Since the size of J is linear in n, this process requires at most quadratically many steps. The verification that a given tuple is justified requires polynomial time w.r.t. data complexity (the verification of Condition 3 and Condition 2 is linear in n, and only the brave entailment of a BCQ from a -KB for Condition 1 depends on the size of the ABox, which can be performed in w.r.t. data complexity). Therefore, the complete procedure runs in polynomial time w.r.t. data complexity. □
Note that it is vital for this procedure that the BTCQ does not contain negation, as this allows to fully focus on the positive entailments of BCQs. In contrast, BTCQs with negation may require a case analysis over query entailments, as exemplified by the tautological BTCQ .
The following theorem summarizes the complexity results for the case without negation in the TCQ.
Until now, work on TCQ answering has primarily focused on complexity analysis for different DL languages [6,7,19]. Attempts towards practical algorithms or implementations are as of now scarce [17,27]. The only attempt toward more practical algorithms close to our scenario that we are aware of has been made for and TCQs without negation in [17], and partially implemented [53]. Some of the results have then been generalized in [18] to query languages that are rewritable in the atemporal case. In this section, we mainly focus on -TKBs and TCQs without negation, building on this previous work. However, some of our results also apply to other DLs and we discuss the case of .
Three different algorithms for answering TCQs without negation over -TKBs without rigid predicates are provided in [17,18]. The first algorithm rewrites the TCQ into a query in ATSQL [28], an SQL variant for temporal databases. The second algorithm first rewrites the TCQ into an equivalent TCQ that does not contain future operators, and then iteratively computes the answers for each time point. The third algorithm computes the answers of the TCQ iteratively as well, but does not eliminate the future operators beforehand. For this, it uses a data structure called answer formulas, which represents the TCQs in which some parts have already been evaluated. This structure contains sets of already computed answers to subqueries, as well as variables that serve as place-holders for subqueries that have to be evaluated at the next time point.
Our first contribution is a method for handling rigid predicates (both concepts and roles) in polynomial time for TCQ answering over -TKBs under the classical semantics. Indeed, [17,18] consider only rigid concepts (but not rigid roles) for which they provide a method that is restricted to TCQs that are rooted, i.e., in which each CQ contains an individual or an answer variable that is connected to all the other terms through roles. As a second contribution, we show that in the absence of rigid predicates, it is sometimes possible to combine the algorithms for inconsistency-tolerant query answering in the atemporal case with algorithms for temporal query answering in the consistent case in order to perform inconsistency-tolerant temporal query answering.
TCQ answering under classical semantics with rigid predicates for and TCQs without negation or unbounded future operators
In this section, we show how TCQ answering with rigid predicates can be reduced to TCQ answering without rigid predicates, enabling us to use the algorithms that have been proposed for this latter case. Throughout the section, is a -TKB and ϕ a TCQ without negation and unbounded future operators (, □, ♢, ). This restriction amounts to using the setting of [17,18] in which the semantics is defined w.r.t. finite sequences of interpretations, and is necessary to reduce TCQ answering with rigid predicates to TCQ answering without rigid predicates. Indeed, consider for instance the query . Such a query can be entailed with rigid predicates, e.g., if A is rigid, but not without rigid predicates since for , the interpretation of every predicate is empty in the pth component of the canonical model of a TKB without rigid predicates.
To the best of our knowledge, the only algorithm that has been proposed for TCQ answering with rigid predicates and aims at practicality is described as well in [17,18], and deals only with rigid concepts and rooted TCQs. We briefly describe this algorithm, which aims at handling streaming data by computing the answers to the query at the last available time point. The key idea is to check all sets of potentially rigid concept assertions and test their compatibility with each of the ABoxes from the sequence together with the TBox. Unfortunately, the original algorithm omits the test whether the checked set of rigid concept assertions covers also the rigid information from the tested ABox together with the TBox. As we found this small flaw in the original algorithm, we present here a mended variant.
In the following, let , , , , and denote respectively the sets of concepts, roles, rigid concepts, rigid roles, and individuals that occur in the TKB . The algorithm first constructs every possible set of assertions built from the rigid concepts and individuals in the TKB . Note that there are such sets. It then runs, in parallel, for each such set an instance of the algorithm for TCQ answering without rigid predicates on the TKB that is obtained by adding the assertions in to every ABox of the TKB. For each time point i, it takes into account the new dataset available by eliminating the incompatible instances, i.e., those for which
is inconsistent, or
a rigid concept assertion entailed by does not belong to .1
This condition is new and added after consultation with the authors of [17,18].
The answers at time point i are then obtained by taking the intersection of the answers returned by all active instances.
We follow a similar idea in the sense that we also add assertions to the TKB that propagate the effects of the rigid predicates. We show that this way, for , TCQ answering with rigid predicates can be reduced to TCQ answering without rigid predicates in polynomial time.
In order to show that TCQ answering with rigid predicates can be reduced to TCQ answering without, we construct in polynomial time a set of assertions that captures all information about rigid concepts and roles that is relevant for consistency checking and TCQ answering. Then, TCQ answering over with , can be performed by TCQ answering over with . Without any restriction on the TBox, may be infinite, as illustrated in the following example.
Consider the TKB with the TBox , where S is rigid, and the ABox sequence consisting of , and for .
Every model of that respects rigid predicates satisfies for every and at every time point. Since with , entails such a query only at time point 0, should be such that entails such a query, so that entails it at every time point. Moreover, there exist models of that respect rigid predicates and for which neither nor hold at any time point . Therefore, cannot contain cycles of S, nor R-assertions. Consequently, has to contain an infinite chain of S-assertions.
This problem motivates us to disallow rigid roles that have non-rigid sub-roles. In other words, we restrict ourselves in the following to TBoxes that entail no role inclusions of the form with , and , . This condition avoids chains of rigid roles in the anonymous part of the canonical model that cannot be entailed by a single rigid assertion. In the example above, if rigid roles are only allowed to have rigid sub-roles, then R has to be rigid. In this case, adding the single assertion to every is sufficient for to be entailed at every time point and for every .
As a first step, we explicitly construct the canonical model of the -TKB . This model will be used to prove that with , and with entail the same BTCQs that do not have negation or unbounded future operators.
We build a sequence of (possibly infinite) ABoxes similar to the chase presented in [25] for KBs. Let be a set of assertions. We say a positive inclusion (PI) α is applicable into an assertion if one of the following conditions is satisfied:
, and ,
, and there exists no b such that ,
, and ,
, and there exists no b such that , or
, , and .
A PI α is applied to an assertion β by adding a new assertion to such that α is not applicable to β in anymore.
(Rigid chase of a TKB).
Let be a -TKB. Let be such that for and . Finally, let be the set of positive inclusions in , and be the number of assertions in . Assume that the assertions in each are enumerated from to following their lexicographic order. Consider the sequences of sets of assertions defined by
where is defined in terms of the assertion obtained as follows: let be the first assertion in such that there exists a PI in applicable in to β and let α be the lexicographically first PI applicable in to β. is then defined based on the syntactictal form of α and β. Specifically,
if and , then ,
if and , then ,
if and , then ,
if and , then , and
if and , then ,
where is constructed from α and β as follows:
if then , and
otherwise , then a is of the form and we define .
If is rigid, then , otherwise, with and for .
Let N be the total number of assertions in . The assertion(s) added are numbered as follows: if is not rigid, is numbered by , otherwise for every , the assertion added to is numbered by .
We call the rigid chase of the TKB , denoted by , the sequence of sets of assertions obtained as the infinite union of all , i.e.,
Based on the rigid chase of , we construct the sequence of interpretations , where is defined as follows.
, where is the set of individuals that appear in and not in .
For every , .
For every , if , if .
For every , if , if .
We show that is a model of that respects rigid predicates, and that for any BTCQ without negation ϕ such that , iff .
Ifis consistent, thenis a model ofthat respects rigid predicates.
Since for every , , we directly obtain . We can show that for every i, further satisfies every PI in with similar arguments as those used in [25]. Indeed, every PI applicable to an assertion β in at step j of the construction of the rigid chase becomes not applicable to β in for some , because there are neither infinitely many assertions before β, nor infinitely many PIs applied to some assertion that precedes β. Finally, we show that satisfies every negative inclusion of because otherwise would be inconsistent. Moreover, the model respects rigid predicates because, if an assertion β of is rigid, either and by construction for every k, or β has been derived at some step j by applying some PI to an assertion of and for every k. We obtain that in both cases, for every k. □
Next, we show that is the canonical model of for entailment of BTCQ without negation.
Ifis consistent, then for every BTCQ without negation ϕ such that,iff.
Since with is a model of that respects rigid predicates, the first direction is straightforward, and we only need to show that implies . Let with be a model of that respects rigid predicates. We show by structural induction on ϕ that if , then . For the case where ϕ is a CQ , we show that if there exists a homomorphism π of into , then , by defining a homomorphism h from Δ into . □
We are now ready to introduce the set that, if added to every ABox of the TKB, allows us to reduce TCQ answering with rigid predicates to TCQ answering without.
Letbe as defined in Fig.
6
. Then,is computable in polynomial time and such that
Set of rigid assertions added to every ABox of .
is consistent iffis consistent with, and
for any BTCQ ϕ without negation and unbounded future operators and such that,iffwith.
The size of is polynomial in the size of , and , and since query answering as well as subsumption checking are in P, can be computed in polynomial time. The first three parts of contain information about the participation of individuals of in rigid predicates. The last two witness the participation in rigid predicates of the role-successors w.r.t. non-rigid roles, and thus take into account also anonymous individuals that are created in when applying PIs whose right-hand side is an existential restriction of a non-rigid role. The individuals created in when applying such a PI with a rigid role are witnessed by the individuals or if they do not follow from a rigid role assertion, and do not need to be witnessed otherwise, since the assertion is sufficient to trigger the generation of the whole anonymous part implied by the fact that is in the range of .
We split the proof of Proposition 9.5 into several lemmas.
is consistent iffis consistent with.
By Proposition 3.5, is consistent with iff each is consistent. We show that also is consistent iff each is consistent.
For the case where is not consistent, let be a minimal inconsistent subset of . Recall that by Fact 6.11, contains at most 2 assertions. Then is either internal to some , or is of the form with . In the former case, is clearly inconsistent. In the latter case, violates some negative inclusion in the closure of the TBox that involves at least a rigid concept A or a rigid role R by assigning an individual a (or two individuals ) to two disjoint concepts (or roles). We can then assume w.l.o.g. that we are in one of the following cases: (i) , (ii) , (iii) , or (iv) . It follows that respectively (i) , (ii) , (iii) , or (iv) . By construction of , we then conclude that (i) , (ii) , (iii) , or (iv) respectively, and therefore that is inconsistent.
For the other direction, assume there exists , such that is inconsistent, and let be a minimal inconsistent subset of . If is internal to , is clearly inconsistent. Otherwise, is of the form and involves at least one assertion from . The assertions α and β assign an individual x to two disjoint concepts , or a pair of individuals to two disjoint roles . We distinguish three cases.
In the case where (resp. ), since (resp. ) is the only assertion of that contains x, we obtain that (resp. ) is inconsistent, which implies that P (resp. ) is unsatisfiable, i.e., has an empty interpretation in every model of . Since there exists j such that (resp. and ), it follows that is inconsistent.
In the case where , since appears only in concepts that subsume , the fact that x is assigned to two disjoint concepts implies that is unsatisfiable. Thus, and since there exists j such that , is inconsistent.
Finally, in the case where , since α or β is in , at least one of (or ) is rigid. As the case where some ABox is inconsistent is trivial, we assume every to be consistent. If , let be an assertion responsible for the entailment that triggered the addition of α to , and otherwise let . If , let be an assertion responsible for the entailment that triggered the addition of β to , and otherwise . Then is inconsistent because and lead to a (or ) being assigned to two disjoint concepts (or disjoint roles) such that at least one of them is rigid. As a result, is inconsistent as well.
We obtain that in every case, if is inconsistent with , then is inconsistent with rigid predicates. □
We now assume that and are consistent. Note that if this is not the case, they both trivially entail any BTCQ. The following two lemmas show that if a Boolean conjunctive query is such that , then for every , iff .
Letbe such that. Then, for every, ifthen.
By Lemma 9.4, it suffices to focus on the canonical model for testing entailments of . The lemma can be shown by defining a homomorphism from the canonical model of into , the pth component of . □
Letbe such that. For every, ifthen.
Again, we make use of Lemma 9.4 and use the canonical model . The lemma can then be shown by considering some model of , and defining a homomorphism of into . □
Since by Lemmas 9.7 and 9.8, and with coincide on the entailment of BCQs for every time point , we can show as in Proposition 7.6 that they coincide on entailment of BTCQs without negation nor unbounded future operators.
Let ϕ be a BTCQ with no negation or unbounded future operators such that. Then,iffwith.
It follows that TCQs can be answered in with rigid predicates by answering TCQs in without rigid predicates and pruning answers that contain individual names not in . Note that every model of is a model of , but does not respect rigid predicates in general. We can reduce BTCQ entailment over with rigid predicates to BTCQ entailment over without rigid predicates only because our TCQs do not allow LTL operators to be nested in existential quantifications. This prevents existentially quantified variables to link different time points. To see this, consider the query and the TKB with , and . For this TKB, we would have , and therefore could have a different R-successors in each interpretation of a model of , thus y cannot be mapped to the same object at every time point.
In the case of streaming data, if we want to take into account a newly available dataset, we do not need to fully recompute : we only need to add the new rigid assertions that can be derived from the new dataset. Moreover, if we only reason over a window of n time points from our stream, we can annotate the assertions in with a counter that is initialised with n and decremented with each new time point. If an existing assertion is derived again, it is reset to n. Assertions are then removed from if their counter reaches 0.
The main goal of the approaches presented in [17,18] for TCQ answering in is to obtain the query answers at the last time point without storing all the data for all previous time points. Their algorithm uses a bounded history encoding, which means that the space required by the algorithm is constant w.r.t. the number n of previous time points: only the current dataset and some auxiliary relations required for computing the query answers are stored and updated at each time point.
Unfortunately, with rigid predicates present, our approach does not achieve bounded history encoding, since the answers of the subqueries of ϕ at previous time points may change when new rigid assertions are derived from the last dataset. However, if the algorithm of [17,18] has this property, it requires exponential space w.r.t. and which can also be problematic, while our algorithm requires only polynomial space and time. To achieve bounded history encoding (but in exponential time w.r.t. , and ), we could adapt the algorithm of [17,18] to support rigid roles. We would consider all possible sets built from , and following the form of Fig. 6, then verify at each time point whether is consistent with and and contains all rigid assertions that can be derived from as described in Fig. 6.
Our procedure only applies to TBoxes in which rigid roles do not have non-rigid subroles. A possible direction to alleviate these restrictions would be to use ideas similar to those developed in [40] for CQ answering over -KB using the combined approach. This CQ answering approach saturates the data by adding to the ABox every assertion that can be derived, introducing individual names to witness existential role restrictions, and then uses a special rewriting to prune spurious answers. In our setting, we could model infinite chains of rigid roles by adding cycles of rigid roles to , then prune the spurious answers resulting from these cycles.
Regarding , we conjecture that we could have a similar approach for rigid predicates. The main difference would be that since in several assertions may be needed to derive one, would have to be computed iteratively, taking into account its own assertions to derive new ones until a fix-point is reached. Moreover, the problem of infinite chains of rigid roles that cannot be entailed by a polynomial set of assertions would appear as soon as . The combined approach for [41] could provide ideas to overcome this difficulty.
Inconsistency-tolerant TCQ answering without rigid predicates
In this section is a -TKB and ϕ a TCQ without negation.
When , an important consequence of Proposition 3.5 is that the repairs of are all possible sequences where is a repair of , so the intersection of the repairs of is where is the intersection of the repairs of . This allows us to show that the entailment (resp. IAR entailment) of a BTCQ without negation from a consistent (resp. possibly inconsistent) TKB in a DL that has the canonical model property for BCQ entailment can be equivalently defined w.r.t. the entailment (resp. IAR entailment) of the BCQs it contains as follows.
Ifhas the canonical model property for BCQ entailment and, then the entailments shown in Table
3
hold forwhenis consistent, and for.
Entailment under classical or IAR semantics from a -TKB without rigid predicates and such that has the canonical model property for BCQ entailment
ϕ
iff
and
and
or
implies
and
implies
, ,
, ,
, ,
, ,
, ,
, ,
, , and
, , and ,
, , and ,
For the consistent case, all relations in Table 3 but the first one are straightforwardly obtained by applying the definitions of BTCQ satisfaction of Table 1 in Section 2 to the canonical model of . Moreover, by Proposition 3.6, if , then iff . Finally, if , because there exists a model of whose pth component interprets every predicate as the empty set.
For IAR semantics, let denote the intersection of the repairs of and denote the intersection of the repairs of .
iff , i.e., iff and because is consistent. Since the repairs of are the sequences of the repairs of the , , so iff and .
iff , i.e., iff and because is consistent. It follows that iff and .
We show all remaining relations in the same way, applying the definition of IAR semantics and using the fact that is consistent.
□
This is an important result, since it implies that answering temporal CQs under IAR semantics can be done with the algorithms developed for the consistent case (see [17,18] for algorithms for without unbounded future operators) by replacing classical CQ answering by IAR CQ answering (see [14,39,54] for algorithms for ). The following example shows that this is unfortunately not true for brave or AR semantics.
Consider the TKB and the TCQ ϕ defined as follows.
Now, for every , but . This is because the same repair cannot entail both at time point k and , since it would contain both and which is not possible. For AR semantics, consider over the TKB : while ϕ holds under AR semantics at each time point, neither nor does.
However, if the operators allowed in the TCQ are restricted to , and , then AR TCQ answering can be done with the algorithms developed for the consistent case by simply replacing classical CQ answering by AR CQ answering (see [14] for algorithms for ). Indeed, for these operators, the relations of Proposition 9.12 hold for .
iff for every repair of , , i.e., iff for every repair of , and because is consistent. Since the repairs of are the sequences of the repairs of the , this is the case iff and for every repair of , , i.e., iff and .
iff for every repair of , , i.e., iff for every repair of , and because is consistent. It follows that iff and .
We show all remaining relations in the same way, applying the definition of AR semantics and using the fact that TKB repairs are consistent.
The following counter-examples show that this is not the case for the other operators: and .
but and :
(resp. ) but for every k (resp. such that ), :
(resp. ) but for every k (resp. such that ), either or there exists j, such that and :
We can construct similar counter-examples for and .
Interestingly, contrary to the brave semantics, even for general TCQs the “if” direction of Proposition 9.12 is true.
If or , then .
If there exists such that , then .
If there exists k such that and , then .
If there exists k such that and , then .
If there exists such that and for every j such that , , then .
If there exists k such that , and for every j such that , , then .
If there exists k such that , and for every j such that , , then .
It follows that even for unrestricted TCQs, combining algorithms for TCQ answering with algorithms for AR query answering will provide a sound approximation of AR answers.
For brave semantics, it would be useful to characterize the queries for which this method would be correct. Indeed, for many pairs of a TBox and a query, the minimal subsets of the TKB such that the query can be mapped into them cannot be inconsistent. For instance, for -TKBs, this is the case if no pair of predicates that may be involved at the same time point appears in an NI entailed by the TBox. Consider for instance and . For ϕ to be entailed at time point p, should hold at p, at time point and at , so there cannot be a conflict between the C and the A or B timed assertions used to satisfy the different CQs.
Conclusions and future work
For stream reasoning, handling the temporal dimension of the collected data and being resilient against errors in the data are expedient requirements. In the presence of erroneous data, handling inconsistencies is indispensable for logic-based approaches to stream reasoning. In this paper, we have lifted the standard inconsistency-tolerant semantics AR, IAR and brave to a temporal query answering setting that has been widely studied in the literature—namely, where the data is associated with time points and only the query language admits the use of temporal operators from LTL. We have presented complexity results and techniques to combine temporal with inconsistency-tolerant query answering over lightweight DL temporal knowledge bases suited for ontology-mediated situation recognition.
Our main contribution is a complexity analysis of the three semantics, focusing on the DLs and , where we distinguished the cases based on whether rigid concept or role names occur in the TKB, and on whether the query contains negation. We provided general algorithms that allow us to derive the complexity of temporal inconsistency-tolerant query answering from the complexities of consistency checking and classical entailment of temporal conjunctive queries. We furthermore completed the complexity picture for the classical semantics for TCQs without negations. Indeed, for the case where the query language does not provide negation, we devised a general approach to assess the complexity by the use of the canonical model property for B(T)CQ answering and thus not only limited to a particular DL. This approach allows us to derive the complexity of temporal query answering from the complexity of conjunctive query entailment for DLs that have this canonical model property.
Encouragingly, our analysis shows that either with or without negation in the query, in most cases, inconsistency-tolerant reasoning and temporal query answering can be combined without increasing the computational complexity. Furthermore, our results show that disallowing negation in the query language results in a drop in the combined complexity of TCQ answering, and, in the case of with rigid predicates, even in the data complexity. This raises hope that ontology-based stream reasoning applications which are resilient against noise in the data can be feasibly implemented and used in practice.
As a second major contribution, we investigated two techniques useful for developing practical algorithms for inconsistency-tolerant temporal query answering. We first showed that in , under the classical semantics and for queries without negation and unbounded temporal operators, rigid predicates can be handled by adding a set of assertions of polynomial size to each ABox from the TKB. However, our approach, which reduces TCQ answering with rigid predicates to TCQ answering without rigid predicates, works only for BTCQ entailment under the classical semantics.
We then showed that in the case without rigid predicates and for queries without negation, TCQ answering under IAR semantics can be implemented by combining algorithms developed for TCQ answering under the classical semantics with algorithms for CQ answering under IAR semantics over atemporal KBs. Moreover, we showed that when disallowing some of the operators in the queries, the same method can be used for AR semantics, while for full TCQs without negation, it provides for a sound approximation of the AR answers. Unfortunately, this is not the case for brave semantics, which is relevant for practical applications such as recognizing highly critical situations. Thus it would be useful to characterize the queries and TBoxes for which this method is correct. Now, fully fledged practical algorithms still remain to be found for inconsistency-tolerant temporal query answering with rigid predicates.
Another interesting open question is how the complexity changes if we admit not only the qualitative temporal operators from LTL, but also metric temporal operators as found in MTL or [1,5,42]. In , temporal operators can be annotated by time intervals over which they are evaluated. In a query language with these operators, it would for example be possible to directly express that a query was entailed at some point during the last 5–10 time units, using the expression . It is well-known that formulas can be exponentially encoded in LTL (assuming a binary encoding of the intervals) [42], which would also apply to our setting. This immediately gives complexity upper bounds due to our results, tight in the case of data complexity, but with an exponential increase in the case of combined complexity. This blow-up might be unavoidable, since propositional is ExpSpace-complete. In fact, combinations of operators with description logics often lead to an exponential increase in complexity [5,33], and it would be interesting to investigate whether this also happens for the settings considered in this paper. Regarding MTL, an initial investigation of query answering with a Horn-fragment of MTL has been performed in [23].
Footnotes
Acknowledgements
This work has been supported by the DFG in CRC 912 (HAEC), the DAAD, and the grant ANR-16-CE23-0007-01 (“DICOS”). The authors would like to thank Stefan Borgwardt for helpful discussions and the anonymous reviewers for helpful comments.
Detailed proofs
We start by defining the notions of conflicts and causes that will be used in some proofs. A conflict for a KB K=⟨T,A⟩ is a minimal T-inconsistent subset of A. A cause for a BCQ q w.r.t. K is a minimal T-consistent subset C⊆A such that ⟨T,C⟩⊧q. The following definitions extend these notions to the temporal setting.
The conflicts of a DL-LiteR-TKB are at most binary, i.e., contain at most two timed assertions (Fact 6.11).
Note that a KB (resp. TKB) is consistent iff it has no conflict, and that a BCQ (resp. BTCQ) is entailed from a KB (resp. a TKB) K under brave semantics iff it has some cause in K, since such a cause can be extended to a repair that entails the query.
References
1.
R.Alur and T.A.Henzinger, A really temporal logic, J. ACM41(1) (1994), 181–204. doi:10.1145/174644.174651.
2.
A.Artale, R.Kontchakov, A.Kovtunova, V.Ryzhikov, F.Wolter and M.Zakharyaschev, First-order rewritability of temporal ontology-mediated queries, in: Proceedings of the Twenty-Fourth International Joint Conference on Artificial Intelligence, IJCAI 2015, Buenos Aires, Argentina, July 25–31, 2015, Q.Yang and M.Wooldridge, eds, AAAI Press, 2015, pp. 2706–2712, http://ijcai.org/Abstract/15/383. ISBN 978-1-57735-738-4.
3.
A.Artale, R.Kontchakov, A.Kovtunova, V.Ryzhikov, F.Wolter and M.Zakharyaschev, Ontology-mediated query answering over temporal data: A survey (invited talk), in: 24th International Symposium on Temporal Representation and Reasoning, TIME 2017, Mons, Belgium, 2017, October 16–18, S.Schewe, T.Schneider and J.Wijsen, eds, LIPIcs, Vol. 90, Schloss Dagstuhl – Leibniz-Zentrum fuer Informatik, 2017, pp. 1:1–1:37, https://doi.org/10.4230/LIPIcs.TIME.2017.1. ISBN 978-3-95977-052-1. doi:10.4230/LIPIcs.TIME.2017.1.
4.
A.Artale, R.Kontchakov, F.Wolter and M.Zakharyaschev, Temporal description logic for ontology-based data access, in: IJCAI 2013, Proceedings of the 23rd International Joint Conference on Artificial Intelligence, Beijing, China, August 3–9, 2013, F.Rossi, ed., IJCAI/AAAI, 2013, pp. 711–717, http://www.aaai.org/ocs/index.php/IJCAI/IJCAI13/paper/view/6824. ISBN 978-1-57735-633-2.
5.
F.Baader, S.Borgwardt, P.Koopmann, A.Ozaki and V.Thost, Metric temporal description logics with interval-rigid names, in: Frontiers of Combining Systems – 11th International Symposium, Proceedings, FroCoS 2017, Brasília, Brazil, September 27–29, 2017, C.Dixon and M.Finger, eds, Lecture Notes in Computer Science, Vol. 10483, Springer, 2017, pp. 60–76, https://doi.org/10.1007/978-3-319-66167-4_4. ISBN 978-3-319-66166-7. doi:10.1007/978-3-319-66167-4_4.
6.
F.Baader, S.Borgwardt and M.Lippmann, Temporalizing ontology-based data access, in: Automated Deduction – CADE-24 – 24th International Conference on Automated Deduction, Proceedings, Lake Placid, NY, USA, June 9–14, 2013, M.P.Bonacina, ed., Lecture Notes in Computer Science, Vol. 7898, Springer, 2013, pp. 330–344, https://doi.org/10.1007/978-3-642-38574-2_23. ISBN 978-3-642-38573-5. doi:10.1007/978-3-642-38574-2_23.
7.
F.Baader, S.Borgwardt and M.Lippmann, Temporal query entailment in the description logic SHQ, J. Web Sem.33 (2015), 71–93, https://doi.org/10.1016/j.websem.2014.11.008. doi:10.1016/j.websem.2014.11.008.
8.
H.Beck, M.Dao-Tran, T.Eiter and M.Fink, LARS: A logic-based framework for analyzing reasoning over streams, in: Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, Austin, Texas, USA, January 25–30, 2015, B.Bonet and S.Koenig, eds, AAAI Press, 2015, pp. 1431–1438, http://www.aaai.org/ocs/index.php/AAAI/AAAI15/paper/view/9657. ISBN 978-1-57735-698-1.
9.
H.Beck, M.Dao-Tran, T.Eiter and M.Fink, Towards Ideal Semantics for Analyzing Stream Reasoning, 2015, CoRR, http://arxiv.org/abs/1505.05365.
10.
H.Beck, T.Eiter and C.Folie, Ticker: A system for incremental ASP-based stream reasoning, TPLP17(5–6) (2017), 744–763, https://doi.org/10.1017/S1471068417000370. doi:10.1017/S1471068417000370.
11.
L.E.Bertossi, Database Repairing and Consistent Query Answering, Synthesis Lectures on Data Management, Morgan & Claypool Publishers, 2011, https://doi.org/10.2200/S00379ED1V01Y201108DTM020. doi:10.2200/S00379ED1V01Y201108DTM020.
12.
M.Bienvenu, On the complexity of consistent query answering in the presence of simple ontologies, in: Proceedings of the Twenty-Sixth AAAI Conference on Artificial Intelligence, Toronto, Ontario, Canada, July 22–26, 2012, J.Hoffmann and B.Selman, eds, AAAI Press, 2012, http://www.aaai.org/ocs/index.php/AAAI/AAAI12/paper/view/4928.
13.
M.Bienvenu and C.Bourgaux, Inconsistency-tolerant querying of description logic knowledge bases, in: Reasoning Web: Logical Foundation of Knowledge Graph Construction and Query Answering – 12th International Summer School 2016, Tutorial Lectures, Aberdeen, UK, September 5–9, 2016, J.Z.Pan, D.Calvanese, T.Eiter, I.Horrocks, M.Kifer, F.Lin and Y.Zhao, eds, Lecture Notes in Computer Science, Vol. 9885, Springer, 2016, pp. 156–202, https://doi.org/10.1007/978-3-319-49493-7_5. ISBN 978-3-319-49492-0. doi:10.1007/978-3-319-49493-7_5.
14.
M.Bienvenu, C.Bourgaux and F.Goasdoué, Querying inconsistent description logic knowledge bases under preferred repair semantics, in: Proceedings of the Twenty-Eighth AAAI Conference on Artificial Intelligence, Québec City, Québec, Canada, July 27–31, 2014, C.E.Brodley and P.Stone, eds, AAAI Press, 2014, pp. 996–1002, http://www.aaai.org/ocs/index.php/AAAI/AAAI14/paper/view/8231. ISBN 978-1-57735-661-5.
15.
M.Bienvenu, C.Bourgaux and F.Goasdoué, Explaining inconsistency-tolerant query answering over description logic knowledge bases, in: Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, Phoenix, Arizona, USA, February 12–17, 2016, D.Schuurmans and M.P.Wellman, eds, AAAI Press, 2016, pp. 900–906, http://www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/view/12025. ISBN 978-1-57735-760-5.
16.
M.Bienvenu and R.Rosati, Tractable approximations of consistent query answering for robust ontology-based data access, in: IJCAI 2013, Proceedings of the 23rd International Joint Conference on Artificial Intelligence, Beijing, China, August 3–9, 2013, F.Rossi, ed., IJCAI/AAAI, 2013, pp. 775–781, http://www.aaai.org/ocs/index.php/IJCAI/IJCAI13/paper/view/6904. ISBN 978-1-57735-633-2.
17.
S.Borgwardt, M.Lippmann and V.Thost, Temporal query answering in the description logic DL-Lite, in: Frontiers of Combining Systems – 9th International Symposium, FroCoS 2013, Proceedings, Nancy, France, September 18–20, 2013, P.Fontaine, C.Ringeissen and R.A.Schmidt, eds, Lecture Notes in Computer Science, Vol. 8152, Springer, 2013, pp. 165–180, https://doi.org/10.1007/978-3-642-40885-4_11. ISBN 978-3-642-40884-7. doi:10.1007/978-3-642-40885-4_11.
18.
S.Borgwardt, M.Lippmann and V.Thost, Temporalizing rewritable query languages over knowledge bases, J. Web Sem.33 (2015), 50–70, https://doi.org/10.1016/j.websem.2014.11.007. doi:10.1016/j.websem.2014.11.007.
19.
S.Borgwardt and V.Thost, Temporal query answering in DL-Lite with negation, in: Global Conference on Artificial Intelligence, GCAI 2015, Tbilisi, Georgia, October 16–19, 2015, G.Gottlob, G.Sutcliffe and A.Voronkov, eds, EPiC Series in Computing, Vol. 36, EasyChair, 2015, pp. 51–65, http://www.easychair.org/publications/paper/245305.
20.
S.Borgwardt and V.Thost, Temporal query answering in the description logic EL, in: Proceedings of the Twenty-Fourth International Joint Conference on Artificial Intelligence, IJCAI 2015, Buenos Aires, Argentina, July 25–31, 2015, Q.Yang and M.Wooldridge, eds, AAAI Press, 2015, pp. 2819–2825, http://ijcai.org/Abstract/15/399. ISBN 978-1-57735-738-4.
21.
C.Bourgaux and A.-Y.Turhan, Temporal query answering in DL-Lite over inconsistent data, in: The Semantic Web – ISWC 2017 – 16th International Semantic Web Conference, Proceedings, Part I, Vienna, Austria, October 21–25, 2017, C.d’Amato, M.Fernández, V.A.M.Tamma, F.Lécué, P.Cudré-Mauroux, J.F.Sequeda, C.Lange and J.Heflin, eds, Lecture Notes in Computer Science, Vol. 10587, Springer, 2017, pp. 121–137, https://doi.org/10.1007/978-3-319-68288-4_8. ISBN 978-3-319-68287-7. doi:10.1007/978-3-319-68288-4_8.
22.
C.Bourgaux and A.-Y.Turhan, Temporal Query Answering in DL-Lite over Inconsistent Data, 2017, LTCS-Report 17-06, Chair for Automata Theory, TU Dresden, available at: https://lat.inf.tu-dresden.de/research/reports.html.
23.
S.Brandt, E.G.Kalayci, R.Kontchakov, V.Ryzhikov, G.Xiao and M.Zakharyaschev, Ontology-based data access with a Horn fragment of metric temporal logic, in: Proceedings of the Thirty-First AAAI Conference on Artificial Intelligence, San Francisco, California, USA, February 4–9, 2017, S.P.Singh and S.Markovitch, eds, AAAI Press, 2017, pp. 1070–1076, http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14881.
24.
S.Brandt, E.G.Kalayci, V.Ryzhikov, G.Xiao and M.Zakharyaschev, A framework for temporal ontology-based data access: A proposal, in: New Trends in Databases and Information Systems – ADBIS 2017 Short Papers and Workshops, AMSD, BigNovelTI, DAS, SW4CH, DC, Proceedings, Nicosia, Cyprus, September 24–27, 2017, M.Kirikova, K.Nørvåg, G.A.Papadopoulos, J.Gamper, R.Wrembel, J.Darmont and S.Rizzi, eds, Communications in Computer and Information Science, Vol. 767, Springer, 2017, pp. 161–173, https://doi.org/10.1007/978-3-319-67162-8_17. ISBN 978-3-319-67161-1. doi:10.1007/978-3-319-67162-8_17.
25.
D.Calvanese, G.De Giacomo, D.Lembo, M.Lenzerini, A.Poggi, M.Rodriguez-Muro and R.Rosati, Ontologies and databases: The DL-Lite approach, in: Reasoning Web. Semantic Technologies for Information Systems, 5th International Summer School 2009, Tutorial Lectures, Brixen-Bressanone, Italy, August 30–September 4, 2009, S.Tessaris, E.Franconi, T.Eiter, C.Gutiérrez, S.Handschuh, M.Rousset and R.A.Schmidt, eds, Lecture Notes in Computer Science, Vol. 5689, Springer, 2009, pp. 255–356, https://doi.org/10.1007/978-3-642-03754-2_7. ISBN 978-3-642-03753-5. doi:10.1007/978-3-642-03754-2_7.
26.
D.Calvanese, G.De Giacomo, D.Lembo, M.Lenzerini and R.Rosati, Tractable reasoning and efficient query answering in description logics: The DL-Lite family, J. Autom. Reasoning39(3) (2007), 385–429, https://doi.org/10.1007/s10817-007-9078-x. doi:10.1007/s10817-007-9078-x.
27.
D.Calvanese, E.G.Kalayci, V.Ryzhikov and G.Xiao, Towards practical OBDA with temporal ontologies – (position paper), in: Web Reasoning and Rule Systems – 10th International Conference, RR 2016, Proceedings, Aberdeen, UK, September 9–11, 2016, M.Ortiz and S.Schlobach, eds, Lecture Notes in Computer Science, Vol. 9898, Springer, 2016, pp. 18–24, https://doi.org/10.1007/978-3-319-45276-0_2. ISBN 978-3-319-45275-3. doi:10.1007/978-3-319-45276-0_2.
28.
J.Chomicki, D.Toman and M.H.Böhlen, Querying ATSQL databases with temporal logic, ACM Trans. Database Syst.26(2) (2001), 145–178, http://portal.acm.org/citation.cfm?id=383891.383892. doi:10.1145/383891.383892.
29.
G.De Giacomo, R.De Masellis and M.Montali, Reasoning on LTL on finite traces: Insensitivity to infiniteness, in: Proceedings of the Twenty-Eighth AAAI Conference on Artificial Intelligence, Québec City, Québec, Canada, July 27–31, 2014, C.E.Brodley and P.Stone, eds, AAAI Press, 2014, pp. 1027–1033, http://www.aaai.org/ocs/index.php/AAAI/AAAI14/paper/view/8575. ISBN 978-1-57735-661-5.
30.
D.M.Gabbay, The declarative past and imperative future: Executable temporal logic for interactive systems, in: Temporal Logic in Specification, Proceedings, Altrincham, UK, April 8–10, 1987, B.Banieqbal, H.Barringer and A.Pnueli, eds, Lecture Notes in Computer Science, Vol. 398, Springer, 1987, pp. 409–448, https://doi.org/10.1007/3-540-51803-7_36. ISBN 3-540-51803-7. doi:10.1007/3-540-51803-7_36.
31.
M.Gebser, T.Grote, R.Kaminski, P.Obermeier, O.Sabuncu and T.Schaub, Stream reasoning with answer set programming: Preliminary report, in: Principles of Knowledge Representation and Reasoning: Proceedings of the Thirteenth International Conference, KR 2012, Rome, Italy, June 10–14, 2012, G.Brewka, T.Eiter and S.A.McIlraith, eds, AAAI Press, 2012, http://www.aaai.org/ocs/index.php/KR/KR12/paper/view/4504. ISBN 978-1-57735-560-1.
32.
G.Gottlob, NP trees and Carnap’s modal logic, J. ACM42(2) (1995), 421–457. doi:10.1145/201019.201031.
33.
V.Gutiérrez-Basulto, J.C.Jung and A.Ozaki, On metric temporal description logics, in: ECAI 2016 – 22nd European Conference on Artificial Intelligence – Including Prestigious Applications of Artificial Intelligence (PAIS 2016), The Hague, The Netherlands, 29 August–2 September 2016, G.A.Kaminka, M.Fox, P.Bouquet, E.Hüllermeier, V.Dignum, F.Dignum and F.van Harmelen, eds, Frontiers in Artificial Intelligence and Applications, Vol. 285, IOS Press, 2016, pp. 837–845, https://doi.org/10.3233/978-1-61499-672-9-837. ISBN 978-1-61499-671-2. doi:10.3233/978-1-61499-672-9-837.
34.
S.Klarman and T.Meyer, Querying temporal databases via OWL 2 QL, in: Web Reasoning and Rule Systems – 8th International Conference, RR 2014, Proceedings, Athens, Greece, September 15–17, 2014, R.Kontchakov and M.Mugnier, eds, Lecture Notes in Computer Science, Vol. 8741, Springer, 2014, pp. 92–107, https://doi.org/10.1007/978-3-319-11113-1_7. ISBN 978-3-319-11112-4. doi:10.1007/978-3-319-11113-1_7.
35.
R.Kontchakov, C.Lutz, D.Toman, F.Wolter and M.Zakharyaschev, The combined approach to query answering in DL-Lite, in: Principles of Knowledge Representation and Reasoning: Proceedings of the Twelfth International Conference, KR 2010, Toronto, Ontario, Canada, May 9–13, 2010, F.Lin, U.Sattler and M.Truszczynski, eds, AAAI Press, 2010, http://aaai.org/ocs/index.php/KR/KR2010/paper/view/1282.
36.
F.Lécué, Diagnosing changes in an ontology stream: A DL reasoning approach, in: Proceedings of the Twenty-Sixth AAAI Conference on Artificial Intelligence, Toronto, Ontario, Canada, July 22–26, 2012, J.Hoffmann and B.Selman, eds, AAAI Press, 2012, http://www.aaai.org/ocs/index.php/AAAI/AAAI12/paper/view/4988.
37.
D.Lembo, M.Lenzerini, R.Rosati, M.Ruzzi and D.F.Savo, Inconsistency-tolerant semantics for description logics, in: Web Reasoning and Rule Systems – Fourth International Conference, RR 2010, Proceedings, Bressanone/Brixen, Italy, September 22–24, 2010, P.Hitzler and T.Lukasiewicz, eds, Lecture Notes in Computer Science, Vol. 6333, Springer, 2010, pp. 103–117, https://doi.org/10.1007/978-3-642-15918-3_9. ISBN 978-3-642-15917-6. doi:10.1007/978-3-642-15918-3_9.
38.
D.Lembo, M.Lenzerini, R.Rosati, M.Ruzzi and D.F.Savo, Query rewriting for inconsistent DL-Lite ontologies, in: Proceedings, Web Reasoning and Rule Systems – 5th International Conference, RR 2011, Galway, Ireland, August 29–30, 2011, S.Rudolph and C.Gutiérrez, eds, Lecture Notes in Computer Science, Vol. 6902, Springer, 2011, pp. 155–169, https://doi.org/10.1007/978-3-642-23580-1_12. ISBN 978-3-642-23579-5. doi:10.1007/978-3-642-23580-1_12.
39.
D.Lembo, M.Lenzerini, R.Rosati, M.Ruzzi and D.F.Savo, Inconsistency-tolerant query answering in ontology-based data access, J. Web Sem.33 (2015), 3–29, https://doi.org/10.1016/j.websem.2015.04.002. doi:10.1016/j.websem.2015.04.002.
40.
C.Lutz, I.Seylan, D.Toman and F.Wolter, The combined approach to OBDA: Taming role hierarchies using filters, in: The Semantic Web – ISWC 2013 – 12th International Semantic Web Conference, Proceedings, Part I, Sydney, NSW, Australia, October 21–25, 2013, H.Alani, L.Kagal, A.Fokoue, P.T.Groth, C.Biemann, J.X.Parreira, L.Aroyo, N.F.Noy, C.Welty and K.Janowicz, eds, Lecture Notes in Computer Science, Vol. 8218, Springer, 2013, pp. 314–330, https://doi.org/10.1007/978-3-642-41335-3_20. ISBN 978-3-642-41334-6. doi:10.1007/978-3-642-41335-3_20.
41.
C.Lutz, D.Toman and F.Wolter, Conjunctive query answering in the description logic EL using a relational database system, in: IJCAI 2009, Proceedings of the 21st International Joint Conference on Artificial Intelligence, Pasadena, California, USA, July 11–17, 2009, C.Boutilier, ed., 2009, pp. 2070–2075, http://ijcai.org/Proceedings/09/Papers/341.pdf.
42.
C.Lutz, D.Walther and F.Wolter, Quantitative temporal logics over the reals: PSpace and below, Inf. Comput.205(1) (2007), 99–123, https://doi.org/10.1016/j.ic.2006.08.006. doi:10.1016/j.ic.2006.08.006.
43.
A.Margara, J.Urbani, F.van Harmelen and H.E.Bal, Streaming the web: Reasoning over dynamic data, J. Web Sem.25 (2014), 24–44, https://doi.org/10.1016/j.websem.2014.02.001. doi:10.1016/j.websem.2014.02.001.
44.
A.Mileo, A.Abdelrahman, S.Policarpio and M.Hauswirth, StreamRule: A nonmonotonic stream reasoning system for the semantic web, in: Web Reasoning and Rule Systems – 7th International Conference, RR 2013, Proceedings, Mannheim, Germany, July 27–29, 2013, W.Faber and D.Lembo, eds, Lecture Notes in Computer Science, Vol. 7994, Springer, 2013, pp. 247–252, https://doi.org/10.1007/978-3-642-39666-3_23. ISBN 978-3-642-39665-6. doi:10.1007/978-3-642-39666-3_23.
45.
B.Motik, B.Cuenca Grau, I.Horrocks, Z.Wu, A.Fokoue and C.Lutz, OWL 2 Web Ontology Language Profiles, 2012, available at: http://www.w3.org/TR/owl2-profiles/.
46.
OWL Working Group, OWL 2 Web Ontology Language: Document Overview, W3C Recommendation, 2009, available at: https://www.w3.org/TR/owl2-overview/.
47.
Ö.L.Özçep, R.Möller and C.Neuenstadt, A stream-temporal query language for ontology based data access, in: KI 2014: Advances in Artificial Intelligence – 37th Annual German Conference on AI, Proceedings, Stuttgart, Germany, September 22–26, C.Lutz and M.Thielscher, eds, Lecture Notes in Computer Science, Vol. 8736, Springer, 2014, pp. 183–194, https://doi.org/10.1007/978-3-319-11206-0_18. ISBN 978-3-319-11205-3. doi:10.1007/978-3-319-11206-0_18.
48.
A.Pnueli, The temporal logic of programs, in: 18th Annual Symposium on Foundations of Computer Science, Providence, Rhode Island, USA, 31 October–1 November 1977, IEEE Computer Society, 1977, pp. 46–57, https://doi.org/10.1109/SFCS.1977.32. doi:10.1109/SFCS.1977.32.
49.
Y.Ren and J.Z.Pan, Optimising ontology stream reasoning with truth maintenance system, in: Proceedings of the 20th ACM Conference on Information and Knowledge Management, CIKM 2011, Glasgow, United Kingdom, October 24–28, 2011, C.Macdonald, I.Ounis and I.Ruthven, eds, ACM, 2011, pp. 831–836. ISBN 978-1-4503-0717-8. doi:10.1145/2063576.2063696.
50.
R.Rosati, On conjunctive query answering in EL, in: Proceedings of the 2007 International Workshop on Description Logics (DL2007), Brixen-Bressanone, Near Bozen-Bolzano, Italy, 8–10 June, 2007, D.Calvanese, E.Franconi, V.Haarslev, D.Lembo, B.Motik, A.Turhan and S.Tessaris, eds, CEUR Workshop Proceedings, Vols 250, CEUR-WS.org, 2007, http://ceur-ws.org/Vol-250/paper_83.pdf.
51.
R.Rosati, On the complexity of dealing with inconsistency in description logic ontologies, in: IJCAI 2011, Proceedings of the 22nd International Joint Conference on Artificial Intelligence, Barcelona, Catalonia, Spain, July 16–22, 2011, T.Walsh, ed., IJCAI/AAAI, 2011, pp. 1057–1062, https://doi.org/10.5591/978-1-57735-516-8/IJCAI11-181. ISBN 978-1-57735-516-8. doi:10.5591/978-1-57735-516-8/IJCAI11-181.
52.
R.Rosati, M.Ruzzi, M.Graziosi and G.Masotti, Evaluation of techniques for inconsistency handling in OWL 2 QL ontologies, in: The Semantic Web – ISWC 2012 – 11th International Semantic Web Conference, Proceedings, Part II, Boston, MA, USA, November 11–15, 2012, P.Cudré-Mauroux, J.Heflin, E.Sirin, T.Tudorache, J.Euzenat, M.Hauswirth, J.X.Parreira, J.Hendler, G.Schreiber, A.Bernstein and E.Blomqvist, eds, Lecture Notes in Computer Science, Vol. 7650, Springer, 2012, pp. 337–349, https://doi.org/10.1007/978-3-642-35173-0_23. ISBN 978-3-642-35172-3. doi:10.1007/978-3-642-35173-0_23.
53.
V.Thost, J.Holste and Ö.L.Özçep, On implementing temporal query answering in DL-Lite (extended abstract), in: Proceedings of the 28th International Workshop on Description Logics, Athens, Greece, June 7–10, 2015, D.Calvanese and B.Konev, eds, CEUR Workshop Proceedings, Vols 1350, CEUR-WS.org, 2015, http://ceur-ws.org/Vol-1350/paper-63.pdf.
54.
E.Tsalapati, G.Stoilos, G.B.Stamou and G.Koletsos, Efficient query answering over expressive inconsistent description logics, in: Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI 2016, New York, NY, USA, 2016, 9–15 July, S.Kambhampati, ed., IJCAI/AAAI Press, 2016, pp. 1279–1285, http://www.ijcai.org/Abstract/16/185. ISBN 978-1-57735-770-4.