1 / 50

Figaro Yet Another Constraint Programming Library

Figaro Yet Another Constraint Programming Library. Martin Henz, Ka Boon Ng National University of Singapore Tobias Müller Universität des Saarlandes. Finite Domain Constraint Programming. A technique for solving combinatorial search and optimization problems. S E N D + M O R E = M O N E Y.

felix
Download Presentation

Figaro Yet Another Constraint Programming Library

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

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

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

  4. S E N D+ M O R E= M O N E Y Modeling 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

  5. S E N D+ M O R E= M O N E Y S  N E  N N  N D  N M  N O  N R  N Y  N 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

  6. Propagate S E N D+ M O R E= M O N 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} 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

  7. Propagate S E N D+ M O R E= M O N 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} 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

  8. Propagate 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} 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

  9. Labeling S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..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 E  4 E = 4 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}

  10. Propagate S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..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 E  4 E = 4 S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8}

  11. Labeling S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S E N D+ M O R E= M O N E Y E  4 E = 4 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} S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8}

  12. Propagate S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} S E N D+ M O R E= M O N E Y E  4 E = 4 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} N  {6} D  {7} M  {1} O  {0} R  {8} Y  {2} S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8}

  13. 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 E N D+ M O R E= M O N E Y E = 4 E  4 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} N  {6} D  {7} M  {1} O  {0} R  {8} Y  {2} S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1} O  {0} R  {2..8} Y  {2..8} E  6 E = 6

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

  15. FD(CP) Languages and Libraries • Languages • CLP(FD) • Eclipse, CHIP • CLAIRE new language • Oz new language • Libraries • PECOS LISP • Ilog Solver C++ • Figaro C++, under development Prolog based

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

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

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

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

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

  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}... E = 4 E  4 S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 6 E  6

  22. Representing Search Trees class naive : public node { private: int idx;vector<var> vars;node*subtree; public : naive(vector<var> 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. Backtracking mark store::mark(); void store::backtrack(mark m); S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 6 E  6

  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. 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. Trailing vs Copying • Trail and backtrack • Copy and abandon S  {9} E  {4..7} N  {5..8} D  {2..8} M  {1}... E = 4 E  4 S  {9} E  {5..7} N  {6..8} D  {2..8} M  {1}... E = 5 E  5 S  {9} E  {5} N  {6} D  {7} M  {1}.. S  {9} E  {6..7} N  {7..8} D  {2..8} M  {1}... E = 6 E  6

  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. Labeling Refers to Variables class naive : public node { private: int idx;vector<var> vars;node*subtree; public : naive(vector<var> 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. 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. Indirect Addressing store vars props trail only use indices in arrays to address variables, propagators and marks 1 2 3 4 5 . . . 1 2 3 4 5 . . . 1 2 3 4 5 . . . Now nodes don’t need to care, whether they work on original or copy.

  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. 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. 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. 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. 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. 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. 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. ?? Global Search ?T F? v1  v2,v1  v2,v1  v2 T? ?F FT TT FF TF

  39. ?? Global Search v1=F ?T F? v1=T v1  v2,v1  v2,v1  v2 T? ?F FT TT FF TF

  40. ?? Global Search v1=F ?T F? v1=T v1  v2,v1  v2,v1  v2 T? v2=T ?F v2=F FT TT FF TF

  41. ?? Global Search v1=F ?T F? v1=T v1  v2,v1  v2,v1  v2 T? v2=T ?F Search Tree v2=F FT v2=T TT FF v2=F solution TF

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

  43. Local Search v1  v2,v1  v2,v1  v2 FT Search Space TT FF TF

  44. Local Search v1  v2,v1  v2,v1  v2 neighborhood FT initial assignment TT FF TF

  45. Local Search v1  v2,v1  v2,v1  v2 FT TT FF local move TF

  46. Local Search v1  v2,v1  v2,v1  v2 FT TT FF TF local move

  47. Local Search v1  v2,v1  v2,v1  v2 FT TT FF solution found TF

  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. 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. Figaro (very last slide) • Figaro, an offspring of Mozart • F I nite domain GA dget for combinatorial p RO blem solving

More Related