MATHEMATICAL MODELS FOR THE CUTTING STOCK WITH LIMITED OPEN STACKS PROBLEM

. This research is focused on solving the Cutting Stock with Limited Open Stacks Problem (CS-LOSP). The CS-LOSP is an optimization problem which consists of the classical Cutting Stock Problem (CSP) paired with the additional constraint that the maximum number of open stacks from the sequencing of the cutting patterns obtained from the CSP solution is equal or lower than a preset limit. Despite being a problem with great practical importance, the literature lacks models for this problem, and only one-dimensional problems are addressed. In this paper, we propose two integer linear programming formulations for the CS-LOSP that are valid for solving instances of the CSP of any dimension. In order to eliminate symmetrical solutions to the problem, the proposed formulations sequence sets of cutting patterns instead of sequencing the cutting patterns individually, thus, the search space for solutions is reduced. A set of randomly generated instances for the two-dimensional problem is used to perform computational experiments in order to validate the proposed mathematical formulations.

The mostly used approach for the CSP is the classical formulation proposed by Gilmore and Gomory in [9,10]. Such formulation, together with the proposed column generation approach for solving the linear programming relaxation of the CSP combined with an integralization technique, is widely applied to solve the CSP [18].
Later on, based on an arc-flow approach, Wolsey [22] and Valério de Carvalho [20] propose a mathematical formulation for the one-dimensional CSP. The model proposed in [20] is extended for the two-dimensional case, i.e., to deal with objects regarding two dimensions, such as plates or boards, in [14].
In [6], the authors develop a procedure to reduce the number of variables and constraints of the arc-flow model proposed in [20]. Such procedure is named as Meet-In-the-Middle (MIM). Another contribution presented in this paper is the proposal of a novel arc-flow formulation which is more compact and presents an improved overall performance.
The current state-of-the-art formulation for the one dimensional CSP is the one proposed in [7]. The authors take advantage of the meet-in-the-middle procedure proposed in [6] and the classical arc-flow formulation proposed in [20] to build a new model in which only half of the bin capacity is considered. The resulting formulation has fewer variables and constraints, and therefore, performs better.
In a two-dimensional Cutting Stock Problem (2D-CSP), two dimensions of the object and the items are relevant, typically length and width. The construction of two-dimensional cutting patterns is considerably more labor-intensive when compared to the one-dimensional CSP. A guillotine cut on a board is a straight cut from one edge to the opposite edge; in other words, the cut is of guillotine type when applied to a rectangle it produces new rectangles. In some practical applications, such as in furniture industry, the cutting equipment is able to perform only guillotines cuts.
In many practical applications, a guillotine cutting pattern is performed in stages. At each stage, cuts are done in the same direction over the whole object or on pieces (strips) of it obtained from cuts performed in a previous stage. The direction in which the cuts are performed is changed at each stage. Thus, if at any stage the cuts are horizontal, at the next stage the cuts will be vertical and vice versa. Changing the direction of the cuts can be expensive, as you need to rotate the machine or the object, which is time-consuming. Therefore, the strategy of limiting the number of stages can be used to optimize the process. On the one hand, this restriction reduces the number of feasible cutting patterns, on the other hand, the amount of material waste can increase. When the number of stages is limited to , the guillotine cutting pattern is called -staged.
In the one-dimensional CSP, a cutting pattern can be obtained by solving a knapsack problem [9,10]. The generation of a two-dimensional cutting pattern is significantly more complex and, depending on the characteristics of the types of allowed cuts, we can find several heuristic and exact approaches to determining two-dimensional cutting patterns in the literature. In this research, we consider the two-staged guillotine cutting pattern, as proposed in [11].
The order in which the cutting patterns are carried out can be relevant to manage the storage space around the cutting machine. In many practical cases, such as cutting wooden boards for furniture making, the machines have automatic unloading stations and the number of such stations is limited. The greater the number of stations, the more expensive the cutting equipment is, so it is quite important for the company to have cutting plans that require a limited and small number of open stacks. In this case, the Minimization of Open Stacks Problem (MOSP) must be taken into account. The MOSP acts in the context in which the allocation of items obtained from the CSP solution are stored in stacks, so that different items are arranged in different stacks. When all cutting patterns containing a specific item type have already been performed, the stack referring to such item is called a closed stack, otherwise, the stack of this item is considered open. The goal of the MOSP is to minimize the maximum number of stacks that are simultaneously open.
A closely related problem to the MOSP is the Minimization of Tool Switches Problem (MTSP). The MTSP aims to determine the order in which a set of tasks must be performed on a single flexible machine. Each of the tasks needs a specific set of tools for its execution, and the in-use machine has a limitation on the maximum number of tools that can be simultaneously allocated to the machine. Thus, it is necessary to switch the tools allocated to the machine to process all tasks. The goal of the MTSP is to minimize the number of tool switches performed.
Yanasse [23] demonstrates that an optimal MTSP solution represents a sequencing of cutting patterns that opens at most stacks if and only if the value of the solution to MTSP is equal to | | − , considering as the set of all item types. With this proposition, in [23] a formulation for the MOSP based on the model proposed in [19] for the MTSP is developed.
The strategy used in [23] to build the model for the MOSP is to change the interpretation of variables and parameters, so that, instead of considering tools and tasks, the problem considers items and cutting patterns, respectively. Once this is done, a constraint is added to the formulation proposed in [19], in order to ensure that at most | | − tool exchanges are performed in the context of the MTSP, thus ensuring that the sequencing is equivalent to a cutting pattern sequencing that opens at most stacks. Finally, the model's objective function is changed to minimize the maximum number of open stacks.
In [15], the authors propose a constraint programming formulation and two new integer linear formulations for the MOSP. The first one seeks to sequence the stacks to be closed, and the second is based on the open stack counting strategy proposed in [8].
A formulation for the MTSP, inspired by the traveling salesman problem, is proposed in [13]. In this formulation, the tasks to be performed are represented by the vertices in a graph and the sequence in which the tasks are carried out is equivalent to the order in which the vertices are traversed in an Euler tour. In this model, a dummy task is established, which represents the beginning and end of the Euler tour. In [5], the formulation proposed in [13] is used as the basis for the construction of three new formulations for the MTSP.
In practical situations, the CSP is often associated with the MOSP. Despite this, in the literature, the CSP and the MOSP are usually independently treated. The independent resolution of the problems consists in solving the CSP and then sequencing the set of cutting patterns to minimize the maximum number of open stacks. In some cases, solving the CSP and the MOSP independently may yield unsatisfactory results. Two disadvantages of the independent resolution approach are discussed in [2], namely: -Solving the two problems independently is not the same as finding a solution that minimizes the maximum number of open stacks while reducing material waste. The quality of the solution obtained from the MOSP resolution strongly depends on the set of cutting patterns determined when solving the CSP. It is possible that there are several sets of cutting patterns that have the same objective function value for the CSP, but present different results for the MOSP. In this case, solving the problems independently does not make it possible to determine the set of cutting patterns that optimizes the two intended objectives. -If there is a limit on the maximum number of stacks that can be opened, then the solution to the cutting stock problem may not present feasible sequencing.
Therefore, the independent approach may be less efficient in optimizing the two intended goals. Instead of solving the CSP and the MOSP independently, it is possible to combine the two problems into a single formulation. In [24], the authors build a formulation for the integrated problem in which the CSP is solved while subjected to the constraints that the maximum number of open stacks during the sequencing of the cutting patterns is equal to or less than a previously defined limit. This problem is known in the literature as the Cutting Stock with Limited Open Stacks Problem (CS-LOSP).
The idea of the formulation proposed in [24] is to build a model for the CS-LOSP that joins the formulation proposed in [9][10][11] for the CSP and the one proposed in [23] for the MOSP. The coupling of both models is done by a set of binary variables. The results obtained from the direct application of the formulation proposed in [24] are limited. The difficulty of solving the model for large instances is mainly due to the huge number of variables and constraints. The size of the formulation under consideration depends on the number of different types of items and the total number of possible cutting patterns, since, even for small problems, the total number of cutting patterns is considerably large, which compromises using the formulation for solving the problem. Throughout this text, we refer to the model proposed in [24] as the Integrated Yanasse and Lamosa (IYL).
Concomitantly, in 2007, in [4] a sequential heuristic for solving the CS-LOSP is proposed. In this heuristic, the cutting patterns are generated one after the other and, then, there are two approaches to deal with the limitation on the maximum number of open stacks. The first approach penalizes the pseudo-prices of some items in order to reduce the number of items in each generated cutting pattern. The second approach explicitly restricts the maximum number of open stacks. To do so, during the generation of each cutting pattern, the current number of open stacks is evaluated and we let be this value. Then, the new cutting pattern must contain at most − new item types. Thus, the limitation on the maximum number of open stacks is respected. More recently, in 2012, a tabu search heuristic combined with a constrained version of the model proposed in [9,10] to solve the CS-LOSP was developed in [1].
In [2], another formulation is proposed for the CS-LOSP. The authors manage to significantly reduce the number of constraints in the model. While in the formulation proposed in [24] the number of constraints grew exponentially as a function of the number of distinct types of items, in the formulation proposed in [2], the number of constraints grows quadratically. Despite the success in reducing the number of constraints in the formulation, the model still has a large number of variables. Another important contribution of the paper is the proposition of a column generation method to solve the linear programming relaxation of the CS-LOSP.
In [24], although the proposed model is valid for cutting stock problems of any dimensions, the focus of the computational experiments is on the one-dimensional problem. In [4], the authors propose the use of a sequential heuristic to solve the one-dimensional CS-LOSP.
To the best of our knowledge, the paper [16] is the only one in the literature to address the two-dimensional CS-LOSP. In such paper, three mathematical models are proposed, focused on the two and three staged twodimensional guillotine cutting stock with limited open stacks problem. Despite the scarcity of papers addressing the two-dimensional CS-LOSP, the two-dimensional case has many real life applications such as in the glass, metal or furniture industries, among others. Therefore, the main contribution of this research is the proposal of two integer linear programming formulations for the CS-LOSP for CSP-type problems of any dimension. Furthermore, such formulations are validated through computational experiments on randomly generated instances for the two-dimensional CSP.
This paper is organized as follows. In Section 2, we present a study on the elimination of symmetries in the solution of the CS-LOSP, which leads to a reduction of the search space. Next, in Section 3, we describe the two proposed formulations for the CS-LOSP. Such formulations aim to sequence sets of cutting patterns instead of sequence the cutting patterns individually. Moreover, both proposed formulations take into account the symmetry elimination stated in Section 2. Computational experiments regarding the two-dimensional CS-LOSP were carried out on randomly generated instances and are detailed in Section 4. The data set and the procedure for generating the cutting patterns are detailed in Sections 4.1 and 4.2, respectively. In order to evaluate the quality of the proposed formulations, in Section 4.3 the sizes of the formulations are analyzed. In Section 4.4 the strength of the models is shown via the quality of the linear programming relaxation of the three formulations addressed in this work. In Section 4.5 we evaluate the computational effort for the proposed formulations and the one from the literature. Finally, the conclusions and future research proposal are provided in Section 5.

