Page 1

A New Clause Learning Scheme for Efficient Unsatisfiability Proofs

Knot Pipatsrisawat and Adnan Darwiche

Computer Science Department

University of California, Los Angeles

Los Angeles, CA 90095 USA

{thammakn,darwiche}@cs.ucla.edu

Abstract

We formalize in this paper a key property of asserting clauses

(the most common type of clauses learned by SAT solvers).

We show that the formalized property, which is called em-

powerment, is not exclusive to asserting clauses, and intro-

duceanewclassoflearnedclauseswhichcanalsobeempow-

ering. We show empirically that (1) the new class of clauses

tends to be much shorter and induce further backtracks than

asserting clauses and (2) an empowering subset of this new

class of clauses significantly improves the performance of the

Rsat solver on unsatisfiable problems.

Introduction

An important technique that underlies most modern SAT

solvers is conflict-clause learning (Marques-Silva and

Sakallah 1996). The algorithm for deriving conflict clauses

in these SAT solvers is based on using implication graphs to

derive a particular class of conflict clauses known as assert-

ing clauses (Marques-Silva and Sakallah 1996; Moskewicz

etal. 2001). Inthispaper, weformalizeanessentialproperty

of asserting clauses, which may also be satisfied by some

non-asserting clauses. We then define a new class of clauses

which is a relaxation of asserting clauses and show that they

tend to be shorter than asserting clauses and lead to much

further backtracks. Empirical results show that selectively

learning the new type of clauses significantly improves the

performance of Rsat, the winner of the industrial category of

the SAT’07 competition, on unsatisfiable problems.

We begin the next section by presenting a model of mod-

ern clause-learning SAT solvers, which we use as a basis for

our discussions in this paper. Then, we introduce a property

of conflict clauses, called empowerment. Next, we define

a new class of conflict clauses and present an efficient al-

gorithm for deriving them. Then, we discuss a special sub-

set of this new class which satisfies empowerment. Finally,

we present experimental results and end with conclusions.

Proofs of all propositions in this paper can be found in (Pi-

patsrisawat and Darwiche 2008).

A Model of Modern SAT Solvers

We begin with some basic notations and definitions. If ∆

and α are two Boolean formulas and ℓ is a literal, we write

Copyright c ? 2008, Association for the Advancement of Artificial

Intelligence (www.aaai.org). All rights reserved.

input : CNF formula ∆

output: A solution of ∆ or unsat if ∆ is not satisfiable

D ← ?? , Γ ← {}

while true do

if S = (∆,Γ,D) is 1–inconsistent then //Conflict

if D = ?? then return unsat

1

2

3

4

α ← an asserting clause for S

m ← the assertion level of α

D ← Dm// the first m decisions

Γ ← Γ ∧ α

5

6

7

8

else9

Choose a literal ℓ s.t. S ?⊢ ℓ and S ?⊢ ¬ℓ

if ℓ = null then return D // satisfiable

D ← D,ℓ

10

11

12

end13

end14

Algorithm 1: A pseudo-code of a SAT solver

∆ |= α to mean that ∆ entails α, and write ∆ ⊢ ℓ to mean

that literal ℓ can be derived from ∆ using unit resolution.

Furthermore, wemaytreataclauseasthesetofliteralsinthe

clause and a CNF formula as the set of clauses it contains.

Algorithm 1 is a pseudo-code of a clause-learning SAT

solver, which is based on making variable assignments,

called decisions. It starts with an empty decision sequence

D and an empty set of learned clauses Γ (Line 1). It then

iterates until it either proves the satisfiability or unsatisfia-

bility of the CNF ∆. In each iteration, the conjunction of ∆,

learned clauses Γ, and decisions D are checked for inconsis-

tency using unit resolution (Line 3). If unit resolution finds

an inconsistency, the algorithm does one of two things:

• If the decision sequence is empty, the CNF ∆ must be

