49 research outputs found
Explicit linear kernels via dynamic programming
Several algorithmic meta-theorems on kernelization have appeared in the last
years, starting with the result of Bodlaender et al. [FOCS 2009] on graphs of
bounded genus, then generalized by Fomin et al. [SODA 2010] to graphs excluding
a fixed minor, and by Kim et al. [ICALP 2013] to graphs excluding a fixed
topological minor. Typically, these results guarantee the existence of linear
or polynomial kernels on sparse graph classes for problems satisfying some
generic conditions but, mainly due to their generality, it is not clear how to
derive from them constructive kernels with explicit constants. In this paper we
make a step toward a fully constructive meta-kernelization theory on sparse
graphs. Our approach is based on a more explicit protrusion replacement
machinery that, instead of expressibility in CMSO logic, uses dynamic
programming, which allows us to find an explicit upper bound on the size of the
derived kernels. We demonstrate the usefulness of our techniques by providing
the first explicit linear kernels for -Dominating Set and -Scattered Set
on apex-minor-free graphs, and for Planar-\mathcal{F}-Deletion on graphs
excluding a fixed (topological) minor in the case where all the graphs in
\mathcal{F} are connected.Comment: 32 page
On-Line Reevaluation of Functions
Given a finite set S and a function f : S^n -> S^m, we consider the problem of making a data structure which maintains a value of x in S^n and allows us to efficiently change an arbitrary coordinate of x and efficiently evaluate f_i(x) for arbitrary i. We both examine the problem for specific choices of f and relate the possibility of an efficient solution to general properties of f: expressibility as a formula, space complexity and time complexity
Inherent Complexity of Recursive Queries
AbstractWe give lower bounds on the complexity of certain Datalog queries. Our notion of complexity applies to compile-time optimization techniques for Datalog; thus, our results indicate limitations of these techniques. The main new tool is linear first-order formulas, whose depth (respectively, number of variables) matches the sequential (respectively, parallel) complexity of Datalog programs. We define a combinatorial game (a variant of Ehrenfeucht–Fraı̈ssé games) that can be used to prove nonexpressibility by linear formulas. We thus obtain lower bounds for the sequential and parallel complexity of Datalog queries. We prove syntactically tight versions of our results, by exploiting uniformity and invariance properties of Datalog queries
On the Strength of Uniqueness Quantification in Primitive Positive Formulas
Uniqueness quantification (Exists!) is a quantifier in first-order logic where one requires that exactly one element exists satisfying a given property. In this paper we investigate the strength of uniqueness quantification when it is used in place of existential quantification in conjunctive formulas over a given set of relations Gamma, so-called primitive positive definitions (pp-definitions). We fully classify the Boolean sets of relations where uniqueness quantification has the same strength as existential quantification in pp-definitions and give several results valid for arbitrary finite domains. We also consider applications of Exists!-quantified pp-definitions in computer science, which can be used to study the computational complexity of problems where the number of solutions is important. Using our classification we give a new and simplified proof of the trichotomy theorem for the unique satisfiability problem, and prove a general result for the unique constraint satisfaction problem. Studying these problems in a more rigorous framework also turns out to be advantageous in the context of lower bounds, and we relate the complexity of these problems to the exponential-time hypothesis
Datalog-Expressibility for Monadic and Guarded Second-Order Logic
We characterise the sentences in Monadic Second-order Logic (MSO) that are over finite structures equivalent to a Datalog program, in terms of an existential pebble game. We also show that for every class C of finite structures that can be expressed in MSO and is closed under homomorphisms, and for all ?,k ?there exists a canonical Datalog program ? of width (?,k), that is, a Datalog program of width (?,k) which is sound for C (i.e., ? only derives the goal predicate on a finite structure ? if ? ? C) and with the property that ? derives the goal predicate whenever some Datalog program of width (?,k) which is sound for C derives the goal predicate. The same characterisations also hold for Guarded Second-order Logic (GSO), which properly extends MSO. To prove our results, we show that every class C in GSO whose complement is closed under homomorphisms is a finite union of constraint satisfaction problems (CSPs) of ?-categorical structures
Ontology-Mediated Querying with Horn Description Logics
An ontology-mediated query (OMQ) consists of a database query paired with an ontology. When evaluated on a database, an OMQ returns not only the answers that are already in the database, but also those answers that can be obtained via logical reasoning using rules from ontology. There are many open questions regarding the complexities of problems related to OMQs. Motivated by the use of ontologies in practice, new reasoning problems which have never been considered in the context of ontologies become relevant, since they can improve the usability of ontology enriched systems. This thesis deals with various reasoning problems that occur when working with OMQs and it investigates the computational complexity of these problems. We focus on ontologies formulated in Horn description logics, which are a popular choice for ontologies in practice
The algebraic structure of the densification and the sparsification tasks for CSPs
The tractability of certain CSPs for dense or sparse instances is known from
the 90s. Recently, the densification and the sparsification of CSPs were
formulated as computational tasks and the systematical study of their
computational complexity was initiated.
We approach this problem by introducing the densification operator, i.e. the
closure operator that, given an instance of a CSP, outputs all constraints that
are satisfied by all of its solutions. According to the Galois theory of
closure operators, any such operator is related to a certain implicational
system (or, a functional dependency) . We are specifically interested
in those classes of fixed-template CSPs, parameterized by constraint languages
, for which the size of an implicational system is a
polynomial in the number of variables . We show that in the Boolean case,
is of polynomial size if and only if is of bounded width. For
such languages, can be computed in log-space or in a logarithmic time
with a polynomial number of processors. Given an implicational system ,
the densification task is equivalent to the computation of the closure of input
constraints. The sparsification task is equivalent to the computation of the
minimal key. This leads to -algorithm for
the sparsification task where is the number of non-redundant
sparsifications of an original CSP.
Finally, we give a complete classification of constraint languages over the
Boolean domain for which the densification problem is tractable