1. 1 Figaro Yet Another Constraint Programming Library Martin Henz, Ka Boon Ng National University of Singapore Tobias Müller Universität des Saarlandes

2. 2 Finite Domain Constraint Programming A technique for solving combinatorial search and optimization problems.

3. 3 S E N D + M O R E = M O N E Y

4. 4 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y Modeling

5. 5 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  N E  N N  N D  N M  N O  N R  N Y  N

6. 6 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  {0..9} E  {0..9} N  {0..9} D  {0..9} M  {0..9} O  {0..9} R  {0..9} Y  {0..9} Propagate

7. 7 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  {1..9} E  {0..9} N  {0..9} D  {0..9} M  {1..9} O  {0..9} R  {0..9} Y  {0..9} Propagate

8. 8 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} Propagate

9. 9 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 4 E  4 Labeling

10. 10 S E N D + M O R E = M O N E Y 0  S,…,Y  9 S  0 M  0 S…Y all different 1000*S + 100*E + 10*N + D + 1000*M + 100*O + 10*R + E = 10000*M + 1000*O + 100*N + 10*E + Y S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 4 E  4 Propagate

11. 11 S E N D + M O R E = M O N E Y S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 4 E  4 Labeling S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 5 E  5 S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8}

12. 12 S E N D + M O R E = M O N E Y S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 4 E  4 Propagate S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1} O  {0} R  {8} Y  {2}

13. 13 S E N D + M O R E = M O N E Y Complete Search Tree S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 4 E  4 S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1} O  {0} R  {8} Y  {2} E = 6 E  6

14. 14 Is That All? Complex symbolic constraints Programmable search Trailing vs copying Design patterns for constraint programming Integration of other search techniques S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. E = 6 E  6

15. 15 FD(CP) Languages and Libraries Languages –CLP(FD) –Eclipse, CHIP –CLAIRE new language –Oznew language Libraries –PECOSLISP –Ilog SolverC++ –FigaroC++, under development Prolog based

16. 16 Design Issues Languages –CLP(FD) –Eclipse, CHIP –CLAIRE –Oz Libraries –PECOS –Ilog Solver Syntax Integration with application programming Programming propagation algorithms Programming search strategies Programming search algorithms

17. 17 Representing the Constraint Store class store { public: store(); var newvar(int lo, int hi); var getlo(var v); var gethi(var v);... }

18. 18 Representing the Constraint Store class store { public: store(); var newvar(int lo, int hi); var getlo(var v); var gethi(var v);... } int main(...) { store*st=new store();...}

19. 19 Representing the Constraint Store class store { public: store(); var newvar(int lo, int hi); var getlo(var v); var gethi(var v);... } int main(...) { store*st=new store(); s = st -> newvar(0,9);... y = st -> newvar(0,9);...}

20. 20 Representing the Constraint Store class store { public: store(); var newvar(int lo, int hi); var getlo(var v); var gethi(var v);... } int main(...) { store*st=new store(); s = st -> newvar(0,9);... y = st -> newvar(0,9); all_different(st, s,..,y);...}

21. 21 Representing Search Trees class node { public: virtual node* child(store *,int)=0; } S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. E = 6 E  6

22. 22 Representing Search Trees class naive : public node { private: int idx;vector vars;node*subtree; public : naive(vector vs,int i,node*t) :... {} node* child(store*st, int i) { if (i==0) { st->tell(vars[idx],st->getlo(vars[idx])); return (idx+1==var.size() ? subtree : new naive(vars,idx+1,subtree)); } else { st->tell(vars[idx],st->getlo(vars[idx])+1, st->gethi(vars[idx])); return new naive(vars,idx,subtree); }}};

23. 23 Backtracking mark store::mark(); void store::backtrack(mark m); S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. E = 6 E  6

