Dec 14 - R2

On the solvability of sparse and dense 3-SAT instances
directly by Packed State Stochastic Process
Kavosh Havaledarnejad Icarus.2012@yahoo.com
Abstract:
In this paper we review solvability of 3-SAT instances in sparse and dense cases directly using
Packed Computation algorithms ( without reduction to 3-RSS ). Methods perhaps can use directly in
solving k-SAT problem in general or (p, q)-CSP in sparse or dense cases when constrains are defined
as conflicts between states of variables. In this paper we compare one randomized packed algorithm
with Schöning algorithm and two new modern versions of Schöning's algorithms and show that our
algorithms beats these modern algorithms only on random generated instances. We will use
benchmarks that are available in SATLIB and show that algorithm is able to solve almost whole of
them. It is probable that one prove that theoretical worst case complexity of this algorithm for 3-SAT
is polynomial or prove is exponential.
Keywords: Packed Computation, Randomized Algorithms, Packed State Stochastic Process, 3-SAT,
Complexity, NP class, Random Walk
1. Introduction
3-SAT problem is a well-known NP-Complete problem that has received much attention in past four
decades because a solution for this problem causes a solution for many other problems in computer
science. One way to dealing this problem is Local Search and a type of local search that is known as
Walk-Sat ( Random Walk Algorithm ). In 1991 Papadimitriou proved that Walk-Sat is able to solve 2-
SAT problem in polynomial complexity ( In quadratic complexity ) [17]. In 1999 U. Schöning
proved a complexity bound for 3-SAT problem using a Multi-Start Random-Walk
algorithm [18]. Recently many efforts conducted to designing new Resolution Algorithms, Local
Searches and Walk-Sat or to derandomize known randomized methods as deterministic algorithms (
see [9-16] ). They obtained better but yet exponential bounds for 3-SAT problem. A Walk-Sat
algorithm first begins with a random truth assignment and continues in each play with choosing a
clause that is not satisfiable and then select one literal uniformly at random from that clause and flip
the value of literal. A multi-start walk-sat is a process that continue this process for a limited time and
if couldn’t find the result will begin with a new random assignment. There are some new and modern
versions of Random Walk algorithm for example like [19] that even beat the algorithms of winners of
SAT Competition 2011.
Our algorithm is very similar to Schöning's algorithm except that for every variable beside "True" and
"False" states we have a new state: "Packed State". In this case variable is none-deterministic. When a
variable is in True or False states we say it is in single state. When a variable is in a single state its
priority is and when a variable is in packed state its priority is . Fig. 1 shows these states and
their priority in a graph.

Fig. 1
Let us return to Schöning's 1999 algorithm. Consider a clause of form . We can consider this
clause as a conflict between three variable-states: . In this case
we say we have a conflict between those states of those variables ( Fig. 2 ).
Fig. 2
In Schöning's algorithm when system chooses such a clause selects one variable uniformly at random
and flips this variable to have a different state ( Here True ). In our algorithm when system chooses
such a clause first observe the priorities ( some priorities may be or ) . If all priorities be equal to
each other system select one variable uniformly at random. If two or one variables have fewer
priorities system chooses one of them ( that have fewer priority ) uniformly at random. Fig. 3-6 shows
these conditions in diagrams.
Fig. 3
Fig. 4

