Fine-grained dichotomies for the Tutte plane and Boolean #CSP

Jaeger, Vertigan, and Welsh [15] proved a dichotomy for the complexity of evaluating the Tutte polynomial at fixed points: The evaluation is #P-hard almost everywhere, and the remaining points admit polynomial-time algorithms. Dell, Husfeldt, and Wahl\'en [9] and Husfeldt and Taslaman [12], in combination with Curticapean [7], extended the #P-hardness results to tight lower bounds under the counting exponential time hypothesis #ETH, with the exception of the line $y=1$, which was left open. We complete the dichotomy theorem for the Tutte polynomial under #ETH by proving that the number of all acyclic subgraphs of a given $n$-vertex graph cannot be determined in time $exp(o(n))$ unless #ETH fails. Another dichotomy theorem we strengthen is the one of Creignou and Hermann [6] for counting the number of satisfying assignments to a constraint satisfaction problem instance over the Boolean domain. We prove that all #P-hard cases are also hard under #ETH. The main ingredient is to prove that the number of independent sets in bipartite graphs with $n$ vertices cannot be computed in time $exp(o(n))$ unless #ETH fails. In order to prove our results, we use the block interpolation idea by Curticapean [7] and transfer it to systems of linear equations that might not directly correspond to interpolation.


Introduction
Counting combinatorial objects is at least as hard as detecting their existence, and often it is harder. Valiant [19] introduced the complexity class #P to study the complexity of counting problems and proved that counting the number of perfect matchings in a given graph is #P-complete. By a theorem of Toda [18], we know that PH ⊆ P #P holds; in particular, for every problem in the entire polynomial-time hierarchy, there is a polynomial-time algorithm that is given access to an oracle for counting perfect matchings. This theorem suggests that counting is much harder than decision.
When faced with a problem that is NP-hard or #P-hard, the area of exact algorithms strives to find the fastest exponential-time algorithm for a problem, or find reasons why faster algorithms might not exist. For example, the fastest known algorithm for computing perfect matchings in n-vertex graphs [1] runs in time 2 n/2 · poly(n). It has been hypothesized that no O 1.99 n/2 -time algorithm for the problem exists, but we do not know whether such an algorithm has implications for the strong exponential time hypothesis. However, we know by [8] that the term O(n) in the exponent is asymptotically tight, in the sense that a 2 o(n) -time algorithm for counting perfect matchings would violate the (randomized) exponential time hypothesis (ETH) by Impagliazzo and Paturi [13]. Using the idea of block interpolation, Curticapean [7] strengthened the hardness by showing that a 2 o(n) -time algorithm for counting perfect matchings would violate the (deterministic) counting exponential time hypothesis (#ETH).
Our main results are hardness results under #ETH for 1) the problem of counting all forests in a graph, that is, its acyclic subgraphs, and 2) the problem of counting the number of independent sets in a bipartite graph. If #ETH holds, then neither of these problems has an algorithm running in time exp(o(n)) even in simple n-vertex graphs of bounded maximum degree. We use these results to lift two known "FP vs. #P-hard" dichotomy theorems to their more refined and asymptotically tight "FP vs. #ETH-hard" variants.

