Weighted Model Counting Overview

• Weighted model counting is a computational framework that assigns weights to Boolean models and sums them, serving as a foundation for probabilistic reasoning and combinatorial analysis.
• Efficient evaluation techniques such as compiled circuit representations (sd-DNNF), dynamic programming with ADDs, and tensor networks significantly reduce computational complexity.
• Recent advances, including hashing-based approximation, neural methods, and quantum algorithms, have broadened WMC's applications in optimization, verification, and statistical inference.

Weighted model counting (WMC) is a computational problem at the intersection of logic, combinatorics, and probabilistic reasoning. Given a propositional formula and a weight associated with each literal (or more generally, each assignment), WMC asks for the sum of the weights of all models (satisfying assignments) of the formula. The weight of a model is typically the product of the weights of the literals that are assigned true in that model. WMC generalizes classical model counting and underpins a variety of inference tasks in graphical models, probabilistic databases, optimization, statistical relational learning, quantitative risk assessment, and recently, quantum computing. The problem is #P-hard in general, but sustained research has produced significant algorithmic, algebraic, and structural advances for specialized instances and approximate solutions.

1. Mathematical Foundations and Extensions

The classical definition of weighted model counting is as follows. For a propositional theory $T$ (Boolean formula) and a nonnegative real-valued weight function $w(l)$ assigning a weight to each literal $l$, the weighted model count is computed as: $$\mathrm{WMC}(T) = \sum_{I \in \mathcal{M}(T)} \prod_{l \in I} w(l)$$ where $\mathcal{M}(T)$ denotes the set of models (satisfying assignments) of $T$.

Algebraic Model Counting (AMC) generalizes WMC by replacing the sum $\sum$ and product $\prod$ with arbitrary commutative semiring operators $\oplus$ and $\otimes$ (with neutral elements $e^{\oplus}$ and $e^{\otimes}$), and a labeling function $\alpha$. Thus, the most generic form is: $$\mathrm{AMC}(T) = \bigoplus_{I \in \mathcal{M}(T)} \bigotimes_{l \in I} \alpha(l)$$ This abstraction encompasses not only probabilistic inference but also enumeration, optimization, soft constraints, polynomials, and set-valued computations (Kimmig et al., 2012).

The classical setting, with $\oplus = +$, $\otimes = \cdot$, and $\mathcal{A} = \mathbb{R}_{\geq 0}$, recovers standard WMC. By modifying the semiring and labeling function, various other tasks—including constraint satisfaction over idempotent or absorption semirings, shortest path problems, and database lineage analysis—can be unified with WMC under the AMC framework.

2. Efficient Evaluation via Circuit Compilation

A central efficiency breakthrough for WMC and AMC is the use of compiled circuit representations, particularly smooth, deterministic, decomposable negation normal form (sd-DNNF) circuits. These circuits possess three key properties:

• Decomposability: Conjunctive children do not share variables, enabling independent model evaluation.
• Determinism: Disjunctive children are mutually exclusive, guaranteeing each model is counted once.
• Smoothness: All children of a disjunction reference the same variables, ensuring correct aggregation.

Evaluation proceeds bottom-up:

• At a literal node: return $\alpha(l)$.
• At a conjunction node: apply $\otimes$ to child evaluations.
• At a disjunction node: apply $\oplus$ to child evaluations.

For WMC, this is specialized as:

• At a literal node: return $w(l)$.
• At an AND node: multiply the children's counts.
• At an OR node: add the children's counts.

Crucially, evaluating an sd-DNNF circuit yields the exact weighted model count in time linear in the circuit size, often exponentially smaller than the number of models or the formula's representation (Kimmig et al., 2012). When additional properties such as idempotence of $\oplus$ or neutrality of $(\oplus, \alpha)$ hold, evaluation can also proceed on even more succinct, relaxed circuit forms.

3. Approximate and Scalable Algorithms

Exact WMC remains intractable for general CNF formulas, leading to intense research on scalable approximate algorithms.

• Hashing-based FPRAS: Randomized hashing with XOR constraints partitions the model space. Using a SAT solver as an $\mathsf{NP}$-oracle and a (possibly black-box) weight oracle, modern algorithms (such as WeightMC and WeightGen) estimate the total model weight or sample models with probability proportional to their weight. The runtime is polynomial in the formula size, tolerance $1/\varepsilon$, logarithm of the confidence $1/\delta$, and a measure of weight imbalance (tilt) such as $r = w_{max}/w_{min}$. If the weight function is available in factored (white-box) form, one can partition the model space into regions of low tilt and further drop runtime dependence from linear to logarithmic in $r$ (Chakraborty et al., 2014).
• Neural/Deep Learning Approaches: For weighted DNF counting, deep graph neural networks trained on approximate counts from the classical KLM sampler can learn to mimic the model counting process. Such methods can generalize across DNF sizes and structures, achieving near-linear runtime (in $n + m$ where $n$ is the number of variables, $m$ the number of clauses) for bounded clause width, and offer high approximation accuracy and substantial acceleration compared to traditional sampling (Abboud et al., 2019).
• Hybrid Sampling-Integration for Real-Valued Domains: Weighted model integration (WMI), involving both Boolean and real variables, admits an FPRAS when restricted to DNF structure and factorizable, concave weight functions. This uses oracles for clause weights (via geometric volume approximation), weighted sampling, and clause evaluation in a tightly orchestrated randomized algorithm, extending classical Karp–Luby–Madras techniques (Abboud et al., 2020).

4. Data Structures, Dynamic Programming, and Knowledge Compilation

Knowledge compilation and advanced dynamic programming paradigms play a fundamental role in the exact WMC regime.

