Introduction to IBEX. Jordan Ninin LAB-STICC / ENSTA-Bretagne Brest, France

Transcription

1 Introduction to IBEX Jordan Ninin LAB-STICC / ENSTA-Bretagne Brest, France Jan, 2014 Jordan Ninin IBEX Jan, / 51

2 First Use Progamming Langage: C++ using your favorite editor (Eclipse, QtCreator, Gedit, vi,...) Minimal integration: #include ibex.h using namespase ibex; First Program: #include ibex.h using namespace std; using namespace ibex; int main(int argc, char argv) { // write your own code here } Jordan Ninin IBEX Jan, / 51

3 Architecture 1 Arithmetic: Interval, IntervalVector,... 2 Symbolic: Function, Variable, 3 Modelisation: NumConstraint, System, SystemFactory, 4 Contractor: CtcFwdBwd, CtcUnion, CtcCompo,... 5 Strategy: DefaultSolver, DefaultOptimizer,... * Tools: Bsc, LinearSolver, CellBuffer,... Jordan Ninin IBEX Jan, / 51

4 Outline 1 Arithmetic Interval IntervalVector IntervalMatrix 2 Symbolic Function, Variable Evaluation 3 Modelisation NumConstraint System 4 Contractor Contractor Algebra Advanced Contractors 5 Tools 6 Strategy Jordan Ninin IBEX Jan, / 51

5 Interval Interval Fundamental rules IBEX is entire based over the type Interval. Each usual arithmetic function are extended to the intervals. Each real number are represented by an interval of 2 floating-point numbers which enclose it. Each operator of the interval arithmetic are computed to respect the inclusion property over the floating-point number. Jordan Ninin IBEX Jan, / 51

6 Interval Basic Constructors and Operators Interval x(1,2); // create the interval [1,2] Interval y(3); // create the interval [3,3] Interval y1; // create the interval [ oo,oo] Interval y2=interval::all_reals; // y2 =[ oo,oo] Interval y3=interval::empty_set; // create the empty interval Interval y4=interval::pi; // y4=[ , Succ( )] Interval z1 = x+y; Interval z2 = x + Interval(5,6) + 4; Interval z3 = z1 + exp(x) acos(y) +log(x z2); Interval z4 = z1 & z2 // z4 = the intersection of z1 and z2 Interval z5 = z1 z2 // z5 = the hull of the union of z1 and z2 Jordan Ninin IBEX Jan, / 51

7 Interval Addition Methods x.lb() x = inf([x]), x.contains(d) True iff d [x], x.ub() x = sup([x]), x.is subset(y) True iff [x] [y], x.mid() the middle of [x], x.is disjoint(y) True iff [x] [y] =, x.rad() the radius of [x], x.is empty() True iff [x] ==, x.diam() the diameter of [x], x.mag() max( x, x ),... ==,!=, +=, -=, *=, /=, &=, =, x.is unbounded(), x.is strict subset(y), x.is bisectable(), x.inflate(d),... Jordan Ninin IBEX Jan, / 51

8 IntervalVector IntervalVector Definie a vector of Interval. // create the interval vector ([ oo,oo],[ oo,oo]) IntervalVector x1(2); // create the intervalvector ([1,3],[1,3]) IntervalVector x2(2,interval(1,3)); //create the interval vector ([0,1],[2,3],[4,5]) double x[3][2]={{0,1},{2,3},{4,5}}; IntervalVector x3(3,x); //create the interval vector ([3.6,3.6],[3.6,3.6],[3.6,3.6],[3.6,3.6]) Vector yy(4,3.6); IntervalVector y(yy); // modify the first element of y y[0] = x3[2] + x2[1]; Jordan Ninin IBEX Jan, / 51

9 IntervalVector IntervalVector x2.init(interval(2,3)); x3.perimeter(); x3.volume(); x3.max_diam(); x3.size(); x1.set_empty(); x2.resize(4); IntervalVector x5= x3.subvector(start,end); Other basic operators are available like in Interval: x.lb(), x.ub(), x.mid(), x.diam(), x.rad(), ==,!=, +=, -=, *=, /=, &=, =, x.is unbounded(), x.is strict subset(y), x.is bisectable(), x.inflate(d),... Jordan Ninin IBEX Jan, / 51

