Structure and Generation
of Splitting Rules for SAT
Master Thesis
Yves Brise
Swiss Federal Institute of Technology Zurich
Institute of Theoretical Computer Science
Professor: Emo Welzl
Advisor: Philipp Zumstein
October 2, 2006
“The branch points, however, increase exponentially with
time. Were it not for the fact that, as soon as a particular
branch is taken, there is an extinction of a vast array of
others in its future, all would soon become unmanageable.
Of course, in dealing with the future, we must be careful
what extinctions we rely upon.”
Quindor Shandess, First Speaker of the Second Foundation,
about the Seldon Plan.
From “Foundation’s Edge”, novel by Isaac Asimov.
That telescope was christened the Star-splitter,
Because it didn’t do a thing but split
A star in two or three the way you split
A globule of quicksilver in your hand
With one stroke of your finger in the middle.
It’s a star-splitter if there ever was one
And ought to do some good if splitting stars
’Sa thing to be compared with splitting wood.
From “The Star-Splitter”, poem by Robert Frost.
Contents
0.1
Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 Introduction
1.1 The satisfiability problem
1.2 The use of splittings . . .
1.3 Discussion of related work
1.4 The results of this thesis .
1.5 Outline of this thesis . . .
2 Basic Definitions
2.1 Boolean logic . . .
2.2 Splitting algorithm
2.3 Graphs . . . . . . .
2.4 Search trees . . . .
2.5 Splitting numbers .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Simplification Rules
3.1 Subsumption rule . . . .
3.2 Pure literal rule . . . . .
3.3 Unit clause rule . . . . .
3.4 Autark assignment rule .
3.5 Input resolution . . . . .
3.6 Davis-Putnam resolution
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
.
.
.
.
.
9
9
10
10
11
12
.
.
.
.
.
13
13
20
26
28
36
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
41
41
43
44
45
47
50
4 Splitting Rules
4.1 Splitting on a variable . . . . . . . . .
4.2 Splitting on a clause . . . . . . . . . .
4.3 Splitting by the conflict graph . . . . .
4.4 Splitting by almost satisfiable formulae
4.5 Splitting by majority sets . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
53
56
57
59
62
65
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
CONTENTS
5 Algorithm by Monien & Speckenmeyer
75
5.1 The prerequisites . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2 The implementation . . . . . . . . . . . . . . . . . . . . . . . 78
5.3 The analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6 The
6.1
6.2
6.3
6.4
3-SAT Algorithm by Zhang
General description . . . . . . .
Main procedures . . . . . . . .
Treatment of autarky . . . . . .
Running time . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
85
85
87
92
99
7 Conclusion
103
List of Figures
105
List of Algorithms
107
Bibliography
109
0.1
Notation
˙ \
∪, ∩, ∪,
∈, ⊆, ⊂
|M |, M × N
∅, , {}
⊤, ⊥, ⊤
⊥
¬, ∧, ∨
→, 7→
a ← b;
⇒, ⇔
N, N0 , Q
R, R0 , R+
max {·} , min {·}
x, y, z
l, u, v, w
l, u, v, w
n, m, ℓ
C = {u1 , . . . , uk }
F = {C1 , . . . , Cm }
vbl(F ), vbl(C)
lit(V )
SAT
F ≡ G, F ≡ G
C ∨ u, F ∧ C
α = (a1 , . . . , ai )
(α, u)
F [α]
F hu := Ci
C1 • C2
F ⊢C
S = {F1 , . . . , Fs }
µ(F )
τ (~t )
tA (·)
TA (·)
O(·)
O∗ (·)
∝
Ĉ, F̂
CĈ , FF̂
⊡
Set union, intersection, disjoint union, and difference.
Set membership, subset relation, proper subset.
Cardinality of set M , cross product of set M and N .
The empty set, empty clause, empty formula.
Boolean truth values true, false, and undefined.
Boolean operators not, and, and or.
Function domain/range definition, function map to.
The value of b is assigned to a (pseudo-code).
Implication and equivalence.
Natural numbers, without or with zero, rational numbers.
Real numbers, without or with zero, positive real numbers.
Maximum/minimum of a set of numbers.
Variables in a Boolean formula.
Literals in a Boolean formula.
Negated literals.
Number of variables, clauses, and literals respectively.
Clause C, represented as a set of k literals.
CNF-formula F , represented as a set of m clauses.
The set of variables of F and C.
The set of literals from a set V of variables.
Equivalence, satisfiability-equivalence of formulae.
Adding literal u to C, adding clause C to F .
Assignment on i variables, sequence of literals.
Adding literal u to the assignment α.
Assignment α applied to formula F .
Replacement of literal u in F by all literals in C.
Resolvent of two clauses.
Clause C can be inferred from F .
Splitting S into s subproblems.
Measure for the formula F (e.g. n, m, or ℓ).
Splitting number τ (·), of the splitting tuple ~t.
Running time of algorithm A.
Search tree of splitting algorithm A.
Big O notation.
Big O notation, polynomial factors suppressed.
Symbol for undefined literals or clauses in open formulae.
Open clause, open formula.
Class of clauses, class of formulae.
End of a proof.
End of a definition, theorem, lemma, or corollary.
End of a remark or an example.
Chapter 1
Introduction
1.1
The satisfiability problem
The Boolean satisfiability problem (SAT) is the question, whether a given
formula of Boolean logic (see [4] by George Boole) has an assignment to its
variables that makes the whole formula true. In 1971 Stephen Cook proved
in [7] that SAT is NP-complete, making it the “first” NP-complete problem.
Since there are infinitely many problems in NP, it is not an easy task to
show the previous claim. One has to rely on the concept of Turing machines
and reducibility, and show a way how to construct a Boolean formula that
simulates the computation of any non-deterministic Turing machine on its
input. To emphasise how important this finding was, we merely point out
that showing the NP-completeness of any other problem is usually done by
showing that there is a polynomial-time reduction from SAT to that problem.
For the theory of NP-completeness and computability theory in general there
are two excellent text books available by Sipser (see [40]), and by Garey and
Johnson (see [17]).
There are quite a few variations of the SAT problem around, so we just
mention them quickly that the reader gets an idea of the field. Typically,
SAT is restricted to deciding the satisfiability of Boolean formula that are in
conjunctive normal form. That means formulae consist of the conjunction of
clauses, which in turn are disjunctions of literals. Now, k-SAT is the problem
of deciding the satisfiability of a Boolean formula in which the length of
clauses is not allowed to exceed the integer number k. Then, there is the
MAXSAT problem which asks for the maximum number of clauses that can
be satisfied in a formula. Similar as before, MAX-k-SAT asks for the maximal
number of clauses that can be satisfied in a formula in which the length of
9
10
CHAPTER 1. INTRODUCTION
the clauses is not allowed to exceed k. Another variation of MAXSAT is
(n, i)-MAXSAT, which is just as MAXSAT, but for formulae on n variables
in which the number of occurrences of a variable is limited to the integer i.
Finally, there is a variation called Exact-SAT, which is the decision problem
whether a formula has a satisfying assignment that satisfies exactly one literal
in each clause.
1.2
The use of splittings
Splittings are a Divide & Conquer technique that “splits” a formula in several formulae and recursively searches for a satisfying assignment in these
subproblems. They have been introduced into the field of satisfiability by
the work of Davis, Putnam, Logemann, and Loveland, after whom the most
general splitting algorithm is usually called DPLL algorithm. The use of
splittings for SAT essentially goes back to [11] and [10].
There are several papers that are concerned with the application of splittings
to the different variations of the SAT problem. Some of them we include here,
in chronological order they are: [31], [36], [42], [19], [2], [30], [20], [18], [14],
[13], [6], [27], [26].
Examples of splittings in the field of graph algorithms are given in [3], [12],
and [15].
1.3
Discussion of related work
There are several surveys that give an overview in the fields of SAT algorithms
and of exponential time algorithms in general. They are a good starting point
for those who are familiar with the basic ideas and want to get a deeper
insight. In [41] there is a overview of several NP-complete problems and
their currently best known solutions. For general ideas about the analysis
of exponential time algorithms [16] can be mentioned. Two surveys that are
much more SAT related as the previous are [9] and [39].
Another approach for solving SAT that is based on the encoding of satisfying
assignments can be found in [32] (reprinted in [33]). It is a probabilistic
algorithm, and the currently best known for k-SAT, k ≥ 4. Also, [25] utilises
the results of that paper.
1.4. THE RESULTS OF THIS THESIS
11
Yet another approach for solving SAT is a method that is called “local
search”. The idea is to start with a initial assignment, that may not satisfy the formula of course, and to change that assignment according to some
heuristics in order to find a satisfying assignment. The difference to splittings is that in local search we do not actually modify the formula, but only
the assignment under scrutiny. Papers that are concerned with local search
algorithms are, in chronological order: [37], [21], [38], [8], [23], [22], [5], [24],
[25].
Since proving an exponential lower bound for the most general framework
of SAT algorithms would prove P =
6 NP, there has been some interest in
proving lower bounds for certain input formulae. Interesting results in that
direction can be found in [34] and [1]. Among other things, there are also
discussions about lower bounds in [21] and [16].
1.4
The results of this thesis
The main result of this thesis is a general framework for splitting algorithms
(see Chapter 2). We formulate the structure of an arbitrary algorithm that
uses splittings, and we derive the tools to analyse its running time. We show
how this framework can be applied to two known algorithms in Chapter 5
and Chapter 6.
In Chapter 4 there we introduce some methods for obtaining particularly
good splittings. The first of these methods is based on the conflict graph of
a Boolean formula. We give a good splitting in case this conflict graph is a
tree (or pseudo-tree). The second idea is based on almost satisfiable formulae
and also on the conflict graph. If we find a subset of a formula that we can
supplement to be an almost satisfiable formula, then we get a good splitting.
Finally, the third idea is based on a special set of assignments, called the
majority set, with respect to some subset of the variables of a formula. We
show that such a majority set can be used to automatically find splittings.
At the end of Section 2.5 there is a sketch for a proof of the fact that we
can efficiently compare different splittings during the execution of a splitting
algorithm.
Several proofs of results from related work have been worked out independently, supplemented, or corrected. These are Lemma 2.29, Lemma 2.31,
Lemma 3.9, Lemma 4.16, Theorem 4.17, Lemma 6.10, Corollary 6.11, and
Lemma 6.12.
12
1.5
CHAPTER 1. INTRODUCTION
Outline of this thesis
In Chapter 2 we are going to introduce the general framework for our splitting algorithms, and also for the analysis of those. In Chapter 3 we are
looking at some techniques to simplify a Boolean formula before making a
splitting. In Chapter 4 we discuss some known splittings, and also how it is
possible to generate good splittings automatically. Chapter 5 and 6 discuss
the application of our framework to known SAT algorithms. Finally, Chapter
7 concludes this thesis.
Chapter 2
Basic Definitions
2.1
Boolean logic
This section is named after George Boole, who has laid the foundations of
what we call today Boolean logic, not least with his book [4] dating from
1854. We will assume that the reader is somewhat familiar with Boolean
logic, e.g. we assume that the truth table for the logic operations such as
and, or, and negation are clear. The two truth values we use shall be ⊤ for
true and ⊥ for false.
Definition 2.1. The basic building block of a Boolean formula is a set V of
variables. Mostly we use the letters x, y, z to represent the variables, probably
with some subscripts, e.g. V = {x1 , . . . , xn }. The variables V are also called
Boolean variables.
Boolean variables can be negated, which will be denoted by x for a variable
x. A single negated or non-negated variable makes up an atomic formula of
Boolean logic.
Composite formulae are obtained by combining atomic and other composite formulae with several logic operators, such as ∧ ( and), ∨ ( or), and ¬
( negation). To clarify the operator precedence certain formulae have to be
put in parentheses, e.g. ¬(x ∧ y). The operator ¬ takes precedence over ∧,
and both of these take precedence over ∨. We state without proof that with
these operators we can actually construct all the Boolean formulae.
Let F be a formula, then vbl(F ) is the set of variables occurring in F .
13
14
CHAPTER 2. BASIC DEFINITIONS
Example 2.1.1.
F = ¬(x ∨ y) ∧ z
is a Boolean formula, and vbl(F ) = {x, y, z}.
⊡
Definition 2.2. Let V = {x1 , . . . , xn } be a set of n Boolean variables. We
˙ , where V = {x1 , . . . , xn }
define a literal l to be an element of lit(V ) := V ∪V
is the set of negated variables. Usually, we will use the letters l, u, v, w to
represent literals. Literals u ∈ V are called positive literals, and literals
u ∈ V are called negative.
A variable x can occur several times in a formula, either as positive literal
x, negative literal x, or both. The positive literal x and the negative literal x
are called complementary.
Definition 2.3. A clause C = {u1 , . . . , uk } is defined to be a set of literals, which is interpreted as the disjunction of the literals, i.e. the formula
u1 ∨ · · · ∨ uk . If C contains two complementary literals, then it is always true.
The empty clause is denoted as and evaluates to ⊥ by definition.
Two clauses C and C ′ are called independent if they are variable-disjoint,
i.e. vbl(C) ∩ vbl(C ′ ) = ∅. If, on the other hand, the clauses contain a
complementary pair of literals (i.e. u ∈ C and u ∈ C ′ ), then C and C ′ are
called conflicting.
We can manipulate the clause C with the usual set operations, but we will
also use a special notation,
C ∨ u,
for adding a literal to the clause, i.e. C ∪ {u}.
Definition 2.4. A Boolean formula F in conjunctive normal form, or CNFformula for short, is defined as a set of clauses, which is interpreted as a
conjunction of those clauses.
For example, the CNF-formula F = {C1 , . . . , Cm } in set representation corresponds to the Boolean formula C1 ∧ · · · ∧ Cm .
The empty CNF-formula is denoted as {} and evaluates to ⊤ per definition.
If, on the other hand, a CNF-formula contains the empty clause ( ∈ F ),
then it always evaluates to ⊥.
We can manipulate a CNF-formula with the usual set operations, but we will
also use the notation,
F ∧ C,
to denote F ∪ {C}.
15
2.1. BOOLEAN LOGIC
Remark 2.1.1. Note that duplicate literals in clauses, and duplicate clauses
in CNF-formulae are ruled out by the set representation. Removing a duplicate item will not change the satisfiability of the clause or formula, so we do
not have to bother about that for most of our purposes.
However, the removal possibly changes the number of satisfiable clauses in a
formula. When defining the notion autark (see Definition 3.4) we will give
this point some consideration.
⊡
Definition 2.5. For k ∈ N, a k-CNF formula F is a CNF-formula in which
no clause has more than k literals. Note that shorter clauses are allowed by
this definition.
Definition 2.6. Let V be a set of variables. An assignment α is defined as
a mapping, α : V −→ {⊤, ⊥}, from V to the set of Boolean truth values. For
example, for V = {x1 , . . . , xn }, we can write the following,
α = (x1 7→ ⊤, x2 7→ ⊥, . . . , xn 7→ ⊥),
for a specific assignment. Note that α does not necessarily map all the variables of a formula F to a truth value. It may be a partial assignment with
respect to the formula F .
The length of an assignment |α| is defined as the number of variables mapped
by it, i.e. |V |.
Instead of explicitly writing down the mapping, we will use the more convenient way of representing an assignment by the sequence of literals which are
mapped to ⊤,
α = (x1 , x2 , . . . , xn ),
which corresponds to the same assignment as above. Positive literals map
the corresponding variable to ⊤, and negative literals map the variable to ⊥.
Complementary literals are not allowed in assignments.
16
CHAPTER 2. BASIC DEFINITIONS
Definition 2.7. The formula F can be restricted by an assignment α, or,
in other words, α can be applied to F . In the process of which all literals u
occurring in F that are mapped by α are replaced by ⊤ or ⊥ respectively. We
write,
F [α] = F [x1 , x2 ,..., xn ] = F [x1 7→⊤, x2 7→⊥,..., xn 7→⊥] .
The following replacement rules apply to an arbitrary formula D,
⊥ ∨ D ≡ D, ⊥ ∧ D ≡ ⊥,
⊤ ∨ D ≡ ⊤, ⊤ ∧ D ≡ D.
Since clauses and literals are formulae too, we use the same notation and
write,
u[α] , C [α] ,
for applying α to u or C.
Sometimes, in a formula F , we want to map all the literals that occur in a
certain clause C to ⊤ (or to ⊥). For that we write,
F [C] (or F [C] ).
For two assignments α1 and α2 that do not contain a complementary pair of
literals we use the following notations.
(i) α1 ∪ α2 := (x | x ∈ α1 or x ∈ α2 )
(ii) α1 \α2 := (x | x ∈ α1 and x 6∈ α2 )
(iii) α1 ⊆ α2 if ∀x ∈ α1 : x ∈ α2
Note that (F [α1 ] )[α2 ] ≡ (F [α2 ] )[α1 ] .
Definition 2.8. An instance of SAT is the decision problem whether a given
formula F has an assignment to its variables such that it evaluates to ⊤. If
so, F is called satisfiable, but unsatisfiable otherwise.
The problem k-SAT is the same as SAT, but restricted to k-CNF formulae.
Theorem 2.9 (Cook, [7]). SAT is NP-complete.
Proof. We do not include the proof of that theorem here, but refer to the
original paper. For an alternative proof see Sipser [40], in the section about
NP-completeness.
17
2.1. BOOLEAN LOGIC
Definition 2.10 (Measuring formulae).
Let F be a CNF-formula on the set of variables V . We use several standard
measures that are defined in the following.
We denote the number of variables of a formula as n, i.e.
n(F ) := |V | = |vbl(F )|.
The number of clauses m is defined as
m(F ) := |F |.
The length of the formula is denoted by ℓ, which is defined as
ℓ(F ) :=
X
C∈F
|C|,
where C is a clause of F .
We use k to indicate the length of the longest clause in F , i.e.
k(F ) := max |C|.
C∈F
Remark 2.1.2. To clarify what happens if we are dealing with an empty
clause, note the following.
If ∈ F then the number of variables is not affected by that,
n(F ) = n(F \ {}).
We do count the empty clause in the number of clauses. So,
m(F ) = m(F \ {}) + 1,
but the length of the empty clause is 0. Therefore,
ℓ(F ) = ℓ(F \ {}).
⊡
18
CHAPTER 2. BASIC DEFINITIONS
Theorem 2.11. For every Boolean formula F we can generate a 3-CNF
formula F ′ in O( poly(ℓ(F )) ), such that F is satisfiable if and only if F ′ is
satisfiable.
Proof (Idea). For an arbitrary Boolean formula using binary operators we
can give an evaluation tree with operators at the internal nodes and literals at
the leaf nodes. By introducing new variables that express the satisfiability
of a subtree rooted at a specific internal node, we can construct a 3-CNF
formula with the stated property. By bounding the size of the tree we also
get a bound on the running time of that procedure. Note that this naturally
means that the length of the constructed formula will be bounded too.
Theorem 2.12. 3-SAT is NP-complete.
Proof. Theorem 2.11 gives us a polynomial-time many-one reduction from
SAT to 3-SAT. Because of that every problem in NP can be reduced to 3SAT, i.e. 3-SAT is NP-hard. Since 3-SAT is only a special restriction of SAT
it is also in NP, therefore it is NP-complete.
Definition 2.13. Two formulae F and G of Boolean logic are called equivalent if it holds that,
α satisfies F ⇔ α satisfies G.
We write,
F ≡ G.
A much weaker notion of equivalence is the following. The formulae F and
G are called satisfiability-equivalent if it holds that,
F is satisfiable ⇔ G is satisfiable.
For short we write,
SAT
F ≡ G.
19
2.1. BOOLEAN LOGIC
Example 2.1.2. It is important to realise that equivalence is not the same
thing as satisfiability-equivalence. For example, consider the following two
CNF-formulae.
F = { {u, v} , {u, v, w} , {u, v, w} , {u, v, w} } ,
F ′ = { {u, v} , {u, v} , {u, v, w} , {u, v, w} , {u, v, w} } .
Clearly, the two formulae are not equivalent (F 6≡ F ′ ), because for α =
(u, v, w) we have,
F [α] ≡ ⊤ 6≡ ⊥ ≡ F ′[α] .
Nevertheless, we can argue that the two formulae are, in fact, satisfiabilitySAT
equivalent (F ≡ F ′ ). The proof goes as follows.
Let C1 = {u, v} and C2 = {u, v} be two clauses. First of all, note that the
formulae F and F ′ only differ by one additional clause in F ′ , which is C2 .
Second, we notice that the literal u does only appear once in both formulae,
which is in the clause C1 . If F ′ is satisfiable, then F is satisfiable too because
of F ⊂ F ′ . So, we only have to prove that,
F is satisfiable ⇒ F ′ is satisfiable.
Suppose that β is a satisfying assignment for F . We consider all four possibilities for assigning truth values to the two variables in vbl(C1 ) = vbl(C2 ).
If (u, v) ⊆ β, then C1 is not satisfied, which leads to a contradiction, because
β does not satisfy F . We can forget this case. If (u, v) ⊆ β or (u, v) ⊆ β,
then β satisfies both C1 and C2 . Therefore, F ′[β] ≡ ⊤.
But what if (u, v) ⊆ β ? In this case C2 is not satisfied, and therefore F ′[β] ≡
⊥. Luckily, we found that the literal u appears only once in F ′ , and the clause
C1 is satisfied by the literal v ∈ β anyway. Therefore β ′ := (β\(u)) ∪ (u)
satisfies both F and F ′ . Basically, we are saying that in this case, even
though β does not satisfy F ′ , there must be another assignment β ′ , that
satisfies both formulae. We are done proving that,
SAT
F ≡ F ′.
⊡
20
2.2
CHAPTER 2. BASIC DEFINITIONS
Splitting algorithm
Before we can define the splitting itself, we need some other definitions. The
first one which we introduce here is the means by which we will gauge the
process of our splitting algorithm. The function µ, that we define in the
following, serves as a placeholder, because most of the considerations in this
section apply to a general notion of measure.
Definition 2.14. Let F be the set of all CNF-formulae. We define a measure
µ to be a function, µ : F → R+
0 , which gives us the ’size’ of any formula
from F. The measure of a trivial formula is defined to be 0, i.e. µ({}) =
µ({}) := 0.
For any formula F ∈ F the function µ must be computable in polynomial
time with respect to ℓ(F ).
Example 2.2.1. For example, µ can be n(F ), ℓ(F ), or
µ(F ) := a · n(F ) + b · ℓ(F ) + c · m(F ), where a, b, c ∈ R+ .
If we suppose F = { {u} , {v} , {v, w} , {u, v, w} }, then for the above choices
of µ, µ(F ) := n(F ) = 3, µ(F ) := ℓ(F ) = 7, or µ(F ) = 3 · a + 7 · b + 4 · c.
⊡
Definition 2.15. Let s ∈ N. A splitting tuple ~t of breadth s is a tuple of
positive real numbers,
~t := (t1 , . . . , ts ), s ≥ 1, ti > 0.
The constant splitting tuple of breadth s with entries 1 is denoted by ~1s .
2.2. SPLITTING ALGORITHM
21
Definition 2.16. Let 0 < s ∈ N. We define a splitting S(F ) of a Boolean
formula F with respect to the measure µ to be a set of formulae {F1 , . . . , Fs }
(not necessarily in CNF) such that the following conditions hold:
(i) The subproblems Fi (all of them) are computed by a procedure that has
an execution time bounded by O( s · poly(ℓ(F )) ).
(ii) Let the Boolean variables fi denote the satisfiability of Fi . There has to
be a Boolean function g : {f1 , . . . , fs } → {⊤, ⊥}, such that g(·) samples
the satisfiability of F ,
F is satisfiable ⇔ g(f1 , . . . , fs ) ≡ ⊤.
The function g must be computable in O(s).
(iii) Let µ(S(F )) = (t1 , . . . , ts ) := (µ(F ) − µ(F1 ), . . . , µ(F ) − µ(Fs )) be the
associated splitting tuple for an arbitrary measure µ. We demand that
ti > 0, for 1 ≤ i ≤ s.
If s = 1 we speak of a trivial splitting, but if s > 1 we call it a proper
splitting.
The splitting tuple ~t = (t1 , . . . , ts ) can be used as a shorthand notation of the
corresponding splitting. Given ~t we would call it a (t1 , . . . , ts )-splitting.
Remark 2.2.1. Note that in the preceding definition we are not relying on
s being a constant of some kind. The framework for the calculation of the
running time of an algorithm based on splittings is going to take s into
account. In Example 2.4.1 we are going to see an application of that feature.
⊡
Theorem 2.17. Let F be a Boolean formula, and S1 (F ) a valid splitting with
respect to the measure µ, using the function g1 (f11 , . . . , fs11 ). Furthermore, let
Fi , 1 ≤ i ≤ s1 , be any of the subproblems from S1 (F ), and suppose that we
have a valid splitting S2 (Fi ) with respect to the same measure µ, using the
function g2 (f12 , . . . , fs22 ). Then, we can combine the two splittings and get a
valid splitting,
S(F ) = (S1 (F )\ {Fi }) ∪ S2 (Fi ),
with respect to the measure µ, using the function g(f11 , . . . , fs11 , f12 , . . . , fs22 ) :=
g1 (f11 , . . . , g2 (f12 , . . . , fs22 ), . . . , fs11 ) on s1 + s2 − 1 variables. The Boolean vari
able fi1 has been replaced in g1 by g2 (f12 , . . . , fs22 ).
22
CHAPTER 2. BASIC DEFINITIONS
Proof.
(i) All the s1 + s2 − 1 subproblems of S(F ) can be computed in at most
O( s1 · poly(ℓ(F )) + s2 · poly(ℓ(Fi )) ) ⊆ O( (s1 + s2 − 1) · poly(ℓ(F ) ) steps.
(ii) We have, g2 (f12 , . . . , fs22 ) ≡ ⊤ ⇔ fi1 ≡ ⊤, by the construction of S(F ).
Therefore, g2 (f12 , . . . , fs22 ) ≡ fi1 , and we can make the replacement in g1 .
(iii) Similar as in condition (ii) we can replace t1i in the splitting tuple ~t1 of
S1 (F ) by (t1i + t21 , . . . , t1i + t2s2 ), where ~t2 = (t21 , . . . , t2s2 ) is the splitting tuple of
S2 (F ). We get a splitting tuple of length s1 + s2 − 1, in which all the entries
are strictly positive.
In the remainder of this section we are going to formulate the notion of a
general recursive splitting algorithm and give a simple example of an actual
implementation. Our splitting algorithm will also feature so-called simplification rules, by means of which certain structures can be guaranteed or
avoided in the input formula for the splitting step. Also, sometimes we want
to use the simplification rules for reducing the formula as much as possible
without actually employing a splitting. Let us make that definition more
formally.
Definition 2.18. The simplification S̃(F ) of a Boolean formula F with respect to the measure µ is defined as a formula F ′ , such that the following
conditions hold:
(i) The formula F ′ is computed by a procedure that has an execution time
bounded by O( poly(ℓ(F )) ).
(ii) The two formulae F and F ′ are satisfiability-equivalent,
SAT
F ≡ F ′.
(iii) The size of the simplified formula F ′ is smaller or equal to the size of
the formula F ,
µ(F ′ ) ≤ µ(F ).
Remark 2.2.2. The trivial splitting S(F ) is in fact a simplification as per
the above definition. It is sometimes convenient, though, to think of simplification and splitting as two separate things, that is why we are introducing
2.2. SPLITTING ALGORITHM
23
Definition 2.18 apart from Definition 2.16. Note that in point (iii) of Definition 2.18 we are also demanding that the simplification reduces the size
of the formula (or leaves it as it is). However, under certain conditions, one
might want to allow “simplification rules” that actually increase the size of
the formula. An example for this type of simplification is the addition of the
resolvent of two clauses. However, in our framework this type of simplification is not valid in its own right. We would have to include this manipulation
in the splitting step, and therefore still ensure that all the subproblems have
smaller size. After having added the resolvent of two clauses, we would have
to argue that the subproblems computed by the splitting get small enough
with respect to the measure µ, as required by (iii) of Definition 2.16.
⊡
We are now ready to give the pseudo-code framework for a SAT splitting
algorithm in general. All algorithms presented in this thesis will be formulated in that framework. Even though the specifics of any algorithm can get
arbitrarily complicated, they all share this common structure.
Algorithm 1: SSAT(F )
input : CNF-formula F
output: satisfiable or unsatisfiable
1
2
3
4
5
F ′ ← SimplifySSAT (F );
if F ′ = {} then return satisfiable;
if ∈ F ′ then return unsatisfiable;
{F1 , . . . , Fs } ← SplitSSAT (F ′ );
return g( SSAT(F1 ), . . . , SSAT(Fs ) );
Note that the two procedures SimplifySSAT and SplitSSAT do the actual
work of applying simplification rules and of computing the splitting. They
have to be specified for the algorithm to make
any sense. Also, the function
W
g has to be specified, although it will be si=1 fi , if not otherwise stated.
24
CHAPTER 2. BASIC DEFINITIONS
Let us look at a simple example. We implement the procedure Simplifyuc
as follows.
Procedure Simplifyuc (F )
input : CNF-formula F
SAT
output: CNF-formula F ′ , no unit clauses, F ≡ F ′
1
2
3
F′ ← F;
while F ′ contains 1-clause {u} do F ′ ← F ′[u] ;
return F ′ ;
As the reader might guess “uc” stands for “unit clause”, and that is exactly
what Simplifyuc does. As long as there are unit clauses it assigns ⊤ to the
single literal that appears in a unit clause.
Procedure SplitDP LL (F )
input : CNF-formula F
output: Splitting S
1
2
x ← any variable
vbl(F
);
[x] in [x]
;
return S = F , F
In the procedure SplitDP LL (F ) we compute the splitting. It complies with
all the three conditions for being a splitting. (i) Choosing a variable and
computing F [x] and F [x] is possible in O( ℓ(F ) ). (ii) If there is no satisfying
assignment for F with either x 7→ ⊤ or x 7→ ⊥, then and only then is
F unsatisfiable. (iii) The splitting tuple with respect to µ(F ) := n(F ) is
~t = (1, 1). So s = 2, and both entries of the splitting tuple are different from
zero.
You can seen that these three procedures (SSAT, Simplifyuc , SplitDP LL )
already compose a complete splitting algorithm. The running time of this
implementation is surely nothing spectacular, and through the use of simplifications we have not gained anything (at least not in the exponential part
of the running time). The running time primarily depends on the number of
variables.
tSSAT (n) ≤
≤
≤
=
∈
3 · poly(ℓ(F )) + 2 · tSSAT (n − 1)
2n · 3 · poly(ℓ(F )) + 2n · tSSAT (0)
2n · 3 · poly(ℓ(F )) + 2n · c
2n · (3 · poly(ℓ(F )) + c)
O( poly(ℓ(F )) · 2n ),
2.2. SPLITTING ALGORITHM
25
where c ∈ R+ is some constant that denotes the time necessary to check the
formulae with no variables left, i.e. check if it contains the empty clause or
not. The first line of the derivation is just saying that the running time is
upper bounded by the time to compute the simplification and construct the
two subproblems plus the time to solve the subproblems recursively. The rest
of the derivation is solving the recursion equation. Note that we neglected
the time to check for the empty formula and empty clause in every recursive
call, but in a reasonable data structure this can be done with one more sweep
through the formula, i.e. in ℓ(F ) steps. If the clauses are ordered according
to their length this is even possible in constant time.
Since a lot of our complexity statements will include a factor of poly(ℓ(F )),
we will make a useful definition that allows us to omit this factor from now
on.
Definition 2.19. Let f (n) be an exponential function in n. We define
O∗ (f (n)) := O( poly(ℓ(F )) · poly(n) · f (n) ) to be the big O notation with the
factor poly(ℓ(F )), and other polynomial factors in n suppressed.
With the preceding definition we are able to restate that the running time
of the algorithm described in this section can be upper bounded by O∗ (2n ).
Upon that we will improve in the following sections. In order to do so we
will introduce the concept of splitting numbers, for an easier analysis of
algorithms with many different splittings.
Remark 2.2.3. To give you an example of how condition (ii) of Definition 2.16 can be used differently, let us consider the formula
F = { {u1 , u2 } , {u2 , u3 } , {v1 , v 2 } } .
Note that the first two clauses do not share any variables with the third
clause. Thus, we can consider the splitting
S(F ) = { {{u1 , u2 } , {u2 , u3 }} , {{v1 , v 2 }} } .
First, note that in this case we are not able to derive the subproblems by
using partial assignments, but we are indeed able to compute this splitting
in O( poly(ℓ(F )) ).
Then of course, we also have to use a different function g in the condition
(ii), since f1 ∨ f2 can be true even if F is not satisfiable. It turns out that in
this case we can use g(f1 , f2 ) := f1 ∧ f2 to express the satisfiability of F . ⊡
26
CHAPTER 2. BASIC DEFINITIONS
2.3
Graphs
Definition 2.20. We define a undirected multi-graph, to be an ordered pair,
G := (V, E), where V is the set of vertices of the graph, and E is the multiset of edges. The edges are taken from V × V, and are defined by their two
endpoints.
We do not allow loops in the graph, i.e. (v, v) ∈
/ E for any v ∈ V.
If not stated otherwise, then speaking of a graph we will denote such an
undirected multi-graph.
The degree of a vertex, d(v), v ∈ V, is defined to be the number of edges
incident to that vertex, i.e. | {(v, w) ∈ E | w ∈ V} |.
Definition 2.21. We define the complete graph Kn to be the graph with the
following generic set of vertices and edges.
V(Kn ) := {1, . . . , n} ,
E(Kn ) := {(i, j) ∈ V(Kn ) × V(Kn ) | i 6= j} .
The graph Kn has n vertices, and every pair of vertices is connected by an
edge.
Definition 2.22. The conflict graph of a CNF-formula F is defined to be
the undirected multi-graph GF , where
V(GF ) := {C | C ∈ F } ,
E(GF ) := {(C, C ′ ) | C, C ′ are conflicting on a variable x ∈ vbl(F )} .
Note that several edges are added to E if C and C ′ have more than one
conflict.
Instead, we speak of the simple conflict graph if multiple edges are not al
lowed.
Example 2.3.1. Consider the following CNF-formula,
F = {u, v, w} , {u, v, l} , u, v, l , {w} , w, l
.
In Figure 2.1 you can see how the conflict graph would look like for the
formula F , whereas the Figure 2.2 shows the simple conflict graph.
⊡
27
2.3. GRAPHS
^XYO`
^XYO`
^XYZ`
^ZO`
^Z`
Figure 2.1: Conflict graph for Example 2.3.1
^XYO`
^XYO`
^XYZ`
^ZO`
^Z`
Figure 2.2: Simple conflict graph for Example 2.3.1
Definition 2.23. A forest is defined to be a graph that contains no cycles.
A tree is a connected forest.
We define a leaf to be a vertex that has degree 1.
Definition 2.24. A pseudo-forest is defined to be a graph that becomes a
forest, once all multiple edges in E between any two vertices v, w ∈ V are
replaced by a single edge (v, w).
In the same way, we define the pseudo-tree and the pseudo-leaf.
28
CHAPTER 2. BASIC DEFINITIONS
2.4
Search trees
In this section we relate the running time of our general splitting algorithm
to the size of the search tree that is induced by the recursive splittings. Even
though these search trees are proper trees as in Definition 2.23, we are not
referring to the section 2.3 about graphs, but give an alternative definition
here, because the search trees of this section take on a purely algorithmic
point of view. In essence, we only use them to deduce the tools for proving
upper bounds for our splitting algorithms.
Definition 2.25. Consider the general splitting algorithm A. For the input
formula F0 (in CNF) the search tree TA (F0 ) is defined as follows:
(i) If F0 is the empty formula, or only contains the empty clause, then
TA (F0 ) consists of one node, labeled with F0 .
(ii) If F0 contains the empty clause and some other clauses, then TA (F0 )
consists of a node labeled with F0 , and one child node, labeled with {}.
(iii) Otherwise, the root of the search tree TA (F0 ) is labeled with F0 , and
there are s subtrees TA (F1 ), . . . , TA (Fs ), where {F1 , . . . , Fs } is a splitting
(produced by the call to SplitA (F0 )).
The idea is to let the height of the search tree represent the measure µ, that
we are attributing to the formula. During the course of the algorithm, the
formulae get smaller, but more numerous, until we reach the lowest level. All
the leaves of the search tree will be at the same level, i.e. µ = 0, and should
be decidable in polynomial time. In order to deduce a meaningful running
time from that search tree, we have to impose the following requirements on
the tree TA (F0 ):
1. The local operations at a node, labeled with some F , are in O( s·ℓ(F ) ).
2. For any node with label F , ℓ(F ) is polynomially bounded by ℓ(F0 ).
3. The maximum number of nodes on a path from the root to a leaf of
TA (F0 ) is bounded by poly(µ(F0 )).
We need the first two conditions, because we want to bound the computational costs at one node of the recursive tree by a polynomial in ℓ(F0 ). Note
2.4. SEARCH TREES
29
that the condition two actually allows the formulae to grow longer during
the execution of the algorithm. This does not contradict the definition of the
splitting as long as the measure µ itself is decreased.
The third condition is needed, because ultimately we only want to consider
the number of leaves of the search tree. Therefore, we have to bound the
number of all nodes by a polynomial in the number of the leaves. In this
thesis we will only be considering splittings with respect to measures that
allow for a constant reduction at each step. Therefore, the maximum number
of nodes on a path from the root to a leaf is actually linearly bounded by
µ(F0 ). For example, we could also imagine a measure µ that is reduced by
1/µ(F ) at the splitting of F . Then, the longest path could still be bounded
in O(µ(F0 )2 ), which is alright. On the other hand, it would not be possible
to have splittings, where µ is reduced only by 1/O(2µ(F ) ).
Let Ni be the number of internal nodes in TA (F0 ), and Nl be the number of
leaves in TA (F0 ). Finally, we can estimate the total number tA (F0 ) of steps
performed by the algorithm A on the input F0 by the size of TA (F0 ):
tA (F0 ) ≤ [maximum running time at internal node] · Ni +
poly(ℓ(F0 )) · Nl
(2.1)
≤ [(smax + 2) · poly(ℓ(F0 )) + smax ] · Ni +
poly(ℓ(F0 )) · Nl
(2.2)
≤ [(smax + 2) · poly(ℓ(F0 )) + smax ] · ( 1 + Q(µ(F0 )) ) · Nl +
poly(ℓ(F0 )) · Nl
(2.3)
∈ O( smax · poly(ℓ(F0 )) · Q(µ(F0 )) · Nl ),
(2.4)
where Q is a polynomial that stands for the maximum number h of nodes
on a path w1 , . . . , wh in TA (F0 ) such that wi+1 is the only direct successor of
wi in TA (F0 ). In Figure 2.3 you can see a search tree that has the maximum
number of internal nodes compared to the number of leaves. This is where
the (1 + Q(µ(F0 )) term comes from in the above derivation. We state this
without proof. In this way, we can bound the number of internal nodes by
the number of leaves.
For a leaf node, we assume that the satisfiability can be decided polynomially
in the length of the original formula. The term for the maximum running
time at an internal node of the search tree is decomposed as follows. For the
internal nodes we have smax as the maximum splitting number that occurs in
the tree. Then, the smax + 2 factor is accounting for the computation of the
smax subformulae in the splitting, for the computation of the simplification,
and for the check of triviality, which all can be done in poly(ℓ(F0 )) steps. The
30
CHAPTER 2. BASIC DEFINITIONS
additional summand of smax , on the other hand, accounts for the computation
of the function g in the splitting.
)
M)
Figure 2.3: Search tree with a lot of internal nodes.
Hence, for every upper bound,
∀F0 ∈ CNF-formulae : Nl ≤ 2α·µ(F0 ) ,
where µ is any measure, we get the upper bound O∗ ( smax · 2α·µ(F0 ) ) on the
running time of algorithm A on the input formula F0 .
Example 2.4.1. Recall Remark 2.2.1 where we stated that smax does not
need to be a constant for the analysis to work. Here we give a very simple
example of that.
Let F be a CNF-formula over the variables V = {x1 , . . . , xn }. Consider the
splitting that computes all the satisfying assignments over V and tests for
each one of them. This is also a splitting in the sense of Definition 2.16. There
[α ]
are s = 2n assignments αi , 1 ≤ i ≤ s, and the restrictions Fi 1 , . . . , F [αs ] can
be computed in time O( s · n · ℓ(F ) ) ⊆ O( s · poly(ℓ(F )) ). The function g
can be computed in O(s). Finally, in every branch we are eliminating all the
variables, therefore, with respect to n, we get a (n, . . . , n)-splitting.
| {z }
s
Now, if we look at Equation (2.4) of this section, then we see that this is
already a little bit too loose for the present example, but we can easily go
back to Equation (2.1). We see that Nl = 2n and Ni = 1. Therefore, the
running time of the algorithm in this example can be upper bounded by
O( s · poly(ℓ(F )) ) · 1 + poly(ℓ(F )) · 2n ⊆ O( poly(ℓ(F )) · 2n ), which is what
we would intuitively expect.
⊡
31
2.4. SEARCH TREES
Our next task is to bound the number of leaves of TA (F0 ) under various
measures µ, gauging the progress of the splittings in the search tree.
Estimating tree size
The considerations in this section hold for arbitrary finite trees T with edges
labeled by positive real numbers. In our case we consider a search tree T (F0 )
for the input formula F0 , and we label each edge from F to Fi by the loss in
the measure µ,
0 < ti = µ(F ) − µ(Fi ).
(2.5)
To each node of the search tree T (F0 ) a splitting tuple is associated in a
natural way (collecting all the labels of the edges to the children of this
node).
Let a(F, µ(F )) denote the number of leaves in the search tree TA (F ). The
number of leaves of that tree depends on the measure µ, apart from the
input formula F of course, because the algorithm A backtracks as soon as
it has reached a leaf, i.e. µ = 0. We can write down the following recursion
equation for a(F0 , µ(F0 )),
a(F0 , µ(F0 )) ≤ a(F1 , µ(F1 )) + . . . + a(Fs , µ(Fs )),
(2.6)
where {F1 , . . . , Fs } are the labels of the children of the root of TA (F0 ).
Now, let us advance by making the induction hypothesis that, ∃γ ∈ R+ ,
independent of µ, such that for all Fi with µ(Fi ) < µ(F0 ),
a(Fi , µ(Fi )) ≤ γ µ(Fi ) .
(2.7)
Since µ(Fi ) = µ(F0 ) − (µ(F0 ) − µ(Fi )) = µ(F0 ) − ti , where ti is the ith entry
of the splitting tuple ~t, we get,
a(F0 , µ(F0 )) ≤
s
X
γ µ(F0 )−ti
i=1
= γ
µ(F0 )
·
s
X
γ −ti .
i=1
Now, consider the following equation,
f~t (γ) :=
s
X
i=1
(γ −1 )ti = 1.
(2.8)
32
CHAPTER 2. BASIC DEFINITIONS
Lemma 2.26. For s > 1, Equation (2.8) has exactly on real solution in the
range 0 < γ −1 < 1, and no other positive solution.
Proof. We have lim f~t (γ) = ∞ and lim f~t (γ) = 0.
γ→0
γ→∞
For 0 < γ < ∞, f~t (γ) is strictly decreasing, because for 0 < ǫ ∈ R we get,
f~t (γ + ǫ) =
s
X
−1 ti
((γ + ǫ) ) =
i=1
s
X
i=1
1
(γ + ǫ)ti
s
s
X
X
1
=
(γ −1 )ti
<
ti
γ
i=1
i=1
= f~t (γ).
This tells us that the Equation (2.8) has exactly one real solution for 0 <
γ < ∞. In Figure 2.4 you can see a picture of f~t (γ).
IG
W
G
G
Figure 2.4: The function f~t (γ) as in Equation (2.8)
Additionally, we calculate f~t (1) = s for any s ≥ 1. Therefore, for s > 1, we
get that the solution to Equation (2.8) must lie between 1 < γ < ∞. From
that follows 1 > γ −1 > 0 as stated in the lemma.
33
2.4. SEARCH TREES
Let us call the solution predicted by Lemma 2.26 γ ∗ . We get,
a(F0 , µ(F0 )) ≤ γ ∗ µ(F0 ) ,
which concludes the induction step.
It remains to show that the hypothesis, Equation (2.7), has a base, but that
is easy to see, because for the leaf labels {} and {} this is clearly true.
a({}, 0) = a({} , 0) = 1 ≤ γ 0 = 1,
for any γ ∈ R+ .
Definition 2.27 (Kullmann, Luckhardt, [30]). Let ~t = (t1 , . . . , ts ).
χ(t1 , . . . , tr )(x) := 1 −
r
X
x−ti ,
i=1
with each splitting tuple ~t the characteristic function χ(~t )(x) is associated,
defined for x ∈ R+ . From Lemma 2.26 it follows directly that, given ~t,
χ(~t )(x) = 0 has exactly one positive solution for x, which is greater or equal
than 1. We call this solution the splitting number and denote it by τ (~t ). Example 2.4.2. Consider the splitting tuple ~t1 = (1, 1). Then, we have the
characteristic function χ(~t1 )(x) = 1 − 2 · x−1 . Therefore, τ (~t1 ) = 2.
For the splitting tuple ~t2 = (1, 2), we get χ(~t2 ) = 1 − x−1 − x−2 . The positive
solution to χ(~t2 )(x) = 0 is,
√
5
1
+
,
τ (~t2 ) =
2
which is the golden ratio.
Definition 2.28 (Kullmann, Luckhardt, [30]). The maximum splitting number of a search tree is defined as follows.
(
1
if T (F0 ) has only one node,
τmax (T (F0 )) :=
max
τ (~tv) otherwise,
⊡
v∈V(T (F0 ))
where ~tv is the tuple associated with the node v in the tree T (F0 ).
34
CHAPTER 2. BASIC DEFINITIONS
Lemma 2.29 (Kullmann, Luckhardt, [30]). Let ~t = (t1 , . . . , ts ) be a splitting
tuple, s ≥ 1. Here are some basic properties of τ (~t ).
(i) τ (~1s ) = s
1
(ii) τ (λ · ~t ) = τ (~t ) λ for λ > 0
(iii) a T τ (~t ) ⇔ χ(~t )(a) T 0 for a > 0
(iv) τ (~t ) = 1 ⇔ s = 1
Proof.
(i) We equate the characteristic function with 0,
χ(~1s )(x) = 1 − s · x−1 = 0.
From that it readily follows that τ (~1s ) = s.
(ii) By definition we have,
χ(λ · ~t )(τ (λ · ~t )) = 0.
1
Let us substitute τ (~t ) λ into the above formula instead of τ (λ · ~t ),
1
χ(λ · ~t )(τ (~t ) λ ) = 1 −
s
X
i=1
1
τ (~t )− λ ·λ·ti = 1 −
s
X
τ (~t )−ti = 0.
i=1
1
Since χ(λ · ~t )(x) = 0 has only one solution, it follows that τ (λ · ~t) = τ (~t) λ .
(iii) In the proof of Lemma 2.26 we have seen that the function f~t (a) is
strictly decreasing for 0 < a < ∞. Therefore, the characteristic function
χ(~t )(a) = 1 − f~t (a) is strictly increasing for 0 < a < ∞, and the statement
is easily implied by χ(~t )(1) < 0 and lima→∞ χ(~t )(a) = 1.
(iv) We already know that τ (~t ) ≥ 1. Let us assume that τ (~t) = 1. Then, we
have,
s
X
~
χ(t )(1) = 1 −
1−ti = 1 − s = 0.
i=1
This can only be true if s = 1, which proves the forward direction. If, on the
other hand, s = 1 by assumption, then we have,
χ(t1 )(x) = 1 − x−t1 = 0.
Therefore, it follows that τ (t1 ) = 1, which proves the backward direction.
35
2.4. SEARCH TREES
Theorem 2.30 (Kullmann, Luckhardt, [30]). Let µ be a measure on formulae such that all µ-differences in a given search tree T (F0 ) are positive.
Then, we have the following bound on the number of leaves in T (F0 ):
| {leaves in T (F0 )} | ≤ τmax (T (F0 ))µ(F0 ) = 2α·µ(F0 ) ,
i.e. α = log2 τmax (T (F0 )) is the corresponding power coefficient.
Proof (by induction). The bound is trivial when T (F0 ) consists of one node
only. So let us assume that T (F0 ) is of the form shown in Figure 2.5.
)
W
WS
)
)V
7 )V
7 )
Figure 2.5: The composition of the search tree T (F0 ).
The proof is an application of the monotonicity of χ(~t ). Let τi := τmax (T (Fi ))
be the maximal splitting number for the search tree T (Fi ), 0 ≤ i ≤ s. Then
we have,
| {leaves in T (F0 )} | =
≤
≤
=
≤
s
X
i=1
s
X
i=1
s
X
| {leaves in T (F1 )} |
µ(Fi )
τi
µ(F )
τ0 i
i=1
µ(F )
τ0 0 ·
µ(F )
τ0 0 .
(induction hypothesis)
=
s
X
µ(F0 )−ti
τ0
i=1
(1 − χ(~t )(τ0 ))
36
2.5
CHAPTER 2. BASIC DEFINITIONS
Splitting numbers
To get a bound on the number of the leaves in the search tree, by Theorem
2.30 we have to estimate τmax considered as the splitting complexity of the
search tree. This requires some techniques for comparing and estimating
splitting numbers (recall Definition 2.27).
Lemma 2.31 (Kullmann, Luckhardt, [30]). For any splitting tuple ~t =
(t1 , . . . , ts ) we have the following properties:
(i) Permutations of ~t do not affect χ(~t ) and τ (~t ).
(ii) In case ~t is at least binary (i.e. s ≥ 2), τ (~t ) is strictly decreasing in
each component.
(iii) τ (t1 , . . . , ts ) < τ (t1 , . . . , ts , ts+1 ) for ts+1 > 0.
(iv) s1/ max{ti } = τ (max {ti } · ~1s ) ≤ τ (~t ) ≤ τ (min {ti } · ~1s ) = s1/ min{ti } .
Proof.
(i) In the characteristic function χ(~t )(x) each of the ti goes into an independent part of the sum. The terms can be arbitrarily ordered, without changing
χ(~t )(x) or τ (~t ).
(ii) Because of (i) we can assume without loss of generality that t1 is the
parameter that is being increased by ǫ ∈ R+ . Let τ = τ (t1 , . . . , ts ), then we
get,
χ(t1 , . . . , ts )(τ ) = 0
= 1−τ
−t1
−
s
X
τ −ti
i=2
< 1 − τ −(t1 +ǫ) −
s
X
τ −ti
i=2
= χ(t1 + ǫ, t2 , . . . , ts )(τ ).
Because of the monotonicity of the function χ(t1 + ǫ, t2 , . . . , ts )(x) it follows
that τ (t1 + ǫ, t2 , . . . , ts ) < τ .
37
2.5. SPLITTING NUMBERS
(iii) Let τ = τ (t1 , . . . , ts ), then we get,
χ(t1 , . . . , ts )(τ ) = 0
= 1−
s
X
τ −ti
i=1
> 1−τ
−ts+1
−
s
X
τ −ti
i=1
= χ(t1 , . . . , ts+1 )(τ ).
Again, by the monotonicity of the function χ(t1 , . . . , ts+1 )(x) it follows that
τ (t1 , . . . , ts+1 ) > τ .
(iv) The equalities follow from Lemma 2.29 (ii), and the inequalities follow
from Lemma 2.31 (ii).
WM
W
W|
W|N
Figure 2.6: The composite splitting tuple t~∗ of Lemma 2.32.
38
CHAPTER 2. BASIC DEFINITIONS
The following lemma connects very well to Theorem 2.17. The situation is
depicted in Figure 2.6. In Theorem 2.17 we have seen that we can combine
two successive splittings to one splitting. The Lemma 2.32 now tells us
that the splitting number of this combined splitting will be in between the
splitting numbers of the constituent splittings. Because of Lemma 2.31, we
can assume without loss of generality that the second splitting is made in
the first branch of the first splitting.
Lemma 2.32 (Kullmann, Luckhardt, [30]). Consider two arbitrary splitting
tuples ~t = (t1 , . . . , tm ) and ~t′ = (t′1 , . . . , t′n ). Then for t~∗ := (t1 + t′1 , t1 +
t′2 , . . . , t1 + t′n , t2 , . . . , tm ) with breadth m + n − 1 (see Figure 2.6), we have:
(i) τ (~t ) = τ (~t′ ) ⇒ τ (t~∗ ) = τ (~t )
(ii) τ (~t′ ) < τ (~t ) ⇒ τ (~t′ ) < τ (t~∗ ) < τ (~t )
(iii) τ (~t′ ) > τ (~t ) ⇒ τ (~t′ ) > τ (t~∗ ) > τ (~t )
Proof. By the definition of the characteristic function we have,
χ(t~∗ )(x) =
=
=
=
′
′
1 − x−t1 · x−t1 − . . . − x−t1 · x−tn − x−t2 − . . . − x−tm
′
′
1 − x−t1 − . . . − x−tm + x−t1 − x−t1 (x−t1 + . . . + x−tn )
′
′
χ(~t )(x) + x−t1 (1 − x−t1 − . . . − x−tn )
χ(~t )(x) + x−t1 · χ(~t′ )(x).
Using Lemma 2.29 (iii) (denoted by 2.29) and the previous derivation for
χ(t~∗ )(x) (denoted by ⋆), (i)-(iii) of Lemma 2.32 follow immediately, for
example in case of (ii):
⋆
2.29
2.29
τ (~t′ ) < τ (t~∗ ) ⇐⇒ χ(t~∗ )(τ (~t′ )) < 0 ⇐⇒ χ(~t )(τ (~t′ )) < 0 ⇐⇒ τ (~t′ ) < τ (~t ),
⋆
2.29
2.29
τ (t~∗ ) < τ (~t ) ⇐⇒ χ(t~∗ )(τ (~t )) > 0 ⇐⇒ χ(~t′ )(τ (~t )) > 0 ⇐⇒ τ (~t′ ) < τ (~t ).
Note that, for the proof of this lemma, the lines above have to be read from
right to left. Also, for the proof of (i) or (iii) we only have to replace the
greater and smaller signs in the above lines by the appropriate relations.
2.5. SPLITTING NUMBERS
39
The following lemma is useful if we want to decide, for a given set of splitting
tuples, which one of those results in the best running time. In most of the
described techniques it is known beforehand which splittings can occur, and
they have a bounded breadth. In that case the splitting numbers can be
calculated in advance and stored in a table for fast look-up. Nevertheless,
in some cases we might want to make this decision on the fly, during the
execution of the splitting algorithm. Typically, numerical calculations such
as the Newton approximation can be used to do that, but we must ensure
that this process does not slow down the algorithm asymptotically.
Lemma 2.33. Let ~t1 ∈ Qs1 and ~t2 ∈ Qs2 be two splitting tuples for a CNFformula F with respect to the measure µ, where s1 and s2 are the breadth of
the splittings respectively. Then, it can be decided in polynomial time whether
τ (~t1 ) < τ (~t2 ).
Proof (sketch). The proof works by a translation of the problem into the
first order theory of the real numbers, and by using its decision algorithm,
that was proposed by James Renegar in 1992 (see [35]).
The translation of the problem into a sentence of the first order theory of the
real numbers looks something like the following,
(∃(x1 , x2 ) ∈ R2 ) [ (χ(~t1 )(x1 ) = 0)
∧ (χ(~t2 )(x2 ) = 0)
∧ (χ(~t2 )(x2 ) − χ(~t1 )(x1 ) > 0) ] ,
which is a Boolean quantifier formula, followed by the conjunction of three
Boolean predicates, that are constructed from the characteristic functions of
the splitting tuples. Note that this translation is not correct yet, because the
predicate equations must consist of polynomials (i.e. only integer exponents),
and not rational functions such as χ(~t1 )(x1 ) and χ(~t2 )(x2 ). However, if the
splitting tuples consist of integer numbers only, then the above condition
d
can be achieved
easily
by multiplying the predicate equations by x , where
d = max t ∈ ~t1 , ~t2 . Even if we allow rational numbers in the splitting
tuples, the predicate equations can be converted to polynomial equations, by
multiplying them by x to the power of the least common denominator of the
fractional exponents.
In any case, let us assume that d is the maximum degree of all polynomials
occurring in any of the predicates. Theorem 1.1 of [35] states that there is
an algorithm for deciding the above sentence in (3 · d)2 .
40
CHAPTER 2. BASIC DEFINITIONS
Chapter 3
Simplification Rules
In this chapter we include some of the known simplification rules for the SAT
problem. We show how they fit into our framework. In the later sections
we will talk about resolution. We will explain how it can be used for some
simplifications, but also how it is not a simplification in its general setting.
3.1
Subsumption rule
If a formula F contains two clauses C and C ′ with C ⊆ C ′ , then we can
discard C ′ from the formula without changing the satisfiability. This is what
the subsumption rule exploits. We find that,
SAT
F ≡ F ′ = F \ {C ′ } if C, C ′ ∈ F and C ⊂ C ′ .
Lemma 3.1. The subsumption rule is a simplification S̃(F ) = F ′ as in Definition 2.18, with respect to any linear combination of the standard measures
n, m, and ℓ with positive coefficients.
Proof.
(i) Is easy to see that we can find the clauses C and C ′ with C ⊂ C ′ and
remove C ′ , if there are such clauses, in O( ℓ(F )2 ) (not necessarily tight).
(ii) If F is satisfiable, then F ′ is too, because F ′ ⊂ F . If, on the other
hand, F ′ is satisfiable, then there exists a satisfying assignment α for F ′ that
naturally satisfies the clause C ∈ F ′ . Since C ⊂ C ′ , α satisfies C ′ , and thus
also F .
41
42
CHAPTER 3. SIMPLIFICATION RULES
(iii) Since at least one non-empty clause is removed from the formula, the
measures m and ℓ are reduced by at least 1. The measure n may in fact stay
the same, but is certainly not increased. Therefore, µ(F ′ ) ≤ µ(F ) for any
linear combination of the standard measures with positive coefficients.
Example 3.1.1. Have a look at the formula
F = { {u, v} , {u, v, w} , {u, v, w} } .
We see that the second clause C ′ = {u, v, w} is a superset of the first clause
C = {u, v}, and therefore we can discard C ′ according to the subsumption
rule. We get
F ′ = F \ {C ′ } = { {u, v} , {u, v, w} } .
F ′ is satisfiable, e.g. by the assignment α = (u, v, w). Therefore, α satisfies
F as well.
⊡
3.2. PURE LITERAL RULE
3.2
43
Pure literal rule
The pure literal rule tells us how to remove a variable x from the formula F
that only appears as positive literals (or only as negative literals). As you
might guess,
[x]
SAT
F
if x only appears positively,
′
F ≡F =
[x]
if x only appears negatively.
F
Lemma 3.2. The pure literal rule is a simplification S̃(F ) = F ′ as in Definition 2.18, with respect to any linear combination of the standard measures
n, m, and ℓ with positive coefficients.
Proof.
(i) We can find a pure literal, if there is any, and make the restriction of the
formula in O( ℓ(F )2 ) (not necessarily tight).
(ii) In both cases, every occurrence of the variable x can be fixed to ⊤.
Therefore, we can delete all clauses containing that literal, and if the resulting
formula is satisfiable, we also have a satisfying assignment for the original
formula F . On the other hand, if we know F to be satisfiable, then any
subset of the clauses has to be satisfiable too. This simplification indeed
produces a subset of the original clauses.
(iii) The variable x appears in at least one clause, therefore we strictly reduce
the measure, i.e. µ(F ′ ) < µ(F ), for any linear combination of the standard
measures with positive coefficients.
Example 3.2.1. Take the formula
F = { {u, v, w} , {u, v, w} , {v, w} , {v, w} } .
Here, the only literal that is pure in F , is the literal u. All other variables
appear as negative and positive literals. The simplified formula F ′ reads
F ′ = F [u] = { {v, w} , {v, w} } .
F ′ is satisfiable, e.g. by the assignment α′ = (v, w). Therefore, α = (u, v, w)
satisfies F .
⊡
44
3.3
CHAPTER 3. SIMPLIFICATION RULES
Unit clause rule
The unit clause rule applies to formulae containing clauses of length 1. If we
want to satisfy the whole formula, then we obviously have to satisfy all its
clauses with the same assignment. If there is a clause of length 1, then we
have to map the literal contained in it to ⊤ in every candidate for a satisfying
assignment. We get
SAT
F ≡ F ′ = F [u] if {u} ∈ F.
Lemma 3.3. The unit clause rule is a simplification S̃(F ) = F ′ as in Definition 2.18, with respect to any linear combination of the standard measures
n, m, and ℓ with positive coefficients.
Proof.
(i) We can find unit clauses, and make the restriction of the formula in
O( ℓ(F )2 ) (not necessarily tight).
(ii) This condition is satisfied, because in order to satisfy F we need to satisfy
all of its clauses. Note that this is also true if a literal exists as positive and as
negative unit clause, i.e. {u} , {u} ∈ F . Whichever unit clause we choose for
the simplification step, the resulting formula will contain the empty clause.
This lets us immediately conclude that the simplified formula (and thus also
the original formula) is not satisfiable.
(iii) By removing a unit clause, we reduce all the standard measures by at
least 1. Therefore, µ(F ′ ) < µ(F ) for every linear combination of the standard
measures with positive coefficients.
Example 3.3.1. Let us simplify the formula
F = { {u} , {u, v, w} , {u, v, w} , {u, v, w} } .
We find that there is a unit clause {u}, which we can use to simplify F by
computing
F ′ = F [u] = { {v, w} , {v, w} } .
F ′ is satisfiable, e.g. by the assignment α′ = (v, w). Therefore, α = (u, v, w)
satisfies F .
⊡
3.4. AUTARK ASSIGNMENT RULE
3.4
45
Autark assignment rule
Two papers that are concerned with autarky are [28] and [29]. The autark
assignment rule is, in a certain sense, a generalisation of the pure literal rule
to several variables.
Definition 3.4 (Monien, Speckenmeyer, [31]). Let F be a CNF-formula, and
W ⊆ vbl(F ). Let α : W → {⊤, ⊥} be a truth assignment on all variables in
W . Then, α is called autark in F if and only if
∀C ∈ F : vbl(C) ∩ W 6= ∅ ⇒ α satisfies C.
All clauses C containing variables from W are satisfied by α.
The definition implies that, given an autark assignment α, we can simplify
F by F [α] . If we consider autark assignments on only one variable, then the
pure literal rule is implied. We have,
SAT
F ≡ F ′ = F [α] if α is autark in F.
Lemma 3.5. The autark assignment rule is a simplification S̃(F ) = F ′ as
in Definition 2.18, with respect to any linear combination of the standard
measures n, m, and ℓ with positive coefficients.
Proof.
(i) If we are given an assignment α, it is easy to check if it is autark. We
just need to compute the restriction of F by α, and then check if we have
gotten a subset of the original formula. It is easy to see that this is possible
in O( ℓ(F )2 ). Note that we can actually do better than that, but it is not
necessary for the proof.
(ii) The restriction of a formula F by an autark assignment produces a
subset of the clauses of F . If F [α] is satisfiable by assignment α′ , then F is
satisfiable by (α, α′ ). If, on the other hand, F is satisfiable, then any subset
of the clauses of F must be satisfiable too.
(iii) Since α is a non-empty autark assignment, we remove at least one clause
from F , by setting at least one variable to ⊤. Therefore, all the standard
measures are reduced by at least 1. It follows that µ(F ′ ) < µ(F ) for any
linear combination of the standard measures with positive coefficients.
46
CHAPTER 3. SIMPLIFICATION RULES
Example 3.4.1. Take the formula
F = { {u, v} , {u, v, w1 } , {u, w1 } , {w2 , w3 , w4 } } .
The assignment α = (u, v) is autark in F . Therefore, we can simplify F by
F ′ = F [α] = { {w2 , w3 , w4 } } ,
a formula with only one clause left. F ′ is satisfiable by the assignment α′ =
(w2 , w3 , w4 ). Therefore, F must be satisfiable by (α, α′ ) = (u, v, w2 , w3 , w4 ).
Note that this is still not yet a total assignment, because the mapping of w1
can be arbitrary.
⊡
Remark 3.4.1. Unlike the other simplification rules, that we have seen so far,
it is not easy to decide if there are any more assignments that are autark in a
given formula. For an idea of the proof of that fact, just consider that every
satisfying assignment for a formula F is autark in F . Therefore, deciding
if there exists a total autark assignment for F is equivalent to deciding the
satisfiability of that formula.
⊡
47
3.5. INPUT RESOLUTION
3.5
Input resolution
Definition 3.6. Two clauses C1 and C2 are resolvable if and only if they
share exactly one conflicting literal:
|C1 ∩ C 2 | = 1.
The resolvent C1 • C2 of two resolvable clauses C1 and C2 with C1 ∩ C 2 = {l}
is defined by
C1 • C2 := (C1 \ {l}) ∪ (C2 \ l ).
For |C1 ∩ C2 | =
6 1 the term C1 • C2 is undefined.
Definition 3.7. For a set of clauses C1 , . . . , Cr , r ≥ 2, we recursively define
the input resolvent,
C1 • . . . • Cr := (C1 • . . . • Cr−1 ) • Cr ,
provided (C1 • . . . • Cr−1 ) and Cr share exactly one conflicting literal.
Definition 3.8. We say that C can be inferred from F if there exists a set
of clauses in F whose input resolvent is a subset of C. For r ≥ 1 we write,
F ⊢ C ⇔ ∃C1 , . . . , Cr ∈ F : C1 • . . . • Cr ⊆ C.
Remark 3.5.1. Note that the input resolvent only uses left-associative resolvents. It is not allowed to have resolvents of the form (C1 • C2 ) • (C3 • C4 ).
We introduce this from of resolution, because in Lemma 3.9 we will see that
there is a very efficient way of deciding whether a clause C can be inferred
from a formula F .
⊡
Example 3.5.1. Consider the following formula,
F = { {u, v, w} , {u, v, w} , {u, v, w} , {u, v, w} , {u, v} } .
We find that the clause {v} can be inferred from F by input resolution,
({u, v, w} • {u, v, w}) • {u, v} = {v} .
The clause {u}, on the other hand, cannot be inferred by input resolution,
but only by a resolvent that is not left-associative, e.g.
({u, v, w} • {u, v, w}) • ({u, v, w} • {u, v, w}) = {u} .
We leave the proof to the reader that there is, in fact, no way of obtaining
{u} by input resolution.
⊡
48
CHAPTER 3. SIMPLIFICATION RULES
The following lemma is very useful when we want to decide whether a clause
C can be inferred from a formula F . There are two parts in the lemma. The
first one states that the fact that C can be inferred from F is equivalent
to the fact that the empty clause can be inferred from the formula F [C] , in
which all the literals in C have been mapped to ⊥. The second part states
that, if we simplify F with respect to the unit clause rule (see Lemma 3.3),
and we find the empty clause, then this is equivalent to the fact that the
empty clause can be inferred from F .
Lemma 3.9 (Kullmann, Luckhardt, [30]). We can decide F ⊢ C by the
following,
(i) F ⊢ C ⇔ F [C] ⊢ ,
(ii) F ⊢ ⇔ ∈ Simplifyuc (F ).
Proof. For r = 1 the proof is easy, so we assume r ≥ 2.
(i) Let us assume that F ⊢ C for some clause C. So, there exists C1 , . . . , Cr ∈
F with C1 • . . . • Cr ⊆ C. If we map all the literals in C to ⊥, then
[C]
(C1 • . . . • Cr−1 )[C] and Cr are two complementary 1-clauses, because the
only literals in those two clauses that do not appear in C are the conflicting
literals.
To prove the opposite direction, first note that, if the empty clause can
be inferred from a formula, then any clause can be inferred. Now, F [C] ⊢
implies that there are C1′ , . . . , Cr′ ∈ F [C] with C1′ • . . . • Cr′ = . But
these clauses must have already been present in F as C1 , . . . , Cr , possibly
containing some additional literals from C, because by restricting F by C we
made these literals disappear. It is clear that C1 • . . . • Cr ⊆ C and therefore
the first part of the lemma follows.
(ii) If F ⊢ , then there exists C1 , . . . , Cr with C1 • . . . • Cr−1 and Cr being
two complementary 1-clauses. This implies that from F [Cr ] the empty clause
can still be inferred, because C1 • . . . • Cr−1 must not share a common literal
with Cr (only one complementary literal). From this it follows inductively
that ∈ Simplifyuc (F ).
The other direction can be proven as follows. Without loss of generality we
can assume that, in the last step of the simplification there are two complementary unit clauses C1′ and C2′ . If these two clauses are part of the original
formula F , then it is easy to see that the empty clause can be inferred.
3.5. INPUT RESOLUTION
49
Otherwise, they may have contained other literals that have already been
eliminated by a unit clause simplification. In this case the two clauses C1′
and C2′ have been present in F as C1 and C2 . Thus, the resolvent C1 • C2 can
further be resolved with those other unit clauses, or as it is, with another
clause that contains more than one literal, but that has itself been reduced to
a unit clause in the process of simplification. Inductively, we get the desired
sequence of clauses that can be resolved to the empty clause, because for the
simplification to start at all we must have at least one unit clause present in
F already.
Lemma 3.10 (Clause elimination).
Let F be a CNF-formula, and C ∈ F . Then we get the following satisfiabilityequivalence, and can possibly remove the clause C.
SAT
F ≡ F \ {C} if (F \ {C}) ⊢ C.
We can simplify F with respect to clause elimination in O( poly(ℓ(F )) ).
Proof. For every clause C ∈ F we compute Simplifyuc ((F \ {C})[C] ). From
Lemma 3.9 it follows that, if we find the empty clause, then (F \ {C}) ⊢ C.
To see the polynomial running time, consider the steps involved. We have to
remove the clause C, compute the restriction, and compute the simplification
for the unit clause rule. All these steps run in O( poly(ℓ(F )) ).
Lemma 3.11 (Clause strengthening).
Let F be a CNF-formula, and C ∈ F . Let C ′ be a strict subset of C, i.e.
C ′ ⊂ C. Then we get the following satisfiability-equivalence, and can possibly
replace the clause C by C ′ .
SAT
F ≡ (F \ {C}) ∧ C ′ if F ⊢ C ′ .
We can simplify the formula F with respect to clause strengthening in at most
O( poly(ℓ(F )) ) time steps.
Proof. Without loss of generality let C ′ = C\ {l} for some literal l ∈ C. For
′
every clause C ∈ F and every literal l ∈ C, we compute Simplifyuc (F [C ] ).
From Lemma 3.9 it follows that, if we find the empty clause, then F ⊢ C ′ .
The proof of the running time is the same as in Lemma 3.10, except that we
not only have to check every clause in the formula, but also for every literal
in each clause. Still, the running time is upper bounded by O( poly(ℓ(F )) ).
50
3.6
CHAPTER 3. SIMPLIFICATION RULES
Davis-Putnam resolution
The general resolution algorithm for CNF-formulae goes back to the 1960
paper of Davis and Putnam (see [11]). It eliminates one variable after the
other by adding all possible resolvents for that variable, and then deleting
all clauses that contain that variable. In the end we either get the empty
formula, or a formula containing the empty clause. From that we can decide
the satisfiability of the original formula. A deduction of the empty clause is
also called a resolution refutation. Let us first define how to eliminate one
variable.
Definition 3.12. Let F be a CNF-formula, and u a literal with vbl(u) ∈
vbl(F ). We define the Davis-Putnam resolution for a single literal as follows,
DPu (F ) := {C
/ vbl(C)} ∪
∈ F | vbl(u) ∈
C1 • C2 | C1 , C2 ∈ F and C1 ∩ C 2 = {u} .
DPu (F ) is the result of substituting the set of clauses in F containing u or
u by the set of all possible resolvents for that literal. For several literals
u1 , . . . , ur we define,
DPu1 ,...,ur (F ) := DPur (. . . (DPu1 (F )) . . .).
Lemma 3.13. Let F be a CNF-formula, and u a literal contained in F .
Then,
SAT
F ≡ DPu (F ).
Proof. First, note that in general resolution (unlike our Definition 3.6) two
clauses sharing more than one conflicting literal can also be resolved, but
only one literal at a time. Such two clauses would have several resolvents.
However, all of these resolvent clauses will contain at least one complementary literal, and would be trivially satisfiable. That is why, for the purpose
of satisfiability-equivalence, we can actually ignore these clauses.
In the forward direction of the proof we are going to show that the conjunction of two resolvable clauses C ∨ u and D ∨ u of F is satisfiability-equivalent
to their resolvent (C ∨ u) • (D ∨ u) = C ∪ D. Since this holds for every pair of
resolvable clauses, and because we are adding the possible resolvent of every
3.6. DAVIS-PUTNAM RESOLUTION
51
pair of clauses (except for the type described in the previous paragraph),
this is already enough to prove the forward direction. The argument goes as
follows. If {(C ∨ u), (D ∨ u)} is satisfiable, then C ∪ D is. Suppose that α
is a satisfying assignment for {(C ∨ u), (D ∨ u)}. Without loss of generality,
we can assume that u ∈ α, therefore D must contain a literal that is satisfied
by α. Now, this literal is also present in C ∪ D, therefore the resolvent is
satisfied by α too. Additionally, note that all clauses in F that do not contain
u or u are contained in DPu (F ), and are therefore naturally satisfied by α.
We prove the backward direction by contradiction. Let us assume that
DPu (F ) is satisfied by the assignment α, but F is not satisfiable by any
assignment, in particular neither by α′ = (α, u) nor by α′ = (α, u). Note
that the literal u as well as the literal u must occur in F , otherwise it would
be a pure literal (DPu (F ) = F [u] or DPu (F ) = F [u] ), or even DPu (F ) = F
if vbl(u) ∈
/ vbl(F ). Because F is not satisfiable, there must be two clauses
C ∨ u and D ∨ u in F , where neither C nor D is satisfied by α, otherwise the
right choice of α′ would satisfy both clauses. In order to continue we must
establish to facts about C and D. First, neither C nor D may be empty. If
both were, DPu (F ) would contain the empty clause. If one of them were,
the other one would be a clause of DPu (F ), and therefore be satisfied by α.
Second, C and D must not contain a conflicting literal. If they did, either α
satisfies one of them, or we could extend α to do so. But then, the resolvent
C ∪ D of these two clauses would not be satisfied by α, which contradicts our
assumption that DPu (F ) is satisfied by α. Therefore, F must be satisfiable.
52
CHAPTER 3. SIMPLIFICATION RULES
Chapter 4
Splitting Rules
In this chapter we are going to look at some well known splittings, and show
how they fit into our framework. In the later sections we are also going to
present some cases in which very good splittings exist, and how to find good
splittings automatically. However, first of all we would like the reader to get
some feeling for the behaviour of splitting numbers. In Section 2.5 we have
laid the theoretical foundations of splitting numbers, but here we just give
some intuitive examples.
Consider a splitting with two branches and in each branch the measure µ is
reduced by a positive real number. We can simply say that this is a (i, j)splitting with i, j ∈ R+ . In Figure 4.1 you can see the behaviour of τ (i, j) for
i, j up to 5. The contour lines are shown for τ (i, j) = 1.2, . . . , 2.0 in interval
steps of 0.1. That means that for all the points lying on such a contour
line the splitting number is the same. The colour of the areas in between
these lines indicates that higher splitting numbers are bad for the running
time of our algorithms. This goes hand in hand with our intuition that it
is better to reduce µ as much as possible in each branch. From blue to red,
the (i, j)-splitting is getting worse and worse. Beyond the 2.0 contour line,
towards the origin of the plot, the splitting number is greater than 2.0 and
gets arbitrarily high when approaching one of the axes.
If we consider splittings with more than two branches, then it is not as easy
to make a visual representation for splittings with three branches. There, the
contour lines become surfaces in three-dimensional space, that are completely
contained in the positive octant. The surfaces “bend” away from the origin,
similar as the contour lines in two dimensions. However, for four dimensions
and higher it gets virtually impossible to pursue a figurative argumentation
within the confinements of the human mind. Instead, we give a table of
53
54
CHAPTER 4. SPLITTING RULES
;J=
T
T
T
T
T
T
T
T
T
;I=
Figure 4.1: Contour plot of τ (i, j), where i, j ∈ R+ .
some splittings with integer µ reduction for two, three, and four branches
respectively.
In the following table the splittings are sorted from left to right with respect
to their breadth, and they are sorted from top to bottom with respect to the
splitting number. The list of splittings appearing in this table is completely
arbitrary, although there are some interesting things to point out.
First, as predicted by Lemma 2.31 (iv), we see that splittings of smaller
breadth are generally better than splittings with more branches. For example, we see that
τ (1, 2) < τ (1, 2, 3) < τ (1, 2, 3, 4).
Second, within one column of the same breadth, we are able to establish a
partial ordering by Lemma 2.31 (ii), but we are not able to give a complete
ordering. For example, for splittings of breadth four,
τ (2, 2, 2, 3) < τ (3, 3, 3, 3),
can be proved by the lemma, because we can just increase the entries in the
splitting tuple ~t = (2, 2, 2, 3) until we get the tuple ~t = (3, 3, 3, 3), but other
55
relations such as,
τ (2, 2, 2, 3) < τ (1, 3, 3, 3),
cannot be proved by that lemma. For that we need numerical calculations
or more properties on the splitting numbers.
Finally, the reader may notice that there are splitting numbers that are
exactly the same, and this is not only the case up to the precision given. For
example we have,
τ (1, 2) = τ (2, 2, 3) = τ (2, 2, 4, 5).
This is, because the tuple ~t = (2, 2, 3) can just be seen a two applications
of the splitting with the tuple ~t = (1, 2). Also, the tuple ~t = (2, 2, 4, 5) can
just be seen as three applications of the splitting with the tuple ~t = (1, 2).
Lemma 2.32 (i) actually predicts that, if we are combining the same splitting
over and over again, the splitting number of the combined splitting does not
change.
τ (~t )
3-tuple ~t
2-tuple ~t
(1, 1)
2.000000000
τ (~t )
4-tuple ~t
τ (~t )
(1, 2, 3, 4) 1.927561975
(2, 2, 2, 3) 1.879385242
(1, 3, 3, 3) 1.863706528
(1, 2, 3)
1.839286755
(2, 2, 3, 3) 1.769292354
(2, 2, 2)
(1, 3, 3)
(1, 2)
1.618033989
(2, 2, 3)
(1, 3)
1.465571232
(2, 2, 4)
(2, 3, 4)
(3, 3, 3)
(2, 2)
(2, 3)
1.414213562
1.324717957
1.732050808
1.695620770
(2, 3, 3, 3) 1.671699882
1.618033989 (2, 2, 4, 5) 1.618033989
(3, 3, 3, 3) 1.587401052
1.553773974
1.465571232
1.442249570
Now, let us go on and talk about how to get splittings from a Boolean formula.
The next sections are going to do that.
56
4.1
CHAPTER 4. SPLITTING RULES
Splitting on a variable
The most obvious way to make a splitting is by choosing one variable and
mapping it to true in one of the subproblems and mapping it to false in
the second subproblem. This splitting has already been explained in Section
2.2. The pseudo-code of the procedure SplitDP LL and also the proof of the
following lemma with respect to the measure µ(F ) := n(F ) can be found
there. Here we only include the proof with respect to the measure µ(F ) :=
ℓ(F ).
Lemma 4.1.
Let F be a CNF-formula, and let x ∈ vbl(F ). Then S =
[x]
[x]
is a splitting with respect to the measures µ(F ) ∈ {n(F ), ℓ(F )},
F ,F
using the function g(f1 , f2 ) := f1 ∨ f2 .
Proof. The proof of this lemma for conditions (i) and (ii) of Definition 2.16,
and for condition (iii) with respect to µ(F ) := n(F ) has already been stated
in Section 2.2. The proof of condition (iii) with respect to µ(F ) := ℓ(F ) is
easy.
Recall (iii) of Definition 2.16. Since the variable x appears at least once in
F , ℓ(F ) is reduced by at least 1 in both branches.
Example 4.1.1. Consider the following formula,
F = { {u, v, w} , {u, w} , {v} } .
Choosing the literal u to split upon, we get
S = F [u] , F [u]
= { {{v}} , {{v, w} , {w} , {v}} } .
S is a (1, 1)-splitting with respect to the number of variables n and a (5, 2)splitting with respect to the length of the formula ℓ.
⊡
Remark 4.1.1. The described procedure is not necessarily a splitting with
respect to the measure µ(F ) := m(F ). To see this, consider the previous
example again. The literal u is a pure literal (see Section 3.2), and therefore
its variable does not appear as the complementary literal. This would result
in a (2, 0)-splitting, which is not allowed. To apply this measure we would
have to make an additional argument, such as insisting on the pure literal
rule being applied in the simplification step.
⊡
4.2. SPLITTING ON A CLAUSE
4.2
57
Splitting on a clause
Another splitting that is often considered is the splitting on a specific clause
C = {u1 , . . . , us }. The idea behind it is that we want to check as few assignments as necessary, covering all possibilities for finding a satisfying one, while
fixing as many variables as possible. Let us suppose that C is contained in
a formula F , but locally C is the only information we use to decide on the
splitting that we take.
The first idea could be to make a splitting that sets exactly one of the s
literals to true in each of the branches. But then we notice that we are
checking for certain assignments several times. Suppose we use α1 = (u1 )
and α2 = (u2 ) for two of the branches, and further suppose that there is a
satisfying assignment which sets both u1 and u2 to true. Then, in both of the
branches we would find that assignment, because α1 as well as α2 partially
agree with the satisfying assignment. This leads us to the following idea. If
we have already checked all the satisfying assignments that set u1 to true in
one branch, then we can safely set u1 to false in the second branch, and use
α2′ = (u1 , u2 ) instead of α2 . Extending this idea to clauses of length s gives
us the following splitting.
Procedure Split(F ,C)
input : CNF-formula F , clause C ∈ F , |C| ≥ 2
output: Splitting S
1
2
3
4
5
6
let C = {u1 , . . . , us };
α1 ← (u1 );
for i = 2 to s do
αi ← (u1 , . . . , ui−1 , ui );
end
return S = F [α1 ] , . . . , F [αs ] ;
Lemma 4.2. Let F be a CNF-formula,
and let C = {u1 , . . . , us } ∈ F , s ≥ 2,
be a clause of F . Then S = F [u1 ] , F [u1 ,u2 ] , . . . , F [u1 ,...,us−1 ,us ] is a splitting
with respect to W
the measures µ(F ) ∈ {n(F ), m(F ), ℓ(F )}, using the function
g(f1 , . . . , fs ) = si=1 fi .
Proof. Recall Definition 2.16.
(i) Given the clause C, we can compute all the involved assignments in O(s2 ).
Since the length of a clause is bounded by ℓ(F ), it follows that s is bounded
58
CHAPTER 4. SPLITTING RULES
by ℓ(F ). Note that in a k-CNF formula s would even be bounded by k. Once
we have the assignments, we can therefore compute the restrictions of F in
at most O(ℓ(F )2 · ℓ(F )) ⊆ O( poly(ℓ(F )) ) time steps.
(ii) A satisfying assignment α of F agrees with exactly one of the assignments
αi , because all of the different assignments on the variables in vbl(C) (except
one) are covered by the branches of the splitting. The only assignment that is
not covered is α′ = (u1 , . . . , us ) which does not satisfy C and therefore cannot
be a satisfying assignment. Consequently, if we assume the correctness of
the recursive call, then α will be found in one of the branches, and therefore
g(f1 , . . . , fs ) will be true.
On the other hand, if one of the fi is true, then the satisfying assignment for
that subproblem together with αi will satisfy F .
(iii) For µ(F ) := n(F ) the condition is satisfied, because in each branch we
are eliminating at least one variable. In fact, we get a (1, . . . , s)-splitting.
For µ(F ) ∈ {m(F ), ℓ(F )} note that the clause C is eliminated in all the
branches. Therefore, the number of clauses m is reduced by at least 1, and
and the length of the formula ℓ is reduced by at least s.
4.3. SPLITTING BY THE CONFLICT GRAPH
4.3
59
Splitting by the conflict graph
If we look at the conflict graph GF of a Boolean formula F (see Definition
2.22), then we can identify some cases in which we can find good splittings.
We have not been able yet to completely dissect the structure of GF in
order to provide a good splitting for every possible case, but we describe a
particularly interesting one here.
It should be pointed out once again that, if we speak of a conflict graph here,
then we do allow multiple edges between clauses, that conflict on more than
one literal. If, on the other hand, we speak of the simple conflict graph, then
multiple edges are not allowed. We get the following easy lemma.
Lemma 4.3. Let F be a Boolean CNF-formula and GF its conflict graph.
Let us suppose that GF contains a leaf with label C ∈ F . If C is a unit clause
{u}, then
SAT
F ≡ F [u] .
If C = {u1 , . . . , uk }, k ≥ 2, let us assume without loss of generality that u1
is the conflicting literal. Then,
SAT
F ≡ F [u2 ,...,uk ] .
Both reductions are a simplification S̃(F ) as in Definition 2.18, with respect
to any linear combination of the standard measures n, m, and ℓ with positive
coefficients.
Proof. If |C| = 1 we can apply the unit clause rule, but if |C| ≥ 2, then
u2 , . . . , uk are pure literals, and we can safely set them to ⊤. See Lemma 3.3
and Lemma 3.2 for a complete proof.
The preceding lemma immediately gives us a method to decide the satisfiability of formulae that have a forest as their conflict graph.
Lemma 4.4. Let F be a CNF-formula and GF its conflict graph. If GF is
a forest, then we can decide the satisfiability of F in polynomial time, i.e.
O( poly(ℓ(F )) ).
Proof. We can construct GF and check if it is a forest in O( m(F )2 · ℓ(F ) ).
Let us suppose GF is a forest. We apply Lemma 4.3 to any node that is a
leaf in GF and call the resulting formula F ′ . It is easy to see that GF ′ is still
a forest, because removing any number of nodes or edges from a forest does
60
CHAPTER 4. SPLITTING RULES
not introduce new cycles. We can compute the necessary restriction in at
most O( ℓ(F ) ) steps. Since there are m clauses, we have to apply the lemma
at most m times, and every application takes at most m(F )2 · ℓ(F ) + ℓ(F )2
steps. Since m(F ) ∈ O( ℓ(F ) ), we get an upper bound of O( poly(ℓ(F )) ) on
that algorithm.
What happens if the conflict graph has a tree-like structure, but there are
multiple edges, that are the only reason why it is not cycle-free? This situation is characterised by the fact that the corresponding simple conflict graph
is a forest. Following Definition 2.24, we say that the conflict graph is a
pseudo-forest.
The following lemma is considering a splitting that can be made on the
clause labeling the neighbour of a pseudo-leaf. The situation is depicted in
Figure 4.2. For that purpose we can assume without loss of generality that,
the clause labeling the pseudo-leaf does not contain any pure literal, because
otherwise we could simplify the formula, similar as in the situation of Lemma
4.3, simply by applying the pure literal rule.
^XXX`
^XXXX`
Figure 4.2: Conflict graph for a formula containing a pseudo-leaf
4.3. SPLITTING BY THE CONFLICT GRAPH
61
Lemma 4.5. Let F be a k-CNF formula and GF its conflict graph. Let
us assume that GF contains a pseudo-leaf with label C ∈ F , and its only
neighbour is labeled with C ′ ∈ F . Without loss of generality, assume that
C = {u1 , . . . , ut } and C ′ = {u1 , . . . , us }, s ≥ t ≥ 2. Then,
S = { F [u1 ,u2 ,...,ut ] , F [u1 ,u2 ,u3 ,...,ut ] , . . . , F [u1 ,...,ut−1 ,ut ] ,
F [u1 ,...,ut ,ut+1 ] , . . . , F [u1 ,...,us−1 ,us ] },
is a splitting with respectWto the standard measures n, m, and ℓ, using the
function g(f1 , . . . , fs ) := si=1 fi .
Proof.
(i) We can find a pseudo-leaf in the conflict graph GF in O( m(F ) · ℓ(F ) ) ⊆
O( ℓ(F )2 ) time steps. Then, we can compute the assignments needed for
the splitting in time O(s2 ). Since s is bounded by the maximum length of
a clause in F , we get that O(s2 ) ⊆ O( k(F )2 ) ⊆ O( ℓ(F )2 ). Finally, we can
apply the assignments computed to F in O( s · ℓ(F )2 ). Therefore, the total
running time can be upper bounded by O( s · poly(ℓ(F )) ).
(ii) Suppose that we split on the clause C as in Lemma 4.2, and that we have
α1 , . . . , αs as those assignments that are used to compute the subproblems.
We have already proved that this splitting is correct with respect to the
measures µ(F ) ∈ {n(F ), m(F ), ℓ(F )}. Now consider the following argument.
After the application of any of these assignments αi , 1 ≤ i ≤ s, the clause C ′
has become isolated in the conflict graph GF [αi ] . This is because the clause C
disappears, and it was the only neighbour of C ′ . Therefore, all the remaining
literals in C ′ have become pure literals. According to the pure literal rule,
those can be eliminated as well. We modify the assignments α1 , . . . , αt , such
that αi′ , 1 ≤ i ≤ t, is equal to (αi , ui+1 , . . . , ut ).
(iii) Same as with condition (ii), the correctness follows from Lemma 4.2
(splitting on a clause) and Lemma 3.2 (pure literal rule).
Remark 4.3.1. The only difference to the normal splitting on a clause in
Lemma 4.2 is that in the first t branches we can always eliminate t variables,
instead of one in the first branch, two in the second, and so on.
⊡
62
CHAPTER 4. SPLITTING RULES
4.4
Splitting by almost satisfiable formulae
Almost satisfiable formulae are CNF-formulae that are unsatisfiable, but
deleting any of the clauses makes them satisfiable. Obviously, if an almost
satisfiable formula is a subset of the formula F that we have to decide the
satisfiability for, then we can conclude that F is not satisfiable. However, if
we only find a subset of the almost satisfiable formula, then we can use this
to generate good splittings. Let us first make the formal definition.
Definition 4.6. An almost satisfiable formula is a CNF-formula F , such
that the following two conditions hold,
(i) F is unsatisfiable,
(ii) F \ {C} is satisfiable for any C ∈ F .
Lemma 4.7. Let F be an almost satisfiable formula. Then, the following
three properties are equivalent,
(i)
X
2−ℓ(C) = 1,
C∈F
(ii) Every total assignment on the variables in vbl(F ) satisfies all but one
clause in F ,
(iii) Every pair of clauses C, D ∈ F shares a complementary literal, without
loss of generality u ∈ C and u ∈ D.
Proof.
P
(i) ⇒ (ii) The sum C∈F 2−ℓ(C) is the expected number of unsatisfied clauses
in a random assignment on the variables in vbl(F ). Since F is unsatisfiable,
the number of unsatisfied clauses cannot be 0. Therefore, the number of
unsatisfied clauses is exactly 1 always.
(ii) ⇒ (i) Since every total assignment leaves exactly one clause unsatisfied,
the expected number of unsatisfied clauses is 1, and (i) follows.
(iii) ⇒ (ii) If every pair of clauses contains a complementary pair of literals
u, u, then every assignment satisfies at least one of the two clauses. Hence,
4.4. SPLITTING BY ALMOST SATISFIABLE FORMULAE
63
under the presumption of (iii) there can be at most one unsatisfied clause.
Since F is unsatisfiable, there is a least one unsatisfied clause. Therefore, the
number of unsatisfied clauses is exactly 1.
(ii) ⇒ (iii) Suppose that there is a pair of clauses C and D that does
not contain a complementary pair of literals. Let the assignment α be an
assignment that maps every literal in C ∪ D to ⊥, and the other variables
from vbl(F )\vbl(C ∪ D) arbitrarily. Then, α does neither satisfy the clause
C nor the clause D, which contradicts the statement of (ii). Therefore, (iii)
follows.
We have already pointed out that, if there is a subset of F that is an almost
satisfiable formula, then F is unsatisfiable. We can also make a slightly
stronger statement in terms of the simple conflict graph GF .
Lemma 4.8. Let F be a k-CNF formula, and GF its simple conflict graph.
If GF contains a complete graph with 2k nodes, i.e. the graph K2k , then F is
unsatisfiable.
Proof. Let F ′ ⊆ F be the 2k clauses that are the node labels of the K2k
subgraph of GF . Since every pair of clauses from F ′ contains complementary
literals, every total assignment on the variables in vbl(F ′ ) satisfies at least
one of the two clauses. Additionally, note that vbl(F ′ ) ⊆ vbl(F ). Therefore,
every total assignment for F can leave at most one clause from F ′ unsatisfied.
Now, the expected number of clauses not satisfied in F ′ is,
k
X
C∈F ′
2−ℓ(C) ≥
2
X
2−k = 1.
i=1
This tells us that the number of unsatisfied clauses in F ′ is exactly 1 in every
total assignment on the variables in vbl(F ). It follows that F is unsatisfiable,
because F ′ ⊆ F .
Lemma 4.9. Let F be a k-CNF formula, and GF its simple conflict graph.
Let F ′ ⊆ F be a set of clauses with |F ′ | = 2k − 1, such that the nodes
labeled with the clauses in F ′ form a complete graph, i.e. K2k −1 . If we can
find a non-empty k-clause C in time O( poly(ℓ(F )) ), such that F ′ ∧ C is an
almost satisfiable formula, then {F [C] } is a trivial splitting with respect to the
standard measures n, m, and ℓ.
64
CHAPTER 4. SPLITTING RULES
Proof.
(i) Computing the conflict graph and identifying the complete subgraph can
be upper bounded by O( m(F )2 · ℓ(F ) ) (not necessarily tight). The clause
C can be found in time O( poly(ℓ(F )) ) by assumption, and applying the
restriction to F takes at most O( k · ℓ(F ) ) ⊆ O( ℓ(F )2 ) time steps. Therefore
the whole computation can be upper bounded by O( poly(ℓ(F )) ).
(ii) The formulae F and F [C] are satisfiability-equivalent because of the definition of almost satisfiable formulae. Since F ′ ∧ C is such a formula, the
only way of satisfying all the clauses in F ′ is by assigning ⊥ to all the variables in C. Since F ′ has to be satisfied in order to satisfy F , it follows that
SAT
F ≡ F [C] .
(iii) Since C is not empty, we eliminate at least one variable. Applying the
restriction also eliminates all the clauses in F ′ from F . Therefore n, m, and
ℓ are all reduced by at least 1.
4.5. SPLITTING BY MAJORITY SETS
4.5
65
Splitting by majority sets
In this section we are going to describe a method to automatically find good
splittings. From Lemma 2.33 we know that, given a constant number of
splittings, we can efficiently decide which one gives the best splitting number.
The question is, how are we going to find candidates for splittings. The
following method is due to Alexander Kulikov (see [27]), where it is used to
generate new simplification rules. First we make some definitions.
Definition 4.10. We define an open clause, Ĉ := {u1 , . . . , uk , ∝}, to be a
clause that contains the symbol ∝. The special symbol ∝ indicates that the
open clause may additionally contain some literals that are not known yet.
For any clause C (not necessarily open), we define close(C) := C\ {∝} to be
the closed clause of fixed length, containing the same literals as C without
the optional ∝.
For an open clause Ĉ we redefine the set of variables occurring in Ĉ as,
vbl(Ĉ) := vbl(close(Ĉ)).
The length of the clause is the following,
ℓ(Ĉ) := |close(Ĉ)|.
Definition 4.11. We define an open formula, F̂ := {C1 , . . . , Cm , ∝}, to be a
CNF-formula containing the symbol ∝. The symbol ∝ indicates that the open
formula may additionally contain some clauses that are not known yet, but
it must not contain any of the variables occurring in the clauses C1 , . . . , Cm .
Any of the clauses C ∈ F̂ may be an open clause.
The base of an open formula F̂ is defined to be, base(F̂ ) := F̂ \ {∝}, the set
of clauses contained in F̂ .
For a CNF-formula F (not necessarily open), we define the closed formula,
close(F ) := {close(C) | C ∈ base(F )}, to be the formula of fixed length without the optional ∝, only containing closed clauses.
We redefine the following in the context of an open formula F̂ .
vbl(F̂ ) := vbl(close(F̂ )),
m(F̂ ) := |base(F̂ )|,
ℓ(F̂ ) := ℓ(base(F̂ )).
66
CHAPTER 4. SPLITTING RULES
Example 4.5.1. Consider the open formula,
F̂ = { {u, v, w} , {v, w, ∝} , {u, v, w, ∝} , ∝ } .
It consists of one closed clause, two open clauses, and the symbol ∝.
The base of F̂ is the following,
base(F̂ ) = { {u, v, w} , {v, w, ∝} , {u, v, w, ∝} } ,
still containing all the open clauses, but not the ∝ sign.
On the other hand, if we close the formula F̂ , we get,
close(F̂ ) = { {u, v, w} , {v, w} , {u, v, w} } .
Finally,
we have vbl(F̂ ) = {u, v, w}, m(F̂ ) = 3, and ℓ(F̂ ) = ℓ(base(F̂ )) =
P
⊡
C∈base(F̂ ) |close(C)| = 8.
Remark 4.5.1. Note that in an open formula it is allowed to have several
identical open clauses. In particular, also the base of an open formula may
contain duplicate clauses. This could be made formal by introducing diverse
symbols for ∝, i.e. one for every occurrence, but since the point is not of
major importance, we hope that the reader feels comfortable with omitting
this notational overhead.
⊡
Definition 4.12. Let F be a closed CNF-formula, V = vbl(F ), and S ⊆ V .
We define the prototype of the formula F , with respect to the set of variables
S, to be the following open formula F̂ ,
proto(F, S) :=
{(C\lit(V \S)) ∪ {∝} | C ∈ F, C 6= C ∩ lit(S) 6= ∅}
∪ {C | C ∈ F, C = C ∩ lit(S)}
∪ {∝} .
Intuitively speaking, in every clause of F we replace all the literals that are
not derived from a variable in S by a single ∝. Those clauses that solely
consist of literals from lit(S) are adopted without change. Finally, we also
add a ∝ on the formula level to account for the possibly lost clauses (those
that do not contain any literal from lit(S)).
4.5. SPLITTING BY MAJORITY SETS
67
Definition 4.13. Let V be a set of variables, Ĉ an open clause with vbl(Ĉ) ⊆
′
V , and F̂ = {C1′ , . . . , Cm
′ } an open formula with vbl(F̂ ) ⊆ V .
We define the class of clauses CĈ to be the set of closed clauses C ∈ CĈ with
close(Ĉ) ⊆ C ⊆ lit(V ). It is the set of clauses that we get if we replace the
∝∈ Ĉ by an arbitrary choice of literals from lit(V ).
We define the class of formulae FF̂ to be the set of closed formulae F ∈ FF̂ ,
where F = {C1 , . . . , Cm } meets the following conditions,
(i) m ≥ m′ ,
(ii) for 1 ≤ i ≤ m′ , Ci ∈ CCi′ if Ci′ is an open clause, Ci = Ci′ otherwise,
(iii) for m′ + 1 ≤ i ≤ m, vbl(Ci ) ∩ vbl(F̂ ) = ∅.
Without loss of generality we can assume that the clauses in F ∈ FF̂ and F̂
are ordered in the same way, i.e. for 1 ≤ i ≤ m′ the clause Ci ∈ F can be
obtained from Ci′ ∈ F̂ by replacing the ∝ by some literals from lit(V ), or it
holds that Ci = Ci′ if Ci′ is not an open clause. This is just what condition
(ii) in the above definition states. We use this to define the following,
map(Ci′ , F, F ′ ) := Ci ,
map(F, F ′ )
:= {C1 , . . . , Cm′ } ,
which takes us from the prototype clauses in F̂ to the corresponding realisation
of a closed clause in the formula F .
Definition 4.14. In the context of open formulae we also redefine the meaning of the restriction of a formula. Let F̂ be a Boolean formula (open or
closed), and let V = vbl(F̂ ). Let α be an assignment on all the variables in
V . We only consider assignments on all known variables of F̂ . When we
apply α to F̂ , still written as F̂ [α] , then we replace all the literals by ⊤ or ⊥
respectively, according to α. All the symbols ∝ are replaced by the additional
truth value ⊤
⊥, that indicates that a definite truth value cannot be attributed
to that part of the formula yet.
Since we are only considering total assignments, no literals will be left in the
formula, and the following replacement rules suffice to reduce the formula to
a single (operator-free) truth value,
⊥∨⊤
⊥≡⊤
⊥, ⊥ ∧ ⊤
⊥ ≡ ⊥,
⊤∨⊤
⊥ ≡ ⊤, ⊤ ∧ ⊤
⊥≡⊤
⊥.
68
CHAPTER 4. SPLITTING RULES
Definition 4.15 (Kulikov, [27]). Let F̂ be an open formula, and V = vbl(F̂ ).
Let α1 and α2 be two total assignments on the variables in V . We define a
relation on the set of all assignments on the variables in V as follows. We
say that α1 is stronger that α2 with respect to the class of formulae FF̂ , and
write α1 ≻FF̂ α2 , if for every formula F ∈ FF̂ and for each assignment β on
all variables of F the following condition holds: if α2 ⊆ β, then β satisfies
not more clauses of F than the assignment (β\α2 ) ∪ α1 .
Lemma 4.16 (Kulikov, [27]). Let F̂ be an open CNF-formula, and let α1
and α2 be two total assignments on the variables in vbl(F̂ ). Furthermore, let
F ∈ FF̂ be a formula on the set V of variables, vbl(F̂ ) ⊆ V ; and let β be a
total assignment on the variables in V , such that α2 ⊆ β. Then,
(i) For any clause C ∈ F \map(F, F̂ ) it holds that C [β] = C [(β\α2 )∪α1 ] .
(ii) For any clause C, if C [α1 ] ≡ ⊤ (or ⊥), then for any assignment α, such
that α1 ⊂ α, it holds that C [α] ≡ ⊤ (⊥ respectively).
(iii) For any clause C ∈ F̂ , if C [α1 ] ≡ C [α2 ] ≡ ⊤
⊥, then C ′[(β\α2 )∪α1 ] = C ′[β] ,
where C ′ = map(C, F, F̂ ).
Proof.
(i) From Definition 4.13 (iii) we know that α1 and α2 do not map any variable
from vbl(F \map(F, F̂ )). Therefore, C [β] = C [β\α2 ] = C [(β\α2 )∪α1 ] .
(ii) If C [α1 ] ≡ ⊤, then α1 must share a common literal with C. Since α1 ⊂ α,
the assignment α does contain this literal as well, and therefore C [α] ≡ ⊤. On
the other hand, if C [α1 ] ≡ ⊥, then α1 must map all the variables in vbl(C) to
⊥. Also, C must be a closed clause, because otherwise C [α1 ] ≡ ⊥ ∨ ⊤
⊥≡⊤
⊥.
Since α1 ⊂ α, the assignment α does map all the variables to ⊥ too, and
therefore C [α] ≡ ⊥.
(iii) Since C [α1 ] ≡ C [α2 ] ≡ ⊤
⊥, we know that both α1 and α2 map all the
variables in vbl(C) to ⊥, and that C is an open clause. Because of Definition
4.13 (iii), we know that α1 and α2 do not map any variable from vbl(C ′ \C).
Therefore, we can replace the literals of α2 by those of α1 in the assignment
β, not changing the restriction of C ′ , i.e. C ′[β] = C ′[(β\α2 )∪α1 ] .
4.5. SPLITTING BY MAJORITY SETS
69
Theorem 4.17 (Kulikov, [27]). Let F̂ be an open CNF-formula, and let α1
and α2 be total assignments on the variables in vbl(F̂ ). Furthermore, let
p1 := |{C ∈ F̂ | C [α1 ] ≡ ⊤}|,
p2 := |{C ∈ F̂ | C [α2 ] ≡ ⊤}|,
q := |{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] 6≡ ⊤
⊥}|.
Then, α1 ≻FF̂ α2 if and only if p1 ≥ p2 + q.
Proof. To prove the forward direction, consider a formula F ∈ FF̂ and an
assignment β to all the variables in vbl(F ), such that α2 ⊂ β. Then the
required statement follows from the following inequalities.
(1)
|{C ∈ F | C [(β\α2 )∪α1 ] ≡ ⊤}| − |{C ∈ F | C [β] ≡ ⊤}|
= |{C ∈ map(F, F̂ ) | C [(β\α2 )∪α1 ] ≡ ⊤}| −
(2)
|{C ∈ map(F, F̂ ) | C [β] ≡ ⊤}|
= p1 + |{C ∈ F̂ | C [α1 ] ≡ ⊤
⊥, map(C, F, F̂)[(β\α2 )∪α1 ] ≡ ⊤}| −
(3)
p2 − |{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, map(C, F, F̂)[β] ≡ ⊤}|
= p1 + |{C ∈ F̂ | C [α1 ] ≡ ⊤
⊥, C[α2 ] 6≡ ⊤
⊥, map(C, F, F̂)[β] ≡ ⊤}| −
(4)
p2 − |{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] 6≡ ⊤
⊥, map(C, F, F̂)[β] ≡ ⊤}|
≥ p1 − p2 − |{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] 6≡ ⊤
⊥}|
(5)
= p1 − p2 − q
(6)
≥ 0
The equalities (1), (2), and (3) follow from Lemma 4.16 (i), (ii), and (iii)
respectively. The inequality (4) follows, because we drop one positive term,
and we drop one condition in the last term, which is negative. The equality
(5) is just replacing the definition of q, and finally, the inequality (6) follows,
because α1 ≻FF̂ α2 , which is the assumption in the forward direction of the
proof.
To prove the backward direction of the theorem, let F ∈ FF̂ and β be an
assignment over all variables in vbl(F ), with α2 ⊆ β. Let #(F, β) be the
number of clauses in F satisfied by β. Of course, we assume that p1 ≥ p2 + q.
70
CHAPTER 4. SPLITTING RULES
Then, we can make the following estimation,
(1)
#(F, β) ≤ p2 + q +
|{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] ≡ ⊤
⊥, map(C, F, F̂)[β] ≡ ⊤}| +
(2)
|{C ∈ F \map(F, F̂ ) | C [β] ≡ ⊤}|
= p2 + q +
|{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] ≡ ⊤
⊥, map(C, F, F̂)[(β\α2 )∪α1 ] ≡ ⊤}| +
(3)
|{C ∈ F \map(F, F̂ ) | C [β] ≡ ⊤}|
= p2 + q +
|{C ∈ F̂ | C [α2 ] ≡ ⊤
⊥, C[α1 ] ≡ ⊤
⊥, map(C, F, F̂)[(β\α2 )∪α1 ] ≡ ⊤}| +
(4)
|{C ∈ F \map(F, F̂ ) | C [(β\α2 )∪α1 ] ≡ ⊤}|
≤ p1 +
|{C ∈ F̂ | C [α1 ] ≡ ⊤
⊥, map(C, F, F̂)[(β\α2 )∪α1 ] ≡ ⊤}| +
(5)
|{C ∈ F \map(F, F̂ ) | C [(β\α2 )∪α1 ] ≡ ⊤}|
= #(F, (β\α2 ) ∪ α1 ).
The inequality (1) follows, because α2 might satisfy that much clauses in
F . The third term are those clauses of F̂ that are not accounted for in
p1 + q, and the fourth term are those clauses that do not appear in F̂ at all.
The equality (2) follows directly from Lemma 4.16 (iii). The equality (3)
follows from Lemma 4.16 (i). The inequality (4) follows from our assumption
p1 ≥ p2 + q, and because we drop one of the conditions in the third term.
Finally, this is just the number of clauses in F that are satisfied by the
assignment (β\α2 )∪α1 . We get that #(F, β) ≤ #(F, (β\α2 )∪α1 ). Therefore,
it follows that α1 ≻FF̂ α2 .
Theorem 4.17 gives us an easy way of checking whether an assignment α1
is stronger than α2 with respect to FF̂ without actually considering all the
formulae in FF̂ . After all this set is infinite. Now we are ready to define the
notion of a majority set.
Definition 4.18 (Kulikov, [27]). Let FF̂ be a class of formulae, and M0
the set of all possible assignments on the variables in vbl(F̂ ). We define
M ⊆ M0 to be majority set for FF̂ , if for all assignments α0 ∈ M0 there
exists an assignment α ∈ M , such that α ≻FF̂ α0 .
4.5. SPLITTING BY MAJORITY SETS
71
Remark 4.5.2. For a class of formulae FF̂ the definition of majority set
is not unique, and in particular, the set of all assignments to vbl(F̂ ) is a
majority set too.
⊡
The following algorithm is a greedy method of constructing a majority set.
It calculates all possible assignments on all the variables of F̂ . Then, in lines
3 to 6, it successively adds assignments to the majority set M . It chooses an
assignment α that is strongest in the sense that it is stronger than as many
assignments as possible from the remaining set of assignments M0 . In line 6,
it then removes α and all those assignments that are dominated by α from
the set M0 .
Algorithm 5: GreedyMajoritySet(F̂ )
input : Open CNF-formula F̂
output: Majority Set M for FF̂
1
2
3
4
5
6
7
8
M ← ∅;
M0 ← All total assignments on the variables in vbl(F̂ );
while M0 6= ∅ do
α ← Assignment in M0 such that |{α0 ∈ M0 | α ≻FF̂ α0 }| is maximal;
M ← M ∪ {α};
M0 ← M0 \({α0 ∈ M0 | α ≻FF̂ α0 } ∪ {α});
end
return M ;
Lemma 4.19. The procedure GreedyMajoritySet computes a majority
set for F̂ in running time O( 4n · poly(ℓ(F̂ )) ), where n is the number of
variables in vbl(F̂ ).
Proof. The algorithm indeed terminates, because in line 4 it always chooses
an assignment α ∈ M0 , and subsequently removes it from M0 . Therefore,
|M0 | is reduced by at least 1 in each repetition of the while loop.
The set M is indeed a majority set, because in line 6 we only discard assignments that are either added to M , or that are dominated by the assignment
α in the sense that α is stronger than those assignments discarded. Since
we are considering the set of all possible assignments, the correctness of the
construction of a majority set follows.
The running time can be proved as follows. Let n be the number of variables
in F̂ , i.e. n(F̂ ). There are 2n possible assignments. For each one we need to
72
CHAPTER 4. SPLITTING RULES
check if it is stronger than any of the other assignments in M0 . From Theorem
4.17 it follows that, given the two assignments, this check can be done in
time O( n · ℓ(F̂ ) ), simply by applying the assignments, and computing and
comparing the parameters p1 , p2 , and q. We can compute the 2n assignments
in time O( 2n · n ) and we can do the cross-check in time O( 2n · 2n · n · ℓ(F̂ ) ).
Since n ∈ O( ℓ(F̂ ) ), it follows that the total running time can be bounded
by the sum of the preceding two, which amounts to O( 4n · poly(ℓ(F̂ )) ).
Of course, when considering majority sets on all variables of a formula F ,
then the running time for constructing such a majority set is devastatingly
high, but the idea is to bound the number of variables for which we compute
the majority set by a constant. Bearing this in mind, we formulate the main
theorem of this section.
Theorem 4.20. Let F be a closed CNF-formula, and let S ⊆ vbl(F ), such
that |S| ≤ c ∈ N, where c is a constant. Furthermore let,
{α1 , . . . , αs } = GreedyMajoritySet( proto(F, S) ),
be the majority set returned by the call to the algorithm GreedyMajoritySet. Then, the splitting
S = F [α1 ] , . . . , F [αs ]
is correct with respect to n(F ).
Proof . We have to show that the three conditions of Definition 2.16 are
fulfilled.
(i) For computing the prototype of F with respect to S we need O( c · ℓ(F ) )
time steps. For the construction of the majority set, according to Lemma
4.19, we need O( 4c · poly(ℓ(F̂ )) ) ⊆ O( 4c · poly(ℓ(F )) ) time steps. Finally,
once we have got the majority set, the restrictions of F by the assignments in
the majority set can be done in O( s · c · ℓ(F ) ). Summing up, if we regard c as
a small constant, we get a total running time bounded by O( s · poly(ℓ(F )) )
as required by the definition of a splitting. Note that s is also bounded by a
constant, because s ∈ O(2c ).
W
(ii) This condition is fulfilled with g(f1 , . . . , fs ) := si=1 fi , because of the
definition of a majority set. For every assignment α on the variables of S
which is not in the majority set, and for every extension of α to a total
assignment on the variables of F , there is a member of the majority set with
the property that the same extension to a total assignment satisfies at least
4.5. SPLITTING BY MAJORITY SETS
73
as many clauses. In particular, if there is a satisfying assignment of F that
uses the same mapping of the variables in S as α, then there is another
satisfying assignment that uses the mapping on the variables in S of one of
the members of the majority set instead. Note that the function g can be
computed in O(s) time steps.
(iii) Every assignment of the majority set maps exactly c variables. Therefore, this condition is easily satisfied. We get the c · ~1s splitting tuple. Using
1
Lemma 2.29, we calculate τ (c · ~1s ) = s c .
Let us now make a longer example, that allows you to see the workings of
the ideas described in this section.
Example 4.5.2. On the set of variables V = {u, v, w1 , w2 }, consider the
following CNF-formula,
F = { {u, v, w2 } , {u, w1 } , {u, v, w1 , w2 } , {v} , {w1 } } .
Let us forget for now that we could apply the unit clause simplification rule
to F . Then, the best splitting that we know of is splitting on one of the 2clauses, which would give us a (1, 2)-splitting with respect to n. This would
result in a splitting number τ (1, 2) ≈ 1.618. Let us see if we can do better by
the application of majority sets. The first thing we have to do is to compute
a prototype with respect to a certain subset of variables. We could try out
all the subsets of size two, but let us just assume that some oracle told us
that S = {u, v} would be a good idea. We get the following prototype,
F̂ = proto(F, S) = { {u, v, ∝} , {u, ∝} , {u, v, ∝} , {v} , ∝ } .
Now, we call the algorithm for the majority set construction with F̂ as input. Let α1 = (u, v), α2 = (u, v), α3 = (u, v), and α4 = (u, v) be all the
assignments on the variables in S.
In order to follow the execution of GreedyMajoritySet(F̂ ), consider the
following table, which gives the parameter p1 − p2 − q for every possible
pairing of the assignments involved.
p1 − p2 − q
α1
α2
α3
α4
α1 α2 α3 α4
0 −2 −1 −2
1
0
1
0
−1 0
0 −1
−1 0
0
0
74
CHAPTER 4. SPLITTING RULES
From this table we can read out whether an assignment on the vertical axis
is stronger than an assignment on the horizontal axis. For example, if we
want to know whether α2 ≻FF̂ α3 , then we just check the entry in the second
row and third column, and find that it is 1. Since p1 − p2 − q ≥ 0 it follows
indeed that α2 is stronger than α3 . If an entry is less than zero, it follows
that a respective statement cannot be made. Note that on the diagonal we
get zero entries, because every assignment is stronger than itself.
Remember that the algorithm for majority set construction will first add the
assignment that dominates as many of the other assignments as possible. In
the second row we find that α2 is stronger than all the other assignments, and
since no other assignment achieves that count, it will be the first assignment
added to the majority set. This also means that all the other assignments
can be disregarded, because they are already dominated by an assignment in
the majority set. The execution of GreedyMajoritySet(F̂ ) terminates,
and M = {α2 } is returned.
To see what effect the application of α1 , . . . , α4 would have on the formula
F , consider the following restrictions,
F [α1 ]
F [α2 ]
F [α3 ]
F [α4 ]
=
=
=
=
{ {w1 , w2 } , , {w1 } }
{ {w1 } }
{ {w1 } , , {w1 } }
{ {w2 } , {w1 } , {w1 } } .
By Theorem 4.17 we can just apply the splitting S = F [α2 ] , because α2
is the only member of the majority set M . The correctness of this splitting
is given by the theorem, but intuitively, in the listing above it can already
be seen, that all the other restrictions result in an unsatisfiable formula. So,
including them in the splitting would only have increased the computing
time needed to decide the satisfiability of F . Note that it is not necessarily
the case though that all the restrictions by assignments that are not in the
majority set result in an unsatisfiable formula.
This provides us with a fabulous (2)-splitting, that has the optimal splitting
number of 1. This is certainly better than splitting on a 2-clause.
⊡
Chapter 5
Algorithm by Monien &
Speckenmeyer
Monien and Speckenmeyer presented an algorithm for k-SAT in 1985 (see
[31]). They proved a time complexity of O∗ (an ), where a is the biggest real
number satisfying the equation
a = 2 − 1/ak−1 .
(5.1)
For 3-SAT this results in a running time bounded by O∗ (1.6181n ). We will
formulate the algorithm in our general splitting framework, and, by different
means, show the same complexity result.
5.1
The prerequisites
The algorithm which we will describe in this section is based upon splitting
on a clause, see Section 4.2, and there Lemma 4.2 in particular. We first
state the general structure of the algorithm and then recall the splitting.
The structure of this algorithm is exactly the same as the algorithm SSAT.
The only thing that changes is that we now call the procedures SimplifyM S
and SplitM S , that are specific for this algorithm.
The basic splitting that we are going to use works as follows. Let F be a
k-CNF formula on n variables, and C = {u1 , . . . , us } ∈ F , s ≤ k, a clause in
F . We will split F into s formulae,
S(F ) = {F1 , . . . , Fs } = F [u1 ] , F [u1 ,u2 ] , . . . , F [u1 ,...,us−1 ,us ] .
75
76
CHAPTER 5. ALGORITHM BY MONIEN & SPECKENMEYER
Algorithm 6: MS(F )
input : CNF-formula F
output: satisfiable or unsatisfiable
1
2
3
4
5
F ′ ← SimplifyM S (F );
if F ′ = {} then return satisfiable;
if ∈ F ′ then return unsatisfiable;
{F1 , . . . , Fs } ← SplitM S (F ′ );
return g( MS(F1 ), . . . , MS(Fs ) );
It has been proven in Lemma 4.2 that this splitting is correct.
We are going to use the number of variables as the measure for the formula
F , i.e. µ(F ) := n(F ). If we use the simple splitting procedure Split(F, C)
for any clause C ∈ F , then the analysis reveals that this algorithm has
a maximum splitting number τmax = τ (1, . . . , k), because the worst case
consists of a formula F that has only k-clauses. For 3-SAT this would result
in a maximum splitting number τmax ≈ 1.839. This is not good enough to
meet the running time that was proved in the original paper. We will need
to do some additional work.
In order to achieve a better running time for our k-SAT algorithm we need
the notion of autark assignments. Autark assignments are such that they
satisfy any clause that contains literals being mapped by the assignment.
Autarky has been formally defined in Definition 3.4.
The importance of the notion autark for our approach is based upon the
following lemma.
Lemma 5.1. Let F be a CNF-formula, and W ⊆ vbl(F ). If the truth
assignment α : W → {⊤, ⊥} is autark in F , then the restriction of F by the
assignment α is a subset of F , i.e.
α autark in F ⇒ F [α] ⊆ F.
Proof. If α is autark in F , then all clauses C ∈ F with vbl(C) ∩ W 6= ∅ are
simultaneously satisfied by α without having fixed any of the variables not
in W . That means, there are only clauses in F [α] that are either satisfied or
untouched by α. The implication of the lemma follows.
5.1. THE PREREQUISITES
77
Remark 5.1.1. Note that the converse is not necessarily true.
α autark in F 6⇐ F [α] ⊆ F.
Consider the simple formula F = { {u, v} , {u, v, w} } and the assignment
α = (w). Clearly, F [α] = { {u, v} } is a subset of F , but it is as obvious that
α is not autark in F , because the clause {u, v, w} is not satisfied by it.
This anomaly arises from the fact that we do not allow duplicate clauses in
a formula. If we did, or if we insisted on the absence of subsumed clauses
(see Section 3.1), the converse of the above lemma would indeed be true. ⊡
Lemma 5.2. Let F be a CNF-formula and α an assignment. If α is not
autark in F , then in F [α] there exists at least one new, short clause (< k).
In more formal terms we can write,
∃C ∈ F [α] : C ∈
/ F and |C| < k(F ).
Proof. If α is not autark in F , then there is a clause C ∈ F such that
vbl(C) ∩ W 6= ∅ and C [α] is not satisfied. Thus, F [α] contains the clause
C ′ = C [α] , and |C ′ | < |C|.
Remark 5.1.2. Consider the formula F = { {u, v} , {w1 , w2 , w3 } } and the
assignment α = (u, v). Clearly, α is not autark, because it does not satisfy
the first clause. If we apply α to F we get,
F [α] = { , {w1 , w2 , w3 } } ,
which does not really have a short clause to branch upon. Anyway, since
ℓ() = 0 the Lemma 5.2 is not violated at all, and of course we can conclude
immediately that F [α] is not satisfiable. So, this case will be caught by the
check for a trivial formula.
⊡
To summarise, if we have an autark assignment α at hand, then we can
safely restrict F by α, because all clauses containing a literal mapped by α
evaluate to ⊤ (see also Section 3.4). On the other hand, if we restrict F
′
by an assignment α′ that is not autark in F , then we can be sure in F [α ]
there exists a clause that is strictly shorter than the longest clause of F , i.e.
smaller than k.
78
5.2
CHAPTER 5. ALGORITHM BY MONIEN & SPECKENMEYER
The implementation
The algorithm below works as follows. It chooses any shortest clause in F
and tries to branch on that clause, as in the splitting described above. If any
of the assignments in the splitting is an autark assignment though, then the
algorithm simply calls itself on the restriction of F by α. This is a trivial
splitting with only one child in the search tree.
Note that we only check whether some few given truth assignments are autark, and not if there exists any. The complexity of this test is upper bounded
by O( s · poly(ℓ(F )) ).
We can specify the algorithm MS by implementing the SplitM S procedure.
Procedure SplitM S (F )
input : CNF-formula F
output: Splitting S
1
2
3
4
5
6
7
8
9
10
11
12
S ← ∅;
{u1 , u2 , . . . , us } ← any shortest clause in F;
for i = 1 to s do
α ← (u1 , . . . , ui−1 , ui );
if α is autark
[α] in F then
S← F
;
return S;
else
S ← S ∪ F [α] ;
end
end
return S;
The SimplifyM S procedure is in fact doing nothing, it just returns the same
formula that it has been given as input. We do not list it here. This, of
course, does not mean that an elaborate simplification rule would not reduce
the practical running time, but we do not need it for our worst case analysis.
The correctness of the algorithm follows from Lemma 4.2 and Lemma 3.4.
5.3. THE ANALYSIS
5.3
79
The analysis
The analysis of the algorithm is based on the fact that, when we evaluate
a k-CNF formula, then every proper branching step which is preceded by a
proper branching step leads to at most k − 1 subproblems. Here, a proper
branching step means a splitting S in which no autark assignment was found.
This behaviour is sufficient to guarantee the claimed bound.
Let F be a k-CNF formula. If S is a proper splitting, i.e. s > 1, then we
know that all the subproblems Fi generated by the call SplitM S (F ) contain
a clause C ∈ Fi with |C| < k (see Lemma 5.2).
Before we proceed towards the running time, we need another result about
splitting numbers.
Lemma 5.3. Let ~t′ = (1, . . . , j) and t~∗ = (2, . . . , j +2) be two splitting tuples,
j ≥ 2. Then τ (t~∗ ) < τ (~t′ ).
Proof. We will use Lemma 2.32 for the proof. Consider the splitting tuple
~t = (1, j + 2). We now see that the tuple t~∗ fits the construction instructions
from the two tuples ~t and ~t′ as given in Lemma 2.32, which we can therefore
apply to our case. If we manage to show that τ (~t′ ) > τ (~t ), then we are
done, because from Lemma 2.32 (ii) it follows that τ (~t′ ) > τ (t~∗ ) > τ (~t ) and
therefore τ (t~∗ ) < τ (~t′ ).
We will prove τ (~t′ ) > τ (~t ) by the following argument. We readily calculate
that, if j = 2, then τ (~t′ ) = 1.62 . . . > τ (~t ) = 1.38 . . .. For j > 2 we can
use properties (ii) and (iii) of Lemma 2.31. Property (ii) states that τ (~t ) is
strictly decreasing in j. On the other hand, property (iii) implies that τ (~t′ )
is strictly increasing in j. From this τ (~t′ ) > τ (~t ) follows for all j ≥ 2,
τ (~t′ ) = τ (1, . . . , j) ≥ τ (1, 2) > τ (1, 4) ≥ τ (1, j + 2) = τ (~t )
Theorem 5.4. The splitting algorithm MS decides the satisfiability of any
k-CNF formula F on n variables in P
O∗ (bn ) steps, where b is the greatest
k−2 i
number satisfying the equation bk−1 − i=0
b = 0.
Proof. First we have a look at the different splitting tuples that can occur
in the search tree TMS (F ), because by Theorem 2.30 we know that we can
upper bound the execution time tMS (F ) by O∗ ( τmax (TMS (F ))n ).
80
CHAPTER 5. ALGORITHM BY MONIEN & SPECKENMEYER
There are essentially two cases. Either we find an autark assignment in the
splitting step, then we get a (j)-splitting, for 1 ≤ j ≤ k. Since τ (j) = 1
for j ≥ 1, we do not have to worry about that (recall that τ (~t ) ≥ 1 for any
splitting tuple, so this is already the lowest we can get). In the other case
we do not find an autark assignment. The number of subformulae generated
by the splitting corresponds to the cardinality s of the shortest clause C in
the formula. In general, we get a splitting tuple ~ts = (1, . . . , s), 1 ≤ s ≤
k. According to Lemma 2.31 (iii) τ (~ts ) is maximal when s is maximal, i.e.
for the ~tk tuple. This worst case is not good enough to prove the running
time we conjectured in Theorem 5.4. In fact, our goal will be to show that
τmax (TMS (F )) ≤ τ (~tk−1 ) < τ (~tk ).
Q
)
Q
Q
Q
M)
Figure 5.1: Example of a splitting tree TMS (F ) for a 3-CNF formula F .
In Figure 5.1 you can see the example of a splitting tree as produced by the
splitting algorithm MS running on a 3-CNF formula. In the following we
will write out the proof for the general case, but in the figures we will stick
to k = 3. The node label is the formula at that specific recursive call, but in
the figures it is mostly omitted. There are different symbols for the nodes.
If the node is represented by a full circle, then this corresponds to the fact
81
5.3. THE ANALYSIS
that there might only be clauses of length k. That means, we can actually
encounter the worst case, a ~tk splitting tuple, at this node. On the other
hand, if the node is represented by an empty circle, then we are sure that
there exists a clause of length at most k − 1 at this node. We know that
the only place where the worst case (1, . . . , k)-splitting can occur, is the root
node of the search tree, and the nodes that are labeled by a formula that was
produced by an autark assignment. If the formula at the current node was
produced by a proper splitting, then there is at least one clause C ∈ F with
|C| < k, which will provide us with a less costly splitting. We will consider
the situation at the root node at the end of the proof.
Q
Q
)DXWDUND
Q
) >D@
Q
M)
Figure 5.2: Modified splitting tuple for a 3-CNF formula.
For now, suppose that the algorithm MS is processing any node except the
root, and that it is forced to make a (1, . . . , k)-splitting. The situation is
depicted in Figure 5.2. The fact that we are forced to choose a k-clause tells
us that the current node is its parent’s only child, and it has been produced
by an autark assignment. Since we are only interested in the number of
leaves, we can view these successive steps as one, for all matters of analysis.
This is indicated by the dashed lines in Figure 5.2. The preceding autark
82
CHAPTER 5. ALGORITHM BY MONIEN & SPECKENMEYER
step has reduced the number of variables by at least 1. So, we can replace all
combinations of an autark step and a (1, . . . , k)-splitting by a (1 + m, . . . , k +
m)-splitting, where m is the number of variables fixed in the autark step.
Recall that, τ (~t ) is decreasing in any of the elements of ~t, so for the analysis
it suffices to consider m = 1.
Still leaving out the argument about the root node, we have the following
situation:

