Part IV · trunk C · constraint programming and SAT · spine

SAT and the CDCL engine

Unit propagation, conflict analysis, backjumping, activity, restarts — resolution with a very good heuristic, and a proof system with limits you can state precisely.

needs 17~2 h slides + 3½ h lablab: uv run co lab 20

SAT solvers went from toy to industrial in about five years, around 1996–2001: GRASP (clause learning), Chaff (watched literals, VSIDS), then MiniSat's clean re-implementation. They now handle hardware verification instances with millions of variables, and they're the engine inside CP-SAT (unit 21), SMT solvers and many planners.

The unit has two halves that belong together. How CDCL works: every component the lab builds. What CDCL can't do: pigeonhole, and the resolution lower bound behind it. The second half is what turns "SAT solvers are magic" into a precise statement.

How to read this deck

Four clauses on five variables run through the engine half: their watched-literal propagation, the conflict, the learned clause by resolution, and the RUP check that a proof checker would do. Two slides then follow the same run with a termination measure, and a variant of it whose learned clause sends the solver back to level 0. The encodings half writes out a two-gate Tseitin transformation and at-most-one of four literals two ways. Every trace was produced by the lab's reference solver. Haken's lower bound is given as an idea; the argument is sketched in the notes.

20 · overview

The route

1 · from DPLL to CDCL

CNF, resolution, unit propagation, watched literals.

2 · learning

Implication graphs, first UIP, backjumping, VSIDS, restarts, LBD; why it stops.

3 · proofs and limits

DRAT; CDCL is resolution; pigeonhole's exponential lower bound.

4 · encodings

Tseitin, at-most-one, cardinality networks: why the smallest CNF is not the best.

getting around

Words with a dotted underline are glossary terms: click one for its definition. G lists every term in the unit, N shows the notes. Optional extra: interactive figures, linked from the slides they support by a small ▸ chip; skip them freely.

section 1

From DPLL to CDCL

Branch, propagate, and remember why you failed.

20 · DPLL

CNF, resolution, and unit propagation

CNF: a conjunction of clauses, each a disjunction of literals. SAT is NP-complete (Cook 1971); 3-SAT already is.

resolution $$\frac{(C \lor x) \qquad (D \lor \lnot x)}{C \lor D}$$

Sound and complete for refutation: $F$ is unsatisfiable iff the empty clause can be derived.

DPLL (Davis, Logemann & Loveland 1962): branch on a variable, apply unit propagation (a clause with all literals false but one forces it), and backtrack chronologically on a conflict.

two watched literals (Chaff 2001)

Watch two non-false literals per clause. A clause needs attention only when a watched literal becomes false: find a replacement, or the clause is unit or conflicting.

Backtracking costs nothing: unassigning variables never invalidates a watch. No counters to restore.

Lab step 1's test: on 40 random formulas with random decisions, the watch loop reaches exactly the assignments and conflicts of naive propagation.

20 · DPLL · example

Watched literals, on four clauses

$c_1 = (\lnot x_1 \lor x_3)$, $\ c_2 = (\lnot x_2 \lor \lnot x_3 \lor x_4)$, $\ c_3 = (\lnot x_2 \lor \lnot x_4 \lor x_5)$, $\ c_4 = (\lnot x_4 \lor \lnot x_5)$. Each clause watches its first two literals. Decide $x_1$, then $x_2$.

just assigned	visit clauses watching	what happens
$x_1$ (decision, level 1)	$\lnot x_1$: $c_1$	no replacement, other watch $x_3$ free: unit, $x_3$
$x_3$	$\lnot x_3$: $c_2$	replacement $x_4$ is free: watch moves to $x_4$
$x_2$ (decision, level 2)	$\lnot x_2$: $c_2$, $c_3$	$c_2$: only $\lnot x_3$ left, false: unit, $x_4$. $c_3$: watch moves to $x_5$
$x_4$	$\lnot x_4$: $c_3$, $c_4$	$c_3$: unit, $x_5$. $c_4$: both literals false: conflict

