An Improved Upper Bound for SAT
aa r X i v : . [ c s . D S ] J u l An Improved Upper Bound for SAT
Huairui Chu
School of Computer Science andEngineering, University of ElectronicScience and Technology of China, China, [email protected]
Mingyu Xiao
School of Computer Science andEngineering, University of ElectronicScience and Technology of China, China, [email protected]
Zhe Zhang
School of Computer Science andEngineering, University of ElectronicScience and Technology of China, China,
Abstract
We show that the CNF satisfiability problem can be solved O ∗ (1 . m ) time, where m is the number of clauses in the formula, improving the known upper bounds O ∗ (1 . m )given by Yamamoto 15 years ago and O ∗ (1 . m ) given by Hirsch 22 years ago. By usingan amortized technique and careful case analysis, we successfully avoid the bottlenecks inprevious algorithms and get the improvement. The problem of testing the satisfiability of a propositional formula in conjunctive normal form(CNF), denoted by SAT, is one of the most fundamental problems in computer science. It isthe first problem proved to be NP-complete [2] and plays an important role in computationalcomplexity and artificial intelligence [9]. To make the problem tractable, a large number ofreferences studied it from the view of heuristic algorithms, approximation algorithms, random-ized algorithms, and exact algorithms. In this paper, we study exact algorithms for SAT withguaranteed theoretical running time bounds.
To evaluate the running time bound, there are three frequently used measures: the number ofvariables n , the number of clauses m , and the length of the whole input L . The trivial algorithmto check all possible assignments runs in O ∗ (2 n ) time . A nontrivial bound better than O ∗ (2 n )was obtained in [5], which is O ∗ (2 n (1 − √ /n log m ) ). Later better upper bounds were introducedin [6] and [21]. However, no algorithm with running time bound O ∗ ( c n ) for some constant c < k -SAT problem (where each clause in the CNF-formula contains at most k literals), a seriesof significant results have been developed. A branch-and-bound technique was introduced in [17]and [3], which can solve k -SAT in O ∗ (( α k ) n ) time where α k is the largest root of the function x = 2 − /x k − . After this, a series of improvements on the upper bounds for k -SAT have beenmade. Most of them are based on derandomization, such as the O ∗ (2 (1 − / k ) n ) bound in [19] The notation O ∗ suppresses all polynomially bounded factors. For two functions f and g , we write f ( n ) = O ∗ ( g ( n )) if f ( n ) = g ( n ) n O (1) . O ∗ ((2 − / ( k + 1)) n ) bound in [4]. Recently a new randomized algorithm for k -SATwith better running time bound was introduced [11].When the length of the input L is taken as the measure, from the first algorithm with runningtime bound O ∗ (1 . L ) by Gelder [10], the result was improved frequently. Let us quote thebound O ∗ (1 . L ) by Kullmann [15], O ∗ (1 . L ) by Hirsch [12], O ∗ (1 . L ) by Hirsch [13],and O ∗ (1 . L ) by Wahlstr¨om [22]. Currently, the best known bound was O ∗ (1 . L ) obtainedby Chen and Liu [1].Another important measure is the number of clauses m . Monien and Speckenmeyer [16] gavean O ∗ (1 . m )-time algorithm in 1980, which was improved to O ∗ (1 . m ) by Hirsch [12] in 1998.Then it took seven years for Yamamoto to slightly improve Hirsch’s bound to O ∗ (1 . m ) [23].In this paper, we will significantly improve Yamamoto’s bound obtained 15 years ago. Previousand our results are listed in Table 1.Table 1: Previous and our upper bounds for SATrunning times references O ∗ (1 . m ) [16] O ∗ (1 . m ) [12] O ∗ (1 . m ) [23] O ∗ (1 . m ) This paper
All algorithms in Table 1 are branch-and-search algorithms. The branch-and-search idea issimple and practical: we iteratively branch on a literal into two branches by letting it be 1 or0. Consider an ( a, b )-literal (a literal such that itself appears in a clauses and the negation of itappears in b clauses). In the branching where the literal is assigned 1, we can reduce a clauses;in the branching where the literal is assigned 0, we can reduce b clauses. We hope that thevalues of a and b are larger, so that we can reduce the instance to a greater extent. There areseveral developed techniques to deal with ( a, b )-literals with small values of a and b , say one ofthem is at most 2. Thus the worst case will become to branch on a (3 , ,
3) and a branching factor 1.2600. We get the bound of O ∗ (1 . m ) [16]. It seems that branching on (3 , , ,
3) or (3 ,
4) subsequently. Combing the bad branching vector (3 ,
3) with the good branchingvector (4 ,
3) or (3 , O ∗ (1 . m ). Yamamoto [23] further showed that the worst cases in Hirsch’s algorithm wouldnot always happen: we can further branch with (4 ,
3) or (3 ,
4) at the third level, i.e., afterbranching with (4 ,
3) or (3 ,
4) after branching with (3 , O ∗ (1 . m ). The improvement isvery slow, and we seem to have reached the bottleneck.Our algorithm is still a branch-and-search algorithm, following the main framework in theprevious algorithms. We still can not avoid branching on (3 , , , O ∗ (1 . m ). We also show that after branching on a (3 , Let V = { x , x , . . . , x n } denote a set of n boolean variables . For each variable x i ( i =1 , , , . . . , n ), a literal is either x i or the negation of it x i (we use x to denote the negationof a literal x , and then x = x ). A clause on V is a set of literals on V without a negation of anyliteral in it, which means x and x cannot be contained simultaneously in a clause for any variable x ∈ V . A CNF-formula on V is a sequence of clauses F = { C , C , C , . . . , C m } . We will use m F to denote the number of clauses in F . An assignment for V is a map A : V → { , } . Aclause C j on V is satisfied by A if and only if there exists a literal x in C j such that A ( x ) = 1.A CNF-formula is satisfied by an assignment A if and only if each clause in it is satisfied by A .An assignment A that makes a CNF-formula F satisfied is called a satisfying assignment for F .Given a CNF-formula F on a set of variables V , the SAT problem is to check the existence of asatisfying assignment for F .The degree of a literal x in F is the number of clauses in F containing it. The total degree of a literal x is the degree of x plus the degree of x . If the degree of x is a (resp., at least a orat most a ) and the degree of x is b , we say x is an ( a, b ) -literal (resp., an ( a + , b ) -literal or an( a − , b ) -literal ). Similarly, we can define ( a, b + )-literal, ( a, b − )-literal, ( a + , b + )-literal, ( a − , b − )-literal and so on. Note that a literal x is an ( a, b )-literal if and only if x is a ( b, a )-literal. Aclause containing exactly c literals is called a c -clause . A pair of literals x and y is called a coincident pair if there are at least two clauses containing them simultaneously.Our algorithm will first apply reduction rules to reduce the instance and then apply branchingrules to search for a solution when the instance can not be further reduced. Next, we firstintroduce the reduction rules. We have five reduction rules. The first two are easy to observe and used in the literature [7].
R-Rule 1 (Elimination of 1-clauses and pure literals)
If the CNF-formula contains a -clause { x } or an ( a, -literal x with a > , assign x = 1 . R-Rule 2 (Elimination of subsumptions)
If the CNF-formula contains two clauses C and C ′ such that C ⊆ C ′ , then delete C ′ . The following proposition is known as the resolution technique in the literature, which wasfirst proved in [20], and then used in many SAT algorithms.
Definition 1 (Resolution on a variable)
Let F be a CNF-formula containing a variable x .Let E , E , . . . , E a be the clauses containing x and D , D , . . . , D b be the clauses containing ¯ x . Resolving on variable x is to construct a new CNF-formula F \ x by the following method: foreach i ∈ { , , . . . , a } and j ∈ { , , . . . , b } , add the clause F ij = E i ∪ D j \ { x, ¯ x } to the formulaif it does not contain both a literal and the negation of it; delete E i ( i ∈ { , , . . . , a } ) and D j ( j ∈ { , , . . . , b } ) from the formula. We may always use F \ x to denote the CNF-formula after resolving a variable x in F . Proposition 1 [20]
Let F be a CNF-formula containing a variable x and F \ x be the CNF-formula after resolving on variable x . Then F has a satisfying assignment if and only if F \ x does. -Rule 3 (Resolving on some variables) If there is an ( a, b ) -literal x such that a = 1 and b ≥ or a = 2 and b = 2 , then resolve x in F , i.e., replace F with F \ x . We also introduce a simple but powerful concept, based on which we can design severalreduction rules.
Definition 2 (Autarkic sets)
A set X of literals is called an autarkic set if each clausecontaining a negation of a literal in X also contains a literal in X . Lemma 1
If a CNF-formula F has a satisfying assignment, then it has a satisfying assignmentwhere all literals in an autarkic set are assigned 1.Proof. If we assign 1 to all literals in an autarkic set X , then any clause containing either aliteral in X or a negation of a literal in X is satisfied, since each clause containing a negation ofa literal in X also contains a literal in X . Any other assignment of literals in X can only satisfya subset of these clauses. So we can simply assign 1 to all literals in X .The following reduction rule was firstly used in [12]. It is an application of a special autarkicset. R-Rule 4 [12]
If each clause containing a (2 , + ) -literal also contains a (3 + , -literal, assign to each (3 + , -literal. Our algorithm also needs to eliminate another kind of autarkic sets.
R-Rule 5
Let X be the set of (4 , -literals x such that there is a clause containing both x and a (3 , + ) -literal. If each clause containing a negation of a literal in X also contains a (4 , -literal,assign to each literal in X . Each clause containing a negation of a literal x ∈ X also contains a (4 , y . Since ¯ x is a (3 , y is also in X . Thus X is an autarkic set. In this reduction rule,the requirement of ‘a clause containing both x and a (3 , + )-literal’ plays no role in establishing X to be an autarkic set. This requirement is used to identify a particular subset of (4 , Lemma 2
After applying any of the above reduction rules, the satisfiability of the formula doesnot change. Except for the application of R-Rule 3 on a (2 , -literal where the number of clausesdoes not increase, each application of other reduction rules decreases the clause number by atleast 1. Definition 3 (Reduced formulas)
A formula is called reduced if none of the five reductionrules can be applied on the formula.
For an instance F , we will use R ( F ) to denote the resulting reduced formula after iterativelyapplying the reduction rules on F . Lemma 3
Given a formula, we can apply the five reduction rules in polynomial time to changeit to a reduced formula.Proof.
It is easy to see that each reduction rule can be applied in polynomial time. Since eachreduction rule either assigns a literal to 1 or resolve a variable, we know that we can apply atmost n times of reduction rules. Thus, the total running time is bounded by a polynomial.4 emma 4 Let F be a reduced formula. Then there is no 1-clause, (2 , -literal or (1 − , a ) -literalwith a ≥ in F . Furthermore, the total degree of any literal in F is at least .Proof. If there is a (0 , a )-literal, then R-Rule 1 would be applicable. If there is a (1 , a )-literal,then R-Rule 3 would be applicable. If there is a (2 , F isreduced.If a literal has a total degree at most 4, then it must be a (2 ,
2) or (1 − , a ) or ( a, − )-literal.For the last case, the negation of the literal is a (1 − , a )-literal. Our algorithm will first apply our reduction rules to reduce the instance. When no reductionrule can be applied anymore, we will branch to search for a solution. Our branching rule issimple. We take a literal x and branch on it into two sub-instances. In one sub-instance weassign x = 1 and in the other one we assign x = 0, i.e, we get two sub instances F x and F ¯ x .Selecting different literals to branch will lead to different algorithms. We want to select ‘good’literals to branch on such that the size of the sub instances can be reduced fast.We use the number m of clauses to evaluate the size of the formula. Assume the numberof clauses of the current instance is m . If a branching operation branches into l sub-branchessuch that the number of clauses in the i -th sub-instance decreases by at least c i , we say thisoperation branches with a branching vector ( c , c , . . . , c l ). The largest root of the function f ( x ) = 1 − P li =1 x − c i is called the branching factor . If γ is the maximum branching factoramong all branching factors in an algorithm, then the running time of the algorithm is boundedby O ∗ ( γ m ). More details about the analysis and how to solve recurrences can be found in themonograph [8]. The following property is frequently used in the paper: for two branching vectors C = ( c , c , . . . , c l ) and B = ( b , b , . . . , b l ), if it holds that c i ≥ b i for each i , then we say B covers C . The corresponding branching factor of a branching vector C is not greater than thecorresponding branching factor of a branching vector that covers C . Similar to the technique used by Niedermeier and Rossmanith to solve the 3-hitting set prob-lem [18], we also classify formulas in our algorithm into two classes: good formulas and badformulas. For good formulas, we may be able to branch with good branching vectors. For badformulas, we may only be able to get bad branching vectors. We will show that bad formulas willnot appear frequently. Then we can use an amortized analysis to get better branching vectors.To make the amortized analysis easy to follow, we will use the substitution method to prove ourbounds. The precise definitions of good and bad formulas are given below.
Definition 4 (Good formulas & bad formulas)
A formula F is a bad formula if and onlyif the following four conditions are satisfied(1) F only contains (3 , -literals, (3 , -literals and (4 , -literals.(2) There is no coincident pair.(3) There is no -clause.(4) There is no clause containing a (4 , -literal and a (3 , + ) -literal simultaneously.A formula is good if it is not a bad formula. .2 The algorithm and its analysis The main steps of our algorithm are listed in Algorithm 1. The precise descriptions and analysisof lines 11 and 14 are delayed to Sections 6.1 and 6.2.
Algorithm 1
SAT( F ) if {F is not reduced } then Iteratively apply our reduction rules to reduce it. end if if {F is empty } then Return true. end if if {F contains an empty clause } then Return false. end if if {F is a bad formula } then Apply branching rules in Sec. 6.1 to search for a solution. end if if {F is a good formula } then Apply branching rules in Sec. 6.2 to search for a solution. end if
Recall that, for an instance F , R ( F ) is the resulting reduced instance after applying thereduction rules on F , and m F is the number of clauses in F . We have the following importantlemmas, which are the base for us to establish the running time bound. Lemma 5
Let F be a CNF-formula. It holds that m R ( F ) ≤ m F . Furthermore, if F is good,then either R ( F ) is good or m R ( F ) ≤ m F − .Proof. By Lemma 2, we have that m R ( F ) ≤ m F . Next, we assume that F is good.If R ( F ) = F , obviously R ( F ) is good. So we assume that some R-Rules are applied. ByLemma 2, we know that if m R ( F ) = m F then only R-Rule 3 is applied on (2 , F ′ with a (2 , x in it, we show that after applying R-Rule 3 on x the resulting instance F ′\ x is good. Let the two clauses containing x in F ′ be D and D , the two clauses containing ¯ x be E and E . If m F ′ = m F ′\ x , then all E ij = D i ∪ E j \ { x, ¯ x } for each 1 ≤ i, j ≤ F ′\ x . Ifone of D , D , E and E contains at least three literals, then we will get some coincident pair.Otherwise, each E ij is a 2-clause. For any case, F ′\ x is good. Lemma 6
If the formula F is reduced and bad, then our algorithm can branch with either abranching vector covered by (3 , or (4 , , or a branching vector (3 , such that the formula ineach branch is good. Lemma 7
If the formula to branch is reduced and good, then our algorithm can branch witheither a branching vector covered by one of (3 , , (5 , , and (4 , , or a branching vector (3 , or (4 , such that the formula in each branch is good. The proof of Lemma 6 and Lemma 7 are given in Sections 6.1 and 6.2, respectively. Next,we prove the running time bound of the algorithm based on Lemma 5, Lemma 6, and Lemma 7.
Theorem 1
SAT can be solved in O ∗ (1 . m ) time. roof. We use T ( F ) to denote the size of the search tree generated by the algorithm runningon an instance F . We only need to prove that T ( F ) = O (1 . m F ). To prove the theorem, wewill show that there are two constants c = 2 and c = c / . T ( F ) ≤ c . m F − , if F is good, (1)and T ( F ) ≤ c . m F − , if F is bad. (2)First of all, we show that we can assume F is a reduced instance without loss of generality.If the current instance F with m clauses is not a reduced one, our algorithm will apply reductionrules on it to get a reduced instance F ∗ with m ∗ clauses. To prove that (1) and (2) hold for F , we only need to prove that (1) and (2) hold for F ∗ . The reason is based on the followingobservations. If both of F and F ∗ are bad or good, then it holds that c i . m F∗ ≤ c i . m F since m F ∗ ≤ m F by Lemma 5. If F is bad and F ∗ is good, then it holds that c . m F∗ ≤ c . m F . If F is good and F ∗ is bad, then it still holds that c . m F∗ ≤ c . m F because now we have m F ∗ ≤ m F − c < . c .Next, we simply assume that the instance F is reduced and use F and F to denote thetwo sub instances generated by our branching operations. We use the substitution method toprove (1) and (2).Assume that T ( F ) ≤ c i . m F − c i = c if F is good and c i = c if F is bad)holds for all instances F with less than m clauses. We show that it also holds for instances with m clauses.First, we consider the case where F is bad. According to Lemma 6, there are two cases. Forthe first case of branching with a vector (3 ,
4) or (4 , T ( F ) = T ( R ( F )) + T ( R ( F )) + 1 ≤ c . m R ( F + c . m R ( F − c < c ) ≤ c . m F − + c . m F − − ≤ c . m F − . For the second case of branching with a vector (3 , T ( F ) = T ( R ( F )) + T ( R ( F )) + 1 ≤ c . m F − + c . m F − − ≤ c . m F − . Second, we consider the case where F is good. According to Lemma 7, there are two cases.In the first case, the branching vector is (3 ,
5) or (5 ,
3) or (4 , ,
5) or (5 , T ( F ) = T ( R ( F )) + T ( R ( F )) + 1 ≤ c i . m F − + c i . m F − − ≤ c . m F − + c . m F − − ≤ c . m F − , c i , c i ∈ { , } . If the branching vector is (4 , T ( F ) = T ( R ( F )) + T ( R ( F )) + 1 ≤ c i . m F − + c i . m F − − ≤ c . m F − − ≤ c . m F − , where c i , c i ∈ { , } .For the second case of branching with a vector (3 ,
4) or (4 ,
3) such that the two sub instancesare good, we have that T ( F ) = T ( R ( F )) + T ( R ( F )) + 1 ≤ c . m F − + c . m F − − ≤ c . m F − . We have proved that (1) and (2) hold for F . Thus, it holds that T ( F ) = O (1 . m F ), nomatter F is good or bad. Before giving the detailed steps of the branching operations, we give some properties that willbe used to simplify our presentation and analysis.In a branching operation, we need to analyze the branching vector, i.e., the number of clausesdecreased in each branching. Sometimes we can get a branching vector good enough for ouranalysis, such as branching vectors (4 , ,
5) and (5 , Lemma 8
Let F be a formula containing a (3 − , + ) or (0 + , − ) -literal y . Assume the totaldegree of y is a > . If we delete from F at most a − clauses and some literals other than y and ¯ y , where at least one deleted clause contains y , then the resulting formula is good.Proof. Since the total degree of y is a , at least one clause containing y or ¯ y will not be deleted.Then y or ¯ y will be a (2 − , + )-literal in the remaining formula. Thus the formula is good. Corollary 1
Let F be a reduced formula containing only (3 − , − ) , (2 , + ) and (4 + , -literals.For any literal x in it with degree at most , the formula F x is good.Proof. By Lemma 4, we know that the total degree of any literal in F is at least 5 and F doesnot contain any 1-clauses. Note that F x is obtained from F by deleting all clauses containing x and deleting the literal ¯ x . Any literal different from x in a clause containing x will be the literal y in Lemma 8. By Lemma 8, we know the corollary holds.8 emma 9 Let F be a formula containing a (1 , + ) -literal x and at least two different (2 − , + ) -literals other than x and ¯ x . It holds that either m F \ x ≤ m F − and F \ x is a good formula or m F \ x ≤ m F − .Proof. Let the unique clause containing x be C and the clauses containing ¯ x be D , D , . . . D l .Let y and z be two different (2 − , + )-literals other than x and ¯ x , where y and z can be eachother’s negation.It is easy to see that resolving on x will decrease the number of clauses by at least 1. Weassume that the number of clauses decreases by exactly 1 after resolving on x and show for thiscase the formula F \ x must be good. For this case, the l + 1 clauses C, D , D , . . . D l are deletedand all the l clauses D i ∪ C \ { x, ¯ x } ( i = 1 , , . . . , l ) are added in F \ x .Case 1. x is a (1 , x , the degree of any literal does not increaseand no literal other than x and ¯ x disappears. So y and z are still (2 − , + )-literals, witnessingthe goodness of F \ x .Case 2. x is a (1 , + )-literal: We further distinguish two cases: | C | ≥ | C | ≤
2. If | C | ≥
3, then any pair of literals in C \ { x } will be a coincident pair in F \ x . Thus, F \ x is good.If | C | ≤
2, then at most one literal the degree of who will increase after resolving on x , sinceonly the degree of literals in C \ { x } will increase. So one of y and z will be remained as a(2 − , + )-literal in F \ x . Thus, F \ x is good. In this section, we show the detailed branching operations in Algorithm 1. Recall that weonly branch on reduced formulas. The detailed branching steps for bad and good formulas aregiven in Sec. 6.1 and 6.2, respectively. For a bad formula, if there exist (3 ,
4) or (4 , , , + ) or (4 + , + )-literals; second deal with (3 , , , + )-literals (and also (3 + , , ∗ ’ in the ‘Vectors’ column means the corresponding branch will leave a good formula. Fromthe two tables, we can see that direct analysis will get a bound of O ∗ (1 . m ) since the largestbranching factor is 1.2600. This does not use amortization. Our deep analysis in the proof ofTheorem 1 shows that we can improve the bound to O ∗ (1 . m ).Table 2: Branching for Bad FormulasCases Literals Vectors FactorsCase 1 (3 , , ∗ , ∗ ) 1.2600 F is a bad formula Case 1. F contains a (3 , x : We branch on x into two branchings F x and F ¯ x . Thebranching vector is (3 , Case 2. F only contains (3 , x into two branchings F x and F ¯ x . The branching vector is (3 , , + )-literals (3,5) 1.1939Case 1 (4 + , + )-literals (4,4) 1.1893Case 2 (3 , ∗ , ∗ ) or (4 ∗ , ∗ ) 1.2208Case 3 (2 , + )-literals (4,4) 1.1893(3,5) or (5,3) 1.1939(3 ∗ , ∗ ) or (4 ∗ , ∗ ) 1.2208Case 4 (3 , ∗ , ∗ ) or (4 ∗ , ∗ ) 1.2208 F is a good formula Case 1. F contains a (3 , + ) or (4 + , + )-literal x : Branch on x into two branchings F x and F ¯ x . The branching vector will be at least (3 ,
5) or (4 , Case 2. F contains a (3 , , + ) or (4 + , + )-literal): We further distinguishseveral cases to analyze the branching vector. Case 2.1. F also contains a (2 , + )-literal y : We first branch on an arbitrary (3 , x into two branchings F x and F ¯ x . If there is a clause containing both x and y , then in thebranching F x , the degree of y is at most 1. Thus y will become a (1 , + )-literal or (0 , + )-literalin F x and we will further apply R-Rule 1 or 3 on y to decrease the number of clauses by at least1. We can get a branching vector at least (4 , x and y , then in the branching F ¯ x , the degree of y is atmost 1. We apply R-Rule 1 or 3 on y to further decrease the number of clauses by at least 1.We can get a branching vector at least (3 , x or ¯ x does not contain y . For this case,we can only get a branching vector (3 , F x and F ¯ x , the newinstance is a good formula, because there is at least one (2 , + )-literal y in them. Case 2.2. F contains only (3 , , , Y be the setof (4 , x ′ such that there is a clause containing both x ′ and a (3 , + )-literal. Case 2.2.1. Y = ∅ : There is a literal x ∈ Y and a clause containing ¯ x which does notcontain any (4 , F would not be a reducedinstance. Thus the clause containing ¯ x will contain some (3 , + )-literals. We branch on x witha branching vector (4 , F x and F ¯ x are goodformulas. Case 2.2.2. Y = ∅ : For this case, (4 , , F is a goodformula now, we know either Condition (2) or Condition (3) will not hold. Thus there is eithera 2-clause or a coincident pair.First, we assume that F contains a coincident pair { x, y } . If x is a (3 , y must be a (3 , + )-literal. For this case, we branch on x into two branchings F x and F ¯ x . Inthe branching F x , literal y becomes a (1 , + )-literal or a (0 , + )-literal and we can reduce thenumber of clauses by 1 by applying R-Rule 3 or R-Rule 1 on y . We get a branching vector (4 , x and y are (3 , , , x, y ) or one of x and y becomes a literal of degree at most 2. Theremaining case is that both of x and y are (4 , x into twobranchings F x and F ¯ x with a branching vector (4 , F x is good because literal y becomes a (2 − , + )-literal. The formula F ¯ x is good by Lemma 8. Notice that for this case in F the clauses containing ¯ x cannot contain any (4 , , + )-literal.Second, we assume that F does not contain any coincident pair and there is a 2-clause { x, y } . We branch on x into two branchings F x and F ¯ x . In the branching F ¯ x , we get a 1-clausecontaining only y . Furthermore, F ¯ x has at least two clauses containing y because y and ¯ x donot form a coincident pair in F . We apply R-Rule 1 on y and can further decrease the numberof clauses by at least 2. We get a branching vector at least (3 , Case 3. F contains a (2 , + )-literal (but no (3 , + ) or (4 + , F contains only(2 , + )-literals, (3 + , , Case 3.1.
There is a 2-clause C = { x, y } containing a (3 + , + )-literal x : We do a deeperanalysis by considering different cases. Case 3.1.1.
Each clause containing ¯ x is a 2-clause: We branch on x . In the branching of F x , we will get at least two 1-clauses. By applying R-Rule 1 on them, we can further reduce 2clauses. In the branching of F ¯ x , we get at least one 1-clause. By applying R-Rule 1 on it, wecan further reduce 1 clause. So we can get a branching vector (5 ,
3) at least.Next, we can assume that there is a literal z
6∈ { x, ¯ x, y, ¯ y } appearing in a clause containing¯ x . Case 3.1.2.
At least one of x and y is a (3 , x is a (3 , x . In the branching of F ¯ x , there is a 1-clause { y } and we can reduce at least oneclause by applying R-Rule 1 on it. Because z exists, by Lemma 8 we know that if only fourclauses are removed in total, the remaining instance will be a good formula. In the branching of F x , three clauses are deleted and the remaining instance is also a good formula by Corollary 1.We can branch with a branching vector (3 ,
4) with a good formula in each remaining branchingor branch with a branching vector at least (3 , Case 3.1.3.
Both of x and y are (3 + , x also contains y , then we branch on y . In the branching of F y ,literal x will become a (2 + , x . In the branching of F ¯ y , we will have a 1-clause { x } . We can reduce at least one clause byapplying R-Rule 1 on { x } . Then we can get a branching vector (5 ,
3) at least.Otherwise, at most one clause containing ¯ x contains y . For this case, we branch on x . In thebranching of F ¯ x , we will have a 1-clause { y } . We can reduce at least two clauses by applyingR-Rule 1 on { y } . As z exists, by Lemma 8 we know if just 4 clauses are removed in total, theremaining instance is a good formula. For the branching of F x , three clauses are deleted and wecan apply Corollary 1. The remaining instance is also a good formula. So we get a branchingvector (3 ,
4) with a good formula in each remaining branching or a branching vector covered by(3 , Case 3.1.4.
Literal x is a (3 + , y is a (2 , + )-literal, and no clause contains bothof y and ¯ x : We branch on x . In the branching of F x , literal y will become a (1 − , + )-literal. Wecan reduce at least one clause by applying R-Rule 1 or R-Rule 3 on y . In the branching of F ¯ x ,we will have a 1-clause { y } and can reduce at least two clauses by applying R-Rule 1. Thus, wecan get a branching vector of (4 , Case 3.1.5.
Literal x is a (3 + , y is a (2 , + )-literal, and a clause contains both of y and ¯ x : We branch on x .Assume that there is a 2-clause other than C containing x . In the branching of F x , we canfurther decrease the number of clauses by at least 1 by applying R-Rule 3 on y . In the branching11f F ¯ x , we will get at least two 1-clauses and can further decrease the number of clauses by atleast 2 by applying R-Rule 1. We can get a branching vector covered by (4 , x , denoted by C and C , are both 3 + -clauses.We can simply assume that C i ( i = 1 ,
2) does contains C = ( x, y ) or both a literal and itsnegation, since for this case we can simply delete C i without branching. Thus C ∪ C willcontain at least two different literals z and z that are also different from x, ¯ x, y and ¯ y . If x is a(4 + , F x , we reduce at least four clauses directly and leave a (1 , + )-literal y . By applying R-Rule 1 or R-Rule 3 on y , we can further reduce at least one clause.So we can reduce at least five clauses for this case. Next, we assume that x is a (3 , F x , literal y will become a (1 , + )-literal, and literals z and z will becometwo different (2 − , + )-literals (also different from y and ¯ y ). By Lemma 9, we know that afterresolving y in F x , we can reduce one clause with the resulting formula being good or reduce atleast two clauses directly. So in the branching of F x , we can either reduce four clauses leaving agood formula or reduce at least five clauses. In the other branching of F ¯ x , we get a 1-clause { y } ,after applying R-Rule 1 on it we can further reduce one clause. If only three clauses are reducedin this branching, then the remaining formula is good. The reason is as below. In Case 3, F contains only (2 , + )-literals, (3 + , , z
6∈ { x, ¯ x, y, ¯ y } appears in a clause containing ¯ x (after Case 3.1.1). For this case, z will be a (2 − , + )-literal or(0 + , ,
3) leaving a good formula in each branching or a branching vectorcovered by (5 ,
3) or (4 , Case 3.2.
There is a 2-clause C = { x, y } containing two (2 , + )-literals: We consider twosubcases. Case 3.2.1.
There is no clause containing both of y and ¯ x : We branch on x . In thebranching of F x , literal y will become a (1 − , + )-literal. We can reduce one more clause byapplying R-Rule 3 on y . In the branching of F ¯ x , a 1-clause { y } is created and there are twoclauses containing y . We can reduce two more clauses by applying R-Rule 1 on y . We get abranching vector of (3 , Case 3.2.2.
There is a clause D containing both of y and ¯ x : If D is also a 2-clause, thenthere are two 2-clauses { x, y } and { ¯ x, y } . We simply assign y = 1 without branching. Next, weassume that D is a 3 + -clause.If D is a 3-clause, we branch on y . In the branching of F y , literal x will become a (1 − , + )-literal. We can reduce one more clause by applying R-Rule 3 on x . In the branching of F ¯ y , wewill get two -clauses { x } and { z } , where z is the third literal in D . By applying R-Rule 1 on { x } and { z } , we can reduce two more clauses. We get a branching vector of (3 , D is a 4 + -clause, and we branch on x . In the branching of F x , literal y will become a(1 , + )-literal. After applying R-Rule 3 on y , we reduce one more clause leaving a good formula,because D contains at least two literals other than y and ¯ x and then there is a coincident pairafter applying R-Rule 3 on y . In the branching of F ¯ x , we will get a 1-clause { y } . We can reduceone more clause by applying R-Rule 1 on it. Same as before, if just 4 clauses are removed,the remaining instance is good. Thus, we can either get a branching vector (3 ,
4) with a goodformula in each remaining branching or a branching vector covered by (3 , Case 3.3.
There is a clause in F containing both a (3 , x and a (2 , + )-literal y :Let C , C and C be the three clauses containing x , where we assume that C also contains y .Let C be the other clause containing y . We first branch on x with a branching vector (3 , Case 3.3.1. C = C or C = C : This means { x, y } is a coincident pair. In the branching F x , the literal y becomes a (0 , + )-literal. We can further remove at least two clauses by applyingR-Rule 1 on y . We get a branching vector (5 , C = C or C .12 ase 3.3.2. C = C and C = C : Notice that C and C are 3 + -clauses and each ofthem will contain a literal different from { x, ¯ x, y, ¯ y } . In F x , there is a (1 , + )-literal y andtwo different (2 − , + )-literals different from { x, ¯ x, y, ¯ y } . So it satisfies the condition in Lemma 9.After resolving y in F x , we can further either reduce one clause leaving a good formula or reduceat least two clauses. In the branching of F ¯ x , we reduce three clauses directly and the remainingformula is good according to Corollary 1. So the branching vector is either (4 ,
3) with a goodformula in each branching or a vector covered by (5 , Lemma 10
For a reduced instance F without (3 + , + ) -literals, if there is no 2-clause and noclause contains both a (2 , + ) -literal and a (3 , -literal, then either there is no (2 , + ) -literal orthere is a clause containing at least three (2 , + ) -literals.Proof. Since F is a reduced instance, we know that the degree of any literal is at least 2 andthere is no (2 , + , + )-literal. Thus, the formula containsonly (2 , + )-literals, (3 + , , , + )-literal otherwise the lemma trivially holds. It is impossible that each clause containing a(2 , + , , + )-literals. Since there is no 2-clause. We know that theclause contains at least three (2 , + )-literals.By Lemma 10, we know that the remaining case is as follows. Case 3.4.
There is a 3 + -clause C containing at least three (2 , + )-literals { x , x , x } : Let C i be the other clause containing x i ( i = 1 , , C , C and C arethe same. Case 3.4.1.
Two literals in { x , x , x } , say x and x , form a coincident pair: We branch on x with a branching vector (2 ,
3) first. In the branching of F x , literal x will become a (0 , + )-literal and we reduce three clauses by applying R-Rule 1 on x . So we can get a branchingvector of (5 , Case 3.4.2.
At least one of C , C and C contains a negation of x , x or x : Withoutloss of generality we assume that C contains a negation of x . We first branch on x with abranching vector (2 , F x , each of x and x will become a (1 , + )-literal.We can further reduce the number of clauses by at least 2 by applying R-Rule 3 on x and x one by one. In the branching of F ¯ x , after deleting the three clauses containing ¯ x (including C ), the degree of x is at most 1. We can reduce one more clause by applying reduction ruleson x . Thus, we can branch with a branching vector (4 , Case 3.4.3.
None of Case 3.4.1 and Case 3.4.2 happens: We first branch on x with abranching vector (2 , F x , each of x and x will become a (1 , + )-literal.We can reduce two more clauses by applying R-Rule 3 on x and x one by one. Furthermore,the remaining instance is a good formula, because applying R-Rule 3 will create coincident pairsin this case. In the branching F ¯ x , the formula is a good formula by Corollary 1. We get abranching vector (3 ,
4) with a good formula in each branching.
Case 4. F contains only (3 , F is a good formula, we know that there is eithera coincident pair or a 2-clause. Case 4.1. F contains a coincident pair { x, y } : We branch on x into two branchings F x and F ¯ x , and distinguish two subcases to analyze the branching operation. Case 4.1.1.
Three clauses contain x and y simultaneously: In the branching of F x , theliteral y will become a (0 , ,
6) at least.
Case 4.1.2.
Only two clauses contain x and y simultaneously: we assume without loss ofgenerality that no pair of literals appear in more than two clauses simultaneously now.13ssume that one of the clauses containing x is a 2-clause { x, w } , where w can be y . In thebranching of F x , we can apply R-Rule 3 on y to further reduce 1 clause. In the branching of F ¯ x ,we can apply R-Rule 1 on w to further reduce 1 clause. The branching vector will be coveredby (4 , x also contains a literal other than y and ¯ y . At least two of the three literals are different because no pair of literals appear in threeclauses as assumed. Let z and z be the two different literals. In F x , literal y will becomea (1 , + )-literal and z and z will become (2 − , + )-literals. The condition in Lemma 9 holds.After resolving y in F x , we can further either reduce 1 clause leaving a good formula or reduce atleast 2 clauses. In the branching of F ¯ x , we reduce three clauses directly and the leaving formulais good according to Corollary 1. The branching vector is either (4 ,
3) with a good formula ineach branching or a vector covered by (5 , Case 4.2. F does not contain a coincident pair but contains a 2-clause { x, y } : We branch on x with a branching vector (3 , F ¯ x , we will get a 1-clause that only contains y . Furthermore, since F does not contain a coincident pair, we know that there are at least twoclauses containing y in F ¯ x . We can apply R-Rule 1 on y in F ¯ x to further reduce 2 clauses. Thus,we can get a branching vector covered by (3 , SAT is one of the most widely studied NP-complete problems. There is a large number ofreferences in the history, whether from the perspective of experimental algorithms or theoreticalalgorithms. Many fast solvers have been developed and they can solve medium-large sizedinstances within a reasonable running time bound. However, the theoretical research is relativelybackward. It took us decades to improve the running time bound to O ∗ (1 . m ). Accordingto the theoretical results, the size of the problems we can solve is much smaller than that of theproblems solved by fast practical solvers. The gap between theoretical and experimental resultsis large. It is interesting to further explore the problem nature and reduce the gap, especially toaccelerate the research of theoretical algorithms and explain the fast experimental algorithms. References [1] Jianer Chen and Yang Liu. An improved SAT algorithm in terms of for-mula length. In
Algorithms and Data Structures, 11th International Sympo-sium, WADS 2009, Banff, Canada, August 21-23, 2009. Proceedings , pages144–155, 2009. URL: https://doi.org/10.1007/978-3-642-03367-4_13 , doi:10.1007/978-3-642-03367-4\_13 .[2] Stephen A. Cook. The complexity of theorem-proving procedures. In Proceedings of the3rd Annual ACM Symposium on Theory of Computing, May 3-5, 1971, Shaker Heights,Ohio, USA , pages 151–158, 1971. URL: https://doi.org/10.1145/800157.805047 , doi:10.1145/800157.805047 .[3] Evgeny Dantsin. Two systems for proving tautologies, based on the split method. Journalof Mathematical Sciences , 22:1293–1305, 06 1983. doi:10.1007/BF01084392 .[4] Evgeny Dantsin, Andreas Goerdt, Edward A. Hirsch, Ravi Kannan, Jon M. Klein-berg, Christos H. Papadimitriou, Prabhakar Raghavan, and Uwe Sch¨oning. A de-terministic (2-2/(k+1))n algorithm for k-sat based on local search.
Theor. Comput.Sci. , 289(1):69–83, 2002. URL: https://doi.org/10.1016/S0304-3975(01)00174-8 , doi:10.1016/S0304-3975(01)00174-8 . 145] Evgeny Dantsin, Edward A. Hirsch, and Alexander Wolpert. Algorithms for SAT basedon search in hamming balls. In STACS 2004, 21st Annual Symposium on Theoret-ical Aspects of Computer Science, Montpellier, France, March 25-27, 2004, Proceed-ings , pages 141–151, 2004. URL: https://doi.org/10.1007/978-3-540-24749-4_13 , doi:10.1007/978-3-540-24749-4\_13 .[6] Evgeny Dantsin and Alexander Wolpert. Derandomization of schuler’s algorithm forSAT. Electronic Colloquium on Computational Complexity (ECCC) , (017), 2004. URL: http://eccc.hpi-web.de/eccc-reports/2004/TR04-017/index.html .[7] Martin Davis and Hilary Putnam. A computing procedure for quantification the-ory.
J. ACM , 7(3):201–215, 1960. URL: http://doi.acm.org/10.1145/321033.321034 , doi:10.1145/321033.321034 .[8] Fedor V. Fomin and Dieter Kratsch. Exact Exponential Algorithms . Textsin Theoretical Computer Science. An EATCS Series. Springer, 2010. URL: https://doi.org/10.1007/978-3-642-16533-7 , doi:10.1007/978-3-642-16533-7 .[9] M. R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theoryof NP-Completeness . W. H. Freeman, 1979.[10] Allen Van Gelder. A satisfiability tester for non-clausal propositional calculus.
Inf.Comput. , 79(1):1–21, 1988. URL: https://doi.org/10.1016/0890-5401(88)90014-4 , doi:10.1016/0890-5401(88)90014-4 .[11] Thomas Dueholm Hansen, Haim Kaplan, Or Zamir, and Uri Zwick. Faster k -sat algorithmsusing biased-ppsz. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theoryof Computing, STOC 2019, Phoenix, AZ, USA, June 23-26, 2019 , pages 578–589, 2019.URL: https://doi.org/10.1145/3313276.3316359 , doi:10.1145/3313276.3316359 .[12] Edward A. Hirsch. Two new upper bounds for SAT. In Proceedings ofthe Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, 25-27 Jan-uary 1998, San Francisco, California, USA , pages 521–530, 1998. URL: http://dl.acm.org/citation.cfm?id=314613.314838 .[13] Edward A. Hirsch. New worst-case upper bounds for SAT.
J. Autom. Rea-soning , 24(4):397–420, 2000. URL: https://doi.org/10.1023/A:1006340920104 , doi:10.1023/A:1006340920104 .[14] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k-sat. J. Com-put. Syst. Sci. , 62(2):367–375, 2001. URL: https://doi.org/10.1006/jcss.2000.1727 , doi:10.1006/jcss.2000.1727 .[15] O. Kullmann. Deciding propositional tautologies: Algorithms and their complexity. 091997.[16] Burkhard Monien and Ewald Speckenmeyer. Upper bounds for covering problems. Methodsof Operations Research. , 43, 01 1980.[17] Burkhard Monien and Ewald Speckenmeyer. Solving satisfiabil-ity in less than 2n steps.
Discrete Applied Mathematics , 10(3):287–295, 1985. URL: https://doi.org/10.1016/0166-218X(85)90050-2 , doi:10.1016/0166-218X(85)90050-2 . 1518] Rolf Niedermeier and Peter Rossmanith. An efficient fixed-parameter algorithm for 3-hitting set. Journal of Discrete Algorithms , 1(1):89 – 102, 2003. Combinatorial Algorithms.URL: , doi:https://doi.org/10.1016/S1570-8667(03)00009-1 .[19] Ramamohan Paturi, Pavel Pudl´ak, and Francis Zane. Satisfiability coding lemma.In , pages 566–574, 1997. URL: https://doi.org/10.1109/SFCS.1997.646146 , doi:10.1109/SFCS.1997.646146 .[20] John Alan Robinson. A machine-oriented logic based on the resolution principle. J. ACM , 12(1):23–41, 1965. URL: http://doi.acm.org/10.1145/321250.321253 , doi:10.1145/321250.321253 .[21] Rainer Schuler. An algorithm for the satisfiability problem offormulas in conjunctive normal form. J. Algorithms , 54(1):40–44, 2005. URL: https://doi.org/10.1016/j.jalgor.2004.04.012 , doi:10.1016/j.jalgor.2004.04.012 .[22] Magnus Wahlstr¨om. Faster exact solving of SAT formulae with a low number of occur-rences per variable. In Theory and Applications of Satisfiability Testing, 8th InternationalConference, SAT 2005, St. Andrews, UK, June 19-23, 2005, Proceedings , pages 309–323,2005. URL: https://doi.org/10.1007/11499107_23 , doi:10.1007/11499107\_23 .[23] Masaki Yamamoto. An improved o(1.234m)-time deterministic algorithm for SAT.In Algorithms and Computation, 16th International Symposium, ISAAC 2005, Sanya,Hainan, China, December 19-21, 2005, Proceedings , pages 644–653, 2005. URL: https://doi.org/10.1007/11602613_65 , doi:10.1007/11602613\_65doi:10.1007/11602613\_65