7,514 research outputs found
Compositional Algorithms on Compositional Data: Deciding Sheaves on Presheaves
Algorithmicists are well-aware that fast dynamic programming algorithms are
very often the correct choice when computing on compositional (or even
recursive) graphs. Here we initiate the study of how to generalize this
folklore intuition to mathematical structures writ large. We achieve this
horizontal generality by adopting a categorial perspective which allows us to
show that: (1) structured decompositions (a recent, abstract generalization of
many graph decompositions) define Grothendieck topologies on categories of data
(adhesive categories) and that (2) any computational problem which can be
represented as a sheaf with respect to these topologies can be decided in
linear time on classes of inputs which admit decompositions of bounded width
and whose decomposition shapes have bounded feedback vertex number. This
immediately leads to algorithms on objects of any C-set category; these include
-- to name but a few examples -- structures such as: symmetric graphs, directed
graphs, directed multigraphs, hypergraphs, directed hypergraphs, databases,
simplicial complexes, circular port graphs and half-edge graphs.
Thus we initiate the bridging of tools from sheaf theory, structural graph
theory and parameterized complexity theory; we believe this to be a very
fruitful approach for a general, algebraic theory of dynamic programming
algorithms. Finally we pair our theoretical results with concrete
implementations of our main algorithmic contribution in the AlgebraicJulia
ecosystem.Comment: Revised and simplified notation and improved exposition. The
companion code can be found here:
https://github.com/AlgebraicJulia/StructuredDecompositions.j
Dynamic programming for graphs on surfaces
We provide a framework for the design and analysis of dynamic
programming algorithms for surface-embedded graphs on n vertices
and branchwidth at most k. Our technique applies to general families
of problems where standard dynamic programming runs in 2O(k·log k).
Our approach combines tools from topological graph theory and
analytic combinatorics.Postprint (updated version
Space Saving by Dynamic Algebraization
Dynamic programming is widely used for exact computations based on tree
decompositions of graphs. However, the space complexity is usually exponential
in the treewidth. We study the problem of designing efficient dynamic
programming algorithm based on tree decompositions in polynomial space. We show
how to construct a tree decomposition and extend the algebraic techniques of
Lokshtanov and Nederlof such that the dynamic programming algorithm runs in
time , where is the maximum number of vertices in the union of
bags on the root to leaf paths on a given tree decomposition, which is a
parameter closely related to the tree-depth of a graph. We apply our algorithm
to the problem of counting perfect matchings on grids and show that it
outperforms other polynomial-space solutions. We also apply the algorithm to
other set covering and partitioning problems.Comment: 14 pages, 1 figur
A Faster Parameterized Algorithm for Treedepth
The width measure \emph{treedepth}, also known as vertex ranking, centered
coloring and elimination tree height, is a well-established notion which has
recently seen a resurgence of interest. We present an algorithm which---given
as input an -vertex graph, a tree decomposition of the graph of width ,
and an integer ---decides Treedepth, i.e. whether the treedepth of the graph
is at most , in time . If necessary, a witness structure
for the treedepth can be constructed in the same running time. In conjunction
with previous results we provide a simple algorithm and a fast algorithm which
decide treedepth in time and ,
respectively, which do not require a tree decomposition as part of their input.
The former answers an open question posed by Ossona de Mendez and Nesetril as
to whether deciding Treedepth admits an algorithm with a linear running time
(for every fixed ) that does not rely on Courcelle's Theorem or other heavy
machinery. For chordal graphs we can prove a running time of for the same algorithm.Comment: An extended abstract was published in ICALP 2014, Track
Surface Split Decompositions and Subgraph Isomorphism in Graphs on Surfaces
The Subgraph Isomorphism problem asks, given a host graph G on n vertices and
a pattern graph P on k vertices, whether G contains a subgraph isomorphic to P.
The restriction of this problem to planar graphs has often been considered.
After a sequence of improvements, the current best algorithm for planar graphs
is a linear time algorithm by Dorn (STACS '10), with complexity .
We generalize this result, by giving an algorithm of the same complexity for
graphs that can be embedded in surfaces of bounded genus. At the same time, we
simplify the algorithm and analysis. The key to these improvements is the
introduction of surface split decompositions for bounded genus graphs, which
generalize sphere cut decompositions for planar graphs. We extend the algorithm
for the problem of counting and generating all subgraphs isomorphic to P, even
for the case where P is disconnected. This answers an open question by Eppstein
(SODA '95 / JGAA '99)
Dynamic Programming for Graphs on Surfaces
We provide a framework for the design and analysis of dynamic programming
algorithms for surface-embedded graphs on n vertices and branchwidth at most k.
Our technique applies to general families of problems where standard dynamic
programming runs in 2^{O(k log k)} n steps. Our approach combines tools from
topological graph theory and analytic combinatorics. In particular, we
introduce a new type of branch decomposition called "surface cut
decomposition", generalizing sphere cut decompositions of planar graphs
introduced by Seymour and Thomas, which has nice combinatorial properties.
Namely, the number of partial solutions that can be arranged on a surface cut
decomposition can be upper-bounded by the number of non-crossing partitions on
surfaces with boundary. It follows that partial solutions can be represented by
a single-exponential (in the branchwidth k) number of configurations. This
proves that, when applied on surface cut decompositions, dynamic programming
runs in 2^{O(k)} n steps. That way, we considerably extend the class of
problems that can be solved in running times with a single-exponential
dependence on branchwidth and unify/improve most previous results in this
direction.Comment: 28 pages, 3 figure
A practical fpt algorithm for Flow Decomposition and transcript assembly
The Flow Decomposition problem, which asks for the smallest set of weighted
paths that "covers" a flow on a DAG, has recently been used as an important
computational step in transcript assembly. We prove the problem is in FPT when
parameterized by the number of paths by giving a practical linear fpt
algorithm. Further, we implement and engineer a Flow Decomposition solver based
on this algorithm, and evaluate its performance on RNA-sequence data.
Crucially, our solver finds exact solutions while achieving runtimes
competitive with a state-of-the-art heuristic. Finally, we contextualize our
design choices with two hardness results related to preprocessing and weight
recovery. Specifically, -Flow Decomposition does not admit polynomial
kernels under standard complexity assumptions, and the related problem of
assigning (known) weights to a given set of paths is NP-hard.Comment: Introduces software package Toboggan: Version 1.0.
http://dx.doi.org/10.5281/zenodo.82163
Maximum matching width: new characterizations and a fast algorithm for dominating set
We give alternative definitions for maximum matching width, e.g. a graph
has if and only if it is a subgraph of a chordal
graph and for every maximal clique of there exists with and such that any subset of
that is a minimal separator of is a subset of either or .
Treewidth and branchwidth have alternative definitions through intersections of
subtrees, where treewidth focuses on nodes and branchwidth focuses on edges. We
show that mm-width combines both aspects, focusing on nodes and on edges. Based
on this we prove that given a graph and a branch decomposition of mm-width
we can solve Dominating Set in time , thereby beating
whenever . Note that and these inequalities are
tight. Given only the graph and using the best known algorithms to find
decompositions, maximum matching width will be better for solving Dominating
Set whenever
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
- …