Fig. 5
Fig. 6
And it remains to explain that what will happen when we choose a variable-state to flip. When we
choose a state of a variable that is in single state it will convert to packed state and when we choose a
state of a variable that is in packed state it will convert to single state ( but in deferent state ). Fig. 7
and Fig. 8 show these conditions.
Fig. 7
Fig. 8
Ok. One questions is that what will happens if algorithm terminates ( When there is any conflict in
system ) and we will have some variables in packed state. In this case the state of variables that have
an antiseptic value like true or false are the same and for variables that are in packed state we can
select every arbitrary state. It means that sometimes one time running algorithm we can extract more
than one satisfying assignment from the output of algorithm.
Packed Computation is a novel approach for problem solving. In prior paper [1] ( This paper takes
priority to current work but probably will publish after this work ), author showed that how random
generated instances of 3-RSS are tractable using Packed Computation algorithms ( It is not clear that
there are not scarce worst cases that are intractable ). Also we can reduce a 3-SAT instance to a 3-RSS
instance easily and then solve it. As far as reduced instance in dense case may have more dimensions
relative to prime problem, question is that can we use Packed Computation straightly to 3-SAT? This
paper is a reply to this question. One 3-SAT instance consists of variables and clauses. A 3-SAT
instance is a Boolean formula that is a ˄ operator on clauses :

⋀
Each clause is a ˅ operator on literals :
⋁
Every literal is a variable or its negation.
{ } { }
The only thing that a clause does is canceling a case for 3 variables for example a clause in form
cancels the case: (It show a conflict
between 3 state note that 3-SAT is a special case of CSP problem see [8] ) thus we can model a 3-
SAT instance with a conflict matrix like a RSS-Instance with ⁄
connections or conflicts. For this research we only uses the instances that we are sure they have at
least one result. Methods perhaps can use directly in solving k-SAT problem in general or (p, q)-CSP
in sparse or dense cases when constrains are defined as conflicts between state of variables. But
researching regarding these cases is out of the goal of the paper. Expected number of clauses for a 3-
SAT problem containing variables with density is . It is obvious that
progress faster than . If we reduce a 3-SAT instance to a RSS instance number of rules will be
number of clauses in 3-SAT. Thus if we can solve a 3-RSS instance in time complexity , We can
solve a 3-SAT instance with complexity . Thus if complexity of solving a 3-SAT in a direct
way be less than this, it have benefit. In the rest of paper we will introduce one algorithm based on
packed computation and compare it with Schöning's 1999 algorithm [17].We can call this algorithm
. We will introduce two sub-versions for this algorithm. The
limitations of time that we considered for algorithm are polynomial and in this polynomial limitations
algorithm is able to solve almost whole benchmarks that are available in SATLIB.
2. States of variables
Whereas in 3-SAT problem variables are Boolean they have only two states true and false thus
there is only one packed state that is combination of true and false thus among execution of
algorithms variables only stand in T, F or TF ( Packed ) states. When a variable is in T state, priority
of this state is 1 and so on for F state but when a variable is in TF state, the priority of both T and F
states is ⁄ . In a classic walk-sat algorithm variables only stands in true or false states and transform
to each other directly (Fig. 1) but in a packed walk sat variables rotate in two cycles between packed
state and single states ( Fig. 2).

(Fig. 9) Classic Local Search (Fig. 10) Packed Local Search
It remains to explain the treatment with clauses containing literals in packed state. If a clause contains
a true literal and other literals are in false or packed state we consider this clause as a satisfied clause.
But if a clause only contains false and packed literals we consider this clause as an unsatisfied clause.
we can show these conditions as bellow formulas:
2.1. Matrix Representation and generalization
We can represent the states of such a system with two dimensional matrixes like:
{ [ ] }
For PSSP-1 algorithm these states are only:
{ [ ] [ ] [
⁄
⁄
] }
We could choose some more complicated states like:
{ [ ] [ ] [
⁄
⁄
] [
⁄
⁄
] }
Or:
{ [ ] [ ] [
⁄
⁄
] [
⁄
⁄
] [
⁄
⁄
] }
Or even real assignment like:
{ [ ] }
Researcher designed some algorithms based on these conditions but practical performance of these
conditions was not better that our simple PSSP-1 algorithm for random generated instances ( Please
note that random generated instances is not the case in general ). In addition aim of this work is only

