353 research outputs found
Positive-Instance Driven Dynamic Programming for Treewidth
Consider a dynamic programming scheme for a decision problem in which all
subproblems involved are also decision problems. An implementation of such a
scheme is {\em positive-instance driven} (PID), if it generates positive
subproblem instances, but not negative ones, building each on smaller positive
instances.
We take the dynamic programming scheme due to Bouchitt\'{e} and Todinca for
treewidth computation, which is based on minimal separators and potential
maximal cliques, and design a variant (for the decision version of the problem)
with a natural PID implementation. The resulting algorithm performs extremely
well: it solves a number of standard benchmark instances for which the optimal
solutions have not previously been known. Incorporating a new heuristic
algorithm for detecting safe separators, it also solves all of the 100 public
instances posed by the exact treewidth track in PACE 2017, a competition on
algorithm implementation.
We describe the algorithm, prove its correctness, and give a running time
bound in terms of the number of positive subproblem instances. We perform an
experimental analysis which supports the practical importance of such a bound.Comment: A preliminary and abridged version appeared in ESA 201
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
Treewidth in Non-Ground Answer Set Solving and Alliance Problems in Graphs
To solve hard problems efficiently via answer set programming (ASP), a promising approach is to take advantage of the fact that real-world instances of many hard problems exhibit small treewidth. Algorithms that exploit this have already been proposed -- however, they suffer from an enormous overhead. In the thesis, we present improvements in the algorithmic methodology for leveraging bounded treewidth that are especially targeted toward problems involving subset minimization. This can be useful for many problems at the second level of the polynomial hierarchy like solving disjunctive ground ASP. Moreover, we define classes of non-ground ASP programs such that grounding such a program together with input facts does not lead to an excessive increase in treewidth of the resulting ground program when compared to the treewidth of the input. This allows ASP users to take advantage of the fact that state-of-the-art ASP solvers perform better on ground programs of small treewidth. Finally, we resolve several open questions on the complexity of alliance problems in graphs. In particular, we settle the long-standing open questions of the complexity of the Secure Set problem and whether the Defensive Alliance problem is fixed-parameter tractable when parameterized by treewidth
Parameterized Algorithmics for Computational Social Choice: Nine Research Challenges
Computational Social Choice is an interdisciplinary research area involving
Economics, Political Science, and Social Science on the one side, and
Mathematics and Computer Science (including Artificial Intelligence and
Multiagent Systems) on the other side. Typical computational problems studied
in this field include the vulnerability of voting procedures against attacks,
or preference aggregation in multi-agent systems. Parameterized Algorithmics is
a subfield of Theoretical Computer Science seeking to exploit meaningful
problem-specific parameters in order to identify tractable special cases of in
general computationally hard problems. In this paper, we propose nine of our
favorite research challenges concerning the parameterized complexity of
problems appearing in this context
A contraction-recursive algorithm for treewidth
Let tw(G) denote the treewidth of graph G. Given a graph G and a positive
integer k such that tw(G) <= k + 1, we are to decide if tw(G) <= k. We give a
certifying algorithm RTW ("R" for recursive) for this task: it returns one or
more tree-decompositions of G of width <= k if the answer is YES and a minimal
contraction H of G such that tw(H) > k otherwise.
RTW uses a heuristic variant of Tamaki's PID algorithm for treewidth
(ESA2017), which we call HPID. RTW, given G and k, interleaves the execution of
HPID with recursive calls on G /e for edges e of G, where G / e denotes the
graph obtained from G by contracting edge e. If we find that tw(G / e) > k,
then we have tw(G) > k with the same certificate. If we find that tw(G / e) <=
k, we "uncontract" the bags of the certifying tree-decompositions of G / e into
bags of G and feed them to HPID to help progress. If the question is not
resolved after the recursive calls are made for all edges, we finish HPID in an
exhaustive mode. If it turns out that tw(G) > k, then G is a certificate for
tw(G') > k for every G' of which G is a contraction, because we have found tw(G
/ e) <= k for every edge e of G. This final round of HPID guarantees the
correctness of the algorithm, while its practical efficiency derives from our
methods of "uncontracting" bags of tree-decompositions of G / e to useful bags
of G, as well as of exploiting those bags in HPID.
Experiments show that our algorithm drastically extends the scope of
practically solvable instances. In particular, when applied to the 100
instances in the PACE 2017 bonus set, the number of instances solved by our
implementation on a typical laptop, with the timeout of 100, 1000, and 10000
seconds per instance, are 72, 92, and 98 respectively, while these numbers are
11, 38, and 68 for Tamaki's PID solver and 65, 82, and 85 for his new solver
(SEA 2022).Comment: 17 pages, 2 figures, submitted IPEC 202
Finding Optimal Tree Decompositions
The task of organizing a given graph into a structure called a tree decomposition is relevant in multiple areas of computer science. In particular, many NP-hard problems can be solved in polynomial time if a suitable tree decomposition of a graph describing the problem instance is given as a part of the input. This motivates the task of finding as good tree decompositions as possible, or ideally, optimal tree decompositions.
This thesis is about finding optimal tree decompositions of graphs with respect to several notions of optimality. Each of the considered notions measures the quality of a tree decomposition in the context of an application. In particular, we consider a total of seven problems that are formulated as finding optimal tree decompositions: treewidth, minimum fill-in, generalized and fractional hypertreewidth, total table size, phylogenetic character compatibility, and treelength. For each of these problems we consider the BT algorithm of Bouchitté and Todinca as the method of finding optimal tree decompositions.
The BT algorithm is well-known on the theoretical side, but to our knowledge the first time it was implemented was only recently for the 2nd Parameterized Algorithms and Computational Experiments Challenge (PACE 2017). The author’s implementation of the BT algorithm took the second place in the minimum fill-in track of PACE 2017. In this thesis we review and extend the BT algorithm and our implementation. In particular, we improve the eciency of the algorithm in terms of both theory and practice. We also implement the algorithm for each of the seven problems considered, introducing a novel adaptation of the algorithm for the maximum compatibility problem of phylogenetic characters. Our implementation outperforms alternative state-of-the-art approaches in terms of numbers of test instances solved on well-known benchmarks on minimum fill-in, generalized hypertreewidth, fractional hypertreewidth, total table size, and the maximum compatibility problem of phylogenetic characters. Furthermore, to our understanding the implementation is the first exact approach for the treelength problem
PACE Solver Description: Bute-Plus: A Bottom-Up Exact Solver for Treedepth
This note introduces Bute-Plus, an exact solver for the treedepth problem.
The core of the solver is a positive-instance driven dynamic program that
constructs an elimination tree of minimum depth in a bottom-up fashion. Three
features greatly improve the algorithm's run time. The first of these is a
specialised trie data structure. The second is a domination rule. The third is
a heuristic presolve step can quickly find a treedepth decomposition of optimal
depth for many instances.Comment: 4 pages, 1 appendix pages, 0 figures. A version of this tool
description paper without the appendix is published in the proceedings of
IPEC 2020:
https://drops.dagstuhl.de/opus/volltexte/2020/13337/pdf/LIPIcs-IPEC-2020-34.pdf
. Changes: this version expands the paper from a preliminary versio
- …