unsatisfiable and the algorithm terminates (Line 4).

• If the decision sequence is not empty, an asserting clause

α is generated with an assertion level m. The algorithm

then erases all decisions made after level m, adds α to Γ,

and moves on to the next iteration (Lines 5-8).

If unit resolution detects no inconsistency, the algorithm

tries to find a literal ℓ whose value is not currently implied

or falsified by unit resolution, and adds it to the decision se-

quence (Line 12). If no such literal is found, the algorithms

terminates having proven satisfiability (Line 11). We will

now provide the missing definitions.

Proceedings of the Twenty-Third AAAI Conference on Artificial Intelligence (2008)

1481

Page 2

• A decision sequence is an ordered set of literals D =

?ℓ1,...,ℓn?. Each literal ℓkis called the decision at level

k. We write Dmto denote the subsequence ?ℓ1,...,ℓm?.

When appropriate, we will treat a decision sequence as

the conjunction or the set of all literals in the sequence.

• A SAT state is a tuple (∆,Γ,D), where ∆ and Γ are CNFs

such that ∆ |= Γ, and D is a decision sequence. We will

write Skto denote the state (∆,Γ,Dk).

• (∆,Γ,D) is 1–inconsistent iff ∆ ∧ Γ ∧ D ⊢ false.

• A literal ℓ is implied by state S = (∆,Γ,D) at level n,

written S ⊢n ℓ, iff n is the smallest integer for which

∆ ∧ Γ ∧ Dn ⊢ ℓ. We say that the implication level of

literals ℓ,¬ℓ is n in this case, write S ⊢ ℓ to mean S ⊢kℓ

for some k, and write S ?⊢ ℓ to mean S ?⊢kℓ for all k.

• S = (∆,Γ,?ℓ1,...,ℓn?) is normal iff for 1 ≤ k ≤ n,

Sk−1is not 1–inconsistent, Sk−1?⊢ ℓkand Sk−1?⊢ ¬ℓk.

The notion of normal states prohibits SAT solvers from

making a decision in the presence of a conflict. The state S

on Line 3 of Algorithm 1 is always normal. Therefore, from

now on, we will assume that every SAT state is normal.

We are now ready to define the remaining notions used in

Algorithm 1. An asserting clause is a special type of conflict

clause that satisfies some strong conditions, so we start first

by defining the weaker notion of a conflict clause. Our defi-

nition of conflict clause closely follows the graphical defini-

tion in (Zhang et al. 2001).

Definition 1 (Conflict Clause) Let S = (∆,Γ,D) be a

SAT state. A clause α = ℓ1∨ ... ∨ ℓmis a conflict clause

for state S iff:

1. ∆ ∧ Γ ∧ ¬α ⊢ false. That is, α is implied by ∆ ∧ Γ and

this can be proven using unit resolution.

2. For each ℓi, S ⊢ ¬ℓi. That is, the literals ¬ℓiare a subset

of the implications derived by unit resolution in state S.

Every conflict clause must contain at least one literal

that is falsified in the last level. Otherwise, the SAT state

would not be normal, because the previous state must be

1–inconsistent. In practice, however, modern SAT solvers

insist on learning conflict clauses that contain exactly one

literal falsified in the last level.

Definition 2 (Asserting Clause) A conflict clause α of a

SAT state S = (∆,Γ,D) is an asserting clause iff it has

exactly one literal ℓ with implication level |D|. The lit-

eral ℓ is called the asserted literal of α.

assertion level of clause α is defined as the highest implica-

tion level k < |D| attained by some literal in α. If |α| = 1,

the assertion level is defined to be zero.

Moreover, the

An asserting clause is guaranteed to become unit once the

solver backtracks to the assertion level. Moreover, an assert-

ing clause can always be derived for a 1–inconsistent SAT

state that has at least one decision.

Proposition 1 A SAT state S = (∆,Γ,D) with |D| > 0 is