• Algebraic Decision Diagrams (ADDs): The ADDMC framework represents both formulas and weight functions as ADDs. By partitioning clauses into clusters and performing "early projection" (summing out variables after their last use), intermediate ADD sizes are minimized. Several variable and clustering heuristics—e.g., maximum-cardinality search, lexicographic orders, bucket elimination versus bouquet method—dramatically affect performance (Dudek et al., 2019).
• Project-Join Trees and General Frameworks: Dynamic programming on project-join trees unifies the evaluation of function products and additive projections (variable eliminations and clause multiplications). Planning (finding an optimal project-join order) is performed via constraint satisfaction heuristics or anytime tree-decomposition tools (e.g., FlowCutter, HTD, Tamaki). Execution can employ ADDs or tensors, with ADDs generally outperforming tensors on single-core CPUs (Dudek et al., 2020).
• Tensor Networks and Parallelism: Reduction of WMC to tensor network contraction introduces variable and clause tensors with indices determined by occurrences in clauses. Contraction order is informed by carving or tree decompositions of the structure graph, with optimal orders minimizing the maximal intermediate tensor rank—and thus memory usage. The Factor-Tree method further reduces the size of intermediate tensors by decomposing high-rank tensors into trees of low-rank tensors. GPU acceleration and parallel portfolios of decomposition solvers (TensorOrder2) significantly improve performance on large benchmarks (Dudek et al., 2019, Dudek et al., 2020).
• Pseudo-Boolean and Arithmetic Constraints: WMC directly on Pseudo-Boolean (PB) constraints, without reducing to CNF, enables model counters like PBCounter to exploit arithmetic structure for greater succinctness and efficiency, particularly in applications with long constraints. PB-specific preprocessing (e.g., backbone identification) further enhances scalability (Lai et al., 2023).

5. Logical Fragments and Lifted Inference

WMC has deep connections to first-order model counting (WFOMC), where the input is a logical theory and domain size.

• Tractable Fragments: In the two-variable fragment (FO$^2$), symmetric WFOMC admits domain-liftable algorithms with polynomial runtime in domain size, even when extended with counting quantifiers, functionality constraints, existential quantification, and cardinality constraints. Closed-form WFOMC expressions sum over partitions of the domain into types, incorporating both unary and binary predicates, and exploit lifted interpretations to avoid grounding. The corresponding family of weight functions strictly generalizes the symmetric case, permitting rich probabilistic models and count constraints (Kuusisto et al., 2018, Kuzelka, 2020, Malhotra et al., 2020, Malhotra et al., 2021).
• Complexity Classification: There is a dichotomy: prefix classes with fewer than three quantifiers admit tractable WFOMC; for prefix classes with three or more quantifiers, WFOMC is $\#\text{P}_1$-complete for some sentences (Kuusisto et al., 2018).
• Lifted Sampling: Analogous to liftable counting, polynomial-time lifted sampling in FO$^2$ with counting quantifiers is possible, providing efficient generation of models distributed by weight in large statistical relational domains (Wang et al., 2023).

6. Quantum Algorithms and Numeric Precision

• Quantum Model Counting: Quantum algorithms for WMC (QWMC, QWCS) modify Grover's search, phase estimation, and amplitude amplification to encode weights in amplitudes via single-qubit rotations or phase flips. These approaches require only $\Theta(2^{n/2})$ oracle calls (for $n$-variable inputs), a quadratic speedup over classical $\Theta(2^n)$ sampling or enumeration. This has significant implications for probabilistic inference, partition function computation, and compact representation of physical models, with explicit circuit and amplitude analysis detailed in (Riguzzi, 2019, Riguzzi, 29 Jun 2024).
• Numerical Considerations: Weighted model counters using floating-point arithmetic are susceptible to precision loss, underflow, and overflow. The extended-range double (ERD) format, with 64-bit mantissa and separate 64-bit exponent, overcomes range limits of IEEE double, ensuring correctness for problems with many variables. For formulas with mixed sign weights, interval arithmetic (e.g., via MPFI) can certify result precision efficiently, with fallback to full rational arithmetic only when required for guarantee. This hybrid architecture provides precision guarantees while avoiding the cost of universal rational evaluation over all instances (Bryant, 8 Aug 2025).

7. Applications and Related Structural Parameters

Weighted model counting is central to:

• Probabilistic inference in Bayesian networks and Markov logic networks.
• Quantitative verification of hardware and randomized algorithms.
• Statistical relational learning
• Quantum and classical statistical physics (e.g., partition function of Ising and Potts models, using a general Dirac notation–to–WMC translation as formalized by a type system and denotational semantics, implemented in the DiracWMC Python framework) (Ende et al., 29 Aug 2025).
• Structural parameterizations: Problems remain fixed-parameter tractable when parameterized by the sum of a constraint (e.g., at most $k$ ones in an assignment) and signed twin-width of the (signed) incidence graph. This parameterization is tight; vanilla twin-width or removal of the bound destroys tractability, as shown for Bounded-ones WMC (BWMC) (Ganian et al., 2022).

Domain	WMC Role	Key Methodological Feature
Graphical models	Partition function computation	Knowledge compilation, hashing
Hardware verification	Fault-tolerant design analysis	Decision-DNNF, tensor networks
SRL / MLNs	Lifted inference, structure	FO$^2$ tractable fragments
Statistical physics	Dirac notation translation,	CNF encoding for quantum models
Optimization	Shortest/Widest path, soft-OR	AMC over combinatorial semirings

The flexibility of WMC (and its algebraic generalizations) arises from the ability to instantiate different weight functions, semirings, and structural relaxations, each enabling tractable or scalable reasoning in distinct contexts. The field continues to expand towards richer logic, tighter numeric guarantees, and new architectures (e.g., quantum, neural, tensor).