proposing packed computation as a powerful method. Thus in this paper we will focus on this simple
algorithm.
Consider a literal in an unsatisfied clause and we want to flip this literal. Whereas is unsatisfied
thus must be only or . If be will convert to and if be will convert to . Assume that we
can represent flip operator as a matrix thus we have:
Assume that:
[ ]
Thus we have:
[ ] [ ] [
⁄
⁄
] [ ] [
⁄
⁄
] [ ]
Solving these equation we have:
[
⁄ ⁄
⁄ ⁄
]
Please note that we wrote this matrix for acting in a literal no a variable. If then matrix for
variable is the same but if ̅ then matrix for flip will be:
[
⁄ ⁄
⁄ ⁄
]
Please note that in classical Schöning algorithm states and flip matrices are in form:
[ ] [ ] [ ]
3. Schöning's Algorithm
Let us first introduce a well-known method ( see [18] ) for dealing with k-SAT problems. It is a
simple local search algorithm. Schöning established a powerful mathematical proof proving that
Expected Number of Steps for this algorithm working out a 3-SAT instance is at most bounded by
.
Algorithm 3.1. SCHÖNING'S
In this algorithm variables are always in T or F. if a clause have conflict and selected variable is T it
will convert to F and vice versa.

4. Basic Action
For proposing our algorithm let us first introduce one basic action that is like flip in Schöning
algorithm. This basic action is LocalChange.
Action 4.1. LocalChange( l ) : in this action is a literal that is false or packed from a variable thus
can be or ̅. If literal be in a single state converts to packed state . And if literal be in packed
state it will convert to true state ( Fig. 11 )
Fig. 11
5. PSSP-1
PSSP-1 is a randomized algorithm and is very similar to Schöning's algorithm. In this algorithm
after each restart we have step. In each step we choose a clause uniformly at random and if it
be an unsatisfied clause ( A clause that have conflict and whole of its literals are false or packed
means whole states that it cancels are on ) then we select this clause and if priority of some literals be
less than others then select one of less priorities uniformly at random and if priority of all be equal
select one literal of all uniformly at random ( Please note that for example for the case that only one
literal have less priority we have only one selection and we only choose it ) (Fig. 3-6 ).
Algorithm 5.1. PSSP-1.1
1- Repeat these command to convergence
2- Select an initial assignment 𝑎 { } 𝑛
uniformly at random
3- Repeat 𝑛 times:
4- Let 𝐶 be an unsatisfied clause
5- Pick one literal 𝑙 of three literals in 𝐶
6- Flip the value of 𝑙
7- Check the correctness for termination

In the first row of algorithm 5.1 we considered a restart for algorithm thus whereas in each restart
we have repeat, the total time that we considered for this algorithm is polynomial because along
the research algorithm was able to solve almost all instances with this limitations.
One question is that this algorithm has overhead because we first choose a clause uniformly at random
and then check that is this clause unsatisfied. We could select the clause from the list of unsatisfied
clauses uniformly at random but this approach also has overhead ( because we must save the list of
unsatisfied clause and manage it with an approach ) and in the case of this algorithm, this overhead is
bigger than the approached that used in PSSP-1 here for random generated instances. But at the end of
research it turned out that this approach is not suitable for hard benchmarks like SATLIB UF 20 – 250
thus we propose here algorithm 2:
Algorithm 5.2. PSSP-1.2
6. Two modern versions of Schöning's algorithm
Here we introduce two modern versions of Schöning's algorithm that we call them Break-Only
algorithms ( [19] ) and in the next session compare them with PSSP-1. These algorithms even beat the
algorithms of winners of SAT Competition 2011 ( See [19] ).
This algorithms are exactly Schöning's 1999 algorithm ( [18] ) means they are Multistart Random
Walk but have two difference:
1- Choosing an unsatisfied clause is not arbitrary and algorithm chooses one unsatisfied clause
from the list of all unsatisfied clauses uniformly at random.
2- When algorithm chooses a clause, selecting variable to flip is not uniformly at random and
algorithm calculates a probability distribution for this selection.
1- Repeat time
2- Select an initial assignment 𝑎 {𝑃} 𝑛
3- Repeat 𝑛 time
4- Choose a clause 𝐶 uniformly at random
5- If 𝐶 is unsatisfied then:
6- Pick one literal 𝑙 of the less priority literals in 𝐶 uniformly at random
7- Do a LocalChange for 𝑙
8- Check the correctness
9- Repeat time
10- Select an initial assignment 𝑎 {𝑃} 𝑛
11- Repeat 𝑛 time
12- Choose a clause 𝐶 from the list of unsatisfied clauses uniformly at random
13- Pick one literal 𝑙 of the less priority literals in 𝐶 uniformly at random
14- Do a LocalChange for 𝑙
15- Check the correctness