10 IntervalMatrix IntervalMatrix Since we cannot build 3-dimensional arrays in C++, all the bounds must be set in a single n*2 array representing the matrix row by row double _M[9][2]={{0,1},{0,1},{0,1}, {0,2},{0,2},{0,2}, {0,3},{0,3},{0,3}}; IntervalMatrix M(3,3,_M); / create M = (([0,1] [0,1] [0,1]) ; ([0,2] [0,2] [0,2]) ; ([0,3] [0,3] [0,3]) ) / Jordan Ninin IBEX Jan, / 51

11 IntervalMatrix Operator between IntervalVector and IntervalMatrix double _x[3][2]={{0,1},{2,3},{4,5}}; IntervalVector x(3,_x); IntervalMatrix M(3,3); M=Matrix::eye(3)+Interval( 1,1) Matrix::ones(3); IntervalVector y=m x; // matrix vector multiplication IntervalMatrix N=M.transpose(); // N is MˆT Jordan Ninin IBEX Jan, / 51

12 Symbolic Type Variable Variable x ; // create a scalar variable Variable v(3); // create a vector variable of size 3 Variable m(4,4); // create a Matrix 4x4 symbolic variable Function Variable x(2), y; Function f(x, x[0] pow(x[2],2) exp(x[0] x[2]); Function h(x,y, x[1] (x[0]+y)); Warning! the maximal number of variable is limited to 6: Solution: compress all the variables in a single vector variable. Jordan Ninin IBEX Jan, / 51

13 Function, Variable Example: f(x) = x 0 x 2 1 exp(x 0x 1 ) exp x 0 x 2 x 1 x 0 x 1 a Function is the expression tree of a mathematical equation, a Variable is a leaf of the expression tree. Jordan Ninin IBEX Jan, / 51

