49,220 research outputs found
Answer Set Solving with Bounded Treewidth Revisited
Parameterized algorithms are a way to solve hard problems more efficiently,
given that a specific parameter of the input is small. In this paper, we apply
this idea to the field of answer set programming (ASP). To this end, we propose
two kinds of graph representations of programs to exploit their treewidth as a
parameter. Treewidth roughly measures to which extent the internal structure of
a program resembles a tree. Our main contribution is the design of
parameterized dynamic programming algorithms, which run in linear time if the
treewidth and weights of the given program are bounded. Compared to previous
work, our algorithms handle the full syntax of ASP. Finally, we report on an
empirical evaluation that shows good runtime behaviour for benchmark instances
of low treewidth, especially for counting answer sets.Comment: This paper extends and updates a paper that has been presented on the
workshop TAASP'16 (arXiv:1612.07601). We provide a higher detail level, full
proofs and more example
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
Stable Model Counting and Its Application in Probabilistic Logic Programming
Model counting is the problem of computing the number of models that satisfy
a given propositional theory. It has recently been applied to solving inference
tasks in probabilistic logic programming, where the goal is to compute the
probability of given queries being true provided a set of mutually independent
random variables, a model (a logic program) and some evidence. The core of
solving this inference task involves translating the logic program to a
propositional theory and using a model counter. In this paper, we show that for
some problems that involve inductive definitions like reachability in a graph,
the translation of logic programs to SAT can be expensive for the purpose of
solving inference tasks. For such problems, direct implementation of stable
model semantics allows for more efficient solving. We present two
implementation techniques, based on unfounded set detection, that extend a
propositional model counter to a stable model counter. Our experiments show
that for particular problems, our approach can outperform a state-of-the-art
probabilistic logic programming solver by several orders of magnitude in terms
of running time and space requirements, and can solve instances of
significantly larger sizes on which the current solver runs out of time or
memory.Comment: Accepted in AAAI, 201
- …