Gábor Kusper University of Linz RISC Austria Proving by Assignment Trees that SAT Solvers are Non-Polynomial in Unit Propagation Framework with 1 Selection and Cache Gábor Kusper University of Linz RISC Austria 2004

Outline Representations of SAT Unit Propagation and Resolution DPLL and GUS Unit Propagation Framework

Motivation Theorema, http://www.theorema.org/ A1, ..., An G. A1, ..., An, G is unsatisfiable.

Boolean Satisfiability (SAT) Identify truth assignment that satisfies boolean formula or prove it does not exist. SAT: Boolean Satisfiability if the boolean formula is in CNF form. Well-known NP-complete problem.

Conjunctive Normal Form (CNF) Clause F = ( a  c )  ( b  c )  (¬a  ¬b  ¬c ) Negative Literal Pozitive Literal

Representations F = ( a  c )  ( b  c )  (¬a  ¬b  ¬c ) S = { { a, c }, { b, c }, {¬a, ¬b, ¬c } } + x + M = x + + - - - True True True a b c False False False

Clause Classification x - + x x x x - x + - + 2-Clause Empty Clause Unit Clause Clear Clause

Clause Set Classification x - + x x x x - x + - + Unsatisfiable Clause Set Empty Clause Set, Satisfiable

Resolution Unit Propagation Simplifying SAT Resolution Unit Propagation

Resolution if A, B are clauses and a is a literal, then res(A, B, a) := A  B \ {a, ¬a}. - + + x + + x + x + + + res(A, B, a) A B a

Unit Propagation (UP) If S is a clause set and a is a literal, then UP(S, { a }) := { C \ { a } | C  S  a  C }. x - + - - x + x x + + + Unit Clause x - x UP by +xx

SAT Solvers DPLL GUS

BCP Boolean Constraint Propagation (BCP): Iterated application of unit propagation. x - + - - x + x x + + + x - x UP by +xx UP by x-x

DPLL Procedure Davis & Putnam & Logemann & Loveland Procedure Function DPLL(S : Clause Set) : Boolean Begin S := BCP(S); if S =  then return True; if   S then return False; Let a be a variable in S; return DPLL( S  { { a } } )  DPLL( S  { { ¬a } } ); End

Example - - x x + + - x - + x x - x x - - x - - x x + + x + + - x -

Assignment We say for short clause disjunctive set of literals. assignment conjunctive set of literals. The intended meaning of assignment { a, b } is that we assign true to a and false to b. If C is a clause, then C is an assignment. If A is an assignment, then A is a clause. If S is a clause set, then S is an assignment set. If T is an assignment set, then T is a clause set.

Hyper-Unit Propagation (HUP) If S is a clause set and A is an assignment, then HUP(S, A) := { C \ A | C  S  C  A =  }. x - + - - x + + + x x + x x x HUP by ++x x - + - - x + + + x x + x x x x - + x - x UP by +xx UP by x+x

Sub-Model (sm) If C is a clause and c is a literal in C, then sm(C, c) := C \ { c }  { c }. sm(C, c) is an assignment. (a  b  c)  (a  b)  c. + + + x - - + x sm(C, c) C c

Expansion Rule If HUP(S, A) is unsat, then {A}  S  S. If C  S, c  C and HUP(S, sm(C, c)) is unsat, then {sm(C, c)}  S  S, i.e., {C \ {c}}  S  S, because res(C, sm(C, c)) = C \ {c}.

GUS General Unicorn-SAT(GUS) Function GUS(S : Clause Set) : Boolean Begin if S =  then return True; Let C be a minimal clause in S; For each c  C do If ( GUS( HUP(S, sm(C, c) ) ) ) then return True; od return False; End

Example - - x x + + - x - + - x x - x x x + x x + x x - - x - x x +

Unit Propagation Framework Unit Propagation Framework with 1 Selection and Cache Limitation Lemma

Strategy Set & Function If C is a clause and T is an assignment set, then T is a strategy set generated by C, if { C }  T is unsatisfiable. If C is a clause and F is a function, that has the type “function F( C : clause) : assignment set”, and F(C) is a strategy set generated by C, then F is a strategy function.

Example x x x x + x x x C C T T + + + + + + + + C - - - + + x x x C

Strategy Function of DPLL Function DPLL_STF( C : Clause ) : Assignment Set Begin if ( C is empty ) then return ; if ( C is unit ) then return { C }; Let c be a literal in C; return { { c }, { c } }; End

Example x x x x + x x x +x x x C T C T + + + + + x x x - x x x C T

Strategy Function of GUS Function GUS_STF( C : Clause ) : Assignment Set Begin T := ; While (C is not empty) do Let c be a literal in C; T := T  { sm(C, c) }; C := C \ { c }; od return T; End

Example x x x x + x x x C C T T + + + + C - - - + - - + x - + x x

UPFw1S Function UPFw1S(S : Clause Set, STF : Strategy Function) : Boolean Begin if ( S =  ) then return True; if (   S ) then return False; Let C be a clause in S; // 1 Selection T := STF ( C ); // T is a strategy set For each A  T do if ( UPFw1S( HUP(S, A), STF ) ) then return True; od return False; End