When algorithm chooses a clause first calculates a function for each variable. Assume that variables
dealing the clause be then algorithm calculates . Probability distribution for
selecting a variable to flip obtains from:
For calculating this function for a variable , algorithm uses two parameters and .
Parameter is simply number of clauses that will become satisfied after flipping this variable
and is simply number of clauses that will become unsatisfied after flipping this variable. In
[19] Authors showed that best formulas are only based on because we omit calculating
that is an overhead. In [19] algorithms only based on had better performance relative
to algorithms based on both parameters or even winners of SAT Competition 2011.
First algorithm of [19] is . This algorithm calculates the function for variable
based on this formula:
Second algorithm from [19] is . This algorithm calculates the function for
variable based on this formula:
Based on [19] the best value of for first algorithm is 2.5 and for second is 2.3 ( For random
generated instances ).
However choosing a clause from list of unsatisfied clauses and calculating parameter have
overhead.
The simple method for implementation of these algorithms is that first we assess whole unsatisfied
clauses by a review on all clauses and then select one of them uniformly at random and for computing
parameter for a variable, we can do it by a review on all clauses. In another implementation
we used method of WalkSat43 [20] but in these algorithms, it leads to worse overhead relative to
simple method. Thus we used the original implementation of authors of [19]. Their method for the
case of 3-SAT manages the list of unsatisfied clauses along computation but for parameter: ,
calculates it directly whenever is needed. This method was the best.
7. Experimental Results
Before proposing experimental results let us first propose a hard instance namely Worse Case 4
(see [1] ) for 3-SAT problem that seems is hard to solve by Packed Computation algorithms.
Worse Case 4:
For producing a Worst Case 4 instance we first assume a Global Solution uniformly at random
and based on this assumption whole Variables have a state G that is in Global and a state N that is not
in Global. Also we select 3 of variables uniformly at random and call them X, Y and Z. For the
clauses that are exactly between X, Y and Z, we consider a conflict for all of them except the case that
whole states be in global ( NNN, NNG, NGG … but No GGG ). For other clauses that are not exactly
between X, Y and Z we produce whole clauses that exactly one or exactly two of states be in Global

