CSc Parallel Scientific Computing, 2017

Transcription

1 CSc Parallel Scientific Computing, 2017

2 What is? Given: a set X of n variables, (i.e. X = {x 1, x 2,, x n } and each x i {0, 1}). a set of m clauses in Conjunctive Normal Form (CNF) (i.e. C = {c 1, c 2,, c m }.) Each clause contains some of the variables, and for each x X, either x or x appears. Does an assignment, σ : X {0, 1}, exist such that for all c C, c = true.

3 Example X = {x 1, x 2, x 3 } C = {x 1 x 2, x 3 x 1, x 3 x 1 x 2 } The set of clauses C, is also known as a formula.

4 Result: A boolean true or false Input: A set of variables X[1..n] Input: A formula F[1..m] Let satisfied[1..m] and assign[1..n] be new arrays; Initialize(assign) ; // set all assignments to 0 while NotAllOnes(assign) do Increment(assign) ; // change the assignment in one position, treating assign like a binary number Initialize(satisfied); for i=1 to m do satisfied[i] = evaluate(f [i]); if all c C are satisfied then return true; return false;

5 Example X = {x 1, x 2, x 3 } C = {x 1 x 2, x 3 x 1, x 3 x 1 x 2 } We will start with x 1 = 0, x 2 = 0, and x 3 = 0. With this assignment, we obtain: 0 1, 1 1, which is equal to 1, 1, 0. This is not satisfiable. We move on to x 1 = 0, x 2 = 0, and x 3 = 1. We obtain: 0 1, 0 1, which is equal to 1, 1, 1. This is satisfiable!

6 Comment and for presentation The algorithm on the previous slides take Θ(2 n ) time to run. We need to be able to use heuristics and approximations to solve this problem faster. There are 2 approaches: modified brute force using heuristics, such as DPLL algorithm ( Davis, Putnam, Logemann, Loveland 1962). randomized approximation algorithms, such as MAX-SAT approximation algorithm (1974).

7 DPLL (1962) The idea of the is that you start with a formula F and a partial interpretation I, where initially, I =. Evaluate F using the assignments in I. If all of the clauses in F are true using the assignments in I, then F is satisfiable. If at least one clause is definitely false using the assignments in I, then F is not satisfiable. If there are some clauses for which you can not tell, we pick an assignment for a varaible, x i / I and add it to I, and recursively repeat the process.

8 Pseudocode for DPLL-SAT(X,F, I) Result: A true or false Input: A set of variables X[1..n] Input: A formula F Input: A partial interpretation I if I F then return true; else if I F then return false; else choose x i / I ; return DPLL-SAT(X, F, I {x i = 1}) or DPLL-SAT(X, F, I {x i = 0});

9 Analysis of the above algorithm At the moment this is just an elegant way of doing the Naive above. However, we should add two heuristics: Choosing assignment of pure literals

10 We view F as having the unit rules from I into it. When we consider these assignments, we can remove some variables from the clauses of F that have no bearing on the final result. This is accomplished by removing the negation of all variables of the assignment from the clauses of F.

11 Example Suppose that F = {x 1 x 2, x 3 x 1, x 3 x 1 x 2 }. and I = {x 3 = 1} That tells us that x 3 is true, and hence x 3 is false. We know that x 3 has no bearing on the truth value of the clauses in which x 3 is part. (we can remove false from an or statement). So we can simplify F to be F = {x 1 x 2, x 1, x 3 x 1 x 2 }.

12 If a variable only appears positively, (i.e. for any given variable x i, x i never appears) then we don t lose anything by deciding to set it to true. If a variable only appears negatively, (i.e. for any given variable x i, x i itself never appears) then we don t lose anything by deciding to set it to false.

13 Example Suppose that F = {x 1 x 2, x 3 x 1, x 3 x 1 x 2 }. We see that x 1 only appears positively, so we will choose to set it to 1, and update I = I {x 1 = 1}.

14 Full-DPLL-SAT(X, F, I) if I F then return true; else if I F then return false; else F, I = unitpropogation(f, I); if I is inconsistent then // I contains both x i and x i for some x i X return false; F, I = dealwithpureliterals(f, I); if F = then // If all clauses are "unit propogated" away return true; choose x i / I ; return Full-DPLL-SAT(X, F, I {x i = 1}) or Full-DPLL-SAT(X, F, I {x i = 0});

15 How to make DPLL work in Parallel Broadcast the initial F to all processors. Allow multiple processors to work on different partial interpretations in parallel, doing unit propagation as needed. Each processor will communicate its result to the master processor. If any processor answers with yes, yes will be returned and the other processors will stop.

16 Parallel DPLL (cont.) The broadcast of information to all processors will take: T comm1 = t startup + F t data The collection of information from all of the processors will take: T comm2 = t startup + t data

17 α- Definition An algorithm is said to be a randomized α-approximation algorithm for a particular problem if the algorithm runs in polynomial time, and it produces a solution that is αopt, where OPT is the optimal solution for the original algorithm.

18 -SAT-(X, F) Result: an assignment, σ, of variables that approximately satisfies F Input: A set of variables X[1..n] Input: A set of clauses F[1..m] Let σ[1..n] be a new array; for i=1 to n do toss = flip-a-fair-coin() ; // With probability 1 2 if toss=heads then σ[i] = 1; ; // if toss=tails else σ[i] = 0; return σ;

19 Analysis Johnson (1974) proves that this approximation algorithm is a 1 2-approximation for satisfiability. In this case, we mean that this algorithm is guaranteed to return an assignment that satisfies at least half of the clauses in F. Clearly this algorithm runs in Θ(n) time.

20 How to get rid of randomization We can use the Method of Conditional Expectations to turn this algorithm into a deterministic one (i.e. without randomization).

21 Pseudocode for Deterministic-(X,F) Let σ[1..n] be a new array; for i=1 to n do Set σ[i] = 1; totalweightiftrue=0; for j=1 to m do if σ[1..i] satisfies F[j] then weight-if-true = 1; else k=sizeof(f[j]); weight-if-true = 1 1 k 2 ; totalweightiftrue+=weight-if-true; ; // Repeat the same code for σ[i] = 0 if totalweightiftrue > totalweightiffalse then σ[i] = 1; else σ[i] = 0; return σ;

22 1. First, we will scatter parts of the formula array to each processor. 2. We will have each processor compute weight-if-true and weight-if-false for each clause in F. 3. Each processor will s its values back to the master processor. 4. The master processor will do a parallel sum to decide on the correct assignment.

23 Analysis of Computation Time Steps 2 and 4 contribute to the computation time: Step 2: T comp1 = Θ( nm p ) where p=the number of processors. This is because we have to calculate n assignments. Step 4: T comp2 = Θ(n log m) This is because we have to do n parallel sums. The total time is: T comp = Θ( nm p + n log m)

24 Analysis of Communication Time Steps 1 and 3 contribute to the communication time. Step 1: T comm1 = t startup + m p t data This is because we have to scatter m p each processor. Step 3: T comm2 = t startup + 2t data data items to Since each processor has to s 2 values back to the master.