6 research outputs found

    The Complexity of Approximately Counting Tree Homomorphisms

    Full text link
    We study two computational problems, parameterised by a fixed tree H. #HomsTo(H) is the problem of counting homomorphisms from an input graph G to H. #WHomsTo(H) is the problem of counting weighted homomorphisms to H, given an input graph G and a weight function for each vertex v of G. Even though H is a tree, these problems turn out to be sufficiently rich to capture all of the known approximation behaviour in #P. We give a complete trichotomy for #WHomsTo(H). If H is a star then #WHomsTo(H) is in FP. If H is not a star but it does not contain a certain induced subgraph J_3 then #WHomsTo(H) is equivalent under approximation-preserving (AP) reductions to #BIS, the problem of counting independent sets in a bipartite graph. This problem is complete for the class #RHPi_1 under AP-reductions. Finally, if H contains an induced J_3 then #WHomsTo(H) is equivalent under AP-reductions to #SAT, the problem of counting satisfying assignments to a CNF Boolean formula. Thus, #WHomsTo(H) is complete for #P under AP-reductions. The results are similar for #HomsTo(H) except that a rich structure emerges if H contains an induced J_3. We show that there are trees H for which #HomsTo(H) is #SAT-equivalent (disproving a plausible conjecture of Kelk). There is an interesting connection between these homomorphism-counting problems and the problem of approximating the partition function of the ferromagnetic Potts model. In particular, we show that for a family of graphs J_q, parameterised by a positive integer q, the problem #HomsTo(H) is AP-interreducible with the problem of approximating the partition function of the q-state Potts model. It was not previously known that the Potts model had a homomorphism-counting interpretation. We use this connection to obtain some additional upper bounds for the approximation complexity of #HomsTo(J_q)

    The Complexity of Computing the Sign of the Tutte Polynomial

    Get PDF
    We study the complexity of computing the sign of the Tutte polynomial of a graph. As there are only three possible outcomes (positive, negative, and zero), this seems at first sight more like a decision problem than a counting problem. Surprisingly, however, there are large regions of the parameter space for which computing the sign of the Tutte polynomial is actually #P-hard. As a trivial consequence, approximating the polynomial is also #P-hard in this case. Thus, approximately evaluating the Tutte polynomial in these regions is as hard as exactly counting the satisfying assignments to a CNF Boolean formula. For most other points in the parameter space, we show that computing the sign of the polynomial is in FP, whereas approximating the polynomial can be done in polynomial time with an NP oracle. As a special case, we completely resolve the complexity of computing the sign of the chromatic polynomial - this is easily computable at q=2 and when q is less than or equal to 32/27, and is NP-hard to compute for all other values of the parameter q.Comment: minor updates. This is the final version (to appear in SICOMP

    Boolean approximate counting CSPs with weak conservativity, and implications for ferromagnetic two-spin

    Get PDF
    We analyse the complexity of approximate counting constraint satisfactions problems #CSP(F)\mathrm{\#CSP}(\mathcal{F}), where F\mathcal{F} is a set of nonnegative rational-valued functions of Boolean variables. A complete classification is known in the conservative case, where F\mathcal{F} is assumed to contain arbitrary unary functions. We strengthen this result by fixing any permissive strictly increasing unary function and any permissive strictly decreasing unary function, and adding only those to F\mathcal{F}: this is weak conservativity. The resulting classification is employed to characterise the complexity of a wide range of two-spin problems, fully classifying the ferromagnetic case. In a further weakening of conservativity, we also consider what happens if only the pinning functions are assumed to be in F\mathcal{F} (instead of the two permissive unaries). We show that any set of functions for which pinning is not sufficient to recover the two kinds of permissive unaries must either have a very simple range, or must satisfy a certain monotonicity condition. We exhibit a non-trivial example of a set of functions satisfying the monotonicity condition.Comment: 37 page

    Matroids, Complexity and Computation

    No full text
    The node deletion problem on graphs is: given a graph and integer k, can we delete no more than k vertices to obtain a graph that satisfies some property π. Yannakakis showed that this problem is NP-complete for an infinite family of well- defined properties. The edge deletion problem and matroid deletion problem are similar problems where given a graph or matroid respectively, we are asked if we can delete no more than k edges/elements to obtain a graph/matroid that satisfies a property π. We show that these problems are NP-hard for similar well-defined infinite families of properties. In 1991 Vertigan showed that it is #P-complete to count the number of bases of a representable matroid over any fixed field. However no publication has been produced. We consider this problem and show that it is #P-complete to count the number of bases of matroids representable over any infinite fixed field or finite fields of a fixed characteristic. There are many different ways of describing a matroid. Not all of these are polynomially equivalent. That is, given one description of a matroid, we cannot create another description for the same matroid in time polynomial in the size of the first description. Due to this, the complexity of matroid problems can vary greatly depending on the method of description used. Given one description a problem might be in P while another description gives an NP-complete problem. Based on these interactions between descriptions, we create and study the hierarchy of all matroid descriptions and generalize this to all descriptions of countable objects
    corecore