The Complexity of Weighted Boolean #CSP

This paper gives a dichotomy theorem for the complexity of computing the partition function of an instance of a weighted Boolean constraint satisfaction problem. The problem is parameterised by a finite set F of non-negative functions that may be used to assign weights to the configurations (feasible solutions) of a problem instance. Classical constraint satisfaction problems correspond to the special case of 0,1-valued functions. We show that the partition function, i.e. the sum of the weights of all configurations, can be computed in polynomial time if either (1) every function in F is of product type'', or (2) every function in F is pure affine’’. For every other fixed set F, computing the partition function is FP^{#P}-complete.

💡 Research Summary

The paper establishes a complete dichotomy for the computational complexity of evaluating the partition function of weighted Boolean constraint satisfaction problems (#CSP). An instance consists of Boolean variables and constraints drawn from a fixed finite set F of non‑negative real‑valued functions. The partition function Z(I) is the sum over all assignments of the product of the weights contributed by each constraint. The authors identify two structural families of functions that render Z(I) tractable:

1. Product type – every f∈F can be written as a product of unary functions, i.e., f(x₁,…,x_k)=∏_{i=1}^k g_i(x_i). In this case the variables are independent, and Z(I) can be computed by evaluating a simple sum for each variable and multiplying the results. The algorithm runs in time polynomial in the size of the instance.

2. Pure affine – each f∈F is the indicator of an affine subspace over GF(2), possibly multiplied by a constant. Equivalently, f(x)=1 iff A·x=b (mod 2) for some matrix A and vector b. By assembling all affine constraints into a linear system and applying Gaussian elimination, the number of free variables r is obtained, and Z(I)=2^{r} times the product of the constant factors. This also yields a polynomial‑time algorithm.

The main technical contribution is the proof that for any fixed set F that is not wholly contained in either of these two families, computing Z(I) is FP^{#P}‑complete. The hardness proof proceeds in two stages. First, the authors show that any such F must contain a “core” function that is neither product nor pure affine; this function can be used to simulate basic Boolean gates (AND, OR, NOT) through gadget constructions. Second, using the expressive power of these simulated gates, they give a parsimonious reduction from a known #P‑complete problem (e.g., #SAT or counting cycle covers) to the weighted #CSP with constraints from F. The reduction relies on a combination of expressibility theory, holographic transformations, and polynomial interpolation to preserve non‑negativity of weights while encoding arbitrary counting problems. Consequently, the partition function problem lies at the top of the counting hierarchy for such F, i.e., it is FP^{#P}‑hard and belongs to FP^{#P} (by definition), establishing completeness.

The paper also situates its results within the broader landscape of CSP complexity theory. It extends Schaefer’s classic dichotomy for Boolean CSPs (which deals with decision problems) to the counting setting with weights, and it aligns with the Holant framework’s known tractability criteria. Several illustrative examples are provided: the ferromagnetic Ising model’s interaction function is of product type and thus tractable; the weighted version of 3‑SAT falls outside both tractable families and is therefore #P‑complete. The authors discuss the role of the non‑negativity restriction, noting that allowing negative weights can break the dichotomy and lead to richer classifications.

Finally, the paper outlines future directions. Extending the dichotomy to larger domains (non‑Boolean variables) or to mixed‑sign weight functions remains open. Another promising line is to refine the classification inside the FP^{#P}‑complete region by identifying subclasses that admit approximation schemes or fixed‑parameter tractable algorithms. Overall, the work delivers a clean, elegant classification: the partition function of a weighted Boolean #CSP is polynomial‑time computable exactly when the constraint language consists solely of product‑type or pure‑affine functions; otherwise, it is as hard as any counting problem in #P.