1–inconsistent iff it has an asserting clause.

The completeness of Algorithm 1 can be shown by real-

izing that asserting clauses learned by the algorithm never

repeat (otherwise, the conflict would have been prevented).

Since every conflict comes with an asserting clause (Propo-

sition 1) and there are only finitely many clauses, the algo-

rithm can only experience a finite number of conflicts. It

cannot keep making decisions indefinitely either and, there-

fore, has to terminate. This proof will be referred to again

when we introduce a new class of conflict clauses.

Empowerment

In this section, we introduce a new property, which is satis-

fied by all asserting clauses.

Definition 3 (1–Empowerment) Let α ⇒ ℓ be a clause

where ℓ is a literal and α is a conjunction of literals. The

clause is 1–empowering with respect to CNF ∆ via ℓ iff

1. ∆ |= (α ⇒ ℓ): the clause is implied by ∆.

2. ∆ ∧ α ?⊢ ℓ: the literal ℓ cannot be derived from ∆ ∧ α

using unit resolution.

We will also say in this case that ℓ is the empowering lit-

eral of clause α ⇒ ℓ. Moreover, we will say that a clause

is 1–empowering with respect to state (∆,Γ,D) iff it is 1–

empowering with respect to ∆ ∧ Γ. Intuitively, a clause is

1–empowering with respect to a CNF ∆ iff (1) it is logi-

cally implied by the CNF and (2) adding it to the CNF al-

lows unit resolution to derive a new implication that could

not be derived without the clause. Consider the CNF ∆ =

(a ∨ b) ∧ (¬a ∨ c) ∧ (b ∨ ¬c ∨ d) for an example, and the

clause (b ∨ d) which is implied by the CNF. Adding ¬d to

∆ does not allow unit resolution to derive b even though b

is implied by ∆ ∧ ¬d. Yet, this derivation becomes possible

once we add the clause (b∨d) to ∆. Hence, the clause is 1–

empowering with respect to ∆ via literal b. Note, however,

that the clause (b ∨ c) is not 1–empowering with respect to

the same CNF, because ∆ ∧ ¬b ⊢ c and ∆ ∧ ¬c ⊢ b.

This means that adding a conflict clause that is not 1–

empowering to the knowledge base will not lead to any new

implication. Note that if a clause is not 1–empowering with

respect to a knowledge base, adding more clauses to the

knowledge base will not make it so.

Proposition 2 All asserting clauses of a SAT state S are 1–

empowering with respect to S and the asserted literals are

their empowering literals.

Given this result, the learning component of Algorithm 1

can be viewed as one that tries to empower unit resolution so

that it becomes more complete. In particular, each time unit

resolution discovers a contradiction, it does so under a par-

ticular decision sequence. When this sequence is not empty,

it means that unit resolution has missed an implication due

to its incompleteness.By adding the empowering clause,

we are effectively allowing unit resolution to discover this

implication at an earlier stage, using only part of the cur-

rent decision sequence.1Therefore, the shorter the empow-

ering clause is, the better it is in making unit resolution more

complete. Moreover, an empowering clause with a smaller

assertion level will allow unit resolution to derive the missed

1In (del Val 1994), a similar analysis on the completeness of

unit resolution is given in the context of knowledge compilation.

1482

Page 3

a

b

c

d

e

(¬a b)

v

(¬a ¬b c)

v

(¬c e)

(¬b ¬c d)

v

v

v

v

C =

4

C =

3

C =

2

C =

1

Figure 1: An implication graph. Each node is labeled with an

implication and its reason.

implication under a smaller subset of the current decision se-

quence.

A New Class of Conflict Clauses

In this section, we introduce a new class of clauses, which is

a relaxation of asserting clauses. This class of clauses may

satisfy the empowerment property as well. Later, we argue

and show empirically that an empowering subset of this new

class could improve the performance of SAT solvers.

Definition 4 (Bi-Asserting Clause) A conflict clause β of a