The Tutte polynomial under #ETH
The Tutte polynomial of a graph G with G = (V, E) is the bivariate polynomial T (G; x, y) defined via where k(A) is the number of connected components of the graph (V, A). The Tutte polynomial captures many combinatorial properties of a graph in a common framework, such as the number of spanning trees, forests, proper colorings, and certain flows and orientations, but also less obvious connections to other fields, such as link polynomials from knot theory, reliability polynomials from network theory, and (perhaps most importantly) the Ising and Potts models from statistical physics. We make no attempt to survey the literature or the different applications for the Tutte polynomial, and instead refer to the upcoming CRC handbook on the Tutte polynomial [10]. Since T (G; −2, 0) corresponds to the number of proper 3-colorings of G, we cannot hope to compute all coefficients of T (G; x, y) in polynomial time. Instead, the literature and this paper focus on the complexity of evaluating the Tutte polynomial at fixed evaluation points. That is, for each (x, y) ∈ Q 2 , we consider the function T x,y defined as G → T (G; x, y). Jaeger, Vertigan, and Welsh [15] proved that this function is either #P-hard to compute or has a polynomial-time algorithm. In particular, if (x, y) satisfies (x − 1)(y − 1) = 1, then T x,y corresponds to the 1-state Potts model and has a polynomialtime algorithm, and if (x, y) is one of the four points (1, 1), (−1, −1), (0, −1), or (−1, 0), it also has a polynomial-time algorithm; the most interesting point here is T (G; 1, 1), which corresponds to the number of spanning trees in G and happens to admit a polynomial-time algorithm.
A trivial algorithm to compute the Tutte polynomial runs in time 2 O(m) , where m is the number of edges. Björklund et al. [2] proved that there is an algorithm running in time exp O(n) , where n is the number of vertices. Dell et al. [8] proved for all hard points, except for points with y = 1, that an exp o(n/ log 3 n) -time algorithm for T x,y on simple graphs would violate #ETH. Distressingly, this result not only left open one line, but also left a gap in the running time. Curticapean [7] introduced the technique of block interpolation to close the running time gap: Under #ETH, there does not exist an exp o(n) -time algorithm for T x,y on simple graphs at any hard point (x, y) with y = 1. 1

Our contributions:
We resolve the complexity of the missing line y = 1 under #ETH. On this line, the Tutte polynomial counts forests weighted in some way, and the main result is the following theorem.

