Efficient Incremental #SAT via Cross-Instance Knowledge Reuse

Abstract: Model counting ($#\text{SAT}$) is a fundamental yet $#\text{P}$-complete problem central to probabilistic reasoning. In this work, we address \textit{incremental model counting}, where sequences of structurally similar formulas must be counted. We propose an approach that amortizes computation via a persistent caching mechanism, retaining component data across solver calls to avoid redundant search. Additionally, we investigate branching heuristics adapted for this setting. We focus on the problems of argumentation and soft core, for which incremental model counting is natural. Experiments demonstrate that our method improves performance compared to current model counters, highlighting the capability of structure-aware reuse in dynamic environments.

• The paper introduces a cross-instance framework for incremental #SAT that reuses search artifacts to drastically cut computation time.
• It employs explicit component caching with symmetry-aware normalization to maintain correctness despite dynamic changes in CNF formulas.
• The approach further reuses tree decompositions and hybrid heuristics, yielding notable runtime improvements in applications like dynamic argumentation.

Efficient Incremental Model Counting via Cross-Instance Knowledge Reuse

Introduction and Motivation

Model counting (#SAT), the task of determining the number of satisfying assignments for a propositional formula in CNF, is central to a variety of AI domains, including exact probabilistic inference, reliability analysis, and knowledge representation. While model counters such as cachet, SharpSAT, and d4 have achieved notable advances, these solvers fundamentally assume static instances—discarding all learned information between closely related problem formulations. However, real-world applications often involve iterative or dynamic problem instances with high syntactic overlap, such as argumentation dynamics and iterative soft core minimization. The inability of classical tools to leverage structural similarity across sequences of formulas leads to redundant computation and suboptimal efficiency.

This paper addresses the incremental #SAT problem by introducing a cross-instance knowledge reuse framework that amortizes computation across evolving CNF repositories. Through persistent component caching and reuse of branching heuristics, notably tree decompositions (TDs), the proposed approach executes model counting in dynamic settings with significant time and memory advantages over both static and alternative incremental methods.

Framework for Incremental Model Counting

The central abstraction is a dynamic repository of CNF formulas undergoing arbitrary syntactic updates, captured as sequences of clause/variable addition and removal steps. Rather than invoke model counting after each atomic modification, counts are computed at explicit checkpoints reflecting batches of updates. The aim is to minimize cumulative runtime across these sequence points by leveraging computation and search artifacts from prior calls.

The framework formalizes an explicit state transition system where a formula evolves through batches of elementary operations:

• Clause addition/removal: Modifies the clause set within a fixed variable scope.
• Variable addition/removal: Adjusts the counting scope, with stringent preconditions to preserve formula well-formedness.

This generalization strictly subsumes classical incremental SAT, allowing unrestricted structural modifications without reliance on assumption propagation. Importantly, this enables reusing search products even when the clause or variable set changes in unpredictable ways.

Persistent and Symmetry-Aware Component Caching

Canonical component decomposition and caching underpin state-of-the-art DPLL-style #SAT solvers, ensuring that repeated subproblems are only solved once. However, classical cache representations in tools such as SharpSAT and d4 encode indices relative to a static base formula, rendering cache keys unsound when clauses or variables change. The current work overcomes this by:

1. Adopting fully explicit clause-literal representations: Cache keys are treated as the total syntactic content of components, ensuring correctness under arbitrary formula evolution.
2. Normalization and symmetry exploitation: Instead of naive lexicographic sorting, the cache key construction judiciously orders literals and clauses by occurrence frequencies, then canonicalizes the component up to automorphic variable renaming.

This "lazy symmetry caching" allows the reuse of model counts for subproblems that are semantically isomorphic but not syntactically identical—critical when formulas in dynamic sequences differ only by literal or variable permutations.

Figure 1: Comparison of d4 runtimes with no sharing versus shared symmetric caching on argumentation benchmarks—persistent cache yields multi-order performance gains in the majority of cases.

The experimental data show orders-of-magnitude runtime improvements on dynamic argumentation tasks, with cache sharing modes frequently outperforming standard baseline processing by factors of 10--50× on simpler sequences.

Reuse of Structural Heuristics (Tree Decomposition Sharing)

Branching variable selection heuristics are responsible for the exponential search space reduction observed in modern model counters. Heuristics informed by the structure of the primal variable graph, especially tree decompositions (TDs), exhibit consistent practical advantages. However, TD computation is expensive and highly sensitive to formula structure.

The paper proposes amortizing TD computation by constructing the TD only for the initial formula in a batch and reusing it throughout the sequence, provided only clause removal operations are performed. This leverages the stability of decompositional structure and enforces globally consistent branching orders, resulting in improved cache locality and positive hit rates.

Hybrid heuristics combining deterministic scores (DLCS) with TD-based ordering further enhance cache efficacy. Empirically, DLCS outperforms conflict-driven alternatives like VSADS in the incremental use case—this is attributed to its less volatile variable selection when formula structure changes only minimally.

Empirical Evaluation and Numerical Results

Two primary application domains are considered: extension counting in dynamic argumentation frameworks and subset-minimal soft core computation. The experiments span large collections of benchmarks (264 dynamic AF sequences; 3000+ soft core instances) and rigorously contrast the proposed framework with leading #SAT solvers and recent incremental model counters.

Highlights include:

• On dynamic argumentation, persistent caching yields a median speedup of 1200%, with frequent outliers at 5000% or more. The number of cache hits increases from 0 (no reuse) to hundreds per repository, confirming substantive reuse.
• The "shared+symmetry" mode achieves best-in-class results, consistently solving more benchmarks than non-incremental d4 and GANAK, both in total and under hard timeouts.
• For soft core minimization, persistent cache and TD sharing dominate for easier instances. On the hardest benchmarks (high runtime intervals), specialized search techniques in tools like GANAK close the margin, but the reuse-based approach remains competitive.

  Figure 2: Runtime scatterplot comparing the best d4 configuration to GANAK, illustrating d4 superiority on easier instances due to cache/TD reuse, with GANAK excelling on a subset of highly structured, pre-processing-friendly benchmarks.

Further mode ablations (Figures 5–7) confirm that cache sharing is the main driver of speedup on easier sequences, while TD reuse becomes pivotal on structurally stable but complex instances.

Discussion and Implications

This work establishes that explicit, normalized component caching together with structural heuristic reuse can dramatically accelerate #SAT over sequences of syntactically similar CNF problems. The key new technical insight is that cache representations must be robust to client-driven formula modification—necessitating semantic rather than purely syntactic keys (i.e., canonicalization up to permutation).

Practically, this enables efficient deployment of #SAT in iterative AI tasks such as dynamic argumentation, core minimization, and many incremental reasoning and diagnosis workflows. The framework obviates the need for knowledge compilation or precomputed variable activation strategies, generalizing across arbitrary clause/variable edits.

On the theoretical side, the approach highlights substantial interaction between formula structure, component symmetries, and the efficiency of knowledge reuse. This opens avenues for the systematic study and automatic detection of cross-instance transfer potential in symbolic reasoning.

Future work includes extending the framework to projected (weighted) model counting, increasing the scope for multi-repository amortization (e.g., in portfolio or distributed reasoning), and integrating finer-grained structure learning for dynamic benchmarks with less syntactic similarity.

Conclusion

The cross-instance knowledge reuse approach advanced in this paper demonstrates that explicit and symmetry-aware cache representations, coupled with structural heuristic sharing, enable practical and reliable incremental model counting across evolving CNF benchmarks. Substantial empirical gains are observed in core AI reasoning tasks, and the results generalize across both practical and competition-derived benchmarks. This contribution lays a systematic foundation for future research into incremental #SAT and its application within dynamic and iterative AI workflows.