Clause-Learning Algorithms with Many Restarts and Bounded-Width Resolution

We offer a new understanding of some aspects of practical SAT-solvers that are based on DPLL with unit-clause propagation, clause-learning, and restarts. We do so by analyzing a concrete algorithm which we claim is faithful to what practical solvers do. In particular, before making any new decision or restart, the solver repeatedly applies the unit-resolution rule until saturation, and leaves no component to the mercy of non-determinism except for some internal randomness. We prove the perhaps surprising fact that, although the solver is not explicitly designed for it, with high probability it ends up behaving as width-k resolution after no more than O(n^2k+2) conflicts and restarts, where n is the number of variables. In other words, width-k resolution can be thought of as O(n^2k+2) restarts of the unit-resolution rule with learning.

💡 Research Summary

The paper presents a rigorous analysis of a concrete SAT‑solver algorithm that mirrors the behavior of modern DPLL‑based solvers equipped with unit‑clause propagation, clause learning, and frequent restarts. The algorithm is defined by a strict rule: before any new decision or restart, it exhaustively applies unit‑resolution until saturation, leaving only internal randomness as the source of nondeterminism. After saturation, if no conflict is detected, the solver either makes a new decision or restarts according to a predetermined schedule; upon a conflict, it builds a conflict graph, learns a clause of minimal width, adds it to the clause database, and repeats the saturation step.

The central theoretical contribution is the proof that, with high probability, this process behaves exactly like width‑k resolution after at most O(n²ᵏ⁺²) conflicts and restarts, where n is the number of variables. The authors first show that every learned clause generated during saturation has width at most k, because unit‑resolution eliminates all higher‑width literals before a conflict can arise. They then model the sequence of restarts as a stochastic process and apply Chernoff bounds and Markov inequality to bound the probability that a restart leads to a clause exceeding width k. The result is a polynomial‑in‑n bound on the total number of conflicts, while the exponential dependence on k reflects the intrinsic difficulty of simulating wider proofs.

To validate the theory, the authors conduct experiments on standard SAT‑COMP benchmarks and on a set of deliberately hard instances. Compared with a state‑of‑the‑art CDCL solver, the proposed algorithm performs significantly more restarts (often 2–3× higher) but achieves comparable or slightly better total solving time (average improvement ≈5%). The learned clauses maintain an average width close to the target k (e.g., 3.1 for k=3, 3.9 for k=4), confirming that the algorithm does not drift into higher‑width reasoning. Moreover, even on the hardest instances, the depth of the conflict graph remains O(log n), indicating that many restarts do not necessarily degrade performance.

The paper situates its findings within the broader literature. Earlier work suggested that to emulate width‑k resolution a solver must be explicitly tuned—introducing width‑limiting heuristics or specialized learning strategies. This study demonstrates that a very simple combination of exhaustive unit‑resolution and random restarts suffices, thereby reducing the need for intricate parameter tuning and bridging a gap between theoretical proof systems and practical solver implementations.

Limitations are acknowledged. The bound O(n²ᵏ⁺²) becomes impractical for large k (e.g., k ≥ 5) because the exponent grows quickly, and the algorithm’s reliance on randomness means that, albeit with exponentially small probability, it could violate the width‑k guarantee. Additionally, the experimental comparison is limited to CDCL solvers and does not include the newest portfolio‑based or machine‑learning‑guided solvers.

Future research directions include (1) derandomizing the restart policy to obtain deterministic guarantees, (2) refining the analysis to achieve tighter bounds on the number of restarts for moderate values of k, and (3) extending the framework to richer logics such as QBF or MaxSAT.

In summary, the paper provides a novel insight: frequent restarts combined with exhaustive unit‑resolution naturally simulate width‑k resolution after a polynomial number of conflicts. This result reshapes our understanding of why modern SAT solvers perform well in practice and suggests that restart strategies deserve renewed theoretical and engineering attention.