but we don’t produce the clauses that any or exactly tree state be in Global ( GNN, GGN … but No
GGG and NNN ).
7.1. An analysis on the runtime results
In this session complexity tables of algorithm in practice will proposes. We measure complexity
based on number of flips. We do these experiments on a sequence of sizes like
. These experiments give us a sequence of number of
flips ( average case or maximum case ) .
It is not clear that PSSP-1 has a polynomial or exponential complexity but here we assume a
polynomial formula for the complexity. In [1] it was mathematically analyzed that if we assume a
polynomial function for estimating an exponential function then: deviation must be very big or base of
exponential must be near to 1 ( unity ).
Let assume that, time complexity of system be in form . Thus for two consequence sizes we
have:
{
( )
( )
( )
( )
Thus we obtain a sequence of exponents . We can find estimated exponent by this formula:
̅ ( ) ∑
It give us estimated complexity we can show it like ̅
. But we can calculate a Deviation for it.
Deviation show how much practical exponents deviate from this estimation. We have:
̅ ( ) ∑ ̅
Tables 1 to 3 show experimental results for practical complexity of proposed algorithm
PSSP-1.1. From tables it is obvious that complexity of Packed Algorithm have polynomial
grow for random generated instances ( Note that we only tested random generated instances
and don’t speak regarding worst cases). Table 4 shows the complexity of PSSP-1.1 on Worse
Case 4.
PSSP-1 Density of clauses 0.01 Number of tests = 100
n AVG WRS Success n AVG WRS Success
50 384.8 1026 100% 300 1999.3 2932 100%
100 680.24 1452 100% 350 2375.26 3244 100%
150 1037.02 1748 100% 400 2656.16 3570 100%
200 1357.18 2134 100% 450 3008.96 4704 100%
250 1655.02 2636 100% 500 3378.1 4636 100%
AVG CPX = AVG DEV = 0.242 WRS CPX = WRS DEV = 0.413
(Table. 1) Practical time complexity for PSSP-1 on 3-SAT instances with clause density 0.01.

35 230.24 745 100% 210 1396.86 2322 100%
70 489.34 1152 100% 245 1678.36 3243 100%
105 748.38 1659 100% 280 1894.92 2884 100%
140 983.62 1870 100% 315 2128.14 3901 100%
175 1223.82 2195 100% 350 2385.66 3768 100%
(Table. 2) Practical time complexity for PSSP-1 on 3-SAT instances with clause density 0.1
20 141.96 488 100% 120 806.26 1560 100%
40 283.66 902 100% 140 973.9 1720 100%
60 430.12 1228 100% 160 1088.76 2316 100%
80 572.38 1514 100% 180 1254.5 2114 100%
100 676.28 1104 100% 200 1330.6 2222 100%
(Table. 3) Practical time complexity for PSSP-1 on 3-SAT instances with clause density 0.5
PSSP-1 Worse Case 4 Number of tests = 100
10 94.27 428 100% 60 1173.86 6368 100%
20 271 1092 100% 70 1657.42 7898 100%
30 541.62 2472 100% 80 1853.12 10836 100%
40 834.06 3252 100% 90 2437.42 8256 100%
50 1063.12 4004 100% 100 2348.56 7676 100%
(Table. 4) Practical time complexity for PSSP-1 on random instances of type worse case 4
7.2. SATLIB benchmarks
Also we tested algorithm in benchmarks that are available in SATLIB websites. We
restricted algorithm to restart. And in this polynomial limitation algorithm was able to
solve almost whole SATLIB benchmarks. We only tested the benchmarks that are all
satisfiable and show algorithm is able to solve almost whole of them with this polynomial
limitations. The whole time of these experiments was only several hours (Table. 5). The
number of successes of algorithm PSSP-1.1 on uf225-960 was different for .Net and C++
implementations even with repeating experiments. That author can explains why it may

happens. In [21] Stephen A. Cook states that it is not clear that there is a source of random
number source in nature. Thus random functions in programming languages are only very
complicated mathematical functions. In fact random function of .Net is more random relative
to random function of C++ as random function of .Net depends on time and some dynamic
properties of system but random function of C++ is only a static sequence.
Instance
Number of
successes
AVG MAX
 uf20-91: 20 variables, 91 clauses - 1000
instances, all satisfiable 1000/1000 12042.76 141361
instances, all satisfiable 100/100 923551 16479001
 uf100-430: 100 variables, 430 clauses -
1000 instances, all satisfiable 1000/1000 2956897.4 135569601
instances, all satisfiable
C#:100/100
C++:98/100
155308604.14 1969192801
 uf250-1065: 250 variables, 1065 clauses -
100 instances, all satisfiable 99/100 181326891.02 1761920705
 RTI_k3_n100_m429: 100 variables, 429
clauses – 500 instances, all satisfiable 500/500 2620933.8 120121201
 BMS_k3_n100_m429: 100 variables,
number of clauses varies – 500 instances,
all satisfiable
500/500 15689771.4 417664001
 CBS_k3_n100_m403_b10: 100 variables,
403 clauses, backbone size 10 - 1000
1000/1000 730456.2 16711201
 CBS_k3_n100_m418_b70: 100 variables, 1000/1000 1957353.8 59223601

418 clauses, backbone size 70 - 1000
 flat50-115: 50 vertices, 115 edges - 1000
 flat75-180: 75 vertices, 180 edges - 100
(Table. 5) Number of successes for solving SATLIB benchmark by PSSP-1 with polynomial
limitations
7.3. Comparing with Schöning algorithm
In this session we compare complexity of Schöning algorithm and PSSP-1 algorithm based
on "number of flips before convergence appears" and "number of variables". The instances
that used for these experiments were satisfiable random generated instances. In each size we
tested 100 instances and the instances were the same for Schöning algorithm and PSSP-1
algorithm. We measured the complexity of average and worst case for both algorithms. In
each diagram we considered a constant density that is probability of existence of a clause
when we are generating random instances.
Fig. 12-14 shows these experiments respectively on densities 0.1, 0.5 and 0.01. Diagrams of
Schöning algorithm are magenta ( worst case and average ) and diagrams of PSSP-1 are blue
( worst case and average ). It is obvious the diagram that is above is diagram of worst case
and diagram of below is for average practical complexity. Observing diagrams it is obvious
that performance of PSSP-1 algorithm is very better than Schöning's algorithm in practice.
These diagrams induce this concept that it is probable that these packed algorithms be
theoretically polynomial.

Fig. 12. Comparison of PSSP-1 and Schöning algorithms in clause density 0.1

7.4. Comparison with Break-Only algorithms
In this session we compare PSSP-1.1 with Break-Only algorithms from [19] that even beats
the winners of SAT Competition 2011. Number of flips of these algorithms is fairly less than
proposed algorithm PSSP-1. But however choosing an unsatisfied clause uniformly at
random and calculating parameter have big but polynomial overhead in these
algorithms thus we compared algorithms based on real runtime based on milliseconds. The
system was a core-I5 CPU with 6 Gigabytes of RAM. Platform was Visual C++ 2010 and
operating system was Windows Eight. Fig. 15-17 shows the result of these comparisons by
diagrams where red square diagram is and greed diamond diagram is
and blue circle diagram is . From the diagram it is obvious
that performance of is better on random generated instances.

Fig. 15. Comparison of PSSP-1.1 and Break-Only algorithms in clause density 0.1

Also we compares algorithm with algorithm on UF20 to
UF175 of SATLIB. (Fig. 18) show that is very weak in these benchmarks thus
we implemented an algorithm that choose the clause directly from the list of unsatisfied
clauses uniformly at random and changed the inner loop iterations to . Result of
comparing this new algorithm is available in (Fig. 19).

Fig. 18. Comparing with in UF20 to UF-175

Fig. 19. Comparing with in UF20 to UF-175
Finally we considered a time out of 10 second for algorithms and compared them on some
SATLIB benchmarks. Result of this competition is available in Table. 6.
Instance Successes of PSSP-1.1 Successes of Break-Only-Poly
 uf200-860:
99 100
 uf225-960:
98 100
 uf250-1065:
98 97
(Table. 6) Comparing PSSP-1.2 and Break-Only-Poly with timeout 10 second.
7. Conclusion
Aim of this work was only proposing packed computation. In this article we proved in
practice that 3-SAT can be solved straightly using Packed Computation with good
performance. It seem solving 3-SAT straightly is better than reduction to 3-RSS. Methods
may uses directly in solving k-SAT and Constrain Satisfaction Problem in general.
Comparison with Schöning algorithm we show that this algorithm have exponential behavior
on our instances but solve these instances in a very slowly growing complexity
based on number of flips. We showed that algorithm has very better performance
on random generated instances relative to and
algorithms. However proving polynomiality or exponentiality of such packed computation
algorithms is an open question.
8. Acknowledgements
I thank Dr. Mohammad Reza Sarshar and Dr. Shahin Seyed Mesgary and Sina Mayahi in
university of Karaj and Professor Albert R. Meyer university of MIT and others who helped
me conducting these researches.
9. References
1-An introduction to Packed Computation as a new powerful approach to dealing NP-Completes,
Kavosh Havaledarnejad, ( Under Review in Theoretical Computer Science )
2- The Complexity of Theorem-Proving Procedures, Stephen A. Cook, University of Toronto 1971
3- Reducibility among Combinatorial Problems, Richard M. Karp, University of California at Berkley
1972
4- Probability and Computing Randomized Algorithms and Probabilistic Analysis, Michael
Mitzenmacher and Eli Upfal, Cambridge
5- Mathematics for Computer Science, Eric Lehman and F Thomson Leighton and Albert R Meyer
6- 21 NP-Hard problems, Jeff Erikson, 2009
7- Introduction to Probability Models Sixth Edition, Sheldon M. Ross, ACADEMIC PRESS San
Diego London Boston New York Sydney Tokyo Toronto

8- Improved Algorithms for 3-Coloring, 3-Edge-Coloring, and Constraint Satisfaction, David
Eppstein
9- R. Schuler, U. Schöning, and O. Watanabe. A probabilistic 3-SAT algorithm further improved. In:
Proceedings of the 19th Annual Symposium on Theoretical Aspects of Computer Science (STACS),
192-202, 2002.
10- D. Rolf. 3-SAT 2 RTIME(1:32971n). Diploma thesis, Department Of Computer Science,
Humboldt University Berlin, Germany, 2003.
11- S. Baumer and R. Schuler. Improving a probabilistic 3-SAT algorithm by dynamic search and
independent clause pairs. In: Proceedings of the 6th International Conference on Theory and
Applications of Satisability Testing (SAT), 150-161, 2003.121
12- D. Rolf. 3-SAT 2 RTIME(O(1:32793n)) - improving randomized local search by initializing
strings of 3-clauses. Electronic Colloquium on Computational Complexity (ECCC), 2003.
13- K. Iwama and S. Tamaki. Improved upper bounds for 3-SAT. In: Proceedings of the 15th Annual
ACM-SIAM Symposium on Discrete Algorithms (SODA), 328-328, 2004.
14- R. Paturi, P. Pudlak, M.E. Saks, and F. Zane. An improved exponential-time algorithm for k-SAT.
In: Proceedings of the 39th Annual IEEE Symposium on Foundations of Computer Science (FOCS),
628-637, 1998.
15- D. Rolf. Derandomization of PPSZ for Unique-k-SAT. In: Proceedings of the 8th
International
Conference on Theory and Applications of Satisability Testing (SAT), 216-225, 2005.
16- R. Paturi, P. Pudlak, M.E. Saks, and F. Zane. An improved exponential-time algorithm for k-SAT.
Journal of the Association for Computing Machinery 52(3): 337-364, 2006.
17- C. H. Papadimitriou: On selecting a satisfying truth assignment. Proc. 32nd FOCS (1991)
163–169.
18- U. Schöning: A probabilistic algorithm for k-SAT and constraint satisfaction problems.
Proc. 40th
, FOCS (1999) 410–414.
19- Balint, Adrian and Schöning, Uwe: Choosing Probability Distributions for Stochastic
Local Search and the Role of Make versus Break, In SAT 2012, 16–29. Springer.
20- Alex Fukunaga, Eﬃcient Implementations of SAT Local Search
21- The P versus NP Problem, Stephen Cook, April, 2000. Manuscript prepared for the Clay
Mathematics Institute for the Millennium Prize Problems

Dec 14 - R2

More Related Content

What's hot (19)

Viewers also liked (19)

Similar to Dec 14 - R2 (20)

Dec 14 - R2