7,514 research outputs found

    Compositional Algorithms on Compositional Data: Deciding Sheaves on Presheaves

    Full text link
    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

    Get PDF
    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

    Full text link
    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 O(2h)O^*(2^h), where hh 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

    Full text link
    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 nn-vertex graph, a tree decomposition of the graph of width ww, and an integer tt---decides Treedepth, i.e. whether the treedepth of the graph is at most tt, in time 2O(wt)n2^{O(wt)} \cdot n. 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 22O(t)n2^{2^{O(t)}} \cdot n and 2O(t2)n2^{O(t^2)} \cdot n, 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 tt) that does not rely on Courcelle's Theorem or other heavy machinery. For chordal graphs we can prove a running time of 2O(tlogt)n2^{O(t \log t)}\cdot n for the same algorithm.Comment: An extended abstract was published in ICALP 2014, Track

    Surface Split Decompositions and Subgraph Isomorphism in Graphs on Surfaces

    Get PDF
    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 2O(k)O(n)2^{O(k)} O(n). 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

    Get PDF
    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

    Full text link
    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, kk-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

    Get PDF
    We give alternative definitions for maximum matching width, e.g. a graph GG has mmw(G)k\operatorname{mmw}(G) \leq k if and only if it is a subgraph of a chordal graph HH and for every maximal clique XX of HH there exists A,B,CXA,B,C \subseteq X with ABC=XA \cup B \cup C=X and A,B,Ck|A|,|B|,|C| \leq k such that any subset of XX that is a minimal separator of HH is a subset of either A,BA, B or CC. 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 GG and a branch decomposition of mm-width kk we can solve Dominating Set in time O(8k)O^*({8^k}), thereby beating O(3tw(G))O^*(3^{\operatorname{tw}(G)}) whenever tw(G)>log38×k1.893k\operatorname{tw}(G) > \log_3{8} \times k \approx 1.893 k. Note that mmw(G)tw(G)+13mmw(G)\operatorname{mmw}(G) \leq \operatorname{tw}(G)+1 \leq 3 \operatorname{mmw}(G) and these inequalities are tight. Given only the graph GG and using the best known algorithms to find decompositions, maximum matching width will be better for solving Dominating Set whenever tw(G)>1.549×mmw(G)\operatorname{tw}(G) > 1.549 \times \operatorname{mmw}(G)

    Solving weighted and counting variants of connectivity problems parameterized by treewidth deterministically in single exponential time

    Full text link
    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
    corecore