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¨ unchen, 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¨ olle, 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