Conflict-Driven Clause Learning

• CDCL is a SAT solving method that integrates systematic search with conflict analysis and non-chronological backtracking to efficiently prune the search space.
• It employs techniques such as unit propagation, watched literals, and implication graphs to detect conflicts and derive learned clauses that avoid repetition of failed assignments.
• CDCL's versatility is demonstrated through its extensions into domains like cryptanalysis, circuit verification, and neural network verification, enhancing its practical impact.

Conflict-Driven Clause Learning (CDCL) is the foundational paradigm for modern SAT solving, merging systematic branching search with robust learning from conflicts. CDCL maintains a dynamic trail of partial Boolean assignments, leveraging clause database management, efficient propagation techniques, sophisticated conflict analysis, and non-chronological backtracking to prune the search space. The core innovation is the extraction of "learned clauses" from conflicts, preventing the solver from repeating the same failing assignment patterns. Recent years have seen generalizations and optimizations of the CDCL architecture, including probabilistic and quantum-guided heuristics, domain-specific integrations, extensions to richer abstract domains, and advances in learned clause database management. CDCL's influence extends to cryptanalysis, circuit verification, ILP, and neural network verification, establishing it as the dominant approach for Boolean reasoning in both theory and large-scale practice.

1. Core Workflow and Architecture

A CDCL SAT solver operates on a CNF formula $F$ and alternates between decision assignments, unit propagation, conflict analysis, learning, and backtracking:

• Decision & Propagation: On each iteration, either a branching literal is assigned at a new decision level, or forced assignments (via unit propagation) are performed. Watched-literal data structures enable $O(1)$ per-assignment propagation checks, even on large clause databases (Nejati et al., 2020).
• Conflict Detection: If a clause becomes falsified under the current assignment, a conflict is detected.
• Implication Graph & First-UIP Clause Learning: The solver constructs an implication graph tracing the causal path from decisions to the conflict. It resolves along this graph until producing a clause with exactly one literal assigned at the current decision level—the First Unique Implication Point (1-UIP). This clause generalizes the reason for the conflict (Nejati et al., 2020).
• Non-chronological Backjumping: The solver undoes assignments up to the highest level in the learned clause (excluding the 1-UIP literal), ensuring immediate unit propagation of the learned clause when backtracking (Nejati et al., 2020).
• Clause Database Management: Learned clauses are added to the database, with periodic deletion of low-quality clauses to control memory and maintain high propagation speed (Krüger et al., 2022).

2. Conflict Analysis, Clause Learning, and Backjumping

Conflict analysis in CDCL is formalized via implication graphs, where:

• Vertices correspond to assigned literals at the current decision level plus a special conflict node ($\perp$).
• Edges model "reason clauses" used for propagation.
• Clause learning constructs a new clause by resolving until a cut (the 1-UIP) is found, encapsulating the minimal reason for the conflict.

Mathematically, for a conflict at decision level $d$, the learned clause $C^*$ satisfies: $$C^* \subseteq F \quad \wedge \quad C^* \text{ is unit under the backtrack assignment}$$ where the assertion level is

$$\beta = \max \{ \text{level}(l) \mid l \in C^*, l \neq l_0 \}$$

with $l_0$ being the single literal from the current decision level (Nejati et al., 2020). Backjumping reverts the assignment stack to this assertion level, enforcing $l_0$ via propagation.

Variable selection is typically driven by the VSIDS heuristic, and clause deletion is orchestrated by measures such as LBD (Literal Block Distance), size, and activity scores (Nejati et al., 2020, Krüger et al., 2022).

3. Learned Clause Database Management Strategies

The learned clause database can theoretically grow exponentially, so identifying and maintaining only the most relevant clauses is critical for performance. Multiple relevance metrics are widely employed:

• Clause Size ($\mathrm{SIZE}(c)$): Favors shorter clauses.
• Literal Block Distance (LBD): Measures the number of distinct decision levels among clause literals [Audemard–Simon 2009]. Lower LBD empirically correlates with strong pruning.
• VSIDS-based Clause Activity ($O(1)$0): Incrementally increased when the clause participates in conflicts, subject to periodic decay.

As presented in "Towards Learned Clauses Database Reduction Strategies Based on Dominance Relationship" (Lonlac et al., 2017), multi-criteria dominance relations can be defined: $O(1)$1 where $O(1)$2 is the set of measures. The degree of compromise (DegComp) of a clause is formed from normalized scores: $O(1)$3 At each reduction, all clauses strictly dominated by the reference clause of minimal DegComp are deleted. Clauses with $O(1)$4 or $O(1)$5 are unconditionally preserved.

Empirical results on industrial benchmarks reveal that the dominance-based (DegComp) strategy outperforms or matches single-metric strategies and results in a dynamically varying deletion fraction per cleaning step (Lonlac et al., 2017).

4. Theoretical Foundations, Clause Deletion, and Proof Complexity

CDCL is tightly connected to subsystems of resolution in proof complexity. In "On CDCL-based proof systems with the ordered decision strategy" (Mull et al., 2019):

• Ordered Decision (π-D) + DECISION Learning: Yields a proof system polynomially equivalent to π-ordered resolution. Fixed variable orderings can limit the solver to weaker proof systems.
• FIRST-L Learning: By stopping analysis after the first new clause when backtracking, CDCL is polynomially equivalent to full resolution, recovering all of classical resolution's proof-theoretic power.