what the watches saved

$x_1$ touched one clause, $x_3$ one. $c_4$ was not looked at until $x_4$ was set: before that it had two unassigned watches, so it could not be unit.

Undoing level 2 unassigns $x_2, x_4, x_5$ and moves no watch back: $c_2$ still watches $x_4$ and $\lnot x_2$, both unassigned again, which is a valid state.

explore interactively

section 2

Learning

A conflict is a lesson; write it down.

20 · learning

The implication graph and the first UIP

Lab step 2's textbook example. Clauses (¬x₁∨x₃), (¬x₂∨¬x₃∨x₄), (¬x₂∨¬x₄∨x₅), (¬x₄∨¬x₅). Decisions x₁, then x₂.

Implication graph: a node per assigned literal (at its decision level, on the trail), with edges from the reason clause's other literals. A conflict is a clause with every literal false.

first UIP

A UIP is a current-level node on every path from the decision to the conflict. The first UIP is the one closest to the conflict.

Here x₄ is not a UIP: x₂ → x₅ bypasses it. The first UIP is x₂, and the learned clause is ¬x₂ ∨ ¬x₃: backjump to level 1 and assert ¬x₂. The next slide derives it.

Computing it is resolution: resolve the conflict clause with the reason of the latest current-level literal until one current-level literal remains.

explore interactively

20 · learning · example

The learned clause, by resolution, and checked

analysis: resolve backwards along the trail

clause so far	level-2 literals	resolve with
$c_4 = (\lnot x_4 \lor \lnot x_5)$	2	reason of $x_5$: $c_3$
$(\lnot x_2 \lor \lnot x_4)$	2	reason of $x_4$: $c_2$
$(\lnot x_2 \lor \lnot x_3)$	1	stop

One level-2 literal left, $\lnot x_2$: the first UIP. The clause's other literal, $\lnot x_3$, is from level 1, so backjump to level 1. There the clause is unit and asserts $\lnot x_2$ (an asserting clause). Its LBD is 2: levels 1 and 2.

the RUP check a proof checker does

To accept $(\lnot x_2 \lor \lnot x_3)$ as a lemma, assume its negation, $x_2$ and $x_3$, and propagate over the clauses so far:

$c_2$ gives $x_4$. $c_3$ gives $x_5$. $c_4$ is now false: conflict, so the lemma is implied. ✓

No search, no heuristics: two unit propagations. That is why checking a DRAT proof is cheap even when finding it wasn't.

The backjump skipped nothing here, but with ten decisions between level 1 and the conflict it would skip all of them: non-chronological backjumping.

explore interactively

The two resolution steps. $(\lnot x_4 \lor \lnot x_5)$ and $(\lnot x_2 \lor \lnot x_4 \lor x_5)$ clash on $x_5$; the resolvent keeps everything else, $(\lnot x_2 \lor \lnot x_4)$. That still has two level-2 literals. Resolving on $x_4$ with $(\lnot x_2 \lor \lnot x_3 \lor x_4)$ gives $(\lnot x_2 \lor \lnot x_3)$, with a single level-2 literal.

The reference analyze returns this clause with the asserting literal first, the backjump level 1 and LBD 2. After backjumping, the trail is $x_1, x_3$ at level 1, and the new clause immediately propagates $\lnot x_2$ at level 1: the solver will never try $x_2$ with $x_3$ again.

RUP stands for reverse unit propagation: the lemma is checked by propagating its negation. A first-UIP clause always passes, because the propagations that produced the conflict are exactly the ones the check replays.

20 · learning

The rest of the engine

