Effective Bounding Techniques For Solving Unate and Binate Covering Problems

1. Xiao Yu Li Seattle, WA, USA Effective Bounding Techniques For Solving Unate and Binate Covering Problems Matthias F. Stallmann Raleigh, NC, USA Franc Brglez Raleigh, NC, USA

2. Related Work • Unate (Set) Cover Problem (UCP) 1987: espresso, Rudell et al 1993: espresso-signature, McGeer at al …. • Binate Cover Problem (BCP) 1996: scherzo, Coudert 2002: bsolo, Manquinho et al …

3. Native MinCostSat Problems ATPG Minimum-Length Plan Logic Minimization TechnologyMapping Crew Scheduling FSM Minimization Vehicle Routing Boolean Relations MinCostSat Covering Non-Covering Binate Covering Unate Covering

4. Outline • Background • Our UCP/BCP Solver • Experimental Results • Conclusions

5. Unate (Set) Covering Three backup positions to fill. Five players to choose from. Want to minimize the number of players. Duncan Francis Malone Stockton Yao Guard 1 1 Forward 1 1 Center 1 1 1

6. Unate Covering as CNF Sat • Conjunctive Normal Form Guard F ∨ S Forward D ∨ M Center D ∨ M ∨ Y • Goal: minimize F + S + D + M + Y Min-cost solutions: F =1, D =1, S = M = Y = 0 M =1, S =1, D = F = Y = 0

7. Binate Covering Problem Additional constraint 1: Malone and Stockton are together ( M ∧ S) (M ∨ S) ∧ (M ∨ S) Additional constraint 2: Duncan and Stockton can’t be signed together ( D ∧ S ) D ∨ S

8. Binate Covering Problem (cont.) constraints covering matrix F ∨ S D ∨ M D ∨ M ∨ Y M ∨ S M ∨ S D ∨ S

9. ATPG Minimum-Length Plan Logic Minimization TechnologyMapping Crew Scheduling FSM Minimization Vehicle Routing Boolean Relations MinCostSat Problems Revisited MinCostSat Covering Non-Covering Binate Unate Most rows have both 1’s and -1’s Covering Matrix No -1’s Most rows have no -1’s

10. Solve MinCostSat as ILP MinCostSat is a special case of 0-1 integer linear programming For each constraint in the MinCostSat instance... x1∨ x2∨ x3∨ x4 ...replace xi with (1 - xi): (1 − x1) + x2 + (1 − x3) + x4 ≥ 1 −x1+ x2 − x3+ x4≥ −1

11. −x1 + x2 − x3 + x4 ≥ −1 x1 v x2 v x3 v x4 x1 v x2 v x4 x1 v x2 v x3 −x1 − x2 + x4 ≥ −2 x1 + x2 + x3 ≥ 1 MinCostSat as ILP: an example MinCostSat ILP Assume unit cost, minimize: x1 + x2 + x3 + x4

12. Technology Mapping • Cover A m1 ∨ m4 ∨m5 • Cover B m2 ∨m4 • Cover C m3 ∨m5 • m2 ∨ m1 m2 ∨ m1 • m3 ∨ m1 m3 ∨ m1

13. Our UCP/BCP Solver Classical branch and bound 1. Upper/lower bound calculation (for a unate example) 2. Branching (variable assignment) 3. One iteration of the main algorithm 4. Effect of better (global) upper bounds and (local) lower bounds.

14. LB = 3 An Example (Steiner 9) UB = 6 find “cover” to get UB based on max. ind. set (MIS)

15. st09 X2 X3 X4 X5 X6 X7 X8 X9 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 After assignment of a variable UB = 4 (+ 1 = 5) X1 = 1 X1 = 0 LB = 2 (+ 1 = 3)

16. UB=5 LB=4 The algorithm: one iteration 2. select a variable 1. dequeue “best” node in priority queue x x=0 x=1 UB=6 LB=3 3. create two new nodes UB=5 LB=4 UB=5 LB=3 UB=5 LB=3 4. do reduction and compute bounds 5. enqueue both new nodes

17. on queue legend Lower and Upper Bounds UB/LB UB= 7 6 5 7/3 x5=0 x5=1 7/5 6/4 x9=0 x9=1 dead end 7/6 5/4 dead end

