70 research outputs found
Existential Second-Order Logic Over Graphs: A Complete Complexity-Theoretic Classification
Descriptive complexity theory aims at inferring a problem's computational
complexity from the syntactic complexity of its description. A cornerstone of
this theory is Fagin's Theorem, by which a graph property is expressible in
existential second-order logic (ESO logic) if, and only if, it is in NP. A
natural question, from the theory's point of view, is which syntactic fragments
of ESO logic also still characterize NP. Research on this question has
culminated in a dichotomy result by Gottlob, Kolatis, and Schwentick: for each
possible quantifier prefix of an ESO formula, the resulting prefix class either
contains an NP-complete problem or is contained in P. However, the exact
complexity of the prefix classes inside P remained elusive. In the present
paper, we clear up the picture by showing that for each prefix class of ESO
logic, its reduction closure under first-order reductions is either FO, L, NL,
or NP. For undirected, self-loop-free graphs two containment results are
especially challenging to prove: containment in L for the prefix and containment in FO for the prefix
for monadic . The complex argument by
Gottlob, Kolatis, and Schwentick concerning polynomial time needs to be
carefully reexamined and either combined with the logspace version of
Courcelle's Theorem or directly improved to first-order computations. A
different challenge is posed by formulas with the prefix : We show that they express special constraint satisfaction problems
that lie in L.Comment: Technical report version of a STACS 2015 pape
Query complexity of membership comparable sets
AbstractThis paper investigates how many queries to k-membership comparable sets are needed in order to decide all (k+1)-membership comparable sets. For k⩾2 this query complexity is at least linear and at most cubic. As a corollary, we obtain that more languages are O(logn)-membership comparable than truth-table reducible to P-selective sets
Fast Parallel Fixed-Parameter Algorithms via Color Coding
Fixed-parameter algorithms have been successfully applied to solve numerous
difficult problems within acceptable time bounds on large inputs. However, most
fixed-parameter algorithms are inherently \emph{sequential} and, thus, make no
use of the parallel hardware present in modern computers. We show that parallel
fixed-parameter algorithms do not only exist for numerous parameterized
problems from the literature -- including vertex cover, packing problems,
cluster editing, cutting vertices, finding embeddings, or finding matchings --
but that there are parallel algorithms working in \emph{constant} time or at
least in time \emph{depending only on the parameter} (and not on the size of
the input) for these problems. Phrased in terms of complexity classes, we place
numerous natural parameterized problems in parameterized versions of AC. On
a more technical level, we show how the \emph{color coding} method can be
implemented in constant time and apply it to embedding problems for graphs of
bounded tree-width or tree-depth and to model checking first-order formulas in
graphs of bounded degree
Computing Shortest Paths in Series-Parallel Graphs in Logarithmic Space
Series-parallel graphs, which are built by repeatedly applying
series or parallel composition operations to paths, play an
important role in computer science as they model the flow of
information in many types of programs. For directed series-parallel
graphs, we study the problem of finding a shortest path between two
given vertices. Our main result is that we can find such a path in
logarithmic space, which shows that the distance problem for
series-parallel graphs is L-complete. Previously, it was known
that one can compute some path in logarithmic space; but for
other graph types, like undirected graphs or tournament graphs,
constructing some path between given vertices is possible in
logarithmic space while constructing a shortest path is
NL-complete
Parallel Multivariate Meta-Theorems
Fixed-parameter tractability is based on the observation that many hard problems become tractable even on large inputs as long as certain input parameters are small. Originally, "tractable" just meant "solvable in polynomial time," but especially modern hardware raises the question of whether we can also achieve "solvable in polylogarithmic parallel time." A framework for this study of parallel fixed-parameter tractability is available and a number of isolated algorithmic results have been obtained in recent years, but one of the unifying core tools of classical FPT theory has been missing: algorithmic meta-theorems. We establish two such theorems by giving new upper bounds on the circuit depth necessary to solve the model checking problem for monadic second-order logic, once parameterized by the tree width and the formula (this is a parallel version of Courcelle\u27s Theorem) and once by the tree depth and the formula. For our proofs we refine the analysis of earlier algorithms, especially of Bodlaender\u27s, but also need to add new ideas, especially in the context where the parallel runtime is bounded by a function of the parameter and does not depend on the length of the input
Computing Hitting Set Kernels By AC^0-Circuits
Given a hypergraph H = (V,E), what is the smallest subset X of V such that e and X are not disjoint for all e in E? This problem, known as the hitting set problem, is a basic problem in parameterized complexity theory. There are well-known kernelization algorithms for it, which get a hypergraph H and a number k as input and output a hypergraph H\u27 such that (1) H has a hitting set of size k if, and only if, H\u27 has such a hitting set and (2) the size of H\u27 depends only on k and on the maximum cardinality d of edges in H. The algorithms run in polynomial time, but are highly sequential. Recently, it has been shown that one of them can be parallelized to a certain degree: one can compute hitting set kernels in parallel time O(d) - but it was conjectured that this is the best parallel algorithm possible. We refute this conjecture and show how hitting set kernels can be computed in constant parallel time. For our proof, we introduce a new, generalized notion of hypergraph sunflowers and show how iterated applications of the color coding technique can sometimes be collapsed into a single application
On the Descriptive Complexity of Color Coding
Color coding is an algorithmic technique used in parameterized complexity theory to detect "small" structures inside graphs. The idea is to derandomize algorithms that first randomly color a graph and then search for an easily-detectable, small color pattern. We transfer color coding to the world of descriptive complexity theory by characterizing - purely in terms of the syntactic structure of describing formulas - when the powerful second-order quantifiers representing a random coloring can be replaced by equivalent, simple first-order formulas. Building on this result, we identify syntactic properties of first-order quantifiers that can be eliminated from formulas describing parameterized problems. The result applies to many packing and embedding problems, but also to the long path problem. Together with a new result on the parameterized complexity of formula families involving only a fixed number of variables, we get that many problems lie in fpt just because of the way they are commonly described using logical formulas
Dynamic Kernels for Hitting Sets and Set Packing
Computing small kernels for the hitting set problem is a well-studied computational problem where we are given a hypergraph with n vertices and m hyperedges, each of size d for some small constant d, and a parameter k. The task is to compute a new hypergraph, called a kernel, whose size is polynomial with respect to the parameter k and which has a size-k hitting set if, and only if, the original hypergraph has one. State-of-the-art algorithms compute kernels of size k^d (which is a polynomial kernel size as d is a constant), and they do so in time m? 2^d poly(d) for a small polynomial poly(d) (which is a linear runtime as d is again a constant).
We generalize this task to the dynamic setting where hyperedges may continuously be added or deleted and one constantly has to keep track of a size-k^d hitting set kernel in memory (including moments when no size-k hitting set exists). This paper presents a deterministic solution with worst-case time 3^d poly(d) for updating the kernel upon hyperedge inserts and time 5^d poly(d) for updates upon deletions. These bounds nearly match the time 2^d poly(d) needed by the best static algorithm per hyperedge. Let us stress that for constant d our algorithm maintains a dynamic hitting set kernel with constant, deterministic, worst-case update time that is independent of n, m, and the parameter k. As a consequence, we also get a deterministic dynamic algorithm for keeping track of size-k hitting sets in d-hypergraphs with update times O(1) and query times O(c^k) where c = d - 1 + O(1/d) equals the best base known for the static setting
Kernelizing the Hitting Set Problem in Linear Sequential and Constant Parallel Time
We analyze a reduction rule for computing kernels for the hitting set problem: In a hypergraph, the link of a set c of vertices consists of all edges that are supersets of c. We call such a set critical if its link has certain easy-to-check size properties. The rule states that the link of a critical c can be replaced by c. It is known that a simple linear-time algorithm for computing hitting set kernels (number of edges) at most k^d (k is the hitting set size, d is the maximum edge size) can be derived from this rule. We parallelize this algorithm and obtain the first AC? kernel algorithm that outputs polynomial-size kernels. Previously, such algorithms were not even known for artificial problems. An interesting application of our methods lies in traditional, non-parameterized approximation theory: Our results imply that uniform AC?-circuits can compute a hitting set whose size is polynomial in the size of an optimal hitting set
- …