SAT state (∆,Γ,D) is a bi-asserting clause if it has exactly

two literals with implication level |D|. The assertion level

of β is defined as the second highest implication level of its

literal. If |β| = 2, its assertion level is defined to be zero.

We will show in a later section that a class of bi-asserting

clauses tends to be much shorter and have smaller assertion

levels than asserting clauses for the same conflict. Deriv-

ing a bi-asserting clause is similar to deriving a normal as-

serting clause. The standard algorithm performs a series

of resolutions to derive an asserting clause (see (E´ en and

S¨ orensson 2003; Ryan 2004)). We will refer to it as Al-

gorithm 2 in our discussion. We describe this algorithm

through the following example. Let ∆ be the conjunction

of C1= (¬a ∨ b),C2= (¬a ∨ ¬b ∨ c),C3= (¬b ∨ ¬c ∨

d),C4= (¬c∨e),C5= (¬d∨¬e). Now, consider the state

S = (∆,true,?a?). From this state, unit resolution will de-

rive some implications before discovering a conflict. The

derivations of implications are visualized in Figure 1. An

edge X → Y in this graph indicates that X’s literal directly

contributes to the implication of Y ’s. A reason of an im-

plication is the clause in which the literal becomes unit. In

this case, assume that the implications b,c,d,e are discov-

ered in this order and that C5is found to be empty (all of its

literals have been falsified). The following trace shows how

Algorithm 2 derives an asserting clause from this example.

Step Clause

1

(¬d ∨ ¬e)

2

(¬c ∨ e)

3

(¬c ∨ ¬d)

4

(¬b ∨ ¬c ∨ d)

5

(¬b ∨ ¬c)

6

(¬a ∨ ¬b ∨ c)

7

(¬a ∨ ¬b)

8

(¬a ∨ b)

9

(¬a)

The algorithm starts by initializing the conflict clause to

be the empty clause (Step 1). Then, it picks a literal in the

clause whose negation was implied last (e in this case). The

algorithm resolves the reason of this literal (Step 2) with the

conflictclauseandreplacestheconflictclausewiththeresol-

vent, (¬c ∨ ¬d) (Step 3). Next, since, in the current conflict

Explanation

C5: the empty clause

C4: the reason of e

resolving 1 & 2 on e

C3: the reason of d

resolving 3 & 4 on d

C2: the reason of c

resolving 5 & 6 on c

C1: the reason of b

resolving 7 & 8 on b

clause, the negation of ¬d was implied last, the algorithm

resolves its reason (Step 4) with the conflict clause and pro-

duces (¬b ∨ ¬c) (Step 5). This process is repeated until the

conflict clause becomes asserting (Step 9). We refer to the

clauses in Steps 3,5,7 as intermediate conflict clauses.

This algorithm can be modified to derive bi-asserting

clauses without any added complexity. We only need to

detect when the intermediate conflict clause contains two

(instead of one) literals falsified at the conflict level. Note,

however, that not every bi-asserting clause is 1–empowering

and the algorithm described above, does not guarantee to

produce 1–empowering bi-asserting clauses. For example,

the bi-asserting clause (¬c ∨ ¬d) is not 1–empowering for

the above example, while (¬b∨¬c) is. This suggests that bi-

asserting clauses should be learned with care to avoid adding

clauses that will not contribute any new implication.

Learning 1–Empowering Bi-Asserting Clauses

In this section, we address the issue of learning 1–

empowering bi-asserting clauses.

whether the clause α ⇒ ℓ is empowering with respect to

CNF ∆ via literal ℓ can be done by checking if ∆∧¬α ⊢ ℓ.

The time complexity of this test is linear in the size of the

knowledge base. In practice, however, this test would in-

cur too much overhead. Hence, we will next present an ef-

ficient algorithm that detects the empowerment of the de-

rived bi-asserting clause, but only with respect to the clauses