These results clarify how the interplay of decision strategies and learning schemes governs the deductive strength of CDCL-based solvers and highlight the foundational role of heuristics and learning in simulating general resolution.

5. Clause Forgetting, Runtime Distributions, and Empirical Insights

Though clause learning is crucial for pruning the search space, it can paradoxically degrade performance if clauses are never deleted (Krüger et al., 2022). Extensive experiments show:

• Retaining all learned clauses often leads to long-tailed, multimodal runtime distributions best modeled as mixtures of Weibull distributions.
• Empirically, about 25–32% of instances show runtime multimodality, and never deleting clauses frequently increases mean runtime.
• Clause deletion (forgetting) acts as a mode reset, shifting the solver between statistical "regimes" and breaking long-tail behavior. This breaks pathological slow modes and significantly improves mean runtime and outlier frequency.
• State-of-the-art policies typically delete a dynamically determined fraction of the most "irrelevant" clauses, as measured by combinations of LBD, activity, and size (Lonlac et al., 2017, Krüger et al., 2022).

The statistical view (Weibull mixture model) provides a formal rationale for periodic clause database cleaning, beyond just improving unit propagation speed.

6. Advanced Integrations: Domain-Specific and Hybrid CDCL

CDCL has been substantially extended beyond classical SAT:

• Cryptanalysis: Specialized CDCL engines, such as CDCL(Crypto), incorporate domain-specific propagation and conflict analysis routines (e.g., algebraic consistency in ARX adders, differential reasoning) injected via callbacks (Nejati et al., 2020). Programmatic addition of reason/conflict clauses guided by cryptanalytic knowledge enhances pruning rates and solves instances beyond the reach of black-box encodings.
• Integer Programming: The IntSat framework generalizes CDCL to integer variables and linear constraints, employing conflict-driven learning of general integer inequalities (via resolution and cutting planes) and bound-propagation (Nieuwenhuis et al., 2024).
• Neural Network Verification: Both DeepCDCL and proof-driven CDCL(T) methodologies modularly integrate SAT solvers (with asynchronous or theory-driven clause learning) and DNN verifiers, demonstrating significant speedups and scalability to real-world networks (Isac et al., 15 Mar 2025, Liu et al., 2024).
• First-Order Logic (FOL): The two-watched literal scheme, vital for efficient Boolean CDCL, has been lifted to FOL, supporting unit propagation and conflict detection on non-ground clauses through invariant-maintaining watched-pair structures (Briefs et al., 20 May 2026).
• Quantum and Heuristic Guidance: Quantum-guided subproblem search (Maouaki et al., 25 May 2026) and p-bit Ising sampler–based assumption heuristics (Bino, 5 May 2026) bias the branching heuristics or assumption literals that drive CDCL internal search, yielding order-of-magnitude reductions in conflicts and propagations for select distributions.

7. Practical Guidelines and Extensions

Several best practices and extensibility properties emerge from the literature:

• Choice and Normalization of Relevance Measures: In dominance-based deletion schemes, any set of normalized measures can be incorporated; adding a measure can only contract or expand the set of dominated clauses (Lonlac et al., 2017).
• Unconditional Protection of Potent Clauses: Clauses with $O(1)$6 or $O(1)$7 should always be retained, as they are typically of highest strength (Lonlac et al., 2017).
• Cleaning Frequency: Retain the reduction-triggering policy of the base solver for deletion/cleaning steps.
• Overhead Considerations: The time complexity of the multi-measure deletion procedure is $O(1)$8 per cleaning, which is marginal relative to the benefit of dynamic adaptation (Lonlac et al., 2017).
• Extensibility: The dominance-based approach supports extension to skyline-based deletion or multiple reference clauses, enabling finer-grade clause management if needed.
• Trade-offs: No single deletion or selection policy is uniformly optimal; degeneracies among relevance measures and diversity of instance characteristics necessitate adaptive, multi-criteria strategies (Lonlac et al., 2017, Krüger et al., 2022).
• Theoretical and Empirical Rationale for Clause Deletion: Clause forgetting not only accelerates propagation but is statistically essential to avoid pathological (super)polynomial-time behavior (Krüger et al., 2022).

---

References:

• "Towards Learned Clauses Database Reduction Strategies Based on Dominance Relationship" (Lonlac et al., 2017)
• "CDCL(Crypto) SAT Solvers for Cryptanalysis" (Nejati et al., 2020)
• "Too much information: why CDCL solvers need to forget learned clauses" (Krüger et al., 2022)
• "On CDCL-based proof systems with the ordered decision strategy" (Mull et al., 2019)
• "Proof-Driven Clause Learning in Neural Network Verification" (Isac et al., 15 Mar 2025)
• "DeepCDCL: An CDCL-based Neural Network Verification Framework" (Liu et al., 2024)
• "Conflict-Driven XOR-Clause Learning (extended version)" (Laitinen et al., 2014)
• "IntSat: Integer Linear Programming by Conflict-Driven Constraint-Learning" (Nieuwenhuis et al., 2024)
• "A Two-Watched Literal Scheme for First-Order Logic" (Briefs et al., 20 May 2026)
• "Probabilistic-bit Guided CDCL for SAT Solving using Ising Consensus Assumptions" (Bino, 5 May 2026)
• "QGCL: Quantum-Guided Clause Learning for Cryptanalytic SAT" (Maouaki et al., 25 May 2026)