Theorem 1 (Forest counting is hard under #ETH).
If #ETH holds, then there exist constants , C > 0 such that no O(exp( n))-time algorithm can compute the number of all forests in a given simple n-vertex graph with at most C · n edges.
The fact that the problem remains hard even on simple sparse graphs makes the theorem stronger. The previously best known lower bound under #ETH was that forests cannot be counted in time O exp(n δ ) where δ > 0 is some constant depending on the instance blow-up caused by the known #P-hardness reductions for forest counting; our rough estimate suggests that δ is much smaller than 1/2. Our approach yields a #P-hardness proof for forest counting that is simpler than the proofs we found in the literature. 2 Combined with all previous results [15,8,7], we can now formally state a complete #ETH dichotomy theorem for the Tutte polynomial over the reals.

Corollary 2 (Dichotomy for the real Tutte plane under #ETH).
Let (x, y) ∈ Q 2 . If (x, y) satisfies (x − 1)(y − 1) = 1 or (x, y) ∈ (1, 1), (−1, −1), (0, −1), (−1, 0) , then T x,y can be computed in polynomial time. Otherwise T x,y is #P-hard and, if #ETH is true, then there exists > 0 such that T x,y cannot be computed in time exp( n), even for simple graphs with n vertices The result also holds for sparse simple graphs. We stated the results only for rational numbers in order to avoid insightless discussions about how real numbers should be represented.
For the proof of Theorem 1, we establish a reduction chain that starts with the problem of counting perfect matchings on sparse graphs, which is known to be hard under #ETH. As an intermediate step, we find it convenient to work with the multivariate forest polynomial as defined, for example, by Sokal [17]. After a simple transformation of the graph, we are able extract the number of perfect matchings of the original graph from the multivariate forest polynomial of the transformed graph, even when only two different variables are used. Subsequently, we use Curticapean's idea of block interpolation [7] to reduce the problem of computing all coefficients of the bivariate forest polynomial to the problem of evaluating the univariate forest polynomial on multigraphs where all edge multiplicity are bounded by a constant. Finally, we replace parallel edges with parallel paths of constant length to reduce to the problem of evaluating the univariate forest polynomial on simple graphs.

#CSP over the Boolean domain under #ETH
In the second part of this paper, we consider constraint satisfaction problems (CSPs) over the Boolean domain, which are a natural generalization of the satisfiability problem for k-CNF formulas. A constraint is a relation R ⊆ {0, 1} k for some k ∈ N, and a set Γ of constraints is a constraint language. CSP(Γ) is the constraint satisfaction problem where all constraints occurring in the instances are of a type contained in Γ, and #CSP(Γ) is the corresponding counting version, which wants to compute the number of satisfying assignments. If all constraints happen to be affine, that is, they are linear equations over GF (2), then the number of solutions can be determined in polynomial time by applying Gaussian elimination and determining the size of the solution space. Creignou and Hermann [6] prove that, as soon as you allow even just one constraint type that is not affine, the resulting CSP problem is #P-hard.

Our contributions:
We prove that all Boolean #CSPs that are #P-hard are also hard under #ETH. The #P-hardness is established in [6] by reductions from counting independent sets in bipartite graphs, which we prove to be hard in the following theorem.

Theorem 3 (Counting independent sets in bipartite graphs is hard under #ETH).
If #ETH holds, then there exist constants > 0 and D ∈ N such that no O(exp( n))-time algorithm can compute the number of independent sets in bipartite n-vertex graphs of maximum degree at most D.
The fact that the problem is hard even on graphs of bounded degree makes the theorem stronger. We remark that the number of independent sets in bipartite graphs has a prominent role in counting complexity. Currently, the complexity of approximating this number is unknown, and many problems in approximate counting turn out to be polynomial-time equivalent to approximately counting independent sets in bipartite graphs. Theorem 3 shows that this mysterious situation does not occur for the exact counting problem in the exponential-time setting: it is just as hard as counting satisfying assignments of 3-CNFs.
The #P-hardness of counting independent sets in bipartite graphs was established by Provan and Ball [16]. The main ingredient in their proof is a system of linear equations that does not seem to correspond to polynomial interpolation directly. We prove Theorem 3 by transferring the block interpolation idea from [7] to this system of linear equations, which we do using a Kronecker power of the original system. Theorem 3 combined with existing reductions in [6] yields the fine-grained dichotomy.

Corollary 4 (Creignou and Hermann under #ETH).
Let Γ be a finite constraint language. If every constraint in Γ is affine, then #CSP(Γ) has a polynomial-time algorithm. Otherwise #CSP(Γ) is #P-complete, and if #ETH holds, it cannot be computed in time exp(o(n)) where n is the number of variables.
We consider Corollary 4 to be a first step towards understanding the fine-grained complexity of technically much more challenging dichotomies, such as the ones for counting CSPs with complex weights of Cai and Chen [3], or the dichotomy for Holant problems with symmetric signatures over the Boolean domain of Cai, Lu and Cia [4].

Preliminaries
Given a matrix A of size m 1 × n 1 and a matrix B of size m 2 × n 2 their Kronecker product A ⊗ B is a matrix of size m 1 m 2 × n 1 n 2 given by Let A ⊗n be the matrix defined by A ⊗1 = A and A ⊗n+1 = A ⊗ A ⊗n . Furthermore, if A and B are quadratic matrices of size n a and n b , respectively, then det( The exponential time hypothesis (ETH) by Impagliazzo and Paturi [13] is that satisfiability of 3-CNF formulas cannot be computed substantially faster than by trying all possible assignments. The counting version of this hypothesis [8] reads as follows: There is a constant c > 0 such that no deterministic algorithm can compute #3-SAT in time exp(c · n), where n is the number of variables.
A different way of formulating #ETH is to say no algorithm can compute #3-SAT in time exp(o(n)). The latter statement is clearly implied by the formal statement, and it will be more convenient for discussion to use this form.
The sparsification lemma by Impagliazzo, Paturi, and Zane [14] is that every k-CNF formula ϕ can be written as the disjunction of 2 n formulas in k-CNF, each of which has at most c(k, ) · n clauses. Moreover, this disjunction of sparse formulas can be computed from ϕ and in time 2 n · poly(m). The density c = c(k, ) is the sparsification constant, and the best known bound is c(k, ) = (k/ ) 3k [5]. It was observed [8] that the disjunction can be made so that every assignment satisfies at most one of the sparse formulas in the disjunction, and so the sparsification lemma applies to #ETH as well. In particular, #ETH implies that #3-SAT cannot be computed in time exp(o(m)), where m is the number of clauses.
We also make use of the following result, whose proof is based on block interpolation.
Theorem 5 (Curticapean [7]). If #ETH holds, then there are constants , D > 0 such that neither of the following problems have O(2 n )-time algorithms, even for simple n-vertex graphs G of maximum degree at most D: • Computing the number of perfect matchings of G.
• Computing the number of independent sets of G.

Counting forests is #ETH-hard
Let F(G) be the set of all forests of G, that is, edge subsets A ⊆ E(G) such that the graph (V (G), A) is acyclic. For y = 1, only the terms with k(A) + |A| − |V | = 0 survive, and we get the following: We want to prove that, for every fixed x = 1, computing the value T (G; x, 1) for a given graph G is hard under #ETH. In particular, this is true for T (G; 2, 1), which is the number of forests in G. The goal of this section is to prove the following theorem.
If #ETH holds, then there exist , C > 0 such that the function that maps simple n-vertex graphs G with at most C · n edges to the value T (G; x, 1) cannot be computed in time 2 n .
Theorem 6 yields Theorem 1 as its special case with x = 2.

The multivariate forest polynomial
A weighted graph is a graph G in which every edge e ∈ E(G) is endowed with a weight w e , which is an element of some ring. We use the multivariate forest polynomial, defined e.g. by Sokal [17, (2.14)] as follows: Projecting all weights w e onto a single variable x yields the univariate forest polynomial: where a k (G) is the number of forests with k edges in G. For all x ∈ R \ {1}, the formal relation between T (G; x, 1) and the univariate forest polynomial is given by the identity The first equality follows from the fact that A is a forest if and only if k(A) + |A| − |V | = 0 holds. As a result, evaluating the forest polynomial and evaluating the Tutte polynomial for y = 1 are problems that are polynomial-time equivalent. For a forest A ∈ F(G), let c(A) be the family of all sets T ⊆ V (G) such that T = ∅ and T is a maximal connected component in A; clearly, each such T is the vertex set of a tree in the forest, where we also allow trees with |T | = 1. Adding an apex). Let G be a weighted graph, and let G be obtained from G by adding a new vertex a and joining it with each vertex v ∈ V (G) using an edge of weight z v . Then

Lemma 7 (
Moreover, when we set z v = −1 for all v ∈ V (G) and w e = w for all e ∈ E(G), we have that the coefficient of w n/2 in F (G ) is equal to the number of perfect matchings in G.
Proof. In order to prove the claim, we first define a projection φ that maps forests A in the graph G to forests A = φ(A ) in the original graph G. In particular, φ simply removes all edges added in the construction of G , that is, Next we conveniently characterize the forests A that map to the same A under φ. Let A be a fixed forest in G. Then a forest A in G maps to A under φ if and only if there is a set X with X = A \ A such that the following property holds: (P) For all trees T ∈ c(A), at most one edge of X is incident to a vertex of T .
The forward direction of this claim follows from the fact that A is a forest, and so in addition to any tree T ∈ c(A) it can contain at most one edge connecting T to a; otherwise the tree and the two edges to a would contain a cycle in A . For the backward direction of the claim, observe that adding a set X with the property (P) to A cannot introduce a cycle.
Finally, we calculate the weight contribution of all A that map to the same A. Let A be a forest in G, let A = φ(A ) and X = A \ A. The weight contribution of A in the definition of F (G ) is e∈A w e . For all e ∈ A, we have w e = w e . For all e ∈ X, we let v e ∈ V (G) be the vertex with e = {a, v e }, and we have w e = z ve . Thus the overall weight The sum in the middle is over all X with the property (P), and the first equality follows from the bijection between forests A and sets X with property (P). For the second equality, we use property (P) and the distributive law. We obtain (3) by taking the sum of equations (4) over all A ∈ F(G).
For the moreover part of the lemma, note that the stated settings of the edge weights for G yields Since (V (G), A) is an acyclic graph with exactly n/2 edges, it is either a perfect matching or it contains an isolated vertex. If it contains an isolated vertex v, then we have {v} ∈ c(A) and thus the product in (5) is equal to zero. It follows that A does not contribute to the sum if it is not a perfect matching. On the other hand, if A is a perfect matching, then we have |T | = 2 for all T ∈ c(A), so the product in (5) is equal to 1.
Overall, we obtain that [w n/2 ]F (G ) is equal to the number of perfect matchings of G.
Lemma 7 shows that computing the multivariate forest polynomial is at least as hard as counting perfect matchings; moreover, this is true even if at most two different edge weights are used. Next we argue how to reduce from the multivariate forest polynomial with at most two distinct weights to the problem of evaluating the univariate polynomial in multigraphs. We do so via an oracle serf-reduction, whose queries are sparse multigraphs in which each edge has at most a constant number of parallel edges.

Lemma 8 (From two weights to small weights using block interpolation). Let
x and y be two variables, and let z ∈ R \ {0} be fixed. There is an algorithm as follows: 1. Its input is a weighted graph (G, w) with w e ∈ {x, y} for all e ∈ E(G), and a real > 0.

It has access to an oracle that computes
, where w can be any weight function that assigns integer weights w e satisfying 0 ≤ w e ≤ C for some constant C that only depends on .
We remark that non-negative integer multiples of z, say z · w e , can be thought of as w e parallel edges of weight z in a multigraph. The quantity F (G ; z) for this multigraph G is then equal to the value F (G; z · w ) of the weighted forest polynomial of G at z · w . In particular, F (G ; 1) is the number of forests in G .
Proof. Let (G, w) with w ∈ {x, y} E and > 0 be given as input. We define C ∈ N as a large enough constant to be determined later. The algorithm now assigns a new weight z · w e to each edge e, where each w e is chosen from the set of indeterminates X ∪ Y with X = {x 1 , . . . , x m/C } and Y = {y 1 , . . . , y m/C } in the following way: If w e = x, choose w e ∈ X, and if w e = y, choose w e ∈ Y . We further demand that the number of edges sharing the same weight is at most C for each weight in X ∪ Y . Among all such assignments z · w , we pick an arbitrary one. We now consider the polynomial F (G; z · w ). It has at most 2m/C variables and the maximum degree of each variable is at most C, so F (G; z · w ) has at most (C + 1) 2m/C monomials, where m = |E(G)|. The coefficients of this polynomial can be reconstructed when its values are given for all evaluation points in the grid (z · [0, C]) 2m/C . Since each evaluation point only uses non-negative integer multiples of z between 0 and z · C, we can obtain the values at these evaluation points by querying the oracle for F (G; z · w ) that we are given. The number of evaluation points in the grid is equal to (C + 1) 2m/C . The claim on the running time follows since the interpolation can be performed in time poly (C + 1) 2m/C , which is at most C · 2 m when C is chosen large enough depending on .
In order to obtain the coefficient of x i y j in F (G; w), we compute the image of F (G; z·w ) under the projection that maps all variables in X to x/z and all variables in Y to y/z. That is, we sum up the coefficients of F (G; z·w ) corresponding to the same monomial x i y j , and divide by the factor z i+j .
The combination of Lemma 7 and Lemma 8 shows, for all fixed x = 0, that it is hard to evaluate F (G; x) for multigraphs with at most a constant number of parallel edges. Next we apply a stretch to make the graphs simple. To this end, we calculate the effect of a k-stretch on the univariate forest polynomial of a graph. forest polynomial under a k-stretch). Let G be a multigraph with m edges, where every edge is weighted with w ∈ R and let k be a positive integer such that the number g k (w) with

Lemma 9 (The
is well-defined. Let G be the simple graph obtained from G by replacing every edge by a path of k edges. Then we have Proof. We define a mapping φ that maps forests in G to forests in G as follows: We add an edge e ∈ E(G) to A = φ(A ) if and only if A contains all k edges of G that e got stretched into. That is, subgraphs A that only differ by edges in "incomplete paths" are mapped to the same multigraph A by φ.
Clearly, φ partitions F(G ) into sets of forests with the same image under φ. Let A be a forest in G, and let us describe a way to generate all A with φ(A ) = A. First, for each e ∈ A, we add its corresponding path in G of length k to A . Moreover, for each edge e ∈ E(G) \ A, we can add to A any proper subset of edges from the k-path in G that corresponds to e. Therefore, at each e ∈ E(G) \ A independently, there are k i ways to extend A by i edges to a forest in G . A forest A can be obtained in this fashion if and only if φ(A ) = A holds.
For a fixed A, let us consider all summands w |A | in F (G ; w) with φ(A ) = A. By the above considerations, the total weight contribution of these summands is w k·|A| · k−1 i=0 k i w i m−|A| , which equals w k·|A| · (w + 1) k − w k m−|A| by the binomial theorem. These remarks justify the following calculation for the forest polynomial: Since the sum in the last line is equal to F G; g k (w) , this concludes the proof.
We are now in position to formally prove the main theorem of this section.
Proof (of Theorem 6). Let x ∈ R \ {1}. Suppose that, for all > 0, there exists an algorithm B to compute the mapping G → T (G; x, 1) in time 2 n for given simple graphs G with at most C n edges, where C will be chosen later. By (2), algorithm B can be used to compute values F (G; 1 x−1 ) with no relevant overhead in the running time, so let t = 1 x−1 . Given such an algorithm (or family of algorithms), we devise a similar algorithm for counting perfect matchings, which together with Theorem 5 implies that #ETH is false.
Let G be a simple n-vertex graph with at most C ·n edges. Let G be the graph obtained from G as in Lemma 7 by adding an apex, labeling the edges incident to the apex with the indeterminate z, and all other edges with the indeterminate w. By Lemma 7, the coefficients of the corresponding bivariate forest polynomial of G are sufficient to extract the number of perfect matchings of G, so it remains to compute these coefficients.
To obtain the coefficients, we use Lemma 8. The reduction guaranteed by the lemma produces 2 m multigraphs H, all with the same vertex set V (G ). Moreover, each H has at most C |E(G )| = C (|E(G)| + n) ≤ O(C n) edges, and the multiplicity of each edge is at most C . Finally, each edge of each H is assigned the same weight z, which we will choose later.
The reduction makes one query for each H, where it asks for the value F (H; z). Our assumed algorithm however only works for simple graphs, so we perform a 3-stretch to obtain a simple graph H with at most 3|E(H)| ≤ O(C n) edges. Lemma 9 allows us to efficiently compute the value F (H; z) when we are given the value F (H ; t) and z = g 3 (t) holds. Since g k is a total function whenever k is a positive odd integer, and 3 is indeed odd, the value g 3 (t) is well-defined, and we set z = g 3 (t).
We set C large enough so that E(H ) ≤ C · n holds. Trickling back the reduction chain, we can use algorithm B to compute T (H ; x, 1) in time 2 n any > 0. Using (2), we get the value of F (H ; t) since x = 1. This, in turn, yields the value of F (H; z) since (z + 1) k − z k = 0 and g 3 (t) = z. We do this for each of the 2 m queries H that the reduction in Lemma 8 makes. Finally, the latter reduction outputs the coefficients of the bivariate forest polynomial of G , which contains the information on the number of perfect matchings of G.
To conclude, assuming the existence of the algorithm family B, we are able to count perfect matching in time poly(2 m ) for all > 0, which implies via Theorem 5 that #ETH is false.
Note that the construction from the proof of Theorem 1 implies hardness of T (G; x, 1) for tripartite G, and also in the bipartite case whenever x = −1.

Counting solutions to Boolean CSPs under #ETH
In this section, we prove that the #P-hard cases of the dichotomy theorem for Boolean CSPs by Creignou and Hermann [6] are also hard under #ETH. The main difficulty is to establish #ETH-hardness of counting independent sets in bipartite graphs. We do so first, and afterwards observe that all other reductions in [6] can be used without modification.

Counting Independent Sets in Bipartite Graphs is #ETH-hard
We prove that the problem of counting independent sets in bipartite graphs admits no subexponential algorithm under #ETH, even for sparse and simple graphs.

Proof (of Theorem 3).
We reduce from the problem of counting independent sets in graphs of bounded degree; by Theorem 5, this problem does not have a subexponentialtime algorithm. First we note that a set is an independent set if and only its complement is a vertex cover. Hence their numbers are equal. We devise a subexponential-time oracle reduction family to reduce counting vertex covers in general to counting them in bipartite graphs.
Given a graph G with n vertices and m edges, and a running time parameter d ∈ N, the reduction works as follows. We partition the edges into |E| d blocks of size at most d each. We denote the blocks by B 1 , . . . , B m d . Next, for each = ( 1 , . . . , m d ) ∈ N m/d , we construct the graph G by replacing each edge e ∈ B i with a copy of the gadget H i shown in Figure 1. Note that G is bipartite. Every set S ⊆ V (G) has exactly one type. Let x t be the number of all sets S ⊆ V (G) that have type t. We classify vertex covers C ⊆ V (G ) of G by their intersection with V (G), so let S = C ∩ V (G) and let t be the type of S. By Observation 10 and the fact that all inserted gadgets act independently after conditioning on the intersection of the vertex covers of G with V (G), there are exactly Since G is bipartite, our reduction can query the oracle to obtain the numbers N for all ∈ [(d + 1) 3 ] n d . This yields a system of linear equations of type (6), where the x t for t ∈ T are the unknowns; note that we have exactly |T | equations and unknowns. Let M be the corresponding |T | × |T | matrix, so that the system can be written as N = M · x.
It remains to prove that M is invertible. For this, we observe that M can be decomposed into a tensor product of smaller matrices as follows. Let A be the (d + 1) 3 × (d + 1) 3 where the row indices are from [(d + 1) 3 ], the column indices τ are from {0, . . . , d} 3 , and the entries are defined via A τ = (2 τ 1 3 τ 2 5 τ 3 ) . Provan and Ball, as well as the reader, observe that A is the transpose of a Vandermonde matrix. Due to the uniqueness of the prime factorization, the evaluation points 2 τ 1 3 τ 2 5 τ 3 are distinct for distinct τ , and thus det(A) = 0. Furthermore, we observe that M = A ⊗ n d holds, which implies det(M ) = 0 and that M is invertible.
Since M is invertible, we can solve the equation system N = M ·x in time polynomial in its size, and compute x t for all t ∈ T . Finally, we compute the sum of x t over all matrices t whose first column contains only zeros. This yields the number of all sets S ⊆ V (G) that intersect every edge of G at least once, that is, the number of vertex covers of G which equals, as mentioned above, the number of independent sets of G.
Assume that #ETH holds, and let , D > 0 be the constants from Theorem 5, which are such that no algorithm can count independent sets in general graphs of maximum degree D in time 2 n . We apply our reduction to such a graph; it makes at most 2 O(log d·m/d) queries to the oracle. Since m ≤ Dn holds, and the running time for solving the linear equation system is polynomial in the number of queries, we can choose d ∈ N to be a large enough constant depending on > 0 to achieve an overall running time of O(2 1 2 n ) for the reduction. Also note that the queries to the oracle for bipartite graphs have degree at most (d + 1) 3 · D, which is a constant that only depends on . If there was an algorithm for counting independent sets in bipartite graphs that ran in time O(2 1 2 n ), we would get a combined algorithm for counting independent sets in general graphs that would be faster than the choice of and D would allow. Hence, under #ETH, there are constants , D > 0 such that no O(2 n )-time algorithm can count all independent sets on graphs of maximum degree at most D .
We defer the simple observations needed to prove Corollary 4 to the appendix.
Proof. Given a bipartite graph G = (V∪ U, E) with constant degree we construct a 2-CNF F by adding a clause (v → u) for every edge {v, u} ∈ E. Now the number of independent sets in G equals the number of satisfying assignments of F . Furthermore the existence of an algorithm that solves #Imp2Sat in time 2 o(n) would imply the existence of an algorithm that solves #BIS in time 2 o(n) . Applying Theorem 3 we obtain that such an algorithm would refute #ETH.
We sketch how to obtain the #ETH dichotomy theorem for Boolean CSPs.
Proof (of Corollary 4). If every relation in Γ is affine then we can solve #CSP(Γ) in polynomial time using Gaussian elimination as in [6]. Otherwise, the problem is #Phard by [6]. If, in addition, #ETH holds, #CSP(Γ) cannot be solved in time 2 o(n) as a subexponential algorithm could also be used to solve #Pos2Sat or #Imp2Sat (see Observation 11) in time 2 o(n) which is not possible assuming #ETH (by Theorem 5 and Lemma 12).