Maximum Model Counting

• Maximum model counting is the study of techniques for determining the number of satisfying assignments using exact, high-confidence approximate, and scalable methods.
• It encompasses diverse approaches such as hashing with XOR constraints, partial knowledge compilation, and theory-native projected counting.
• Researchers apply these methods to enhance performance in domains like SMT solving, probabilistic logic programming, and certified model counting.

Maximum model counting denotes the study of procedures that determine, certify, or tightly approximate the number of satisfying assignments of a logical specification when exactness, confidence, or scalability is pushed to an extreme. In the cited literature, the phrase is not fixed to a single formal problem. Taken together, the works suggest three closely related uses: exact model counting, high-confidence approximate counting, and highly scalable counting over richer theories. At its core lies the model count of a Boolean formula $F$,

$$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$

together with weighted and projected variants that count weighted models or distinct assignments on a chosen projection set (Boreale et al., 2019, Fichte et al., 31 Jan 2025).

1. Scope and formal variants

Taken together, the cited works suggest that “maximum model counting” is used in at least three nearby senses rather than as a single standardized term.

Use in the literature	Characteristic objective	Representative works
Exact counting	Determine the true count $\#F$	(Birnbaum et al., 2011, Lai et al., 2022, Vílchez et al., 17 Sep 2025)
High-confidence approximate counting	Make $\delta$ as small as feasible under PAC guarantees	(Yang et al., 2023, Tan et al., 2024)
Highly scalable approximate counting	Preserve useful guarantees on very large CNF, SMT, or lifted instances	(Boreale et al., 2019, Shaw et al., 24 Jul 2025, Bremen et al., 2020)

A probabilistic approximate counter is typically specified in PAC form. One formulation requires that $\mathsf{Count}(F,\varepsilon,\delta)$ return $c$ such that