used in its derivation. Even though the derived bi-asserting

clauses are not guaranteed to be 1–empowering with respect

to other clauses in the knowledge base, we will show in the

next section that they tend to in the majority of cases. Our

approach for generating empowering bi-asserting clauses is

based on the notions of merge resolutions. Defined in (An-

drews 1968), a resolution between clauses C1and C2is a

merge resolution iff C1and C2share a literal (C1∩C2?= ∅).

Proposition 3 An intermediate conflict clause of Algorithm

2 is 1–empowering with respect to the clauses used in its

derivation if at least a step in the derivation is a merge res-

olution.

In general, checking

Based on this result, all we need to ensure that the conflict

clause is 1–empowering is the existence of a single merge

resolution step in the resolution derivation of the clause.

This additional check incurs very little overhead.

We close this section by noting that integrating bi-

asserting clauses into Algorithm 1 still maintains the com-

pleteness of the algorithm given that a standard unit prop-

agation algorithm is used (Ryan 2004). This is due to the

result in (Ryan 2004), which states that every intermediate

conflict clause in the derivation must not already appear in

the knowledge base at the time of the derivation. As a result,

our completeness proof presented earlier still holds.

Experimental Results

We modified Rsat (Pipatsrisawat and Darwiche 2007), the

winner of the SAT’07 competition (industrial category), to

detect any occurrence of 1–empowering bi-asserting clauses

(with respect to the clauses in the derivation) during con-

flict clause derivation. If found, the bi-asserting clause is

1483

Page 4

FamilyTotal# solved SAT

Rsat+

# solved UNSAT

Rsat+Rsat Rsat++RsatRsat++

difp

dlx iq unsat 1

grieu 2005

engine

fpga

fvp sat 3

fvp unsat 1,2

IBM

liveness sat 1

liveness unsat 1,2

narain 2005

npe

pipe ooo

pipe sat 1

pipe unsat 1.0,1.1

SAT-Race

SAT Comp. 07

vliw sat 2

vliw unsat 2,3,4

29

32

32

10

21

20

26

274

10

21

10

29

1

20

0

11

20

1

107

28

0

18

0

11

20

1

104

28

2

19

0

11

20

1

105

000

10

0

7

3

0

25

164

16

0

7

1

0

25

165

16

0

7

4

0

25

165

5

0

6

3

0

9

0

7

0

6

3

0

6

0

6

3

0

0

7

2

1

0

7

2

1

0

7

2

16

29

10

27

200

173

12

0

14

101

56

14

0

20

110

59

16

1010

0

66

50

9

0

0

019

110

60

68

49

9

0

64

48

9

0

90

0

0

6

0

610

Total949338329336402433438

Table 1: Performance of Rsat with different learning schemes.

learned instead of the asserting clause otherwise learned.

We considered Rsat with the following learning schemes:

(i) learn only asserting clauses (normal Rsat) (ii) learn 1–

empowering bi-asserting clause when possible (Rsat+) (iii)

learns 1–empowering bi-asserting clause only when its as-

sertion level is at least 2 levels smaller than that of the as-

serting clause (Rsat++).

Althoughempowermentisonlywithrespecttotheclauses

used in the derivation, in practice, it usually results in em-

powerment with respect to the whole formula. We found

that, on 95% of the problems, over 80% of the bi-asserting

clauses derived are 1–empowering with respect to the whole

formula at the time of learning.

We experimented with 949 SAT problems from previous

SAT/SAT-Race competitions and contemporary libraries.2

Each solver is given 1,800 seconds per problem on a 3.8GHz

machine with 3GB of RAM. Table 1 reports the number of

problems solved by different versions. According to this

table, Rsat+ and Rsat++ perform considerably better than

Rsat. For satisfiable problems, Rsat+ tends to be worse than

the others, whereas Rsat and Rsat++ have comparable per-

formances. For unsatisfiable problems, however, Rsat++