14 Function, Variable Create a Function Vector-valued/Matrix-valued function: Return Variable x,y; Function f(x,y, Return(x y, x y)); Function g(x,y, Return(Return(exp(x),sqrt(y)), Return(x y,log(x) ) ); Using the Minibex syntax function f(x) return ((2 x, x); ( x,3 x)); end Function f( myfunction.txt ); Listing 1: myfunction.txt Jordan Ninin IBEX Jan, / 51

15 Function, Variable Other Composing Function / create the distance function with 2 arguments / Variable a(2), b(2); Function dist(a,b,sqrt(sqr(a[0] b[0])+sqr(a[1] b[1]))); / create the constant vector pt=(1,2) / Vector pt(2); pt[0]=1; pt[1]=2; / create the function x >dist(x,pt). / Variable x(2); Function f(x,dist(x,pt)); Symbolic Differentiation: Function::DIFF Function gf(f, Function::DIFF); = Create the expression tree of the gradient of the function f. Jordan Ninin IBEX Jan, / 51

16 Evaluation Interval Evaluation The interval evaluation of f is an enclosure of the image of the given input interval vector [x] by f: {f(x),x [x]} f([x]) The input of a Evaluation is an IntervalVector in any case (no matter the dimension of the variable). The order of the input IntervalVector is the same order as the one of the variable at the creation of the function. The type of the output depends of the evaluator: IntervalVector x(5,interval( 1,1)); Interval y = f.eval(x); IntervalVector yv= g.eval_vector(x); IntervalMatrix ym= h.eval_matrix(x); Jordan Ninin IBEX Jan, / 51

17 Evaluation Example: x [1,2] [1,3], f(x) = x 0 x1 2 exp(x 0x 1 ) [ , ] [ , ] [1, 18] exp [2.718, ] [1,2] x 0 x 2 [1,9] [1,6] [1,3] x 1 x 0 x 1 [1,3] [1,2] Jordan Ninin IBEX Jan, / 51

18 Evaluation Gradient/Jacobian evaluation The interval evaluation of f is an enclosure of the image of the gradient/jacobian of f over an interval vector [x]: { f(x),x [x]} f([x]) The type of the output depends of the evaluator: IntervalVector x(5,interval( 1,1)); IntervalVector yv= f.gradient(x); IntervalMatrix ym= g.jacobian(x); Jordan Ninin IBEX Jan, / 51

19 Evaluation Example: x [1,2] [1,3], f(x) = x 0 x 2 1 exp(x 0x 1 ), f ( [ ,6.282] [ , 9.282] [ , 6.282] [ , ] [ , 9.282] [2.718, ] [2.718, ] [1,9] [1, 18] exp [2.718, ] [2, 12] [0,0] [2,6] [1,1] x 0 x 2 [1,2] [1,2] [1,9] [1,6] [0,0] [1,3] [0,0][1,3] x 1 x 0 x 1 [1,3][0,0] [1,1] [1,1] [1,1] [1,2] [0,0] Jordan Ninin IBEX Jan, / 51 )

20 Evaluation Backward evaluation The backward evaluation is the reverse process of an evaluation. Given two intervals [y] and [x], it compute an interval [z]: [z] = [x] {z,f(z) [y]} or [z] = [x] f 1 ([y]) This algorithm does not return a new interval [z] but contract the input interval [x] which is therefore an input-output argument. Variable x1, x2; Function f(x1,x2,sin(x1+x2)); double _box[2][2]={{1,2},{3,4}}; IntervalVector box(2,_box); f.backward( 1.0,box); / box = ([1, ] ; [3, ]) / Jordan Ninin IBEX Jan, / 51

21 Evaluation Example: Let f(x) = x 0 x 2 1 exp(x 0 +x 1 ) f.backward(-100, ([1,2],[2,6])) [ , [ 100, 100] ] [4, 72] exp [104, [ , 172] ] [1,2] x 0 x 2 [4,36] + [4.6443, [3, 8] ] [2.6443, ] [2,6] x 1 x 0 x 1 [2.6443, [2,6] ] [1,2] After the backward, box = [1,2] [2.6443,4.1474] Jordan Ninin IBEX Jan, / 51

22 Evaluation Exercice: If I have an scalar variable, an Vector variable and an Matrix variable, how can I arrange this in a single IntervalVector to compute a evaluation? = Use the backward algorithm to insert in an IntervalVector and the eval algorithm to extract from it!!! Jordan Ninin IBEX Jan, / 51

23 Evaluation Variable x, v(6), m(5,5); Function proj_x(x,v,m, x); Function proj_v(x,v,m, v); Function proj_m(x,v,m, m); Function f(x,v,m, transpose(v) m v x); Interval xi(3,5); IntervalVector vi(6,interval(0,1)); IntervalMatrix mi(5,5,interval( 1,3)); IntervalVector box( ); proj_x.backward(xi,box); // insert xi in the right position of x in box proj_v.backward(vi,box); // insert vi in the right position of v in box proj_m.backward(mi,box); // insert mi in the right position of m in box Interval res=f.eval(box) Jordan Ninin IBEX Jan, / 51

24 NumConstraint NumConstraint a NumConstraint is a mathematical constraint: f(x) 0, g(x) = 0,... It composes by a function and a comparison sign. The possible signs are: LT (<), LEQ ( ), EQ (=), GEQ ( ), GT (>). Like in Function, the number of variable is limited to 6. Variable x;variable x; NumConstraint c(x,sin(x)=0.5); // the constraint sin(x)=0.5 Function f(x,x+1); NumConstraint c(f,leq); // the constraint x+1<=0 Jordan Ninin IBEX Jan, / 51

25 System System A System in IBEX is a set of constraints with, optionnaly, a goal function to minimize and an initial domain for variables. a System can be created with a file (in MinIbex language) or with a SystemFactory. Variables x1 in [0,1]; x2, x3; Minimize 5 x1 x3ˆ4 (10 x2ˆ2) Constraints 2 x1 + 2 x2 + log(x3) <= 10; end System sys( mysystem.txt ); Jordan Ninin IBEX Jan, / 51

26 System SystemFactory Simplify the construction of System. Warning! each NumConstraint must have the same number of variables. The order of each variable must be respected. Variable x, y; NumConstraint c(x,y, x sqrt(y) >= 0); SystemFactory fac; fac.add_var(x); // add a variable to the system fac.add_var(y); // add a variable to the system fac.add_goal(x+y);// add a objective function fac.add_ctr(c); // add a constraint System sys(fac); Jordan Ninin IBEX Jan, / 51

27 Contractor Programming The key idea behind contractor programming is to abstract the algorithm from the underlying constraint and to view it as function Ctc : Advantage Ctc : IR n IR n such that C([x]) [x] Standardize the interface between algorithms, Simplify Interfaces, Combination, Composition,... Propose building blocks to create high-level algorithm. Jordan Ninin IBEX Jan, / 51

28 Forward-Backward The standard way to contract with respect to a constraint is by using the forward-bacwkard algorithm. Variable x,y,z; NumConstraint c(x,y,z,x+y=z); CtcFwdBwd ctc1(c); Function f(x,y,z, x+y z); CtcFwdBwd ctc2(f); // create the contractor with the constraint f=0 Jordan Ninin IBEX Jan, / 51

29 Forward-Backward This contractor reduces the input box to an enclosure of the domain which respect the constraint, using the method contract. Variable x,y; double = 0.5 sqrt(2); Function f(x,y,return(sqrt(sqr(x)+sqr(y)) d, sqrt(sqr(x 1.0)+sqr(y 1.0)) d); IntervalVector box(2,interval( 10,10)); CtcFwdBwd c(f); c.contract(box); // now box= ([0.2929, ] ; [0.2929, ]) The behavior is the same as: f.backward(0,box); Jordan Ninin IBEX Jan, / 51

30 Fixpoint The fixpoint operator applies a contractor Ctc iteratively, while the gain is more than the given ratio: fixpoint(ctc) : [x] Ctc(...Ctc(Ctc([x]))...), CtcFwdBwd ctc(f); CtcFixPoint ctcfix(ctc,1.e 3); ctcfix.contract(box); Jordan Ninin IBEX Jan, / 51

31 CtcFwdBwd composed with a CtcFixPoint Let c(x) = x 0 x1 2 exp(x 0 +x 1 ) = 100 where [x] [1,2] [2,6]. [ , [ 100, 100] ] [7.12, [6.99, [4, 72] 30.4] 34.4] exp [ , [104, [106.99, 172] 134.4] ] [1,2] x 0 x 2 [7.12, [4,36] [6.99,17.2] 15.2] + [3, [4.6443, [4.67, 8] 4.9] ] [2.6443, [2.67, ] [2,6] 3.9] x 1 x 0 x 1 [2.67, [2.6443, [2,6] 3.9] ] [1,2] C([1,2] [2,6]) [1,2] [ ,3.8667] Jordan Ninin IBEX Jan, / 51

32 Contractor Algebra Union, Composition The interest of the contractor programming is to compose, to intersect, to make the union of contractor: union(c 1,...,C n ) : [x] C 1 ([x])... C n ([x]). inter(c 1,...,C n ) : [x] C 1 ([x])... C n ([x]). compo(c 1,...,C n ) : [x] C n (...C 2 (C 1 ([x])...). The Union corresponds to a logical OR between the NumConstraint of the contractor. The composition is more efficient than the intersection, that is why the composition is always preferred. CtcUnion c_union(c1,c2); CtcCompo c_compo1(c1,c2); Array<Ctc> array(c1,c2,c_union); CtcCompo c_compo2(array); Jordan Ninin IBEX Jan, / 51

33 Advanced Contractors Interval Newton This contractor find a zero of a vector-valued function. It is very efficient if the box contains only one solution. If the box is contracted, it is a mathematical proof that the box contain a solution. Variable x,y; double d = 0.5 sqrt(2); Function f(x,y,return(sqrt(sqr(x)+sqr(y)) d, sqrt(sqr(x 1.0)+sqr(y 1.0)) d); IntervalVector box(2,interval(0.2,0.4)); CtcNewton c(f); c.contract(box); Jordan Ninin IBEX Jan, / 51

34 Advanced Contractors Propagation, Linear Relaxation CtcPropa: The propagation operator calculates the fixpoint of (the composition of) n contractors by using a more sophisticated ( incremental ) strategy than a simple loop. it can be defined as follows: propagation(c 1,...,C n ) := fixpoint(compo(c 1,...,C n )). Array<Ctc> array(c0,c1,c2,c3); CtcPropag(array); CtcPolytopeHull: This contractor computes the convex hull of a System using Linear Relaxation Technique (XTaylor, Affine Arithmetic, Composition). CtcPolytopeHull( new LinearRelaxCombo(sys)); Jordan Ninin IBEX Jan, / 51

35 Advanced Contractors Ctc3BCid, CtcAcid Other improvement of the propagation algorithm, such as: Ctc3BCid(ctc), CtcAcid(sys,ctc): B B 3 B 4 2 B 1 x C([x]) B 1 B 2 B 3 B 4 Jordan Ninin IBEX Jan, / 51

36 Advanced Contractors Q-Intersection The Q-Intersection contract the box, by calculating the union of the boxes resulting from the contraction with all combinations of q contractors among n. q inter(c 1,...,C n,q) := union(...,inter(c i1,...,c iq ),...) This contractor is typically used where we have a set of contractors that result from measurements (each measurement enforces a constraint), some of which can be incorrect. CtcQInter(const Array<Ctc>& list, int q); Jordan Ninin IBEX Jan, / 51

37 Advanced Contractors Your own Contractor To create a contractor, you just have to declare a class that extends Ctc and create: a constructor that calls the constructor of Ctc. The later need the size of the input box. a method: void contract(intervalvector& box) #include ibex.h namespace ibex{ class MyContractor : public Ctc { public: MyContractor(int n) : Ctc(n) { } // Constructor void contract(intervalvector& box) { // Contractor box=box.mid()+0.5 Interval( 1,1) box.rad(); } }; } Jordan Ninin IBEX Jan, / 51

38 Advanced Contractors Other Contractors CtcEmpty(int n): Return the empty box. CtcIdentity(int n): Return the box without modifying. CtcInteger(int nb var, const BoolMask& is int): Contract the box to integer set (according to the mask). CtcInverse(Ctc& c, Function& f): Make a evaluation, then contract the result using c and insert the contraction in the original box using backward algorithm. Interval res= f.eval(box); c.contract(res); f.backward(res,box); CtcNotIn(Function& f, const Interval& y): Contract according the constraint f(x) y. CtcPrecision(int nb var, double ceil): Empty the box if its diameter is smaller than ceil. Jordan Ninin IBEX Jan, / 51

39 Advanced Contractors How to interact two Modelizations of one problem? C 0 ([x] [y]) C 1 ([x]) Model 1 C 11 ([x]): Linear Relaxation C 12 ([x]): Local minimization C 3 ([x],[y]) C 2 ([y]) Link between Model 1 and Model 2 Interaction between [x] and [y] Model 2 C 21 ([y]): Forward-Backward C 22 ([y]): Fixed point over C 21 C 23 ([y]): Local minimization C 0 ([x] [y]) = C 3 ( (C11 C 12 )([x]), (C 21 C 23 )([y]) ) Jordan Ninin IBEX Jan, / 51

40 Advanced Contractors Construct a Contractor depending of a problem C 0 ([x]) C 2 ([x]) = C 1 ([x]) Fixed Point of C 1 ([x]) Forward-Backward of the non-convex part C 3 ([x]) Linear Relaxation of the entire problem except the black-box constraint C 4 ([x]) If condition then Compute the black-box constraint Jordan Ninin IBEX Jan, / 51

41 Tools Bisector: Bsc object to bisect an IntervalVector following a strategy. LargestFirst bsc; pair<intervalvector,intervalvector> res=bsc.bisect(box); Storage: CellBuffer CellHeap stock; stock.push(box); IntervalVector res=stock.pop(); LinearSolver: Interface with a linear solver LinearSolver ls(int nb_vars, int nb_ctr); Jordan Ninin IBEX Jan, / 51

42 Solver: create a Solver/Paver with a contractor, a bisector and a Buffer. All the IntervalVector with a max diam less than prec will be considers as a solution. Solver(Ctc& ctc, Bsc& bsc, CellBuffer& buffer, double prec); std::vector<intervalvector> solve(init_box); Optimizer: create a global optimizer with a system, a contractor and a bisector. Optimizer opti(system& sys, Bsc& bsc, Ctc& ctc, double prec); void optimize(const IntervalVector& init_box); opti.loup point // access to the global minimum of sys Jordan Ninin IBEX Jan, / 51

43 Compiling, Linking Automatic linkage with: Soplex: implementation of a Linear Solver. FiLib or Goal: implementing the interval arithmetic. See the makefile or simple qt.pro and replace the????? by the path where IBEX is installed. Jordan Ninin IBEX Jan, / 51

44 Listing 2: makefile IBEXHOME :=??????????? CXXFLAGS = I$(IBEXHOME)/IBEX/include/ibex I$(IBEXHOME)/IBEX/ include I$(IBEXHOME)/soplex 1.7.2/src frounding math msse2 mfpmath=sse LIBS = L$(IBEXHOME)/IBEX/lib L$(IBEXHOME)/soplex 1.7.2/lib libex lsoplex lprim Listing 3: simple qt.pro IBEXHOME =??????????????????? INCLUDEPATH += $$IBEXHOME/IBEX/include/ibex $$IBEXHOME/IBEX/ include $$IBEXHOME/soplex 1.7.2/src frounding math msse2 mfpmath=sse LIBS += L$$IBEXHOME/IBEX/lib L$$IBEXHOME/soplex 1.7.2/lib libex lsoplex lprim Jordan Ninin IBEX Jan, / 51

45 In Practice DOWNLOAD IBEX Jordan Ninin IBEX Jan, / 51