Multi-Domain Logic and its Applications to SAT Implementation Issues Tudor Jebelean, Johannes Kepler Unversity Linz Gábor Kusper, Eszterházy Károly College Eger SYNASC 2008

Outline History Implementation issues –Data structure: Spare literal matrix with pointers –Branching: Propagate as much information as possible! Clustering –Test results Deletion of Weaker Assignments –Test results Future work

History Philosophy: Propagate as much information as possible at once! Gábor Kusper: Investigation of Binary Representations of SAT especially 2-Literal Representation. Proceedings of CSCS-2002, Gábor Kusper: Solving the Resolution-Free SAT Problem by Hyper- Unit Propagation in Linear Time. Annals of Mathematics and Artificial Intelligence 43, , Gábor Kusper: Solving and Simplifying the Propositional Satisability Problem by Sub-Model Propagation. PhD thesis. Johannes Kepler University Linz, RISC, Gábor Kusper, Lajos Csőke: Better Test Results for the Graph Coloring and the Pigeonhole Problems using DPLL with k-Literal Representation. Proceedings of ICAI-2007, Volume II , 2007.

Literal in Multi-Domain Logic A literal is the set of the Boolean assignments which make the function true. The representation: {}FALSE {0}  a {1}a{0,1}TRUE { }FALSE{00}  a  b {11}a  b{00,11}a  b {10}a  b {00,10}  b {10,11}a {00,10,11}a  b {01}  a  b {00,01}  a {01,11}b {00,01,11}  a  b {01,10}a  b {00,01,10}  a  b {01,10,11}a  b{00,01,10,11} TRUE a  b

Literal Representation Note that we need 2 k bits. The representation: 00FALSE 10  a 01a11TRUE 0000FALSE1000  a  b 0001a  b1001a  b 0010a  b 1010  b 0011a 1011a  b 0100  a  b 1100  a 0101b 1101  a  b 0110a  b 1110  a  b 0111a  b1111TRUE a  b

Basics of the implementation

Literal Representation A literal is represented as an integer array. This allows us to use bitwise operations: Intersectionbitwise and (&) Unionbitwise or (|) Based on these fast methods we can implement –Unit Propagation –Deletion of Weak Assignments

Unit Propagation on Literal Level Up to 5 prop. variables / multi-variable we can represent a literal by 1 integer (32 bits). In this case we need only 3 elementary operations: –public void unitPropagation(int unit) { bits &= unit; if ( bits == unit ) { subsumed = true; } }

Unit Propagation on Literal Level In general a literal is an integer array. Then we need O(3 * 2 k / 32) elementary operations: public void unitPropagation(Literal unit) { intersection(unit); if (equals(unit)) { subsumed = true; } } public void intersection(Literal lit) { int[] input = lit.getBits(); for (int i=0; i<bits.length; i++) { bits[i] &= input[i]; } } public boolean equals(Literal lit) { boolean isEqu = true; int[] input = lit.getBits(); for (int i=0; i<bits.length; i++) { if (bits[i] != input[i]) { isEqu = false; break; } } return isEqu; }

Details of the implementation Data structure: Spare literal matrix with pointers Branching: Propagate as much information as possible!

Data structure Spare literal matrix with pointers Example: ( a  ¬b )  (¬a  c )  (¬a  ¬c ) Multi-var_1 … 2 var. / multi-var: Domains: Clause_1 Clause_2 …

Literal Representation, Once more Note that we need 2 k bits. The representation: 00FALSE 10  a 01a11TRUE 0000FALSE1000  a  b 0001a  b1001a  b 0010a  b 1010  b 0011a 1011a  b 0100  a  b 1100  a 0101b 1101  a  b 0110a  b 1110  a  b 0111a  b1111TRUE a  b

Granularity of Unit Propagation A unit has exactly one literal, which is an integer array (with k = 2^number of prop. var / multi-var bits). With this representation we may propagate: 1, 2, …, k-1 bits at once Most coarse grained UP (lot of information):1 bit … Normal UP (half of the information):k/2 bits … Most fine grained UP (very little information):k-1 bits We may mix kind of UPs when we branch!

Propagate as much as possible Use always the most coarse grained UP for branching, i.e., propagate as much information as you can!

Test results We tested our Java implementation on unsatisfiable SAT problems from the SATLIB page:

What is the value of Multi-Domain Logic? Multi-Domain Logic brings new ideas, which result in new simplification techniques: –Clustering –Deletion of Weak Assignments –Variable merging We implemented DPLL using Multi-Domain Logic to judge these techniques.

Clustering Clustering is a method which shuffles the propositional variables in order to have more multi-variable units at the beginning of the search.

Search Space BRANCHING UNIT PROPAGATION Early UNIT PROPAGATIONS small search space!

Does Multi-Domain Logic allow early units? YES! Do this: –Take the shortest clause. –Merge its variables. –Now it is a unit! BUT! –The number of bits grows exponential by increasing the number of merged Boolean variables! The solution! –Cluster the input clause set before the search starts!

Clustering uuf cnf, rate = 7 Before clustering: %TERNARY %BINARY %TERNARY %TERNARY %TERNARY %BINARY %TERNARY %TERNARY %TERNARY %BINARY … After clustering: %BINARY %BINARY %BINARY %TERNARY %BINARY %BINARY %BINARY %TERNARY %UNIT %BINARY … Borders are at: 1, 8, 15, 22, 29, 36, 43, 50, 57, …

Test Result, Clustering UUF050: Unsatisfiable Uniform Random-3-SAT Problems with 50 propositional variables

The same result in table form Propositional variables / multi-variable: Running time without clustering (ms): Running time with clustering (ms): Clustering gives significant speed-up! Best running time (319 ms) is in case of clustering and 3 prop. var. / multi-var. Note that the longest clause is 3-clause!

Weaker Assignments Let F be a formula, D be a domain and v, w elements of D. Then w is weaker than v iff v occurs in any literal where w occurs. The weaker assignment w can be eliminated from D, because any solution using w can be transformed in a solution using v

Search Space

Search Space after Deleting the Weaker Assignments

Test Results Pigeon Hole Problem with 6 holes and 7 pigeons hole6.cnf: …

The same result in table form Propositional variables / multi-variable: Running time (ms) with no Deletion of Weaker Assignments (DoWA): Running time (ms) with DoWA only once in the preprocessing: Running time (ms) with DoWA also after a new unit is found: Deletion of Weaker Assignments gives significant speed-up! Best running times is in case of 6 prop. var. / multi-var. Note that the longest clause is 6-clause!

The same table for hole7.cnf Propositional variables / multi-variable: Running time (ms) with no Deletion of Weaker Assignments (DoWA): Running time (ms) with DoWA only once in the preprocessing: Running time (ms) with DoWA also after a new unit is found: Deletion of Weaker Assignments gives significant speed-up! Best running times is in case of 7 prop. var. / multi-var. Note that the longest clause is 7-clause!

Future work Now it is implemented in Java. –Migrate it to C / C++. We would like to implement –Variable merging, –Lazy data structure, –Watch literals, –Pure literal elimination.

Thank you for your attention!