$$\Pr\Big[\frac{\#F}{1+\varepsilon} \le c \le (1+\varepsilon)\#F\Big] \ge 1-\delta.$$

The high-confidence regime emphasizes pushing $\delta$ to very small values, which the literature explicitly identifies as an Achilles heel of standard hashing-based counters (Yang et al., 2023).

The Model Counting Competition formalizes four closely related counting tasks. Standard model counting is

$\mc(F)=|\Mod(F)|.$

Weighted model counting is

$\wmc(F,w)=\sum_{M\in\Mod(F)} w(M).$

Projected model counting is

$$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$0

Projected weighted model counting is

$$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$1

These definitions are important because modern “maximum” practice rarely concerns only plain $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$2SAT; it also concerns weighting, projection, and hybrid combinations of both (Fichte et al., 31 Jan 2025).

2. Exact counting and exhaustive architectures

Exact model counting remains the reference point. It is $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$3P-complete, and early exact work already showed that counting is structurally different from satisfiability. The Davis–Putnam-based CDP algorithm replaces SAT’s existential branching with additive branching, using the base cases “empty formula $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$4” and “formula containing an empty clause $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$5.” Its abstract reports an average running time $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$6, where $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$7. The same study also showed that the hardest regions for counting need not coincide with the classical SAT phase transition: for random 3-CNF, the maximum difficulty for counting appeared around $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$8, not around the familiar SAT region near $$\#F = |\{\sigma \in \{0,1\}^m : \sigma \models F\}|,$$9 (Birnbaum et al., 2011).

This difference matters for the interpretation of “maximum.” Maximum difficulty in counting is often associated with formulas that still have many models, because the counter must account for all of them. That observation directly contradicts the common misconception that the hardest $\#F$0SAT instances should simply mirror the hardest SAT instances. The counting landscape is instead shaped by exhaustive exploration, additive composition of branches, and the fact that pure-literal effects that help SAT do not automatically help counting (Birnbaum et al., 2011).

More recent exact and near-exact approaches move away from pure search trees toward structured circuit representations. “Fast Converging Anytime Model Counting” presents PartialKC as an anytime method based on partial knowledge compilation into CCDD. Its estimator is unbiased, it can converge to the exact count once compilation completes, and it empirically reached convergence on 933 of 1214 benchmarks within 5000 seconds and 8 GB memory while solving 1103 of 1214 instances overall (Lai et al., 2022). This suggests that, in practice, “maximum” exact counting is often approached through progressively refined compiled structure rather than a single monolithic exhaustive search.

3. Hashing, XOR constraints, and high-confidence approximation

Modern approximate model counting is dominated by hashing-based methods. The central idea is to add random XOR constraints and use SAT calls to determine whether the surviving cell is empty or small. “Approximate Model Counting, Sparse XOR Constraints and Minimum Distance” makes this viewpoint explicit and studies the satisfiability of

$\#F$1

under sparse random XOR constraints. Its main contribution is geometric: the feasibility of sparsifying XORs while retaining guarantees depends on the minimum Hamming distance between models. For sparse XOR distribution parameter $\#F$2, the joint survival probability of two assignments at Hamming distance $\#F$3 depends on $\#F$4 with $\#F$5, and the resulting variance bounds are governed by pairwise distances in the solution set. In short, higher minimum distance allows shorter XORs without losing correctness guarantees (Boreale et al., 2019).

That geometric dependence addresses a central practical bottleneck. Dense XORs are expensive for SAT solvers; sparse XORs are much cheaper. The cited work shows that dense XORs are not the only theoretically defensible choice. For instance classes with large minimum distance, the expected XOR length implied by the bounds can be much smaller than earlier worst-case bounds. A representative comparison reported expected length $\#F$6 under an older bound versus $\#F$7 when using $\#F$8 for $\#F$9, $\delta$0, and $\delta$1 (Boreale et al., 2019).

High-confidence counting introduces a second bottleneck: the dependence on $\delta$2. “Rounding Meets Approximate Model Counting” isolates this issue and proposes RoundMC, which changes the per-run estimator by rounding and computes the repetition count using a tighter decomposition into under- and over-estimation probabilities. On a benchmark suite of 1890 instances, RoundMC solved 204 more instances than ApproxMC and achieved a $\delta$3 speedup. For $\delta$4 and $\delta$5, the paper reports 19 repetitions for RoundMC versus 117 for ApproxMC (Yang et al., 2023). A common misconception is that improving approximate counting at small $\delta$6 requires fundamentally new solvers; this work shows that changing the estimator and the amplification analysis can already alter the practical regime dramatically.

4. Partial knowledge compilation and symmetry-exploiting counting

A second major line of work approaches maximum scalability through partial compilation rather than pure hashing. “Approximate Model Counting by Partial Knowledge Compilation” introduces partial Decision-DNNF by adding unknown leaves to a rooted DAG with decision and decomposition nodes. Each call to PartialKC builds a randomly partial Decision-DNNF, and an unbiased estimate of the model number can be computed from that partial object. The compiled size after $\delta$7 MicroKC calls is $\delta$8, and computing the estimate from the resulting circuit also takes $\delta$9. The experimental study reported that PartialKC is more accurate than both SampleSearch and SearchTreeSampler, and that PartialKC scales better than SearchTreeSampler (Lai, 2018).

The significance of this construction is methodological. Full knowledge compilation offers polynomial-time counting once compilation succeeds, but full compilation may explode. PartialKC makes incomplete structure first-class: unknown regions are represented explicitly, yet the estimator remains unbiased. In effect, the method blurs the traditional boundary between exact compilation and Monte Carlo estimation. That is one of the clearest senses in which the literature pushes counting toward a “maximum” regime: it does not wait for a full circuit, but it still uses as much exact structure as has been discovered so far (Lai, 2018).

A different form of structure exploitation appears in first-order weighted counting. “Approximate Weighted First-Order Model Counting” studies symmetric WFOMC and decomposes the count by predicate cardinalities. For predicates $\mathsf{Count}(F,\varepsilon,\delta)$0, the weighted count is written as a sum over tuples $\mathsf{Count}(F,\varepsilon,\delta)$1, where each term combines a predicate-weight factor $\mathsf{Count}(F,\varepsilon,\delta)$2 with an unweighted first-order model count under cardinality constraints. The resulting ApproxWFOMC is an anytime algorithm that maintains lower and upper bounds, refines cardinality intervals, and realizes its unweighted oracle with ApproxMC3. It is presented as applicable to Markov logic networks and probabilistic logic programs and comes with PAC guarantees on the generated bounds (Bremen et al., 2020). This suggests that, in lifted settings, maximum scalability is often obtained not by abandoning combinatorial symmetry, but by organizing the search around it.

5. Beyond propositional CNF: SMT, hybrid theories, and integer linear constraints

The extension from Boolean CNF to richer theories changes what must be counted and what can be hashed. “Bit-Vector Model Counting using Statistical Estimation” studies approximate counting for bit-vector SMT formulas and, more generally, distinct outputs of a designated bit-vector variable. Its SearchMC framework treats the unknown influence $\mathsf{Count}(F,\varepsilon,\delta)$3 as a latent quantity, maintains a particle-filter approximation to its posterior, and adaptively chooses XOR-streamlined exhaust-up-to-$\mathsf{Count}(F,\varepsilon,\delta)$4 queries so that each solver call is informative. The implementation is reported to be faster than the most similar previous approaches and also supports formulas over floating-point constraints, including an application to a vulnerability in differential privacy mechanisms (Kim et al., 2017).

Hybrid SMT raises a sharper challenge because the counted space is discrete while the ambient theory may include continuous domains. “Approximate SMT Counting Beyond Discrete Domains” defines the projected counting problem

$\mathsf{Count}(F,\varepsilon,\delta)$5

for formulas over $\mathsf{Count}(F,\varepsilon,\delta)$6, where the projection set $\mathsf{Count}(F,\varepsilon,\delta)$7 belongs to a discrete theory such as bit-vectors while the remaining variables may range over reals, floating-point values, arrays, or uninterpreted functions. Its counter, pact, applies hashing only to the projection variables and leaves the remaining reasoning to the SMT solver. The paper proves an $\mathsf{Count}(F,\varepsilon,\delta)$8-guarantee and an SMT-call bound

$\mathsf{Count}(F,\varepsilon,\delta)$9

Empirically, on 14,202 instances, pact finished on 603, while the baseline finished on 13 (Shaw et al., 24 Jul 2025). This directly addresses the misconception that approximate counting over rich SMT theories must proceed by bit-blasting: the cited result shows that theory-native projected hashing can materially enlarge the solvable region.

Exact counting over arithmetic domains shows a similar pattern. “An Exhaustive DPLL Approach to Model Counting over Integer Linear Constraints with Simplification Techniques” studies model counting over integer linear constraints,

$c$0

and introduces EDPLLSim, an exhaustive DPLL architecture augmented with mixed-integer-programming simplifications such as bound strengthening, coefficient strengthening, row removal, and component decomposition. On 2840 random benchmarks, it solved 1718 instances, while the state-of-the-art approach solved 1470; on 4131 application instances, it was the only approach to solve all 4131 (Vílchez et al., 17 Sep 2025). Here again, “maximum” performance is achieved by avoiding a propositional detour and exploiting the native structure of the theory.

6. Competitions, certification, and the contemporary landscape

The Model Counting Competition provides the clearest operational picture of the field. The 2021–2023 iterations organized four tracks around MC, WMC, PMC, and PWMC. The results show that no single technique universally dominates. Search-based counters with component caching and structural heuristics, especially SharpSAT-TD, have been particularly strong on MC and WMC; knowledge-compilation systems such as D4 and ExactMC remain close competitors; GPMC has been especially strong on PMC and PWMC; and approximate portfolios combining Arjun, GANAK, and ApproxMC have been notably effective for projected counting. The competition analysis explicitly notes that approximate methods did not clearly outperform exact counting on MC within one-hour limits, whereas on PMC approximate portfolios did push beyond the best exact solvers (Fichte et al., 31 Jan 2025).

These results matter for the interpretation of “maximum model counting.” In current practice, the frontier is plural. For plain MC and WMC, exact solvers can still define the top end of performance on many benchmark suites. For PMC and hybrid projected tasks, approximate and portfolio methods increasingly determine the frontier. The same competition report emphasizes better preprocessing, structure-aware heuristics, proof certification, and hybrid architectures as central open directions (Fichte et al., 31 Jan 2025).

Trust in approximate counts has itself become a research topic. “Formally Certified Approximate Model Counting” presents the first certification framework for approximate model counting with formally verified guarantees on output quality. It combines a static Isabelle/HOL proof of ApproxMC’s PAC guarantee with dynamic per-run verification of CNF-XOR solver calls by proof certificates. Experimentally, certificate generation adds little overhead, and the checker fully certified $c$1 of instances with generated certificates under the same time and memory limits as the counter (Tan et al., 2024). This changes the status of high-confidence approximation: it is no longer merely a matter of asymptotic probabilistic analysis, but also of proof-producing solver infrastructure.

Taken together, these works suggest that the modern subject encompasses exactness, approximation, theory-awareness, structural exploitation, and certification. The frontier is defined less by a single algorithmic paradigm than by the ability to combine them while retaining either exact semantics or explicit PAC-style guarantees.