24. 24 Depth-first Search (backtracking) node * solve_one(store * s,node * t) { if (t == NULL) return t; mark m = s->mark(); try {return solve_one(s,t->child(s,0));} catch (Failure) { s->backtrack(m); return solve_one(s,t->child(s,1)); }

25. 25 Stepping Back Nothing new so far; Oz has programmable search algorithms through spaces (Schulte, ICLP’97); Ilog Solver has IlcManager objects. But: –“lean” stores –nodes as an abstraction for programming search strategies more on the basic data structures in the proceedings moving on: Trailing vs. Copying (Schulte, ICLP’99)

26. 26 Trailing vs Copying Trail and backtrack Copy and abandon S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. E = 6 E  6

27. 27 Copying Stores Simply copy the store with all variables and constraints: store::store(const store*); But: nodes refer to variables; their addresses change!

28. 28 Labeling Refers to Variables class naive : public node { private: int idx;vector vars;node*subtree; public : naive(vector vs,int i,node*t) :... {} node* child(store*st, int i) { if (i==0) { st->tell(vars[idx],st->getlo(vars[idx])); return (idx+1==vars.size() ? subtree : new naive(vars,idx+1,subtree)); } else { st->tell(vars[idx],st->getlo(vars[idx])+1, st->gethi(vars[idx])); return new naive(vars,idx,subtree); }}};

29. 29 Search Refers to Marks node * solve_one(store * s,node * t) { if (t == NULL) return t; mark m = s->mark(); try {return solve_one(s,t->child(s,0));} catch (Failure) { s->backtrack(m); return solve_one(s,t->child(s,1)); }

30. 30 Indirect Addressing only use indices in arrays to address variables, propagators and marks Now nodes don’t need to care, whether they work on original or copy. 12345...12345... 12345...12345... 12345...12345... varspropstrail store

31. 31 Depth-first Search (copying) node * solve_one(store * s,node * t) { if (t == NULL) return t; store s2 = new store(s); try {return solve_one(s,t->child(s,0));} catch (Failure) { return solve_one(s2,t->child(s,1)); }

32. 32 Stepping Back Indirect addressing allows copy and trailing- based search Possibly interesting combinations of the two to be explored Moving on: Memory policy just one dimension in the “design space” for search algorithms.

33. 33 Dimensions in the Design Space for Search Algorithms Exploration: depth-first search, limited- discrepancy search,... Memory policy: copying, trailing,... Optimization: branch-and-bound, restart optimization,... Interaction: first, last, all solution search, tracing,... Visualization: “Oz Explorer” like search tree visualization

34. 34 STK: Software Engineering of Inference Engines STK originally developed for Oz Allows to separate design dimensions into modules Software architecture ensures reusability of components STK ideas will be at the heart of Figaro

35. 35 Example: Exploration and Interaction Exploration is defined by a class that extends the abstract class exploration. class exploration { public: virtual node * one_step()=0; }

36. 36 Example: Exploration and Interaction Exploration is defined by a class that extends the abstract class exploration. class exploration { public: virtual node * one_step()=0; } Interaction calls one_step according to the desired mode of interaction. node * first(exploration * e) { node * n; while (n = e->one_step()) if (n==success_node) break; return n; }

37. 37 Stepping Back Design patterns for tree search More in paper: A Search Toolkit for Constraint Programming (PADL’00) Moving on: Constraint programming is just one technique: local search?

38. 38 Global Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT F? ?T T? ?F ??

39. 39 Global Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT F? ?T T? ?F ?? v 1 =F v 1 =T

40. 40 Global Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT F? ?T T? ?F ?? v 1 =F v 1 =T v 2 =F v 2 =T

41. 41 Global Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT F? ?T T? ?F ?? v 1 =F v 1 =T v 2 =F v 2 =T v 2 =F v 2 =T solution Search Tree

42. 42 Local Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT F? ?T T? ?F ?? v 1 =F v 1 =T v 2 =F v 2 =T v 2 =F v 2 =T solution consider only full assignments of variables to values

43. 43 Local Search FF FT TF TT Search Space v 1  v 2,v 1  v 2,v 1  v 2

44. 44 Local Search v 1  v 2,v 1  v 2,v 1  v 2 FF FT TF TT initial assignment neighborhood

45. 45 Local Search local move FF FT TF TT v 1  v 2,v 1  v 2,v 1  v 2

46. 46 Local Search v 1  v 2,v 1  v 2,v 1  v 2 local move FF FT TF TT

47. 47 Local Search v 1  v 2,v 1  v 2,v 1  v 2 solution found FF FT TF TT

48. 48 Observations Data structures needed for constraint programming are the same as in local search. Integration of CP and LS has been approached before. –Stephen Won, MS thesis supervised by Jimmy Lee (1997)

49. 49 Stepping Back (for good) Viewing constraint programming as a collection of design patterns. Flexible memory policy through indirect addressing Figaro initiative: –library for discrete problem solving and optimization –local search and constraint programming (LP,IP?) –designed by researchers for researchers –open source, current contributors: N U Singapore, partners: CUHK, PSL

50. 50 Figaro (very last slide) Figaro, an offspring of Mozart F I nite domain GA dget for combinatorial p RO blem solving