New Bounds for MAX-SAT by Clause Learning
Alexander S. Kulikov1? and Konstantin Kutzkov2
1
St. Petersburg Department of Steklov Institute of Mathematics
27 Fontanka, 191023 St.Petersburg, Russia
[email protected]
2
Department of Computer Science, University of Munich
Oettingenstr. 67, 80538 München, Germany
[email protected]
Abstract. To solve a problem on a given CNF formula F a splitting
algorithm recursively calls for F [v] and F [¬v] for a variable v. Obviously, after the first call an algorithm obtains some information on the
structure of the formula that can be used in the second call. We use
this idea to design new surprisingly simple algorithms for the MAX-SAT
problem. Namely, we show that MAX-SAT for formulas with constant
clause density can be solved in time cn , where c < 2 is a constant and
n is the number of variables, and within polynomial space (the only
known such algorithm by Dantsin and Wolpert uses exponential space).
We also prove that MAX-2-SAT can be solved in time 2m/5.88 , where
m is the number of clauses (this improves the bound 2m/5.769 proved
independently by Kneis et al. and by Scott and Sorkin).
1
Introduction
Splitting method is one of the most popular ways of proving upper bounds for
SAT and MAX-SAT problems. The simplest form of a splitting algorithm is given
in Fig. 1. Obviously, without the simplification phase the worst case running
time of such an algorithm is 2n , as it just considers all possible candidates (i.e.,
assignments of Boolean values to all variables of a formula) to solutions.
A natural idea for reducing the running time of such an algorithm is introducing the following partial order on candidates: α is stronger than β if β cannot
be a solution without α being a solution. Clearly, in such a case there is no need
in considering the assignment β and thus the search space is reduced. This is actually what is done at simplification phase in many known splitting algorithms.
For example, if l is a pure literal, then any assignment α 3 l is stronger than
(α\{l}) ∪ {¬l}. Thus to prove that a given splitting algorithm is correct one
has to prove that any possible candidate is either considered by the algorithm
or is weaker than some other assignment. However such kind of knowledge is
typically used in the same branch. That is, if in some branch an algorithm does
?
Supported in part by INTAS (grants 04-77-7173, 05-109-5352), RFBR (grants 05-0100932-a, 06-01-00502-a, 06-01-00584-a) and Russian Science Support Foundation.
Splitting Algorithm
Input: a CNF formula F .
Method.
1.
2.
3.
4.
Simplify F as long as it is possible.
If the solution for F is obvious (in particular, if F is empty), then return it.
Choose a variable v according to some heuristic.
Recursively call for F [v] and F [¬v] and return the solution according to the solutions returned by both recursive calls.
Fig. 1. Form of a splitting algorithm
not consider an assignment β, then there is an assignment α, which is stronger
than β and is considered in the same branch.
In this paper we show how to get rid in the current branch of the candidates
considered in another branch. The idea itself is quite natural and not new: it
is used, e.g., in theoretical algorithms ([1], [2]), practical solvers ([3], [4], [5])
and even in proof systems ([6]). In SAT algorithms this is usually called clause
learning, which means that an algorithm stores partial assignments that make a
formula unsatisfiable. In our new algorithms we use a natural extension of this
simple idea, i.e., we store partial assignments that cannot be extended to an
optimal (satisfying maximal possible number of clauses) assignment. We prove
the following bounds (throughout all the paper we ignore polynomial factors):
– cn for MAX-SAT for formulas with constant clause density, where c < 2 is
a constant and n is the number of variables;
– 2m/5.88 for MAX-2-SAT, where m is the number of clauses.
Both algorithms use only polynomial space.
Overview of previous results. We are only aware of one bound better than 2n
for MAX-SAT for formulas with constant clause density. The algorithm is due
to Dantsin and Wolpert [7]. This algorithm however uses exponential space.
For MAX-2-SAT, several bounds w.r.t. the number of clauses were obtained
since 1999, see Table 1. Note that the bounds by Scott and Sorkin are actually
applied to a wider class of problems, namely for MAX-2-CSP. All these bounds
explore the splitting method, which seems to be unable to give any non-trivial
upper bound for MAX-2-SAT w.r.t. the number of variables. Williams [8] uses
a fast matrix multiplication algorithm in a nice way to get a 2n/1.261 bound.
Table 1. Known bounds for MAX-2-SAT
2m/2.873
2m/4.000
2m/5.000
2m/5.000
2m/5.217
2m/5.500
2m/5.769
2m/5.769
2
2.1
[9]
[10]
[11]
[12]
[13]
[14]
[15]
[16]
Niedermeier and Rossmanith
Hirsch
Gramm, Hirsch, Niedermeier, and Rossmanith
Scott and Sorkin
Kneis and Rossmanith
Kojevnikov and Kulikov
Kneis, Mölle, Richter, and Rossmanith
Scott and Sorkin
General Setting
Main Definitions
Let V be a set of Boolean variables. The negation of a variable v ∈ V is denoted
by ¬v. A literal is either a variable or its negation. A clause and an assignment
are sets of literals that do not contain any variable together with its negation.
A formula in conjunctive normal form (CNF) is a multi-set of clauses. A total
assignment is an assignment to all variables of a formula. We say that a clause
C is satisfied by an assignment α, if C ∩ α 6= ∅; however, we say that C is
falsified by α, if ∀l ∈ C, ¬l ∈ α. By V (α) we denote the set of variables of
α. By Cl(F, α) we denote the number of clauses of F satisfied by α and by
MCl(F ) we denote the maximal number of simultaneously satisfiable clauses
(thus, MCl(F ) = maxα Cl(F, α)). The SAT problem asks whether there exists an
assignment that satisfies all clauses of a given formula. The MAX-SAT problem
asks for an assignment that satisfies MCl(F ) clauses.
A d-literal is a literal occurring exactly d times in a formula. A d+ -literal
appears at least d times. A (d1 , d2 )-literal appears d1 times positively and d2
times negatively. Other literal types are defined similarly.
Let F be a CNF formula, v be a variable of F , α be an assignment to variables
of F . We usually write assignments {v} and {¬v} just as v and ¬v. By F [α] we
denote the formula resulting from F by first removing all clauses satisfied by α
and then removing all literals l such that ¬l ∈ α from the remaining clauses. Let
also
Fv = {C : C ∪ {v} ∈ F }, F¬v = {C : C ∪ {¬v} ∈ F }, F−v = {C ∈ F : v 6∈ C} ,
then clearly
F [v] = F¬v ∪ F−v , F [¬v] = Fv ∪ F−v .
For assignments α and β such that V (β) ⊆ V (α), by αβ we denote the
assignment resulting from α by changing the values of V (β) in accordance with
β. For example, αa assigns the value True to a.
Let α be a total assignment to a formula F and a be an (i, j)-literal of F .
Then,
Cl(F, αa ) = i + Cl(F [a], α) = i + Cl(F¬a , α) + Cl(F−a , α) ,
(1)
Cl(F, α¬a ) = j + Cl(F [¬a], α) = j + Cl(Fa , α) + Cl(F−a , α) .
(2)
By n(F ) and m(F ) we denote, respectively, the number of variables and
clauses in a formula F (we usually omit F , when it is clear from the context).
2.2
Splitting Algorithms
A splitting algorithm usually first somehow simplifies an input formula F and
then recursively calls for several formulas of the form F [α] (this is called
splitting). To estimate the running time of a splitting algorithm one has to
specify a formula complexity measure γ(F ). A splitting number of a splitting F [α1 ], . . . , F [αk ] is defined to be the unique positive root of the equation
Pk
1 = i=1 x−ai , where ai = γ(F ) − γ(F [αi ]), and is denoted by τ (a1 , . . . , ak ).
It is known [17] that the running time of a splitting algorithm on a formula
γ(F )
F does not exceed τmax , where τmax is the maximal splitting number of this
algorithm. Thus, to prove upper bounds on the running time it suffices to prove
upper bounds on τmax . There are several simple properties of splitting numbers
[17]. In particular,
–
–
–
–
–
τ (a, a) = 21/a
;
√
τ (a, b) ≤ 21/ ab ;
τ (a1 , . . . , ap ) ≤ τ (b1 , . . . , bp ), if ∀i, ai ≥ bi ;
τ (1, 2, . . . , a) < 2 and τ (1, 2, . . . , a) < τ (1, 2, . . . , a + 1);
τ (1, a) → 1 as a → ∞.
To prove that a splitting algorithm is correct one has to prove that this
algorithm considers all possible candidates to solutions (e.g., if an algorithm
for SAT returns the answer “Unsatisfiable”, then one has to guarantee that
it considered all possible total assignments and none of them is a satisfying
assignment). To achieve this goal splitting algorithms usually split on a set of
assignments α1 , . . . , αk , such that any possible total assignment is an extension
of one of αi ’s. However if we know that a total assignment β cannot be a solution
without a total assignment α being a solution, then there is no need to consider β.
For example, if l is a pure literal, then there is no sense in considering assignments
containing ¬l. We formalize this simple idea in the following definition (a similar
definition is used in [18]).
Let α1 and α2 be assignments to variables of a formula F . We say that α1
is stronger w.r.t. F than α2 and write α1 F α2 , if for any total assignment β,
β α2 can be a solution to a problem for F only if β α1 is a solution (again, we
omit F if this does not lead to ambiguity). By a solution for SAT we mean a
satisfying assignment, while a solution for MAX-SAT is an assignment satisfying
the maximal number of clauses.
3
A New Algorithm for MAX-SAT
In this section we show that MAX-SAT for formulas with at most ∆n clauses,
where ∆ is a constant, can be solved in time cn , where c < 2 is a constant.
First, let us give some informal ideas showing that there exists a SAT algorithm with running time cn , where c < 2, for formulas with constant clause
density ∆. The algorithm works as follows. If a formula contains a (d+ , d+ )literal l, for some big constant d = d(∆), it just splits on it. This provides a
good splitting number w.r.t. the number of clauses (in both branches at least d
clauses are eliminated). Otherwise, the algorithm picks a d− -literal a and checks
the satisfiability of Fa . This can be easily done in polynomial time: at each step
we choose a literal (of course, we assume that it is not pure) and split the current formula into two formulas having fewer clauses; since Fa contains at most d
clauses, the size of the resulting splitting tree is at most 2d . If Fa is unsatisfiable,
then so is F [¬a] = Fa ∪ F−a and we can just assign the value True to a. Otherwise, we find a satisfying assignment to Fa . It is easy to see that it contains at
most d literals. Let us denote it by α = {l1 , . . . , lk } (k ≤ d).
Now we recursively call for F [¬a] = Fa ∪ F−a . If the answer is “Satisfiable”
we immediately return. Otherwise we can conclude that α cannot be extended
to a satisfying assignment of F−a , which means that we do not need to consider
extensions of α in the a-branch. Thus, we split F [a] to
F [a, ¬l1 ], F [a, l1 , ¬l2 ], . . . , F [a, l1 , . . . , lk−1 , ¬lk ] .
The overall splitting number w.r.t. n is τ (1, 2, . . . , k+1) < 2. Thus, the algorithm
is always able to find a good splitting w.r.t. either n or m. Since m ≤ ∆n, we
can prove that the overall running time of this algorithm is cn , where c < 2.
The formal description of the algorithm for MAX-SAT is given in Fig. 2.
The algorithm first applies the pure literal rule as long as it is applicable. Then
it splits on a D+ -literal, if such literal exists. If there is no such literal, the
algorithm just selects any literal a and finds optimal assignments αa and α¬a
for Fa and F¬a , respectively. Since both Fa and F¬a contain at most D clauses,
this can be done in polynomial time. Moreover, we can assume that both αa
and α¬a contain at most D literals. Finally, the algorithm splits a formula using
the literals of one of the found assignments. We do not explain here how the
algorithm constructs the answer from the answers returned by the recursive
calls, as this is a standard operation (all one needs to do is to count the number
of currently satisfied clauses; see, e.g., [10]).
Theorem 1. For any constant ∆ > 0 there exist constants D > 0 and c < 2
such that MaxSatAlg(D) returns MCl(F ) for any formula F with at most ∆n(F )
clauses in time cn(F ) .
Proof. If a current formula F contains a D+ -literal, the algorithm just splits
on it. This removes one variable and at least one clause in one branch and one
variable and at least D clauses in the other branch (remind that F does not
contain pure literals). Now consider the case when F consists of D− -literals
Algorithm MaxSatAlg
Parameters: a positive real number D.
Input: a CNF formula F .
Output: MCl(F ).
Method.
1. Assign the value True to all pure literals of F .
2. If F is empty, then return 0.
3. If F contains a D+ -literal a, then recursively call for F [a] and F [¬a] and return
the answer.
4. Let a be any literal of F . Let also i = d(a), j = d(¬a).
5. Find optimal assignments for Fa and F¬a . Denote them by αa = {x1 , . . . , xp } and
α¬a = {y1 , . . . , yq }, respectively, and let
ka = MCl(Fa ) = Cl(F, αa ) ,
k¬a = MCl(F¬a ) = Cl(F, α¬a ) .
6. If i + k¬a ≥ j + ka , then recursively call for
F [a], F [¬a, ¬y1 ], F [¬a, y1 , ¬y2 ], . . . , F [¬a, y1 , . . . , yq−1 , ¬yq ]
and return the answer.
7. Otherwise recursively call for
F [¬a], F [a, ¬x1 ], F [a, x1 , ¬x2 ], . . . , F [a, x1 , . . . , xp−1 , ¬xp ]
and return the answer.
Fig. 2. An algorithm for MAX-SAT
only. Assume w.l.o.g. that i + k¬a ≥ j + ka (remind that a is an (i, j)-literal).
We claim that α¬a ∪ a F α¬a ∪ ¬a. Indeed, consider any total assignment β to
F . By (1),
Cl(F, β α¬a ∪a ) = i + k¬a + Cl(F−a , β α¬a ) ,
while by (2),
Cl(F, β α¬a ∪¬a ) ≤ j + ka + Cl(F−a , β α¬a ) .
So, β α¬a ∪a satisfies at least as many clauses of F as β α¬a ∪¬a (for any β) and
we conclude that α¬a ∪ a F α¬a ∪ ¬a. Thus, we do not need to consider any
extension of α¬a in the ¬a-branch. Thus, we can split as follows:
F [a], F [¬a, ¬y1 ], F [¬a, y1 , ¬y2 ], . . . , F [¬a, y1 , . . . , yq−1 , ¬yq ] .
If i + k¬a < j + ka , then by using exactly the same argument one can show that
αa ∪ ¬a F αa ∪ a. This ensures that MaxSatAlg is correct.
Now let us estimate the running time. We use the following complexity measure (for w = w(∆) defined later):
n(F ) + wm(F ), if F contains a D+ -literal,
γ(F ) =
n(F ),
otherwise.
If a formula contains a D+ -literal, the algorithm splits with a splitting number
at most τ (1 + w, 1 + wD). Otherwise, the splitting number is at most rD =
τ (1, 2, . . . , D + 1) (as p, q ≤ D). Now let d be any constant bigger than ∆.
Assume now that there exists constants w and D, such that
1
1
τ (1 + w, 1 + wD) ≤ 2 1+wd and τ (1, . . . , D + 1) ≤ 2 1+wd .
Then the running time of the algorithm is bounded by
γ
n+wm
1+w∆
2 1+wd ≤ 2 1+wd ≤ 2n 1+wd = cn ,
1+w∆
where c = 2 1+wd < 2 is a constant. Below we prove that such w and D exist.
It is easy to see that for any integer D ≥ 1 there exists wD > 0 such that
1
τ (1, . . . , D + 1) = 2 1+wD d (since τ (1, . . . , D + 1) < 2). Thus, it is sufficient to find
1
an integer D such that τ (1 + wD , 1 + wD D) ≤ 2 1+wD d . To show this it suffices
√1
to show that (1 + wD d)2 ≤ (1 + wD )(1 + wD D) (since τ (a, b) ≤ 2 ab ). The last
inequality is equivalent to wD d2 +2d ≤ D +1+wD D, which is obviously satisfied
for large enough D.
t
u
4
MAX-2-SAT
In this section we present a new algorithm for MAX-2-SAT with a running time
2m/5.88 ≈ 1.12512m . It extends an algorithm by Kojevnikov and Kulikov [14]
by using the idea of clause learning. The analysis is mostly the same as in [14]
with several cases improved. The algorithm first simplifies an input formula by
applying (as long as it is possible) to it almost common clauses, pure literal, dominating unit clause, and frequently meeting variables rules. We do not describe
here the rules in detail (see [14]), but provide several important properties of simplified formulas in Lemma 1, where by a simplified formula we mean a formula
for which no rule described above is applicable. After simplifying the algorithm
just splits a resulting formula by assigning Boolean values to some variables.
Before stating some known properties of this algorithm we give some additional definitions. For a literal l, by d1 (l) we denote the number of unit clauses
(l) in a formula and by d2 (l) we denote the number of 2-clauses containing the
literal l. By weight of a variable x we mean d2 (x) + d2 (¬x).
Lemma 1 ([14]).
– A simplified formula does not contain variables of weight at most 2.
– A simplified formula does not contain clauses of the form (xy) and (¬xy).
– If a variable x occurs at most one time without a variable y, then a formula
can be simplified.
– If F is a simplified formula, (xy) ∈ F and y has weight 3, then at least in
one of the formulas F [x] and F [¬x] the simplification rules assign a Boolean
value to y.
– If a simplified formula F contains only variables of weight 3, then there is a
variable x, such that both F [x] and F [¬x] (after simplifying) contain at least
6 variables fewer than F .
The running time of the algorithm by Kojevnikov and Kulikov is estimated
w.r.t. the following complexity measure:
γ(F ) = N3 + 1.9 · N4 (F ) +
X i · Ni (F )
2
i≥5
,
where Ni (F ) is the number of variables of weight i of F . We change the coefficients as follows:
γ(F ) = 0.98 · N3 + 1.96 · N4 (F ) +
X i · Ni (F )
i≥5
2
.
Thus, we have to prove that the algorithm always splits a simplified formula
with a splitting number at most τ (5.88, 5.88). Note that reducing the weight of
any variable in a simplified formula reduces γ at least by 0.5 (as the difference
between any two coefficients before Ni is at least 0.5). First consider the case,
when a formula F contains a variable x of weight w ≥ 6. In this case we can
just split on this variable. This reduces γ at least by w in the both branches:
eliminating x reduces γ at least by w/2, decreasing the weight of neighbors of x
further reduces γ at least by w/2.
Now consider a case when F contains only variables of weight at most 4. Let
x be a variable of weight 4. For 1 ≤ i ≤ j ≤ 4, let kij denote the number of
neighbors of x that have weight j and occur i times with x. It is easy to see
that such a neighbor of x becomes a variable of weight (j − i) after assigning a
Boolean value to x. By Lemma 1, kij = 0 for j ≤ 2 and for j −i ≤ 1. So, only k13 ,
k14 and k24 can be positive. Since x is a variable of weight 4, k13 +k14 +2k24 = 4.
Now let F 0 be a formula obtained from F by assigning a Boolean value to x.
Then,
γ(F ) − γ(F 0 ) = (0.98 · k13 + 1.96 · (k14 + k24 + 1)) − 0.98 · k14 =
0.98 · (k13 + k14 + 2k24 ) + 1.96 = 0.98 · 4 + 1.96 = 5.88 .
If F contains only variables of weight at most 3, then by Lemma 1 we can always
find a (6, 6)-splitting w.r.t. n. This gives a (5.88, 5.88)-splitting w.r.t. γ, since
γ(F ) = 0.98 · n(F ). The only remaining case is when a formula contains at least
one variable of weight 5 and all other variables have weight at most 5 and this
is the case where we explore clause learning.
First, let us calculate a straightforward splitting number. It is done similarly
to the case with a variable of weight 4:
k13 + k14 + k15 + 2k24 + 2k25 + 3k35 = 5 ,
γ(F ) − γ(F 0 ) =
(0.98 · k13 + 1.96 · (k14 + k24 ) + 2.5 · (k15 + k25 + k35 + 1))
−(0.98 · (k14 + k25 ) + 1.96 · k15 )
= 0.54 · (k13 + k14 + k15 + 2k24 + 2k25 + 3k35 ) + 2.5
+0.44 · (k13 + k14 + 2k24 + k25 + 2k35 )
= 5.2 + 0.44 · (k13 + k14 + 2k24 + k25 + 2k35 ) .
Thus, if
(k13 + k14 + 2k24 + k25 + 2k35 ) ≥ 2
(3)
then we already have a required splitting number. This, in particular, means
that we do not need to consider cases when either k24 > 0 or k35 > 0.
The idea of clause learning is used in the following lemma, which says that for
any two neighbors of a we do not need to consider extensions of some assignment
to these neighbors in one of the branches.
Lemma 2. Let F be a simplified 2-CNF formula, a be a variable of weight 5
and l, l0 be literals appearing with a. Then either
{a, l1 , l2 } F {¬a, l1 , l2 } or {¬a, l1 , l2 } F {a, l1 , l2 } ,
where l1 is either l or ¬l and l2 is either l0 or ¬l0 .
Proof. Let F contain i2 2-clauses with literal a, j2 2-clauses with ¬a, i1 clauses
(a) and j1 clauses (¬a). Note that Fa and F¬a consist of i2 and j2 unit clauses,
respectively.
Now, from the fact that 5 = (i2 + j2 ) = (i1 + i2 − j1 ) + (j1 + j2 − i1 ) we
conclude that either (i1 +i2 −j1 ) or (j1 +j2 −i1 ) is at least 3. W.l.o.g. we assume
that i1 + i2 − j1 ≥ 3.
Let α be a total assignment to F . Then, by (1) and (2),
Cl(F, αa ) = i1 + i2 + Cl(F¬a , α) + Cl(F−a , α) ,
Cl(F, α¬a ) = j1 + j2 + Cl(Fa , α) + Cl(F−a , α) .
Thus,
Cl(F, αa ) − Cl(F, α¬a ) = i1 + i2 − j1 − j2 + Cl(F¬a , α) − Cl(Fa , α)
≥ 3 − j2 + Cl(F¬a , α) − Cl(Fa , α)
Note that Cl(F¬a , α) − Cl(Fa , α) ≥ −i2 , as α satisfies at least 0 clauses of
F¬a and at most i2 clauses of Fa . If (l) or (¬l) is in F¬a , we set l1 to be a literal
satisfying this unit clause. Otherwise, if (l) or (¬l) is in Fa , we set l1 so that it
falsifies the corresponding clause. The literal l2 is defined similarly. Then, for any
α 3 l1 , l2 , Cl(F¬a , α) − Cl(Fa , α) ≥ −i2 + 2, and hence Cl(F, αa ) − Cl(F, α¬a ) ≥
3−j2 −i2 +2 ≥ 0. Thus, we have shown that for any total assignment α such that
a, l1 , l2 ∈ α, Cl(F, αa ) ≥ Cl(F, α¬a ), which means that {a, l1 , l2 } F {¬a, l1 , l2 }.
t
u
Let us give an example of using this lemma. Suppose that F contains the
following five clauses: (al1 )(al2 )(al3 )(¬al4 )(¬al5 ) (and does not contain any other
clauses with variable a). Lemma 2 implies that {a, ¬l2 , l4 } F {¬a, ¬l2 , l4 }.
Indeed, any extension of {¬a, ¬l2 , l4 } satisfies at most 4 of the mentioned above
clauses (as (al2 ) is falsified), while any extension of {a, ¬l2 , l4 } satisfies at least
4 of these clauses.
Now we consider all the remaining cases. Remind that F contains only
variables of weight at most 5 and let a be a variable of weight exactly 5.
First consider the case when a has a neighbor b of degree 3. By (3), k13 = 1
and k15 = 4. By Lemma 1, b is assigned a Boolean value in at least one
of the branches F [a] and F [¬a], moreover all three neighbors of b are different variables. Thus, splitting on a provides a splitting number not exceeding
τ (5.2 + 0.44, 5.2 + 0.44 + 2 · 0.54) < 1.12.
Suppose that a appears with some variable b twice. This means, by (3),
that k25 = 1 and k15 = 3. Lemma 2 implies that {la , lb } F {¬la , lb }, where
la and lb are literals of a and b. Thus, we can assign a Boolean value to b
in one of the branches F [a] and F [¬a]. The corresponding splitting number is
τ (5.2 + 0.44, 5.2 + 0.44 + 0.98) < 1.121.
Now we know that a has exactly five different neighbors. Moreover, by (3)
at most one of them has weight at least 4, while all other have weight exactly 5
(in other words, k14 ≤ 1, k15 ≥ 4, k14 + k15 = 5). W.l.o.g. we can assume that
d1 (a) + d2 (a) − d1 (¬a) ≥ 3 (otherwise, we consider ¬a instead of a). Let b1 , b2
be any two literals appearing together with the literal a and c be any literal
appearing together with the literal ¬a. Lemma 2 then implies that
{a, ¬b1 , ¬b2 } F {¬a, ¬b1 , ¬b2 } ,
{a, ¬b1 , c} F {¬a, ¬b1 , c} .
Thus we can split F to F [a], F [¬a, b1 ], F [¬a, ¬b1 , b2 , . . . , bi2 , ¬c1 , . . . , ¬cj2 ],
where b1 , . . . , bi2 and c1 , . . . , cj2 are all literals appearing together with the literals a and ¬a, respectively. So all we have to do is to show that this splitting
gives good splitting number in all the remaining cases. First, rename the literals
so that the splitting above corresponds to a splitting
F [a], F [¬a, l1 ], F [¬a, ¬l1 , l2 , l3 , l4 , l5 ] .
Let l1 , l2 , l3 , l4 be literals of variables of weight 5 variables and l5 be literal of a
variable of weight d, where d ∈ {4, 5}.
Assume that l1 has at least three neighbors of degree less than 5 in F [¬a].
Then the straightforward splitting number is τ (5.2 + 0.44 · (5 − d), 5.2 + 0.44 ·
(5 − d) + 1.96 + 3 · 0.98 + 0.54, 5.2 + 0.44 · (5 − d) + 5 · 1.96 + (d − 5) · 0.98). In both
cases it does not exceed 1.1249. Otherwise, the neighborhood of {l1 , l2 , l3 , l4 }
in F [¬a] contains at least 8 literals of variables of weight 5 (and hence these
are different from l1 , l2 , l3 , l4 , l5 ). In this case it is not difficult to show that the
splitting number does not exceed τ (5.2 + 0.44 · (5 − d), 5.2 + 0.44 · (5 − d) + 1.96 +
4 · 0.54, 5.2 + 0.44 · (5 − d) + 5 · 1.96 + (d − 5) · 0.98 + 2.94), hence, 1.1246.
References
1. Williams, R.: On computing k-CNF formula properties. In: Proceedings of the
6th International Conference on Theory and Applications of Satisfiability Testing.
Volume 2919 of Lecture Notes in Computer Science. (2003) 330–340
2. Robson, J.: Algorithms for maximum independent sets. Journal of Algorithms
7(3) (1986) 425–440
3. Marques-Silva, J., Sakallah, K.: Grasp: a search algorithm for propositional satisfiability. IEEE Transactionon Computers 48(5) (1999) 506–521
4. Moskewicz, M., Madigan, C., Zhao, Y., Zhang, L., Malik, S.: Chaff: engineering an
efficient SAT solver. In: Proceedings of the 38th Design Automation Conference.
(2001) 530–535
5. Zhang, H.: Sato: An efficient propositional prover. In: Proceedings of the 14th
International Conference on Automated Deduction. Volume 1249 of Lecture Notes
in Computer Science. (1997) 272–275
6. Beame, P., Impagliazzo, R., Pitassi, T., Segerlind, N.: Memoization and DPLL:
formula caching proof systems. In: Proceedings of 18th IEEE Annual Conference
on Computational Complexity. (2003) 248–259
7. Dantsin, E., Wolpert, A.: MAX-SAT for formulas with constant clause density
can be solved faster than in O(2n ) time. In: Proceedings of the 9th International
Conference on Theory and Applications of Satisfiability Testing. Volume 4121 of
Lecture Notes in Computer Science. (2006) 266–276
8. Williams, R.: A new algorithm for optimal 2-constraint satisfaction and its implications. Theoretical Computer Science 348 (2005) 357–365
9. Niedermeier, R., Rossmanith, P.: New upper bounds for MaxSat. In: Proceedings of
Automata, Languages and Programming: 26th International Colloquium. Volume
1644 of Lecture Notes in Computer Science. (1999) 575–585
10. Hirsch, E.A.: A 2K/4 -time algorithm for MAX-2-SAT: Corrected version. ECCC
Report TR99-036, Revision 02 (2000)
11. Gramm, J., Hirsch, E.A., Niedermeier, R., Rossmanith, P.: Worst-case upper
bounds for MAX-2-SAT with an application to MAX-CUT. Discrete Applied
Mathematics 130(2) (2003) 139–155
12. Scott, A., Sorkin, G.: Faster algorithms for MAX CUT and MAX CSP, with
polynomial expected time for sparse instances. In: Proceedings of 7th International
Workshop on Randomization and Approximation Techniques in Computer Science.
Volume 2764 of Lecture Notes in Computer Science. (2003) 382–395
13. Kneis, J., Rossmanith, P.: A new satisfiability algorithm with applications to MaxCut. Technical Report AIB2005-08, Dept. of Computer Science, RWTH Aachen
University (2005)
14. Kojevnikov, A., Kulikov, A.S.: A new approach to proving upper bounds for
MAX-2-SAT. In: Proceedings of the Seventeenth Annual ACM-SIAM Symposium
on Discrete Algorithms. (2006) 11–17
15. Kneis, J., Moelle, D., Richter, S., Rossmanith, P.: Algorithms based on the
treewidth of sparse graphs. In: Proceedings of the 31st International Workshop
on Graph-Theoretic Concepts in Computer Science. Lecture Notes in Computer
Science (2005) 385–396
16. Scott, A.D., Sorkin, G.B.: Linear-programming design and analysis of fast algorithms for Max 2-SAT and Max 2-CSP. Discrete Optimization (2006) to appear.
17. Kullmann, O., Luckhardt, H.: Algorithms for SAT/TAUT decision based on various
measures. Preprint (1998)
18. Kulikov, A.S.: Automated generation of simplification rules for SAT and MAXSAT.
In: Proceedings of the Eighth International Conference on Theory and Applications
of Satisfiability Testing. Volume 3569 of Lecture Notes in Computer Science. (2005)
430–436