UPFw1S is a SAT solver S S1 C S2 A1 A2 Ak Sk HUP by A1 HUP by A2 We know that if T is a strategy set generated by C, then { C }  T is unsatisfiable. Assume T = { A1, A2, ..., Ak } is strategy set generated by C  S. HUP by A1 S HUP by A2 S1 HUP by Ak C S2 A1 A2 Ak Sk

Simulated DPLL & GUS Function Simulated_DPLL( S : Clause Set) : Assignment Begin return UPFw1S(S, DPLL_STF); End Function Simulated_GUS( S : Clause Set) : Assignment return UPFw1S(S, GUS_STF);

k-Clause Set [2^k] := the set of all possible k-clauses on the same variables. For all k : [2^k] is unsatisfiable. Assume we have 3 variables. + + x [4]= + - x - + x - - x x + + [4]= x + - x - + x - - + x + [4]= + x - - x + - x - or [1]= x x x

HUP on k-Clause Set HUP by ++x HUP by ++x HUP([2^k], A) = [2^(k-m)], where m = |A|. HUP by ++x [8] [2] + + + + + - + - + [8]= + - - - + + - + - - - + - - - HUP by ++x x x + =[2] x x -

DPLL and GUS on [2] [2] [1] + - [2] [1] + - HUP by + DPLL: UP steps: 1

DPLL and GUS on [4] [2] [4] ++ -x [2] +x [1] [4] ++ +- [2] -x HUP by +x [2] 1 [4] DPLL: HUP by -x ++ UP steps: 4 -x [2] 1 +x HUP by -+ [1] [4] GUS: HUP by +x UP steps: 4 ++ +- [2] 1 -x

DPLL and GUS on [8] [4] [8] +++ -xx [4] +xx [1] [8] +++ [2] ++- +-x HUP by +xx [4] 4 [8] DPLL: HUP by -xx +++ UPs: 10 -xx [4] 4 +xx HUP by --+ [1] [8] GUS: HUP by -+x HUP by +xx +++ UPs: 11 -1 [2] 1 ++- +-x [4] 4 -xx

Limit for Strategy Sets If T is strategy set generated by C and C is a k-clause, then T subsumes at least 2^k – 1 k-clauses on the variables of C. This holds, because { C }  T is unsatisfiable. - - + - - + T = - + x = - + + - x x - + - + + + + + - + - + + - - + + + - - + - + x + x x C T

Limit for Children [1] [8] +++ [2] ++- +-x [4] -xx HUP by --+ If we break down [2^k] by a strategy set to [2^k1], [2^k2], ..., [2^km] then 2^k1 + 2^k2 + ... + 2^km  2^k – 1. This holds, because of Limit for Strategy Sets. HUP by --+ [1] [8] HUP by -+x HUP by +xx +++ [2] ++- +-x [4] -xx

Assignment Tree (A-tree) A, Cs is an A-tree if A is an assignment and Cs is a set of A-trees. We can represent a run of UPFw1S by an A-tree. xxx HUP by --+ [1] [8] --+ -+x +xx HUP by -+x HUP by +xx +++ [2] ++- xx+ x-+ x+x +-x [4] -xx xx+

Unit Assignment Tree xxx xxx --+ -+x +xx -xx -xx +xx xx+ x-+ x+x x-x (a)  , Cs is a unit A-tree if Cs is a set of unit A-trees. (b)  A, Cs is a unit A-tree if A is a unit and Cs is a set of unit A-trees. convert to unit A-tree xxx xxx --+ -+x +xx -xx -xx +xx xx+ x-+ x+x x-x x+x x-x x+x xx+ xx+ xx+ xx+ xx+

Cached Unit Assignment Tree xxx convert to cached unit A-tree -xx -xx +xx xxx x-x x+x x-x x+x -xx +xx xx+ xx+ xx+ xx+ x-x x+x x-x x+x xx+ xx+ xx+ xx+

Auxiliary Lemmas The number of edges of a cached unit A-tree equals to the number of used UP steps in the run of UPFw1SC, if this cached unit A-tree corresponds to this run of the framework. A well-know graph theory states that if a tree has N nodes, then it has N-1 edges.

Number of Nodes of a CUA-Tree Let AT be a A-tree, which represent a run of UPFw1SC on [2^n], n > 0. We convert AT to a cached unit A-tree. Let CUAT this cached unit A-tree. Then CUAT has 2^n + 2^(n-1) – 1 nodes. Proof by Induction: For k = 1 is true, because [2] has 2 nodes. Let us assume that it holds for k = n-1. We show that it holds for k = n. We assume that n > 1. The child nodes of root correspond to a run of UPFw1SC on [2^(n-1)]. Since n > 1, the root has at least two child nodes. Hence, it has at least 2 * (2^(n-1)+2^(n-2) – 1) + 1 nodes.

Limitation Lemma There is no SAT solver algorithm in the Unit Propagation Framework with 1 Selection and Cache, which can show that [2^n] is unsatisfiable using fewer UP steps than 2^n + 2^(n-1) - 2. It holds, because each cache unit A-tree, which correspond to a run of this framework on [2^n] has at least 2^n + 2^(n-1) – 1 nodes.

Hence Therefore, each SAT solver in this framework uses at least 2^n + 2^(n-1) – 2 UP steps to show that [2^n] is unsatisfiable. Hence, SAT solvers are non-polynomial in Unit Propagation Framework with 1 Selection and Cache.

Thank you for your attention! Download: http://www.risc.uni-linz.ac.at/people/gkusper/UPF.ppt