autark step,
 (j), for 1 ≤ j ≤ k
~t =
(1, . . . , l), for 1 ≤ l ≤ k − 1 branching on short clause,

(2, . . . , k + 1)
modified branching as discussed before.
The first option is a trivial splitting, so τ (~t ) = 1. The second tuple is what
we are actually working towards, namely τ (~tk−1 ). The third choice are the
splitting tuples of the form ~t = (2, . . . , k + 1), that have been discussed
above. They are a combination of an autark step and a branching with k
subproblems. Lemma 5.3 tells us that τ (2, . . . , k + 1) < τ (1, . . . , k − 1).
Therefore, we are done establishing τmax (TMS (F )) ≤ τ (1, . . . , k − 1), for all
nodes in the search tree except for the root node.
Now, consider the root node. First, note that if we do not have a (1, . . . , k)splitting at the root, then we are done. If we do have a (1, . . . , k)-splitting
at the root, then we get the subproblems Fi , that we can solve in tMS (Fi ) ≤
poly(ℓ(Fi )) · τmax (TMS (Fi )) ≤ poly(ℓ(Fi )) · τ (1, . . . , k − 1)|vbl(Fi )| steps each.
Therefore, if we regard k as a constant, the running time on the formula F
can be written as follows:
k
X
tMS (F ) ≤ k · poly(ℓ(F )) +
tMS (Fi )
≤ k · poly(ℓ(F )) +
i=1
k
X
i=1
poly(ℓ(Fi )) · τ (1, . . . , k − 1)n−i
≤ k · poly(ℓ(F )) + k · poly(ℓ(F )) · τ (1, . . . , k − 1)n
∈ O∗ ( τ (1, . . . , k − 1)n )
It remains to show that we have proved the same upper bound for the running
time as in the original paper. What we have got, in the end, is O∗ (bn ), where
b is the only positive number satisfying the equation
b
k−1
−
k−2
X
i=0
bi = 0.
(5.2)
5.3. THE ANALYSIS
83
Now recall Equation (5.1) from the beginning of this chapter, which describes
the original running time. ItP
transforms into ak − 2 · ak−1 + 1 = 0, and subsek−2 i
quently to (a − 1) · (ak−1 − i=0
a ) = 0. That means, from Equation (5.1)
we compute the same solutions as from Equation (5.2), plus an additional
solution at a = 1. Since the biggest real number satisfying Equation (5.1)
is greater than 1, we find that the biggest solution of Equation (5.2) is the
same as the biggest solution of Equation (5.1).
84
CHAPTER 5. ALGORITHM BY MONIEN & SPECKENMEYER
Chapter 6
The 3-SAT Algorithm by Zhang
In a 1995 paper, Zhang presented an algorithm for 3-SAT besides a general
framework for counting the number of satisfying assignments of k-CNF formulae (see [42]). The complexity of this 3-SAT algorithm is O∗ (1.5702n ) =
O∗ (20.6510·n ), which improves on the results of Monien and Speckenmeyer,
and Schiermeyer (see [31],[36]), which have running times of O∗ (1.6181n )
and O∗ (1.579n ) respectively.
6.1
General description
The new idea of the algorithm is that it takes into account the number of 1and 2-clauses. It is, in fact, desirable to have such short clauses, because they
provide good splittings. In trying to achieve that, the algorithm assumes that
the input formula F contains at least one short clause to begin with. This
requires that we ensure the existence of at least one short clause at all times
during the recursive evaluation.
Of course, if we want to take advantage of short clauses in the splitting
step, then we have to be careful about not loosing too many of them in
the simplification step. Therefore, the algorithm by Zhang only applies a
restricted set of simplification rules. These are:
• If F contains a pair of complementary clauses (e.g. {u} and {u}), then
return an unsatisfiable formula, i.e. F ′ = {}.
• Apply the subsumption rule to 3-clauses that are subsumed by a shorter
clause.
85
86
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
• As long as there are more than two 1-clauses, or if there is a 2-clause
that is independent of the last remaining 1-clause, then apply the unit
clause rule to an arbitrary 1-clause.
Let us make a minor definition, that we will only use in connection with this
algorithm.
Definition 6.1. Given a 3-CNF formula F , we partition F into the following
sets of clauses:
(i) C0 is the set of all 1-clauses,
(ii) C1 is a maximal set of 2-clauses in which every variable appears only
once in C0 ∪˙ C1 ,
(iii) C2 is the set of all remaining 2-clauses,
(iv) C3 is the set of all 3-clauses.
For i ∈ {0, 1, 3} we will use ci to denote |Ci |, and additionally we define
c2 := max {2, |C2 |}.
Note that the definitions of C1 and C2 are not unique, because it matters in
which order the 2-clauses are added to C1 . Some clauses may prevent others
from being added to C1 , if they share common variables. The important
thing, though, is that C1 is a maximal set of 2-clauses (i.e. there is no clause
C ∈ C2 that is independent of all the clauses in C0 ∪˙ C1 ), but not necessarily
a maximum set of 2-clauses. C1 is empty, for example, when there is a single
1-clause sharing its variable with all 2-clauses. Then c0 = 1, c1 = 0, and
c2 ≥ 0.
Let us first state the general structure of the algorithm as it has been defined
in Section 2.2, and then we will be ready to formulate the Simplify and the
Split procedure for the algorithm by Zhang.
We have already pointed out that the algorithm Zh expects an input formula
that has at least one short clause. From now on we will assume that this is
the case for the original input formula. If not, then, at the beginning, we can
always split on a 3-clause like in the algorithm by Monien and Speckenmeyer,
checking for autark assignments. From Lemma 5.2 we get the desired property that there is at least one short clause, and the analysis of the algorithm
can be slightly modified to include the first (and only) splitting on a 3-clause
(see end of Section 5.3 for an example of how this can be done). Regarding
all the other recursive calls we will ensure that there is always a short clause
as we go along.
6.2. MAIN PROCEDURES
87
Algorithm 8: Zh(F )
input : 3-CNF formula F containing a short clause
output: satisfiable or unsatisfiable
1
2
3
4
5
F ′ ← SimplifyZh (F );
if F ′ = {} then return satisfiable;
if ∈ F ′ then return unsatisfiable;
{F1 , . . . , Fs } ← SplitZh (F ′ );
return g( Zh(F1 ), . . ., Zh(Fs ) );
6.2
Main procedures
Now, let us have a look at the procedure SimplifyZh .
Procedure SimplifyZh (F )
input : 3-CNF formula F containing a short clause
SAT
output: Formula F ′ with short clause, F ′ ≡ F
1
2
3
4
5
6
7
8
9
10
F′ ← F;
while any of the following rules applies do
if {u} ∈ F ′ and {u} ∈ F ′ then F ′ ← {};
if ∃C ∈ C3 : ∃C ′ ∈ F ′ : C ′ ⊂ C then F ′ ← F ′ \ {C};
if (c0 ≥ 2) or (c0 = 1 and c1 > 0) then
{u} ← any 1-clause in F ′ ;
F ′ ← F ′[u] ;
end
end
return F ′ ;
In line 3 of SimplifyZh we check for complementary 1-clauses, and we modify
the formula such that it only contains the empty clause. In line 4 we check
for 3-clauses in F ′ that are subsumed by any shorter clause, and if we find one
we remove it from the formula. Finally, in the lines from 5 to 8 we remove
unit clauses by the unit clause rule, but we are careful not to delete the
last remaining unit clause if there is no other short clause (i.e. a 2-clause).
This last remark, in fact, guarantees the output condition of the SimplifyZh
procedure.
Lemma 6.2. Let F be a 3-CNF formula with at least one short clause, i.e.
c0 + c1 ≥ 1. Then, SimplifyZh (F ) returns a satisfiability-equivalent formula
F ′ with at least one short clause.
88
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
Proof. The satisfiability-equivalence is ensured by the unit clause rule (see
Lemma 3.3) and the subsumption rule (see Lemma 3.1).
The fact that F ′ must contain a short clause is ensured, because, first of all,
F did contain a short clause, and then we are only removing 3-clauses and
1-clauses. However, we only remove the last 1-clause if there is at least one
2-clause present, i.e. c1 > 0.
Another basic idea of the algorithm is that it relaxes the concept of autarky
under certain conditions. Remember that, restricting a formula by an autark
assignment does not produce any new clauses. In this algorithm we also
consider assignments over one variable that produce exactly one new clause,
and we treat them separately. More formally, we define the notion of quasiautarky.
Definition 6.3. Let F be a 3-CNF formula. An assignment α with |α| = 1
is called quasi-autark in F , if |F \F [α] = 1|.
Using this definition, now we can also write down the SplitZh procedure of
the algorithm by Zhang.
Procedure SplitZh (F )
input : 3-CNF formula F , c0 + c1 ≥ 1
output: Splitting S, for each Fi ∈ S : c0 + c1 ≥ 1
1
2
3
4
5
if c0 = 1 then return UnitZh (F );
(α1 ,α2 ) ← AssignZh (F );
if αi autark in F for i = 1, 2 then return AutZh (F, αi );
if αi quasi-autark
F for
[α in
i = 1, 2 then return qu-AutZh (F, αi );
[α2 ]
1]
return S ← F , F
;
Even though not all the components of the procedure SplitZh have been
defined yet, let us propose the following lemma.
Lemma 6.4. Let F be a 3-CNF formula with c0 + c1 ≥ 1, that has been
produced by SimplifyZh . Then, SplitZh (F ) returns a splitting S, and for
each Fi ∈ S it holds that c0 + c1 ≥ 1.
Proof. This lemma will easily follow from Lemmata 6.5, 6.7, 6.8, 6.13, and
Lemma 6.6. The first four of these lemmata are going to ensure that the procedures UnitZh , AutZh , and qu-AutZh actually return a required splitting.
6.2. MAIN PROCEDURES
89
The last one of these is going to state that F ≡ F [α1 ] ∨ F [α2 ] , where α1 and α2
have been returned by the call to AssignZh . Together with g(f1 , f2 ) := f1 ∨f2
and the fact that, by Lemma 5.2, both F [α1 ] and F [α2 ] contain at least one
short clause, this is going to ensure the correctness of the splitting.
Note that we are going to skip the proof of condition (i) of the definition of a
splitting (see Definition 2.16), because that is not very difficult to show, given
the polynomial running time of all the constituent procedures. Condition
(iii) of Definition 2.16 is going to be discussed in Section 6.4, where we
define the measure µ.
Now, let us return to the description of what happens in the procedure
SplitZh . After the simplification of the formula either c0 = 0 and c1 ≥ 1, or
it is c0 = 1 and c1 = 0, i.e. there is one 1-clause {l} left, and every 2-clause
contains either l or l. Let us look at this latter case first. The precondition
for calling the procedure UnitZh is c0 ≥ 1 and c1 ≤ 1, and because of c0 = 1
and c1 = 0 we may call it rightly.
Procedure UnitZh (F )
input : 3-CNF formula F , c0 ≥ 1, c1 ≤ 1
output: Splitting S, for each Fi ∈ S : c0 + c1 ≥ 1
1
2
3
4
5
6
{l} ← any 1-clause in F ;
{u, v, w} ← any 3-clause in F ;
if l ∈ {u, v, w} then return S ← {F [l] };
α ← (l, u, v, w);
if α autark in F then return Aut
Zh (F, α);
[l]
[α]
return S ← F ∧ {u, v} , F
;
The procedure UnitZh removes the possibly last unit clause by constructing
a splitting that also incorporates one of the 3-clauses. In one of the two
branches a 2-clause is added to the formula to ensure that there will be a
short clause afterwards. In the other branch this is achieved by asserting
that the defining assignment is not autark.
Lemma 6.5. Let F be a 3-CNF formula with c0 ≥ 1, c1 ≤ 1. Then,
UnitZh (F ) returns a splitting S, and for each Fi ∈ S it holds that c0 +c1 ≥ 1.
Proof. First, note that the clause {u, v, w} must not contain the literal l, otherwise it would have been removed by the subsumption rule in SimplifyZh .
90
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
However, it may contain the literal l, which is checked in line 3. If so, it is
sufficient to return {F [l] } because of the unit clause rule. Also, the postcondition will be satisfied, because without loss of generality, the formula F [l]
contains the clause {v, w}, and therefore c0 + c1 ≥ 1. From now on we can
assume that the clauses {l} and {u, v, w} are independent.
Second, note that the correctness of the splitting returned by the call to the
procedure AutZh in line 5, which, by the way, has the same postcondition
as UnitZh , will be established in Lemma 6.7. For now, we only state that
the preconditions for that lemma are satisfied, i.e. α is autark in F and
|α| = 4 ≥ 2.
We restrict this proof to showing that the splitting returned in line 6 of
UnitZh complies with the condition (ii) of Definition 2.16 with respect to
g(f1 , f2 ) := f1 ∨f2 . Condition (i) is easy to see, given the polynomial running
time of the call to AutZh . Condition (iii) will be discussed in the section
about the running time (see Section 6.4), where we define the measure µ.
We have F1 = F [l] ∧ {u, v} and F2 = (F [l] )[u,v,w] . In both branches we restrict
F by the assignment (l), because this easily follows from the unit clause
rule. Then, in the first branch, we add the clause {u, v}, which will make
the clause {u, v, w} obsolete because of the subsumption rule. In the second
branch we apply the assignment (u, v, w), which is equivalent to adding the
three 1-clauses {u}, {v}, and {w}. This also makes the clause {u, v, w}
obsolete because of the unit clause rule. Therefore, it is enough to show that
the following holds,
u∨v∨w ≡
≡
≡
≡
(u ∨ v) ∨ (u ∧ v ∧ w)
(u ∨ v ∨ u) ∧ (u ∨ v ∨ v) ∧ (u ∨ v ∨ w)
⊤ ∧ ⊤ ∧ (u ∨ v ∨ w)
u ∨ v ∨ w.
The postcondition of UnitZh is fulfilled, because F1 contains the clause
{u, v}, and because F2 has been produced by an assignment that is not
autark in F (see Lemma 5.2).
Let us return once again to the procedure SplitZh and assume that c0 = 0
after the simplification. We skip the UnitZh procedure and compute two
assignments α1 and α2 by calling the AssignZh procedure. These assignments, provided they are neither autark nor quasi-autark, are afterwards
used to produce the splitting for the current recursive call. This is done in
line 2 of the procedure SplitZh .
91
6.2. MAIN PROCEDURES
Procedure AssignZh (F )
input : 3-CNF formula F , c0 = 0, c1 ≥ 1
output: Assignments α1 and α2 , s.t. F ≡ F [α1 ] ∨ F [α2 ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if c2 ≥ 1 then
if F contains conflicting
{u, v} , {u, w} ← any
α1 ← (u, w);
α2 ← (u, v);
else
{u, v} , {u, w} ← any
α1 ← (u);
α2 ← (u, v, w);
end
else if c2 = 0 then
{u, v} ← any 2-clause in
α1 ← (u);
α2 ← (u, v);
end
return α1 , α2 ;
2-clauses then
conflicting pair of 2-clauses;
pair of 2-clauses sharing literal u;
F;
During the construction of α1 and α2 we can distinguish three different cases.
The first two cases apply only if c2 ≥ 1, i.e. there are 2-clauses in F that
are not independent of each other. We further distinguish by the existence
of conflicting 2-clauses.
• Case 1.1: c2 ≥ 1 and there is a pair of conflicting 2-clauses. This case
is handled in the lines 2 to 5.
• Case 1.2: c2 ≥ 1 and there is no pair of 2-clauses with a conflicting
literal, but there are 2-clauses that share a common literal. This case
is handled in the lines 6 to 9.
• Case 2: c2 = 0, i.e. all the 2-clauses are independent of each other.
This case is handled in the lines 11 to 14.
We can formulate the following lemma.
Lemma 6.6. Let F be a 3-CNF formula with c0 = 0 and c1 ≥ 1. Then,
AssignZh (F ) returns two assignments α1 and α2 subject to F ≡ F [α1 ] ∨F [α2 ] .
92
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
Proof. Note that, because of the unit clause rule, restricting a formula F by
an assignment α produces a formula F [α] that is satisfiability-equivalent to
the formula in which we add a unit clause for every literal in α. Therefore,
the following is enough to show that the postcondition of the procedure
AssignZh holds.
For the Case 1.1 we have,
(u ∨ v) ∧ (u ∨ w) ≡ (u ∧ w) ∨ (v ∧ w) ∨ (u ∧ u) ∨ (u ∧ v)
≡ (u ∧ w) ∨ (v ∧ w) ∨ (u ∧ v)
≡ (u ∧ w) ∨ (u ∧ v).
For the Case 1.2 we have,
(u ∨ v) ∧ (u ∨ w) ≡ (u ∧ u) ∨ (u ∧ v) ∨ (u ∧ w) ∨ (v ∧ w)
≡ u ∨ (u ∧ v) ∨ (u ∧ w) ∨ (v ∧ w)
≡ u ∨ (u ∧ v ∧ w).
For the Case 2 recall Lemma 4.2, which produces the assignments for splitting on a clause in the exact same way.
Additionally, note that if we only have two clauses like {u, v} and {u, v}, or
two clauses like {u, v} and {u, v}, then we will end up in Case 1.1, because
both pairs contain at least one conflicting literal. Since only the conflicting
literal is used in both α1 and α2 , we do not get a contradiction there.
6.3
Treatment of autarky
In this description, so far, we have sometimes used the two helper procedures
AutZh and qu-AutZh , which are called in the appropriate places in case we
find an autark or a quasi-autark assignment. These procedures are explained
in the following. This is perhaps the right place to point out that both of
these procedures are only necessary in order to show an improved running
time, and not for the correctness of the algorithm.
When we have to process an autark assignment, it is less complicated if the
assignment maps several variables. Let us discuss this case first, although
in the pseudo-code implementation it is treated last (see lines 8 to 10 of the
procedure AutZh ).
6.3. TREATMENT OF AUTARKY
93
Procedure AutZh (F ,α)
input : 3-CNF formula F , α autark in F , |α| + c1 ≥ 2
output: Splitting S, for each Fi ∈ S : c0 + c1 ≥ 1
1
2
3
4
5
6
7
8
9
10
11
if |α| = 1 then
let α = (u);
if c1 ≥ 2 then return S = F [u] ;
else if c1 = 1 then
return UnitZh (F [u] ∧ {u});
end
else if |α| ≥ 2 then
let α = (α′ , u);
′
return S = F [α ] ∧ {u} ;
end
If |α| ≥ 2, then we return a splitting that we obtain by removing an arbitrary
literal u from the assignment, such that the resulting assignment α′ does not
map the literal u. Then, α′ is applied to the formula and the clause {u}
is added. By adding the 1-clause we ensure that there is at least one short
clause in the next recursive call.
Lemma 6.7. Let F be a 3-CNF formula, and α an assignment that is autark
in F , with |α| ≥ 2. Then, AutZh (F ,α) returns a trivial splitting S = {F ′ }
with c0 + c1 ≥ 1 for F ′ .
Proof. Again, we will skip the proof of condition (i) and (iii) of Definition
2.16, because the former is not difficult to show and the latter is going to be
discussed in Section 6.4, where we define the measure µ.
The satisfiability-equivalence of F and F ′ can be proven as follows,
F
SAT
≡
≡
SAT
≡
=
F [α]
(autark assignment rule)
[α′ ] [u]
(F )
(decomposition of α)
[α′ ]
F ∧ {u} (unit clause rule)
F ′.
94
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
Let us discuss what happens if AutZh is called with |α| = 1. Then, α′ would
be empty, thus eliminating no variables at all. As the choice of our measure µ
will reveal this results in a possible (0)-splitting, which is not allowed by the
definition of a splitting (Definition 2.16). We have to be more careful in this
case. This treatment is done in the lines 1 to 7 of the procedure AutZh . First,
note that this case can only originate from a call in line 4 of the procedure
SplitZh , because in the procedure UnitZh , where AutZh is called as well, we
only ever check assignments that map at least four variables. Consequently,
we have to investigate the assignments that are constructed in the procedure
AssignZh , and indeed in Case 1.2 and Case 2 assignments of length one
will be produced. To handle these cases we formulate the following lemma.
Lemma 6.8. Let F be a 3-CNF formula, and α an assignment that is autark
in F , with |α| = 1. Then, AutZh (F ,α) returns a splitting S, and for each
Fi ∈ S it holds that c0 + c1 ≥ 1.
Proof . Let α = (u), we know already that c0 = 0 and c1 ≥ 1, because
the procedure AssignZh has been executed in this recursive call. If c1 ≥
2 then we can return {F [u] } because of the autark assignment rule. The
postcondition c0 + c1 ≥ 1 will be satisfied, because at most one clause from
C1 will disappear, leaving the formula with at least one short clause.
If c1 = 1, we apply the assignment nevertheless, but we add the clause {u}
afterwards. We may do this because of the unit clause rule. Now, we have
a formula with c0 = c1 = 1, and we can therefore call the procedure UnitZh
with that formula as input. This gives us a splitting that has already been
described in connection with that procedure. Note that the correctness of
the splitting returned by the procedure UnitZh is proved with the help of
Lemma 6.7, therefore we do not get a cyclic dependence. The postcondition
c0 + c1 ≥ 1 is fulfilled, because UnitZh asserts the same postcondition.
Having discussed the treatment of autark assignments, we now proceed to
quasi-autark assignments. For that we need the following two lemmata. The
first one is useful when replacing all occurrences of a pure literal by the
disjunction of several other literals.
Definition 6.9. Let F be a CNF-formula containing the literal u, and let C
be a clause with vbl(u) ∩ vbl(C) = ∅. Then, we define the replacement in F
of u by C as the following,
F hu := Ci := { D | D ∈ F, u ∈
/ D } ∪ { (D\ {u}) ∪ C | D ∈ F, u ∈ D } .
In every clause D of F that contains the literal u we replace u by the literals
in C.
95
6.3. TREATMENT OF AUTARKY
Lemma 6.10 (Zhang, [42]). Let F be a CNF-formula containing the literal
u, and let C be a clause with C ∈
/ F and vbl(u) ∩ vbl(C) = ∅. If u is a
pure literal in F (i.e. u does not appear), then the following two formulae
are satisfiability-equivalent,
SAT
F ∧ (C ∨ u) ≡ F hu := Ci.
Proof . Let α be a satisfying assignment of F ∧ (C ∨ u). If the literal
u is mapped to ⊤ by α, it must hold that C [α] ≡ u[α] = ⊤, therefore
F hu := Ci[α] ≡ F [α] ≡ ⊤. On the other hand, if u is mapped to ⊥ by
α, then in every clause D ∈ F that contains u, there is another literal that is
satisfied. We can therefore say that Dhu := Ci[α] ≡ D[α] ≡ ⊤. We get that
F hu := Ci[α] = ⊤, i.e. α satisfies F hu := Ci.
Conversely, α satisfies F hu := Ci by assumption, and we have to prove the
other direction. Let u not yet be mapped by the assignment α. If α satisfies
C, then construct α′ = (α, u). From that follows that α satisfies F ∧ (C ∨
u). On the other hand, if α does not satisfy C, then in every clause D ∈
F hu := Ci there must be a literal that is satisfied but not contained in C.
Therefore α satisfies F , and naturally α′ = (α, u) satisfies F ∧ (C ∨ u).
Remark 6.3.1. Lemma 6.10 is actually just a special case of Davis-Putnam
resolution (see Section 3.6). From Lemma 3.13 it follows directly that,
SAT
F ∧ (C ∨ u) ≡ DPu (F ) = F hu := Ci,
for formula F , clause C, and literal u as in Lemma 6.10.
⊡
Corollary 6.11 (Zhang, [42]). Let F be a CNF-formula not containing the
clause C. If the literal u only appears in the clause (C ∨ u ∨ v), then F is
satisfiable if and only if one of the following formulae is satisfiable.
(1) F [v,u]
(2) F hu := Ci[v,u]
Proof. From the splitting on a variable (see Lemma 4.1) it follows that F
is satisfiable if and only if either F [v] or F [v] is satisfiable.
96
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
In F [v] the literal u does not appear any more, therefore the formula is
satisfiability-equivalent to F [v,u] because of the pure literal rule.
In F [v] the literal u appears only in the clause (C∨u). By Lemma 6.10 this formula is satisfiability-equivalent to F [v] hu := Ci. Since neither v nor v appear
in C this is equivalent to F hu := Ci[v] . This in turn is satisfiability-equivalent
to F hu := Ci[v,u] , because u does not appear any more in F hu := Ci.
Lemma 6.12 (Zhang, [42]). Let F be a CNF-formula, w a literal from F .
If the literals u and v do not appear in F , then F ∧ {u, v, w} is satisfiable if
and only if one of the following formulae is satisfiable.
(1) F [w,u,v]
(2) F [w,u,v]
(3) F [w,u,v]
Note that the complementary literals u and v may appear in F .
Proof. From the splitting on a variable (see Lemma 4.1) it follows that F
is satisfiable if and only if either F [w] or F [w] is satisfiable.
If the assignment α satisfies the literal w, then clearly α satisfies the clause
{u, v, w}. Therefore u and v can safely be mapped to ⊥ because of the pure
literal rule.
If, on the other hand, α does not satisfy the literal w, then either u or v
has to be mapped to ⊤. It is sufficient, though, to map exactly one of the
two to ⊤, because {u, v, w} is the only clause in which u and v appear at
all. Therefore, F [w] is satisfiable if and only if either F [w,u,v] or F [w,u,v] is
satisfiable.
Now we are ready to discuss the course of action if we encounter a quasiautark assignment. We discard the present splitting and compute a new one
as follows. Remember that, only an assignment over one variable can be
quasi-autark.
Using Corollary 6.11, F is satisfiable if and only if one of the formulae F [v,u]
or F hu := wi[v,u] is satisfiable. If both formulae contain short clauses, then
this shall be our splitting (see line 11 of the procedure qu-AutZh ), but we
have to distinguish the cases when one of the formulae does not contain any
short clauses.
6.3. TREATMENT OF AUTARKY
97
In general, the following two splitting cases can occur in the procedure quAutZh .
• Case A: The assignment (v, u) is autark in F hu := wi.
• Case B: Both branches naturally contain short clauses.
The Case B results in a splitting being returned in line 11. The other case
is handled in the lines 4 to 9, and the splitting is returned in line 9.
Note that, in case we find an assignment α that is autark in F (possibly in
line 3 or in line 8), we can simply call the procedure AutZh , that has already
been discussed.
Procedure qu-AutZh (F ,α)
input : 3-CNF formula F , c0 = 0, α quasi-autark in F and computed
by AssignZh
output: Splitting S, for each Fi ∈ S : c0 + c1 ≥ 1
1
2
3
4
5
6
7
8
9
10
11
let α = (u);
let F \F [α] = { {v, w} };
if (v, u) is autark in F then return AutZh (F ,(v, u));
if (v, u) is autark in F hu := wi then
α1 ← (w, u, v);
α2 ← (w, u, v);
α3 ← (w, u, v);
if αi autark in
i = 1, 2, 3 then return AutZh (F ,αi );
F[α for
[α2 ]
1]
return S = F , F , F [α3 ] ;
end
return S = {F [v,u] , F hu := wi[v,u] };
Lemma 6.13. Let F be a 3-CNF formula, c0 = 0, and let α be a quasiautark assignment in F . Then, qu-AutZh (F ) returns a splitting S, and for
each Fi ∈ S it holds that c0 + c1 ≥ 1.
Proof . First, note that the correctness of the splittings returned by the
procedure AutZh (in line 3 and 8) is given by Lemma 6.7, because the
precondition for those calls is satisfied. Let β be the autark assignment for
the call, then β is obviously autark by the corresponding if-statement, and
|β| + c1 ≥ 2 is satisfied, because we only consider |β| ≥ 2.
98
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
Let us talk about the Case B then. The correctness of the splitting returned
in line 11 of the procedure qu-AutZh is ensured by Corollary 6.11. As
demanded by the corollary, the literal u does only appear in F in the clause
{u, v, w}. To see why this is the case, let {u, u′ } be the 2-clause that is
present at the beginning of the procedure AssignZh (because of c1 ≥ 1), and
let α = (u) be the quasi-autark assignment in F . Since α is quasi-autark,
the literal u appears in exactly one clause C of F . It must be a 3-clause,
C = {u, v, w}, because quasi-autarky can only occur in the Case 1.1 or Case
2 of the procedure AssignZh . However, if there were a 2-clause containing
the literal u at the beginning of the procedure AssignZh , then the Case
1.1 would have applied. The other requirement of Corollary 6.11 is that
the clause {w} does not appear in F , and this is clearly the case because of
c0 = 0. The correctness of Case B follows.
The correctness of the splitting computed in Case A is ensured by Lemma
6.12. From the preceding paragraph we know that the literal u only appears
in the clause C = {u, v, w}. Because of that, and since the assignment (v, u)
is autark in F hu := wi, we can also conclude that the literal v only appears
in the clause C. Therefore, the requirements of Lemma 6.12 are met, and we
can apply the proposed splitting to the formula (F \ {C}) ∧ C.
6.4. RUNNING TIME
6.4
99
Running time
If we simply use the number of variables in the formula as the measure to
analyse this algorithm, we do not get a better bound as in the algorithm
of Monien & Speckenmeyer. This is, because in Case 2 of the Assignzh
procedure we would get a (1, 2)-splitting with a splitting number of 1.618.
Instead, as has already been alluded to, we will also take into account the
number of short clauses. The following parametrised function will serve our
purposes,
µ(F ) := n − ǫ(c0 + c1 + c2 ),
where 0 < ǫ < 31 is to be determined later on. Shortly, we will show that the
condition (iii) of the definition of a splitting (see Definition 2.16) is satisfied
for all the splittings computed in this algorithm (i.e. positive µ-loss in every
branch). However, first we need to show that the above definition of µ is
correct (i.e. µ is always positive), and that for the leaves in the search tree
TZh (F ) it is actually possible to decide satisfiability in polynomial time.
Lemma 6.14. Let F be a CNF-formula and µ(F ) := n − ǫ(c0 + c1 + c2 ). If
0 < ǫ < 31 , then µ(F ) ≥ 0.
Proof. Because of the definition of c2 , and since on n variables we cannot have
more than n clauses that are independent from each other (i.e. c0 + c1 ≤ n),
we get the following inequality,
ǫ(c0 + c1 + c2 ) ≤ ǫ(c0 + c1 ) + ǫ · 2 ≤ ǫ · n + ǫ · 2 = ǫ(n + 2).
n
So, if we assume that ǫ < n+2
for n ≥ 1, it follows that ǫ(c0 + c1 + c2 ) ≤ n.
n 1
Since minn∈N n+2 = 3 , we are done for n ≥ 1.
Now, for a formula F with n(F ) = 0, µ(F ) is zero anyway, because there
cannot be any clauses on zero variables, except for the empty clause.
Therefore, µ(F ) ≥ 0 for any n ≥ 0.
Lemma 6.15. Let F be a CNF-formula and µ(F ) := n − ǫ(c0 + c1 + c2 ), for
0 < ǫ < 31 . If µ(F ) = 0, then the satisfiability of F can be decided in running
time O(1).
Proof . Since µ(F ) = 0, it follows that n = ǫ(c0 + c1 + c2 ). We get the
following derivation,
n = ǫ(c0 + c1 + c2 ) < 31 (c0 + c1 + c2 ),
⇒ 3 · n < c0 + c1 + c2 ≤ n + 2,
⇒ 2 · n < 2,
⇒ n < 1.
100
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
We conclude that, for µ(F ) = 0, the formula F contains no variable at all.
Therefore, F is either empty or only contains the empty clause. The claimed
upper bound for the running time follows.
Now that we have established the validity of our measure µ, we can formulate
the main theorem of this chapter.
Theorem 6.16. Let F be a 3-CNF formula, and n the number of variables of F . The splitting algorithm Zh decides the satisfiability of F in
O∗ (1.570214n ) = O∗ (20.65096·n ).
Proof. First we will go through all the cases and see what kind of splittings
arise.
Procedure UnitZh
When we call the procedure UnitZh , there is a 1-clause {l}, and there is at
most one 2-clause which contains either the literal l or the literal l, because
c1 ≤ 1. In the first branch, where we use F [l] ∧ {u, v}, we have one 1-clause
disappear, at most one 2-clause from C1 disappears, possibly all 2-clauses
from C2 disappear, and the 2-clause {u, v} is added. This is always assuming
the worst case, i.e. as many short clauses as possible are satisfied. Therefore,
the measure µ is reduced as little as possible. Since we are eliminating one
variable, we have a splitting distance of at least µ(F ) − µ(F [l] ∧ {u, v}) ≥
1 − ǫ(1 + 1 + 2 − 1) = 1 − 3ǫ.
In the second branch, where we use F [α] , the situation is very similar. The
only differences are that here, the addition of the short clause is guaranteed
by the non-autarky of α, and that this time four variables are eliminated by
the assignment. As before, the sum c0 + c1 + c2 is reduced by at most 3.
Therefore, the minimum splitting distance is 4 − 3ǫ.
Procedure AutZh
The procedure AutZh either returns a trivial splitting or a splitting generated
by the procedure UnitZh , which has been discussed above.
Procedure AssignZh , Case 1.1
The two branches are symmetrical, therefore we get a balanced splitting.
Considering one of the branches, in the worst case we have two clauses disappear from C1 and all from C2 . Since neither of the two assignments is
autark, at least one short clause is added. Therefore c0 + c1 + c2 is reduced
by at most 3. For both branches we get a distance of at least 2 − 3ǫ.
6.4. RUNNING TIME
101
Procedure AssignZh , Case 1.2
In the first branch only one clause disappears from C1 , but possibly all from
C2 . Since α1 is not quasi-autark there are at least two short clauses being
added. The distance is at least 1 − ǫ.
In the second branch there are at most two clauses disappearing from C1 , but
possibly all from C2 . At least one short clause is being added because α2 is
not autark. The distance is at least 3 − 3ǫ.
Procedure AssignZh , Case 2
In both branches, exactly one clause from C1 disappears. In the first branch
two short clauses are added, because α1 is not quasi-autark. The distance
is at least 1 + ǫ. In the second branch at least one short clause is added,
because α2 is not autark. The distance is at least 2.
Procedure qu-AutZh , Case A
Note that the literals u and v must not appear in C1 , as we have established
in the proof of Lemma 6.13. Also, C0 is empty, i.e. there are no 1-clauses.
Restricting F by the assignment α1 might therefore reduce the number of
clauses in C1 by at most three. Restricting F by either α2 or α3 on the
other hand can reduce c1 by at most two. In the worst case, for all three
assignments, the clauses from C2 disappear completely, thus reducing c2 by
at most two. On the bright side, at least one short clause is added on account
of none of the assignments being autark. Therefore, the distance in the first
branch, that corresponds to α1 , is at least 3 − 4ǫ. In the other two branches
we are slightly better off with a distance of at least 3 − 3ǫ.
Procedure qu-AutZh , Case B
This case results in the same splitting as case 1.1.
Optimising ǫ
From the discussion above we derive the list of possible splittings that can
occur, depending on ǫ. We leave aside trivial splittings, because their splitting
number is optimal (it equals 1) if the distance is greater than zero, which is
always the case.

(1 − 3ǫ, 4 − 3ǫ)
Procedure UnitZh and AutZh ,




Case 1.1 and Case B,
 (2 − 3ǫ, 2 − 3ǫ)
~t =
(1 − ǫ, 3 − 3ǫ)
Case 1.2,


(1 + ǫ, 2)
Case 2,



(3 − 4ǫ, 3 − 3ǫ, 3 − 3ǫ) Case A.
102
CHAPTER 6. THE 3-SAT ALGORITHM BY ZHANG
>T@
&DVH%
&DVH
&DVH$
&DVH
8QLW
>E@
Figure 6.1: Splitting numbers of the non-trivial cases in the Zhang algorithm,
depending on ǫ.
We are looking for the maximum of the splitting numbers of all these tuples,
and we want to minimise this with respect to ǫ.
Numerical calculations show that this is achieved at a value of ǫ ≈ 0.1528477,
and τmax (TZh ) = τ (1 + ǫ, 2) < 1.570214. Therefore the complexity of this
algorithm is approximately O∗ (1.570214µ(F ) ). Since µ(F ) ≤ n, it follows
that the upper bound on the running time in Theorem 6.16 is correct and
amounts to O∗ (1.570214n ) = O∗ (20.65096·n ).
Chapter 7
Conclusion
There are several ways in which the work of this thesis could be enhanced.
For example, the sections about the conflict graph (see Section 4.3) and the
almost satisfiable formulae (see Section 4.4) are far from complete, and some
interesting results can hopefully be found there.
The section about majority sets (see Section 4.5) does not give an actual
analysis of an algorithm using this method. It would be interesting to tackle
the problem of analysing such an algorithm, because after all the splittings
are not known prior to execution.
Even though the framework for splitting algorithms allows for a general measure µ, we have mostly just used the number of variables. The only substantial application of a different measure has been done in Chapter 6. It would
be interesting to investigate what other measures are useful. The question
is, what is the optimal measure?
The currently best known algorithms for SAT are neither deterministic nor
do they just use splittings of the DPLL type. How can this splitting framework be used in combination with approaches such as probabilistic analysis,
covering codes, and local search?
Finally, the method of analysis that we use, i.e. the splitting numbers, can
be refined perhaps. Recall that the running time of our splitting algorithms
merely depends on the maximal splitting number of the whole search tree.
Are we giving away too much there?
103
104
List of Figures
2.1
Conflict graph for Example 2.3.1
2.2
Simple conflict graph for Example 2.3.1 . . . . . . . . . . . . . 27
2.3
Search tree with a lot of internal nodes. . . . . . . . . . . . . . 30
2.4
The function f~t (γ) as in Equation (2.8) . . . . . . . . . . . . . 32
2.5
The composition of a search tree. . . . . . . . . . . . . . . . . 35
2.6
Splittings of Lemma 2.32 . . . . . . . . . . . . . . . . . . . . . 37
4.1
Splitting number for (i, j)-splittings . . . . . . . . . . . . . . . 54
4.2
Conflict graph for a formula containing a pseudo-leaf . . . . . 60
5.1
Splitting tree in the algorithm MS . . . . . . . . . . . . . . . 80
5.2
Modified splitting in the algorithmMS . . . . . . . . . . . . . 81
6.1
Optimisation of the Zhang 3-SAT splitting numbers . . . . . . 102
105
. . . . . . . . . . . . . . . . 27
106
List of Algorithms
1
SSAT(F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2
Simplifyuc (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3
SplitDP LL (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4
Split(F ,C) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5
GreedyMajoritySet(F̂ ) . . . . . . . . . . . . . . . . . . . . 71
6
MS(F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
7
SplitM S (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
8
Zh(F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
9
SimplifyZh (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
10
SplitZh (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11
UnitZh (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
12
AssignZh (F ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
13
AutZh (F ,α) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
14
qu-AutZh (F ,α) . . . . . . . . . . . . . . . . . . . . . . . . . . 97
107
108
Bibliography
[1] Michael Alekhnovich, Edward A. Hirsch, and Dmitry Itsykson. Exponential lower bounds for the running time of DPLL algorithms on satisfiable formulas. Electronic Colloquium on Computational Complexity
(ECCC), 041, 2004.
Annotation: Lower bounds on two specific families of DPLL
algorithms on satisfiable formulae are proved (Generalised
myopic algorithms and drunk algorithms). Proving an exponential lower bound in the most general setting would prove
P=
6 NP. The paper introduces two heuristics, one to choose
the variable to branch upon, and the second to decide which
value to try first.
[2] Nikhil Bansal and Venkatesh Raman. Upper Bounds for MAXSAT:
Further Improved. In 10 th International Symposium on Algorithms and
Computation (ISAAC), Chennai, India, 1999, Proceedings, volume 1741
of Lecture Notes in Computer Science, pages 247–258. Springer, 1999.
Annotation: Deterministic MAXSAT can be solved in
O∗ (1.341294m ) = O∗ (20.424·m ) and also in O∗ (1.105729ℓ ) =
O∗ (20.145·ℓ ). This paper features an elaborate case analysis to
prove a splitting number that is small enough.
[3] Richard Beigel and David Eppstein. 3-Coloring in Time O(1.3289n ).
Journal of Algorithms, 54(2):168–204, 2005.
Annotation: This paper proves that the (3, 2)-CSP can be
solved in O∗ (1.3645n ) = O∗ (20.448·n ), no algorithm is given.
The problems 3-Coloring, 3-Edge-Coloring, and 3-ListColoring are special cases of the (3, 2)-CSP. The problem
3-SAT is equivalent to a (2, 3)-CSP. The techniques involved
are Davis-Putnam backtracking and network flow based ideas.
109
110
BIBLIOGRAPHY
[4] George Boole. An Investigation of the Laws of Thought. Macmillan,
London, 1854.
Annotation: Citing the author, this book is an investigation
of the laws of thought, on which are founded the mathematical
theories of logic and probabilities. It is a very influential book
(300+ pages), that introduces Boolean logic.
[5] Tobias Brueggemann and Walter Kern. An improved deterministic local search algorithm for 3-SAT. Theoretical Computer Science, 329(13):303–313, 2004.
Annotation: Deterministic 3-SAT, using local search, can be
solved in O∗ (1.473n ) = O∗ (20.559·n ). The paper improves on a
bound given in [8]. It uses covering codes and then splittings
to search for a satisfiying assignment in the subcubes. The
concept of blocked clauses is introduced.
[6] Jesper M. Byskov, Bolette A. Madsen, and Bjarke Skjernaa. New algorithms for Exact Satisfiability. Theorical Computer Science, 332(13):515–541, 2005.
Annotation: The problem Exact-SAT can be solved in
O∗ (1.1749n ) = O∗ (20.2325·n ), and the problem Exact-3-SAT
in O∗ (1.1003n ) = O∗ (20.1379·n ). The paper describes a deterministic splitting algorithm.
[7] Stephen A. Cook. The Complexity of Theorem-Proving Procedures. In
3 rd Symposium on Theory of Computation (STOC), Shaker Heights,
USA, 1971, Proceedings, pages 151–158. ACM Press, 1971.
Annotation: This paper is very influential, because it is the
first proof of NP-completeness, making SAT the “first” NPcomplete problem.
[8] Evgeny Dantsin, Andreas Goerdt, Edward A. Hirsch, Ravi Kannan,
Jon M. Kleinberg, Christos H. Papadimitriou, Prabhakar Raghavan,
and Uwe Schöning. A deterministic (2 − 2/(k + 1))n algorithm for kSAT based on local search. Theoretical Computer Science, 289(1):69–83,
2002.
Annotation: This paper gives a deterministic k-SAT in
2 n
) ). The paper contains an improvement for 3O∗ ((2 − k+1
∗
SAT to O (1.481n ) = O∗ (20.567·n ). The algorithm is a derandomisation of the algorithm given in [37]. It uses covering
BIBLIOGRAPHY
111
codes and simple local search. The 3-SAT improvement uses a
more complicated local search, which introduces the notation
of constrained clauses.
[9] Evgeny Dantsin, E. A. Hirsch, Sergei Ivanov, and Maxim Vsemirnov.
Algorithms for SAT and Upper Bounds on Their Complexity. Electronic
Colloquium on Computational Complexity (ECCC), 8(12), 2001.
Annotation: This is a survey of algorithms for SAT. It discusses a derandomisation of [32], and also some local search
related techniques. It provides about 40 useful references.
[10] Martin Davis, George Logemann, and Donald W. Loveland. A Machine
Program for Theorem-Proving. Communications of the ACM, 5(7):394–
397, 1962.
Annotation: This is a very influential paper about the practical implementation of the Davis-Putnam procedure [11]. It
introduces the simple splitting on a variable. Together with P
for Putnam, the authors’ names provide the acronym DPLL,
that is used to denote this splitting, and sometimes also for a
splitting algorithm in general.
[11] Martin Davis and Hilary Putnam. A Computing Procedure for Quantification Theory. Journal of the ACM, 7(3):201–215, 1960.
Annotation: This is a very influential paper introducing the
idea of resolution proofs for SAT. Subsequently, this gave rise
to the use of splittings that are described in this thesis. It introduces two simplification rules (unit clause rule, pure literal
rule).
[12] David Eppstein. The Traveling Salesman Problem for Cubic Graphs.
In 8 th Workshop on Algorithms and Data Structures (WADS), Ottawa,
Canada, 2003, Proceedings, volume 2748 of Lecture Notes in Computer
Science, pages 307–318. Springer, 2003.
Annotation: The problem Hamilton Cycle can be solved
in O∗ (1.25992n ) = O∗ (20.333·n ) in graphs with n vertices and
maximum vertex degree 3. The algorithm is an elaborate case
analysis of reductions and splittings.
112
BIBLIOGRAPHY
[13] David Eppstein. Quasiconvex Analysis of Backtracking Algorithms. In
15 th Symposium on Discrete Algorithms (SODA), New Orleans, USA,
2004, Proceedings, pages 788–797. SIAM Press, 2004.
Annotation: This paper uses variable weight functions to
analyse DPLL algorithms. The weight function is optimised
with quasiconvex programming.
[14] Sergey S. Fedin and Alexander S. Kulikov. Automated Proofs of Upper
Bounds on the Running Time of Splitting Algorithms. In 1 st International Workshop on Parametrized and Exact Computation (IWPEC),
Bergen, Norway, 2004, Proceedings, volume 3162 of Lecture Notes in
Computer Science, pages 248–259. Springer, 2004.
Annotation: This paper presents a procedure that, given
a set of simplification rules, can prove upper bounds for the
problems SAT, MAXSAT, and (n, 3)-MAXSAT. The paper
features a list of many known simplification rules. Its general splitting algorithm considers all splittings on up to two
variables. The upper bounds for SAT and MAXSAT are with
respect to ℓ and m. For the problem (n, 3)-MAXSAT there is
also a bound with respect to n.
[15] Fedor V. Fomin, Fabrizio Grandoni, and Dieter Kratsch. Measure and
Conquer: Domination - A Case Study. In 32 nd International Colloquium
on Automata, Languages and Programming (ICALP), Lisbon, Portugal,
2005, Proceedings, volume 3580 of Lecture Notes in Computer Science,
pages 191–203. Springer, 2005.
Annotation: The paper gives an application of non-standard
measures for the analysis of DPLL recursion trees. It shows
that the graph problem Minimum Dominating Set is solvable in O∗ (1.514n ) = O∗ (20.598·n ).
[16] Fedor V. Fomin, Fabrizio Grandoni, and Dieter Kratsch. Some New
Techniques in Design and Analysis of Exact (Exponential) Algorithms.
Bulletin of the EATCS, 87:47–77, 2005.
Annotation: This survey discusses several techniques in the
design and analysis of exact exponential algorithms. It provides over 60 references. There are four categories of techniques presented; they are Measure & Conquer, Lower bounds,
Bounded tree-width, and Memorization.
BIBLIOGRAPHY
113
[17] Michael Garey and David S. Johnson. Computers and Intractability: A
Guide to the Theory of NP-completeness. W.H. Freeman and Company,
New York, 1979.
Annotation: This book is an extensive guide to the theory
of NP-completeness. It presents problems from different fields,
along with their proof of NP-completeness.
[18] Jens Gramm, Edward A. Hirsch, Rolf Niedermeier, and Peter Rossmanith. Worst-case upper bounds for MAX-2-SAT with an application
to MAX-CUT. Discrete Applied Mathematics, 130(2):139–155, 2003.
Annotation: The paper proves that the problem MAX-2SAT is solvable in O∗ (1.1487m ) = O∗ (20.2·m ). This also implies
that MAX-2-SAT is solvable in O∗ (1.0718ℓ ) = O∗ (20.1·ℓ ). The
algorithm uses a simple DPLL splitting on only one variable,
which chooses variables with a high number of occurences first.
[19] Edward A. Hirsch. Two New Upper Bounds for SAT. In 9 th Symposium
on Discrete Algorithms (SODA), San Francisco, USA, 1998, Proceedings, pages 521–530, 1998.
Annotation: The paper gives an algorithm for SAT in
O∗ (1.239m ) = O∗ (20.30897·m ) and in O∗ (1.076ℓ ) = O∗ (20.10537·ℓ ).
The algorithm is a splitting algorithm that uses several splitting rules.
[20] Edward A. Hirsch. New Worst-Case Upper Bounds for SAT. Journal of
Automated Reasoning, 24(4):397–420, 2000.
Annotation: This paper shows that SAT can be solved in
O∗ (1.239m ) = O∗ (20.30897·m ) and in O∗ (1.074ℓ ) = O∗ (20.10299·ℓ ).
It uses a splitting algorithm that consist of Reduce and
Split steps. The check for a trivial formula is done in the
Split step. It only considers splittings on two variables.
[21] Edward A. Hirsch. SAT Local Search Algorithms: Worst-Case Study.
Journal of Automated Reasoning, 24(1/2):127–143, 2000.
Annotation: This paper gives upper and lower bounds for
probabilitstic local search algorithms. It does not use splittings.
114
BIBLIOGRAPHY
[22] Edward A. Hirsch. Worst-case study of local search for MAX-k-SAT.
Discrete Applied Mathematics, 130(2):173–184, 2003.
Annotation: This paper gives a (1 − ǫ)-approximation algorithm for MAX-k-SAT with respect to n. It is based on [37].
The algorithm is local search related and splittings are not
used.
[23] Thomas Hofmeister, Uwe Schöning, Rainer Schuler, and Osamu Watanabe. A Probabilistic 3-SAT Algorithm Further Improved. In 19 th Symposium on Theoretical Aspects of Computer Science (STACS), Antibes,
France, 2002, Proceedings, pages 192–202, 2002.
Annotation: This paper gives a probabilistic algortihm
for 3-SAT that can be upper bounded by O∗ (1.3302n ) =
O∗ (20.412·n ). It is local search related and does not use splittings.
[24] Kazuo Iwama. Worst-case upper bounds for k-SAT.
the EATCS, 82:61–71, 2004.
Bulletin of
Annotation: This article gives a more detailed description
of the ideas used in [25]. It includes a table that compares
current SAT algorithms up to that date.
[25] Kazuo Iwama and Suguru Tamaki. Improved upper bounds for 3SAT. In 15 th Symposium on Discrete Algorithms (SODA), New Orleans,
USA, 2004, Proceedings, page 328, 2004.
Annotation: This paper gives a probabilistic 3-SAT algorithm with an upper bound in O∗ (1.324n ) = O∗ (20.405·n ), and
4-SAT in O∗ (1.474n ) = O∗ (20.560·n ). It combines the two algorithms from [37] and [32]. These algorithms use local search
and the coding lemma for satisfying assignments.
[26] Arist Kojevnikov and Alexander S. Kulikov. A New Approach to Proving Upper Bounds for MAX-2-SAT. In 7 th Symposium on Discrete Algorithms (SODA), Miami, USA, 2006, Proceedings, pages 11–17. ACM
Press, 2006.
Annotation: This paper proves that MAX-2-SAT can be
solved in O∗ (1.1343m ) = O∗ (20.1818·m ). It uses a splitting algorithm and a non-standard measure for the analysis.
BIBLIOGRAPHY
115
[27] Alexander S. Kulikov. Automated Generation of Simplification Rules
for SAT and MAXSAT. In 8 th International Conference on Theory
and Applications of Satisfiability Testing (SAT), St. Andrews, Scotland,
Proceedings, volume 3569 of Lecture Notes in Computer Science, pages
430–436. Springer, 2005.
Annotation: The paper proves that (n, 3)-MAXSAT can
be solved in O∗ (1.272021n ) = O∗ (20.347·n ). The algorithm improves on a bound given in [2]. The paper is aimed at automatically finding new simplification rules for SAT and MAXSAT.
It introduces open formulae and majority sets.
[28] Oliver Kullmann. Investigations on autark assignments. Discrete Applied Mathematics, 107(1-3):99–137, 2000.
Annotation: This paper is concerned with the concept of
autarky. It introduces lean clause-sets, which do not have nontrivial autarkies, and linear autarkies, which can be found in
polynomial time.
[29] Oliver Kullmann. Lean clause-sets: generalizations of minimally unsatisfiable clause-sets. Discrete Applied Mathematics, 130(2):209–249,
2003.
Annotation: This paper carries on and extends some of the
ideas of [28].
[30] Oliver Kullmann and Horst Luckhardt. Algorithms for SAT/TAUT decision based on various measures, 1999.
Annotation: This paper investigates the DNF-TAUT problem, which is the coNP-complete complement of CNF-SAT.
The paper contains a lot of material about splitting numbers
and search trees. It has an overview of the, up to that date,
best known bounds (with respect to ℓ, m, and n) for different versions of the DNF-TAUT problem. It provides over 50
references. The paper also identifies hard domains for solving
formulae parametrised by q = m/n.
[31] Burkhard Monien and Ewald Speckenmeyer. Solving satisfiability in less
than 2n steps. Discrete Applied Mathematics, 10:287–295, 1985.
116
BIBLIOGRAPHY
Annotation: This paper shows that k-SAT can be solved in
O∗ (ank ), where ak is the greatest number satisfying the equation ak = 2 − 1/akk−1 . It is one of the first results better than
O∗ (2n ). The algorithm branches on the shortest clause, and
makes use of autark simplification steps.
[32] Ramamohan Paturi, Pavel Pudlák, Michael E. Saks, and Francis Zane.
An Improved Exponential-Time Algorithm for k-SAT. In 39 th Symposium on Foundations of Computer Science (FOCS), Los Alamitos, USA,
1998, Proceedings, pages 628–637. IEEE Computer Society, 1998.
Annotation: This influential paper gives a probabilistic kSAT algorithm. For example, the problem 3-SAT can be solved
in O∗ (1.362n ) = O∗ (20.446·n ). The method uses bounded resolution and the coding lemma.
[33] Ramamohan Paturi, Pavel Pudlák, Michael E. Saks, and Francis Zane.
An Improved Exponential-Time Algorithm for k-SAT. Journal of the
ACM, 52(3):337–364, 2005.
Annotation: This article is a reprint of [32].
[34] Pavel Pudlák and Russell Impagliazzo. A lower bound for DLL algorithms for k-SAT (preliminary version). In 11 th Symposium on Discrete
Algorihms (SODA), San Francisco, USA, 2000, Proceedings, pages 128–
136, 2000.
Annotation: This paper proves a lower bound for DPLL
algorithms on certain inputs.
[35] James Renegar. On the Computational Complexity and Geometry of
the First-order Theory of the Reals: Parts I, II and III. Journal of
Symbolic Computation, 13:255–352, 1992.
Annotation: This paper is useful for proving a polynomial
running time on the problem of ordering splitting numbers
when given a set of splitting tuples.
[36] Ingo Schiermeyer. Solving 3-Satisfiability in Less Than 1.579n Steps. In
6 th Workshop on Computer Science Logic (CLS), San Miniato, Italy,
1992, Selected Papers, volume 702 of Lecture Notes in Computer Science,
pages 379–394. Springer, 1992.
BIBLIOGRAPHY
117
Annotation: This paper proves that 3-SAT can be solved
in O∗ (1.579n ) = O∗ (20.659·n ). It uses a splitting algorithm and
a classical analysis by solving the recursion equations. For 3SAT this is a slight improvement over [31].
[37] Uwe Schöning. A Probabilistic Algorithm for k-SAT and Constraint
Satisfaction Problems. In 40 th Symposium on Foundations of Computer
Science (FOCS), New York, USA, 1999, Proceedings, pages 410–414,
1999.
Annotation: This paper gives a probabilistic algorithm for
k-SAT, that is based on local search and restart. The problem
k-SAT is shown to be solvable in O∗ ( (2· k−1
)n ). The algorithm
k
chooses a initial assignment and makes random flips on the
mapping of the variables.
[38] Uwe Schöning. A Probabilistic Algorithm for k-SAT Based on Limited
Local Search and Restart. Algorithmica, 32(4):615–623, 2002.
Annotation: This paper develops the same ideas as [37].
[39] Uwe Schöning. Algorithmics in Exponential Time. In 22 nd Symposium
on Theoretical Aspects of Computer Science (STACS), Stuttgart, Germany, 2005, Proceedings, volume 3404 of Lecture Notes in Computer
Science, pages 36–43. Springer, 2005.
Annotation: This survey describes exponential backtracking analysis, and randomised local search for 3-SAT. It is a
nice overview of the ideas and applications of splittings for
3-SAT, and it mentions the best known SAT algorithms up to
that date.
[40] Michael Sipser. Introduction to the Theory of Computation. Second
Edition. Pws Publishing, 2006.
Annotation: This is a very useful book about computability
and complexity theory. It includes a proof that SAT is NPcomplete.
[41] Gerhard J. Woeginger. Exact Algorithms for NP-Hard Problems: A
Survey. In 5 th Workshop on Combinatorial Optimization, Aussois,
France, 2001, Revised Papers, volume 2570 of Lecture Notes in Computer Science, pages 185–208. Springer, 2001.
118
BIBLIOGRAPHY
Annotation: This is a survey of fast exponential time solutions for several NP-complete problems (e.g. TSP, SAT, several graph problems). It provides a lot of references. This paper is interesting for its broad range of ideas, and applications
of splittings for different problems. The problem SAT itself is
not treated extensively.
[42] Wenhui Zhang. Number of Models and Satisfiability of Sets of Clauses.
Theoretical Computer Science, 155(1):277–288, 1996.
Annotation: This paper gives a framework for counting the
satisfying assignments of a formula. The central tool are socalled bases, formulae that are unsatisfiable and contain only
conflicting clauses. With the help of these bases and a case distinction the autor sets up an upper bound for 3-SAT, which
can be solved in O∗ (1.571n ) = O∗ (20.652·n ). This is an improvement over [31] and [36].