Constraint Modelling Challenge 2005 In conjunction with The Fifth Workshop on Modelling and Solving Problems with Constraints Held at IJCAI 2005, Edinburgh, Scotland, 31 July, 2005 Barbara M. Smith and Ian P. Gent Cork Constraint Computation Centre, University College Cork, Ireland and School of Computer Science, University of St Andrews, Scotland 1 Introduction The first Constraint Modelling Challenge was posed in May 2005; we challenged constraint programmers to solve a dif- ficult optimization problem. There are a number of existing papers on the problem that we chose, but it had not previously been tackled using constraint programming, to our knowl- edge. In this paper, we attempt to present the thirteen sub- missions that we received, summarising the wide variety of ideas that the Challenge entrants used, and pointing out dif- ferences and similarities. The statement of the problem follows: A manufacturer has a number of orders from cus- tomers to satisfy; each order is for a number of dif- ferent products, and only one product can be made at a time. Once a customer’s order is started (i.e. the first product in the order is being made) a stack is created for that customer. [Each customer places exactly one order.] When all the products that a customer requires have been made, the order is sent to the customer, so that the stack is closed. Be- cause of limited space in the production area, the maximum number of stacks that are in use simulta- neously, i.e. the number of customer orders that are in simultaneous production, should be minimized. More formally: we are given a Boolean matrix in which the columns correspond to the products and each row corresponds to the order of a particular customer. The entry c ij =1 iff customer i has ordered some quantity of product j (the quantity ordered is irrelevant). The objective is to find a per- mutation of the products such that the maximum number of open orders at any point in the sequence is minimized: order i is open at point k in the pro- duction sequence if there is a product required in order i that appears at or before position k in the sequence and also a product that appears at or after position k in the sequence. The problem is one of a number of related sequencing problems discussed by Fink & Voss [4]. Another problem from this paper appears in CSPLib as prob039 (the rehearsal problem) and has previously been tackled using constraint programming. The rehearsal problem can be viewed as the open stacks problem with a different objective (to minimize the order spread, i.e. the total for all customers of the time that their order is in production). The different objective changes the character of the problem completely, however, and ex- perience of solving the rehearsal problem cannot easily be transferred. Fink and Voss cite several papers on the open stacks prob- lem, using a variety of Operations Research techniques. Lin- hares and Yanasse [8] list several equivalent problems, in- cluding graph path-width. The Challenge instances were provided by the groups en- tering the Challenge, and seem to present different kinds of difficulty, depending on their source. Three of the instances (SP2, SP3 and SP4) have not yet been solved optimally. In the following sections, we first describe a number of pre- processing steps that could be used to simplify the instances, and a number of lower bounds on the number of open stacks that can be derived to assist in proving optimality. We then describe the different solution approaches that were tried in the Challenge entries. We do not discuss the performance of the models here; detailed results can be found in the individ- ual submissions. 2 Preprocessing There are a number of ways in which a given instance can be preprocessed to make it simpler to solve. Many or all of these have previously appeared in the literature on the open stacks problem, but here we mainly cite their use in the Challenge submissions. The simplest reduction is to remove orders that require no products and products that do not appear in any order, al- though the Challenge instances should have been constructed so that there are no such orders or products. Let P be the set of products. Let C(p) be the set of orders (or customers) requiring a product p and C(P ) be the set of customers requiring a set of products P ⊂ P . If the orders requiring product j , C(j ), are a subset of those requiring product k, C(k), then product j can be re- moved from the problem; once an optimal sequence is found, product j can be inserted next to product k without affect- ing the maximum number of open stacks. Many Challenge entries remove dominated products in this way, e.g. [11; 13; 14]. Garcia de la Banda and Stuckey [5] and Miller et al. prove the correctness of this reduction; [5; 11] credit it to Bec- ceneri et al. [2], who did not give a proof. Shaw and Laborie Constraint Modelling Challenge 2005 1
Transcript
Constraint Modelling Challenge 2005
In conjunction with The Fifth Workshop onModelling and Solving Problems with Constraints
Held at IJCAI 2005, Edinburgh, Scotland, 31 July, 2005
Barbara M. Smith and Ian P. GentCork Constraint Computation Centre, University College Cork, Irelandand School of Computer Science, University of St Andrews, Scotland
1 IntroductionThe first Constraint Modelling Challenge was posed in May2005; we challenged constraint programmers to solve a dif-ficult optimization problem. There are a number of existingpapers on the problem that we chose, but it had not previouslybeen tackled using constraint programming, to our knowl-edge. In this paper, we attempt to present the thirteen sub-missions that we received, summarising the wide variety ofideas that the Challenge entrants used, and pointing out dif-ferences and similarities.
The statement of the problem follows:
A manufacturer has a number of orders from cus-tomers to satisfy; each order is for a number of dif-ferent products, and only one product can be madeat a time. Once a customer’s order is started (i.e.the first product in the order is being made) a stackis created for that customer. [Each customer placesexactly one order.] When all the products that acustomer requires have been made, the order is sentto the customer, so that the stack is closed. Be-cause of limited space in the production area, themaximum number of stacks that are in use simulta-neously, i.e. the number of customer orders that arein simultaneous production, should be minimized.More formally: we are given a Boolean matrix inwhich the columns correspond to the products andeach row corresponds to the order of a particularcustomer. The entrycij = 1 iff customer i hasordered some quantity of productj (the quantityordered is irrelevant). The objective is to find a per-mutation of the products such that the maximumnumber of open orders at any point in the sequenceis minimized: orderi is open at pointk in the pro-duction sequence if there is a product required inorder i that appears at or before positionk in thesequence and also a product that appears at or afterpositionk in the sequence.
The problem is one of a number of related sequencingproblems discussed by Fink & Voss[4]. Another problemfrom this paper appears in CSPLib as prob039 (the rehearsalproblem) and has previously been tackled using constraintprogramming. The rehearsal problem can be viewed as theopen stacks problem with a different objective (to minimize
the order spread, i.e. the total for all customers of the time thattheir order is in production). The different objective changesthe character of the problem completely, however, and ex-perience of solving the rehearsal problem cannot easily betransferred.
Fink and Voss cite several papers on the open stacks prob-lem, using a variety of Operations Research techniques. Lin-hares and Yanasse[8] list several equivalent problems, in-cluding graph path-width.
The Challenge instances were provided by the groups en-tering the Challenge, and seem to present different kinds ofdifficulty, depending on their source. Three of the instances(SP2, SP3 and SP4) have not yet been solved optimally.
In the following sections, we first describe a number of pre-processing steps that could be used to simplify the instances,and a number of lower bounds on the number of open stacksthat can be derived to assist in proving optimality. We thendescribe the different solution approaches that were tried inthe Challenge entries. We do not discuss the performance ofthe models here; detailed results can be found in the individ-ual submissions.
2 PreprocessingThere are a number of ways in which a given instance can bepreprocessed to make it simpler to solve. Many or all of thesehave previously appeared in the literature on the open stacksproblem, but here we mainly cite their use in the Challengesubmissions.
The simplest reduction is to remove orders that require noproducts and products that do not appear in any order, al-though the Challenge instances should have been constructedso that there are no such orders or products.
Let P be the set of products. LetC(p) be the set of orders(or customers) requiring a productp andC(P ′) be the set ofcustomers requiring a set of productsP ′ ⊂ P .
If the orders requiring productj, C(j), are a subset ofthose requiring productk, C(k), then productj can be re-moved from the problem; once an optimal sequence is found,productj can be inserted next to productk without affect-ing the maximum number of open stacks. Many Challengeentries remove dominated products in this way, e.g.[11; 13;14]. Garcia de la Banda and Stuckey[5] and Miller et al.prove the correctness of this reduction;[5; 11] credit it to Bec-ceneriet al. [2], who did not give a proof. Shaw and Laborie
Constraint Modelling Challenge 2005
1
[13] note that it is effective on many Challenge instances and,for one set of instances, removes on average half of the prod-ucts, while in[5] it is calculated that 16% of products areremoved across the whole set of instances. Beldiceanu andCarlsson[3] use a special case of this reduction in which twoproducts required for exactly the same orders are merged.
Szymanek and Hennessy[15] recognise that ifC(j) ⊆C(k), then it is safe to insist that productj is sequenced be-fore productk; however, they imposed this as a dominanceconstraint, and found that it did not reduce search.
If the set of productsP can be partitioned into two setsP ′
andP ′′, such thatC(P ′) ∩ C(P ′′) = ∅, i.e. there are no or-ders requiring products in bothP ′ andP ′′, then the subprob-lems defined byP ′ andP ′′ can be solved separately. Garciade la Banda & Stuckey[5] note that this simplification wasused in[19], and was useful for some of the Challenge in-stances. Simonis[14] found that the full decomposition wasonly useful for Challenge instances that were not difficult tosolve anyway, but that a special case ofsingleton productswas useful: a singleton product is required for only one or-der and that order requires no other products. Such a productcan be scheduled at the beginning of the production sequencewithout affecting the maximum number of open stacks.
3 Lower BoundsFinding a good lower bound on the maximum number ofopen stacks is useful in proving optimality: if a solution isfound whose value is equal to the lower bound, the solutionis known to be optimal and the search can terminate. This ap-plies even to incomplete search methods, which cannot proveoptimality in any other way, as well as to complete methodswhere it may be possible, though time-consuming, to show byexhaustive search that there is no solution with a better value.
The simplest lower bound is the maximum number of or-ders requiring a product. Other lower bounds are derived byconsidering theco-demand graphthat has a node for each ofthem orders and an edge between nodesi andj iff there is aproduct required by both orders. LetNi be the set of neigh-bours of nodei in this graph.
Miller [9] states and proves a number of theorems on lowerbounds based on the co-demand graph. The simplest is thatif δ is the smallest degree of any node, thenδ + 1 is a lowerbound on the maximum number of open stacks. Garcia dela Banda and Stuckey also use this bound, from[2] whereit is not proved. Miller gives similar results that improveslightly on this bound. Another result from[9] calculatesπij = |(Ni ∪ Nj) − i − j|, 1 ≤ i, j ≤ m, i 6= j, i.e. πij
is the number of orders that share a product with eitheri orj or both, excludingi andj themselves. Ifρ is the minimumvalue ofπij over all pairs of nodesi andj, thenρ + 1 is alower bound.
Garcia de la Banda and Stuckey[5] also use a number ofbounds from[2] based on derivingminorsby removing nodesor contracting edges in the co-demand graph.
Pesant[11] discusses the connection between the problemand a constrained graph colouring problem. A solution tothe open stacks problem withk stacks corresponds to ak-colouring of the co-demand graph, i.e. an allocation of one
of k colours to the vertices of the graph in such a way thatany pair of nodes linked by an edge have different colours.The reverse is not necessarily true; Pesant shows that addi-tional constraints are required to ensure that ak-colouringcan correspond to a product sequence with at mostk openstacks. Hence, the chromatic number of the graph (the min-imum number of colours) gives a lower bound on the min-imum number of open stacks[13]. Although solving thegraph colouring problem simply to compute a lower boundcould be expensive, the size of any clique in the graph alsogives a lower bound. Shaw and Laborie[13] use a greedyclique-finding algorithm to find a large clique in the graph;they found this bound useful in proving optimality. Pesant[11] notes that if the graph, after pre-processing to removedominated products, is a clique, then the minimum numberof stacks is the number of orders.
Simonis[14] finds lower bounds by solving small subprob-lems consisting of 3 to 5 products. The optimal solutions forthese subproblems can be easily found by considering all per-mutations of the products. However, only subsets of the firstfew products are considered, where the products are orderedby a weight function (also used to derive the initial static vari-able ordering).
Baptiste[1] finds lower bounds by solving a small MIPmodel for each position in the sequence. For each positionj, 1 ≤ j ≤ n, the division of products into before and af-ter j that minimizes the number of stacks that are open atjis found. The maximum of these optimal solutions gives alower bound on the value of the optimal solution to the origi-nal problem.
4 Symmetry BreakingAs in many sequencing problems, reversing an optimal se-quence of products gives another optimal sequence. Severalauthors add a constraint to break the symmetry. For instance,Shaw & Laborie[13] and Baptiste[1] choose one of the prod-ucts requiring in the largest number of orders and constrainthis product to appear in the first half of the production se-quence. Although using very different models, Simonis[14]and Beldiceanu & Carlsson[3] both impose a fixed order onthe first two variables selected, corresponding in both casesto two products.
5 Constraint Programming Models5.1 A Basic ModelPossibly the most obvious viewpoint on which to base a con-straint model has a variable for each product, whose valuesare the positions in the production sequence:pk = i iff prod-uct k is scheduled in positioni, 1 ≤ i, k ≤ n. There is anallDifferent constraint on these variables, and other variablesare introduced to allow the number of open stacks to be de-termined from the production sequence. Variablesfj andlj ,for 1 ≤ j ≤ m can be defined as the first and last positionsin the sequence where the stack for orderj is open. Thiscan be expressed as the constraintsfj = minpk|k ∈ Pjand lj = maxpk|k ∈ Pj, wherePj is the set of prod-ucts in orderj. A boolean variableoij indicates whetheror not the stack for orderj is open during theith time-slot
Constraint Modelling Challenge 2005
2
in the production sequence:oij = (fj ≤ i ∧ lj ≥ i),1 ≤ i ≤ n; 1 ≤ j ≤ m.
The number of open orders during theith time-slot is∑1≤j≤m oij . Finally, the objective is the maximum value
of this sum, over all values ofi, 1 ≤ i ≤ n.
5.2 A Dual Viewpoint
Since any production sequence can be seen as a permutationof the products, a dual viewpoint has variables representingthe positions in the production sequence, whose values arethe products, so thatsi = k iff product k is scheduled inpositioni, 1 ≤ i, k ≤ n.
These two sets of variables can be linked by channellingconstraints:si = k iff pk = i. Miller, Prosser & Unsworth[10] and Shaw & Laborie[13] use both sets of variables,linked by these channelling constraints; in[13], the inverseconstraint in ILOG Solver is used to implement the chan-nelling constraints efficiently.
The values assigned to thesi variables must be all differ-ent; the channelling constraints in fact obviate the need foran explicit allDifferent constraint on either set of variables toensure correct solutions[7], but specifying such a constraintand maintaining generalized arc consistency can increase do-main filtering. Shaw and Laborie[13] maintained GAC onthe allDifferent constraint for that reason.
Miller, Prosser and Unsworth[10] use a search strategythat assigns values to the variabless1, s2, ..., sn in that order,i.e. the sequence is built up chronologically. They use a num-ber of lower bounds, analogous to those derived in[9] thatthey use in preprocessing, but dependent on a partial assign-ment. They note, however, that the cost of calculating thesebounds dynamically is very high. A probably more useful dy-namic reduction is based on the observation that if the vari-abless1, ...si have been assigned, then any product that doesnot require a new stack can be scheduled next, without affect-ing whether or not the sequence can be completed optimally.Hence, all the products that are required only by customerswhose orders have already been started should be sequencednext, in any order.
Shaw and Laborie[13] also describe this reduction, but fi-nally used a different search strategy that they found morerobust. The products are partitioned into two subsets,P1 andP2, such thatP1 will be sequenced beforeP2. Each subsetforms a subproblem that can be solved independently of theother, and it is solved by recursively subdividing into two sub-sets. If at any point either subproblem is insoluble (becausethe current upper bound on the maximum number of openstacks cannot be achieved) the search can backtrack. Thesearch decisions assign a product to one subproblem or theother.
Hebrard, Hnich and Walsh[6] use a variant of the basicmodel with only the dual variables. They instead use special-purpose global constraints (one for each order) to link thevariablessi, 1 ≤ i ≤ n, defining the position of each productin the production sequence, and the variablesoij , 1 ≤ i ≤ n;1 ≤ j ≤ m, indicating whether or not the stack for orderjis open during theith time-slot in the production sequence.They describe the propagation of these global constraints.
They also use a heuristic to choose the variable (product)to occupy the position in the middle of the sequence; theirreasoning is that the maximum number of open stacks tendsto occur in the middle of the sequence, and hence that theproducts sequenced in the middle are the most important. Foreach product, they consider placing that product in the middleof the sequence (in positionm/2) and finding the minimumnumber of open stacks at that point. To do this, they parti-tion the other products into two sets, such that the number oforders required by a product in both sets is minimized. Anyorder that is required both by a product in the first half of thesequence and by a product in the second half of the sequencemust have an open stack at positionm/2. They find the ‘Min-Intersect’ partition of the remaining products for each prod-uct j, by solving a subsidiary constraint optimization prob-lem. These solutions are then used as a heuristic to guide thesearch. The product which will give the minimum numberof open stacks is positioned atm2; this minimum number ofopen stacks atm/2 is also a lower bound on the optimal so-lution that can be found as a result of this (or any subsequent)choice of ‘middle’ product. The bound is further tightenedby constraining the remaining products to be before or afterm/2 according to the optimal partition, and finding the opti-mal sequence under those constraints. These bounds are thenpassed to the complete method.
5.3 Permuting the CustomersRather than finding a permutation of the products, as in thebasic model, Wilson and Petrie[17] solve the open stacksproblem by finding an optimal permutation of the orders (cus-tomers). This idea was previously proposed by Yanasse[18].If we consider the customer whose order is completed first,and the point in the sequence of products when that happens,every product that customer requires must be made beforethat point in the sequence. Further, there is no advantage toscheduling any other product before that point. So the max-imum number of open stacks occurring while the first cus-tomer’s stack is open occurs when the last product for thecustomer is made, and is equal to the number of products thecustomer requires. Reordering the number of products up tothis point in the sequence makes no difference to the maxi-mum number of open stacks in the whole sequence.
This idea can be extended to the remaining customers. Apermutation of the customers can be defined from a permuta-tion of the products, by considering the points in the sequenceat which the last product for each customer is made, breakingties for instance by the initial ordering of the customers. Wil-son and Petrie also give a function mapping a permutation ofthe customers to a permutation of the products, and show thatthe maximum number of open stacks in this sequence is noworse than in any other product sequence corresponding tothe same permutation of the customers. Hence, it is sufficientto consider permutations of the customers. Such a permuta-tion defines thecustomer elimination sequence, i.e. it definesthe order in which the stacks are closed.
(This idea is related to the dynamic reduction used byMiller et al. [10]: as the sequence of products is built up, anyproduct that does not require opening a stack can be immedi-ately added to the sequence. Hence, the next real decision is
Constraint Modelling Challenge 2005
3
effectively which stack to open next.)Their CP model hasm variables,r1, ..., rm, constrained to
be all different: r1 is the customer whose order is fulfilledfirst, and so on. Constraints relate the successive neighbour-hoods of customers in the co-demand graph to the sets of openstacks when customerr1 is eliminated, when customerr2 iseliminated and so on. (When customerr1 is eliminated, thereis a stack open for each of its neighbours.) From the setsof open stacks, the maximum number of open stacks can befound.
Wilson and Petrie eliminate some equivalent sequences ofcustomers by using the idea of dominated customers. At anypoint in the search, adding a customeri to the sequence asthe next customer to be eliminated entails opening stacks forall the remaining customers who require products that are re-quired by customeri, i.e. for all customers inNi, the neigh-bourhood ofi in the co-demand graph, who are not in theneighbourhood of any customer already sequenced. Cus-tomer i dominates customeri′ if the set of new stacks re-sulting from addingi to the sequence is a strict subset of theset of new stacks resulting from addingi′, or the sets of newstacks are the same andi < i′. This also gives a variable or-dering heuristic: choose the customer which will result in thesmallest number of new open stacks.
They also discuss branching decisions based on whethertwo customers overlap, or if not, in which order they appear,and discuss implied constraints that can be derived.
Permuting the customers rather than the products clearlyreduces problem size when the number of customers is lessthan the number of products; Wilson and Petrie also foundthat it gives good results generally.
5.4 Multiple ViewpointsSzymanek and Hennessy[15] use a number of different view-points, including that of the basic model given earlier, linkedby channelling constraints. The principal search variables intheir model are boolean variablescpkl, representing the rel-ative position of the stacks for customers (orders)k and l;cpkl = 0 iff the stack for orderk is closed before the stackfor orderl is opened. For any two ordersk, l that have a prod-uct in common,cpkl = cplk = 1. The importance of thesevariables is that ifcpkl = 0, then ordersk and l can poten-tially share a stack location.
Their model also views the problem as one of finding apermutation of the orders. Since the stacks for two or moreorders may be started at the same time, if they require thesame product, two different permutations of the orders maycorrespond to the same permutations of the products. Domi-nance rules are introduced to distinguish some of these cases;for instance, ifPj′ ⊂ Pj , then orderj is considered to appearbeforej′, even if the first product in the sequence required byeither of them is required by both. Szymanek and Hennessygive a global constraint that is used to link thecpkl variables,the permutation of the orders, and the objective. The searchassigns thecpkl variables first, then thepj variables of thebasic model (and then variablesfj andlj of the basic model;but since the sequence has been fixed by the previous assign-ments, there are presumably no decisions to be made at thisstage).
Although Szymanek and Hennessy have variables repre-senting the sequence of customers as one viewpoint in theirmodel, they do not construct the product sequence from thecustomer sequence, as Wilson and Petrie do, and so do notappear to get the same benefits.
5.5 A Scheduling ModelBeldiceanu and Carlsson[3] use the basic model, but vieweach order as a task requiring a resource (its stack) and usethecumulativeconstraint provided in SICStus Prolog to linkthe sets of variablessj , fj , 1 ≤ j ≤ m to the objective, whichon this view is the maximum number of resources in simulta-neous use.
They use a static variable ordering, arranging the productvariables in descending order of the number of customers re-quiring each product. The value ordering chooses values asclose to the middle of the sequence as possible; hence, thesearch strategy tries to build up the sequence from the middleto the ends, and puts the products most in demand in the mid-dle of the sequence. Beldiceanu and Carlsson comment thatthe weakness of the model is the poor propagation of the maxamd min constraints, defining the variablesfj and lj . Theysuggest that this could be improved by developing a globalconstraint, with appropriate filtering algorithm, to constrain avariable to be the maximum or minimum of a set of variablesthat are all different.
Shaw and Laborie[13] also use a scheduling viewpoint,as well as the variables of the basic model and their duals.They define variables representing the start and end of eachactivity (order stack) and relate these to the variablesfj , lj .Constraint-based scheduling algorithms are used to reasonabout the starts and ends of the activities and the resourceusage, and these inferences can propagate to the other vari-ables.
The scheduling viewpoint leads to some implied con-straints that can be expressed in terms of the start and endvariables. Beldiceanu and Carlsson[3] define thedurationofthe stack for orderj, as the number of products it requires;this then gives a constraint on the start and end times of theactivity. An equivalent constraint onfj andlj is given by[13;14]: lj ≥ fj + |Pj | − 1, 1 ≤ j ≤ n. Simonis[14] extendsthis to subsets ofPj .
Shaw and Laborie give further constraints of this kind. Iftwo ordersj andk share at least one product (Pj ∩ Pk 6= ∅),then the corresponding activities must overlap for a durationat least|Pj ∩Pk|. Further, ifPj ⊂ Pk, then the activity corre-sponding to orderj can start no later and finish no earlier thanthe activity corresponding to orderk. These constraints couldbe expressed either in terms of the start and finish variablesin the scheduling model, or in terms of thefj , fk, lj , lk in thebasic model.
5.6 A Graph Colouring ModelAs described earlier, the open stacks problem can be viewedas a constrainted graph colouring problem, and this can beuseful in deriving lower bounds on the optimal solution.Shaw and Laborie[13] include a graph colouring viewpointin their model in order to use this perspective on the prob-lems dynamically during the search. The aim is to colour
Constraint Modelling Challenge 2005
4
the co-demand graph so that if two customers both have theirstacks open at some point during the product sequence, theirnodes in the graph are assigned different colours. Clearly,if two nodes are neighbours in the graph, they must be as-signed different colours (there is at least one product that theyboth require). Shaw and Laborie introduce new variables,hj , 1 ≤ j ≤ m, wherehj represents the colour assignedto node (customer)j. If nodesj, j′ are neighbours in the co-demand graph, the constrainthj 6= hj′ is added at the start.Otherwise, the colour variables are related to the other vari-ables of the problems by the constraints: iffj ≤ lj′∧fj′ ≤ ljthenhj 6= hj′ . The colours are interchangeable, and to reducethis symmetry, the large clique in the co-demand graph that isfound during pre-processing, in order to provide a bound onthe optimal value, is coloured at the start.
(Although using a very different approach, Truchet, Bour-don and Codognet[16], as described below, consider the pos-sibility that two customers can possibly share the same stack,in a similar manner.)
Whereas Shaw and Laborie use the graph colouring per-spective in conjunction with other viewpoints, Pesant[11]bases his model entirely on solving the constrained graphcolouring problem. He finds initial upper and lower boundson the objective value (the upper bound being one less thanthe number of customers, since it is easy to detect if the co-demand graph is a clique, and otherwise, the number of stacksrequired is less than the number of customers). He does abinary search to find the smallest value ofk for which ak-colouring that can correspond to an product sequence usingkstacks exists.
As in [13], the colour symmetries are partly broken by pre-colouring a large clique in the co-demand graph. Furthersymmetry-breaking constraints are also added, by orderingthe sets of nodes assigned to each of the remaining colours.
Having found ak-colouring of the graph, it has to be con-verted, if possible, into a feasible product sequence. For eachcolouri, Pesant first searches for a sequence of the customersin the colour classCi that have been assigned to that colour;this is the order in which these customers will use their com-mon stack location. This order in turn constrains the productsequence. The variablespj , 1 ≤ j ≤ n of the basic model areused, together with an allDifferent constraint on these vari-ables. The search backtracks if it proves impossible to find aproduct sequence.
Unary constraints can be added on the variablespj corre-sponding to the products required by the customer currentlybeing considered that uses stack locationi. Since none of thecustomers assigned to colouri can have any products in com-mon, the number of products required by the customers usingstack locationi previously, and the number required by thecustomers using this location subsequently, give lower andupper bounds on the position in the product sequence of anyproduct required by this customer.
Pesant comments that the expertise that has been developedin solving graph colouring problems makes this a potentiallyfruitful approach to solving the open stacks problem.
5.7 Putting the products in order
Simonis [14] develops a model in which at any point dur-ing the search, the partial solution already built up indicatesthe order in which the products already considered will besequenced but not their positions in the sequence. This isimplemented by a real-valued variableyi for each producti;a complete solution can be translated into a production se-quence by arranging the products in ascending order of thevalues assigned to the corresponding variables. The domainsof the variables are an arbitrary real interval, with two sen-tinel values, saystart andend, marking the start and end ofthe interval. Once values in this interval, sayv1, v2, ..., vk
with v1 < v2 < ... < vk have been assigned to a subset of thevariables, the next variable considered is assigned a value inone of the sub-intervals defined by this assignment, i.e. in ei-ther(start, v1) or (v1, v2) or ... or(vk, end) Hence, the newassignment represents a decision as to how the correspondingproduct should be placed in the sequence in relation to thosealready placed.
Simonis notes that the advantage of this model, in compari-son with a model in which the variables represent the positionin the sequence of each product, or the product to be placedin each position in the sequence, is that the branching factorof the search tree is small at the top of the tree. The first twovariables are assigned arbitrarily, and the third has three pos-sible choices. Eventually, the final product can go in one ofn + 1 subintervals. In contrast, if the variables correspond tothe positions in the sequence, for the first variable assignedthere aren choices,n− 1 choices for the second variable andso on.
The products are initially ordered by a weight function,where a product has a high weight if it is required by manycustomers, each of whom requires few other products. Simo-nis also uses an expensive shaving technique during searchthat combines a dynamic variable and value ordering heuristicwith domain filtering. At each choice point, for every unas-signed product variable and every sub-interval that it couldbe placed in, the increase in the cost function that wouldresult from placing the product in that sub-interval is com-puted. This may remove some inconsistent values; thereafterthe variable that causes the greatest increase in cost and thevalue that causes the smallest increase in cost is selected.
Simonis also uses a partial search (usingcredit-basedsearch) to find good solutions quickly, combined with thecomplete search.
The values assigned to theyi variables are hard to interpretin this model; we might think of them as something like atime. Variablesf ′j , l
′j and so on are defined in a similar way
to the basic model; for instance,f ′j = minyk|k ∈ Pj, andhence the objective can be defined using similar constraints.
It seems that this model would be similar to using the basicmodel with a search strategy that chooses the relative orderof the products, rather than their positions in the sequence,by adding inequality constraints between them, so that at achoice point during search, the choice might be betweenp1 <p2 andp1 > p2. However, Simonis considered this searchstrategy and concluded that it did not allow the constraints topropagate well.
Constraint Modelling Challenge 2005
5
6 A Mixed Integer Programming ApproachBaptiste[1] gives a MIP formulation for the problem that issimilar to the basic CP model given earlier, but uses 0/1 ratherthan integer variables. So instead ofpk = i iff product k isscheduled in positioni, he hasxki = 1 iff productk is sched-uled in positioni. The constraints
∑nk=0 xki = 1, 1 ≤ i ≤ n
and∑n
i=0 xki = 1, 1 ≤ k ≤ n ensure that exactly one prod-uct is scheduled in any position, and every product is sched-uled somewhere; the latter constraint replaces the allDifferentconstraint.
For every orderj and sequence positioni, three 0/1 vari-ables are defined. Instead of variablesfj andlj , variablesbij ,aij are defined such thatbij = 1 iff order j starts productionin position i or before, andaij = 1 iff order j ends pro-duction at positioni or after. The constraints defining thesevariables are:bi+1,j ≥ bij andaij ≤ ai−1,j . With these vari-ables, the variablesoij of the basic model can be defined byoij = bij + aij − 1. These variables are linked to the de-cision variablesxki: for any orderk and productj such thatcjk = 1, xki ≤ oij , since if productk is scheduled in positioni and orderj requires that product, then the stack for orderjis open at positioni. Hence, the objective can be defined asbefore.
The formulation allows cuts analogous to the implied con-straints derived from the scheduling model discussed earlier;for instance, if two ordersj andj′ are such thatPj′ ⊆ Pj ,i.e. all products required byj′ are also required byj, thenbij ≤ bij′ andaij ≥ aij′ , for all i, 1 ≤ i ≤ n.
Baptiste comments that the weakness of the MIP modelis that many symmetries (apart from the obvious reversal ofthe sequence) cannot easily be broken. He tried a secondaryobjective that found a solution with the minimum number ofstacks that gave the lexicographically smallest sequence ofproducts, to break other symmetries that arise from permutingproducts without changing the number of open stacks, but thiswas not successful.
7 Local SearchTwo of the submissions use local search to solve the prob-lems; a few other cases use local search in conjunction withcomplete search.
Prestwich[12] uses a similar model to Baptiste’s MIPmodel, which can similarly be seen as a 0/1 version of the ba-sic CP model described earlier. He proposes to increase thesolution density of the model in order to improve the perfor-mance of local search, by adding “pseudo-solutions” in sucha way that any pseudo-solution can be transformed into a truesolution that is at least as good.
The pseudo-solutions are obtained by relaxing the con-straints
∑nk=0 xki = 1 and
∑ni=0 xki = 1 to
∑ni=0 xki ≥ 1,
for 1 ≤ k ≤ n, i.e. each product can appear more than oncein the sequence, and the number of product assigned to a po-sition in the sequence can be 0, 1 or more. An alternativerelaxation also has the constraints
∑nk=0 xki ≥ 1 i.e. every
position in the sequence must have at least one product. Prest-wich shows that a solution satisfying these constraints can beconverted into a dominating solution representing a permuta-tion of the products, and that there can be super-exponentially
more solutions satisfying either set of relaxed constraints thanthere are to the original model. A local search algorithmrelated to WalkSAT is used with all three models, and therelaxed models are shown to be much faster than the origi-nal model on an artificial instance for which optimal pseudo-solutions exist. On Challenge instances, the second relaxationis found to give best results.
Truchet, Bourdon and Codognet[16] use an idea reminis-cent of one of the viewpoints in[15]: to reduce the maxi-mum number of open stacks, it is important to ensure that asfar as possible, two orders that have no products in commoncan share a stacking space. (Of course, two orders that dohave a product in common must both have their stacks openwhen that product is made and so cannot share a stackingspace.) They define a relationSep(j, j′) = (Pj ∩ Pj′ = ∅):Sep(j, j′) is true for two productsj, j′ if they can potentiallybe separated i.e. can share a stacking space. They define asurrogate for the objective,g, defined to be the number ofpairs of orders,j, j′ such that (in terms of the basic model)fj > lj′ ∨ fj′ > lj , i.e. the stack for orderj opens afterthe stack for orderj′ closes, or v.v. They show that find-ing a permutation that maximizesg is equivalent to findinga permutation that minimizes the maximum number of openstacks.
The advantage of defining the new objective function isthat g has a greater range of values than the original objec-tive and is more suitable for use as an error or cost functionin local search.
Truchetet al. use a local search method (Adaptive Searchimplemented for permutation problems) to find improvedconfigurations by identifying a variable that can be consid-ered (partly) responsible for the poor quality of the currentconfiguration, and trying another value in this variable’s do-main.
Shaw and Laborie[13] combine the constraint model de-scribed earlier with local search, although only for the largerChallenge instances. Whenever a new (and therefore better)solution is found, Large Neighbourhood Search is used to tryto improve it further. A sub-sequence of the product sequenceis selected at random and LNS attempts to reassign the prod-ucts in these positions using a smaller number of open stacks.
8 A Model Checking ApproachMiller [9] solves the open stacks problem by viewing a prod-uct sequence with at mostM open stacks as a violation of asafety property; if such a violation is found, model checkingprovides a counter-example that can be converted into a solu-tion to the open stacks problem with at mostM open stacks.
Because proving that no solution exists for a givenM isvery difficult or in some cases impossible with this approach,Miller derives a number of lower bounds on the value of theoptimal solution; if a solution can be found with value equalto the lower bound, then this is sufficient proof that no bettersolution exists. These bounds are also used by Miller, Prosserand Unsworth[10].
Miller also gives a heuristic method for constructing solu-tions, which she reports often find the optimal solutions im-mediately, and otherwise gives a good starting point. This
Constraint Modelling Challenge 2005
6
is based on constructing primarily a sequence ofcustomersfrom which the product sequence can be derived, in such away as to keep the number of open stacks low. This approachis reminiscent of the complete method used by Wilson andPetrie[17].
Miller comments that an advantage of the model checkingsystem used (SPIN) is the backtracking that it provides. Inthis case, if at some point during search, the firsti products inthe sequence have been chosen, and more thanM stacks havebeen opened, the search will immediately backtrack. Fur-ther, if this sub-sequence used at mostM open stacks, butthe search has previously extended a sub-sequence consistingof thesei products in a different order, then the search mustpreviously have failed because at some later point it was im-possible to use no more thanM stacks. Hence, the currentsub-sequence should again fail. This is recognised by SPIN,because the state of the system at this point is identical to thepreviously visited state. The notion of identical states appearsin a different guise in the approach described in the next sec-tion.
9 A Dynamic Programming ApproachGarcia de la Banda and Stuckey[5] use a dynamic program-ming formulation to solve the open stacks problem. Theypoint out that if a subsetP ′ of the products has been sched-uled at the beginning of the sequence, with the last product inthis sub-sequnce beingp, the customers that have open stacksat this point are those who ordered productp, as well as thosewho ordered any other product inp as well as any product thathas not been sequenced. This does not depend on the order inwhich the previous products,P ′−p, are scheduled, nor onthe order of the remaining products,P − P ′.
If the minimum number of stacks required to schedule theset of productsS, given that the products inP − S havealready been sequenced, isstacksP (S) and the set of cus-tomers with open stacks at that point isA(p, P − S − p),wherep is the last product sequenced inP − S, Garcia dela Banda & Stuckey give the basic dynamic programming re-cursion:
stacksP (S) = minp∈S
maxA(p, S−p), stacksP (S−p)
They suggest that this is potentially a much more efficientapproach than, say, the basic CP model given earlier, becauserather than implicitly considering every permutation of theproducts, it is only necessary to consider the subsets ofP .
They use a number of lower bounds on the optimal value,some of which are discussed earlier. They find an optimalsolution by either trying every possible value from the lowerto the upper bound, or by doing a binary search in this range(as does Pesant[11]).
They comment that although their approach does not useconstraint programming, it is equivalent to a constraint pro-gramming approach in which states visited are memoized.
10 Summary and ConclusionsA number of key ideas emerge from the the approachesadopted in the various submissions to the Challenge. We list
here some of the ideas that appear in different submissions,in various guises:
• Instances can often be reduced by preprocessing them, toremove products or customers that cannot affect the so-lution. Lower bounds on the optimal solution can also becalculated in various ways ahead of search; this appearsto be crucial in proving optimality for many instances.
• Although the problem is ostensibly one of finding a per-mutation of the products, in fact, focussing on the se-quence of the customers can be a more fruitful way toconsider the problem. This has been done either byspecifically sequencing the customers, or by recognisingthat while sequencing the products, the real decisions areonly those that involve opening a new stack.
• If building up the product sequence chronologically, re-arranging the products before timep cannot affect theoptimal arrangement of the products afterp, and v.v.This observation has been recognised in various ways,from a dynamic programming approach, to various waysof splitting the sequence and dealing with the two partsseparately.
• Two orders can share the same stack location only if theyhave no products in common; the products that they eachrequire must also be separated in the product sequence.Since it is only by sharing stack locations that the num-ber of open stacks can be reduced, some Challenge sub-missions have focussed on orders that can potentially beseparated in this way as the key to minimizing the num-ber of open stacks.
The Challenge entrants had only limited time (around sixweeks) to devise models to solve the open stacks problem.Given that, we were gratified to receive so many excellententries. The variety of approaches and the number of interest-ing ideas in the submissions is impressive. The Challenge hasconclusively shown that constraint programming is a fruitfulapproach to solving the open stacks problem. We plan to sub-mit the problem, with the Challenge instances, to CSPLib andhope to see further development of the models described here.
11 Thanks, and Advice to Future OrganisersWe especially thank Patrick Prosser for proposing the Mod-elling Challenge as a part of the 2005 Workshop. It was alsohis idea that it be a challenge, not a competition or evaluation.We think this is very important: we do not feel that constraintprogramming is at a point where winners can be determinedpurely by cpu time given the large variety of tools and tech-niques used.
We thank the organising and programme committees of theIJCAI 05 Workshop on Modelling and Solving Problems withConstraints, and most especially Zeynep Kiziltan for her ex-tensive help. We thank Toby Walsh for agreeing to enter theresults of the Challenge into CSPLib. For other help in var-ious ways we would like to thank Ian Miguel, Sylvain Soli-man, and members of the CP Pod research group. We wouldlike to thank the UK’s Symmetry and Search network, whichsponsored the prize for best paper.
Constraint Modelling Challenge 2005
7
Of course we very much thank all the entrants to the Chal-lenge, and especially those who also submitted instances dur-ing the first phase.
We hope that modelling challenges can be run in the future,perhaps annually. We do not think it appropriate to keep thechallenge in our hands, so we thought it might be useful tooffer advice to future organisers.
The first point is to emphasise that we always intended thechallenge to allow non-constraint based approaches, and anumber of such entries appeared. We think this was very ben-eficial to the Challenge and for comparing constraints withother approaches, and it should be preserved. The name ofthe Challenge (i.e.Constraintmodelling) worried some en-trants who checked with us before submitting, but it is hard tosee how to rename the Challenge which is about constraintsand comparison with other approaches.
The second is that there are certain points in the pro-cess that we perhaps needed to put more work into. Firstamong those would have been the selection and distributionof the Challenge instances. Some work double checking themwould have been useful, and also solving them with a simplesolver to filter out very easy ones. The obvious reason we didnot do this is pressure of time.
A third point is that the two phase approach to the Chal-lenge seemed to work well. In the first phase entrants wereable to submit their own instances for use in the second phase.In fact we used all instances that were submitted (barring oneomitted by error), and they were pleasingly diverse. We didn’tconcern ourselves if instances were hand crafted to be easyfor a particular solver and hard for others, since all other en-trants had the chance to construct instances like this too.1
We do hope that this report is useful to others interested inthis problem, and again hope this will be repeated in futureyears: but it does take some time to complete, so be warned!
References[1] P. Baptiste. Simple MIP Formulations to Minimize the
Maximum Number of Open Stacks. IJCAI05 ConstraintModelling Challenge entry.
[2] J. C. Becceneri, H. H. Yanasse, and N. Y. Soma. Amethod for solving the minimization of the maximumnumber of open stacks problem within a cutting process.Comput. Oper. Res., 31(14):2315–2332, 2004.
[3] N. Beldiceanu and M. Carlsson. AcumulativeModelfor a Pattern Sequencing Problem. IJCAI05 ConstraintModelling Challenge entry.
[4] A. Fink and S. Voss. Applications of modern heuristicsearch methods to pattern sequencing problems .Com-puters & Operations Research, 26:17–34, 1999.
[5] M. Garcia de la Banda and P. J. Stuckey. Dynamic Pro-gramming to Minimize the Maximum Number of OpenStacks. IJCAI05 Constraint Modelling Challenge entry.
1However, note that we required source code to be entered un-der a promise of confidentiality, meaning that we could if necessarycheck for entries which had a database of known instances with so-lutions, which we would have been unhappy with.
[6] E. Hebrard, B. Hnich, and T. Walsh. Partition with Min-imal Intersection. IJCAI05 Constraint Modelling Chal-lenge entry.
[7] B. Hnich, B. M. Smith, and T. Walsh. Dual Models ofPermutation and Injection Problems.JAIR, 21:357–391,2004.
[8] A. Linhares and H. H. Yanasse. Connections betweencutting-pattern sequencing, vlsi design, and flexible ma-chines.Comput. Oper. Res., 29(12):1759–1772, 2002.
[9] A. Miller. Improved lower bounds for solving the min-imal open stacks problem. IJCAI05 Constraint Mod-elling Challenge entry.
[10] A. Miller, P. Prosser, and C. Unsworth. A ConstraintModel and a Reduction Operator for the MinimisingOpen Stacks Problem. IJCAI05 Constraint ModellingChallenge entry.
[11] G. Pesant. Trying Hard to Solve the SimultaneouslyOpen Stacks Problem with CP. IJCAI05 ConstraintModelling Challenge entry.
[12] S. Prestwich. Open Stack Minimisation by Local Searchand Reverse Dominance Reasoning. IJCAI05 Con-straint Modelling Challenge entry.
[13] P. Shaw and P. Laborie. A Constraint Programming Ap-proach to the Min-Stack Problem. IJCAI05 ConstraintModelling Challenge entry.
[15] R. Szymanek and M. Hennessy. Modelling Challenge– Open Stack Problem. IJCAI05 Constraint ModellingChallenge entry.
[16] C. Truchet, J. Bourdon, and P. Codognet. Tearing cus-tomers apart for solving PSP-SOS. IJCAI05 ConstraintModelling Challenge entry.
[17] N. Wilson and K. Petrie. Using Customer EliminationOrderings to Minimise the Maximum Number of OpenStacks. IJCAI05 Constraint Modelling Challenge entry.
[18] H. H. Yanasse. On a pattern sequencing problem to min-imize the maximum number of open stacks.EuropeanJournal of Operational Research, 100:454–463, 1997.
[19] B. J. Yuen and K. V. Richardson. Establishing theoptimality of sequencing heuristics for cutting stockproblems.European Journal of Operational Research,84:590–598, 1995.
Constraint Modelling Challenge 2005
8
Simple MIP Formulations to Minimize the Maximum Number of Open Stacks
AbstractWe consider a manufacturing scheduling problemin which the sequence of products to be manufac-tured has to be determined so as to minimize thenumber of customer orders that have been startedand are waiting to be completed. We describe astraightforward local search method together witha powerful lower bound based on a MIP formula-tion. Finally we introduce another MIP with spe-cific cuts that allows us to optimally solve mediumsize instances. Experimental results are reported.
1 IntroductionWe consider the manufacturing scheduling problem as de-scribed in the 2005 Constraint Modeling Challenge web-pages.
“A manufacturer has a number of orders from customersto satisfy; each order is for a number of different products,and only one product can be made at a time. Once a cus-tomer’s order is started (i.e., the first product in the order hasbeen made) a stack is created for that customer. When all theproducts that a customer requires have been made, the orderis sent to the customer, so that the stack is closed. Because oflimited space in the production area, the number of stacks thatare in use simultaneously,i.e., the number of customer ordersthat are in simultaneous production, should be minimized.”
We use the following notation. The Boolean matrixK isused to identify the products required by customers. The en-try Kcp is 1 if and only if customerc requires productp. mandn respectively denote the total number of customers andthe total number of products. Customers are numbered from0 to m − 1 and products are numbered from0 to n − 1. Wesay that a customerc starts (respectively ends) att if and onlyif the first (resp. last) product required byc is sequenced inpositiont.
We refer to the web pages of the challengewww.dcs.st-and.ac.uk/ ipg/challenge/index.htmlfor a complete description of the problem and for a briefbibliography.
2 Lower BoundThe most basic lower bound is the maximum over all productsp of
∑m−1c=0 Kcp. To improve this bound, we introducelb(t) a
MIP based bound associated tot ∈ 0, ..., n− 1. Our lowerbound is then the maximum over allt of lb(t).
Informally speakinglb(t) corresponds to the problem ofdeciding which products are sequenced before/after positiont in the sequence. Indeed, a productp is either sequencedbefore or after positiont. Let thenxp ∈ 0, 1 denote thebinary variable corresponding to this alternative (xp = 1 ifand only ifp is sequenced strictly beforet, xp = 0 otherwise).As exactlyt products must be sequenced in position0, ..., t−1, we have
∑np=0 xp = t.
Now let us introduce, for each customerc ∈ 0, ...,m−1,three binary variablesbc, ac, ic ∈ 0, 1.• bc equals one if and only if customerc starts beforet.
• ac equals one if and only if customerc ends after or att.
• ic equals one if and only if customerc starts beforet andends after or att (“ i” stands for In process).
We can link these 3 variables as follows:ic ≥ bc + ac − 1since (1)ic equals 1 if the customer starts before and endsafter t and (2) a customer must start beforet or end aftert hencebc + ac is never 0 in a solution. Our objective isto minimize the number of customers for whichic = 1 so,the objective of the MIP is exactly
∑m−1c=0 ic. It now re-
mains to link the customer variables to the product variables:∀c ∈ 0, ...,m − 1, (
∑n−1p=0 Kcp)bc ≥
∑n−1p=0 Kcpxp and
(∑n−1
p=0 Kcp)ac ≥∑n−1
p=0 Kcp(1 − xp). In the above equa-
tion, (∑n−1
p=0 Kcp) plays the role of a big “M ” (this is thesmallest possible one). Altogether, this leads to:
minm−1∑c=0
ic
∑n−1p=0 xp = t
∀c ∈ 0, ...,m− 1, ic ≥ bc + ac − 1∀c ∈ 0, ...,m− 1, (
Computinglb should be easy since the MIP containsO(n +m) variables andO(n+m) constraints. Experimental resultsshow that this is true for most of the instances.
Constraint Modelling Challenge 2005
9
3 Upper Bound
We use a very simple local search method to compute an up-per bound of the optimal solution. As this procedure is notthe major contribution of the paper, we mention it briefly.
Through out the local search, our criterion is a lexicograph-ical combination of the number of open stacks and of the sumof the staring times minus the completion times. The sec-ondary criterion is extremely useful to guide the search to-wards promising regions. The local search is based on a ran-dom insertion “move” (remove a product in the sequence andinsert it somewhere else). Such a move is always acceptedif the objective function is improved. Based on a probabil-ity that decreases over time (like in simulated annealing), themove is also accepted if it does not deteriorate the objectivefunction too much. The total number of iterations is exactly50000.
4 MIP Formulation
We first describe a basic model and we then introduce somecuts to improve the search for the solution.
4.1 Basic Model
We use the following variables:
• Product Assignment.For each productp and each se-quence positiont (0 ≤ t < n), xpt is the binary assign-ment variable that equals 1 if and only ifp is sequencedin positiont.
• Customer Variables. For each customerc and eachsequence positiont, we have three binary variablessct, ect, ict ∈ 0, 1 that equal 1 if and only if the cus-tomer respectively starts before or att, ends after or att,or is in process att.
• Stack Variable.The variableσ ∈ 0,m represents thenumber of stacks simultaneously open in the solution.
The objective is to minimizeσ. We now describe the con-straints that ensure we reach an optimal solution.
• One product at a time. For all sequence positiont ∈ 0, ..., n − 1, we have exactly one product,i.e.,∑n−1
p=0 xpt = 1.
• Products are sequenced.All products are sequencesomewhere,i.e., ∀p ∈ 0, ..., n− 1,
∑t xpt = 1.
• Bounding the number of open customers.At any posi-tion t, the number of customers in process is not greaterthanσ, i.e., ∀t ∈ 0, ..., n− 1,
∑m−1c=0 ict ≤ σ
• Start and end Variables.Sincesct equals 1 iff,c startsbefore or att, we have∀c ∈ 0, ...,m − 1,∀t ∈0, ..., n − 1, sct ≥ sc t−1. For the same reason,∀c ∈ 0, ...,m − 1,∀t ∈ 0, ..., n − 1, ect ≤ ec t−1.Finally, ict = sct + ect − 1.
• Linking customers and products.For any customerc andproductp such thatKcp = 1, we havexpt ≤ ict.
4.2 Some nice properties of the MIPOur MIP containsO(n(m + n)) binary variables andO(n(m + n)) constraints. We believe this is rather low andcan lead to small search trees. The nice property of the MIP isthat when the sequence of products is known (i.e., whenxpt
variables are fixed), the remaining problem does not requireany branching so, the last line of the MIP can be replaced by
Interestingly, we could also do the opposite. Indeed, whensct, ect, ict values are fixed, it is easy to see that the remainingproblem is a pure assignment problem. So it does not requireany branching. Hence, we could alternatively replacexpt ∈0, 1 by xpt ∈ [0,1].
In practice, this does not prove to be very efficient and it ismuch better to state to the MIP that all variables are indeedbinary. However, this shows that our formulation is relativelytight.
4.3 CutsFirst, we try to “tighten” e and s variables. Consider acustomerc. It requiresq =
∑n−1p=0 Kcp products hence
ec q−1 ≥ 1 and∀t ≥ q, ect ≥ 1− sc t−q For the same reason,sc n−q ≥ 1 and∀t < n− q, sct ≥ 1− ec t+q.
Second, we add a redundant constraints on “aggregated”customers. Consider two customersc and c′ and letq de-note the number of products required byc or by c′. Thereareq products sequenced before the end ofc or of c′ hence,ec q−1 + ec′ q−1 ≥ 1 and for the same reason,sc n−q +sc′ n−q ≥ 1.
Third, we add a constraint of “included” customers. Con-sider two customersc andc′ such that all products required byc′ are also required byc. Then, for anyt, we havesct ≥ sc′t
andect ≥ ec′t.Finally, we add a simple constraint to break symmetry. To
do so, we chose a product required by a maximum number ofcustomers and we constrain it to be sequenced in the first halfof the sequence.
4.4 Things that do not work!We have tried to use the lower and upper bounds computed inSections 2 and 3 to tightenσ. The outcome of the resulting
Constraint Modelling Challenge 2005
10
MIP is either infeasibility (in this case the initial upper boundis optimal) or an optimal solution. Surprisingly, the behaviorof this new MIP is much worse than the initial one.
We have also tried to replace the constraints∀c ∈0, ...,m − 1,∀p s.t., Kcp = 1,∀t ∈ 0, ..., n −1, xpt ≤ ict by ∀c ∈ 0, ...,m − 1,∀t ∈ 0, ..., n −1,
∑p:Kcp=1 xpt ≤ ict. This formulation more compact and
should be more efficient. Preliminary tests have shown that itincreases the average number of nodes by more than 50!
Finally, we have implemented a rather complex MIP for-mulation to look for an optimal solution that lexicographi-cally minimize the sequence of products. This MIP is alsousing a quadratic number of variables and constraints and al-lows to break many symmetries (much more than in the initialMIP) because of the secondary objective function. Unfortu-nately, this does not work either.
4.5 Experimental ResultsAll experiments were run on PC Dell Latitude D600 runningXP. Cplex 9.0 has been used to solve the MIPs. We have fol-lowed the guidelines of the Challenge to report experiments.The values required in the tables are well suited to CP ap-proaches but are less relevant to MIP approaches. Indeed,it is impossible to distinguish the time spent to find an opti-mal solution from the time spent for the proof itself. For thisreason, we have slightly modified the tables. In the following,the “search effort” always denote the number of nodes in MIPsearch trees.
We first report our results on a small set of instances withvarious sizes Miller19, GP1, GP2, GP3, GP4, GP5, GP6,GP7, GP8, NWRS1, NWRS2, NWRS3, NWRS4, NWRS5,NWRS6, NWRS7, NWRS8, SP1, SP2, SP3 and SP4. Asboth the lower bound computation (Section 2) and the searchfor an optimal solution are based on MIP (Section 4) theymight require a large amount of CPU time. So, we have de-cided to ignore instances GP5, GP6, GP7, GP8, SP3 and SP4.We first ran our MIP on the remaining instances with a timelimit of 1200.0 seconds. Within this time limit, the optimalsolution has been found (and proven) for GP1, GP4, NWRS1,NWRS2, NWRS3, NWRS4 and NWRS5. For the remaininginstances, we ran our small MIP that provides a lower boundand our simple local search algorithms. The cpu time and thenumber of nodes reported are then related to this small MIPonly.
We have also ran our algorithms on the instances clusteredby size (Table 2). Given the huge number of instances, thesearch for an optimal solution was stopped after 300 seconds.The lower bound (Section 2) and the Upper bound (Section 3)have been computed for all instances that could not be solvedwithin 300 seconds. We have added two columns to the table:
• “Av. Gap” provides the average relative gap between theupper and the lower bound
• “Av. Runtime” provides the average runtime over all in-stances (both solved and unsolved).
5 ConclusionThe major weakness of this approach is that we are not ableto break many symmetries. It seems that adding cuts to re-
move symmetries is both complex and ineffective for the MIPapproach. We believe that this strange behavior should bedeeply investigated.
Abstract. This note presents a constraint model for the pattern sequencing prob-lem proposed at the first constraint modelling challenge at IJCAI. This model isbased on a cumulative constraint. We get a model with a linear number of vari-ables and constraints according to the number of products and customers. Resultswith SICStus Prolog are reported on the benchmark suite provided by the orga-nizers of the challenge.
1 Problem Description
Given a 0-1 matrix M in which each column j (1 ≤ j ≤ p) corresponds to a productrequired by the customers and each row i (1 ≤ i ≤ c) corresponds to the order of aparticular customer1, the objective is to find a permutation of the products such that themaximum number of open orders at any point in the sequence is minimized. Order iis open at point k in the production sequence if there is a product required in order ithat appears at or before position k in the sequence and also a product that appears at orafter position k in the sequence.
2 Contribution and Model
Given a p ·c 0-1 matrixM , our contribution is a compact model for the pattern sequenc-ing problem. We came up with a model involving p variables in [1, p], 3 · c variablestaking their values in [1, p], 2 variables taking their values in [0, c], and one cumulative,one alldifferent, one arithmetic as well as c minimum and maximum constraints. Wefirst provide an example of the pattern sequencing problem and recall the definition ofthe cumulative constraint. We then present our model and illustrate it on the exampleinitially introduced.
Consider the matrix depicted by part (A1) of Fig. 1. Part (B1) gives its correspond-ing cumulated matrix obtained by setting to 1 each 0 which is both preceded and fol-lowed by a 1. The cost 3 of this solution corresponds to the maximum number of 1 in thecumulated matrix. But observe that we can get a lower cost by permutting the fourth andthe last columns. The corresponding matrix is depicted by part (A2) of Fig. 1. Finally,
1 The entry cij = 1 iff customer i has ordered some quantity of product j.
Fig. 1. A first matrix (A1) and its corresponding cumulated matrix (B1). A second matrix (A2)where we permute two columns of (A1) and it corresponding cumulated matrix (B2).
part (B2) shows its corresponding cumulated matrix from which we conclude that wehave a solution of cost 2. Before presenting our model we shortly recall the definitionof the cumulative constraint.
Given a set of tasks, where each task has an origin, a duration, an end and a resourceconsumption, the cumulative constraint enforces that at each point in time, the cumu-lated height of the set of tasks that overlap that point, does not exceed a given fixedlimit. It also imposes for each task the fact that the end is the sum of the origin and ofthe duration of that task.
As depicted by Fig. 2, the key idea of our model is to associate to each row (i.e. cus-tomer) i of the cumulated matrix a stack task which start at the first 1 on row i and endsjust after the last 1 of row i. Then the cost of a solution is simply the maximum heighton the corresponding cumulated profile.
For each column j of the 0-1 matrix initially given we create a variable Vj rangingfrom 1 to the number of columns p. The value of Vj gives the position of column j ina solution. Since V1, V2, . . . , Vp must be assigned to distinct positions we first have analldifferent([V1, V2, . . . , Vp]) constraint.
For each row (i.e. customer) i of the 0-1 matrix initially given we create 3 variablesOi, Di and Ei which respectively correspond to the stack opening time, the stack openduration and the stack closing time of customer i. Thus Oi +Di = Ei.
We create a minimum(Oi, [Vi,1, Vi,2, . . . , Vi,ki ]) and a maximum(Ei− 1, [Vi,1, Vi,2,. . . , Vi,ki ]) constraints for linking the opening time Oi and the closing time Ei withthose permutation variables which correspond to those columns of the 0-1 matrix ini-tially given having a 1 on row i. The minimum of the stack open duration Di is set tothe number of 1 on row i of the initial 0-1 matrix.
Finally we put all the stack tasks in a cumulative constraint, telling that each stacktask uses one unit of the ressource during all it execution. Since we want to have thesame model for different limits on the number of open stacks we create one extradummy task which starts at 1, ends at p + 1 and with a height H in [0, c]. We linkH with the number of open stacks Cost by the constraint H + Cost = c.
3 Additional Constraints and Enumeration
Symmetry breaking Va < Vb, where Va and Vb are the first two variables in the staticorder.
Fig. 2. Stack tasks associated to each row (i.e. customer) and corresponding cumulated profile forthe two matrices of the previous example.
Subset row Suppose the 1s in row i form a subset of the 1s in row j. Then we haveDi ≤ Dj , Oi ≥ Oj , Ei ≤ Ej .Dominance constraints First, we give two ways of transforming a valid solution S ′ toanother valid solution S ′′ with the same or lower cost. We say that S ′′ dominates S′.Then, we express constraints that suppress solutions S ′, taking care not to suppress anysolutions S′′. The transformations apply to columns i, j and row q such that the set of1s in column i equals the set of 1s in column j, except M [q, i] = 0 and M [q, j] = 1.Transformation 1: Suppose S ′ is a solution with Oq < Vi < Vj . We obtain S′′ byswapping columns i and j. There are two cases: a) If j is the last column with a 1 inrow q, thenEq and Dq will decrease. b) Otherwise,Eq and Dq remain unchanged. Theother rows are unaffected. The maximum peak cannot increase; it might decrease.Transformation 2: Suppose S ′ is a solution with Eq > Vi > Vj . We obtain S′′ byswapping columns i and j. There are two cases: a) If j is the first column with a 1 inrow q, then Oq will increase and Dq will decrease. b) Otherwise, Oq and Dq remainunchanged. The other rows are unaffected. The maximum peak cannot increase; it mightdecrease.
We don’t want to apply Transformation 2 in case (b), as the obtained S ′′ wouldmatch the precondition of Transformation 1, leading to an infinite sequence of trans-formations. Hence we add the conjunct Vj = Oq to the precondition of Transforma-tion 2. We obtain the following dominance constraints, which suppress solutions S ′:¬(Oq < Vi ∧ Vi < Vj) and ¬(Eq > Vi ∧ Vi > Vj ∧ Oq = Vj).Enumeration We use the following strategy for the enumeration:
– Identical columns are merged.– Variable choice: Columns are ordered by decreasing total number of 1s.– Value choice: From the middle to both extremities. For example, for 15 columns
we get the following ordering of the values: 8, 9, 7, 10, 6, 11, 5, 12, 4, 13, 3, 14, 2,15, 1. The intuition being that columns with higher number of 1s should be placednearer the middle of the schedule. This value choice heuristics was more successfulthan simpler variants for the most difficult instances.
Weakness of the Model It seems that the propagation related to the minimum andmaximum constraints is rather weak since it does not directly takes into account thefact that the permutation variables should take distinct values. One idea for the futurecould be to create the constraint (and a filtering algorithm achieving arc-consistency)
Constraint Modelling Challenge 2005
16
min max(MIN, MAX, [V1, V2, . . . , Vn]) where MIN is the minimum value of V1, V2, . . . , Vn,MAX is the maximum value of V1, V2, . . . , Vn, and V1, V2, . . . , Vn are all different.
4 Results
We run our solver with a 15 seconds time cutoff limit on a 3GHz Pentium 4 with SIC-Stus Prolog on all the instances provided by the organizers of the challenge. The nexttable summarizes our results. Columns A, B, C, D, E, F, G, H, I, J of the table presentednext page respectively provide
• A: The percentage of solved instances to optimality within the cutoff limit of 15seconds,• B: The mean best value found for all instances,• C: The mean total time for finding the optimal solution and for proving optimality
for those instances for which we could prove optimality,• D: The median total time for all instances,• E: The maximum time for all instances,• F: The mean total number of backtracks for finding the optimal solution and for
proving optimality for those instances for which we could prove optimality,• G: The median total number of backtracks for all instances,• H: The maximum number of backtracks for all instances,• I: The total number of instances,• J: The number of instances solved to optimality.
All reported times are expressed in milliseconds. A -1 in columns C and F indicatesthat we could not solve to optimality any instance of a group corresponding to the firstcolumn.
subset_01([], [], _, []).subset_01([X|L1], [X|L2], I, L3) :- !, J is I+1, subset_01(L1, L2, J, L3).subset_01([0|L1], [1|L2], I, [J|L3]) :- J is I+1, subset_01(L1, L2, J, L3).
dominance_constraints([]).dominance_constraints([item(Pi,Pj,task(O,_,E,_,_))|Items]) :-Pi #=< Pj #=> O #>= Pi, Pi #>= Pj #/\ O #= Pj #=> E #=< Pi,dominance_constraints(Items).
The problem A manufacturer has a number of orders from customers to satisfy; each order is for a number of different products, and only one product can be made at a time. Once a customer's order is started (i.e. the first product in the order has been made) a stack is created for that customer. When all the products that a customer requires have been made, the order is sent to the customer, so that the stack is closed. Because of limited space in the production area, the number of stacks that are in use simultaneously i.e. the number of customer orders that are in simultaneous production should be minimized. More formally: we are given a Boolean matrix in which the columns correspond to the products required by the customers and each row corresponds to the order of a particular customer. The entry c_ij = 1 iff customer i has ordered some quantity of product j (the quantity ordered is irrelevant). The objective is to find a permutation of the products such that the maximum number of open orders at any point in the sequence is minimized: order i is open at point k in the production sequence if there is a product required in order i that appears at or before position k in the sequence and also a product that appears at or after position k in the sequence We have n customers (indexed by i) and m products (indexed by j). We have to find a permutation of 1,…m. Let σj be the position of product j in the sequence. P(i) is the set of products of customer i C(j) is the set of customers ordering product j Dynamic Programming Given a solution (permutation) σ, the number of open commands at position t only depends on the product j attached to position t and on the set of products St attached to previous positions (up to t-1). Indeed open commands are C(j) ∪ O(St) with O(St)=i ∈ [1..n] , P(i)∩St ∉ ∅ ,P(i), in other words commands containing product j (namely C(j)) and commands with some products in St but not all (namely O(St)). It is important to note that the actual permutation of St has no impact on the number of open commands at position t. Therefore we can design a dynam ic program with 2m states, corresponding to all possible subsets of [1..m ]. Any state S can be reached from |S| different states1 with one product less. If we denote by f(S) the objective value corresponding to the best permutation of products of S, then S can be recursively written as:
( )
=∅
−∪−=∈
0)(
)()(),(max()( minf
jSOjCjSfSfSj ,
and f([1..m]) is the optimal solution of the problem. Complexity Space complexity is 2m. More precisely, for problems of size n<64, m=30, we need 6x109
bits in memory. The computation algorithm reads as follows: For S in subsets ([1..m]) // 2m subsets Compute O(k), scanning all commands and intersecting their set of product with k Then for all products j (at most m, m/2 in average), compute the union of O(k) and P(j) Then get the cardinality of this set and update f(S∪j) if necessary The time complexity of this algorithm is O(nm2m). However since space complexity limits the size of tractable instances (with this approach) it is intersecting to focus on the case n and m < 64 since in most programming languages it allows performing intersections, union and even cardinality2 operations in constant time. For such instance the number of operations is around (n+m)2m. In practice computations
1 |X| representing the cardinality of set X 2 Having precomputed the number of bits of all 256x256 bitvectors of size ≤ 16
Constraint Modelling Challenge 2005
21
times are <1ms when m=10, around 1s when m=20, around 30mn when m=30. Larger problem cannot be solved with this approach. Future work This dynamic program may help solving larger instances. For instance it could explore in one second nodes of depth m-20 in a chronological branch and bound [Benoist & Cambazard, ongoing work ]. Or it could optimize any window of 20 columns in a local search approach… Table 1. Aggregate results (Thierry Benoist)
• Java Program on PC 2.4Ghz, 1Go RAM. • One run per instance. • No measure of search effort (no backtrack) • Max runtime 2 seconds.
All sets of instances with m ≤ 20 are solved. For results on problems with m=30 see table 2.
AbstractWe argue that a complete method for the OpenStacks problem should be based on dynamic pro-gramming. Starting from a call based dynamic pro-gram, we show a number of ways to improve thedynamic programming search, preprocess the prob-lem to simplify it, and to determine lower and upperbounds. We then explore a number of search strate-gies for reducing the search space. The final dy-namic programming solution is, we believe, highlyeffective.
1 IntroductionThe Open Stacks problem can be phrased as follows: LetPbe a set of products,C a set of customers, and let us assumethat the products ordered by customerci ∈ C are placed instacki satisfying∀ci, cj ∈ C, ci 6= cj : i 6= j. Customerci
is active (or stacki is open) from the time the first productordered byci is built until the last product ordered byci isbuilt. The Minimization of Open Stacks Problem (MSOP)[3] aims at finding an order for building the products inPwhich minimises the maximum number of customers active(or of open stacks) at any time.
2 Dynamic Programming FormulationThe MSOP problem is naturally expressible in a dynamic pro-gramming formulation. Letc(p) be the set of customers or-dering productp ∈ P , andc(S) = ∪p∈Sc(p) be the set ofcustomers ordering products from setS ⊆ P . Assume thatproductp is built immediately before any product from setA ⊂ P , and after any other remaining product (P −A−p).Then, the set of active customers at the timep is built are
a(p, A) = c(p) ∪ (c(A) ∩ c(P −A− p))i.e., those who orderedp, plus those whose orders includesome products scheduled beforep and some scheduled after.Crucially,a(p, A) does not depend on any particular order ofthe products in A orP − A − p. Let stacksP (S) be theminimum number of stacks required to schedule the set ofproductsS assuming that those inP−S are scheduled earlier.Dynamic programming can be used to definestacksP (S) as:
stacksP (S) = minp∈S
maxa(p, S−p), stacksP (S−p)
Dynamic programming is so effective for this problem be-cause it reduces the raw search space from|P |! to 2|P |, sincewe only need to investigate minimum stacks for each subsetof P . Note also that dynamic programming is completelyequivalent to a constraint logic programming approach withmemoing. Although our implementation does not use a CPsystem, it certainly can be considered a CP approach.
The following code illustrates ourA? call based dynamicprogramming algorithm, which improves over a naive dy-namic programming formulation by taking into account lowerL and upper boundsU :
stacks(S, L, U)if (S = ∅) return 0
if (stack[S]) return stack[S]min := U + 1T := Swhile (min > L and T 6= ∅)
p := indexmina(p, S − p) | p ∈ TT := T − pif (a(p, S − p) ≥ min) breaksp := max(a(p, S − p), stacks(S − p, L, U))if (sp < min) min := sp
stack[S] := min
if (min > U ) FAIL := FAIL ∪ SelseSUCCESS := SUCCESS ∪ S
return min
The algorithm starts by checking whetherS is empty, inwhich case 0 stacks are needed. Otherwise, it checks whetherthe minimum number of stacks forS has already been com-puted (and stored instack[S]), in which case it returns thepreviously stored result (code shown in light grey). If not, thealgorithm basically computes insp the valuemax(a(p, S −p), stacks(S − p), L, U) for eachp ∈ S, and updatesthe current minimum inmin if required. Note, however, thatthis computation is avoided (thanks to thebreak) for prod-ucts whose active set of customers is greater or equal thanthe current minimummin, since they cannot improve on thecurrent solution. As a result, the order in which the productsin S are tried will affect the amount of work performed bythe algorithm. The simple heuristic embedded in our algo-rithm selects the productp which would have the least active
Constraint Modelling Challenge 2005
24
customers if scheduled immediately. The loops also stops assoon as the current solution equals the lower bound, since weare only interested in finding one best solution.
The dark grey code stores inSUCCESS the sets whichresulted in finding a solution within the bounds, and inFAILthose which did not. We will make use of these later.
Calling stacks(P,L,U) returns the minimal number ofstacks required to schedule the productsP assuming a lowerboundL and upper boundU . Extracting the optimal solu-tion found fromstack[] is straightforward, and standard fordynamic programming.
We can improve the code above by noticing that whencomputingstacksP (S), the open stacks initially are given byo(S) = c(P − S) ∩ c(S). If we have a productp ∈ S wherec(p) ⊆ o(S), then there must be a solution tostacksP (S)which starts withp.
Lemma 1 If there existsp ∈ S wherec(p) ⊆ o(S) then thereis an optimal order forstacksP (S) beginning withp.
Example 1 Consider the following open stacks problem
p1 p2 p3 p4 p5 p6 p7c1 X . . . X . Xc2 X . . X . . .c3 . X . X . X .c4 . . X X . X Xc5 . . X . X . .
Consider schedulingS = p1, p2, p3, p4, p6 afterp5, p7have been scheduled. Then,o(S) = c1, c4, c5 and an opti-mal schedule can begin withp3 sincec(p3) ⊆ o(S). 2
We can improve the search further using the following ar-gument about the minimal number of stacks required. Definethecustomer graphG = (V,E) for an open stacks problemas:V = c(P ) andE = (c1, c2) | ∃p ∈ P, c1, c2 ⊆ c(P ).That is, nodes represent customers, and nodes are adjacent ifthey order the same product. LetdG(c) be the degree of nodec in G.
Lemma 2 The minimal number of stacks required for set ofproductsS is at leastb(S) = |o(S)| + mindG′(c) | c ∈c(S), G′ = (V,E − (c1, c2)|c1, c2 ⊆ c(P − S)).
Example 2 The customer graph for Example 1 is
c1 c2
c3c4c5
Consider scheduling the setS = p2, p3, p4, p5, p6, p7 afterp1. The open stacks areo(S) = c1, c2. The reducedcustomer graph removes the dashed arc betweenc1 andc2.The remaining degrees are: 2,2,2,4,2 respectively.b(S) =|c1, c2| + 2 = 4. This is a lower bound on a schedule forS, since closing any customer requires at least this many openstacks. 2
We can use this to improve theA? algorithm above. Wereplace the calculationa(p, A) with
a′(p, A) = maxa(p, A), b(A)which gives an improved lower bound on the future numberof stacks required.
3 PreprocessingOur methodology attempts to simplify the problem by apply-ing two preprocessing steps to the initialP . The first stepremoves fromP any productp′ such thatc(p′) ⊆ c(p) forsomep appearing in the reduced problem. Solving the re-duced problem gives an optimal value forP , and optimal so-lutions to the reduced problem can be extended to give op-timal solutions toP by simply placing eachp′ immediatelyafter thep that subsumed it.
This was also noted (although not proved) in Beccenerietal. [1]. We can prove it using Lemma 1. Simply note thatif c(p′) ⊆ c(p) then any order forS including p′ but notincludingp must havec(p′) ⊆ o(S). Because the problem isthe same when considering the reverse order, the same holdsfor orders withp′ beforep.
Example 3 Consider the open stacks problem from Exam-ple 1. Sincec(p2) ⊆ c(p4) andc(p6) ⊆ c(p4), the two prod-ucts can be removed. Inserting them afterp4 in an optimalorder for the reduced set of products, gives an optimal orderfor the original problem.
p5 p7 p3 p1 p4 p2 p6c1 X X – X . . .c2 . . . X X . .c3 . . . . X X Xc4 . X X – X – Xc5 X – X . . . .
2
Our second preprocessing step is more obvious: ifP canbe partitioned into two setsP = P1 ∪ P2 such thatc(P1) ∩c(P2) = ∅, then we can independently orderP1 followed byP2. This is noted by Yeun and Richardson[3]. We thoughtthis was too unrealistic to occur, but it does occur in severalbenchmarks, including some of the mildy difficult ones.
Becceneriet al [1] reference techniques for handling treelike sub-graphs of the customer graph independently, but thepaper is not available (and is in Portugese!).
4 BoundsOurA? algorithm uses both upper and lower bounds to reducethe number of subsets visited. Trivial lower and upper boundsareL = max|c(p)| | p ∈ P andU = |C|.
Our approach tries to improve the lower bound byanalysing the customer graph.
Lemma 3 If Q ⊆ C is clique in the customer graphG, theminimal number of open stacks is at least|Q|
We independently determined this lower bound beforefinding [1] where they explain a more general approach tocalculating lower bounds. They introduce the following lowerbound without proof.
Constraint Modelling Challenge 2005
25
Lemma 4 If d = 1 + mindG(c) | c ∈ C thend is a lowerbound on the open stacks for the problem.
A minor of an open stacks problem can be obtained byeither removing an entire customerc ∈ C (replacingc(p)by c′(p) = c(p) − c), or merging two adjacent customers(c1, c2) ∈ E (replacing each product orderc(p) by c′(p) =(c(p) − c2) ∪ c1 if c2 ∈ c(p), or by c′(p) = c(p) oth-erwise). These operations correspond to edge contraction ornode elimination from the customer graphGc.
Lemma 5 Let m be the minimal open stacks for a problemdefined byc(p), andm′ be the minimal open stacks for theproblem defined byc′(p) wherec′ is a minor ofc. Thenm′ ≤m.
With these two lemmas we apply any number of minorsteps and use the size of the minimum degree node + 1, asa lower bound for the original problem. Note that we canstop when the remaining customer graph is a clique.
Becceneriet al. [1] define a heuristic arc contraction ap-proach (HAC) based on this, but provide no proof of correct-ness. We built an implementation of Becceneriet al.’s algo-rithm and a greedy clique finder (that doesn’t do contractionsbut tries starting from each products set of customers).
In order to improve the upper bound we run a number ofgreedy heuristics of the following general form.
heuristic(S)min := 0while (S 6= ∅)
heuristically selectpS := S − pif (a(p, S − p) > min) min := a(p, S − p)
return min
We experimented with eleven heuristics, with the five mostsuccessful over all benchmark instances being:(1) Yuen’s hueristic 3[2]: selects at each stage the productpwhose intersection of customers with previous active stacksminus the number of new stacks is maximized
indexmaxp∈S
|c(p) ∩ c(P − S)| − |c(p)− c(P − S)|.
(2) minimizes the number of active stacks and breaks ties infavor of products that close greater number of stacks (are thelast product in those stacks)
indexminp∈S
(a(p, S − p),−|c(p)− c(S − p)|).
(3) minimizes the number of active stacks except (a) all ac-tive stack numbers less than the currentmin are consideredequivalent, and (b) ties are again broken in favor of productsthat close more stacks.
indexminp∈S
(max(min, a(p, S−p)),−|c(p)−c(S−p)|).
(4) minimizes the number of active stacks and breaks ties bymaximizing a cost given byΣc∈c(p)2−|n(S,c)| wheren(S, c)is the number of productsp′ ∈ S for which customercappears inc(p′). This effectively assigns to each customerwith m ordered products a cost of (almost) 1 split amongstits products as follows:2−m for the first scheduled product,
2−m+1 for the second, . . . ,2−2 for the second last, and2−1
for the last product.
indexminp∈S
(a(p, S − p),−Σc∈c(p)2−|n(S,c)|)
(5) minimizes the maximum of the number of active stacksrequired using the improved formulaa′(p, A).
indexminp∈S
a′(p, S − p)
We also implemented the minimal cost node heuristic(which we’ll denote (6)) of Becceneriet al [1] which doesnot follow the general greedy format since it selects arcs (notproducts) in the customer graph to determine a product order.
5 Search StrategiesOur A? program is particularly effective when called withL = U = n, where it only explores schedules which use ex-actlyn active stacks. This is related to the fact that the prob-lem isfixed parameter tractable. This immediately suggestsan extended search procedure where we successively try eachpossible value from the lower to the upper bound:
Note that ifstacks returns a number different fromU+1, thisis the optimal value and can be reused in later computations.We need to reset the memoed values for FAILed sets (whenstack[S] > U ), since they must have failed because the upperbound was too low.
We can improve upon this search using binary search. Thefollowing code
gmin := minU := min− 1for (S ∈ FAIL ∪ SUCCESS) stack[S] := 0
elseL := try + 1for (S ∈ FAIL) stack[S] := 0
return gmin
repeatedly tries the midpoint of the current range. If success-ful, it tries values below it after removing allstack[S] compu-tations performed forstacks(P, try, try) (but not those pre-viously calculated and used by this computation), since theycould be too high or too low. If unsuccessful, it tries valuesabove it, after removing FAILed stored values.
Finally, we noted that often the most expensive stack num-ber to try was the stack number below the optimal, and thoseabove the optimal were usually easier than those below. This
Constraint Modelling Challenge 2005
26
motivated a backwards stepwise approach where the possiblestack numbers are tried in decreasing order:
This has another advantage: we can stop at any time witha (non-optimal) solution. Note that sincestacks can returna value less thantry we do not just decrease thetry by oneeach time, but to under the minimum we last found.
6 Experimental ResultsIn this section we briefly describe the effect of the prepro-cessing approaches, lower and upper bounds approaches andsearching approaches.
We compare on all benchmarks except the most difficult:SP2, SP3, SP4, which none of our versions can finish in time.In order to compare the different search approaches we showthe total number of calls tostacks to optimally solve eachinstance (except SP2, SP3, SP4) for each search strategy withall optimizations enabled, and thenbackwards with someoptimizations disabled individually. The appendix shows theresults for all benchmarks.
The dynamic programming code is written in C, with nogreat tuning or clever data structures, and many runtime flagsto allow us to compare the different versions easily.
First of all the definite choice optimization of Lemma 1 ishighly beneficial. The total number of calls tostacks reducesby 1/3 but the time halves since we avoid search for the bestpossible candidate.
The improved search offered by the use ofa′(p, A) insteadof a(p, A) is massive. The search reduces by an order of mag-nitude. But because we havent attempted a very clever imple-mentation ofa′(p,A) execution is slower, since usinga(p, A)we can have a very tight inner loop.
Removing redundant productsp′ where c(p′) ⊆ c(p)for another productp is an important first step. Over thebenchmark suite we remove 16305 redundant products outof 101385 total products, a 16% reduction in size on average.
Given that each extra product could in the worst case doublethe search space, this is vital. This is masked by using thedefinite choice optimization, if both are removed the programfails to solve NWRS8 which has 20 redundant products outof 60.
There are 113 instances where the products are separable(which surprised us somewhat), with 2.42 separate parts onaverage. In most cases the result of separating is not muchbetter than not, since the separable partitions are usually tinysingletons. But there are examples such as Warwick1711where the search space reduces from 1853 calls tostacks to183, even though the separable parts are size 1, 1 and 5 out of29 nonredundant products.
The effect of the upper bound heuristics are not too greatonce we usebackwards. They improve the number of setsin 884 cases, but the percentage improvement is tiny overall(0.0012%) since they do not improve any of the really hardbenchmarks by more that a tiny fraction. Comparatively, theheuristics rank in the order (1) to (6) (worst to best). Of 5964partitions of products for 5803 problems, the following tableshows the number of times each heuristic returned the (equal)bestanswer of all heuristics, theuniquebest answer (betteredall others), the number of times the answer was theoptimalanswer to the problem (of 5803), and the totalsumof theheuristic results is shown.
Although the lower bounds approaches are very successfulat finding good lower bounds, the only time they can improvethebackwards approach is when the lower bound is the op-timal. While this occurs frequently it does not occur on thehard benchmarks so there is little benefit. The HAC heuristicis never improved by the clique approach. The clique lowerbound gives the optimal answer in 2718 benchmarks of 5803,while the HAC approach gives the optimal on 3380.
While the lower and upper bounds are not that useful forbackwards, this is certainly not the case forA?, stepwise orbinarychop. Similarly, without usinga′(p, A) the lower andupper bounds are much more important.
References[1] J.C. Becceneri, H.H. Yannasse, and N.Y. Soma. A
method for solving the minimization of the maximumnumber of open stacks problem within a cutting pro-cess.Computers & Operations Research, 31:2315–2332,2004.
[2] B.J. Yuen. Improved heuristics for sequencing cuttingpatterns. European Journal of Operational Research,87:57–64, 1995.
[3] B.J. Yuen and K.V. Richardson. Establishing the optimal-ity of sequencing heuristics for cutting stock problems.European Journal of Operational Research, 84:590–598,1995.
Constraint Modelling Challenge 2005
27
A AppendixAll experiments were run on a Pentium IV 3.4Ghz with 2GBRAM running Linux Fedora Core 3. The dynamic program-ming software was written in C, compiled with gcc 3.4.2 us-ing -O3. The runs are performed using allA? improvements,all preprocessing steps, all lower and upper bounds heurisitics(using the best value found), and thebackwards stepwisesearch approach. In fact the backwards stepwise approach isfairly insensitive to upper and lower bounds unless the lowerbound is the optimal which can save substantial computation.
Since the program is deterministic the search results arethe same on each run of a benchmark. The timing resultsfor each suite are aggregates over 10 runs of each individualbenchmark in the suite. For the individuals the time shownis the average over ten runs of the individual benchmark.The time calculated is sum of user and system time given bygetrusage , it accords well with wall clock times for theseCPU intensive programs. For the problems that take signifi-cant time we observed around 10% variation in timings acrossdifferent runs of the same benchmark.
The measure of search effort is the number of calls tostacks that do not immediately return, because of cache hitor S = ∅. This is the same as the number of non-symmetriccalls to labeling if we consider this as a constraint pro-gramming approach with memoing. Note that since we usethe backwards stepwise approach, between each successivestack number tried we empty the cache, so the total num-ber of calls is just the sum of the calls made for each stacknumber. The maximum search effort per instance was set at225 = 33554432 calls tostacks.
Note that we always run the dynamic programming searcheven if the calculated lower and upper bounds agree (in whichcase we know we have the optimal solution already)
The software found the opimal solutions for all problemsexcept SP2, SP3 and SP4 which hit the search limit. It finds asolution of size 19 for SP2 using 25785 calls tostacks beforehitting the limit trying 18 stacks. The runtime shown for SP2,SP3 and SP4 is the time to find the best solution. The bestlower bounds we have for SP2, SP3, and SP4 calculated usinglower bound heuristics and usingstepwise are 18, 15 and 22respectively.
Constraint Modelling Challenge 2005
28
File %solved mean Total runtime per instance (ms) Search to find optimal Total search effortbest mean med. max mean med. max mean med. max
Table 2: Individual results: Garcia de la Banda and Stuckey
Constraint Modelling Challenge 2005
30
B ProofsLemma 1 If there existsp ∈ S wherec(p) ⊆ o(S) then thereis an optimal order forstacksP (S) beginning withp.
Proof: Take any optimal orderΠ1p′Π2pΠ3 of S.
Consider the orderpΠ1p′Π2Π3. We show that the
active stacks for each product can only decrease.Consider products inΠ3 have the same active setssince the set of products before and after is an un-changed. Now consider any productp′ (as a gen-eral representative of those products beforep inthe original order). In the original orderap′ =c(P−Π2−p−Π3)∩c(p′∪Pi2∪p∪Π3). Inthe new orderap′′ = c(P−Π2−Π3)∩c(Pi2∪p∪Π3). Nowc(P−Π2−p−Π3) = c(P−Π2−Π3)sincec(p) ⊆ c(P−S) ⊆ c(P−Π2−p−Π3). andc(Pi2 ∪ p ∪ Π3) ⊆ c(p′ ∪ Pi2 ∪ p ∪ Π3).Henceap′′ ⊆ ap′. We also have to examine thestacks forp. In the new ordera(p, S−p) ⊆ o(S)ando(S) is a lower bound on the number of stacksin any order. Hence orderpΠ1p
′Π2Π3 has a mini-mal number of stacks. 2
Lemma 2 The minimal number of stacks required for set ofproductsS is at leastb(S) = |o(S)| + mindG′(c) | c ∈c(S), G′ = (V,E − (c1, c2)|c1, c2 ⊆ c(P − S)).
Proof: At the beginning ofS the remaining cus-tomersc(S). We argue about the minimal num-ber of stacks required to close any open customerc ∈ c(S). In order to close a customerc we needto have open stacks for the customer and all cus-tomersc′ adjacent in the customer graph (sincecandc′ share some productp which needs to be com-pleted before we can closec). The reduced cus-tomer graphG′ removes edges fromG which cor-respond to customer-customer dependencies whichmay already have been completed (since they mayonly occur in products inP − S). In order to closeany customerc, we need to open at leastdG′(c)new customers (since these edges only connect tounopened customers). Hence the bound holds.2
Lemma 3 If Q ⊆ C is clique in the customer graphG, theminimal number of open stacks is at least|Q|
Proof: Assume to the contrary. Eliminating all thecustomers except those inQ (i.e., replacingc(p) byc(p) ∩Q) gives a problem which clearly is a lowerbound on the original problem. Imagine we havea schedule on this reduced problem with|Q| − 1stacks. Then clearly there must be one customerc1
which becomes inactive before another customerc2
becomes active. Contradiction since then the prod-uct wherec1 andc2 are jointly required cannot bescheduled. 2
Lemma 4 If d = 1 + mindG(c) | c ∈ C thend is a lowerbound on the open stacks for the problem.
Proof: In order to close a stack we need to haveactive a customer, and all its neighbours in the cus-tomer graph. Since the customer shares at least one
product with each of these. In order to close the firststack we need to have at leastd active customers.2
Lemma 5 Let m be the minimal open stacks for a problemdefined byc(p), andm′ be the minimal open stacks for theproblem defined byc′(p) wherec′ is a minor ofc. Thenm′ ≤m.
Proof: Take an optimal orderΠ for c. Now since(c1, c2) ∈ E there is a product that sharesc1 andc2
and hence their open lifetimes intersect. Considerthe same orderΠ for c′. Sincec2 is replaced byc1,the lifetime ofc1 is now exactly the union of thelifetimes of c1 andc2 for c. Hence the number ofopen stacksm′′ given byΠ is such thatm′′ ≤ m.The minimal number forc′ is m′ ≤ m′′ ≤ m. 2
Our approach relies on interleaving a complete and a heuristicmethod. We therefore introduce two models: The first one is acomplete model that channels the permutation of the productswith a matrix of Boolean variables standing for open stack ata given time and for a given customer. We detail the propa-gation algorithm for the channelling constraint. The secondmodel is an approximation approach, the idea is that given aproduct p that we schedule at the middle rank (m/2) in the or-dering, we can approximate the best permutation by the bestpartition of products around p. This relies on the observa-tion that having many non-open stacks is harder to achieveat mid-schedule than at the start or the end. When there is ahigh enough demand, then the number of open stacks tends toincrease and then decrease only once, the rank m/2 is there-fore critical. The second observation is that once a product ischosen for the middle rank, the number of open stacks at thetime this product is manufactured depends only on the parti-tion of the other products before or after, and not on the ac-tual permutation. Moreover, if we solve this problem for eachproduct then the best number of stack closed at rank m/2 is alower bound for the whole problem. We therefore solve onesuch problem for each product, and from this preprocessingwe get a lower bound and also an approximate solution. Wealso found that, once each one of these partition problems issolved, giving this partition as starting point for the completemethod is usually a good improvement. When the prepro-cessing is completed, then the upper and lower bounds arehanded to the complete method (when they are not alreadyequal) to hopefully prove optimality.
2 Complete Model
We refer to the matrix containing the data as demand. Thenfor any permutation of the columns (products) of demand,we can construct a matrix openOrders that represents whichorders are open for which products. For instance, let the fol-lowing matrices represent demand ⇒ openOrders for twopossible permutations. The first permutation of the productshas 4 orders opened at once for product 2, whilst the secondpermutation has never more than 2 open orders at the sametime:
P1 P2 P3
C1 0 1 0C2 1 0 1C3 1 0 1C4 0 1 0
⇒
P1 P2 P3
C1 0 1 0C2 1 1 1C3 1 1 1C4 0 1 0
P1 P3 P2
C1 0 0 1C2 1 1 0C3 1 1 0C4 0 0 1
⇒
P1 P3 P2
C1 0 0 1C2 1 1 0C3 1 1 0C4 0 0 1
Suppose that we have n customers and m products. Wedeclare an array permutation of m variables, ranging in[1..m] with an alldiff constraint. The semantic ofpermutation[i] = j is that product i comes jth in the or-dering. We also declare a matrix openOrders of n × m0/1 variables. The semantic of these variables correspondsto the second and fourth matrices (open orders) in the ex-ample above. openOrders[i, j] = 1 iff there exists k, lsuch that permutation[k] ≤ j ≤ permutation[l] andcustomer i demands products k and l. Then we minimisethe maximum sum on the rows of openOrders, that ismaxi(
∑j openOrders[i, j]).
The most important part of this model is the waypermutation and openOrders are channelled. We deviseda global constraint for that purpose.
We need one SEQUENCECHANNEL constraint for eachcustomer. The Boolean variables [B1, . . . , Bn] correspondto one row of openOrders, and the integer variablesX1, . . . , Xk to those variables in permutation such that thecorresponding product is demanded by the customer we con-sider. For instance, on the small example we have:
• SEQUENCECHANNEL(openOrders[1], P2)
• SEQUENCECHANNEL(openOrders[2], P1, P3)
• SEQUENCECHANNEL(openOrders[3], P1, P3)
• SEQUENCECHANNEL(openOrders[4], P2)
Now we give some rules to propagateSEQUENCECHANNEL([B1, . . . , Bn], X1, . . . , Xk). Let
Constraint Modelling Challenge 2005
32
α0 (resp. β0) be the smallest (resp. greatest) index of aBoolean variable that contains the value 1, and α1 (resp. β1)be the smallest (resp. greatest) index of a Boolean variablethat does not contain the value 0. The propagation rules thatwe present here first compute the values of α0, β0, α1, β1,then propagate to the integer variables and conversely, usethe result to refine α0, β0, α1, β1 and prune the booleanvariables:
Propagation Resulting from α0, β0: The first observationis that if there exists i such that Bi = 0 and i − α0 < k thenwe have α0 = i + 1. This is because there is not enoughroom for all the 1’s between α0 and i, and they must be allconsecutive. Of course, the same reasoning can be applied toβ0.
Then we look at the Xi’s. We can prune the bounds of anyXi to [α0..β0]. When this is done we enforce:
α0 = mini(min(Pi)) & β0 = maxi(max(Pi))
We have three cases:
1. β0 − α0 + 1 < k: we fail.
2. β0 − α0 + 1 = k: then we can set α1 and β1 to α0 andβ0 respectively.
3. Otherwise: For all i such that Xi is ground, we enforce:
α1 = min(α1, i) & β1 = max(β1, i)
Moreover, if the total number of values in the domainsof the Xi’s is equal to k, then we have:
α1 = α0 & β1 = β0
Propagation Resulting from α1, β1: We have the follow-ing inequalities:
α1 ≤ mini(max(Pi)) & β1 ≥ maxi(min(Pi))
Since some indexes lower than or equal to mini(max(Pi))(resp. greater than or equal to maxi(min(Pi))) will be set toone.
α1 ≤ β0 − k + 1 & β1 ≥ α0 + k − 1
Since there will be at least k 1’s.Finally we have Bi = 0 for all 1 ≤ i ≤ α0 or n ≥ i ≥ β0
and Bi = 1 for all α1 ≤ i ≤ β1.
3 Heuristic modelThe basic idea here is that the product that we choose to put inthe middle of the ordering is the most constrained. It is easyto see that when the first product is manufactured, we needno more stacks than the demand for that product. This is alsothe case for the last product. Most of the time, the number ofopen stacks will follows a regular distribution with a uniquepeak (or plateau). Moreover, given a product that we chooseto be manufactured in the “middle” of the sequence, only thepartition of the other products before or after the rank m/2 isimportant to know how many stacks will be necessary at timem/2. To understand why this method gives good results, it is
important to notice that for a stack to be closed at time m/2,it must be closed for either 0..m/2 or m/2..m. Therefore,consider a product manufactured at time m/2, and a partitionthat ensure k closed stacks at that time. This ensure at leastkm/2 closed stacks (0’s in openOrders) for any permutationthat respects this partition. The problem that we want to solvecan be formulated as follows:
Given a product p, what is the minimum number of openstacks at time m/2 if we schedule p to rank m/2 ?
The exact rank of other columns does not matter, this valuedepends only on how we partition the columns, either be-fore or after j. Indeed, for any i, if we schedule productj to rank m/2, then we have openOrders[i][m/2] = 1iff either demand[i][j] = 1 or there exists k, l such thatdemand[i][k] = 1 and demand[i][l] = 1 and the productsk and l are scheduled on both sides of m/2, and the exactranking of k and l are not important. We give an equivalentdefinition of the problem using set notations:
Definition 2 MININTERSECTPARTITION: given m setss1, . . . sm, we must partition those sets into 2 groups G1 =s11, . . . s1m/2, G2 = s21, . . . s2m/2 such that |G1| =|G2| and the size of the intersection between the union of allsets within each group is minimised:
min(|⋃
si∈G1
∩⋃
sj∈G2
|)
Indeed, given a product j that is scheduled to the rank m/2,we can represent each product k as the set of customers i thatdemand k and does not demand j (sk = i | demand[i, k] =1∧demand[i, j] = 0). Now if two of those sets share a “cus-tomer” i and are not put into the same group (before/after),then the stack for product j will be open at rank m/2.
We give a constraint program to solve this problem:
1. A set of at most n Boolean variables Z1, . . . Zd, one foreach initial 0 in the column j of demand.
2. m−1 Boolean variables P1, . . . Pm−1, one for each col-umn (product) apart form j. We pose Pk = 0 iff Pk goesbefore the rank i (given to the column j).
3. We post a sum constraint∑
k∈[1..m−1] Pk = m/2, toenforce the partition.
4. For each columns c1, c2 and row r such thatdemand[r, c1] = 1, demand[r, j] = 0 anddemand[r, c2] = 1, we post a constraint to enforce thatif these two columns are partitioned in different sides,then Zr should equal 1:
(Pc1⊕ Pc2
) ⇒ Zr
5. We minimise the sum∑
k∈[1..dj ]Zk, i.e., the number of
“preserved” 0’s (or intersections between columns).
This problem is in practice small (at most n + m − 1Boolean variables) and easy to solve for instances up to acertain size. However, it is NP-hard, and for really large in-stances (say for instance 50 products and customers), solv-ing this partition problem to optimality is difficult. Here is asketch of a proof of NP-hardness:
Constraint Modelling Challenge 2005
33
Proof: We reduce MAX-2SAT to the problem of partition-ing the collection of sets S1, . . . , Sn into two collectionsG1, G2 of equal size such that |⋃Si∈G1
∩⋃Sj∈G2
| is mini-mum.
Let φ be a 2SAT formula with n atoms and m binaryclauses. We introduce two sets Si and Si for every atom xi.For every pair of literals xi, xj there are 3 possibilities:
1. They are opposites (xj = xi), then we do nothing.
2. There is a clause ck = (xi, xj), then we introduce n + 1elements ek1, . . . ek(n+1) in both Si and Sj .
3. Otherwise, for the kth such pair, we introduce n + 2elements fm+k1, . . . fm+k(n+2) in both Si and Sj .
We first show that partitioning Si and Si in the same col-lection is never optimal. Consider such a solution, since thetwo groups have equal size, there exists j such that Sj and Sj
are in the second collection. Now if we swap Si and Sj , wewill remove at least 2n(n + 1) intersections, and add at most2(n − 1)(n + 2). It thus always is an improvement.
As a consequence, any optimal solution corresponds to avalid 2SAT assignment, moreover, since allowed combina-tions are less penalised it corresponds to an optimal 2SATsolution.
3.1 AlgorithmIn this section we detail how we combined these two ap-proaches.
• We solve m times the problem MININTERSECTPARTI-TION, once for each product.
We collect the intersection size and keep it iff it isthe lowest so far.
Then we consider the partition, and we repre-sent the problem using the complete model, but modi-fied as follows: We set permutation[j] = m/2, andfor each i 6= j, we add permutation[i] < m/2 orpermutation[i] > m/2 according to the partition com-puted earlier.
We collect the value returned by the completemethod and keep it iff it is the lowest so far.
• Then we pass the bounds to the complete method, forcompleteness.
4 Implementation and DiscussionWe implemented these models using HalCSP1. The heuristicmodel we actually used for most instances is a slight variationon the one introduced earlier. The only difference is that in-stead of choosing one product, we chose a pair of products toput at rank m/2−1 and m/2. The benefits both on lower andupper bounds usually compensated the fact that O(n2) prob-lems were to be solved instead of O(n). We usually imposedno cutoff when solving MININTERSECTPARTITION, but weimposed time cutoff for the complete method both for solv-ing “partitioned” problems and the “total” one. The value ofthe cutoff varies according to the instances. It is worthwhileto note that MININTERSECTPARTITION being usually small
1available at http://www.cse.unsw.edu.au/ ehebrard/codef.htm
and involving only Boolean variables, the number of back-tracks can be huge for a given duration. On the other hand, thecomplete model makes much less backtracks for similar prob-lem size and duration. For instance, on wbo 30 30.txt wewill have 75,000 backtracks per second in one case and 900 inthe other. Therefore the search effort column should be takenwith great care, as the search effort corresponding to the com-plete method is underestimated in comparison with that ofthe heuristic model. All the experiments were run on desktopwith an Intel Pentium 4 CPU 3.20GHz and 1Gb of memory.The “K”, “M” and “G” in the tables correspond respectivelyto “Thousands”, “Millions” and “Billions” of Backtracks.
5 Appendix
Constraint Modelling Challenge 2005
34
File solved value Total cpu time (s) Best solution backtracks Total backtracksmean mean median max mean median max mean median max
In this paper we demonstrate the benefit of calcu-lating good lower bounds for the value of , themaximum number of concurrently open stacks, foran optimal solution. We give several theoretical re-sults and illustrate their use when applying a modelchecking approach to find solutions. The improve-ment afforded is equally valid when a constraintsmodelling approach is taken.
1 IntroductionWhen an optimal solution to a problem is sought, whichevermodelling approach is used, failure to provide good initialbounds for a solution can make finding a solution more diffi-cult and, in some cases impossible. In this paper we provesome theoretical results which provide some good lowerbounds in some cases. Indeed, we could not have solvedmany of the final instances without these bounds. We also de-scribe a construction technique, based on one of our theoreti-cal results, which often provides us with the optimal solutionwithout the need for search. When the constructed solutionis not necessarily optimal (the maximal number of stacks isnot equal to the best lower bound) it often provides a verygood solution from which to start a search. We combine ourtheoretical results together with a model checking approachto find an optimal solution in almost all of the final instances.It is important to note, however, that when using a constraintsmodelling approach, the application of the theoretical boundsis equally valid and, indeed, essential (see [1]).
2 The model checking approachModel checking has been used efficiently to solve a prob-lem that is very similar to the minimal open stacks problem(MOSP), namely to solve the rehearsal problem [2].
We have adapted this model to investigate MOSP. Al-though we have not exploited the major advantages of modelchecking (concurrency, and communication for example), inthe smaller examples it provides an efficient method for find-ing a solution with maximum number of open stacks less thanor equal to , for given , if such a solution exists.
Explicit state model checking with SPIN involves convert-ing a description of a system (written in the specification lan-
guage Promela) into a finite graph, or state space, and per-forming a depth-first search over the state space. The nodesof the state space are the states, which are stored as tuplesconsisting of the current values of every variable in the sys-tem. Properties are checked by a depth-first search of the statespace. If a state is reached which has been previously visitedthen the search will automatically backtrack. (This includesself loops.)
As well as checking for deadlock, livelock and assertionviolations, SPIN allows us to verify properties expressed aslinear temporal logic (LTL) formulas. If a path is found forwhich a given property is false, the search terminates and thecurrent path provided as a counter-example.
The property that we use in this example, is a safety prop-erty (something bad will never happen). For a given weassert that no solution with maximum number of open stacksless than or equal to is possible. If there is a solution, wecan examine the associated counter-example to construct thecorresponding sequence of products. This sequence is con-structed automatically using a Perl script, we do not providedetails here.
One of the features of SPIN that we exploit is automaticbacktracking, described above. If a subsequence of prod-ucts has been generated in which the maximum number ofopen stacks is already greater than (and so the currentsubsequence can not possibly lead to a solution), a delib-erate self-loop is introduced, causing the search to back-track and the current subsequence to be abandoned. In ad-dition, if the current path has so far successively placedproducts , then, because the associated statesat this point would be identical, if any path had previ-ously been explored for which the first products were also (in any order), the search would again back-track (the number of open stacks from this point onwardswould be the same in either path).
The Promela specification for a simple model (the first example) is provided in Appendix 2. It is pro-vided for the interested reader, and we are happy to provideadditional explanation upon request.
Model checking is a very efficient tool for finding bugs inprograms [3] but proving that no errors exist can be impos-sible due to memory and time constraints. This is becausefinding an error (or solution in our case) involves searchingonly part of the state space, and proving no errors requires
Constraint Modelling Challenge 2005
36
the entire search space to be searched. As such, in the stacksproblem it is usually fairly easy to show that a solution for agiven exists, (and to provide a solution) but - for the largerexamples - difficult (and in some cases impossible) to showthat no solution exists.
The basic approach involves initially setting to be thenumber of customers. We then produce a series of models,reducing the value of by each time, until a model is pro-duced for which no solution with maximum number of openstacks less than or equal to exists. We then increase by , recreate the associated model, and find a solution. Allof these stages are performed automatically, using a templatemodel and a file containing the particular example.
For some of the larger examples however, it is either verytime-consuming, or impossible due to memory constraints, toprove the case where no solution exists using model checkingalone. However, by precomputing a good lower bound for theoptimal solution, it is often possible to avoid this last step al-together. If we have found a solution for which the maximumnumber of open stacks is equal to a known lower bound ,there is no need to investigate further.
In the following section, we give some theoretical results toenable us to establish a set of lower bounds for each example,from which we can choose the best.
3 Finding a good lower boundThe simplest lower bound for the number of concurrentlyopen stacks is given by the maximum number of customersrequesting a single product. In this section we give some re-sults which help to improve on this lower bound.
First of all we introduce the idea of the degree of a givencustomer.Definition 1 For any customer , the degree of , is thenumber of customers for which and select the sameproduct. (We say that and are in a product.)
For example, in instance Miller19, every customer has de-gree because they all appear in a products with othercustomers.
In the following, when we say that is a lower bound,we mean that there is no ordering of products such that themaximum number of concurrently open stacks is less than .
Theorem 1 If
then is a lower bound.
Proof Suppose that is the first customer to have all of itsorders satisfied. Then when the last order containing isfilled, there are at least stacks open. This is because has degree at least , the orders containing must haveinvolved opening stacks for all of the customers adjacentto plus a stack for , none of which can have been closedas is the first customer to have had all of its orders filled.Corollary 1 If we list the degrees of the customers innon-descending order, say, where and , then alower bound is given by .
Theorem 2 Suppose is the minimum of the degrees of thecustomers. If there is only one customer, say, with , then is a lower bound.
Proof If there is a solution with the maximum number of openstacks less than then by theorem 1 it follows that isthe first customer to have all of its products filled. Supposethat the first product in the sequence of products containing is , and the last product in the sequence containing is . Up to and including the point at which is made,no customer ( say) not in a product with can have had astack open. (Otherwise at there are at least stacks open – every customer in a product with , itself, and ). Similarly, if we reverse the order in whichthe products are made, since the maximum number of openstacks will not increase, must again be the first customer tohave all of its products filled, and there can be no productscontaining a customer not in a product with up to the lastproduct containing (). This means, going back to theoriginal order, if is some customer not in a product with , can not appear in any product either up to and including or from to the final product inclusive. Thus can neverappear. This is a contradiction.
Corollary 2 If there is only one customer, say, with mini-mum degree , and all other customers have degree at least , then if there is some product containing of thecustomers not in a product with , then is a lowerbound.
Proof As above, but this time we show that if there is asequence with the maximum number of concurrently openstacks less than , then the product can not appearanywhere in the sequence.
Theorem 3 For any pair of customers and , let bethe size of the set of customers formed by taking the union ofthe neighbours of and the neighbours of and (if necessary)removing customers and . Let be the minimum forall pairs of customers and (where ). Then is a lower bound.
Proof Let customers and be the first two customers tohave all of their products filled. If and have their lastproduct filled at the same time, and the last product containing and is say, then when is placed, customershave orders open. Suppose and have their last productfilled at different times, and suppose has all of its productsfilled first. When the last product for is filled, there are customers with orders open. If is the minimumsuch , clearly is a lower bound.
Corollary 3 Let be the minimum for all triples where , then is a lower bound. If wedefine in a similar way for all then is a lowerbound.
The following result gives an easy way to find a solu-tion with maximum number of open stacks at most
Constraint Modelling Challenge 2005
37
, provided all customers do not have degree .
Theorem 4 If at least one customer has degree less than ,there is a solution with maximum number of concurrentlyopen stacks at most .
Proof Suppose that customer has degree and re-quests products. Then for any sequence in which all of the products containing are placed first, the number of openstacks will never exceed . This is because for the first products the number of stacks is at most , and forthe remaining products the stack for is closed, and so thereare at most open stacks.
Theorem 5 Let and be two products, such that the size ofthe union of the customers requiring product or ()say) is . If all customers with degree belong toboth and , then is a lower bound.
Proof If the first customer to have all of its products filledhas degree at least then, by an argument similar to theabove, is an upper bound. Assume w.l.o.g. that is madebefore . Then, since all customers with degree require both products and , they will not have their stacksclosed until after both and have been made. So no openstacks will be closed until both and have been made. Itfollows that there will be at least stacks openwhen is made. In all cases, is an upper bound
Theorem 6 Let and be two products, such that is madebefore , and the size of the union of the customers requiringproduct or () say) is . Let and be the setsof customers requiring product but not , and vice versa. Ifeither:
1. for every customer , is in a product with everycustomer in or
2. All customers in apart from some customer satisfy(1) and is in a product with all but one of the customersin , say, is in a product with some in , and is in some product with ,
then is an upper bound. If there is some customer forwhich the second case holds, but no suitable exists, is a lower bound.
Proof Omitted for space reasons.
4 A ConstructionThe following construction is loosely based on observationand Theorem 6. It often provides an optimal solution immedi-ately (instances GP3 and GP4, for example), and in all casesprovides a good starting point. In some instances (GP7 forexample) it provided the best solution, where model check-ing alone could not cope with such a large problem.
Construction 1 Let be the minimum size of the pairwiseunions (see Theorems 5 and 6). Pick two customers and such that the size of the union is equal to , and . List the products ordered by first, followed
by any (remaining) products on , followed by any productsthat are ordered only by customers belonging to . Itcan easily be shown that the number of open stacks at anypoint so far is at most . Henceforth, when we haveplaced a product , we say that a customer is finished if itdoes not appear in any unplaced products (unfinished other-wise), and spare if it has not yet appeared in a placed product.For any customer , let equal the number of spare pointsadjacent to , then we define
if is not a spare point otherwise
The construction proceeds as follows: If the number of un-finished customers is at most the maximum stack size so far,stop. Otherwise, pick a customer such that is mini-mal. Add all remaining products ordered by followed by allproducts which are ordered only by customers which are not(now) spare. Repeat as often as necessary.
4.1 ResultsOur experiments were performed on a PC with a 2.4GHz In-tel Xenon processor, 3Gb of available main memory, runningLinux (2.4.18), with SPIN version 4.2.3.
In Table 1 below, we give results of the preprocess to findthe greatest lower bound and the first theorem to find thisbound, for the single detailed examples considered in Table4 of Appendix 1. is the greatest lower bound. Bound is the maximum number of s in a column, and bounds to correspond to Theorem 1, Corollary 1, Theorem 3, Corol-lary 3 (three-way unions), Theorem 2, Corollary 2, Corollary3 (four-way unions), Theorem 5 and Theorem 6. We decidedto not implement bound 7, as it proved to be too time con-suming. In each case an example pair is provided to constructa good initial solution using Construction 1, if such a pair ex-ists. The customer with the smaller degree is given first ineach case.
Our results for the grouped data sets are given in Tables 2and 3 of Appendix 1. Note that we only record the percentagesolved, the mean value and the average time taken to solvecompletely. The time is in seconds, and includes the timetaken to compute the best lower bound in each case. In orderto achieve better, more accurate results, the theoretical resultsachieved in this paper have been applied to a Constraint pro-gramming approach in [1], where results have been recordedmore accurately. We initially limited our search time to hour per data set. However, for some of the data sets, due totime constraints, where we were unlikely to achieve an opti-mal solution within our time limit, we have not tried to finda solution at all. In cases where we believe we could havefound optimal solutions to all instances, but did not (becausewe would have missed the submission deadline!) we havemarked all fields with a ‘T’.
In table 4 we give our results for the single, larger in-stances. In many cases we have used the construction ap-proach to find the best solution. Note that in each case, if theconstructed solution is optimal, the time, number of fails etc.both up to and including the solution is zero (no search is re-quired). In cases where the constructed solution is one more
Constraint Modelling Challenge 2005
38
File Lower bound Bound used Example pairMiller19 13 bound 4
Table 1: Best lower bounds for the larger instances
than the greatest lower bound, the time etc. up to the best so-lution is , but the time etc. to prove the optimum solution isnot. The number of fails recorded is the number of matchedstates in each case (when the search is forced to backtrack).
References[1] A. Miller, C. Unsworth and P. Prosser. A constraint
model and a reduction operator for the minimising openstacks problem. In Ian Gent and Barbara Smith, editors,Proceedings of the 4th Workshop on modelling and solv-ing problems with constraints. Held in conjunction withIJCAI’05. Edinburgh, July 2005.
[2] P. Gregory, A. Miller, and P. Prosser. Solving the re-hearsal problem with planning and with model checking.In Brahim Hnich and Toby Walsh, editors, Proceedingsof the 3rd Workshop on modelling and solving problemswith constraints. Held in conjunction with the 16th Euro-pean Conference on Artificial Intelligence (ECAI 2004).,pages 157–171, Valencia, Spain, August 2004.
[3] Gerard J. Holzmann. The logic of bugs. In Proceed-ings of the 10th ACM SIGSOFT Symposium on Founda-tions of Software Engineering (SIGSOFT’02, pages 81–87, Charleston, South Carolina, USA, November 2002.ACM Press.
Constraint Modelling Challenge 2005
39
Appendix 1
File % solved mean value mean timeproblem 10 10.dat 100 8.04 2.05problem 10 20.dat 100 8.93 2.72problem 15 15.dat 100 12.88 2.83problem 15 30.dat - - -problem 20 10.dat T T Tproblem 20 20.dat T T Tproblem 30 10.dat - - -problem 30 15.dat T T Tproblem 30 30.dat - - -problem 40 30.dat - - -ShawInstances.txt 100 13.72 10.56
SP1 Yes 9 0.375 282 277.79 1135110SP2 No 22 0 0 - -SP3 No 35 0 0 - -SP4 No 54 0 0 - -
Table 4: Times and number of fails to prove the best solution for each problem
Constraint Modelling Challenge 2005
41
Appendix 2The Promela specification for a simple model (the first example) is provided below. Note that we use a set of threedots , to indicate where code has been omitted, for space reasons.
The main process is the scheduler process, and the product order is decided non-deterministically. Note that!" is set to here. This model is used to investigate the existence of a solution with maximum stack size at most .
#define MAX 8#define no_prods 10/* prods labelled 0 to 9 */#define no_custs 10/* custs labelled 0 to 9 */
byte no_needed=9; bit STOP=0;bit prod_made[no_prods]=0;/*set to 0 if prod still not made*/
byte stacks=0; byte no_made=0;/*no of prods currently made*/
byte orders_left[no_custs]=0;/*no of prods left for each cust*//*set in init*/bit order_started[no_custs]=0;/*has custs order started*/typedef array bit prod[no_prods];hidden array orders[no_custs]=0;
prod_made[0]=1; /* don’t need this prod */run scheduler()
#define p (STOP==1)
#include "rehearsal.ltl"
Constraint Modelling Challenge 2005
43
A Constraint Model and a Reduction Operator for the Minimising Open StacksProblem
Alice Miller and Patrick Prosser and Chris UnsworthDepartment of Computing ScienceUniversity of Glasgow, Scotlandalice/pat/[email protected]
Abstract
We present two constraint models for the Minimis-ing Open Stacks Problem (MOSP). Our first modelis based on that reported in [1], and our second isa refinement and is more space efficient. We alsopresent two reduction operators for the MOSP. Onereduction operator is applied as a pre-process to re-move elements of the problem that are provably re-dundant, the second dynamically reduces the prob-lem during search. We also introduce conditionallower bounds, which are lower bounds associatedwith a partial assignment. Experiments are thenperformed using the two reduction operators, andour best constraint model using the lower boundsreported in [2] and the conditional lower bounds.
1 IntroductionThe minimising open stacks problem (MOSP) is in principalvery similar to the rehearsal problem, as described in [3]. TheMOSP is essentially a permutation problem. We are given mproducts and n customers. A customer may demand a num-ber of different products. Therefore we can think of a cus-tomer as a 0/1 vector (or row) of length m and a product asa 0/1 column, where the column has n elements correspond-ing to customers. When the first product for a customer isproduced, a stack (or a pallet) is opened for that customer,and that stack is closed when we have made the last productfor that customer. The products can be made in any order,i.e. we can permute the columns in m! ways. By permutingthe columns we can then control when customer orders areopen and closed. The goal is then to find a permutation thatminimises the number of stacks/pallets open at any time.
Below we present two constraint encodings for the MOSP.The first encoding is based on that in [1] and was imple-mented in JChoco. Our second encoding is more compact, us-ing less variables and less constraints, and allows us to modellarger problems. This model was then encoded in ILOG’sJSolver.
We also present a reduction operator. This is a pre-processing step in problem solving, i.e. the problem is pro-cessed to produce a smaller representative problem that canthen be modelled and solved. The solution to this problem
can then be inflated, in linear time, to give a solution to theoriginal problem.
2 A Constraint Programming EncodingsBelow we introduce the variables and the constraints (in ital-ics). The main aspects of the model are to 1-fill rows of a 0/1array, such that for a given row, say i, we locate the position ofthe first 1 in that row and also the last 1 in that row, and thenfill the intermediate elements with 1’s. This corresponds to acustomer order being open from the first product demandedup to and including the last product demanded.
M a two dimensional array. M[i][j] = 1 if and only if cus-tomer i requires product j. The array M is essentially anarray of constants, i.e. M is the data read in initially anddoes not change.
S a one dimensional array. If S[j] = k then product j willbe produced in time slot (column) k. That is, S gives usthe permutation of the columns. Each variable in S hasa domain 1 to m, and all the variables in S must takedifferent values.
P a one dimensional array. If P[k] = j then in time slot (col-umn) k, product j will be produced. In order to force Sand P to maintain a permutation we use the channellingconstraints S[j] = k ↔ P [k] = j.
T is the timetable, and is a two dimensional array of 0/1variables. S[j] = k → T [i][k] = M [i][j]. That is,if product j is made in time slot k (i.e. S[j] = k) andcustomer i demands product j (i.e. M[i][j]) then productj is made for customer i in time k (i.e. T[i][k] = M[i][j]).
open is a two dimensional array of 0/1 variables. If open[i][k]= 1 then something is made for customer i in time k orearlier. Consequently, a stack is open for that customerat time k and if a stack is open for customer i at time kthe stack is also open at time k+1. Therefore we havea right-rippling constraint such that open[i][k] = 1 →open[i][k + 1] = 1. This right-ripple is initiated whenT[i][k] = 1. We then have the following constraints,T [i][k] = 1 → open[i][k] = 1.
nc is also a two dimensional array of 0/1 variables. Thisarray is symmetrical to the array above, stating whena stack is not closed, and has a left-rippling constraint.If nc[i][k] = 1 then something is made for customer i
Constraint Modelling Challenge 2005
44
in time k or earlier, consequently the stack for this cus-tomer cannot be closed at time k, and neither can it beclosed at time k-1. Therefore we have the left-ripplingconstraint nc[i][k] = 1 → nc[i][k − 1] = 1. Again, theleft-ripple is kicked off when T[i][k] = 1. The constraintis then T [i][k] = 1 → nc[i][k] = 1.
Stacked is a two dimensional array, such that Stacked[i][k] is 1 ifand only if the ith customer’s order is stacked at time kand the stack has not been closed at time k. Therefore wehave the constraint Stacked[i][k] = 1 ↔ open[i][k] =1 ∧ nc[i][k] = 1.
soat is a one dimensional array of m variables with domains0 to n, such that soat[k] is the number of stacks open attime k. Therefore soat[k] is the sum of the variables inthe kth column of array Stacked. Therefore we have theconstraint soat[k] =
∑i=n−1i=0 Stacked[i][k].
cost is the objective variable to be minimised, and is themaximum of the values in the vector soat (stacks openat time). That is, we want to minimise the maximumnumber of stacks open at any time, consequently wehave the constraint maximum(cost, soat[k] : 0 ≤k < m). The maximum constraint works as follows.If the lower bound of some variable soat[k] increasesthen lwb(cost) = max(lwb(cost), lwb(soat[k])). Iflwb(cost) increases then there is no effect. If the up-per bound of some variable soat[k] decreases then wefind the variable soat[l] that has the largest upper boundand set upb(cost) = min(upb(cost), upb(soat[l])). Ifupb(cost) decreases then for all values of k (0 ≤ k <m) upb(soat[k]) = min(upb(soat[k]), upb(cost)).The maximum constraint can also be realised usingprimitive constraints. Consider the case where we have3 variables A, B, C and we constrain variable X to be themaximum of A, B, and C. This can be done as follows:X ≥ A∧X ≥ B ∧X ≥ C ∧ (X = A∨X = B ∨X =C).
The above model was coded in JChoco using the S variablesas the decisions. Variables were instantiated in the static orderS[0], S[1], S[2], ... , S[m-1]. A symmetry breaking constraintwas applied, similar to that in [1], such that S[0] < S[m-1].
A second model was also coded up in JSolver. The P vari-ables were used as decisions, and the arrays open, nc andT were not used (and consequently the ripple constraints inthose arrays were not used). To replace the 2-dimensionalarrays T, open and nc, we introduced the following one di-mensional arrays.
start a one dimensional integer array. If start[i] = kthen the first product for customer i is made intime slot k. This is maintained by the constraintminimum(start[i], S[j] : 0 ≤ j < m ∧ M [i][j] =1). The minimum constraint can be realised eitheras a n-ary constraint, similar to maximise above, or byusing primitives (also as above).
end a one dimensional integer array. If end[i] = kthen the last product for customer i is made intime slot k. This is maintained by the constraint
maximum(end[i], S[j] : 0 ≤ j < m ∧ M [i][j] =1).
The variables in the Stacked array are then maintained by theconstraint, Stacked[i][k] = 1 ↔ start[i] ≤ k ≤ end[i].This (JSolver) model is significantly more compact than theone first described (coded in JChoco) using less variables andless constraints. This allows us to model larger problems.
3 A Reduction OperatorWe now describe a reduction operator, and present a proofthat this reduction is sound. Essentially this operator is a pre-process step where we input the data for the problem and re-move from it products that have no effect on the optimal so-lution. This delivers a new representative problem that hasless columns/products than the original. This reduced prob-lem can then be solved to optimality and an optimal solutionto the original problem constructed in linear time.
3.1 Removing Subsumed ColumnsOur reduction operator removes a product p i from the prob-lem if there exists some other product pj such that all thecustomers that demand product pi also demand product pj ,i.e. we say that pi is a subset of pj . A practical example ofthis might be two products, the first a dustbin and the seconda dustbin lid. No customer demands a dustbin lid if they havenot already demanded a dustbin. We can ignore the produc-tion of the dustbin lid in constructing our schedule. We canthen re-insert the production of the dustbin lid into the sched-ule immediately after the production of the dustbin withoutaltering the cost of that schedule.
Theorem 1 Let Pn be a problem (instance) consisting of nproducts p1, p2, . . . , pn. If, for some i and j, pi ⊆ pj , P i
n−1
is the problem obtained from Pn by removing pi and sin−1
an optimal sequence for P in−1, then si
n−1(i), the sequenceformed by inserting pi after pj in si
n−1, is an optimal se-quence for Pn.
To prove the theorem, we use two lemmas:
Lemma 1 If sn−1 is a sequence corresponding to any prob-lem with n−1 products, and sn a sequence formed by addinga new product pi, then if R and R′ are the maximum numberof open stacks for sn−1 and sn respectively, R′ ≥ R.
Proof Suppose that the maximum number of stacks (R) forsn−1 is achieved when product pk is placed. All of the cus-tomers that have stacks open at that point have ordered prod-ucts before (or at) pk. Regardless of where pi is placed, this isstill true, and so the number of stacks open when pk is placedis still at least R.
Lemma 2 If sn−1 is a sequence corresponding to any prob-lem with n−1 products, and sn a sequence formed by addinga new product pi, which is a subset of some existing productpj , directly after pj , then if R and R′ are the maximum openstacks for sn−1 and sn respectively, R′ = R.
Proof We show that when pi is inserted after pj , the numberof stacks open when any product pk is placed is unchanged.
Constraint Modelling Challenge 2005
45
We also show that the number of open stacks when p i isplaced will be less than or equal to that of pj .
The number of open stacks open when pk is placed equalsthe number of orders opened on or before p k minus the num-ber or orders closed before pk. If pk is positioned before pi
then clearly these totals will be unaffected, thus the numberof open stacks will remain the same.
If pk is positioned after pi then the number of open or-ders will remain the same as all orders that require pi willalready have been opened by pj . The number of closed or-ders will also remain the same as any orders that where pre-viously closed by pj that require pi will now be closed by pi.Therefore the number of open stacks will remain the same.
Because pi will not open any new orders, the number ofopen stacks when pi is placed will be the same as pj minusthe number of orders closed at pj .
Proof of Theorem 1 Suppose that sin−1 is the optimal so-
lution of P in−1 and that R is the maximum number of open
stacks associated with sin−1. By Lemma 2, the maximum
number of open stack for sin−1(i), with pi placed directly af-
ter pj is R.If there is no solution to Pn with maximum number of open
stacks less than R then we are done. Suppose then, that thereis some solution, sn with maximum number of open stacksequal to R′ say, where R′ ≤ R. Removing pi from sn−1
will result in a sequence for P in−1 which must have maximum
number of open stacks R ′′ ≥ R since we know that R is theoptimal value for P i
n−1. But by replacing pi we must obtaina sequence with maximum number of open stacks ≥ R ′′, byLemma 1. Thus R′ ≥ R′′. So we must have R′ = R′′, whichis a contradiction as R′′ ≥ R.
3.2 Dynamic ReductionA variant of the reduction operator is used inside the searchprocess. This operator forces a product to be produced next,based on the state of the partial solution. Assume the searchprocess is free to select the next product to produce, and wehave computed the current number of open stacks. If there isan unselected product such that if selected next the numberof open stacks does not increase, then that decision is forced.Furthermore, this selection will not increase the number ofopen stacks in any subsequent time slots.
3.3 Lower BoundsA set of lower bounds is calculated for each problem, dur-ing a pre-processing stage. The first, bound0, is simply themaximum number of 1s contained in any given column ofthe input data, i.e. the maximum demand for a product. Theother bounds, together with the proof of their validity, are de-scribed in full in [2]. We summarise them below. Note that,for any customer i, deg(i) denotes the degree of i, defined asthe number of customers that order at least one of the sameproducts as i (i.e. the number of neighbours of i). Also, if nis the number of customers, d0, d1, . . . , dn−1 is a list of thedegrees of the customers in non-decreasing order. For anypair of customers i and j, i = j, we define Ri,j to be the setof neighbours of i and j, not including i or j. Similarly wedefine Ri,j,k for any set of (distinct) customers i, j and k.
bound1 = d0 + 1bound2 = maxdi + 1 − i : 0 ≤ i < nbound3 =
d0 + 2 if d1 − d0 > 00 otherwise
bound4 = max|Rx,y| + 1 : x = ybound5 = max|Rx,y,z| + 1 : x = y = z
From this set of lower bounds we choose the maximum, G.If we find a solution with cost G, we know that this must bean optimal solution.
3.4 Conditional Lower BoundsAn additional set of lower bounds are calculated which takeinto account a partial assignment. We define Da to be the setof customers that require product a. We define R i to be theset of neighbours of i. bounda is the lower bound for a partialsolution where a product a has been assigned to the first timeslot. bounda,b is the lower bound when products a and b havebeen assigned to the first two time slots.
bounda1 = max|Rx ∪ Da| + 1 : x
bounda2 = max|Rx,y ∪ Da| + 1 : x = y
bounda3 = max|Rx,y,z ∪ Da| + 1 : x = y = z
bounda = maxbounda1, bounda
2, bounda3
bounda,b1 = max|Rx ∪ Da ∪ Db| + 1 : x
bounda,b2 = max|Rx,y ∪ Da ∪ Db| + 1 : x = y
bounda,b3 = max|Rx,y,z ∪ Da ∪ Db| + 1 : x = y = z
bounda,b = maxbounda,b1 , bounda,b
2 , bounda,b3
These bounds are used by adding the following constraints.
s[1] = a → cost ≥ bounda : 1 ≤ a ≤ mcost < bounda → s[1] = a : 1 ≤ a ≤ m
s[1] = a ∧ s[2] = b →cost ≥ bounda,b : 1 ≤ a, b ≤ m ∧ a = bcost < bounda,b →
s[1] = a ∨ s[2] = b → : 1 ≤ a, b ≤ m ∧ a = b
Our current implementation has a very high cost to calcu-late these bounds. The worst of which being bounda,b, whichtakes O(n4) time. We calculate this for all a and b thereforethe total time for this is O(m2n4). Because of the limitedtime available for development our implementation is verynaive. As a result we have incorporated these bounds into themodel, but the cost to calculate the bounds has not been in-cluded in the results. We do this to show the potential benefitsof the technique without the disadvantage of our naive timerestricted code. We have not measured the time to calculate
Constraint Modelling Challenge 2005
46
these bounds but we estimate the cost for a problem of sizen = 100 m = 100 to be a few minutes. For the problemGP5 adding these bounds reduced the total time from oneand a half hours to 26 minutes, and reduced the number offails from 12324 to 3706.
4 The Experimental ModelOur experiments were performed using our second model,implemented in ILOG’s JSolver. Problems are read in andreduced, using the operator derived from Theorem 1 above.The search process uses the dynamic reduction method de-scribed in section 3.2. The optimal solution was then foundfor this representative problem and proved to be optimal (ei-ther using the greatest lower bound G discussed above, or byshowing that no solution with smaller cost exists). The ac-tual optimal solution was then reconstructed by re-insertingthe subsumed products, and this was done in linear time.
5 Work Not DoneWe have not fully explored the effectiveness of the reductionoperator. It would be interesting to measure the amount ofreduction achieved on each of the challenge problems. Wehave only done an ad-hoc study, which demonstrated that theuse of the operator invariably reduced the time taken to obtaina solution. Indeed in some cases the improvement was quitedramatic.
We have not investigated the relative performances of thevarious lower bounds, i.e. to measure which one is typicallybest. Indeed, for each of the bounds there were exampleinstances where the bound gave the greatest lower bound.It would also be possible to increase the number of lowerbounds checked. For example, extending the notation usedin bounds 4 and 5, max|Rx,y,z,w| + 1 also gives an upperbound, but is expensive to compute.
We have implemented two upper-bounds but we have notincorporated these into our model. The first upper-boundreads in the problem and takes the identity permutation as asolution and then costs that. The second upper bound greed-ily produces a solution in a “furthest-insertion” style. It wasconsidered that if the furthest-insertion upper-bound was rea-sonably good then we could use this not only as an upper-bound but also use that permutation as a static variable order-ing heuristic.
We have not systematically investigated variable or valueordering heuristics.
AcknowledgementsWe are grateful to ILOG SA for providing us with the JSolvertoolkit via an Academic Grant licence. We would like tothank Barbara and Ian for producing such an exciting chal-lenge.
References[1] P. Gregory, A. Miller, and P. Prosser. Solving the re-
hearsal problem with planning and with model checking.In Brahim Hnich and Toby Walsh, editors, Proceedingsof the Workshop on modelling and solving problems with
constraints. Held in conjunction with the 16th EuropeanConference on Artificial Intelligence (ECAI 2004)., pages157–171, Valencia, Spain, August 2004.
[2] Alice Miller. Improved lower bounds for solving the openstacks problem. In Ian Gent and Barbara Smith, editors,Proceedings of the 5th Workshop on modelling and solv-ing problems with constraints. Held in conjunction withIJCAI-05., 2005.
[3] B.M. Smith. Constraint Programming in Practice:Scheduling a Rehearsal. Technical report, APES, 2003.
Appendix of resultsOur experiments were performed on a Pentium4 2.8Ghz pro-cessor with 512 Mbytes of RAM running Microsoft WindowsXP Professional and Java2 SDK 1.4.2.6 with an increasedheap size of 512 Mbytes. Our model was coded up in ILog’sJSolver. For the experiments in Tables 1 and 2 we allowed 60seconds per instance and for Table 3 7200 seconds (2 hours)per instance. These times include model creation but do notinclude the time to compute the lower bounds. In Tables 1and 2 we give the average and max results for only those in-stances that we found and proved optimality.
Constraint Modelling Challenge 2005
47
File % solved mean value time (sec) number of failsmean median max mean median max
This short paper presents a constraint programmingapproach to the Simultaneously Open Stacks Prob-lem. It reformulates the problem as a constrainedgraph colouring problem. The algorithm is de-scribed in detail and experimental results are re-ported.
1 IntroductionAs part of the Fifth Workshop on Modelling and SolvingProblems with Constraints held during IJCAI 2005, a Mod-elling Challenge was proposed. The object of the First Con-straint Modelling Challenge is to model theSimultaneouslyOpen Stacks (SOS) problem as a constraint problem in theconstraint programming or constraint logic programming lan-guage of your choice. Quoting the organisers:
A manufacturer has a number of orders from cus-tomers to satisfy; each order is for a number of dif-ferent products, and only one product can be madeat a time. Once a customer’s order is started (i.e.the first product in the order has been made) a stackis created for that customer. When all the productsthat a customer requires have been made, the orderis sent to the customer, so that the stack is closed.Because of limited space in the production area, thenumber of stacks that are in use simultaneously i.e.the number of customer orders that are in simulta-neous production, should be minimised.
I believe the main constraint of this challenge is actuallyto find a solution approach based on constraint programming.In its original form, the problem consists of finding a permu-tation of the products (corresponding to the production order)that minimises the number of simultaneously open stacks.Every permutation is a valid candidate solution i.e. any ele-ment in the space of all permutations is feasible. Thereforewe are faced with an unconstrained optimisation problem,which is doubly bad news for constraint programmers:
• Intuition and practice agree that constraint programmingtends to perform relatively better when the problem at
∗Research conducted while the author was on sabbatical leavefrom Ecole Polytechnique de Montreal.
hand has constraints that we can exploit. Some con-straints may be harder than others to exploit well buthaving no constraint at all gives us very little leverage.
• We much prefer solving satisfaction problems over op-timisation problems. The natural approach to optimisa-tion in constraint programming even recasts the problemas a succession of satisfaction problems.
Pure local search would do well on this problem and isprobably the best line of attack, as evidenced by some of thescientific literature on the subject. Unfortunately we are con-strained to use constraint programming.
2 Problem TransformationI started out implementing a local search approach, hopingto find some role for constraint programming along the way.Then I had an idea about a transformation of the problemwhich would definitely involve constraint programming. Inthis section, I describe a transformation of the SOS probleminto aconstrained graph colouring problem.
In minimising the number of stacks used, we are in facttrying to find customers whose orders can share a stack (actu-ally the physical space taken by a stack), given an appropriatepermutation of the products. Each timec customers share,we “save”c − 1 stacks. Of course these savings can only becombined if there is a permutation of the products which isconsistent with every such saving. So which customers canpossibly share a stack? A necessary condition is that their or-ders do not have a product in common, otherwise they willeach require a stack when this product is being made. Con-sider then a graphG = (V, E) whose vertices correspondto customers and with an edge between two vertices if andonly if the corresponding orders have a product in common.Such a graph has already been defined in the literature, e.g.[1]. Any subset of customers sharing a stack must correspondto a stable set in that graph. Actually, an admissible vertexcolouring of the graph corresponds to a potential solution tothe SOS problem, where a colour stands for a stack. It is apotential solution because we must make sure that there ex-ists a permutation which separates the orders in every sharedstack. In that sense it is a constrained graph colouring prob-lem. Consider an instance withm orders andn products. Letc : V 7→ 1, 2, . . . , k represent a mapping of the vertices ofG to k colours (identified as integers). Such a mapping ef-
Constraint Modelling Challenge 2005
51
fectively partitionsV into colour classesC1, . . . , Ck. Let Pv
be the set of products required for the order correspondingto vertexv ∈ V , πp ∈ 1, 2, . . . , n represent the positionof productp in the production sequence, andρij ∈ Ci theelement of colour classCi whose rank isj on the stack (i.e.the jth one to use that physical space). We must then find ak-colouringc of G such that
c(u) 6= c(v) (u, v) ∈ E (1)
πp 6= πq 1 ≤ p < q ≤ n (2)
ρir 6= ρis 1 ≤ r < s ≤ |Ci|, 1 ≤ i ≤ k (3)
πp < πq p ∈ Pρij, q ∈ Pρij+1
,
1 ≤ j ≤ |Ci| − 1, 1 ≤ i ≤ k (4)
Equation (1) is for the standard vertex colouring requirement,(2) ensures that theπp’s represent a permutation of the prod-ucts, and (3) similarly ensures a consistent ranking of the or-ders in each colour class. It is Equation (4) that bring the con-strainedness to the colouring: for every colour class and thenevery pair of consecutively ranked orders on the stack cor-responding to that class, there is a strict ordering constraintbetween their respective products since these orders may notoverlap. This is a strong requirement that can significantlyreduce the number of feasible permutations of the products,each time a colour class is fixed.
3 An Exact AlgorithmMy exact CP algorithm solves successive constraint satisfac-tion problems, looking each time for ak-colouring ofG witha different value ofk. A colouring is only valid if it is compat-ible with at least one product permutation constrained as de-scribed above. The colouring is done one colour at a time andthe constraints on the product permutations are added gradu-ally.
In the rest of this section I go into more detail. Constraintprogramming actually comes into play in Section 3.3.
3.1 PreprocessingOften we can reduce the size of an instance by disregardingsome of the products that are dominated. Producti dominatesproductj when the set of orders requiringj is a subset of theset of orders requiringi. Given any solution to the instancewithout considering productj (and in particular any optimalsolution), we can construct a solution to the original instance(i.e. includingj) using the same number of open stacks sim-ply by insertingj immediately afteri in the production se-quence: clearly whenj is being made, every order involvedalready has an open stack from producti just before ([1]).
Once dominated products have been removed, I buildgraphG as defined in the previous section. If that graph isa clique then no two orders may share a stack so we can im-mediately conclude that the minimum number of stacks is thenumber of orders.
In the other, more interesting cases, lower and upperbounds on the number of colours necessary to colour thegraph (i.e. the number of stacks necessary) are computedonce before the start of the search. The upper bound is verysimple and corresponds to the number of orders minus one: if
the graph is not a clique then there must be a pair of verticesthat are not adjacent and the corresponding orders can eas-ily share a stack, using a production sequence which groupstheir respective products, thus separating them. There aremany lower bounds possible and I essentially follow what isdescribed in[1] but initially proposed in[2]. They suggesttaking the minimum of three values:
• the maximum number of orders per product;
• 1+ the smallest degree of a vertex inG;
• the size of a clique which is a minor ofG.
For the latter, graph minors are computed by heuristic arccontraction as described in[1]. To these, I add a fourth al-ternative: the size of a subgraph ofG which forms a clique,obtained through a simple constructive heuristic. That cliqueis actually constructed to break some symmetries during thegraph colouring phase so I use it here “for free” and experi-ments confirm that it is sometimes the best of the four.
3.2 Graph ColouringThe strategy to select the number of coloursk that we try isfairly simple. We start at the lower bound and look for a validconstrained colouring. If we prove that there is no solutionfork colours, the lower bound is set tok + 1 and we repeat theprocess with a number of colours that is half way between thecurrent number and the upper bound. If a solution is found,the upper bound is set tok and we repeat the process withk−1 colours. Otherwise we have reached a given cutoff timeand we repeat the process with a number of colours that ishalf way between the current number and the upper bound,without updating the lower bound. We stop when the lowerand upper bounds coincide, in which case we have provenoptimality, or when a global cutoff time is reached.
The actual graph colouring proceeds one colour at a timeand selects all the vertices to share that colour. It is advanta-geous to proceed in this way because as soon as a colour classis closed, we can add constraints on the product permutation(see Section 3.3). The colours are processed in lexicographicorder and so are the vertices.
In order to break some obvious symmetries, I preassignvertices in some of the colour classes and impose a lexico-graphic ordering on the rest of them. As indicated before,a simple constructive heuristic identifies a hopefully largeclique inG. Each vertex from that cliquev1, . . . , vℓ mustbelong to a distinct colour class so I can safely preassignvi
to Ci. For the remaining colour classesCℓ+1, . . . , Ck, I addconstraintsCi ≺ Ci+1, ℓ + 1 ≤ i ≤ k − 1, meaning that thesmallest index of a vertex inCi should be less than the small-est index of a vertex inCi+1. No doubt much more could bedone to break symmetries.
3.3 Product PermutationAs soon as a colour classCi is closed (i.e. all the vertices ofthat colour have been selected), we have identified the corre-sponding set of orders sharing a stack. This in turn constrainsthe space of feasible product permutations: there must existan ordering of the elements ofCi consistent with an orderingof the products which separates the orders. As each colour
Constraint Modelling Challenge 2005
52
class is closed, the number of feasible product permutationsdecreases. If that number reaches zero (i.e. the domain of aπp becomes empty), we can backtrack.
The basic CP model corresponding to (2)-(4) is:
alldifferent((πp)1≤p≤n) (5)
alldifferent((ρij)1≤j≤|Ci|−1) 1 ≤ i ≤ k (6)
πp < πq p ∈ Pρij, q ∈ Pρij+1
,
1 ≤ j ≤ |Ci| − 1,
1 ≤ i ≤ k (7)
πp ∈ 1, 2, . . . , n 1 ≤ p ≤ n (8)
ρij ∈ Ci 1 ≤ j ≤ |Ci| − 1,
1 ≤ i ≤ k (9)
I search this constrained solution space in the followingway. Constraints (5) and (8) are present from the start. When-ever a colour class is closed, sayCi, we may add constraints(6), (7), and (9) for thati. I then look for a feasible assignmentof the(ρij)1≤j≤|Ci|−1 variables (i fixed), which allows con-straints (7) to do some filtering. This assignment may needof course to be backtracked over. Only once the colouring iscomplete do I seek a feasible assignment of the(πp)1≤p≤n
variables.It is possible to tighten that model by adding implied unary
constraints. If the orders preceeding an orderv on a stack theyshare involve a total oft products and since these products aredistinct, a product involved inv must be sequenced after theset other products. The same reasoning applies for the orderssucceedingv, giving us:
j−1∑
ℓ=1
|Pρiℓ| < πp ≤ n −
|Ci|∑
ℓ=j+1
|Pρiℓ| p ∈ Pρij
,
1 ≤ j ≤ |Ci|,1 ≤ i ≤ k (10)
We could go further than these “monochrome” constraintsand add more global unary inequalities that keep track, forevery productp, of all the other products necessarily beforeor afterp in the sequence, based on the same reasoning butapplied collectively to every colour class closed so far. I havetried this but limited experimentation seems to indicate thateven though it decreases the number of backtracks required,it slows down the algorithm.
4 ResultsThe algorithm was run on all the instances provided for thechallenge. A single run was performed on each instance sincethe algorithm is deterministic and identical parameters wereused throughout (except for the cutoff time, as indicated be-low). The computer used was a Sunfire 4800 equipped with900MHz processors and 8Gb of RAM. The constraint pro-gramming library used was ILOG Solver 4.4. Because of thegreat number of instances, I had to keep the cutoff time low.Table 1 reports on the files containing multiple instances, witha cutoff time of one minute. In order to see how sensitivethese results are to the choice of the cutoff time, I also ranthe same experiments with a five minute cutoff time (Table
2). For the individual instances, which are generally larger, acutoff time of one hour was selected.
Here are a few observations. The smaller instances are allsolved to optimality but that percentage goes down as thesize increases, as should be expected. For a fixed numberof orders, the performance generally increases with the num-ber of products: this is not surprising since more productsmean fewer opportunities of sharing a stack between ordersand lower combinatorics for this algorithm. The very lowmedian values also indicate that a majority of instances arevery easily solved by the algorithm. One exception is theset “ShawInstances.txt” which appears to be more balanced.Its percentage of instances solved to optimality also climbsquickly as more time is given (from a very low 16% withinone minute to 52% within five minutes). Upon further investi-gation, the algorithm actually solves every instance of that setto optimality within twenty minutes. Many of the individualinstances are solved to optimality quickly but the algorithmalso performs poorly on some of the larger ones.
5 DiscussionIn this challenge, I aimed to design a solution approach inwhich constraint programming plays a significant role at themodeling level. I purposely directed most of my efforts tothe part that involved CP. I also generally kept it simple, nobells and whistles, to make it easier to analyse and comparethe core ideas.
One consequence of this is that the graph colouring com-ponent is very basic and there lies a potential source of im-provement. I believe much of the vast expertise in solvinggraph colouring problems could be added here and the al-gorithm’s performance would greatly benefit from it. In myopinion, this approach is interesting because it calls on a well-studied problem, graph colouring, with an extra twist that CPcan handle well.
AcknowledgementsThis research was conducted while I was on sabbatical leaveat the Cork Constraint Computation Centre (4C) and was sup-ported in part by Science Foundation Ireland. I wish to thankthe other members of 4C who participated in this challengefor stimulating discussions, comparison of results, and point-ers to relevant literature.
References[1] J. C. Becceneri, H. H. Yanasse, and N. Y. Soma. A
Method for Solving the Minimization of the MaximumNumber of Open Stacks Problem within a Cutting Pro-cess.Computers & Operations Research, 31:2315–2332,2004.
[2] H. H. Yanasse, J. C. Becceneri, and N. Y. Soma. Boundsfor a Problem of Sequencing Patterns.Pesquisa Opera-cional, 19(2):49–77, 1999.
Constraint Modelling Challenge 2005
53
File % solved mean value time (sec) number of failsmean median max mean median max
Table 3: Performance of the algorithm on individual instances given a one hour cutoff time.
Constraint Modelling Challenge 2005
56
Open Stack Minimisation by Local Searchand Reverse Dominance Reasoning
Steven PrestwichCork Constraint Computation Centre
Department of Computer Science, University College Cork, [email protected]
Abstract
Dominance reasoning can be used to add con-straints to a model, pruning the search space andimproving backtrack search. This paper proposesthe reverse approach for local search: reformula-tion to add artificial solutions that are dominatedby true solutions. On the open stack minimizationproblem this technique can super-exponentially in-crease the solution density, significantly improvinglocal search performance. However, experimentsindicate that solution density is not the only impor-tant model property.
1 IntroductionThe idea that higher solution density1 makes a problem eas-ier to solve seems natural, and is usually assumed to haveat least some effect on search performance [1; 3; 5; 11;12]. But little has been done to exploit this conjecture. Oneway to increase the solution density of a problem is to in-crease problem symmetry by reformulation, and this super-symmetry technique has been shown to improve local searchperformance [7]. Any solution to a supersymmetric model iseither a true solution to the problem, or can be transformed toone by applying a symmetry transformation.
Unfortunately supersymmetric reformulations have beenhard to find — perhaps because supersymmetry is the inverseof symmetry breaking by reformulation, which is known tobe powerful but non-trivial to apply [2]. Moreover, problemfeatures other than solution density also seem to affect searchcost, and there seems to be no agreement on what these fea-tures are. More than one CSP-to-SAT encoding (the totallyweakened and log encodings [8]) increases solution densitybut can make the problem harder to solve by local search.Nevertheless, it seems worth pursuing the idea of increasingsolution density by reformulation. Choosing a good modelcan be as important as choosing a good search algorithm, andnew modelling techniques are of interest to the CP commu-nity.
This paper extends supersymmetry to the more generalnotion of dominance. The idea is to reformulate a prob-
1Defined as the number of solutions divided by the number oftotal variable assignments.
lem in such a way that new, dominated “pseudo-solutions”are added, increasing the solution density of the model andboosting local search performance (we shall ignore backtracksearch). This might be done by simply removing or weak-ening constraints in the model. However, this must be donevery carefully: we must ensure that any pseudo-solution canbe transformed to a true solution that dominates it. As withsupersymmetry this is non-trivial, but this paper demonstratesthat it is possible and can yield good results.
2 Modelling open stack minimisationWe use the following problem as an illustration. A manufac-turer has a number of orders from customers to satisfy; eachorder is for a number of different products, and only one prod-uct can be made at a time. Once a customer’s order is starteda stack is created for that customer. When all the productsthat a customer requires have been made the order is sent tothe customer, so that the stack is closed. Because of limitedspace in the production area, the number of stacks that are inuse simultaneously should be minimized.
2.1 A matrix representationWe can model the problem as a matrix M of binary variables,in which the columns correspond to the products required bythe customers, and the rows to the customers’ orders. Matrixentry Mij = 1 if and only if customer i has ordered somequantity of product j (the quantity ordered is irrelevant). Any0 with a 1 in a column to its left, and another 1 in a columnto its right, is counted as a 1. A score is assigned to eachcolumn: its number of 1s (including 0s counted as 1s). Thescore of the matrix is the maximum of its column scores. Theproblem is to permute the columns of the matrix to minimiseits score.
2.2 An integer modelThe matrix representation can be modelled as an integer pro-gram. Suppose the matrix has R rows and C columns. As-sume that each customer orders at least one product (if notthen that customer can be removed from the problem), so thatevery row has an open order of length at least 1. In the fol-lowing, i is an integer with range 1 . . . R and j, k are integerswith range 1 . . . C. Define variables pjk such that pjk = 1denotes that product j is placed in column k. Each product
Constraint Modelling Challenge 2005
57
must be placed in exactly one column and each column mustreceive exactly one product:
∑
k
pjk = 1∑
j
pjk = 1 (1)
(These two sets of constraints imply each other.) To modelthe idea of 1s influencing 0s to their left and right, definevariables lij and rij such that lik = 1 if and only if Mik has a1 to its left, and rik = 1 if and only if Mik has a 1 to its right.We need constraints
pjk ≤ lik pjk ≤ rik (2)
where Mij = 1, and
lik ≤ li k+1 ri k+1 ≤ rik (3)
We also define variables oik such that oik = 1 denotes thatthere is an open order on row i at column k:
lik + rik ≤ 1 + oik (4)
The l, r, o variables model the fact that any 0 between two1s is counted as though it were a 1. The objective is to findconsistent values for the p, l, r, o variables while minimising
maxk
∑
i
oik
This optimisation problem can be solved as a series of con-straint satisfaction problems (CSPs) with additional linearconstraints: ∑
i
oik ≤ Ω (5)
where Ω is an integer variable. We must minimise Ω: startingwith Ω = R a feasible solution is found; R is then decre-mented and the search resumed with the same variable as-signments (to exploit any solution clustering); and so on untiltimeout occurs.
2.3 Creating new solutionsWe would like to remove or weaken some constraints in orderto create new pseudo-solutions, thus increasing the solutiondensity of the problem. But we cannot simply remove arbi-trary constraints, because solutions to the resulting problemmight not be solutions to the original problem, or they mightbe solutions with larger scores. We must do it in such a waythat any pseudo-solution can be transformed into a true solu-tion of equal or lower score: in other words pseudo-solutionsmust be dominated by true solutions.
Suppose we weaken constraints (1) to∑
k
pjk ≥ 1 (6)
Now each product may be placed in more than one positionin the sequence, and some sequence positions might receiveno products. At first sight this appears useless because so-lutions might not be permutations. However, it can be seenas a model for a generalised form of the problem: find a se-quence of sets of products such that each product appears inat least one set, and the orders are open in set k if there is aproduct required in an order in another set i that appears in aset before or after set k, or in k itself. Such a sequence is apseudo-solution for the original problem.
2.4 From pseudo-solutions to solutionsA dominating solution can be derived from a pseudo-solutionas follows. For any product that appears in more than oneset, remove all but one of its appearances. For example thepseudo-solution
(4, 4, 4, 5, , 1, 2, 3)becomes
(4, , 5, , 1, 2, 3)if we delete all but the first appearance of each product. Wenow have the same number of products as sets, and can ob-tain a permutation by moving products without violating theordering among sets. For example 5 can be moved one set tothe left to obtain
(4, 5, , , 1, 2, 3)then 1 moved two sets to the left to obtain
(4, 5, 1, , 2, 3)and finally 2 moved one set to the left to obtain the permuta-tion
(4, 5, 1, 2, 3)
2.5 Increase in optimal solution densityThe effect on the density of optimal (pseudo-)solutions canbe spectacular. Consider a problem that we shall call AN ,represented by a 2 × 2N matrix:
[00 . . .0 1 . . . 1111 . . .1 0 . . . 00
]
The column permutation shown has 1 open stack in any col-umn, and this is optimal. We may permute the left and rightcolumns separately, and reverse all columns, to obtain anotheroptimal permutation. Thus there are 2(N !)2 optimal permu-tations, and any other permutation such as
[0 . . . 0101 . . . 11 . . . 1010 . . . 0
]
has at least one column with two open stacks (because of thezeroes shown in bold). However, there are many more opti-mal pseudo-solutions. Considering only those cases in whichall (0,1)-columns are in the N left (or right) columns and all(1,0)-columns are in the N right (or left) columns, there are2(2N − 1)2N optimal pseudo-solutions. So the number ofoptimal solutions has been increased by a factor of at least
2(2N − 1)2N
N !>
2N2
NN=
2N2
2log2
NN= 2N2−N log
2N ≈ 2N2
A super-exponential increase in solution density might be ex-pected to have an effect on local search performance.
At the other extreme, for some problems there will be ex-actly the same number of solutions in both models: in otherwords the reformulation introduces no pseudo-solutions.Consider a problem we shall call BN , represented by the2N × N matrix [
UN
LN
]
Constraint Modelling Challenge 2005
58
where UN and LN are upper and lower diagonal N ×N ma-trices respectively:
UN =
111 . . . 111011 . . . 111001 . . . 111
...000 . . . 001
LN =
100 . . . 000110 . . . 000111 . . . 000
...111 . . . 111
Notice that every column has exactly (N +1) 1s and no 0 hasa 1 to the left and the right, but in any other permutation thisis no longer true. For example with B4 if we exchange themiddle two columns:
11110111001100011000110011101111
−→
11110111010100011000101011101111
then both have 6 open stacks instead of 5. So the matrix hastwo optimal solutions, each with (N + 1) open stacks: one iswith UN and LN as shown, the other is obtained by revers-ing their columns. Notice also that each column has at leastone 1 where the other has a 0 in the same row. Therefore notwo columns can be placed in the same set without increas-ing the maximum number of open stacks, and there are onlytwo optimal pseudo-solutions (corresponding to the optimalsolutions).
2.6 Discussion of the modelsWe shall refer to the original integer model as model 1, andthe new one as model 3. We shall also consider an intermedi-ate model 2 in which all sets in the pseudo-solution must benon-empty, which is obtained by replacing (1) with
∑
k
pjk ≥ 1∑
j
pjk ≥ 1 (7)
Model 2 might also have super-exponentially more solutionsthan model 1. Considering only optimal pseudo-solutionsto AN in which product 1 appears in every set, there are2(2N−1 − 1)2(N−1) of them, which is still at least O(2N2
)more than model 1 solutions.
The weakened constraints of models 2 and 3 are analogousto the removal of “at-most-one” clauses in a well-known SATencoding of CSPs [9]. This allows a CSP variable to be as-signed more than one domain value, thus creating pseudo-solutions for the CSP. This is known to improve local searchperformance (though it is not certain that increased solutiondensity is the explanation). Those pseudo-solutions are veryclosely related to CSP solutions, which can be obtained sim-ply by taking any assigned value for each CSP variable. Thepseudo-solutions of models 2 and 3 require a far less obvi-ous transformation to obtain true solutions, are less closelyrelated in terms of Hamming distance, and are dominated bytrue solutions in terms of the objective function in the openstacks problem.
100
1000
10000
100000
100
flips
N
Model 1Model 2Model 3
Figure 1: Results on the AN benchmarks
All three models have O(R2) p, l, r variables and O(RC)o variables, giving a total of O(R(R + C)). They have O(C)constraints (1) or (6) or (7) of size O(R), O(∆RC2) con-straints (2) of constant size where ∆ is the matrix density,2
O(RC) constraints (3) of constant size, O(RC) constraints(4) of constant size, and O(C) constraints (5) of size O(R),giving a total space complexity of O(RC(1 + C∆)). Forsparse matrices the space complexity is low, making the mod-els suitable for large problems in which each customer ordersa small number of products.
3 Experiments
Integer programs can be solved by local search. We use an un-published algorithm based on a recent SAT algorithm calledVW2 [6]. The new algorithm (and VW2) is related to Walk-sat variant B [4; 10], and uses a modified objective functionthat dynamically weights variables to improve search diversi-fication. In the experiments in this section the Walksat noiseparameter p is set to 0.05, the VW2 s parameter is set to 0.1,and the VW2 c parameter to 0.000001.
For the AN benchmark (with super-exponentially manyoptimal pseudo-solutions) the results are shown in Figure 1.The graph is a log-log plot so the straight lines show that thesearch effort is polynomial in N . Models 2 and 3 are indis-tinguishable, but model 1 has a steeper gradient and there-fore a higher polynomial degree. We also experimented withN = 500 and tuned the search algorithm parameters, and theresults were very similar: models 1 and 2 took tens of secondsto solve while model 3 took tens of minutes.
For the BN benchmark (with no optimal pseudo-solutions)the results are shown in Figure 2 and are quite different.Model 1 is now the best, model 2 is slightly worse, and model3 much worse. However, model 2 appears to scale better thanmodel 1 as N increases: unfortunately the crossover (if thereis one) occurs as the problems become expensive to solve.Still, these small differences might vanish under more care-ful tuning of the search algorithm. The main point about thisgraph is that model 2 scales comparably with model 1, andmuch better than model 3.
2Defined as the number of 1-entries divided by the total numberof entries.
Constraint Modelling Challenge 2005
59
100
1000
10000
100000
1e+06
10 100
flips
N
Model 1Model 2Model 3
Figure 2: Results on the BN benchmarks
4 ConclusionModel 2 emerged as the most robust in our experiments.We used unrealistic problems that were solved in polynomialtime, but in experiments on some Challenge instances model2 also gave the best results. It is hoped that the new modeland local search algorithm will perform fairly well on at leastsome of the Challenge benchmarks. However, our main aimwas to demonstrate the idea of reformulating a problem to in-crease its solution density, which generalises the technique ofsupersymmetry.
References[1] D. Clark, J. Frank, I. P. Gent, E. MacIntyre, N. Tomov,
T. Walsh. Local Search and the Number of Solutions. Sec-ond International Conference on Principles and Practicesof Constraint Programming, Lecture Notes in ComputerScience vol. 1118, Springer, 1996, pp. 119–133.
[2] I. P. Gent, J.-F. Puget. Symmetry Breaking in ConstraintProgramming. Tutorial, Tenth International Conferenceon Principles and Practice of Constraint Programming,Toronto, Canada, 2004.
[3] Y. Hanatani, T. Horiyama, K. Iwama. Density Condensa-tion of Boolean Formulas. Sixth International Conferenceon the Theory and Applications of Satisfiability Testing,Santa Margherita Ligure, Italy, 2003, pp. 126–133.
[4] D. A. McAllester, B. Selman, H. A. Kautz. Evidence forInvariants in Local Search. Fourteenth National Confer-ence on Artificial Intelligence and Ninth Innovative Appli-cations of Artificial Intelligence Conference, AAAI Press/ MIT Press, 1997, pp. 321–326.
[5] A. Parkes. Clustering at the Phase Transition. FourteenthNational Conference on Artificial Intelligence and NinthInnovative Applications of Artificial Intelligence Confer-ence AAAI Press / MIT Press, 1997, pp. 340–345.
[6] S. D. Prestwich. Random Walk With ContinuouslySmoothed Variable Weights. Eighth International Confer-ence on Theory and Applications of Satisfiability Testing,Lecture Notes in Computer Science vol. 3569, Springer,2005, pp. 203–215.
[7] S. D. Prestwich. Negative Effects of Modeling Tech-niques on Search Performance. Annals of Operations Re-
[8] S. D. Prestwich. Local Search on SAT-Encoded Colour-ing Problems. Theory and Applications of SatisfiabilityTesting, Lecture Notes in Computer Science vol. 2919,Springer, 2004, pp. 105–119.
[9] B. Selman, H. Levesque, D. Mitchell. A New Methodfor Solving Hard Satisfiability Problems. Tenth NationalConference on Artificial Intelligence, MIT Press, 1992, pp.440–446.
[10] B. Selman, H. A. Kautz, B. Cohen. Noise Strategies forImproving Local Search. Proceedings of the Twelfth Na-tional Conference on Artificial Intelligence, AAAI Press,1994, pp. 337–343.
[11] J. Singer, I. P. Gent, A. Smaill. Backbone Fragility andthe Local Search Cost Peak. Journal of Artificial Intelli-gence Research vol. 12, 2000, pp. 235–270.
[12] M. Yokoo. Why Adding More Constraints Makes aProblem Easier for Hill-climbing Algorithms: AnalyzingLandscapes of CSPs. Third International Conference onPrinciples and Practice of Constraint Programming, Lec-ture Notes in Computer Science vol. 1330, Springer-Verlag1997, pp. 356–370.
A Experimental resultsThe results shown in Table 1 were obtained on a 733 MHzPentium II. We consider only the individual instances, notthe large families of problems. We performed one run perinstance, with a threshold of 108 local moves (flips) and thefollowing algorithm parameter settings: p = 0.05, s = 0.01and c = 0.05/n where n is the number of variables in themodel. (In further experiments with more time and finer tun-ing we found a 20-solution for SP2, a 35-solution for SP3,and a 54-solution for SP4.)
Constraint Modelling Challenge 2005
60
No. of Objective valueFile runs Best Worst flips secs
A Constraint Programming Approach to the Min-Stack Problem
Paul Shaw Philippe LaborieILOG S.A., France
1 IntroductionThis paper tackles the IJCAI-05 modelling challenge usingthe constraint programming libraries Solver [ILOG, 2005b]and Scheduler [ILOG, 2005a] from ILOG. The resulting“min-stack” solver uses a combination of modelling, prop-agation algorithms and search strategies, all of which con-tribute to increased performance on the challenge instances.
2 Base modelHere, a foundation model is introduced which is sufficient tomodel the problem. Later, redundant modelling methods aredescribed which do not change the optimal solution of theproblem, but can help to solve it more quickly.
In the problem, there are n products and m customers. Theset of products demanded by customer j (an order) is denotedby Pj . The set of orders demanding product k is denoted byOk.
The problem is modelled using a constrained variable foreach manufacturing time slot. Variable pi ∈ 1 . . . n in-dicates which product is manufactured at slot i, where slotsrange from 1 to n. A dual model is also created which repre-sents the time slot of the manufacture of each product. Vari-able sk ∈ 1 . . . n indicates in which slot product k is pro-duced. These two sets of variables are maintained in consis-tency via an inverse constraint which specifies that spi
= i.An all-different constraint [Regin, 1994] is also imposed onthe variables p which increases domain filtering.
Each order has a span of activity between the first and lasttime slots involving a product demanded by the order. Vari-ables for these first and last slots are defined for order j asfj = minsk|k ∈ Pj and lj = maxsk|k ∈ Pj. Theconstraint lj ≥ fj + |Pj | − 1 is also imposed.
A Boolean variable (which will also be considered to be0 − 1) αij indicates if order j is active at time slot i via theconstraint αij = (fj ≤ i ∧ lj ≥ i). Using this, the numberof active orders (number of open stacks) αi at time slot i isgiven by αi =
∑1≤j≤m αij . Finally, the objective is to min-
imize the maximum number of open stacks (active orders)α = max1≤i≤n αi.
3 Problem simplificationsBefore even attempting to resolve a problem, certain simpli-fications can be made to it which reduce its difficulty. First
of all, any customer orders demanding no products can be re-moved. Any products which are not ordered by any customercan likewise be removed.
A further observation is that if two products are ordered byexactly the same customers, then one of the products can beremoved without affecting the value of the optimal solution.To see this, note that removing a product can never increasethe optimum. Also, for any solution not involving the re-moved product, the removed product can be inserted directlybefore or after its twin without increasing the number of openstacks.
The final observation is the most powerful, and in practicecan aid search considerably. If for two products k and l, prod-uct l is ordered by a subset of the customers of k (Ol ⊂ Ok),then product l can be removed from the problem. This can beseen in two ways. First, as above, for any solution without l,l can be inserted next to k without increasing the number ofopen stacks. Second, Ol could be modified by adding orders(which can never decrease the optimum) to make it equal toOk, then product l removed using the equality rule.
The product removal rule is effective on many instances.For example, on Simonis’s problem 10 20 instances, on av-erage 10 of the initial 20 products are removed.
4 Lower bounds
Computing a lower bound on the minimum number of openstacks can be useful in proving the optimality of a solution; ifa solution is found with a number of stacks equal to the lowerbound, search can be stopped.
Perhaps the simplest lower bound L1 is the maxi-mum number of customers demanding a product: L1 =max1≤k≤n |Ok|. A better lower bound can be found by ob-serving that if any two customer orders involve the sameproduct, the two orders must be active together in at leastone slot: that is, the orders overlap in time. An ‘order’ graphcan be constructed with a node per order and an edge be-tween two nodes when their corresponding orders share atleast one product. The chromatic number L3 of this graphforms a lower bound on the minimum number of open stacks.
Instead of colouring the order graph optimally to findbound L3, a bound L2 that is cheaper to compute is basedon finding a (large) clique in the order graph. The size of thisclique is a lower bound on L3. A greedy clique finding al-
Constraint Modelling Challenge 2005
62
gorithm is used in the solver, and the constraint α ≥ L2 isadded after finding it.
The bound L2 is indeed useful for proving optimality. Alllarge instances in gp100by100 were closed because a solutionwas found with a number of open stacks equal to the size ofthe maxiumum clique found in the order graph.
5 Redundant modellingRedundant modelling is the addition of supplementary con-straints and variables to the problem, which, although donot reduce the solution space, help the search for solutionsby making deductions (filtering domains) more effectively.Here, two redundant models are added to the original: onebased on graph colouring, and another based on resource-constrained scheduling.
5.1 Colouring modelThe previous section discussed how colouring the order graphcould be used to pre-compute a lower bound. A colouringmodel which bounds the number of open stacks can alsoincrease domain filtering during search. A colour variablecj ∈ 1 . . .m is introduced for each customer order j. Eachpair of orders i, j that overlap must be coloured differently.This is ensured by constraints of the form fi ≤ lj∧fj ≤ li ⇒ci 6= cj . (Note that when orders i and j share a product, bothsides of the implication are added directly, as the orders mustoverlap in this case.) Finally, the constraint that the number ofopen stacks is at least the number of colours used is imposed:α ≥ max1≤j≤m cj .
The colour variables are symmetric under any value per-mutation. To break this symmetry, and to colour the max-imum number of variables and thus aid domain filtering, alarge clique is found (the same one as was used in the bound-ing function L2) and coloured with colours from 1 to L2. Thispre-assignment of the colour variables is done at the start ofsearch.
The redundant colouring model is extremely useful. Forexample, when disabled, one instance in the ShawInstancessuite had to be stopped at over three million choice points,when it is normally solved in a few thousand.
5.2 Scheduling modelFrom a scheduling perspective, each order i can be seen as anactivity over the time interval [fj , lj ] that requires one unit ofa discrete capacity resource of total capacity α. The problemis then to find a solution that minimizes the maximal usageof the resource. Classical constraint-based scheduling algo-rithms available in ILOG Scheduler [ILOG, 2005a] are usedto strengthen the propagation.
Let aj denote the activity representing order j. The follow-ing constraints are imposed:• The activity aj starts at the first slot of j (start(aj) =
fj) and ends at the last slot (end(aj) = lj + 1).1 These1The additional +1 here is because in resource constrained
scheduling, activity execution intervals are normally open to theright. That is, an activity of duration 3 starting at time 1 is saidto end at time 4. The activity executes in the interval [1, 4).
constraints allow the base model and the schedulingmodel to communicate.
• Whenever two orders i and j share at least one product,it means that the two activities ai and aj have to overlapfor a duration that is at least equal to oij = |Pi ∩ Pj |.Thus, the two following temporal constraints can bestated: end(ai) ≥ start(aj) + oij and end(aj) ≥start(ai) + oij .
• Whenever two orders i and j are such that Pi ⊂ Pj itmeans activity aj covers activity ai. Thus, the two fol-lowing temporal constraints can be stated: start(ai) ≥start(aj) and end(ai) ≤ end(aj).
On this scheduling model, resource propagation is en-forced using the balance constraint. This constraint main-tains the transitive closure of a precedence graph whose nodesare the start and end time-points of activities and arcs repre-sent precedence relations. The basic idea of the algorithmis to compute, for each activity aj on the resource, a lowerbound on the resource usage at the start time of aj (symmetri-cal reasoning can be applied to perform propagation based ona lower bound on the resource usage at the completion timeof aj). Using the precedence graph a lower bound on theresource utilization at date start(aj) + ε just after the starttime of aj can be computed assuming that all the resource re-quirements that do not necessarily overlap start(aj) will notoverlap it.
Given this bound, the balance constraint is able to find deadends, to derive new bounds on activity start and end times,and to find new precedence relations that are added into theprecedence graph.
Details of the balance constraint in the more general caseof reservoir resources are available in [Laborie, 2003]. Whatis important is that the balance constraint reasons not onlyon the time-bounds of activities but also on the precedencerelations between activities. It usually allows for a strongerpruning when precedence constraints between activity time-points are fairly dense as is often the case for the challengeproblems.
6 Symmetry breakingAny solution can be mapped into another solution simply byreversing the production sequence 〈p1, . . . , pn〉. In order tobreak this evident symmetry, a product pk among the mostdemanded ones (that is, such that |Ok| is maximal) is selectedand constrained to be produced in the first half of the produc-tion sequence: sk ≤ b(n + 1)/2c.
7 Search strategiesThe master search used is essentially constructive in nature,although some local search is included (see section 7.3). Thestandard constraint programming method of finding and prov-ing an optimal solution is used, where the upper bound on thecost function is continually maintained at one less than thecost of the last solution found. Optimality is proven when thecomplete search tree has been searched. Two search strategiesare described here, one quite classic, but with some iterestingoptimizations, and one more esoteric.
Constraint Modelling Challenge 2005
63
7.1 A search strategyA natural way to search for solutions is to build up theschedule chronologically; that is, instantiate the variablesp1, . . . , pn by increasing index. This can be reasonably ef-fective, but a number of peculiarities of the problem allow itsefficiency to be significantly increased. These can be demon-strated most easily by a transformation of the problem dur-ing search. (This is a descriptive tool; in in reality, no actualtransformation takes place).
Consider that during a search, the schedule has been com-pleted from slot 1 to slot h. Let Sh = ∪1≤i≤hpi be theproducts already scheduled up to and including slot h. LetAh = j|fj ≤ h ∧ lj > h be the set of active orders justafter slot h. The remaining sub-problem (to schedule the re-mainder of the products from slot h+1 onwards) can be trans-formed into an equivalent one by creating a new problem withthe remaining products Rh = 1, . . . , n − Sh and a singlenew product, say product zh, with Ozh
= Ah. In the newtransformed sub-problem, product zh must be scheduled first.This transformation essentially melds all the products alreadyscheduled into one single product representing the active or-ders just after slot h.
There are two points to note here. First, the transformationmakes the sub-problem look like a form of the original prob-lem; the partial assignment of products has been replaced bya single product. Second, the solubility or otherwise of thesub-problem does not depend on the order of product instan-tiations made up to slot h.
The first of the above points can be exploited by recallingthe problem simplifications of section 3. If, for any productk in the new problem, Ok ⊆ Ozh
, then product k can beinserted next to product zh. What does this mean for the orig-inal search? It means that if after scheduling up to and includ-ing slot h, an unscheduled product k exists with Ok ⊆ Ah,then product k can be placed in slot h + 1 without creating achoice point.2
The second point can be exploited by cutting off searchwhen an identical sub-problem has already been encoun-tered [Focacci and Shaw, 2002; Smith, 2005]. For instance,suppose that for a given α, search has proved that thereis no feasible extension of the product assignment 〈1, 2, 3〉.Then, by the ordering rule, none exists for any permutationof 〈1, 2, 3〉. Each time the search backtracks, proving a sub-problem insoluble, the set of products scheduled up to thatpoint is recorded in a set of no-goods. Then, at each point insearch, the set of currently scheduled products is looked up inthe set of no-goods; if it is found then the search is pruned.
These two rules vastly increase the speed of the simple gen-eration scheme. However, another search strategy seems to bemore robust in practice.
7.2 A more robust searchIn the current implementation, a different strategy is usedwhich was found to be more robust than the more standard
2If more than one such product can be committed, the lowestindexed one should be placed at slot h + 1. The remainder of theseproducts will be placed in subsequent slots by re-application of therule at the next slot.
left-to-right scheduling already described. The method isbased on subdivision of the products to the left and right of theschedule, then solving these two sub-problems recursively.More precisely, to divide the products from slots l to r, amidpoint m = b(l + r)/2c is chosen. Then, for each productk for which min(sk) ≤ m ∧ max(sk) > m, a branch is madewith the choices sk ≤ m and sk > m. Once all productshave been divided, the two sub-problems from slots l to mand slots m + 1 to r are solved recursively.
The method works in practice as subdividing the productscreates two independent sub-problems; no rearragement ofthe products on the left hand side can affect the solubility orotherwise of the problem on the right. The reasons are sim-ilar to those already described for the left-to-right strategy;the two sub-problems can be independently transformed tosmaller problems involving the products in their half plus oneother product z, with Oz = Am. (Again, these new prod-ucts need to be placed at one extremity of the schedule ofthe sub-problem.) Sub-problem independence makes searchmuch more efficient as search can backtrack if any of the twosub-problems is independently insoluble.
Good decisions about how to partition the products can findgood solutions more quickly. The approach taken is to place aproduct in the side which has least products already assigned.To choose which product to assign, a calculation is made ofthe increase to |Am| that would result in placing each prod-uct at the chosen side. The product minimizing this value isplaced. On backtracking, the product is placed on the otherside.
7.3 Local improvement
Each time a new (better) solution is found, a local search islaunched using the new solution as a starting point. The localsearch technique used is Large Neighborhood Search [Shaw,1998], which is particularly adapted to constraint program-ming.
One iteration of LNS undoes the assignments of all vari-ables pk where i ≤ k ≤ j and i and j are chosen randomly in[1 . . . n]. LNS then attempts to reassign these variables usinga reduced number of open stacks. This reassignment instan-tiates the product variables by ascending slot and uses a ran-dom value (i.e. product) choice in each slot. The size of thissearch was limited to 100 backtracks. The choice points ex-plored during LNS are counted just as choice points in com-plete search, and the sum of all the choice points (from com-plete search and from LNS) is reported in the final results.
LNS continues accepting improvements until m + n itera-tions have passed without improving the current solution, atwhich point search reverts to complete (constructive) search.If a better solution was found during LNS, the new upperbound found is used to constrain the search by reducing themaximum allowed value of α.
LNS proved invaluable for solving larger instance classes,such as gp100by100, and in general helps achieve a betterupper bound earlier in the search. However, for most smallerinstances, run time increases. LNS is disabled if the problemis thought to be “easy”. In the current implementation, this iswhen n < 20.
Constraint Modelling Challenge 2005
64
8 ResultsThe solver developed closes all problems in the challengesuite except the three largest problems in class sp4. Searcheffort was measured using run time and number of choicepoints. For the results in table 2, a time limit of one hourwas set. Experiments were run on a Dell D610 Laptop with a2GHz Pentium-M processor.
9 CommentsThe time for this challenge was quite limited, and most of theideas presented in this paper have not been properly explored.We believe that the results produced here can be greatly im-proved and there is still much to investigate. For example:deriving finer dominance rules, finding lower bounds duringsearch either by colouring or other methods, deriving a goodlower bound on Am while dividing products, applying sub-problem simplification in the division strategy, and so on.
References[Focacci and Shaw, 2002] F. Focacci and P. Shaw. Prun-
ing sub-optimal search branches using local search. InProceedings of CP-AI-OR ’02, pages 181–189. Springer,2002.
[Laborie, 2003] P. Laborie. Algorithms for propagation re-source constraints in AI planning and scheduling: Exist-ing approaches and new results. Artificial Intelligence,143:151–188, 2003.
[Regin, 1994] J.-C. Regin. A filtering algorithm for con-straints of difference in CSPs. In Proceedings of the 12thAAAI, pages 362–367. AAAI Press / The MIT Press, 1994.
[Shaw, 1998] P. Shaw. Using constraint programming andlocal search methods to solve vehicle routing problems.In M. Maher and J.-F. Puget, editors, Fourth Interna-tional Conference on Principles and Practice of Con-straint Programming (CP ’98), pages 417–431. Springer-Verlag, 1998.
[Smith, 2005] B. M. Smith. Caching search states in permu-tation problems. To appear in the Proceedings of CP 2005,2005.
Constraint Modelling Challenge 2005
65
Table 1: Aggregated Result Summary% Mean Total run time (s) Choice points to optimum Total choice points
In this note we present a model for the constraintmodelling challenge 2005 based on mixed finite do-main and continuous variables implemented usingthe IC library of ECLiPSe. We are interested inproving optimality of our solutions, and thereforechoose a model which minimizes the width of thesearch tree to be explored.The model is naive in thatit does not use any deep theoretical results on pathwidth to check consistency.
1 IntroductionWe present a model for the open stack problem[Fink andVoss, 1999] posed as the first constraint modelling challenge[Gent and Smith, 2005]. Instead of just introducing the modelused for our evaluation, we try to explain the steps which ledto the selection of our method, and why we found other ap-proaches less satisfactory.
We paraphrase the problem definition from[Gent andSmith, 2005] as follows: We consider a problem withn prod-uct types andm orders. All products of the same type aremade consecutively, but we can arrange the order of the prod-uct types freely. A producti is required by orderj if the 0/1integer entrycij is equal to one. A stack for an order is re-quired (isopen) from the time the first product of the orderis made to the time the last product is made (inclusive). Theobjective is to minimize the maximal number of open stacks.
2 Basic ModelThe basic model of the problem is given by the following def-initions and constraints. LetP be the set of production timeslots, i.e.Pi denotes the time point when producti is made.Initially, we assume integer time points from1 to n. The setsof variablesS andE denote the start and finish time pointsfor the orders, i.e.Sj (Ej) is the time point when productionof orderj starts (ends). These variables also range from1 ton. For each time pointi and orderj we have a binary vari-ableOij which denotes whether orderj is open at timei. ThevariableUi denotes the number of open orders at time pointi, and the overall objective is to minimize the maximal uti-lization Limit. We also use the constantscij which indicate
whether orderj requires producti. The model is shown intable 3.
This model can be implemented easily with most finitedomain solvers, and can be combined with a search routinewhich assigns theP variables. By propagation, all other vari-ables are fixed and an optimal solution can be found by aminimize or min max branching scheme[Prestwich, 1999].
Note that constraints 11 to 14 implement a form ofcumu-lative [Aggoun and Beldiceanu, 1993] constraint, and thatthe reified constraints over theO variables perform obliga-tory part reasoning[Simoniset al., 2000]. In many constraintlanguages it would be better to use a single cumulative con-straint of the form1
cumulative(S, D, 1, E, Limit)
2.1 Redundant constraintsWe can strengthen the model by adding a simple redundantconstraint, which uses the fact that all products must be as-signed to different slots and that we know the number of prod-ucts required for each order.
∀1≤j≤m : Ej ≥ Sj + (∑
1≤i≤n
cij) − 1
This is a special case of a more generic redundant constraint,which works for all subsets of the products required for anorder, as shown in table 4. Note that we don’t have to createone constraint for each subset, it suffices to order the productsby earliest start (resp. latest end) and to count the number oftasks which are placed later (earlier), as shown in table 11.
3 Labeling ChoicesThe basic model leaves us with different possibilities on howto assign values to the variables. We explore three possiblealternatives:
3.1 Assigning slots to productsThe most common search strategy will try to fix values forthe variables (see table 8). At each step, we deterministically
1To compute utilization profiles, it is preferable to redefinetheend variables by adding one, to make them consistent with durationvariablesD.
Constraint Modelling Challenge 2005
68
choose a variable to be assigned next based on some heuris-tic, and then non-deterministically try out all possible values,until all variables are assigned. Due to thealldifferent con-straint we know that a trivial bound on the size of the searchspace isn!, we haven choices for the first variable, thenn−1for the second variable, and so on, until the last variable hasonly one value left.
3.2 Assigning products to slotsAn alternative is to assign slots to variables, e.g. to select aslot in the schedule, and then to try out all possible productsfor this slot. We can for example (table 9) assign the slots leftto right, by selecting the product for the left-most slot first(this means assigning it to value 1), then choosing a productfor the second slot, and so on. The trivial search tree sizebound again isn!, the first choice exploresn alternatives.
3.3 Partial ordering of productsA third alternative is not to instantiate the variables directly,but to partially order them by enforcing inequality constraintsbetween them. This is similar to the technique used in[Dincbaset al., 1990] to solve disjunctive scheduling prob-lems. It is also related to MIP models for this problem, whichtypically usen2 0/1 integer variables stating that one productis made before another. If we decide the order of all pairsof products consistently, we impose an order on the taskswhich instantiates the variables. Unfortunately, this searchstrategy does not mix well with the constraint model, we onlyachieve very limited constraint propagation until most tasksare ordered. We could perhaps improve the interaction byusing constraint handling rules (CHR)[Fruhwirth, 1998], butchoose not to follow that route.
4 Problems with modelThe reified constraint model does not remove all inconsistentvalues, as we will show on two examples. For both exampleswe consider 5 products, 5 orders and a limit of 4 open stacks.Table 5 shows the first instance. IfP2 is assigned to 2 andP4 assigned to 4, thenP3 can no longer be assigned to 3. Asthe stacks for ordersO4 andO5 are already open, there is noroom for the additional three stacks required by productP3.Table 6 shows a different situation. IfP2 andP3 are alreadyassigned to 2 and 3 resp., then placingP4 to 4 is no longerpossible because this would require 5 stacks at time point 3.
The problem is caused by the interaction of multiple orderswhen we fix a product to a time slot. The reified constraint(but also the cumulative formulation) ignore this interactionand therefore fail to detect the inconsistency. We can solvethese problems by implementing a stronger propagation for acombined cumulative constraint, as shown in section 5.
A more fundamental problem is the shape of the searchtree. If we use a variable assignment method, we have to pickthe first product and assign a slot to it. The choice of the slotwill be rather uninformed, and for a proof of optimality wewill have to explore all alternatives. For the second variable,we will still need to exploren−1 possible values. Unless ourestimation of the cost is very good, we will need to explorea very large search tree even if we only consider the firstk
variables. A proof of optimality by enumeration seems veryunlikely even for modest problem sizes.
The same argument holds for the slot assignment, the situ-ation is even worse in this case. We have to try all productsfor the selected slot, but many of them will be non critical.This means that the cost bound will only increase slowly, sothat we will have to explore more of the search tree.
Introducing a partial ordering between products seems tobe a good strategy. Unfortunately, we can not use the originalmodel to do this, as the added inequality constraints betweenproducts do not interact sufficiently with the other constraints.We need another model.
5 A combined cumulative global constraintDue to time limitations, we could not fully develop the con-straint, but we did build a simple variant which performs thefollowing pruning (table 12). At each invocation, we build aprofile of open orders at each time point. As starting point weuse theS andE variables. As soon as the upper bound of thestart is less or equal to the lower bound of the end variablefor an order, we know that we have an obligatory part for thisorder. We add up all obligatory parts and obtain a profile ofoverall stack usage. If the number of open stacks exceeds thecost limit, we can fail. Otherwise, we check for each unas-signed product and each value left in its domain, whether itwould fit in the space left in the profile. If this is not possiblewe prune the value from the domain. This solves the problemfrom table 5.
If the product can be placed in a given location, we thencheck how this would modify the profile. We can update theprofile by comparing the slot value considered with the startand end variables for the orders belonging to the product. Wethen check if the generated profile exceeds the cost bound, inwhich case we again can prune the value from the domain.This solves the problem of table 6.
This constraint together with the redundant constraints (16)and (17) drastically reduces the number of choices explored.Unfortunately, this is not enough to prove optimality even formedium sized instances.
6 IC ModelThe key idea for our new model is the concept of a partialorder between products. If we arrange the products in a se-quence, we can calculate the start and end times of the or-ders, and compute the number of open stacks at each timepoint. Instead of using values 1 ton for the variables, we usean arbitrary real interval as their domain. The first two vari-ables can be placed arbitrarily in the interval together withtwo sentinels at the beginning and at the end of the interval.This also eliminates the back-to-front symmetry in the prob-lem. In our assignment routine (table 10 shows a simplifiedform), we decide between which already placed products weshould place the selected product. As value we fix the middleof the interval. If the initial interval is sufficiently large, wecan always find a number between two already selected val-ues, even when using floating point arithmetic. We removethe alldifferent constraint from the model, and satisfy itscon-dition by construction of the search routine. When we have
Constraint Modelling Challenge 2005
69
obtained a solution, we can renumber the products in order oftheir assigned values to the range 1 ton.
Note that it would be very difficult to obtain this splittingbehaviour with integer domains. We would have to use a verylarge initial domain to make sure that there are enough integervalues left between any two already assigned variables to fitin all remaining variables. If we are not extremely careful,wemight loose completeness of the search method.
The new model is given in table 7. This model has beenimplemented using the IC library of the ECLiPSe[Wallaceetal., 1997][Cheadleet al., 2003] system which allows a mix ofdiscrete and continuous variables.
Note that the search tree of this model has a very nice form.The first two variables can be fixed arbitrarily, for the thirdvariable we have three possible choices, for the next one fourand so on. The tree is quite narrow at the top, but we have toexplore more choices the deeper we go in the tree. If we selectthe initial products carefully, we can hope to limit our searchto the top part, exploring relatively few choices. The cumu-lative constraint has been ported to the continuous domain,but we found that the shaving technique described below isperforming slightly more pruning.
7 Search StrategyFor our search method (called cresha (credit+shaving)), wehave to define a variable selection routine and a value order-ing. The variable selection decides which variable to assignnext, the value ordering defines the order in which differentvalues are tested during the search.
7.1 Variable selectionWe use an initial static ordering and complement this by a dy-namic selection which is computed at every step of the search.We found experimentally that the following function is quitesuccessful as a static order:
wi =∑
1≤j≤m
cij ∗1∑
1≤k≤n ckj
The contributing value of an order is inversely proportional tothe number of products that are required by the order.
As the dynamic part we evaluate at each step the minimalcost increase that would be caused by selecting a variableand placing it in the schedule. We choose the variable whichcauses the maximal increase of the cost. For ties we use the“domain size”, the number of slots where the product can beplaced.
7.2 Value orderingAs value ordering heuristic we choose the positions in orderof minimal increase of the cost function. We break ties bychecking how manyS andE variables will be updated bya given assignment value. In order to calculate these strate-gies we have to test each remaining value for each unassignedvariable at every step. We use this quite expensive operationat the same time to remove inconsistent values at each stepand to achieve a form of global forward checking. This is ashaving technique[Torres and Lopez, 2000] applied over thecomplete domain.
8 Problem ReductionWe will now discuss some additional techniques to reducethe number of nodes that need to be explored. Ideally, thesemethods would be used to create new, reduced problem in-stances with fewer variables and constraints. For this evalua-tion we did apply the reductions at runtime.
8.1 Lower Bounds
A trivial lower bound on the cost is given by the maximalnumber of orders for some product.
Limit ≥ max1≤i≤n
∑
1≤j≤m
cij
We can also obtain lower bounds by looking at subsets of theproducts and considering all permutations in which they canbe arranged. We use subsets of 3 to 5 products. Instead oftesting all such subsets, which we deem too expensive, weonly use the first 7 products according to our weight func-tion. These bounds can sometimes significantly increase thelower bound, and so help to avoid some optimality proofs byenumeration.
8.2 Preprocessing
There are a number of other preprocessing steps that can re-duce problem size significantly, so that optimality proofs be-come much simpler.
Subsumed ProductProductk is subsumed by producti if
j|1 ≤ j ≤ m ∧ ckj = 1 ⊆ j|1 ≤ j ≤ m ∧ cij = 1
We can remove the subsumed productk from the problemand schedule it directly before or after producti. It is easy tosee that this does not change the cost of the schedule.
Singleton ProductIf a product is required by a single order and that order needsno other products, then we have a singleton product. For-mally, we can define the set of singleton products as
i|∑
1≤j≤m
(cij ∗∑
1≤k≤n
ckj) = 1
We can schedule such products at the very beginning of thesequence without impact on the overall cost. This reductionseems to occur quite frequently in randomly generated prob-lems.
Problem DecompositionMore generally, the problem can be decomposed into multi-ple subproblems if the graph induced by the matrixcij sep-arates into multiple connected components[Cormenet al.,2001]. The problems can be solved independently and can becombined by piecing together the sub product sequences. Ex-periments on the problem data have shows that this occurs ona number of instances, but since these problems were easilysolved anyway, we did not implement the decomposition.
Constraint Modelling Challenge 2005
70
9 Incomplete SearchAs initially indicated in[Van Hentenryck and Carillon, 1988],it can be advantageous to consider two different search rou-tines when solving a constraint optimization problem, e.g.to provide an incomplete routine to heuristically find a goodsolution quickly, and a complete routine which explores thesearch space efficiently. We also use these two types of rou-tines, the incomplete one is based on partial search, the com-plete routine is limited by a timeout of 600 seconds.
The initial choices in our search are very important, butquite uninformed. Later in the search the insertion points areconstrained by the previously placed products and the searchis effectively guided. We use a partial search technique calledcredit-based search[Beldiceanuet al., 1997] to explore thetop of the search tree completely, while controlling the overalleffort expended. We also tried to use a constraint-based, largeneighborhood search routine to locally improve results, butcould not complete the tests in the given time frame. Theform of the neighborhood in the continuous model seems tobe very interesting for this type of local search.
10 Result tablesAll experiments were run on Linux machines with ECLiPSe5.82. The overview of the results is given in table 1. It showsthe problem set (Set) with author, strategy used, number ofproducts (Pr), number of customers (Cu) and number of in-stances (In), the percentage of instances solved to optimal-ity (Opt), information about the lower bound (LB), the num-ber of solutions found (NrS) and the best solution (Sol). Wethen show the number of assignment steps (Ass), the time(Time) and the number of backtracking steps (BT) requiredto find the best solution (Best) and to prove optimality (Opti-mal). We give the average (Avg), geometric mean (Geom),median (Median), and minimal (Min) and maximal (Max)values where appropriate. The values for optimality are com-puted from those instances for which optimality was proved(by reaching the lower bound or by exhaustive search).
The results for individual problems are shown in table 2.Values in italics show that the optimality proof timed out.Solution values in parenthesis give better solutions whichwere found with other search strategies. The time out for theGP100 and SP sets (marked by *) was increased from 600 to3600 seconds so that the search routine could find a first so-lution. Two instances in the NWRS (marked with +) set weremodified by hand to remove illegal empty rows.
11 SummaryIn this note we have presented our model for the constraintmodelling challenge. We use a mixed integer and continuousvariable model with the IC library of the ECLiPSe language.The schedule is generated by defining an order of the productson the real number axis, inserting new tasks between alreadyplaced ones. This model leads to a nice search tree whichis rather narrow at the top, allowing proofs of optimality byenumeration for medium sized problems.
2The IC library currently does not support holes in continuousdomains, we therefore had to simulate this in the user code
References[Aggoun and Beldiceanu, 1993] A. Aggoun and
N. Beldiceanu. Extending CHIP in order to solve complexscheduling and placement problems.Mathematical andComputer Modelling, pages 57–73, 1993.
[Beldiceanuet al., 1997] N. Beldiceanu, E. Bourreau,P. Chan, and D. Rivreau. Partial search strategy in CHIP.In 2nd Int. Conf. on Meta-Heuristics, 1997.
[Cheadleet al., 2003] A. M. Cheadle, W. Harvey, A. J.Sadler, J. Schimpf, K. Shen, and M. G. Wallace. ECLiPSe:An introduction. Technical Report IC-Parc-03-1, IC-Parc,Imperial College London, 2003.
[Cormenet al., 2001] T. Cormen, C. Leiserson, R. Rivest,and C. Stein. Introduction to Algorithms. MIT Press, 2edition, 2001.
[Dincbaset al., 1990] M. Dincbas, H. Simonis, and P. VanHentenryck. Solving large combinatorial problems inlogic programming.J. Log. Program., 8(1):75–93, 1990.
[Fink and Voss, 1999] A. Fink and S. Voss. Applicationsof modern heuristic search methods to pattern sequencingproblems. Computers and Operations Research, 26:17–34, 1999.
[Fruhwirth, 1998] T. Fruhwirth. Theory and practice of con-straint handling rules.Journal of Logic Programming, 37,October 1998.
[Gent and Smith, 2005] I. Gent and B. Smith. Con-straint modelling challenge 2005. http://www.dcs.st-and.ac.uk/ ipg/challenge/, 2005.
[Prestwich, 1999] S. Prestwich. Three CLP implementationsof branch-and-bound optimization. InParallelism andImplementation of Logic and Constraint Logic Program-ming, volume 2. Nova Science Publishers, Inc, 1999.
[Simoniset al., 2000] H. Simonis, A. Aggoun,N. Beldiceanu, and E. Bourreau. Complex constraint ab-straction: Global constraint visualisation. In P. Deransart,M. Hermenegildo, and J. Maluszynski, editors,Analysisand Visualization Tools for Constraint Programming,volume 1870 ofLecture Notes in Computer Science,pages 299–317. Springer, 2000.
[Torres and Lopez, 2000] P. Torres and P. Lopez. Overviewand possible extensions of shaving techniques for job-shopproblems. In2nd International Workshop on Integrationof AI and OR techniques in Constraint Programming forCombinatorial Optimization Problems (CP-AI-OR’2000),pages 181–186, March 2000.
[Van Hentenryck and Carillon, 1988] P. Van Hentenryck andJ.P. Carillon. Generality versus specificity: An experiencewith AI and OR techniques. InAAAI, pages 660–664,1988.
[Wallaceet al., 1997] M. Wallace, S. Novello, andJ. Schimpf. ECLiPSe : A platform for constraintlogic programming. ICL Systems Journal, 12(1), May1997.
Constraint Modelling Challenge 2005
71
A Results
Best OptimalK Set Opt Key LB NrS Sol Ass Time BT Ass Time BT1 hs 100.00 Avg 7.9273 1.23 8.0309 80.43 0.23 0.98 93.58 0.24 2.85
spread(E,Orders):-(foreach(Ex,E),foreach(Set,Orders) do
prep_set(Set,SetN,MinSet),sort(0,=<,MinSet,MinSorted),(foreach(V,MinSorted),for(J,SetN,1,-1),fromto(0,A,A1,BoundE) doA1 is max(A,V+J-1)
),Ex #>= BoundE
).
Table 11: Spread Redundant Constraint
cumul(Assign,S,E,Limit):-store_obligatory_parts(S,E,Obl),create_events(Obl,Events),sort(time of event,=<,Events,Sorted),build_profile(Sorted,Profile),check_resource(Profile,MaxUse),Limit #>= MaxUse,find_unassigned_vars(Assign,Unass),get_max(Limit,LimitMax),(foreach(X,Unass),param(Obl,Sorted,LimitMax) do
get_assign_domain(X,DomList),(foreach(V,DomList),param(X,Obl,Sorted,LimitMax) do
addit_events(X,V,Obl,NEvents),append(NEvents,Sorted,NAll),sort(t of event,=<,NAll,NSorted),build_profile(NSorted,NProfile),check_resource(NProfile,NUse),(NUse =< LimitMax ->
true;
remove_value(X,V))
)).
Table 12: Combined Cumulative Constraint
Constraint Modelling Challenge 2005
77
Modelling Challenge - Open Stack Problem
Radoslaw Szymanek and Mark HennessyCork Constraint Computation Centre
The Open Stack minimization problem exhibitsmany features which lead to an interesting CPmodel for study. In this short paper, we will de-scribe the main ideas behind one possible modelingapproach. The experimental results show that ourapproach can solve the Open Stack instances pro-posed for this modeling challenge. It is also able toproduce proof of optimality within a given searchcut-off limit for a large number of instances.
1 IntroductionA manufacturer has a number of orders from a customer tosatisfy; Once a customer’s order is started (i.e. any product inthe order has been made) a stack is created for that customer.When all products required by a customer have been made, itsstack is closed and the order is sent to the customer. Becauseof limited space in the production area, the number of stacksthat are in use simultaneously (i.e. the number of customerorders that are in simultaneous production), should be min-imized. This problem and possible local search approachesare presented in detail in [Fink and Voss, 1999].
Our model consists of five different viewpoints which areconnected using channeling constraints. The model alsocontains implied constraints, symmetry breaking constraints,dominance constraints and a specially designed global con-straint. For the purposes of clarity the variables in this paperare represented with a lower case letter and a single or dou-ble index while entities such as customers and products arerepresented with an upper case letter.
2 ExampleWe will use example depicted in Figure 1 to explain ourmodel. It consists of five products and four customers. Theorder matrix oij specifies what products are ordered by whichcustomers. For example, product P2 is ordered by customerC4 only. The current ordering of products makes the numberof required stacks equal to the number of customers. How-ever, if P5 is swapped with P2 then it is possible to decreasethe number of required stacks by one, which is the optimalnumber of stacks for this example.
3 Viewpoints and VariablesA graphical representation of all viewpoints is depicted inFigure 2. The first basic viewpoint looks at the positions ofproducts. The problem is described by variables pi, whichrepresent the positions of products. Knowledge about posi-tions of products is sufficient to determine the number of re-quired stacks. For our example, there are five variables p1,p2, p3, p4, and p5. Each pi variable has a domain consistingof p values, where p is the number of products.
The second viewpoint looks at the problem from a cus-tomer perspective, however it still uses pi variables. The stackfor Ci is opened at position si and is closed at position ei. Inaddition, we can introduce variable di which represents thedifference between a closing position and an opening posi-tion. Initially, the domains of all variables will have p values.
The third viewpoint considers the customer positions. Vari-able ci defines the position at which Ci is serviced. In ourexample, there are four variables c1, c2, c3, and c4. Each vari-able will initially have a domain consisting of c values, wherec is the number of customers. The positions of products andthe number of required stacks can be decided, given the posi-tions for all customers. However, in our approach we also usethe cp matrix from the next viewpoint to improve the boundon the number of stacks required given a partial solution.
1st viewpoint
cp
pp
ci
de
s
i
ii
i
pi
i
2nd viewpoint
3rd viewpoint
4th viewpoint
5th viewpoint
Figure 2: Graphical representation of different viewpoints
Figure 3: Customer precedence matrix for the example
The fourth viewpoint decides the relative positions of cus-tomer stacks. A boolean variable cpij from customer prece-dence matrix specifies if stack for Ci is not closed beforestack for Cj is opened. In our example, the optimal solutionmakes variable cp13 equal to zero since the stack for C1 isclosed before stack for C3 is open. If customers Ci and Cj
overlap then both cpij and cpji are equal one. Please note thatany customers that share products will overlap. The cp ma-trix for our example is depicted in Figure 3. This viewpointworks very well if there are many ones in the order matrix.
The fifth viewpoint looks at the relative positions of prod-ucts. A boolean variable ppij from the product precedencematrix specifies that Pi is positioned after Pj . In our exam-ple, the left solution will assign value zero to pp25 since P2 isnot positioned after P5. On the other hand, the right solutionwill assign value one to pp25 since P2 is positioned after P5.Each ppii is equal to one.
4 ConstraintsThis section presents the constraints that are required to guar-antee the correctness of solutions for different viewpoints.It does not include implied constraints nor channeling con-straints. The simplest viewpoint is the product position one.It imposes an alldifferent constraint to make all productpositions unique.
The second viewpoint requires constraints to express rela-tions between products of Ci and si, ei, and di. First, si isequal to the minimal position of any product of Ci. Second,ei is equal to the maximal position of any product of Ci. Fi-nally, di is larger or equal to the number of products of Ci
minus one.The customer position (3rd) viewpoint requires an
alldifferent constraint to enforce that each customer is po-sitioned differently. This constraint will put any two cus-tomers at different positions even if they have the same setof products.
The fourth viewpoint takes into account the precedencerelations between customers. It requires constraints whichmake sure that there is no pair of customers Ci and Cj suchthat Ci is closed before Cj and vice verse. Given any pair ofvariables cpij and cpji only one can be equal to zero.
The fifth viewpoint models problem in terms of productprecedence relations. The constraints imposed by this view-point make sure that for every pair of products Pi and Pj
variables ppij and ppji are not equal. This prevents a situa-tion when Pi is positioned after Pj and at the same time Pj ispositioned after Pi.
5 Implied ConstraintsThere are additional constraints which may improve propaga-tion within different viewpoints. For example, it is possible
to add implied constraints on si and ei variables after analy-sis of order matrix o. For any pair of customers Ci and Cj ,which require the same set of products, we can impose im-plied constraint which forces si to be equal to sj and ei beequal to ej . If Ci and Cj differ in only one product then theweaker implied constraint is imposed which enforces that si
is equal to sj or ei is equal to ej . On the other hand, if twocustomers Ci and Cj do not share any products then si has tobe different from sj and ei has to be different from ej .
We also add implied constraints which are imposed overthe customer precedence variables. For any pair of customersCi and Cj which do not share any products, if there existsa customer Cm which is in parallel to Cj and Ci is closedbefore Cm then Cj can not be closed before Ci. It is alsopossible to add different types of implied constraints for thesame viewpoint which check any triplet of customers Ci, Cj ,and Cm. If cpij = 0 and cpjm = 0 then it implies that Ci
is closed before Cm, so cpim = 0. However, the numberof constraints of this type grows quickly with the increaseof customers, which often renders those constraints of littlevalue if any. In order to reduce the size of the model we donot include these constraints in a model.
Since the second viewpoint extends the first viewpoint, thefollowing constraints should be rather called implied con-straints than channeling constraints. If si is equal to sj thenany Pm which does not belong to both customers can not beplaced at position equal to si. Similar constraints can be im-posed if we substitute s with e. However, we did not includethese implied constraints in our model since they increasedsearch time.
6 Channeling Constraints
The most important channeling constraints are the ones be-tween the fourth and the fifth viewpoint. They are expressedas reified constraints which take as input boolean variablecpij and the disjunction of constraints of type ppmv = 1,where Pm is any product of Ci and Pv is any product of Cj .In other words, it means that Ci can not be closed before Cj
if there is at least one product of Ci which is positioned laterthan any product of Cj . These channeling constraints make itpossible to reason about the precedence relationship betweenproducts implied by the customer precedence relationship andvice verse.
The channeling constraint between the first and the fifthviewpoint are expressed using a sum constraint. Variable pi
is equal to the sum of variables in ith row of pp matrix. Onthe other hand, the channeling constraints between the secondviewpoint and the fourth viewpoint are expressed as reifiedconstraints which take as arguments constraint sj ≤ ei andboolean variable cpij .
There are also single direction channeling constraintswhich are imposed to improve propagation between modelsfor different viewpoints. For example, cpij = 0 implies thatci < cj . In addition, ci < cj implies that ei ≤ ej . Onthe other hand, ei < ej implies that ci < cj . Since oneproduct can close more than one open stack, the channelingconstraints are expressed as implication constraints.
Constraint Modelling Challenge 2005
79
7 Dominance ConstraintsThere are number of possible dominance constraints whichare imposed. The dominance constraint prevents explorationof the search space which contains a wasteful solution if thereis a guarantee that there is a better or equally good solutionin different part of the search space. We refer the reader to[Prestwich and Beck, 2004] for more elaborate explanation ofdominance constraints. In the case of the Open Stack prob-lem, if for some special conditions the existence of the solu-tion with the larger size of open stacks indicates the existenceof the solution with a smaller number of open stacks thenwe can immediately cut the search space which contains thewasteful solution.
The first dominance rule imposes additional constraints onproduct positions. If the set of customers of Pi is a propersubset of the set of customers of Pj then Pi can always besafely positioned before Pj . In this case, constraint ppij = 0is imposed. In our example, P3 would have a smaller posi-tion than P4. We have not included this dominance rule inour model since we are not certain that it does not conflictwith other dominance rules. In addition, these constraintsprolonged search on instances we have tested.
The second dominance rule imposes additional constraintson customer positions. If the set of products of Ci is a propersubset of the set of products of Cj then Ci is positioned earlierthan Cj . It is expressed using constraints ci < cj . In ourexample, this dominance rule will position C1 before C2.
The third dominance rule is based on the customer neigh-borhood. The neighborhood of Ci is defined as the set ofcustomers for which a variable from the ith row of the cp ma-trix equals one. That is, Ci has a neighbor Cm if cpim = 1.If there is a pair of customers Ci and Cj such that for allk, cpik ≤ cpjk and there is a Cm for which cpim < cpjm
then Ci is positioned earlier than Cj . In other words, Ci ispositioned before Cj if the neighborhood of Ci is a propersubset of the neighborhood of Cj . For efficiency reasons, aconstraint to discover this dominance rule is imposed only forpairs of Ci and Cj where there exists a Cm, such that cpim isnot fixed and cpjm = 1 before search.
8 Symmetry breakingThe products of the first customer can be ordered in any way.They could be assigned based on lexicographical ordering ofthe products. The symmetry breaking will choose one possi-ble ordering and enforce it. However, this symmetry breakingcan sometimes conflict with a product dominance rule, whichis explained in section 10.
The first three dominance constraints are not imposed incase when sets under consideration are the same. However, insuch case we could apply symmetry breaking and still imposedominance like constraints but only for pairs when i < jgiven Ci and Cj or Pi and Pj . In other words, dominanceconstraints could be strengthen by removing requirement forproper subset if i < j. Applying similar approach to the thirddominance rule is of little practical use since constraints todetect and enforce this dominance rule are expensive in termsof time and memory. We observed the increase of the searchtime when we included symmetry breaking to strengthen thethird dominance rule.
9 Special global constraintWe implemented special global constraint to obtain betterlower-bound estimate given partial solution. It involves cp,c and limit variable which denotes the maximal number ofopen stacks. We do do not describe the consistency algorithmin full detailed. Due to space limitation a non incrementalversion of the algorithm was presented in Algorithm 1. Thisalgorithm presents reasoning for the minimal number of openstacks based on cp and c matrix only.
Algorithmus 1 Consistency function for the proposed globalconstraint
1: for i = 0 to c do2: lastPosition[i] = 0; minNeighbors[i] = 0;3: for j = 0 to c do4: if cpji.min() = 0 then5: lastPosition[i]++;6: end if7: if cpij .min() = 1 then8: minNeighbors[i]++;9: end if
10: end for11: end for12: open[i] - boolean value, initially false since Ci’th cus-
tomer is not open13: for i = 0 to c do14: i - currently considered position15: for j = 0 to c do16: if lastPosition[j] ≤ i then17: open[j] = true; Cj becomes open since already
its last possible position is analyzed18: end if19: end for20: lowerbound = - i + 1; number of closed customers21: if only Cm can be placed at position i then22: for j = 0 to c do23: if cpmj.min() = 1 then24: open[j] = true; Cm opens Cj25: end if26: end for27: else28: compute the minimal additional open customers
(minAdd) given possible customers at position i29: lowerbound = lowerbound + minAdd;30: end if31: for j = 0 to c do32: if open[j] = true then33: lowerbound++;34: end if35: end for36: if lowerbound < minNeighbors[i]-i then37: lowerbound = minNeighbors[i] - i;38: end if39: use lowerbound to update number of open stacks40: end for
The lines from 1 to 11 compute the last possible positionat which Ci can be opened and the minimal number of cus-tomers open if Ci is open. Given Ci the number of zero’s
Constraint Modelling Challenge 2005
80
in the ith column of the cp matrix gives the latest possibleposition at which Ci is opened. On the other hand, the num-ber of ones in the ith row specifies the number of customerswhich are (were) open if Ci is open. The main loop, whichstarts at line 13, computes the lowerbound of required stackstaking into account every position separately. The for loop inlines 15 to 19 opens a customer if its last possible open po-sition is equal to current position i. If it is known that Cm
takes position i then mth row of cp matrix is used to updateopen array. If it is not known which customer takes positioni then all candidates are examined and the candidate whichwill open the smallest number of customers is used to com-pute the lowerbound. Line 20 initiates the lowerbound withvalue i − 1 since this reflects the number of customers whichare already closed at position i. The lines 32 to 35 simplycount the number of previously or currently open customersat position i. The lowerbound for number of openstacks canprune the domain of openstack variable or detect inconsis-tency when partial solution exceeds the number of allowedopen stacks.
10 Model discussionThe complexity of the model depends on the number of cus-tomers and number of products. The number of variablesand constraints grow quadratically with the number of cus-tomers and products. The model uses many different view-points therefore channeling constraints are a significant partof the model. The third and fourth viewpoint require c2 andp2 variables respectively. However, those variables are re-quired to reason directly about the precedence constraints oc-curring in the partial solution. The model uses few globalconstraints, like alldifferent and the special global constraintwhich is presented in section 9. They help to improve the rea-soning, especially in the case when proving the optimality ofthe solution. The dominance rules can make some instanceseasy to prove since they indicate the search space which canbe omitted. The model uses also some symmetry breaking tocomplement the dominance rules.
While it is often beneficial to add dominance and symme-try breaking constraints to a model, in the case of the openstack problem there can be a conflict between product dom-inance constraints and symmetry breaking for the productsof the first customer. Consider only products P3 and P4 andonly customers C3 and C4 from the example. The customerdominance rule will enforce that c4 < c3. The product dom-inance rule will enforce that p3 < p4. Finally, the symmetrybreaking for the products of the first customer enforce thatp4 = 1 since it is the product of C4, which is the first cus-tomer. Clearly, we can not have all three techniques appliedat the same time. The decision which technique should bediscarded is instance dependent. In our case, due to time lim-itations we decided to discard the symmetry breaking as itapplies only to products of the first customer which can po-tentially have an impact.
11 SearchThe search approach is based on standard variable and valueordering heuristic. The variable ordering heuristic uses for-ward min domain as the first criteria and forward degree as
the second criteria. The ties are resolved based on lexico-graphical ordering. The search variables consists of variablesfrom cp matrix, p variables, s variables, and finally e vari-ables in such order. In addition variables within cp matrix areordered. The rows of the cp matrix that contain more unfixedvariables are considered first. Please note that search does notuse c variables as the position of the customer is decided bythe cp matrix. Similarly, the pp matrix is not included sincep variables denote the product positions. The c and pp vari-ables are only used to improve the reasoning and discover in-consistent partial solutions faster. The value ordering choosesalways the minimal possible value within a variable domain.This value ordering will first choose the value zero for anyprecedence variable, which prefers the situation when a cus-tomer is closed before another one is open. This often leadsto good quality first solution. In order to be certain that ourglobal constraint is complete, we run additional search withall variables.
12 Experimental setupWe measure the search effort in time and number of back-tracks. We use JaCoP solver [Kuchcinski, 2003], which weaugmented with additional global constraint. The experimen-tal results are presented in the appendix using the suggesteddata format.
13 Conclusions and Future WorkThe presented model for the open stack problem uses manymodeling techniques. It models the problem using multipleviewpoints, channeling constraints, dominance constraints,implied constraints, symmetry breaking, and a specially de-signed global constraint. Future work will evaluate the in-fluence of the particular model components on search. Forexample, the removal of the second viewpoint could reducesearch time on average. The choice between conflicting dom-inance rules and symmetry breaking constraints can be doneon a instance basis. In addition, different search algorithmsbased on instance characteristics could be proposed.
AcknowledgmentsWe would like to thank Nic Wilson for interesting discus-sions.
References[Fink and Voss, 1999] A. Fink and S. Voss. Applications
of modern heuristic search methods to pattern sequencingproblems. Computers and Operations Research, 26:17–34, 1999.
[Kuchcinski, 2003] K. Kuchcinski. Constraints-drivenscheduling and resource assignment. ACM Transactionson Design Automation of Electronic Systems (TODAES),8(3):355–383, July 2003.
[Prestwich and Beck, 2004] Steven Prestwich and J. Christo-pher Beck. Exploiting dominance in three symmetricproblems. In Proc. 4th Int. Workshop on Symmetry & Con-straint Satisfaction Problems, 2004.
Constraint Modelling Challenge 2005
81
File proven best time to best backtracks to best time to backtracks tooptimal value solution solution prove prove
SP1 No 11 96.0 21577 - -SP2 No 22 13.6 287 - -SP3 No 51 67.5 317 - -SP4 No 71 486.35 521 - -
Table 1: Times and number of backtracks to prove the optimal solution for each problem
In order to measure the time to find an optimal solution, the solver is given a lowerbound which corresponds to the optimalsolution. This allows the solver to start backtracking to the first search node immediately after finding the solution with optimalvalue. In other words, we have a two-pass experimental setup. The first time we look for an optimal solution with proof ofoptimality within a given limit of the search effort. The second time we use the cost of the optimal solution to set the lowerboundand measure the time required to find an optimal solution. The values for last three columns of Table 2 are computed only forinstances which were proven optimal. We have set the cut-off limit to 100.000 backtracks. The runtimes specify the amount ofCPU seconds as given by a time command from Linux. Due to a tight submission deadline we were not able to obtain resultsfor files wbo 30 15, wbo 30 30, wbop 30 30, and wbp 30 30.
Constraint Modelling Challenge 2005
82
File % mean time (sec) # backtracks # backtrackssolved value to find optimal per instance
This article is about modelling and solving issuesfor a Pattern Sequencing Problem, proposed as theFirst Constraint Modelling Challenge. PSP-SOSis difficult in that relevant information is not self-contained in the variables’ values. A first model,still global but less global, so to say, is proposed. Aderived second model, more precisely dedicated tolocal search methods, is then implemented with theAdaptive Search meta-heuristic.
1 IntroductionThis paper intends to describe an entry to the First ConstraintModelling Challenge. The goal is to model and solve, withconstraint programming techniques, a particular Pattern Se-quencing Problem. PSP consist in finding a permutation ofsome production patterns, optimizing some objective func-tions dealing with store-house’s size or handling costs. Theparticular PSP of the challenge is known as the simultane-ously open stack problem, or PSP-SOS, as stated in[Finkand Voss, 1999]. An expression of PSPs as graph pathwidthproblems can be found in[Linhares and Yanasse, 2002].
Let us recall the problem briefly and introduce our nota-tions, see also figure 1. A delivery service has to satisfy thedemands ofn customersc1...cn. Each of them has ordered aparticular subset of some productsp1...pm. We will write si
the order of customeri, si ⊂ p1...pm. The goal is to findthe order in which the products should be delivered.
Suppose that the products are ranked by a permutationσ: itgives a schedule where productpσ(1) is the first one delivered,and so on. Most of our notations will depend on the orderσso we will not write it. Letsti (respfti) be the starting time(resp finishing) of customerci in the scheduleσ. The deliveryservice uses a stack per customer: this stack is closed beforesti, open fromsti to fti, and closed again afterfti.
The goal is to minimize the maximum number of simulta-neously opened stacks, in order to realize the schedule in thesmallest storehouse as possible. With our notations, this canbe written as:
minimizeσf(σ)
wheref(σ) = max1≤j≤m ♯i ≤ n, sti ≤ σ(j) ≤ fti
Products in order σ
Custo
mers
line 4 = order of customer c4
2 4 5 4 2 number of open stacks at each time max=5
st4=2 ft4=5
1 0 0 1 00 1 0 1 01 0 1 0 00 1 0 0 10 0 1 0 1
Figure 1: An example of theProb matrix, with the stacksshown in grey and the number of open stacks for every timeunit given at the bottom.
A convenient solution for representing the problem, cho-sen by the Challenge organizers as their instances’ format,isto use a matrix of sizen × m, where thei-th row, j-th col-umn contains a1 if customerci has ordered productpj , and0otherwise. In the following, we will write this matrixProb.Line Probi represents the order of customerci.
2 Modelling the PSP-SOS as a ConstraintSatisfaction Problem
We will discuss in this section some of the issues whenmodelling PSP-SOS. The goal is to find a model that canbe expressed in an existing Constraint Programming Lan-guage, then solve it with a classical solver. Several lan-guages and generic solvers exist nowadays, like the Prologfamily with for instance GNU-Prolog with constraints[Diazand Codognet, 2001], CHIP[Aggoun and Beldiceanu, 1991],Localizer and Localizer++[Michel and Hentenryck, 2001],just to name a few. Their pros and cons in terms of expressiv-ity, efficiency or genericity could be discussed for hours.
Let us very briefly recall that a distinction is made betweenthe complete methods, able of giving a proof of optimality,and the incomplete ones which have been proved very effi-cient in practice, but are unable to prove optimality.
Whatever language and solver are chosen, PSP-SOS hassome features which make it challenging to program. Mainly,
Constraint Modelling Challenge 2005
84
it gives an objective function to minimize that is expressedasa maximum on some of the problem’s data. Moreover, thevariables are either subsets ofp1...pm or sequences of0and1 in the matrix model, anyway the cost not only dependon their values, but on their values within the configuration:a 0 in a column can mean that the stack is closed, or open,depending on the before and after values. So to say, the prob-lem structure is such that the relevant information is not self-contained.
This appears as a major issue for solving PSP-SOS. Withcomplete method, filtering techniques are very efficient whenapplied locally. Here we have the analoguous of a global con-straint and they are well known to be difficult to deal with.With incomplete methods, it leads to other issues that will bediscussed below.
2.1 Intrinsic issues of the PSP-SOSAs a first point, an obvious remark is that PSP problems are amatter of finding an order on the products. A model will any-how have to include an alldifferent constraint on thepj . Thusa reasonnable choice is to state the maximum open stacksproblem as a permutation problem on the productsp1...pm.Then, a possibility would be to keep the model with a per-mutation CSP on theProb matrix columns, andf as objec-tive function. Anyway, it is worth focusing on the problem’sstructure to understand better how this objective functionbe-haves on the search space.
The second point concerns the customers. Unlikely tomany optimization problems, the PSP-SOS objective func-tion ranges over a very small domain of values. The only wayto decrease it, is to tear apart two customers in the schedule.Intuitively, thinking about the stacks: the goal is to minimizethe number of stacks needed to satisfy the customers’ orders,which does well mean that the delivery service wants to re-use as many stacks as possible. The more stacks are re-used,the more likely we are to have a schedule with a minimumnumber of SOSs.
In the orderσ, we will write ci1 ≪ ci2 ↔ ∀α ∈ si1 , ∀β ∈si2 , σ(α) < σ(β), that is, customerci1 has been fully servedbefore customerci2 begins to be served. In that case they canshare a stack and the objective function may decrease of1,depending on whether those two customers where situated onthe columns realizing the maximum or not.
Intuitively, the range ofg may be greater than the range off but they behave in the same way. See example on figure 2.Think of an elementary step fromσ to σ′, g(σ) > g(σ′) →f(σ) ≤ f(σ′) if g decreases,f may increase or not depend-ing on the position whereg decreases w.r.t. the maximum.Conversely,f(σ) < f(σ′) → g(σ) > g(σ′), except in rarecases. Now our goal will be to maximizeg.
As a third point, we observe that, whatever the scheduleσ, it is not possible to tear apart two customers who share atleast one product. Such two customers can obviously nevershare a stack and from a resolution point of view, we had bestnot wasting any search effort on this couple. So it shall beusefull to include this knowledge on the problem’s structurein the model.
For this we define the relationSep on the customers in or-der to distinguish the customers’ couple for which we may be
Column realizing the maximum
abc
Figure 2: On this example, only the open stacks in the currentschedule are represented. Pairs of stacks(a, b) and(c, b) docount inf as they are separated by the column, or time, real-izing the maximum off . Pair of stacks(a, c) do count ingbut not inf .
able to decrease the objective function (separable customers),from the ones for which we will certainly not (unseparableones):
Sep(ci1 , ci2) ↔ ∀α ∈ si1 , ∀β ∈ si2 , α 6= β
With the matrix representation, one hasSep(ci1 , ci2) ↔Probi1 Probi2 = 0, that is, the scalar product of the two linesis equal to zero. This can be pre-computed once and for alland accessed in constant time, let us writeSep the resultingn × n boolean matrix.
All those remarks lead to the following model: find a per-mutationσ on the productsp1...pm, such that:
Or, writing it without all our notations and without con-straints instead of errors:
• Variables Productsp1...pm
• DomainsPermutations of thepis
• External data Orders of the customers, that is a set ofnsubsets of thepis,s1...sn
From which we compute theSep matrix: Sep(j1, j2) =(sj1 ∩ sj2 = ∅)
• Constraints For all j1, j2 ≤ n, if Sep(j1, j2) then state
∃ǫ ∈ <, >, ∀α ∈ si1 , ∀β ∈ si1 , αǫβ
At that time, we havem variables, a domain of sizen!(which is equivalent as before), and a number of constraintsdepending on the customers’ orders, of ordern2, but less thanbefore. Each constraint is a disjunction of conjonctions ofin-equalities (when explicitely written). At least, we have got ridof the starting times and finishing times which where partlyresponsible of the problem’s difficulty. Of course, it stillhasglobal constraints, and has probably no solution in general,but that will be handled by an incomplete method.
2.2 Issues of PSP-SOS w.r.t. an incomplete methodIncomplete methods have been introduced a few decades ago.They aim at either solve a constraint satisfaction problem orCSP (such as famous SAT[Selmanet al., 1992]), or find
Constraint Modelling Challenge 2005
85
good solutions to optimization problems. Among them, lo-cal search techniques consists, roughly speaking, in choos-ing randomly an assignment of domain’s values to the vari-ables, explore a neighbourhood of this configuration, tryingto improve an error (penalty, cost) function, eventually per-form a move and iterate. Meta-heuristics such as Tabu Search[Glover and Laguna, 1997] are added to prevent being stuckin local minima of the error function. This error function ischosen so that it expresses in some way the proximity to asolution, usually by taking the number of violated constraintsin the case of a CSP, or the function to optimize in an opti-mization problem.
Using an local search method for the PSP-SOS problemmay seem both natural and quite challenging. It is naturalbecause local search methods usually deal easily with permu-tation problems (or problems with an alldifferent constrainton all them variables, and all the variables have the samedomain, of sizem). They start with a permutation on thedomain’s values, and move by swaping two values. This en-sures that the alldifferent constraint is kept satisfied withoutany effort during the search process. We have chosen to usea local search method for both their well-known efficiencyon optimization problems, and this ability of dealing with thepermutations problems.
The challenging part comes from the error function todefine. Obviously, the real objective functionf , given asthe maximum of simultaneously open stacks, is not accurateenough. It is worth detailing why: the current configurationisvery likely to be realized not only for one column, but several.Then the only way of improving the objective function wouldbe to modify all these columns, except in very particular localcases1.
Improvingf thus cannot be done in one move (swap of thevariables’ values), except if a move is defined as the swapsof several variables but there are two reasons for not tryingthis: firstly, the neighbourhood would be rather big w.r.t. thesearch space size, probably resulting in bad performances.Secondly, the goal of the challenge is not to design a dedi-cated algorithm for solving the PSP-SOS but to use existingconstraint programming techniques to solve it, and perform-ing such unusual moves would not play fair, in our opinion.To simply check, we have tried such an objective functionwith a local search method where a move consists in a swap,and it cycled as expected.
So, one issue in defining the error function is to find a wayto express the value of the current configuration more accu-rately than byf . From the above discussion, we will take theg function, that is, the errors w.r.t. the above constraints.In-deed,g has a range greater thanf , resulting in moves that donot decrease the real cost of the current configuration. Thisshould not be a problem for a local search method: all thecontrary, the idea is to guide the search more precisely, al-lowing moves staying on the same value forf , but intuitivelyimproving the chances to find a better configuration. We thuswill base our error function ong.
1when there is only one variable realizing the maximum. But thiswill not happen twice in a row, or the problem is trivial
3 Solving PSP-SOS with adaptive searchAdaptive Search is a local search method introduced in[Codognet, 2000]. Although being a mere local searchmethod, it includes ideas close to greedy algorithms in theway it defines the neighbourhood exploration. The main ideais to rely on a projection of the error function on the variables.Within the current configuration, the values of the differentvariables are probably not the same: some variables may beclose to satisfy the constraints, while other ones may be re-sponsible for a big part of the whole error (think about thequeens which attacks the most of the other queens in then-queens problem, for instance). The idea is to select one ofthese bad variables for the next move. The configuration’sneighbourhood is the domain of this particular variable. Itisexplored trying to minimize the error function (the main one,because of course we do still want to improve this error onnot only the ones on the variables). It can happen that mov-ing the selected variable does not enable to decrease the errorfunction. In order to avoid cycling, a tabu-like memory isadded to mark those variables for a certain number of itera-tions. A Tabu solving method for PSPs is also given in[Finkand Voss, 1999], but with a very different coding (as a graphin instanciation).
The adaptive search method has been implemented for per-mutation problems by D. Diaz and P. Codognet as an open-source C library, available online2. Details can be found in[Codognet and Diaz, 2001], which shows that the method isvery efficient on classical benchmarks. The library includesall of the functions to solve a CSP by adaptive search, pro-vided the user defines the error functions corresponding tohis problem, both for the whole configuration and for the vari-ables. Actually, the first one can be deduced from the secondone in a way we describe below.
3.1 Writing the model in adaptive searchNow the question is to compute the error at the variable level,corresponding to the model described above where we havediscarded the inseparables couples of customers. Countingthe error corresponding to a customer is straightforward: justtake the number of other customers, separable with him, andnot separated. Question is, how to project this on a productj0? In particular, should we count all the open stacks at instantj0 ? For the rows having a1, obviously yes: swaping thecolumn may improve the cost. For the other ones, the rowsbeing open at instantj0 but not effective, it would introduce abias in the model, because swaping the column cannot resultin an improvement ofg, at least on this row (maybe in thewhole configuration, but this is not the point). So we take thefollowing error for columnj0:
e(j0) =∑
1≤i≤n
[Probi,j0 = 1] ♯1 ≤ i ≤ n, Sep(i, i′)
with [P ] = 1 if predicateP is true,0 otherwise.Concerning the error function for the whole configuration,
the adaptive search method suggests to aggregate the vari-ables’ error with an appropriate operator, coherent with the
2at http://pauillac.inria.fr/˜diaz/adaptive/
Constraint Modelling Challenge 2005
86
problem, such as addition or maximum. As we have madeenough efforts to get rid of the poor information given by themaximum, this one is rejected. Although it would not giveback thef function, a risk still arises that a single swap maynot improve the global error function. The addition is thus abetter choice, keeping the accuracy of the model. The errorfunction is:
∑1≤j≤m e(j). It is easily checked that this er-
ror function corresponds to the model described above with amin-conflict way of counting.
At that point the reader may have the impression that wesimply have replaced the maximum by the addition in the ob-jective functionf , which is not such a big deal. This belongedto the possilibities that we initially studied in order to have amore accurate objective function: counting the bad zeros inthe matrix (those within an open stack), couting the wholenumber of open stacks, etc. None of them has been kept,because the crucial property for the model to have the sameoptima asf would not have been satisfied. Counter examplesare easily found.
3.2 Experiments and results
We have implemented the model and error functions de-scribed above in the adaptive search library. A major draw-back of this implementation is the fact that the errors are notcomputed incrementally, although the library leaves the pos-sibility to do it. It would probably improve the calculationtime. But it does not affect the number of iterations which ismaybe a more neutral measure of the implementation’s effi-ciency.
Experiments have been conducted on the set of instancesproposed by the Challenge organization and the table of re-sults is given in appendix A. A classical issue with the localsearch methods is the parameter tuning. We have chosen amaximal tabu tenure to try and force good minimas, and amaximal percentage of resets variables to ensure diversifica-tion. The maximum number of iterations has been chosen big(as an order of hunders×m), which leads to a calculationtime of a few minutes per instance. More details on technicalissues is to be found in appendix A and code in appendix B.
Let us precise the complexity of the computation of thedifferent functions. We count the number of arrays’ accesses,the number of operations being of the same order. For eachiteration, are computed:
• Error on them variables:m for the computation of thesti andfti, m × n2 for the errors. That is,O(m × n2)
• Error on the solution: same
• Computation of the effective error (w.r.t.f ): O(n × m)
• Updates after a swap:O(n × m) for storing the bestsolution found so far (computation of its effective error).
In the end, the complexity of an iteration is inO(m × n2),which is reasonnable.
Finally, the comparison with other solving methods canhardly be made in this paper, as there is by now few litter-ature on the PSP-SOS and will probably be far more after theChallenge.
4 ConclusionThe maximum open stack definitely appears to be a challeng-ing problem for the constraint community, as a model shallpresent some features known to be difficult for constraint pro-gramming, close the global constraint problems.
We have given a model for representing the maximum openstack problem, and solved it with a local search method. Thestrength of the model relies on two properties: firstly, it takesinto account the inner structure of the problem by focusingon relevant information. Secondly, it modifies the objectivefunction in order to measure more accurately the value of aconfiguration.
AcknowledgmentThank you to Marc Christie, LINA, for his help.
References[Aggoun and Beldiceanu, 1991] Abderrahmane Aggoun and
Nicolas Beldiceanu. Overview of the chip compiler sys-tem. Proceedings of ICLP91, pages 775–789, 1991.
[Codognet and Diaz, 2001] Philippe Codognet and DanielDiaz. Yet another local search method for constraint solv-ing. LNCS 2246, SAGA 2001, first Symposium on Stochas-tic Algorithms : Foundations and Applications, 2001.
[Codognet, 2000] Philippe Codognet. Adaptive search, pre-liminary results.BOOK of the 4th ERCIM/CompulogNetWorkshop, 2000.
[Diaz and Codognet, 2001] Daniel Diaz and PhilippeCodognet. Design and implementation of the gnu prologsystem. Journal of Functional and Logic Programming,6, 2001.
[Fink and Voss, 1999] Andreas Fink and Stefan Voss. Appli-cations of modern heuristic search methods to pattern se-quencing problems.Computers and Operations Research,26:17–34, 1999.
[Glover and Laguna, 1997] F. Glover and M. Laguna.TabuSearch. Kluwer Academic Publishers, 1997.
[Linhares and Yanasse, 2002] Alexandre Linhares and Hara-cio Hideki Yanasse. Connections between cutting-patternsequencing, vlsi design and flexible machines.Computersand Operations Research, 29:1759–1772, 2002.
[Michel and Hentenryck, 2001] L. Michel and P. Van Hen-tenryck. Localizer++: An open library for local search.Technical Report, CS-01-03, Brown University, 2001.
[Selmanet al., 1992] Bart Selman, Hector Levesque, andDavid Mitchell. A new method for solving hard satisfi-ability problems.AAAI’92, pages 440–446, 1992.
We use the adaptive search C library proposed by Diaz and Codognet under public licence, available online athttp://pauillac.inria.fr/˜diaz/adaptive/ . The detailed code of our implementation is given in the nextappendix B. We do not have modified the solver, except for a minor part to add some time measurements for the benches.The total code (our implementation plus this slightly modified adaptive search library) is sent to the Challenge Organizationseparately. Experiments have been conducted on an Intel Pentium 4 at 2,66 GHz with 512 Mb RAM. The compiler is gccversion 3.3.4.
The percentage of proved optimality is zero for all instances, due to the incomplete method we use. We thus leave the columnblank.
As we use a local search method, we define the search effort as the number of iterations. We recall from the paper that thecomplexity order for one iteration isO(m × n2), wherem is the number of products andn the number of customers. Thecutoff limit we chose is defined as a maximal number of iterations depending onm, which explains why the next to last columnis quasi-constant for instances of same size.
The solver has been used with the following parameters. We only detail the most important ones, please refer to the codeand the adaptive search documentation for more details. We did not spend too much time in parameter tuning, in particulardidnot try and benefit from the plateau’s heuristic from adaptive search. It is possible that the results could be improved intermsof calculation time, by incrementally computing the costs,and in terms of search effort, by a finer parameter tuning.
• Number of iterations before a restart is triggered:100 × m. This choice is somehow arbitrary. Our first experimentsshowed that the best solution had been found far before this limit for the small or easy instances, for example on the firstHarvey instances, after a few hundreds of iterations for problem of size10 and20. One could argue that it would havebeen sufficient to fix this parameter to far less than100×m, say around20× m, to improve our results for the challenge.Now our strategy has been to give the solver a reasonnable chance of finding good solutions. Anyway a run for a typical30 instance lasts around a few minutes, which is reasonnable.
• Number of restarts:10, and only the best solution among the10 runs is kept
• Number of variables reset at a restart:100 %
• Number of runs:1. It would have been equivalent to perform10 runs fixing the number of restarts to0, but less convenient.
• Number of iterations a variables is frozen when it does not allow to improve the error:m the number of variables. Wehave chosen to fix it to the maximum, in order to insist on promising neighbourhoods and get the best possible optima,although it might slow the search (see adaptive search documentation and articles for explanations on the parameter)
Since the first parameter (search effort for one restart) hasvoluntarily been fixed to a high value, we add another column inthe table of results to give the computation time for finding the best solution.
Constraint Modelling Challenge 2005
88
Constraint Modelling Challenge 2005
89
A.2 Individual results (Truchet, Bourdon, Codognet)We have chosen to run the program only once with some restartsfrom 2 to 10, and a number of iterations before restart from10×m to 100×m, depending on the instances’ sizes and difficulty. Thus the best and worst objective values found are equal.
Total runtime Total search effort Runtime to find Search effort to findFile Number Objective value over all runs over all runs best solution best solution
B CodeImportant remark: we have made the initial mistake to exchange the columns and rows of theProb matrix from the Challenge’sdefinition. When we realized it, it was too late to correct it.Thus in our implementation the customers are on the columns,and the products on the rows. Although it has no consequence on the resolution nor on the permutation finally provided by thesolver, it may affect the lisibility of the displayed matrixes for somebody who would run the code with displays. Anyway,itdoes not affect the results as we have translated all the input matrixes. We apologize to the Challenge’s Organizers.
It is important to remark that we have not fully used the possibilities of the library, which can be seen in the Costif Swapand ExecutedSwap functions. Defining these two functions better would allow to incrementally compute the errors.
Constraint Modelling Challenge 2005
90
Constraint Modelling Challenge 2005
91
Constraint Modelling Challenge 2005
92
Constraint Modelling Challenge 2005
93
Constraint Modelling Challenge 2005
94
Using Customer Elimination Orderings to Minimise the Maximum Number ofOpen Stacks
A Submission for the First Constraint Modelling Challenge
Nic Wilson and Karen PetrieCork Constraint Computation Centre
Department of Computer Science, University College Cork, Irelandn.wilson,[email protected]
1 IntroductionThe minimisation of the maximum number of open stacksproblem involves a set of customers, each which requires aparticular subset of a set of products. A solution is a totalordering of the products; the aim is to find a solution whichminimises a particular cost function, the maximum numberof open stacks (see below). Equivalent problems, such asminimisingpathwidth, have been studied in the literature (seehttp://www.dcs.st-and.ac.uk/ ipg/challenge/).
The approach we describe in this paper is using a branch-and-bound algorithm based on a remodelling of the prob-lem. Instead of searching for orderings of products, we searchfor orderings of customers, specifically, when they are elimi-nated from the problem. Perhaps not surprisingly, this simpleidea has been suggested before for this problem, in: H. H.Yanasse, On a pattern sequencing problem to minimize themaximum number of open stacks,European Journal of Op-erational Research, Vol. 100, 454–463, 1997. In this paperwe analyse this approach in some depth, and describe our im-plementation using constraint programming. We also discusshow the approach might be extended.
2 Problem and NotationWe first describe the problem with our notation. We havea setC of n customers and a setP of m products, both ofwhich we totally order in some arbitrary way. Each customerx requires a setprodx of products.
In the table below we consider an instance with customersa, b, c, d, e, f and productsA,B,C, D, E, F. The ele-ments ‘1’ within the above table indicate which customer re-quires which product. For example, the setprodc of prod-ucts required by customer c is equal toA,C. There arealso m timepoints, 1, . . . ,m. A solution states whichproduct is produced at which timepoint. Formally, a solu-tion π is a function from the set of timepoints to the setof products. Productπ(1) is made first, followed byπ(2),and thenπ(3), . . . , π(m). Hence a solution can be consid-ered as a sequence ofm products. ProductX is made attimepoint π−1(X). The table illustrates the solutionπ =(A,B, C, D, E, F ), i.e.,π(1) = A, π(2) = B etc.
For customerx, let startπx be the timepoint in the solu-tion π when the stack forx begins, i.e., when the first prod-uct thatx requires is made. Similarly letendπx be the point
when the stack forx ends, when the last product thatx re-quires is made. We will often abbreviatestartπx andendπx tostartx and endx, respectively. In the example,startc = 1andendc = 3 since the first product in the solution sequencerequired by customer c is placed at the first time point, andthe last product required by c is placed at the third time-point. Formally,startπx = min π−1(Y ) : Y ∈ prodx andendπx = max π−1(Y ) : Y ∈ prodx.
Given a solutionπ, for timepoint j ∈ 1, . . . ,m,the set open(j) of open stacks atj is defined to bethe set of customers whose stack is open atj, i.e.,x : startx ≤ j ≤ endx. The cost of solutionπ is de-fined to be the size of the largest setopen(j), i.e.,maxj∈1,...m |open(j)|. The aim is to find a solution withminimal cost.
The entries∗ in the table indicate that a customer hasan open stack at a particular timepoint. For example, thereis an open stack for customerc at timepoint 2; this is be-cause timepoint 2 is in the interval[startc, endc] = [1, 3].There are five open stacks at timepoint 3, when product C ismade. The cost of this solution, i.e., of the product ordering(A,B, C, D, E, F ) is equal to 5, since the maximum numberof open stacks at any timepoint is 5.
3 Customer EliminationIn this section we show how that it is sufficient to focus on aspecial type of solution, based on an ordering of customers.
Generating a Customer Ordering from a SolutionWe can generate a permutation of the customers from a solu-tion, by considering the order in which customers are elimi-nated, i.e., the ordering of the values ofendx over customersx. This is not usually unique, but we can break ties using
Constraint Modelling Challenge 2005
95
the initial ordering of customers. In the example, customer cis eliminated first, at timepoint 3, sinceendc = 3, thend attimepoint 4, followed bya ande at timepoint 5, andb andf attimepoint 6, sinceendb = endf = 6. We use the alphabeticalordering to break ties giving a customer elimination ordering(c, d, a, e, b, f).
This defines a functionf from solutions to customer or-derings. (Formally, a customer ordering is defined to be afunction from1, . . . , n to C.) We write the effect off onsolutionπ asf(π). For customersx andy, customerx is or-dered beforey by f(π) if and only if either (i)x is eliminatedbeforey by π (i.e., endπx < endπy ), or (ii) x is eliminated si-multaneously withy by π (i.e., endπx = endπy ), andx < y(according to the input total order on customers).
Generating a Solution from an Ordering of CustomersWe will generate a functiong that maps a customer orderingρto a solutiongρ. The idea is that the products required by thefirst customer (according toρ) are introduced first, and thenadditional products required by the second customer etc. Tiesare broken by the input ordering on products. In the exam-ple, the customer orderingc, d, a, e, b, f generates a productorderingA,C,B, D, E, F .
Let G(X) be the earliest position in the customer or-dering ρ that requires productX, so that G(X) =min ρ−1(x) : prodx 3 X. Thengρ is defined as follows:X is ordered beforeY by gρ if and only if either (i)G(X) <G(Y ) or (ii) G(X) = G(Y ) andX < Y ; that is, eitherX isfirst required by an earlier customer (in orderingρ) thanY , orthey are both first required by the same customer, andX < Yin the input product ordering.
The example illustrates that applyingf then g doesnot necessarily give the same solution as we started with:A,B,C, D, E, F is changed toA,C,B, D, E, F . In fact thecost is even changed: the cost of the second solution is just 4,as opposed to 5 for the first solution. The following proposi-tion states that applyingf and theng can never increase thecost of a solution.Proposition 1 If we start with a solutionπ and generate theassociated customer elimination sequencef(π), and gener-ate from that its associated solutiong(f(π)), then the cost ofthis new solution is no worse than that of the original solu-tion: cost(g(f(π)) ≤ cost(π).
Sketch of proof: Consider any solutionπ. Write the asso-ciated customer elimination orderingf(π) asx1, x2, . . . , xn.For i = 1, . . . , n, let ji = endxi be the position at whichcustomerxi is eliminated.
Let Prod1 be the sequence of products appearing in posi-tions1, . . . , j1 in the solutionπ, i.e.,π(1), . . . , π(j1). Theopen stacks setsopen(j) occurring at positionsj correspond-ing to elements ofProd1 are increasing in size (since no cus-tomer is eliminated in this interval), so with the largest occur-ring atj1, as customerx1 is eliminated. Permuting the prod-ucts inProd1 cannot make the last such set any larger, and socannot increase the cost of the solution. We permuteProd1 toput products required by customerx1 first, and putting thoseproducts in input products order. Hence these products are inthe order dictated byg(f(π)).
Let Prod2 be the (possibly empty) set of products appear-ing in positionsj1 + 1, . . . , j2 in the solutionπ. We per-mute Prod2 to put products required by customerx2 first,and putting those products in input products order. Again,no customer is eliminated in this interval, so this cannot in-crease the cost of the solution. We continue this process withProd3, . . . , Prodn.
Applying this sequence of operations generates solutiong(f(π)). None of the operations increases the cost of thesolution, socost(g(f(π)) ≤ cost(π), as required. 2
This result leads to the following result, which means thatwe can search for customer elimination orderings, withoutlosing completeness. The costcost(ρ) of a customer elimi-nation orderingρ is defined to becost(g(ρ)), the cost of theassociated product ordering.
Proposition 2 Suppose elimination orderingρ has minimalcost, i.e., for all elimination orderingsρ′, cost(ρ′) ≥ cost(ρ).Theng(ρ) is an optimal solution, i.e., for all solutionsπ,cost(π) ≥ cost(g(ρ)) = cost(ρ).
Proof: Let π be any solution. By the previous proposition,cost(π) ≥ cost(g(f(π)), which by definition is equal tocost(f(π)), the cost of the elimination orderingf(π). By thehypothesis,cost(f(π)) ≥ cost(ρ) = cost(g(ρ)), proving thatcost(π) ≥ cost(g(ρ)), Sinceπ was an arbitrary solution, thisproves the optimality of solutiong(ρ). 2
Cost in terms of neighbourhoodsTheneighbourhoodNbd(x) of a customerx is defined to bethe set of customers that share a common product with cus-tomerx, i.e.,y ∈ C : prodx ∩ prody 6= ∅. In the example,Nbd(c) = a, b, c, e; this is becausec requires productsAandC, anda andb also requireA, and customersa ande alsorequire productC.
We say that a customer elimination orderingρ is feasi-ble if there is some solution which hasρ as its associatedcustomer elimination ordering, i.e., if there exists solutionπ with ρ = f(π). It can be checked that if we generatean elimination orderingρ = f(π) from a solutionπ, thengenerate a solutiong(ρ) from that, and an elimination order-ing f(g(ρ)) from that, we get the same elimination ordering:ρ = f(g(ρ)). This implies that a customer elimination order-ing is feasible if and only ifρ = f(g(ρ)).
Consider a feasible customer elimination orderingρ =(x1, x2, x3, . . .), and its associated solutiong(ρ). Whenx1
is eliminated, i.e., at timepointendx1 , the products requiredby x1 have been made, which means that there is an openstack for every neighbour ofx1. We write Stacks(x1) =Nbd(x1) = Nbd(ρ(1)). Similarly, whenx2 is eliminated,at timepointendx2 , (unlessendx2 = endx1) there is an openstack for every neighbour ofx1 or of x2, except for customerx1, which has been eliminated. We writeStacks((x1, x2)) =Nbd(x1) ∪Nbd(x2)− x1.
More generally for a sequence of customersseq = (x1, . . . , xi) we write Stacks(seq) =(Nbd(x1) ∪ · · · ∪ Nbd(xi)) − x1, . . . , xi−1. We
Constraint Modelling Challenge 2005
96
can compute this iteratively using the equationStacks((x1, . . . , xi)) = (Stacks((x1, . . . , xi−1))−xi−1)∪(Nbd(xi)− x1, . . . , xi−1).
For elimination ordering ρ, let ncost(ρ) =maxi=1,...,n |Stacks((x1, . . . , xi))|. It is only at time-points in endxi
: i = 1, . . . , n that the number of openstacks could decrease. Ifρ is feasible then customers geteliminated fromg(ρ) in the orderρ (sinceρ = f(g(ρ))),so the largest set of open stacks for solutiong(ρ) is equalto Stacks((x1, . . . , xi)) for somei = 1, . . . , n. Hence, forfeasibleρ, cost(ρ) = ncost(ρ).
For any customer elimination orderingρ we have:ncost(ρ) ≥ cost(ρ). Let ρ′ = f(g(ρ)), which is a feasiblecustomer elimination ordering. Then, using Proposition 1,ncost(ρ′) = cost(ρ′) ≤ cost(ρ) ≤ ncost(ρ). So the minimumof ncost(ρ) over all customer elimination orderingsρ is equalto the minimum ofcost(ρ) over all customer elimination or-derings, which, by Proposition 2, is equal to the minimumof cost(π) over all solutionsπ, i.e., the cost of the optimalsolutions. This shows that allowing infeasible customer elim-ination orderings in our search algorithms does not affect theresult. The basic algorithm below performs a search over cus-tomer elimination orderings.
4 Basic Customer Elimination AlgorithmThe algorithm is based on chronological backtracking search.The valuemaxStacksis the maximum number of open stacksallowed. For example, if we have already found a solutionwith costR then we could setmaxStacks= R − 1 to see if itis possible to improve on this solution.
Alternatively, we could run the algorithm repeatedly, incre-mentingmaxStackseach time, starting withmaxStacks= 1(or maxStacksequalling the size of the smallest neighbour-hood). The optimal cost will be the value ofmaxStacksin thefirst run that succeeds.
A sequence of customersseqis built up incrementally.seqis initialised as the empty sequence.
While seqdoesn’t contain all customers, do (a) and (b):(a) Choose customerx not in seq, and addx to the end of
sequenceseq;
(b) If |Stacks(seq)| > maxStacksthen backtrack to the lastreassignable choice (i.e., the last choice such that thereexists an alternative not yet tried). If no such choice ex-ists, return ‘fail’ and stop.
If the algorithm doesn’t return ‘fail’, then (the final)seqis a customer elimination sequence with cost no more thanmaxStacks, which can be converted to a solutiong(seq) withcost no more thanmaxStacks. If the algorithm returns ‘fail’,then every customer elimination sequence has cost greaterthanmaxStacks; in which case there is no solution with costless thanmaxStacks. (These properties follow from the re-sults and the discussion above.)
Complexity for problems with high optimum costIt can be seen that this algorithm will find the optimal costquickly (and prove optimality) for problems with high path-width, i.e., where the optimal cost is close to the number ofcustomers.
A lower bound for the optimal cost is the size of the small-est neighbourhood. This is because the set of open stackswhen the first customer is eliminated is that customer’s neigh-bourhood. If for some customerx, Nbd(x) 6= C then elimi-natingx first leads to an elimination sequence with cost lessthann. This implies that the optimal cost is equal ton if andonly if every customer is a neighbour of every other customer,i.e., for allx ∈ C, Nbd(x) = C.
Let w be the cost of the optimal solution. Suppose, dur-ing the algorithm, an initial sequenceseq of length (n −maxStacks) has been chosen, so that(n − maxStacks) cus-tomers have been eliminated, and there aremaxStackscus-tomers remaining to be eliminated. If|Stacks(seq)| ≤maxStacksthen any choices for the remainder of the sequencewill succeed, since there are onlymaxStackscustomers re-maining in the problem. This implies that ifmaxStacks≥ wthen success or failure will be determined by choosing a se-quence of at mostn − maxStackscustomers, and hence atmostn− w customers.
If maxStacks< w then the algorithm will return ‘fail’,since there is no solution with cost at mostmaxStacks. More-over, no sequence longer thann − w + 1 will be generated.This is because if a sequence of lengthn − w + 1 were tosucceed with the test in (b) then the largest number of stacksgenerated so far would be not more thanmaxStacksand soat mostw − 1; but then any extension of this sequence willhave cost at mostw−1 (since onlyw−1 customers remain),which contradictsw being the cost of the optimal solution.Therefore we have:
Finding an optimal solution (and proving optimality) for fam-ilies of instances withn − w bounded by a constant is poly-nomial in the number of customers and products
5 Implementation with CPThe CP-based implementation of the customer eliminationalgorithm hasn search variablesx1, . . . , xn all of domain1, . . . , n representing the ordering in which then cus-tomers are eliminated. The only constraint on these searchvariables is a global ‘alldifferent’ which forces the orderingto form a permutation.
The method commences by a preprocessing step whichaims to calculate a lower bound for the optimal value. Thisis done by calculating the neighbourhood setNbd(x), foreach customerx. This is done in a similar manner to thatdescribed in Section 3. The lower-bound (lwb) for the opti-mal value is then calculated, which corresponds to the car-dinality of the smallest neighbourhood set. At this stageanother set of variablesy1, . . . , yn is created with domainlwb, . . . , n. Intuitively these variables correspond to theoptimal value of the current partial or full customer elimina-tion ordering, with lower bound ofyk given by the size of thesetStacks(x1, . . . , xk).
Once the bound has been calculated, and they-variableshave been allocated their corresponding domains, thenbranch-and-bound search commences. This takes the formof a standard branch-and-bound search across thex variables.Every time a search variable is instantiated, the correspondingy variable is calculated to give the current bound on the opti-
Constraint Modelling Challenge 2005
97
mal solution. There is a global ‘max’ constraint across this setof variables so that every time a partial ordering is found witha worse optimal value than a previous solution, early pruningcan take place. The combination of this early pruning throughthe use of the global constraints, and the good bound on theobjective value, creates an efficient solving mechanism forthis problem.
6 Further Techniques
6.1 A simple dominance condition removinginfeasible elimination orderings
Suppose we have scheduled a subset of the customersC ′, asseq. Let C ′′ = C − C ′ be the remaining unscheduled cus-tomers. LetS be the union of neighbourhoods of each el-ement inC ′, i.e., S = (
⋃x∈C′ Nbd(x)). Let x and y be
two remaining customers. If we schedulex next then the setNbd(x) − S get added to the current open stacks. Say thatydominatesx (givenC ′ or seq) if either of the following hold:
(i) Nbd(x)− S % Nbd(y)− S
(ii) Nbd(x)− S = Nbd(y)− S andy < x.
Say thatx ∈ C ′′ is undominated if there does not existy ∈C ′′ which dominatesx.
When we have scheduled customersC ′ we only need toconsider undominated customers to schedule next. The rea-son for this is that ifx is not undominated there always existsa y which is undominated and which dominatesx, and anycustomer ordering beginningseq, x is no better than the cor-responding customer ordering where customery is broughtforward just beforex (and so beginningseq, y, x).
This view also suggests a simple heuristic for choosingwhich customerx to schedule next: choose one with smallestsetNbd(x)− S.
6.2 Before-overlap branching
Here we discuss another kind of decision to branch over,which can be used on its own or in conjunction with customerelimination.
Let x andy be two customers. We say customerx is beforecustomery (with respect to some solution) ifendx < starty,i.e., if the stack forx closes before that ofy opens. We saythatx andy overlapif x is not beforey, andy is not beforex, i.e., if there exists some point in which both the stacks forx andy are open. This happens if and only ifstartx ≤ endyand starty ≤ endcx. If x and y are neighbours (i.e., theyrequire a common product) then customersx andy overlap.For any two customersx andy, exactly one of the followingthree possibilities occurs (in any given solution):
(i) x is beforey;
(ii) y is beforex;
(iii) x andy overlap.
Implied constraints can be generated in each case, espe-cially (i) and (ii).
Propagation from before statements Obviously:before(x, y) andbefore(y, z) imply before(x, z).If before(x, y) and overlap(y, z) then notbefore(z, x), andalsoendx ≤ endz.
This latter implication restricts the search for customerelimination orderings: we can assume thatx appears earlierin the sequence thanz in the customer elimination ordering.beforestatements also strongly restrict directly the possiblesolutions (ordering of products).
Propagation from overlaps Consider a setR of r cus-tomers, every pair of which overlap, i.e., for allx, y ∈ R,overlap(x, y). Then the cost of the solution is at mostr. Thisis because at the pointmin endx : i ∈ R, there is an openstack for each customer inR.
If x andy overlap then, when the first of them is eliminated,there is an open stack for both customers. In particular, ifendx ≤ endy then at the point thatx is eliminated, the currentset of open stacks includes bothx andy.
We could therefore construct a search tree by at each nodechoosing two customers, and constructing a branch for eachof the three possibilities above. We will need relatively fewbeforedecisions at (above) a node for either inconsistency,or becoming close to generating a solution with cost withinthe upper boundmaxStacks, sincebeforestatements stronglyrestrict solutions and customer elimination orderings. Nodeswith almost alloverlapdecisions associated allow weaker di-rect propagation. However, then searching for feasible cus-tomer elimination sequences at such a node may well be ef-fective, since the increased number of overlaps will tend toincrease the number of open stacks, potentially clashing withthe upper bound and allowing backtracking. (Causing fur-ther overlaps is similar to increasing the neighbourhoods ofcustomers; customer elimination is very effective when theneighbourhoods get larger.)
7 DiscussionWe analysed and proved equivalence of a simple reformula-tion of the problem (customer elimination sequences), withan associated branch-and-bound approach. We implementedthis approach with CP technology; as expected, given the ear-lier discussion, the approach works very well when the op-timum cost is high, as demonstrated by the experimental re-sults. However, the approach is also very successful for manyproblems with much lower optimum cost; propagating thelower bound based on the sizes of the neighbourhoods seemsto be very effective for some of these problems.
AcknowledgementsThis material is based upon works supported by the ScienceFoundation Ireland under Grant No. 00/PI.1/C075. We aregrateful for valuable discussions with many of our colleaguesincluding Radek Szymanek, Gilles Pesant, Steve Prestwich,David Burke, Gene Freuder, Tom Carchrae, Armagan Tarim,Joe Bater, Mark Hennesey, Alex Ferguson and Brahim Hnich.
- All experiments were run on a Dell Latitude D400 laptopwith a 2GHz 4M Pentium processor, and 1GB of RAM.
- ECLiPSe 5.8 ]79 was used for the implementation of thefull algorithm, the code relies on theic, ic global,ic search and thebranch and bound algorithms.
- One run was used for each instance.
- The maximum time allowed for each run was 5 minutes.
The method of gauging search effort is adeep backtrackcount. A deep backtrack is where a variable has been set to avalue and search has continued, and later this search tree nodehas had to be returned to, and the alternative branch taken.Therefore the deep backtrack count does not includeshal-low backtracks, where a variable is assigned a value which isfound purely by propagation to be inconsistent.
The mean, median and maximum number of backtracks tofind the optimal solution have not been included in the twotables of aggregate results. This is because in ECLiPSe ahandler is triggered when a better optimal solution is foundthan the incumbent. It is possible to print the number ofbacktracks at this point (as we did with the single instances),but we could not see how to get the program to store such avalue. The large number of instances made it impractical togo through the program output and calculate such values byhand.
Constraint Modelling Challenge 2005
99
File Best Solved Runtime Search effort (bts) to Total search effortvalue Optimally? (sec) find optimal solution (backtracks)
![Page 1: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/1.jpg)
![Page 2: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/2.jpg)
![Page 3: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/3.jpg)
![Page 4: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/4.jpg)
![Page 5: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/5.jpg)
![Page 6: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/6.jpg)
![Page 7: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/7.jpg)
![Page 8: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/8.jpg)
![Page 9: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/9.jpg)
![Page 10: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/10.jpg)
![Page 11: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/11.jpg)
![Page 12: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/12.jpg)
![Page 13: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/13.jpg)
![Page 14: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/14.jpg)
![Page 15: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/15.jpg)
![Page 16: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/16.jpg)
![Page 17: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/17.jpg)
![Page 18: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/18.jpg)
![Page 19: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/19.jpg)
![Page 20: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/20.jpg)
![Page 21: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/21.jpg)
![Page 22: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/22.jpg)
![Page 23: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/23.jpg)
![Page 24: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/24.jpg)
![Page 25: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/25.jpg)
![Page 26: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/26.jpg)
![Page 27: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/27.jpg)
![Page 28: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/28.jpg)
![Page 29: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/29.jpg)
![Page 30: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/30.jpg)
![Page 31: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/31.jpg)
![Page 32: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/32.jpg)
![Page 33: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/33.jpg)
![Page 34: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/34.jpg)
![Page 35: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/35.jpg)
![Page 36: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/36.jpg)
![Page 37: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/37.jpg)
![Page 38: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/38.jpg)
![Page 39: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/39.jpg)
![Page 40: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/40.jpg)
![Page 41: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/41.jpg)
![Page 42: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/42.jpg)
![Page 43: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/43.jpg)
![Page 44: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/44.jpg)
![Page 45: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/45.jpg)
![Page 46: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/46.jpg)
![Page 47: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/47.jpg)
![Page 48: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/48.jpg)
![Page 49: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/49.jpg)
![Page 50: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/50.jpg)
![Page 51: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/51.jpg)
![Page 52: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/52.jpg)
![Page 53: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/53.jpg)
![Page 54: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/54.jpg)
![Page 55: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/55.jpg)
![Page 56: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/56.jpg)
![Page 57: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/57.jpg)
![Page 58: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/58.jpg)
![Page 59: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/59.jpg)
![Page 60: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/60.jpg)
![Page 61: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/61.jpg)
![Page 62: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/62.jpg)
![Page 63: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/63.jpg)
![Page 64: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/64.jpg)
![Page 65: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/65.jpg)
![Page 66: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/66.jpg)
![Page 67: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/67.jpg)
![Page 68: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/68.jpg)
![Page 69: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/69.jpg)
![Page 70: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/70.jpg)
![Page 71: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/71.jpg)
![Page 72: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/72.jpg)
![Page 73: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/73.jpg)
![Page 74: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/74.jpg)
![Page 75: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/75.jpg)
![Page 76: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/76.jpg)
![Page 77: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/77.jpg)
![Page 78: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/78.jpg)
![Page 79: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/79.jpg)
![Page 80: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/80.jpg)
![Page 81: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/81.jpg)
![Page 82: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/82.jpg)
![Page 83: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/83.jpg)
![Page 84: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/84.jpg)
![Page 85: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/85.jpg)
![Page 86: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/86.jpg)
![Page 87: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/87.jpg)
![Page 88: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/88.jpg)
![Page 89: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/89.jpg)
![Page 90: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/90.jpg)
![Page 91: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/91.jpg)
![Page 92: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/92.jpg)
![Page 93: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/93.jpg)
![Page 94: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/94.jpg)
![Page 95: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/95.jpg)
![Page 96: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/96.jpg)
![Page 97: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/97.jpg)
![Page 98: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/98.jpg)
![Page 99: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/99.jpg)
![Page 100: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/100.jpg)
![Page 101: Constraint Modelling Challenge 2005 In conjunction with ...and Beldiceanu & Carlsson [3] both impose a fixed order on the first two variables selected, corresponding in both cases](https://reader033.documents.pub/reader033/viewer/2022061001/60b02e3db7694759931ca7bd/html5/thumbnails/101.jpg)
