From Total Assignment Enumeration to Modern SAT Solver

A new framework for presenting and analyzing the functionality of a modern DLL-based SAT solver is proposed. Our approach exploits the inherent relation between backtracking and resolution. We show how to derive the algorithm of a modern SAT solver from DLL step-by-step. We analyze the inference power of Boolean Constraint Propagation, Non-Chronological Backtracking and 1UIP-based Conflict-Directed Backjumping. Our work can serve as an introduction to a modern SAT solver functionality and as a basis for future work on the inference power of a modern SAT solver and on practical SAT solver design.

💡 Research Summary

The paper presents a systematic framework for deriving the algorithmic structure of modern DLL‑based SAT solvers starting from the most naïve total assignment enumeration (TAE) approach. It first clarifies the relationship between exhaustive search (TAE) and the classic DPLL (DLL) backtracking algorithm, showing that TAE can be viewed as a depth‑first traversal of the assignment space that checks clause satisfaction only after a complete assignment is built, whereas DLL interleaves clause checks after each variable decision, allowing early conflict detection. The authors formalize proof size for both methods as the number of decision steps (flips are not counted as decisions) and prove that TAE does not p‑simulate DLL, because the shortest DLL proof for a simple unsatisfiable formula (a ∧ ¬a) has size 1 while any TAE proof requires 2ⁿ − 1 steps.

From this baseline, the authors incrementally add four enhancements that characterize modern SAT solvers: (1) Boolean Constraint Propagation (BCP), (2) Non‑Chronological Backtracking (NCB), (3) 1‑UIP‑based Conflict‑Directed Backjumping (CDB), and (4) Conflict Clause Recording (CCR). The paper focuses on the first three, leaving CCR for future work. A central technical contribution is the introduction of “parent clause” and “parent resolution” concepts. For each decision level d, a parent clause is a clause containing the flipped literal v_d together with a subset of previously assigned literals that are falsified under the current partial assignment. This clause is derived by tree‑like resolution during backtracking and serves as a logical justification for the flip. Maintaining parent clauses guarantees two invariants: flip‑consistency (every right decision level has a valid parent clause) and resolution‑consistency (the global resolution graph G remains a valid tree‑like resolution refutation, and each parent clause is a root of a subtree).

Algorithm 1 (the SAT Solver Skeleton, SSS) implements DLL with explicit parent‑clause maintenance. It consists of three nested loops: the main loop (selecting a new decision literal), the conflict‑analysis loop (detecting a falsified clause and possibly flipping the current decision), and the backtracking loop (resolving parent clauses with the current backtrack clause to generate a new backtrack clause). The status of each decision level (L or R) is tracked, and the backtrack clause is updated by resolution with the parent clause of the current level. The authors prove that the two invariants are preserved throughout execution.

The paper then analyses the inference power of each enhancement. BCP adds unit‑propagation: whenever a clause becomes unit under the current partial assignment, the remaining literal is forced. The authors show that BCP p‑simulates DLL (any DLL proof can be transformed into a BCP‑augmented proof of comparable size) but also construct a family of formulas where the shortest BCP proof is linearly longer than the optimal DLL proof, demonstrating that BCP can increase proof size in the worst case.

Non‑Chronological Backtracking (NCB) is examined next. When a conflict is found, NCB jumps back directly to the lowest decision level that appears in the conflict clause, rather than simply undoing the most recent decision. The authors prove that DLL with NCB is at least as strong as plain DLL and, in fact, has the same proof power: any DLL proof can be simulated without increasing size, and vice‑versa. The key insight is that the backtrack clause generated during NCB is always a root of a tree‑like resolution refutation, preserving the resolution‑consistency invariant.

The third enhancement, 1‑UIP‑based Conflict‑Directed Backjumping (CDB), builds on the implication graph used in modern solvers. The algorithm identifies the first Unique Implication Point (UIP) in the conflict graph, learns the corresponding clause, and backjumps to the UIP level. The authors argue that CDB contributes both “backward pruning” (reducing the size of the newly generated left decision subtree) and “forward pruning” (reducing the search space after the learned clause is added). By interpreting the learned clause as a new parent clause, they show that CDB does not increase proof size relative to DLL, and that DLL, DLL + NCB, and DLL + CDB are all equally strong with respect to minimal resolution refutation size.

The paper situates these results within the broader landscape of proof systems. General resolution (GR) is known to be the strongest among propositional proof systems. Tree‑like resolution (TLR) is a restricted form where each clause appears at most once on any path from a source to the empty clause. Prior work has shown that DLL with Conflict Clause Recording (CCR) and unrestricted restarts p‑simulates GR. The authors note that the inference power of CCR remains an open question, but their framework clarifies the contribution of BCP, NCB, and CDB. They demonstrate that while BCP can increase proof length, NCB and CDB do not affect the asymptotic proof size.

Finally, the authors discuss practical implications. They argue that the first step in implementing a modern SAT solver should be the maintenance of parent clauses, as this provides a clean foundation for adding BCP, NCB, and CDB independently. The paper also references related work on data structures, heuristics, and extensions to Satisfiability Modulo Theories (SMT), suggesting that the presented framework can serve as a pedagogical guide for both theoretical analysis and practical solver development.

In summary, the paper offers a clear, step‑by‑step derivation of a modern SAT solver from a naïve exhaustive search, introduces a novel resolution‑based perspective on parent clauses, and rigorously compares the inference power of the three most widely used enhancements (BCP, NCB, and 1‑UIP CDB). Its contributions lie both in providing an accessible blueprint for implementing modern solvers and in establishing a theoretical baseline for future investigations into the proof‑complexity of SAT solving techniques.