255 research outputs found
Counting Complexity for Reasoning in Abstract Argumentation
In this paper, we consider counting and projected model counting of
extensions in abstract argumentation for various semantics. When asking for
projected counts we are interested in counting the number of extensions of a
given argumentation framework while multiple extensions that are identical when
restricted to the projected arguments count as only one projected extension. We
establish classical complexity results and parameterized complexity results
when the problems are parameterized by treewidth of the undirected
argumentation graph. To obtain upper bounds for counting projected extensions,
we introduce novel algorithms that exploit small treewidth of the undirected
argumentation graph of the input instance by dynamic programming (DP). Our
algorithms run in time double or triple exponential in the treewidth depending
on the considered semantics. Finally, we take the exponential time hypothesis
(ETH) into account and establish lower bounds of bounded treewidth algorithms
for counting extensions and projected extension.Comment: Extended version of a paper published at AAAI-1
Solving weighted and counting variants of connectivity problems parameterized by treewidth deterministically in single exponential time
It is well known that many local graph problems, like Vertex Cover and
Dominating Set, can be solved in 2^{O(tw)}|V|^{O(1)} time for graphs G=(V,E)
with a given tree decomposition of width tw. However, for nonlocal problems,
like the fundamental class of connectivity problems, for a long time we did not
know how to do this faster than tw^{O(tw)}|V|^{O(1)}. Recently, Cygan et al.
(FOCS 2011) presented Monte Carlo algorithms for a wide range of connectivity
problems running in time $c^{tw}|V|^{O(1)} for a small constant c, e.g., for
Hamiltonian Cycle and Steiner tree. Naturally, this raises the question whether
randomization is necessary to achieve this runtime; furthermore, it is
desirable to also solve counting and weighted versions (the latter without
incurring a pseudo-polynomial cost in terms of the weights).
We present two new approaches rooted in linear algebra, based on matrix rank
and determinants, which provide deterministic c^{tw}|V|^{O(1)} time algorithms,
also for weighted and counting versions. For example, in this time we can solve
the traveling salesman problem or count the number of Hamiltonian cycles. The
rank-based ideas provide a rather general approach for speeding up even
straightforward dynamic programming formulations by identifying "small" sets of
representative partial solutions; we focus on the case of expressing
connectivity via sets of partitions, but the essential ideas should have
further applications. The determinant-based approach uses the matrix tree
theorem for deriving closed formulas for counting versions of connectivity
problems; we show how to evaluate those formulas via dynamic programming.Comment: 36 page
Lower Bounds for the Graph Homomorphism Problem
The graph homomorphism problem (HOM) asks whether the vertices of a given
-vertex graph can be mapped to the vertices of a given -vertex graph
such that each edge of is mapped to an edge of . The problem
generalizes the graph coloring problem and at the same time can be viewed as a
special case of the -CSP problem. In this paper, we prove several lower
bound for HOM under the Exponential Time Hypothesis (ETH) assumption. The main
result is a lower bound .
This rules out the existence of a single-exponential algorithm and shows that
the trivial upper bound is almost asymptotically
tight.
We also investigate what properties of graphs and make it difficult
to solve HOM. An easy observation is that an upper
bound can be improved to where
is the minimum size of a vertex cover of . The second
lower bound shows that the upper bound is
asymptotically tight. As to the properties of the "right-hand side" graph ,
it is known that HOM can be solved in time and
where is the maximum degree of
and is the treewidth of . This gives
single-exponential algorithms for graphs of bounded maximum degree or bounded
treewidth. Since the chromatic number does not exceed
and , it is natural to ask whether similar
upper bounds with respect to can be obtained. We provide a negative
answer to this question by establishing a lower bound for any
function . We also observe that similar lower bounds can be obtained for
locally injective homomorphisms.Comment: 19 page
On space efficiency of algorithms working on structural decompositions of graphs
Dynamic programming on path and tree decompositions of graphs is a technique
that is ubiquitous in the field of parameterized and exponential-time
algorithms. However, one of its drawbacks is that the space usage is
exponential in the decomposition's width. Following the work of Allender et al.
[Theory of Computing, '14], we investigate whether this space complexity
explosion is unavoidable. Using the idea of reparameterization of Cai and
Juedes [J. Comput. Syst. Sci., '03], we prove that the question is closely
related to a conjecture that the Longest Common Subsequence problem
parameterized by the number of input strings does not admit an algorithm that
simultaneously uses XP time and FPT space. Moreover, we complete the complexity
landscape sketched for pathwidth and treewidth by Allender et al. by
considering the parameter tree-depth. We prove that computations on tree-depth
decompositions correspond to a model of non-deterministic machines that work in
polynomial time and logarithmic space, with access to an auxiliary stack of
maximum height equal to the decomposition's depth. Together with the results of
Allender et al., this describes a hierarchy of complexity classes for
polynomial-time non-deterministic machines with different restrictions on the
access to working space, which mirrors the classic relations between treewidth,
pathwidth, and tree-depth.Comment: An extended abstract appeared in the proceedings of STACS'16. The new
version is augmented with a space-efficient algorithm for Dominating Set
using the Chinese remainder theore
Treewidth-aware Reductions of Normal ASP to SAT -- Is Normal ASP Harder than SAT after All?
Answer Set Programming (ASP) is a paradigm for modeling and solving problems
for knowledge representation and reasoning. There are plenty of results
dedicated to studying the hardness of (fragments of) ASP. So far, these studies
resulted in characterizations in terms of computational complexity as well as
in fine-grained insights presented in form of dichotomy-style results, lower
bounds when translating to other formalisms like propositional satisfiability
(SAT), and even detailed parameterized complexity landscapes. A generic
parameter in parameterized complexity originating from graph theory is the
so-called treewidth, which in a sense captures structural density of a program.
Recently, there was an increase in the number of treewidth-based solvers
related to SAT. While there are translations from (normal) ASP to SAT, no
reduction that preserves treewidth or at least keeps track of the treewidth
increase is known. In this paper we propose a novel reduction from normal ASP
to SAT that is aware of the treewidth, and guarantees that a slight increase of
treewidth is indeed sufficient. Further, we show a new result establishing
that, when considering treewidth, already the fragment of normal ASP is
slightly harder than SAT (under reasonable assumptions in computational
complexity). This also confirms that our reduction probably cannot be
significantly improved and that the slight increase of treewidth is
unavoidable. Finally, we present an empirical study of our novel reduction from
normal ASP to SAT, where we compare treewidth upper bounds that are obtained
via known decomposition heuristics. Overall, our reduction works better with
these heuristics than existing translations
- …