107 research outputs found
Complexity of Monadic inf-datalog. Application to temporal logic.
In [11] we defined Inf-Datalog and characterized the fragments of Monadic inf-Datalog that have the same expressive power as Modal Logic (resp. , alternation-free Modal -calculus and Modal -calculus). We study here the time and space complexity of evaluation of Monadic inf-Datalog programs on finite models. We deduce a new unified proof that model checking has 1. linear data and program complexities (both in time and space) for and alternation-free Modal -calculus, and 2. linear-space (data and program) complexities, linear-time program complexity and polynomial-time data complexity for (Modal -calculus with fixed alternation-depth at most ).
Decidability Results for the Boundedness Problem
We prove decidability of the boundedness problem for monadic least
fixed-point recursion based on positive monadic second-order (MSO) formulae
over trees. Given an MSO-formula phi(X,x) that is positive in X, it is
decidable whether the fixed-point recursion based on phi is spurious over the
class of all trees in the sense that there is some uniform finite bound for the
number of iterations phi takes to reach its least fixed point, uniformly across
all trees. We also identify the exact complexity of this problem. The proof
uses automata-theoretic techniques. This key result extends, by means of
model-theoretic interpretations, to show decidability of the boundedness
problem for MSO and guarded second-order logic (GSO) over the classes of
structures of fixed finite tree-width. Further model-theoretic transfer
arguments allow us to derive major known decidability results for boundedness
for fragments of first-order logic as well as new ones
On relating CTL to Datalog
CTL is the dominant temporal specification language in practice mainly due to
the fact that it admits model checking in linear time. Logic programming and
the database query language Datalog are often used as an implementation
platform for logic languages. In this paper we present the exact relation
between CTL and Datalog and moreover we build on this relation and known
efficient algorithms for CTL to obtain efficient algorithms for fragments of
stratified Datalog. The contributions of this paper are: a) We embed CTL into
STD which is a proper fragment of stratified Datalog. Moreover we show that STD
expresses exactly CTL -- we prove that by embedding STD into CTL. Both
embeddings are linear. b) CTL can also be embedded to fragments of Datalog
without negation. We define a fragment of Datalog with the successor build-in
predicate that we call TDS and we embed CTL into TDS in linear time. We build
on the above relations to answer open problems of stratified Datalog. We prove
that query evaluation is linear and that containment and satisfiability
problems are both decidable. The results presented in this paper are the first
for fragments of stratified Datalog that are more general than those containing
only unary EDBs.Comment: 34 pages, 1 figure (file .eps
The Complexity of Datalog on Linear Orders
We study the program complexity of datalog on both finite and infinite linear
orders. Our main result states that on all linear orders with at least two
elements, the nonemptiness problem for datalog is EXPTIME-complete. While
containment of the nonemptiness problem in EXPTIME is known for finite linear
orders and actually for arbitrary finite structures, it is not obvious for
infinite linear orders. It sharply contrasts the situation on other infinite
structures; for example, the datalog nonemptiness problem on an infinite
successor structure is undecidable. We extend our upper bound results to
infinite linear orders with constants.
As an application, we show that the datalog nonemptiness problem on Allen's
interval algebra is EXPTIME-complete.Comment: 21 page
Monadic Queries over Tree-Structured Data
Monadic query languages over trees currently receive considerable interest in the database community, as the problem of selecting nodes from a tree is the most basic and widespread database query problem in the context of XML. Partly a survey of recent work done by the authors and their group on logical query languages for this problem and their expressiveness, this paper provides a number of new results related to the complexity of such languages over so-called axis relations (such as "child" or "descendant") which are motivated by their presence in the XPath standard or by their utility for data extraction (wrapping)
Deciding FO-rewritability of Regular Languages and Ontology-Mediated Queries in Linear Temporal Logic
Our concern is the problem of determining the data complexity of answering an ontology-mediated query (OMQ) formulated in linear temporal logic LTL over (Z,<) and deciding whether it is rewritable to an FO(<)-query, possibly with some extra predicates. First, we observe that, in line with the circuit complexity and FO-definability of regular languages, OMQ answering in AC0, ACC0 and NC1 coincides with FO(<,≡)-rewritability using unary predicates x ≡ 0 (mod n), FO(<,MOD)-rewritability, and FO(RPR)-rewritability using relational primitive recursion, respectively. We prove that, similarly to known PSᴘᴀᴄᴇ-completeness of recognising FO(<)-definability of regular languages, deciding FO(<,≡)- and FO(<,MOD)-definability is also PSᴘᴀᴄᴇ-complete (unless ACC0 = NC1). We then use this result to show that deciding FO(<)-, FO(<,≡)- and FO(<,MOD)-rewritability of LTL OMQs is ExᴘSᴘᴀᴄᴇ-complete, and that these problems become PSᴘᴀᴄᴇ-complete for OMQs with a linear Horn ontology and an atomic query, and also a positive query in the cases of FO(<)- and FO(<,≡)-rewritability. Further, we consider FO(<)-rewritability of OMQs with a binary-clause ontology and identify OMQ classes, for which deciding it is PSᴘᴀᴄᴇ-, Π2p- and coNP-complete
- …