18. Branch-and-bound solver: eclipse Initialize root; Q.enqueue(root); globalUB=UB(root) The algorithm while ( Q is not empty ) { node = Q.dequeue(); if( LB(node) < globalUB ) { select branching variable x_i for ( b = 0 to 1 ) { n_b = (node for x_i = b) do reduction and bounds for n_b if ( UB(n_b) < globalUB ) {globalUB = UB(n_b) } if ( LB(n_b) < globalUB ) { Q.enqueue( n_b) } }}}

19. Eclipse Performance Factors • Seven Performance Factors • Lower Bounding (ILP techniques) • Upper Bounding (stochastic search) • Search-Tree Exploration Strategies • Branching Variable Selection • Search Pruning • Reductions • Data Structures

20. Factor 1: Lower Bounding Three lower-bounding strategies: • Maximum Independent Set (MIS) • Linear Programming Relaxation (LPR) • Cutting Planes (CP)

21. Lower Bounding: MIS • MIS - maximum independent set of rows • Row 1, 2 form an independent set => LB = 2 • Row 1, 3, 4 form an independent set => LB = 3

22. Feasible region Lower Bounding: LPRelaxation Relax integer constraints (LPR): x2 Integer optimum = 2 (1, 1) (0.5, 0.5) LP cost = 1.0 x1 LP optimum is a lower bound on integer optimum

23. Cut Lower Bounding: Cutting Planes (CP) x2 Feasible region (0.7, 1.1) (0.5, 0.5) x1 CP cuts off fractional solution but not integer solutions

24. 115 110 105 100 95 90 MIS MIS2 LPR CP Lower Bound Methods (rot.b) are needed to see this picture. Graphics decompressor QuickTimeｪ and a 0 1 2 3 4 5 OPT (MIS2 is MIS with extra tricks) Most effective by far: CP

25. MIS MIS2 LPR CP Lower Bound Methods (apex4.a) 800 750 700 650 600 550 500 OPT Most effective: CP

26. MIS MIS2 LPR CP Lower Bound Methods (c1908_F) 12 10 8 6 4 2 0 OPT no bounding method appears effective here … (not a case of covering problem instance)

27. Next Performance Factor: • Lower Bounding (ILP techniques) • Upper Bounding (stochastic search) • Search-Tree Exploration Strategies • Branching Variable Selection • Search Pruning • Reductions • Data Structures

28. Factor 2: Upper Bounding • Stochastic local search for optimal solution: • Apply at the root only or at each node • Initialization – solution based on linear programming for lower bound • For comparison purposes we initialize the global UB to the cost of the optimal solution (oracle)

29. root node oracle Upper Bound Methods (max1024) we report average cpu-seconds to solve the instance with different UB strategies using the same LB (the best possible, i.e. CP) 240 200 160 120 80 40 0 none

30. bench1.pi 300** 4.7 **timeout value Local Search Initialization … random initialization of local search is not effective, see the table of runtimes (in cpu-seconds): rounded LP solution benchmark random

31. … search using priority queue performs better than depth-first search (recursion - the usual method): benchmark depth-first priority* max1024 74.1 27.5 Factor 3: Tree-Exploration Strategy (runtimes in cpu-seconds) * smallest lower bound first (to try to reduce UB quickly)

32. Experimental Results • The solvers • Scherzo [Coudert, DAC1996] • Cplex (State of the art IP/ILP Solver) • Eclipse-lpr (LP Relaxation) • Eclipse-cp (Cutting Planes) • The benchmarks • Logic minimization (unate covering) • FSM minimization (binate covering)

33. Unate Results (nodes visited) “harder” (timed out)

34. Typical Results: Unate (runtime) timeout

35. Typical Results: small binate eclipse-cp spends a lot of time with cuts at each node (cplex visits more nodes and does cuts less frequently)

36. Large binate benchmarks CPLEX only does cuts at some nodes. We visit fewer nodes... ... but spend more time We do cuts everywhere -- could be more judicious

37. espresso (hours) latte (secs) benchmark cover total cover total prom2 --- 12** 12.9 14.7 **timeout prom2 287 287 287 latte = espresso - mincov + eclipse-cp benchmark prod-orig prod-heur prod-latte

38. The Last Words … Acknowledgments: • for the benchmarks • for the solvers (aura, bsolo, espresso, scherzo) • for constructive reviews Under construction: • code tune-ups before the release of eclipse • additional experiments -- for the journal submission -- for comprehensive web-posting of results