Non-chronological backjumping: jump to the second-highest level in the learned clause, where it becomes unit. It can skip many levels of irrelevant decisions.
VSIDS (Chaff): bump the activity of variables in each conflict, and grow the bump by 1/decay after every conflict, so recent conflicts weigh exponentially more. Branch on the most active.
Phase saving (Pipatsrisawat & Darwiche 2007): re-assign a variable its last value, so backjumps don't discard satisfied sub-problems.
Restarts (unit 19's Luby, or adaptive): cheap, because learned clauses and activities survive.

clause deletion by LBD (Glucose, 2009)

Literal block distance: the number of distinct decision levels in a learned clause. "Glue" clauses (LBD ≤ 2) link two blocks of propagation and are kept forever. Periodically delete the worse half of the rest, never a clause that is a current reason.

Lab then, random 3-SAT at the threshold:

n	your conflicts	MiniSat	your s	MiniSat s
150 unsat	2 236	3 051	0.40	0.015
200 sat	8 588	7 748	2.31	0.048

The same conflicts, 30–50× the time per conflict: the algorithm is right, the language is slow.

Why VSIDS works is still partly empirical. The best-supported explanation (Liang et al. 2015) is that it focuses search on the "bridge" variables of the formula's community structure, which is why it does well on industrial instances with modular structure and less well on random ones.

Against unit 19b's backjumping. Conflict-directed backjumping on a CSP, with a nogood store, rests on the same idea: a nogood per dead end, and a jump past the choices it does not name. It differs in when it jumps (only once every value of a variable is closed, not at every conflict), in what it learns (the union of the reasons, not a first-UIP clause), in where it lands (the deepest variable of the nogood, closing its value, not the second-deepest level with the UIP forced), and above all in how it uses what it learned: its store is checked when a value is tried, while learned clauses take part in unit propagation. Unit 19b's slide "CBJ with a nogood store, against CDCL" sets the two side by side.

20 · learning · termination

Why CDCL stops, whatever it branches on

It is not obvious. VSIDS may branch on any variable, and a backjump can throw away every level, so the number of free variables goes back up. Counted level by level, it does go down.

the termination measure

For each decision level $\ell = 0, \dots, n$, let $f_\ell$ be the number of variables not assigned at any level $\le \ell$ on the trail. Read them as one number in base $n+1$, level 0 leading:

$$\mu = \sum_{\ell=0}^{n} f_\ell \,(n+1)^{\,n-\ell}$$

A level not yet open adds nothing, so its digit repeats the one before.

every step lowers $\mu$

Propagate at level $d$: $f_d - 1$.
Decide: $f_{d+1} - 1$.
Conflict at $d > 0$: the asserting clause adds a literal at some level $j < d$, so $f_j - 1$. The digits after $j$ go back up, but together they are worth less than one unit of digit $j$.
Conflict at level 0, or nothing left to decide: stop.

Each step lowers the first digit it changes. $\mu \ge 0$ and starts below $(n+1)^{n+1}$, so the run ends.

full proof in the notes (N)

where the choice of variable went

$\mu$ counts free variables per level, never which ones. VSIDS and phase saving pick which literal joins a level, not how many do. The heuristic owes one thing: an unassigned variable.

Unit 19b's measure, in CDCL's terms. Same shape: one digit per level, the shallowest leading, and every step lowers the first digit it changes while possibly raising the ones after it. In 19b a digit counts the values a depth still has to try. CDCL has no such list: a backjump does not flip the decision at level $j$ to its next value, it adds a literal the learned clause forces there. So here a digit counts the variables still free after that level. 19b gives a depth with no frame the top digit $\top$; here a level not yet open needs no special case, since "free after level $\ell$" already repeats the current count.

Full proof

Write $a_\ell$ for the number of literals at level $\ell$, so $f_\ell = n - (a_0 + \dots + a_\ell)$.

First, the digits are digits. Every level above 0 starts with a decision on an unassigned variable, so there are at most $n$ decisions and the levels run from 0 to at most $n$: $\mu$ has $n + 1$ digits. Each $f_\ell$ lies in $\{0, \dots, n\}$, a valid digit in base $n+1$, so $0 \le \mu \le (n+1)^{n+1} - 1$. With nothing assigned every digit is $n$ and $\mu$ is exactly $(n+1)^{n+1} - 1$; unit clauses in the input start it lower.

Second, comparing: if two values agree on digits $0, \dots, j-1$ and the first has a smaller digit $j$, the first is smaller, because the second's digit $j$ is worth at least $(n+1)^{n-j}$ more, while the first's digits after $j$ are worth at most $\sum_{\ell>j} n\,(n+1)^{n-\ell} = (n+1)^{n-j} - 1$, a geometric sum.

Third, each step, with $d$ the current level:

Propagate enqueues one literal at level $d$: $f_\ell$ drops by 1 for every $\ell \ge d$ and is unchanged before $d$. The first changed digit, $f_d$, drops.
Decide opens level $d+1$ with its decision literal: $f_\ell$ drops by 1 for every $\ell \ge d+1$, digits up to $d$ unchanged.
Conflict at $d > 0$. First-UIP analysis returns a clause with exactly one literal at level $d$, the UIP's negation, and all others false at levels below $d$. Let $j$ be the highest of those levels, or 0 if there are none. Cancelling levels above $j$ leaves digits $0, \dots, j$ unchanged, and the digits after $j$ rise to $f_j$: the undone variables are free again. The UIP's variable was assigned at level $d > j$, so it is now unassigned, while every other literal of the clause is still false: the clause is unit and its literal is enqueued at level $j$. Net effect: digits before $j$ unchanged, $f_j$ one lower, and by the comparison above $\mu$ falls, whatever the digits after $j$ did.
Conflict at level 0 means the empty clause is derivable: unsatisfiable, stop. No conflict and no unassigned variable: satisfiable, stop.

So every step but the last lowers $\mu$ by at least 1, from at most $(n+1)^{n+1} - 1$, without going below 0: at most $(n+1)^{n+1} - 1$ steps before the stop. For the example, $\mu$ starts at $6^6 - 1 = 46\,655$ and the run takes 8 steps, ending at $41\,472$. The bound is far from tight. Its only job is to show that the run ends.

None of this names the variable that was decided on, or its value, so it holds for VSIDS, phase saving, random choice, anything that returns an unassigned variable. Clause deletion removes clauses and never touches the trail, so it leaves $\mu$ alone; the solver never deletes a clause that is a current reason, which keeps the trail's justifications intact. Restarts are the one move that raises $\mu$: see "Back to level 0, and restarts".

Checked. The reference solver was instrumented to compute $\mu$ after every assignment and assert that it fell: 3 000 random formulas (seed 20, 3 to 12 variables, clauses of 1 to 3 literals) with a uniformly random variable and value at every decision, no restarts and clause deletion every 3 learned clauses; 2 503 were unsatisfiable, and every answer matched brute force. On 1 000 random 3-SAT formulas at ratio 4.3 (seed 21, 6 to 14 variables), $\mu$ fell across all 3 245 backjumps, 997 of them to level 0.

20 · learning · termination · example

The measure, on the running example

$n = 5$, so base 6

step	free after levels 0–5	$\mu$
start	5 5 5 5 5 5	46 655
decide $x_1$	5 4 4 4 4 4	45 100
propagate $x_3$	5 3 3 3 3 3	43 545
decide $x_2$	5 3 2 2 2 2	43 286
propagate $x_4$, $x_5$	5 3 0 0 0 0	42 768
conflict, jump to 1, $\lnot x_2$	5 2 2 2 2 2	41 990
decide $x_4$	5 2 1 1 1 1	41 731
propagate $\lnot x_5$: all set	5 2 0 0 0 0	41 472

Down on every row, including the jump: digits 2 to 5 go back up from 0 to 2, but digit 1 falls from 3 to 2.

The jump of the implication graph slide. Under each level, the variables still free after it. Digit 1 falls from 3 to 2 and outweighs digit 2's rise: one unit of digit 1 is worth $6^4 = 1\,296$, more than all later digits can hold ($1\,295$). Decisions outlined; the shaded literal is the one the learned clause asserts; dashed cells are unassigned again.

20 · learning · termination

Back to level 0, and restarts

The example with $c_2$ shortened to $(\lnot x_2 \lor x_4)$. Same decisions, same conflict, but analysis ends at the unit learned clause $(\lnot x_2)$: no level-1 literal is involved, so the jump goes to level 0 and undoes $x_1$ and $x_3$ too. Shading as on the previous slide.

what went down

Five literals undone, and digits 1 to 5 jump back up to 4. But the leading digit, the variables not fixed at level 0, falls from 5 to 4: $42\,768 \to 37\,324$.

Level 0 is never undone, so that digit never rises, and at most $n$ jumps land there. Between two of them, the digit for level 1 only falls, and so on down.

restarts raise $\mu$

A restart cancels every level above 0, sending those digits back up. But a run without restarts ends within $(n+1)^{n+1}$ steps, and Luby cutoffs grow without bound: some run is given that many conflicts, and ends.

Or keep every learned clause: each one is new, and there are only $3^n$ clauses. The lab's solver deletes clauses, so it relies on Luby.

The variant, step by step. Clauses $c_1 = (\lnot x_1 \lor x_3)$, $c_2' = (\lnot x_2 \lor x_4)$, $c_3$, $c_4$ as before. Decide $x_1$: $c_1$ gives $x_3$. Decide $x_2$: $c_2'$ gives $x_4$, $c_3$ gives $x_5$, $c_4$ is false. Resolve $c_4$ with $c_3$ on $x_5$: $(\lnot x_2 \lor \lnot x_4)$. Resolve with $c_2'$ on $x_4$: $(\lnot x_2)$, one literal, so the jump level is 0. The reference solver's trace: digits 5 3 0 0 0 0 ($\mu = 42\,768$), then 4 4 4 4 4 4 ($\mu = 4 \cdot 9\,331 = 37\,324$); it then decides $x_1$ again, propagates $x_3$, decides $x_4$, propagates $\lnot x_5$, and stops satisfiable at 4 2 0 0 0 0 ($\mu = 33\,696$).

The leading digit alone. $f_0$ is the number of variables not fixed at level 0. It never rises, not even across restarts, and every jump to level 0 lowers it: that alone bounds the jumps to level 0 by $n$. Between two of them levels 0 and 1 are never cancelled, so $f_1$ only falls, bounding the jumps to level 1; and so on. $\mu$ is that argument, level by level, written as one number.

The other way out: keep every learned clause. A learned clause is always new when nothing is deleted. Suppose the learned clause $C$ were already in the database at the conflict. Its literals other than the UIP's are false at levels $\le j$, and propagation runs to a fixpoint before every decision. So at the end of level $j$'s propagation, $C$ was unit and would already have forced the asserted literal, at level $j$ or below. But the UIP's variable was assigned at level $d > j$, a contradiction. Restarts do not affect this, so with no deletion every conflict adds a clause never seen before. There are $3^n$ clauses on $n$ variables (each variable positive, negative or absent), so a run has at most $3^n$ conflicts, and between two conflicts at most $n$ decisions and $n$ propagations. Checked on 1 500 random 3-CNF formulas (3 to 12 variables, $n$ to $6n$ clauses), restarting on the Luby schedule with a unit of one conflict, so very often, and deleting nothing: none of the 2 396 learned clauses was already in the database.

Unbounded cutoffs. This is unit 19b's argument, unchanged, and the one the lab's solver relies on, since it deletes clauses. Restart $i$ comes after $100 \cdot \mathrm{luby}(i)$ conflicts in the lab's solver. The Luby sequence takes the value $2^k$ for every $k$, so some run is allowed at least $(n+1)^{n+1}$ conflicts; by the measure slide, that run cannot reach its cutoff, because a run without restarts has fewer steps than that. It ends with an answer, and both answers are sound. A schedule with bounded cutoffs, such as "restart every 100 conflicts" combined with aggressive deletion, has neither argument, and termination is then not guaranteed.

Level 0 is never undone, even by a restart: the solver's restart is a cancel to level 0, and level-0 literals have no decision to undo. So the leading digit only ever falls, across the whole run, restarts included.

section 3

Proofs and limits

"Unsatisfiable" should come with evidence.

20 · proofs

DRAT: checkable unsatisfiability

A DRAT proof lists every learned clause (and every deletion) in order. A checker replays it: each lemma must be RUP, meaning that assigning its negation and unit-propagating over the clauses so far gives a conflict. It ends with the empty clause.

A first-UIP clause is always RUP: that's what analysis just showed.
RAT extends RUP to cover inprocessing techniques that add non-implied clauses (such as blocked clauses).
SAT competitions require verified proofs; drat-trim and the formally verified cake_lpr check them.

Lab then, proofs from your solver, checked by colib.drat (an independent RUP checker):

instance	lemmas	check
3-SAT n = 120, unsat	831	accepted, 0.2 s
pigeonhole 7 into 6	784	accepted, 0.2 s

The tests also check 30 proofs, with aggressive deletions included. A solver bug that learns a wrong clause fails the check, even if the final answer happens to be right.

20 · limits

CDCL is resolution, and pigeonhole defeats resolution

Pipatsrisawat & Darwiche 2011; Atserias, Fichte & Thurley 2011

CDCL with restarts polynomially simulates general resolution, and every CDCL run yields a resolution refutation of similar size. So a resolution lower bound is a CDCL lower bound.

Haken 1985

Every resolution refutation of the pigeonhole formula $\mathrm{PHP}^{n+1}_n$ has size $2^{\Omega(n)}$.

Why, in one line: any refutation must at some point hold a clause about a third of all the pigeons at once, and building clauses that wide one resolution at a time takes exponentially many steps. sketch in the notes (N)

Counting ("$n+1$ objects don't fit in $n$ places") can't be expressed compactly in clause-by-clause reasoning. Unit 18's alldifferent does it in one matching.

Lab then, conflicts:

pigeonhole	yours	MiniSat	CaDiCaL	Kissat s
7 into 6	784	2 498	1 044	0.004
9 into 8	41 364	39 063	31 719	0.13
10 into 9	—	510 308	267 023	0.50
11 into 10	—	10.7 M	2.2 M	3.2

Better engineering shifts the curve; it doesn't change its shape. Stronger proof systems (cutting planes, extended resolution) have short pigeonhole proofs, and pseudo-Boolean solvers exploit that.

explore interactively

section 4

Encodings

The same constraint, very different CNFs.

20 · encodings

Tseitin, at-most-one, cardinality

Tseitin (1968): name every subformula with a fresh variable. Linear size, equisatisfiable. Arbitrary circuits become CNF.
At most one of $n$: pairwise ($\binom n2$ clauses), sequential counter (Sinz 2005, $3n - 4$ clauses, $n - 1$ variables), bitwise ($n \lceil\log n\rceil$ clauses), commander, product.
At most $k$: sequential counters, sorting and cardinality networks (Asín et al. 2011), totalizers.

Arc consistency is the property that matters: does unit propagation on the encoding prune as much as the constraint would? Pairwise and the sequential counter both have it.

Lab then, n-queens with your solver (clauses / seconds):

n	pairwise	sequential	bitwise
40	103 520 / 0.33	18 292 / 3.82	35 584 / 0.88
60	352 880 / 0.97	41 832 / 20.9	83 604 / 10.5

The largest CNF is the fastest. Pairwise propagates in one step. The counter needs chains of auxiliary variables, which also distract the branching heuristic. Fewer clauses is not the objective; propagation strength and a branching-friendly variable set are.

20 · encodings · example

Two encodings, written out

Tseitin on a two-gate circuit

Circuit $o = (a \land b) \lor c$, asserted true. Name the gates $g = a \land b$ and $o = g \lor c$:

gate	clauses
$g \leftrightarrow a \land b$	$(\lnot g \lor a)$, $(\lnot g \lor b)$, $(g \lor \lnot a \lor \lnot b)$
$o \leftrightarrow g \lor c$	$(\lnot o \lor g \lor c)$, $(o \lor \lnot g)$, $(o \lor \lnot c)$
output	$(o)$

7 clauses. The circuit has 5 satisfying inputs $(a,b,c)$, and each extends to exactly one value of $g, o$: same count, so equisatisfiable, and models map back.

at most one of four, two ways

Pairwise, 6 clauses: $(\lnot x_1 \lor \lnot x_2)$, $(\lnot x_1 \lor \lnot x_3)$, $(\lnot x_1 \lor \lnot x_4)$, $(\lnot x_2 \lor \lnot x_3)$, $(\lnot x_2 \lor \lnot x_4)$, $(\lnot x_3 \lor \lnot x_4)$.

Sequential counter, 8 clauses and 3 new variables $s_1, s_2, s_3$ ("one of the first $i$ is true"): $(\lnot x_1 \lor s_1)$, $(\lnot x_2 \lor s_2)$, $(\lnot s_1 \lor s_2)$, $(\lnot x_2 \lor \lnot s_1)$, $(\lnot x_3 \lor s_3)$, $(\lnot s_2 \lor s_3)$, $(\lnot x_3 \lor \lnot s_2)$, $(\lnot x_4 \lor \lnot s_3)$.

Set $x_1$ true. Pairwise: one round gives $\lnot x_2, \lnot x_3, \lnot x_4$. Counter: $s_1$, then $\lnot x_2$ and $s_2$, then $\lnot x_3$ and $s_3$, then $\lnot x_4$. Same result, after a chain of six propagations.

Tseitin check. Brute force over all assignments of the seven clauses' variables gives 5 models in the variables that occur, one per satisfying input of the circuit; for example $a = b = 0$, $c = 1$ forces $g = 0$ (by $(\lnot g \lor a)$) and $o = 1$. The reference solver finds $c = o = 1$, everything else false. Only the "$\to$" half of each gate is needed for equisatisfiability (Plaisted–Greenbaum); both halves keep the model count equal.

AMO clauses are exactly what the reference amo_pairwise and amo_sequential return for literals 1–4, with auxiliaries numbered 6, 7, 8. For $n = 4$ the counter is not smaller (8 against 6); it wins from $n = 6$ on ($14$ against $15$), and by $n = 40$ it is $116$ clauses against $780$. The queens table on the previous slide shows what the longer propagation chains cost.

20 · lab

Lab 20 — what you build

about 3½ hours · uv run co lab 20

Assignment and two-watched-literal propagation.
First-UIP conflict analysis and backjumping with phase saving.
The CDCL loop: VSIDS, Luby restarts.
DRAT proofs and LBD-based deletion.
Encodings: three at-most-one, at-most-k, pigeonhole, queens, colouring.

uv run co test 20
uv run co then 20     # MiniSat, CaDiCaL, Kissat · pigeonhole · encodings · DRAT checks

20 · checkpoint

Done when

checkpoint

All five lab steps are ✓.
Your solver emits a DRAT proof that an external checker accepts, and you can explain pigeonhole's hardness in terms of resolution lower bounds rather than "it just takes a long time".
You can compute the first UIP of a small implication graph by hand.
You can say what falls on every step of a CDCL run, even a jump to level 0, and why restarts need an argument of their own.

Reading

Marques-Silva, Lynce & Malik, Handbook of Satisfiability, ch. 4.
Eén & Sörensson, "An extensible SAT-solver" (2003).
Audemard & Simon, IJCAI 2009 (LBD).
Haken, TCS 39 (1985); Buss's survey (2012).

21 lazy clause generation: CP propagators that explain themselves to this solver · 22 hardness and reductions.

SAT and the CDCL engine

The route

From DPLL to CDCL

CNF, resolution, and unit propagation

Watched literals, on four clauses

Learning

The implication graph and the first UIP

The learned clause, by resolution, and checked

The rest of the engine

Why CDCL stops, whatever it branches on

The measure, on the running example

Back to level 0, and restarts

Proofs and limits

DRAT: checkable unsatisfiability

CDCL is resolution, and pigeonhole defeats resolution

Encodings

Tseitin, at-most-one, cardinality

Two encodings, written out

Lab 20 — what you build

Done when

Reading

Next