and Rsat+ solve 36 and 31 more problems than Rsat, re-

spectively. Moreover, the new learning scheme decreases

the running time on unsatisfiable problems by 34% (71,246

s for Rsat and 47,400 s for Rsat++). Overall, Rsat++ used

only 99,209 seconds, while Rsat used 114,600 seconds.3

We have also evaluated the version of Rsat that learns bi-

asserting clauses regardless of their empowerment. This ver-

sion of Rsat solved only 647 problems (normal Rsat solved

740 problems). This is because these bi-asserting clauses are

not necessarily capable of generating any new implications.

So, in the long run, they only contribute to the overhead of

unit propagation no matter how short they are.

We also measured the sizes of different conflict clauses

derived by Rsat++ and found that, on average, the size of a

2http://www.satcompetition.org/2007,http://fmv.jku.at/sat-

race-2006/, http://www.research.ibm.com/haifa/projects/verification

/RB Homepage/fvbenchmarks.html, http://www.miroslav-velev.co

m/sat benchmarks.html

3OnlyproblemssolvedbybothRsatandRsat++areconsidered.

bi-asserting clause is slightly less than half the size of an as-

serting clause. Moreover, on average, the backtrack induced

by a bi-asserting clause is about 5-6 times longer than the

one induced by an asserting clause.

Related Work and Conclusions

Learning non-asserting clauses have been previously pro-

posed by (Ryan 2004) and (Dershowitz, Hanna, and Nadel

2007). In both work, non-asserting clauses are learned in

addition to asserting clauses (i.e. the solvers may add two

clauses per conflict). Moreover, additional clauses learned

in both cases may not be empowering nor bi-asserting.

In conclusion, we formalized a key property of assert-

ing clauses called empowerment and presented a new class

of conflict clauses called bi-asserting clauses. Our experi-

ments showed that, by selectively learning empowering bi-

asserting clauses, Rsat produces shorter conflict clauses,

performs longer backtracks, and performs better on unsat-

isfiable problems.

Acknowledgments

This work has been partially supported by Air Force grant

#FA9550-05-1-0075 and by NSF grant #IIS-0713166.

References

Andrews, P. B. 1968. Resolution with merging. J. ACM

15(3):367–381.

del Val, A. 1994. Tractable databases: How to make propo-

sitional unit resolution complete through compilation. In

Proceedings of KR-94, pp. 551-561.

Dershowitz, N.; Hanna, Z.; and Nadel, A. 2007. Towards

a better understanding of the functionality of a conflict-

driven sat solver. In SAT, 287–293.

E´ en, N., and S¨ orensson, N. 2003. An extensible sat-solver.

In Proceedings of SAT 2003.

Marques-Silva, J. P., and Sakallah, K. A. 1996. GRASP -

A New Search Algorithm for Satisfiability. In Proceedings

of IEEE/ACM Intl. Conf. on CAD, 220–227.

Moskewicz, M.; Madigan, C.; Zhao, Y.; Zhang, L.; and

Malik, S. 2001. Chaff: Engineering an efficient sat solver.

In Proceedings of DAC’01, June 2001.

Pipatsrisawat, K., and Darwiche, A. 2007. Rsat 2.0: Sat

solver description. Technical Report D–153, Automated

Reasoning Group, Comp. Sci. Department, UCLA.

Pipatsrisawat, K., and Darwiche, A. 2008. A new clause

learning scheme for efficient unsatisfiability proofs. Tech-

nical Report D–156, Automated Reasoning Group, Comp.

Sci. Department, UCLA.

Ryan, L. 2004. Efficient Algorithms for Clause-Learning

SAT Solvers. Master’s thesis, Simon Fraser University.

Zhang, L.; Madigan, C. F.; Moskewicz, M. W.; and Ma-

lik, S. 2001. Efficient conflict driven learning in boolean

satisfiability solver. In ICCAD-01, 279–285.

1484