Symmetries in the CS-LOSP solution
One of the challenges of solving the CS-LOSP is the large amount of symmetrical solutions. Given any set of cutting patterns, there is a variety of possible cutting patterns sequences that respect the limitation on the maximum number of open stacks, resulting in multiple solutions with the same objective function value.
It is possible to reduce the number of feasible cutting patterns sequences and, consequently, the search space for solutions. Dominance relationships among the cutting patterns are presented in [3,8] in the MOSP context. In those papers, the authors show that given a cutting pattern 1 , if there is any cutting pattern 2 , such that all items generated by the cutting pattern 1 are also generated by the execution of the cutting pattern 2 , then the cutting pattern 1 is eliminated from the sequence.
In the context of CS-LOSP, in order to guarantee an optimal solution, it is necessary to consider all the cutting patterns, without exception. Therefore, the strategy used in [3,8] needs to be adapted. Instead of eliminating the dominated cutting patterns, the approach developed in this research consists of grouping the cutting patterns into sets and then determine an optimal sequence of such sets. Definition 1. Any two cutting patterns are called to be of the same type if when they are executed they produce the same types of items, regardless of the quantities of each item. Otherwise, they are called cutting patterns of different types.
Consider a set of arbitrary feasible cutting patterns , with cardinality equal to , containing distinct types of cutting patterns. The cutting patterns in can be grouped into proper subsets of , in order to ensure that each of the subsets contains only cutting patterns of the same type. Let the subsets with such properties be given by , = 1, . . . , . So, the following properties apply.
Proposition 1. Given a sequence of cutting patterns in which cutting patterns in , for any ∈ {1, 2, . . . , }, are executed one immediately after the other, the order in which these cutting patterns are executed can be swapped without changing the maximum number of open stacks by this sequence.
Proof. Let be an arbitrary sequence of cutting patterns in which cutting patterns in are executed one immediately after the other. Then we divide in three subsequences, 1 , 2 and 3 , where 1 is equivalent to the part of the sequence prior to the execution of the cutting patterns in ; 2 is the order in which the cutting patterns in are executed, and the subsequence 3 is equivalent to the part of the sequence which is related to the cutting patterns that are executed after the cutting patterns in . Let be the maximum number of stacks opened by the subsequence 1 and be the number of stacks that are opened right after the completion of the last element of subsequence 1 . When a cutting pattern is performed, for each distinct type of item generated by the cutting pattern, a new stack is opened if and only if the stack for such item has not been previously opened. Since all cutting patterns in generate the same item types, then, after the execution of the first cutting pattern in 2 , all stacks related to items which were generated by cutting patterns in are already opened. Thus, when executing the remaining part of the sequence 2 , no new stack will be opened. Thus, let ℓ be the amount of items of different types generated by cutting patterns in and be the number of stacks related to items generated by cutting patterns in which were previously opened, that is, during execution of the sequence 1 . Then, the number of stacks opened by the sequence 2 is given by + 1 − .
During the execution of the sequence 3 , stacks can be opened or closed. Let 2 be the maximum number of stacks opened by the sequence 3 . Therefore, the maximum number of stacks opened by the sequence is given by Since, by hypothesis, 2 is an arbitrary sequence, we conclude that the maximum number of open stacks during the execution of is independent of the sequence 2 . Therefore, the order in which the cutting patterns in 2 are executed can be swapped without changing the maximum number of open stacks.
Proposition 2. Given a set of cutting patterns , let be a set of all feasible sequences of cutting patterns in , where ⊂ is the set of all feasible sequence of cutting patterns in in which all cutting patterns that produce the same item types are performed one right after the other. Moreover, let be the complement of . So, for every sequence * ∈ , it is possible to find a sequence * ∈ such that the maximum number of open stacks from the execution of * is equal to or less than the maximum number of open stacks from the execution of * .
Proof. Let be an arbitrary feasible cutting pattern ∀ = 1, . . . , ; a set containing those cutting patterns and * ∈ an arbitrary sequence of the cutting patterns in , given by: 1 does; and let the cardinality of 1 be equal to 1 . In the sequence * , at most, the first 1 terms belong to 1 . Let * 1 be the largest index value such that, ∀ 1 ≤ ≤ * 1 , ∈ 1 . By construction, * 1 +1 / ∈ 1 . Let 2 be the set of all the cutting patterns in that produce the same item types as the cutting pattern * 1 +1 , and let the cardinality of 2 be equal to 2 . Therefore, in the sequence * , at most, the first 1 + 2 terms belong to 1 ∪ 2 ; let * 2 be the largest value such that, such that all cutting patterns in produce the same types of items. This process can be repeated in order to obtain all sets , 1 ≤ ≤ and the values * , so that, ∈ ∪ =1 , ∀ 1 ≤ ≤ * , and * ≤ ∑︀ . Let * ∈ be a sequence in which the cutting patterns in 1 are executed, followed by the execution of all the cutting patterns in 2 , and so on, i.e.: It can then be seen that the Consider the amount of types of items that are produced by a cutting pattern of the set and 1 the number of stacks opened by the execution of the first cutting pattern of the sequence * . When executing the other 1 − 1 cutting patterns, no new stack is opened since all cutting patterns in 1 generate the same types of items, therefore, all the stacks related to these items are already opened. When executing the cutting pattern 1 + 1, the stacks related to the cutting patterns in 2 , that were not previously opened due to the execution of the cutting patterns in 1 , must be opened. Consequently, the total number of stacks that have been opened up to the instant ℎ = 1 + 1 is equal to 1 is the set of item types cut by a cutting pattern in . The completion of the next 2 − 1 cutting patterns does not open any new stack, as all stacks referring to 2 have already been opened previously. When the cutting pattern 2 + 1 is executed, exactly the same process is repeated, so the total of stacks that were opened up to the instant ℎ = 2 + 1 is equal to The function ℎ is given by: Now, considerˆ* a subsequence of * composed of the first * −1 + 1 cutting patterns of the sequence * , in the same order of execution as in * . Let * ℎ be the total number of open stacks at the instant ℎ. It is easy to show that, when executing the first cutting pattern of the sequenceˆ*, 1 stacks are opened, and when executing the remaining * 1 − 1 cutting patterns, no new stack is opened since all cutting patterns in 1 generate the same item types. Accordingly, all stacks related to these items are already opened. When executing the cutting pattern * 1 + 1, the stacks referring to the cutting patterns in 2 that were not previously opened. Hence, the total number of stacks that have been opened up to the instant ℎ = * 1 + 1 is equal to 1 + ( 2 − | 1 ∩ 2 |). The completion of the next * 3 − * 1 − 1 cutting patterns does not open any new stack, since only cutting patterns in 1 ∪ 2 will be performed and all the stacks related to 1 and 2 have already been opened before. When the cutting pattern * 3 + 1 is executed, exactly the same process happens. Thus, the total number of stacks that have been opened up to the instant ℎ = * 3 + 1 is equal . Therefore, the function * ℎ is very similar to the function ℎ , the only difference between them is the range of ℎ: Let ℎ be the number of closed stacks after the execution of the ℎth cutting pattern of the sequence * . If ℎ ≤ 1 then no stack can be closed since there is no item such that all cutting patterns containing this item have already been executed. At the instant ℎ = 1 + 1, all cutting patterns in 1 were already completed, then, the stacks related to the items in 1 , that are not present in any other cutting pattern, can be closed. Therefore, there is a total of | 1 ∖{(∪ =2 ( )}| closed stacks at this instant. Analogous to what was done before, no stack can be closed until the instant ℎ = 2 + 1. At this instant, all the cutting patterns related to the sets 1 and 2 have been executed. Therefore, the stacks related to the types of items present in the cutting patterns in 1 ∪ 2 which are not present in any other cutting pattern in , ∀ = 1, . . . , can be closed, i.e., | 1 ∪ 2 ∖{(∪ =3 ( )}| stacks are closed. In general, we have: Let ℎ be the number of stacks that are open during the completion of the ℎth cutting pattern of the sequence * , then: The maximum number of stacks that are open simultaneously during the execution of the sequence * is given by: for some ℎ ∈ {1, 2, . . . , }. Note that ℎ is contained in the range { , +1 } for some and therefore: Let * ℎ be the number of stacks that are open during the completion of the ℎth cutting pattern of the sequence * , then: where * ℎ is the number of close stacks after the completion of the ℎth cutting pattern of the sequencê * . Unless all cutting patterns of a set have been executed, the stacks referring to the items generated by this set cannot be closed. At the instant ℎ * ∈ ( * , * +1 ], all executed cutting patterns belong to one of the sets 1 , 2 , . . . , * , * +1 . Let be the set containing all the sets , such that, all cutting patterns in were executed until the instant ℎ * and the complement of ; hence, ⊂ {1, 2, . . . , } and therefore: Concomitantly, we have: and then: where * is the maximum number of open stacks when executing the sequence * . Therefore, for every sequence in it is possible to find a sequence * ∈ such that the maximum number of open stacks from execution of * is equal to or less than the maximum number of open stacks from the execution of * .

The proposed formulations for the CS-LOSP
Propositions 1 and 2 presented in Section 2 can be used to reformulate the CS-LOSP as shown in this section. Proposition 1 guarantees that, for a sequence in , the order in which the cutting patterns of the same type are carried out can be changed without changing the maximum number of stacks opened by this sequence. Proposition 2 guarantees that if there is a sequence of cutting patterns that opens at most stacks, then there is a sequence in which cutting patterns of the same type are performed, one right after the other, that respects the limitation on the maximum number of open stacks. Thus, the search space is reduced and thereby only the sequences in need to be considered. In this way, the CS-LOSP can be reformulated as a problem of determining the frequency at which the cutting patterns should be performed in order to minimize material waste and, at the same time, to find a sequence of sets of cutting patterns of the same type such that its fulfillment opens, at most, stacks.
According to Definition 1 (Sect. 2), any set of cutting patterns containing different types of cutting patterns can be divided into subsets of cutting patterns of the same type. Let , = 1, . . . , , be the disjoint subsets of such that every cutting pattern in is of the same type. Next, we state the indices, parameters and variables that are used in the proposed formulations for the CS-LOSP which are presented in Sections 3.1 and 3.2. Integer decision variable that determines how many times the cutting pattern , = 1, . . . , is performed; Binary decision variable that is equal to 1 if the the cutting pattern is used on the solution and 0 otherwise.

Indices, parameters and variables
Considering the indices, parameters and sets defined above, in the following Sections 3.1 and 3.2, we present two new linear integer programming models for the CS-LOSP that aims to sequence sets of cutting patterns of the same type instead of sequencing the cutting patterns individually.

Formulation I
While in the formulation proposed in [24] the cutting patterns were individually sequenced, the Formulation I, proposed here, seeks to determine a sequence of sets of cutting patterns of the same type that respects Note that, a set of cutting patterns of the same type must be performed at some point in the sequence of a solution if, and only if, at least one cutting pattern in is used. Thus, consider the following constraints: Constraint sets (1) and (2)  = 0, as long as the value of the constant is large enough. Therefore, if no cutting pattern belonging to the cutting pattern set of the same type is used, then no cutting pattern is executed at the instant . This way, this instant can be ignored in sequencing. Since is a binary variable for every , ∈ {1, . . . , }, the set of constraints (6) guarantees that at most one set of cutting patterns of the same type is executed at the instant , for every ∈ {1, . . . , }. Note that, since there are cutting patterns that may not be used in the final solution, it is allowed that there are instants of time in which no cutting pattern is executed, thus, in the optimal sequencing it is necessary to exclude the instants in which no set of cutting patterns is used.
The objective function (8) aims to minimize the overall cost associated to the cutting patterns. The constraints (9) ensures that the demand is fulfilled. The constraint (10) guarantees that the maximum number of simultaneously open stacks equals . This constraint derives from the fact that a solution for the MTSP in which | | − tool changes are performed represents, in the context of the MOSP, a sequence of cutting patterns that opens at most stacks as demonstrated in [23]. The constraints (11) and (12)

Formulation II
In this section, we propose a second formulation for the CS-LOSP based on the models proposed in [5,9]. In this formulation, the sets of cutting patterns to be performed are represented by the vertices of a graph and the sequence in which the sets of cutting patterns are carried out is equivalent to the order in which the vertices are traversed in an Euler circuit. In this model, a dummy set of cutting patterns is established, which represents the beginning and the end of the Euler circuit. Let , and be the indices related to the sets of cutting patterns of the same type, ∀ , , ∈ ′ 2 . For all ∈ ′ 2 , ∈ ′ 2 and ̸ = , let be equal to 1, if the execution of the set of cutting patterns of the same type is done immediately after the execution of the set ; and 0, otherwise. Similarly, for all ∈ ′ 2 , ∈ ′ 2 , ̸ = and ∈ ( ∖ ) ∪ ( ∖ ), let be a binary variable equal to 1 if the execution of the set of cutting patterns of the same type is done immediately after the execution of the set and if the stack related to the item type is open after the execution of the set of cutting patterns of the same type and before the execution of the set of cutting patterns of the same type ; and 0, otherwise. Note that the variable is not defined for ∈ ∩ , once the stack must be open after the execution of the set which implies = 1, so there is no need to consider the set of variables for ∈ ∩ . Finally, for all ∈ 2 , let be an auxiliary variable used to prevent the formation of sub-cycles, as proposed in [17]. In this section, we chose to present the constraints of Formulation II in blocks to facilitate the understanding of the modeling. Firstly, we present the constraints regarding the sequence of the sets of cutting patterns of the same type, then we present another block of constraints that ensures that the sequence of the sets of cutting patterns of the same type respects the limitation on the maximum number of simultaneously open stacks. This latter block of constraints is based on some of the constraints proposed in [5]. Finally, we present the objective function and some additional constraints.
For all ∈ ′ , the set of cutting patterns of the same type must be present in the sequence of sets of cutting patterns of the same type if, and only if, at least one cutting pattern in is executed in the CS-LOSP solution. Therefore, we propose the following block of constraints: The constraints (21), (22) and (29) guarantee that the set of dummy cutting patterns is used. The sets of constraints (23) ensure that, considering as a sufficiently large constant, if a cutting pattern in is used ( ∑︀ ∈ > 0) then at least one set must be performed immediately after the execution of the cutting patterns in . The constraints (24) guarantee that if no cutting pattern in is used ( ∑︀ ∈ = 0) then no cutting patterns set is executed immediately after the execution of the cutting patterns in . Lastly, the constraints (25) ensure that if any cutting pattern in is used, then exactly one set of cutting patterns is executed immediately after the execution of the cutting patterns set . Similarly, the sets of constraints (26), (27) and (28) assure that if any cutting pattern in is used, then exactly one set of cutting patterns is executed prior to the execution of the set of cutting patterns . If no cutting pattern in is used, then the execution of the set of cutting patterns can not be preceded by the execution of any set of cutting patterns of the same type.
Following, we present and describe, in the context of the CS-LOSP, the constraints proposed in [5] that are used in the Formulation II.
The constraints (30) ensure that a stack related to an item type in ∖ can only be open after the execution of the set of cutting patterns of same type if the stack was already open before the execution of the set of cutting patterns of same type . The left-hand side of the set of constraints (31) counts the number of open stacks after the execution of the set referring to items that are not generated when executing a cutting pattern in . Thus, the constraints (31) ensure that this quantity, plus the number of different item types generated by the execution of a cutting pattern in is less than or equal to , ensuring that the limit on the maximum number of open stacks is respected. Finally, the constraints (32) ensure that can only be equal to one if the set is executed immediately after . If a set of cutting patterns is not used, then we have = = 0, for every , ∈ ′ 2 , the set of constraints (32), proposed in [5], does not account for this particular case, therefore, we add the following constraints to the model: The set of constraints (33) together with the constraints (32) ensure that if a set of cutting patterns is not used, then = = 0 for , ∈ ′ 2 . The remaining constraints as well as the objective function of the proposed Formulation II is given by: and constraints (21)-(33).
The objective function (34), as well as the constraints (35)-(38), are equivalent to the sets of constraints (8)- (12), respectively. The constraints (39) are based on the constraints proposed in [17], to avoid sub-cycles. This set of constraints have two main goals, the first is to ensure that the sequence of sets of cutting patterns starts and ends with the dummy set 0 . The second goal of the constraints is to eliminate sequences in which more than 2 sets of cutting patterns are executed, i.e., to eliminate sub-cycles in which a set of cutting patterns is executed more than once. A detailed explanation of this set of constraints can be found in [17]. As stated in [17], the variables are defined as non-negative integers. We can show that in this particular case their domain can be restricted to {1, 2, . . . , 2 }. Let = 1 → 1 → . . . → be a feasible sequence of sets of cutting patterns with ≤ 2 , then, by setting 1 = 1, 2 = 2, . . . , = we can see that the constraints (39) are satisfied. Since in all feasible sequence of sets of cutting patterns, at most 2 sets of cutting patterns are executed, we conclude that the domain of the variables can be restricted to {1, 2, . . . , 2 }. The remaining constraints are related to the domain of the variables.

Computational experiments
In order to validate the proposed models and to compare the time required to determine an optimal solution, computational tests on random instances are performed and analyzed. In Section 4.1 we describe the random data set generated for the two-dimensional CS-LOSP, which are available at https://github.com/ ggazzinelli/2D-CS-LOSP, and in Section 4.2 we detail the cutting pattern generation used in this work as well as a proposition that guarantees that the dominated cutting patterns can be removed from the solution without loss of optimality. Analyses of the size and the quality of the linear programming relaxation of the proposed mathematical formulations are presented in Sections 4.3 and 4.4, respectively. Finally, in Section 4.5 we present the computational results for the two-dimensional CS-LOSP.
The approaches were coded in Julia Programming Language (version 1.1.1) using the IBM ILOG CPLEX (version 20.1) as the general ILP solver. The experiments were carried out on a computer with an Intel 7i-8700 (3.20 GHz), 16 GB of RAM.

Data set for the two-dimensional CS-LOSP
In this section we describe the proposed data set for the two-dimensional CS-LOSP that was considered for analyzing and comparing the Integrated Yanasse and Lamosa (IYL), Formulation I and Formulation II models. We assume that a sufficiently large number of identical two-dimensional objects is available to be cut. According to the typology proposed in [21], in the context of CSPs, this particular CSP is known as the Single Stock Size Cutting Stock Problem (SSSCSP). Furthermore, for the computational experiments, exact two-stage guillotine cutting patterns were considered. The characteristics of the instances are described as follows.
The dimension of the standard objects to be cut × is fixed at 1000 × 500. Two intervals were considered to generate the length of the items [200, 500] and [300, 800]. The length of the demanded items ℓ was randomly generated without repetition, that is, items of different types have different lengths. The width of the required items was randomly generated as one of the values of the set {100, 200, 300, 400}. The number of distinct types of items in each instance is 5 or 10. The demand of items was randomly generated in the range [100, 400], i.e., ∈ [100, 400], = 1, . . . , | |. By combining the different parameters mentioned above, four classes of instances were generated: The parameter represents the amount of stacks that can be opened, this parameter can significantly change the time required to reach an optimal solution. Since | | is the number of types of items, the value of can vary from 1 up to | |. In [2], the authors argue that the relevant values of are typically small. Furthermore, from the point of view of practical application, this number should also be small because the greater the number of unloading stations (number of open stacks), the more expensive and spacious the equipment must be. Thus, in the computational tests, we considered three values for , namely: = 2, = 3 and = 4. Note that for = 1 only homogeneous cutting patterns can be used and, therefore, the problem is trivial. Moreover, for the computational experiments, we consider = 1, = 1, . . . , .

Generation of cutting patterns and reduction strategies via dominance and feasibility
As described in [11], the 2-stage guillotine cutting patterns can be built in two steps. In the first step, horizontal strips are defined and, for each horizontal strip, the feasible cutting patterns. In the second step, the number of times each strip is used with its respective cutting pattern is determined.
Considering the exact 2-stage guillotine cutting pattern, an item type can be produced by cutting a strip if and only if the width of the strip and the item type is the same. Thus, we are interested only in strips such as its width is equal to for at least one index ∈ . Let be the number of distinct strips that are capable of producing at least one type of item when cut, note that since it is possible to have 1 = 2 for 1 ̸ = 2 , then ≤ | |. Let = 1, . . . , be the indexes that identify the strips of dimensions × and be the set of item types that may be produced by the strip , i.e., = { | = }. Each strip can be cut in several ways, the specific way in which a strip is cut corresponds to a onedimensional cutting pattern. Considering as the number of times that item type is present in the strip , ∈ we must have: ∑︁ Every feasible solution of (45) corresponds to a feasible one-dimensional cutting pattern for the strip . Let be the set of the distinct one-dimensional cutting patterns that can be obtained by cutting a strip of dimensions × . For all ∈ and ∈ , let be the number of times the strip is cut according to the cutting pattern , ∀ ∈ and ∈ , must satisfy: Finally, let be the number of times item type is produced by cutting the strip according to the onedimensional cutting pattern . A two-dimensional guillotine 2-stage exact cutting pattern can be represented by an | |−dimensional vector ( ) = ( | | ) where the th coordinate corresponds to the number of times that item type is present in the cutting pattern.
The number of cutting patterns of a class depends on the dimension of the items (length and width) and the number of different types of items. For classes such that the size of the items is relatively small or that there are a lot of items of different types, the number of feasible cutting patterns can be excessively large, making it difficult to solve the problem up to optimality.
In this subsection, we show that there are two subsets of the cutting patterns that can be eliminated without affecting the CS-LOSP optimal solution. The first one regards the cutting patterns that become infeasible due to the limitation on the number of open stacks. Whenever a cutting pattern is performed, the stacks related to the cut items must be opened. Thus, if the number of different types of items in a single cutting pattern already exceeds the maximum limit of stacks that can be opened simultaneously, this cutting pattern cannot be part of the solution and can be removed from the problem without changing the CS-LOSP optimal solution. The second one regards the cutting patterns that are dominated by another cutting pattern. We define dominated cutting patterns, in the context of a CS-LOSP, through Proposition 3, as follows: Proposition 3. In a CS-LOSP in which overproduction is allowed, and the objective is to minimize the number of cut objects, consider two distinct cutting patterns: 2 , . . . , 2 , . . . , ( 2) | | ) . If both cutting patterns produce the same types of items when cut, that is, for all such that ( 1) = 0, we have ( 2) = 0 and vice versa, and ( 2) ≥ ( 1) for ∈ . Then, the cutting pattern ( 1 ) is dominated by the cutting pattern ( 2) . Therefore, ( 1) can be removed from the problem without changing the optimal CS-LOSP solution.
Proof. Consider an optimal solution for the CS-LOSP in which the cutting pattern ( 1) is part of the solution. When ( 2) ≥ ( 1) for ∈ , then the quantity of items obtained from the cutting pattern 2 is equal to or greater than the quantity of items obtained from the cutting pattern 1 , for any type of item. Therefore, when replacing the cutting pattern 1 by the cutting pattern 2 , the quantity of items remains the same or increases, this way the demand constraints are fulfilled and the quantity of used objects remains the same. Furthermore, if for all such that ( 1 ) = 0, we have ( 2) = 0, and vice versa, then the number of open stacks is exactly the same, since both cutting patterns generate the same types of items. Therefore, an execution of the cutting pattern 1 can be replaced by the execution of the cutting pattern 2 without changing the value of the objective function. Thus, the removal of the cutting pattern 1 does not change the value of the objective function at all in an optimal solution. In this case, the cutting pattern 1 is dominated by the cutting pattern 2 .
Proposition 3 guarantees that all cutting patterns dominated by some other cutting pattern can be removed without altering the optimal solution to the problem. Consequently, the overall number of cutting patterns is reduced. The number of variables and constraints of the models proposed in this research is closely linked to the number of cutting patterns. Thus, adopting the strategy of removing dominated cutting patterns considerably reduces the computational complexity of the problem and, therefore, this procedure is used in computational tests.
Similar to the formulations proposed in [2,24], the formulations proposed in this research require that the feasible cutting patterns be determined a priori. The amount of feasible cutting patterns can be reduced due to Proposition 3. Furthermore, observe that if a cutting pattern produces more than types of items it is infeasible in the context of CS-LOSP, therefore we only generate cutting patterns that produce at most four different item types, since this is the biggest value of considered in the computational experiments performed in this section. Hence, the first step for carrying out the computational experiments, is the generation of the feasible cutting patterns, ignoring the dominated patterns in accordance with Proposition 3 and those such that the number of items generated from their execution is greater than four. This set of generated cutting patterns is used in all computational experiments performed in this section.

Models size
By sequencing sets of cutting patterns of the same type rather than sequencing the cutting patterns individually, it is possible to significantly reduce the number of variables and constraints of the models. While the IYL model, proposed in [24], has 2| | + 2 + 2 − | | variables, the Formulation I has 2| | 2 + 2 2 + 2 − | | variables. Since the value of 2 can be significantly lower than the value of , the number of variables in the Formulation I tends to be smaller than the number of variables in the IYL model.
The Formulation II has 2( + 1) Table 1 shows the comparison between the number of variables and constraints regarding the three formulations for Classes 1-4. We can notice that, among the three formulations, the Formulation I is the most compact. Moreover, the proposed Formulation I and Formulation II have a lower number of constraints and variables when compared to the formulation from the literature. The difference in size of the models is particularly noticeable for classes with items of small size, i.e., Classes 1 and 2.

Analysis of the quality of linear programming relaxation
The linear programming relaxation of an ILP model is an important tool to assess the model strength. Moreover, the linear programming relaxation of a formulation can provide useful lower bounds. In order to compare the strength of the formulations proposed in this research and the one proposed in [24], we perform some computational experiments to compare the quality of the linear programming relaxation of the models. In this subsection, we present the results for the computational experiments performed on 10 instances of Class 1 considering = 2, i.e., the maximum number of open stacks allowed was fixed at 2.
For this set of instances, the average value for the integer optimal solution to the CS-LOSP the equals to 347. Regarding the linear programming relaxation of the Formulation I and the model proposed in [24], both

Computational results
In this subsection, we compare the computational time spent to determine an optimal solution via the IYL, Formulation I and Formulation II models for Classes 1 to 4 and the obtained results are presented in Table 2.
The CPLEX absolute GAP was set at its default of 10 −6 . Remembering that no cutting pattern with more than item types was considered. The first column of Table 2 identifies the instance of the class; the second column presents the value of ; the third, fourth and fifth columns present the computational time spent to reach an optimal solution considering the IYL, Formulation I and Formulation II models, respectively. The sixth column presents the value of the objective function of the optimal solution to the problem. The remaining columns of the table repeat the same pattern of the second, third, fourth, fifth and sixth columns. In the Table 2 we refer to the Formulation I and Formulation II as F1 and F2, respectively. Instances in which none of the three models was able to reach an optimal solution, within the time limit of 7200 s, were omitted from the table.
Among the 120 test instances, it was possible to solve 87, 103 and 88 by the IYL, Formulation I and Formulation II models, respectively. The Formulation II model presents interesting results for the instances where = 2, for these instances, while Formulation II outperforms the other two formulations by solving 36 instances up to optimality while the IYL and Formulation I models solve 29 and 31 instances, respectively. For = 3 and = 4 the Formulation I presents better results. Based on the results presented in the previous tables, we can observe that the size of the items is a factor with a great impact on computational time. For classes with items of smaller size, the time required to determine an optimal solution was greater, and, therefore, the number of instances solved for these classes was smaller. This result is expected since the smaller the size of the items, the greater the number of possible cutting patterns and, consequently, the size of the model. Another parameter that influences the time required to determine an optimal solution is the number of items of different types. Classes containing a greater number of types of items require more computational time.
As discussed in Section 2, by sequencing subsets of cutting patterns of the same type instead of sequencing the cutting patterns individually, it is possible to significantly reduce the number of variables and constraints in the models. This reduction is particularly notable for classes in which the item size is shorter. The reduction in the number of variables and constraints directly reflects on the time required to determine an optimal solution, the models proposed in this research are able to solve a larger number of instances when compared to the IYL formulation, the results are particularly remarkable for Class 2 in which the IYL formulation is able to determine the optimal solution for only one instance, while the Formulation I and Formulation II solve 13 and 15 instances, respectively.

Conclusions and future research
In this research, we propose two new integer linear programming models for the cutting stock with limited open stacks problem (CS-LOSP), both valid for the one-dimensional and the two-dimensional CS-LOSP. The proposed models are compared with the formulation proposed in [24]. To guarantee the validity of the model, several computational tests were performed with randomly generated two-dimensional instances of the CSP. In order to eliminate symmetrical solutions of the problem and to reduce the search space for solutions, we demonstrate that the CS-LOSP can be reformulated as the problem of determining how often cutting patterns should be performed in order to minimize material waste while simultaneously finding a sequence of sets of cutting patterns of the same type whose execution respects the pre-established maximum limit on the number of open stacks. It is worth mentioning that sequencing sets of cutting patterns of the same type instead of sequencing all the cutting patterns individually enables a reduction on the number of variables and constraints in the model. This reduction is more expressive for instances where the demanded item sizes are relatively small. Furthermore, by removing symmetric solutions from the problem, it is possible to notice an increase in model performance. Considering the 120 instances used in the computational tests, it was possible to solve a total of 102 and 89 instances respecting the time limitation of 7200, using Formulation I and Formulation II, respectively, while for the model proposed in [24], a total of 87 instances were solved. Although the proposed modeling presents interesting results, the computational tests performed are limited and suggest the need to develop more efficient models for the resolution of the CS-LOSP, especially to deal with instances containing a large number of different types of items where the results obtained in this work are unsatisfactory. As further research, we recommend investigating alternative solution approaches, such as heuristics and metaheuristics, aiming to solve larger instances.