A general framework for providing interval representations of Pareto optimal outcomes for large-scale bi- and tri-criteria MIP problems

The Multi-Objective Mixed-Integer Programming (MOMIP) problem is one of the most challenging. To derive its Pareto optimal solutions one can use the well-known Chebyshev scalarization and Mixed-Integer Programming (MIP) solvers. However, for a large-scale instance of the MOMIP problem, its scalarization may not be solved to optimality, even by state-of-the-art optimization packages, within the time limit imposed on the optimization. If a MIP solver cannot derive the optimal solution within the assumed time limit, it provides the optimality gap, which gauges the quality of the approximate solution. However, for the MOMIP case, no information is provided on the lower and upper bounds of the components of the Pareto optimal outcome. For the MOMIP problem with two and three objective functions, an algorithm is proposed to provide the so-called interval representation of the Pareto optimal outcome designated by the weighting vector when there is a time limit on solving the Chebyshev scalarization. Such interval representations can be used to navigate on the Pareto front. The results of several numerical experiments on selected large-scale instances of the multi-objective, multidimensional 0-1 knapsack problem illustrate the proposed approach. The limitations and possible enhancements of the proposed method are also discussed.


Introduction
The derivation of optimal solutions to large-scale instances of the Mixed-Integer Programming (MIP) problem can be impossible within a reasonable time limit even for contemporary commercial MIP solvers, e.g., GUROBI (Gurobi (2023)), CPLEX (IBM (2023)).In this case, a MIP solver provides the optimality gap (MIP gap) that gauges the quality of the approximate solution, i.e., the last feasible solution (incumbent).This optimality gap is calculated based on the incumbent and the so-called MIP best bound.
In the current work, we say that an instance of the MOMIP problem is large-scale if its Chebyshev scalarization cannot be solved to optimality by a MIP solver within an assumed time limit that is reasonable in the decision-making process.The existence of this limit is justified in solving practical multi-criteria decision-making problems.When there is a time limit on deriving a single Pareto optimal solution, the Chebyshev scalarization of the instance may not be solved to optimality.The decision maker (DM) then obtains the incumbent, i.e. the approximation of the Pareto optimal solution, as well as the MIP gap of the single-objective optimization problem.However, based on this information, the quality of the approximation of a single component (namely its lower and upper bounds) of the Pareto optimal outcome, i.e. the image of the Pareto optimal solution in the objective space, cannot be shown to the DM.And it is based on these components that the DM navigates on the Pareto front (set of Pareto optimal outcomes).Fortunately, there is a method to provide the DM with such lower and upper bounds in the literature.
In Kaliszewski and Miroforidis (2019), a general methodology for multi-objective optimization to provide lower and upper bounds on objective function values of a Pareto optimal solution designated by a vector of weights of the Chebyshev scalarization of a multi-objective optimization problem has been proposed.The bounds form the so-called interval representation of the Pareto optimal outcome.The DM can use interval representations instead of (unknown) Pareto optimal solutions, to navigate on the Pareto front.To derive them, one needs the so-called lower shells and upper shells whose images in the objective space are finite two-sided approximations of the Pareto front (see, e.g., Kaliszewski and Miroforidis (2014)).
In Kaliszewski and Miroforidis (2022), it has been shown how to provide lower and upper shells to large-scale instances of the MOMIP problem.In that work, lower shells are composed of incumbents to the Chebyshev scalarization of the MOMIP problem derived within the time limit, and upper shells consist of elements that are solutions to the Chebyshev scalarization of a relaxation of the MOMIP problem.
However, there is a lack of an algorithmic method for deriving an upper shell that is necessary to calculate the interval representation of the Pareto optimal outcome designated by a given vector of weights of the Chebyshev scalarizing function.The idea of how to derive such useful upper shells for the MOMIP problem with two objective functions has been shown in our earlier works Kaliszewski and Miroforidis (2021) and Miroforidis (2021).
In the current work, we combine ideas from works Kaliszewski and Miroforidis (2019), Kaliszewski and Miroforidis (2022), Kaliszewski andMiroforidis (2021), andMiroforidis (2021).For this reason, our work is an incremental one.For the MOMIP problem with up to three objective functions, we propose an algorithmic method of deriving upper shells that can be used to calculate the interval representation of a single Pareto optimal outcome designated by a given vector of weights of the Chebyshev scalarizing function.This opens the way for providing the DM with this representation when there is a time limit for deriving a single Pareto optimal solution.Because of the need to derive the appropriate upper shells, additional time is needed for optimization, but as we show in numerical experiments, this time can be a fraction of the assumed time limit.To illustrate our method, we present results of several numerical experiments with selected large-scale instances of the multi-objective multidimensional 0-1 knapsack problem.
To our best knowledge, the method we propose is the only algorithmic method for determining the interval representation of the Pareto optimal outcome given by weights of the Chebyshev scalarizing function for large-scale instances of the MOMIP problem, assuming the existence of a time budget for optimization.This method which is a generic framework for providing these interval representations is the main contribution of this work.
The current work is organized as following.In Section 2, we formulate the MOMIP problem and we recall a method for the derivation of Pareto optimal solutions with the use of the Chebyshev scalarization.In Section 3, we briefly recall the theory of parametric lower and upper bounds.There, we also introduce the concept of the interval representation of the implicit Pareto optimal outcome as well as an indicator measuring its quality.In Section 4, we present two versions of an algorithm for deriving interval representations of implicit Pareto optimal outcomes.In Section 5, we conduct extensive numerical experiments as well as discuss their results.In Section 6, we show the limitations of the proposed method as well as discuss how to eliminate them.Section 7 contains some final remarks.

Background
where objective functions, and "vmax" is the operator of deriving set N that contains all Pareto optimal solutions in X 0 .The set R k is called the objective space.Solution x ∈ X 0 is Pareto optimal, if for any which is denoted by the relation x ≻ x.We say that element f (x), x ∈ X 0 , is the outcome of x.Set f (N ) is called the Pareto front.
Given λ, x P opt (λ) denotes the implicit Pareto optimal solution designated by λ that is a solution which would be derived if problem (2) with λ were solved to optimality.f (x P opt (λ)) denotes the implicit Pareto optimal outcome designated by λ.

Lower and upper bounds on components of implicit Pareto optimal outcomes
The general theory of lower and upper bounds on components of implicit Pareto optimal outcomes is given in Kaliszewski and Miroforidis (2019).To calculate the bounds, one needs two finite sets (that satisfy certain properties) namely a lower shell (S L ⊆ X 0 ) and upper shell Given λ, S L , and S U , the theory provides formulas for calculating lower and upper bounds on Formulas for lower bounds L l (S L , λ) and upper bounds U l (S U , λ) are shown in Kaliszewski and Miroforidis (2022).In that work, all those elements of the theory of lower and upper bounds that are required to understand the rest of the current work are presented in a synthetic way.
In addition, and of great relevance to the current work, the theory specifies that only elements x ∈ S U appropriately located with respect to the vector of lower bounds L(S L , λ) := (L 1 (S L , λ), . . ., L k (S L , λ)) can provide upper bounds Ul({x}, λ) = f l (x) for f l (x P opt (λ)) for some l.This is specified by the following lemma defined in Kaliszewski and Miroforidis (2019).
Lemma 1.Given lower shell S L and upper shell S U .Suppose x ∈ S U and L l (S L , λ) ⩽ f l (x) for some l and L l (S L , λ) ⩾ f l (x) for all l = 1, . . ., k, l ̸ = l.Then x provides an upper bound for f l (x P opt (λ)), namely f l (x P opt (λ)) ⩽ f l (x).

The interval representation of the implicit Pareto optimal outcome
Given λ, S L , and For k = 2, components of the interval representation of f (x P opt (λ)), lower and upper shells as well as vectors of lower and upper bounds are illustrated in Figure 1.

Providing interval representations of implicit Pareto optimal outcomes
Given λ, we assume that there is a time limit T L on solving problem (2) by a MIP solver.We also assume that if the MIP solver can not derive the solution to (2), i.e., x P opt (λ), within T L , then it provides incumbent IN C λ that is the approximation of x P opt (λ).In this case, our goal is to provide R(S L , S U , λ) calculated on some lower shell S L and on some upper shell S U .

The derivation of lower and upper shells
As in Kaliszewski and Miroforidis (2022), we will use S L := {IN C λ } as a valid lower shell one can use to calculate L l (S L , λ), l = 1, . . ., k.
To populate upper shell S U , the following two Lemmas defined in Kaliszewski and Miroforidis (2022) can be used.Lemma 2. Given λ ′ , solution x ′ to the relaxation of problem ( 2) with X ′ 0 , X ′ 0 ⊃ X 0 , is not dominated by solution x to problem (2) for any λ.Lemma 3. If x is a Pareto optimal solution to the relaxation of problem (1) with X ′ 0 , then set {x} is an upper shell to problem (1).
Given X ′ 0 ⊃ X 0 and λ, let ChebRLX(X ′ 0 , λ) denote the Chebyshev scalarization (problem (2)) of some relaxation of the MOMIP problem (problem (1)) with feasible set X ′ 0 for some λ.Based on Lemmas 2 and 3, one can derive a single-element upper shell by solving ChebRLX(X ′ 0 , λ).Given X ′ 0 ⊃ X 0 , the sum of such single-element upper shells derived for different vectors λ forms upper shell S U .
The surrogate relaxation of problem (1) with , where µ p ⩾ 0, p = 1, . . ., m, µ ̸ = 0, is a valid relaxation of this problem (see Kaliszewski and Miroforidis (2022)).µ is a vector of surrogate multipliers.We will use this type of relaxation with µ as a parameter to derive elements of an upper shell.We also follow what has been shown in Kaliszewski and Miroforidis (2022) on large-scale instances of the MOMIP problem that Given λ and S L , based on Lemma 1, element x of upper shell S U is a source of an upper bound on f l (x P opt (λ)), l ∈ {1, . . ., k}, when f (x) is appropriately located with respect to the vector of lower bounds L(S L , λ).In Miroforidis (2021), an idea of how to derive an upper shell that consists of an element useful to calculate upper bounds on f l (x P opt (λ)) has been proposed.This idea is to probe the objective space by perturbing components of vector λ.Yet, there is no algorithmic approach in Miroforidis (2021) doing that.In the current work, we try to fill in this gap.
For k = 2, the idea of an algorithm for deriving upper shell S 1 U whose some element is a source of an upper bound on f 1 (x P opt (λ)) is shown in Figure 2. Let us assume that vector µ is given.At the beginning, S 1 U := ∅.In the first step, we set the first probing vector for some δ > 0 (as a probing vector, we exclude λ because we expect that the corresponding solution will not be properly located with respect to the vector of lower bounds, see Kaliszewski and Miroforidis (2021)).Let x λ ) is not appropriately located with respect to the vector of lower bounds L = L(S L , λ).Hence, we continue.In the second step, we set λ is not a source of an upper bound on f 1 (x P opt (λ)).Hence, we continue.In the third step, we set λ U is a valid upper shell.To obtain an upper bound on f 2 (x P opt (λ)), we need to derive upper shell S 2 U .To do this, in the first step, we set λ and proceed in the same way.Given l ∈ {1, . . ., k}, the FindUpperShell algorithm tries to derive upper shell S l U whose element x is a source of an upper bound on f l (x P opt (λ)), i.e.Ul(S l U , λ).In Line 2, we set step size δ that is used to modify components of consecutive probing vectors λ ′ .Parameter γ > 0 controls the step size, i.e., the greater the value of parameter γ, the denser the sampling of the objective space to search for the desired element of the upper shell.In the main loop (Lines 4-14), we populate upper shell S l U checking if its new element fulfills conditions of Lemma 1 to be a valid source for the upper bound on x fulfills conditions of Lemma 1 for l, L(S L , λ), and S U = {x} then U l(S l U , λ) := f l(x) ; break ; Comment: break while.
fl(x P opt (λ)).The algorithm stops when λ ′ l ⩾ 1 OR some component of λ ′ is negative OR an element that fulfills conditions of Lemma 1 is found.Lines 6 and 9 guarantee that k l=1 λ ′ l = 1.The exit condition of the "while" loop ensures that λ ′ l > 0, l = 1, . . ., k.

If no element of S l
U satisfies conditions of Lemma 1, the algorithm simply returns the upper shell as well as the only available upper bound on f l (x P opt (λ)), namely y * l .Otherwise, an upper bound better than y * l is returned as well as the upper shell.

Calculating interval representations
Based on the above elements, an interval representation of the Pareto optimal outcome given by vector λ can be calculated with the use of the Chute algorithm.Along with the interval representation, this algorithm also returns lower and upper shells that were determined during its operation.In Subsection 5.7, we explain why the algorithm also returns lower and upper shells.Line 4 of the algorithm needs clarification.Vector µ can be set as shown in Kaliszewski and Miroforidis (2022), namely by taking µ p := 1, p = 1, . . ., m.In that work, all surrogate multipliers have the same value.We call this version of the Chute algorithm Chute1.
Yet, in Kaliszewski and Miroforidis (2022), Section "Final remarks", it has been suggested that "Tighter bounds might be obtained with other values of the multipliers.This possibility is worth exploring in future works.".Unfortunately, there is no idea there how to select a vector of surrogate multipliers other than (1, . . ., 1) ∈ R m .However, we can use the theory of duality for this purpose.
Given µ, λ, let x be the solution to ChebRLX(X ′ 0 (µ), λ), and s(µ) be the objective function value of x.Based on Lemmas 2 and 3, {x} is a valid upper shell.Let s be the objective function value of the solution to problem (2) with λ and X 0 .It is a well-known fact (see, e.g., Glover (1965), Glover (1968)) that s ⩾ s(µ).Hence, for a given λ and µ, s(µ) is a lower bound on values of s.
Given λ, the best (highest) lower bound s * on values of s is the objective function value of the solution µ * to the following surrogate dual problem that is connected to the Chebyshev scalarization (problem (2)).Solving (6) to optimality can be time-consuming.Yet, a suboptimal vector of multipliers μ can be determined instead of µ * .It can be done with the help of a quasi-subgradient-like algorithm (we shall call it Suboptimal) by Dyer (Dyer (1980)) with the following stopping condition.6) is greater than N " OR "time limit on optimization is greater than T S seconds".

"Number of iterations without improving the value of the objective function in problem (
In the current work, we set time limits on computation, hence the above stopping condition is justified in practice.
A version of the Chute algorithm that uses (in Line 4) the Suboptimal algorithm to set vector of surrogate multipiers µ for a given λ, we shall call Chute2.It has two additional input parameters N and T S .
Let us note, that in the Chute2 algorithm, we set the vector of surrogate multipliers once for a given λ.The FindUpperShell algorithm uses perturbations of the λ vector to sample the objective space, and for all these perturbations the same vector µ is used.It is our heuristic assumption that even using the same vector µ for various vectors λ ′ , that are close to λ, the Chute2 algorithm is able to find a better R(S L , S U , λ), so tighter upper bounds on components of f (x P opt (λ)), than the Chute1 algorithm.However, it is at the cost of increasing the computation time relative to Chute1 by at most T S .We will check it experimentally in the next section.
The idea (for k = 2 and ρ = 0) of using suboptimal values of surrogate multipliers to get an upper shell that is a source of a better upper bound is illustrated in Figure 3. Let µ I := (1, . . ., 1) ∈ R m , and μ be the output of the Suboptimal algorithm (with some N and T S ) for some λ.x(µ I ) is the solution to optimization problem (2) with X 0 replaced with X ′ 0 (µ I ), and s(µ I ) is the objective function value of x(µ I ).x(μ) is the solution to optimization problem (2) with X 0 replaced with X ′ 0 (μ), and s(μ) is the objective function value of x(μ).Vector of lower bounds L is marked with a triangle.Both elements f (x(μ)) and f (x(µ I )) are appropriately located with regards to L (see Lemma 1) to be sources for an upper bound on f 2 (x P opt (λ)).As s(μ) > s(µ I ) (contours of the Chebyshev metric for both values s(μ) and s(µ I ) are shown by solid thin lines) as well as is a source of a better upper bound on f 2 (x P opt (λ)) for than element x(µ I ), as upper bounds are calculated with the use of components of the upper shell elements.In Figure 3, f (x(μ)) is closer to the (unknown) Pareto front (represented by the solid curve) than element f (x(µ I )).It could happen that condition f 1 (x(μ)) < f 1 (x(µ I )) AND f 2 (x(μ)) < f 2 (x(µ I )) does not hold.In this case, if f 2 (x(μ)) ⩾ f 2 (x(µ I )), we obtain no better upper bound on f 2 (x P opt (λ)).On the other hand, if f 1 (x(μ)) ⩾ f 1 (x(µ I )) and still f (x(μ)) is appropriately located with regards to L (see Lemma 1) to be a source for an upper bound on f 2 (x P opt (λ)), we get a better upper bound on f 2 (x P opt (λ)).

Chute
, λ) be the vector of lower bounds ; 4 Set vector of multipliers µ ;

Computational experiments
In this section, we present the results of two experiments where we apply algorithms Chute1 and Chute2 presented in Subsection 4.2 to selected instances of the Multi-Objective Multidimensional 0-1 Knapsack Problem (MOMKP) with two and three objective functions.The instances are demanding for modern MIP solvers.

Multi-objective multidimensional 0-1 knapsack problem
For k > 1, the MOMKP is formulated in the following way.vmax where all a p,j , c p,j are non-negative.In Kaliszewski and Miroforidis (2022), it has been explained why the MOMKP is N P-hard.

Test instances of the MOMIP problem
As tri-criteria instances of the MOMKP, we take two instances from Kaliszewski and Miroforidis (2022) that were generated based on the 1st problem of the 6th group (n = 500, m = 10) of multidimensional 0-1 knapsack problems as well as on the 1st problem of the 9th group (n = 500, m = 30) (both single-objective problems are stored in Beasley OR-Library, http://people.brunel.ac.uk/∼mastjjb/jeb/info.html).We call these tri-criteria instances Three6.1 and Three9.1,respectively.
By removing the third objective function of problem Three6.1,we create a bi-criteria instance called Bi6.1.Analogously, by removing the third objective function of problem Three9.1,we create a bi-criteria instance called Bi9.1.

Experimental setting
Gurobi (version 10.0.0) for Windows 10 (x64) is our selected MIP solver.The optimizer is installed on the Intel Core i7-7700HQ-based laptop with 16 GB RAM.
To be consistent with limiting optimization time, we do not derive element ŷ to optimality.So, it is not known.Instead, we separately maximize each objective function of problem (7) within the time limit equal to 400 seconds.For instances Three6.1 and Three9.1,we set y * l , l = 1, 2, 3, to the best upper bound (provided by the MIP solver) on values of the respective objective functions (none of these maxima the MIP solver determined in this time limit).Thus, for Three6.1 y * := (128872, 131116, 131738), and for Three9.1 y * := (119379.88,119365,118122).Obviously, ŷl < y * l .Hence, such y * approximating ŷ can be used in (2) as well as when calculating lower and upper bounds.To avoid redundant calculations, for instances Bi6.1 and Bi9.1, we take only the first two components of respective y * .
For instances Bi6.1 and Bi9.1, we generate one set of five vectors λ uniformly sampled from two-dimensional unit simplex (see Smith and Tromble (2004)), and obtain corresponding to them vectors of lower bounds L(S L , λ) (Table 1 and Three9.1,we generate separate sets of five vectors λ, uniformly sampled from the three-dimensional unit simplex, and obtain corresponding to them vectors of lower bounds L(S L , λ) (Tables 2 and 3 For all problem instances, for no vector λ, the selected MIP solver derived the solution to problem (2) in the assumed T L = 1200 seconds.Thus, the use of the Chute algorithm to determine interval representations of Pareto optimal outcomes given by vectors λ is justified.
We conduct two numerical experiments.In experiment 1, we test the behavior of algorithm Chute1.In experiment 2, we test the behavior of algorithm Chute2.In both experiments, on generated test instances, we test the behavior of the Chute algorithm for γ := 10, 30, 50.Given λ, we check the impact of parameter γ on components of G P sub (R(S L , S U , λ)).
In the tables with results of the experiments, the meaning of the columns is as follows.
• U (S U , λ) -components of the vector of upper bounds; • GAP P sub % -components of G P sub (R(S L , S U , λ)); • |S U | -the number of elements in the upper shell; • Time S U (s) -time to derive the upper shell (in seconds); for Chute2, the running time of the Suboptimal algorithm is given in parentheses.
In bold, we indicate the improvement of a single component of G P sub (R(S L , S U , λ)) when changing the value of parameter γ to a higher value, namely, we consider changes from γ = 10 to γ = 30 and from γ = 30 to γ = 50.By underscore, we indicate the deterioration of a single component of G P sub (R(S L , S U , λ)) when changing the value of parameter γ to a higher value, namely, we consider changes from γ = 10 to γ = 30 and from γ = 30 to γ = 50.

Experiment 1
In this experiment, we check the behavior of the Chute1 algorithm.
The results for instance Bi6.1 are shown in Tables 4-6, and the results for instance Bi9.1 are shown in Tables 7-9.The results for instance Three6.1 are shown in Tables 10-12, and the results for instance Three9.1 are shown in Tables 13-15.
For instance Bi6.1, when changing γ = 10 to γ = 30, we observe an improvement in at least one component of G P sub (R(S L , S U , λ)) for four vectors λ, although only in two cases (λ no. 3 and 5) two components improve.Yet, when changing γ = 30 to γ = 50, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for three vectors λ.For λ no. 3, we observe a deterioration of the first component of G P sub (R(S L , S U , λ)), and at the same time, an improvement of the second.For λ no. 5, we observe an improvement of the first component of G P sub (R(S L , S U , λ)), and at the same time, a deterioration of the second.
When changing γ = 10 to γ = 50, we observe an improvement in at least one component of G P sub (R(S L , S U , λ)) for all vectors λ.
For instance Bi9.1, we observe a similar phenomenon (an improvement as well as a deterioration), although when changing γ = 10 to γ = 30, we observe an improvement in only one component of G P sub (R(S L , S U , λ)) for just two vectors λ.When changing γ = 10 to γ = 50, we observe an improvement in G P sub (R(S L , S U , λ)) for vectors λ no.1-4 (at least one component improves).For λ no. 5, G P sub (R(S L , S U , λ)) remains unchanged.
For instances Bi6.1 and Bi9.1, the higher the value of parameter γ (higher sampling density of the objective space ), the more numerous the derived upper shells are.For each vector λ, the time to derive the corresponding upper shell is a small fraction of the assumed time limit T L = 1200 seconds.
Let us check the results for tri-criteria instances.For instance Three6.1, when changing γ = 10 to γ = 30, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for three vectors λ, although only for one (λ no.4) all components improve.When changing γ = 30 to γ = 50, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for three vectors λ.We also observe a deterioration of the first component of G P sub (R(S L , S U , λ)) for λ no. 2, and, at the same time, an improvement on its third component.When changing γ = 10 to γ = 50, we observe an improvement in G P sub (R(S L , S U , λ)) for all vectors λ (at least one component improves).For instance Three9.1 and vectors λ no.2-5, upper bounds on all components of f (x P opt (λ)) are equal to the corresponding component of y * .Only for λ no. 1, f 3 (x P opt (λ)) < y * 3 , and when changing γ = 10 to γ = 30 as well as γ = 30 to γ = 50, there is an improvement only for the third component of G P sub (R(S L , S U , λ)).For instances Three6.1 and Three9.1, the higher the value of parameter γ (higher sampling density of the objective space ), the more numerous the derived upper shells are.For instance Three6.1 and instance Three9.1 with γ = 10, for most vectors λ, the time to derive the corresponding upper shell is a small fraction of the assumed time limit T L = 1200 seconds.However, for instance Three9.1 with γ = 30 and γ = 50, the time to derive the corresponding upper shell increases significantly compared to γ = 10, for all vectors λ.
We checked that for all instances, for no vector λ, the MIP solver derived the optimal solution to problem (2) within time limit T L + Time S U .

Experiment 2
In this experiment, we check the behavior of the Chute2 algorithm with parameters N = 20 and T S = 400.Recall, they are related to the Suboptimal algorithm.The results for instance Bi6.1 are shown in Tables 16-18, and the results for instance Bi9.1 are shown in Tables 19-21.The results for instance Three6.1 are shown in Tables 22-24, and the results for instance Three9.1 are shown in Tables 25-27.
For instance Bi6.1, when changing γ = 10 to γ = 30, we observe an improvement in at least one component of G P sub (R(S L , S U , λ)) for all vectors λ, although only in three cases (λ no.3-5) two components improve.Yet, when changing γ = 30 to γ = 50, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for three vectors λ (no. 1, 2, and 5).For λ no. 3, we observe a deterioration of the second component of G P sub (R(S L , S U , λ)), and, at the same time, an improvement on the first one.All components of G P sub (R(S L , S U , λ)) deteriorate for λ no. 4. When changing γ = 10 to γ = 50, we observe an improvement in G P sub (R(S L , S U , λ)) for all vectors λ (at least one component improves).
For instance Bi9.1, when changing γ = 10 to γ = 30, we observe an improvement in at least one component of G P sub (R(S L , S U , λ)) for all vectors λ, and for λ no.2-5 both components of G P sub (R(S L , S U , λ)) improve.When changing γ = 30 to γ = 50, we observe an improvement in both components of G P sub (R(S L , S U , λ)) for all vectors λ but the first one , where the first component of G P sub (R(S L , S U , λ)) deteriorates.When changing γ = 10 to γ = 50, we observe an improvement in G P sub (R(S L , S U , λ)) for all vectors λ (at least one component improves).
For instances Bi6.1 and Bi9.1, the higher the value of parameter γ (higher sampling density of the objective space ), the more numerous the derived upper shells are.For instance Bi6.1, average times over all vectors λ to derive the upper shell for γ = 10, γ = 30, and γ = 50 are, respectively, 77.74, 85.03, and 83.28 seconds.These times are small fractions of the assumed time limit T L = 1200 seconds.For instance Bi9.1, average times over all vectors λ to derive the upper shell for γ = 10, γ = 30, and γ = 50 are, respectively, 444.71, 535.92, and 618.98 seconds, and they are not small fractions of T L = 1200 seconds.
Let us check the results for tri-criteria instances.For instance Three6.1, when changing γ = 10 to γ = 30, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for vectors λ no. 1, and 3-5.For λ no. 2, we observe an improvement in the third component of G P sub (R(S L , S U , λ)) as well as a deterioration of the first one.When changing γ = 30 to γ = 50, we observe an improvement of G P sub (R(S L , S U , λ)) in at least one of its components for vectors λ no.1-3, and 5.For λ no. 4, we observe an improvement in the second and third components of G P sub (R(S L , S U , λ)) as well as a deterioration of the first one.When changing γ = 10 to γ = 50, we observe an improvement in the G P sub (R(S L , S U , λ)) for all vectors λ (at least one component improves).
For instance Three9.1, when changing γ = 10 to γ = 30, we observe an improvement in all components of G P sub (R(S L , S U , λ)) for vectors λ no.1-4, and for λ no. 5, G P sub (R(S L , S U , λ)) remains unchanged.When changing γ = 30 to γ = 50, we observe an improvement in all components of G P sub (R(S L , S U , λ)) for vector λ no. 1.For λ no. 2, we observe a deterioration of all components of G P sub (R(S L , S U , λ)), and for λ no.3-4, we observe an improvement in two components of G P sub (R(S L , S U , λ)), and a deterioration of one of its components.When changing γ = 10 to γ = 50, we observe an improvement in the G P sub (R(S L , S U , λ)) for all vectors λ (at least one component improves) but the last one.
For instances Three6.1 and Three9.1, the higher the value of parameter γ (higher sampling density of the objective space For instance Three9.1,average times over all vectors λ to derive the upper shell for γ = 10, γ = 30, and γ = 50 are, respectively, 425.48, 470.58, and 531.72 seconds, and they are not small fractions of T L = 1200 seconds. We checked that for all instances, for no vector λ, the MIP solver derived the optimal solution to problem (2) within time limit

Comparing Chute2 with Chute1
When comparing Chute2 to Chute1, for all tested instances and all values of the γ parameter, we observe no deterioration of any component of G P sub (R(S L , S U , λ)).We observe the following.For instance Bi6.1, for all values of γ, all components of G P sub (R(S L , S U , λ)) improve for all vectors λ.
For instance Bi9.1, for γ = 10, all components of G P sub (R(S L , S U , λ)) improve for four vectors λ, and one component improves for one vector λ.The same situation occurs for γ = 30 and γ = 50.
For instance Three6.1, for γ = 10, at least one component of G P sub (R(S L , S U , λ)) improves for all vectors λ, and for two ones all components improve.The same situation occurs for γ = 30 and γ = 50.
For instance Three9.1, for all γ, at least one component of G P sub (R(S L , S U , λ)) improves for four vectors λ.All components of G P sub (R(S L , S U , λ)) improve for γ = 10, γ = 30, and γ = 50, respectively, for three, four, and three vectors λ.For all values of the γ parameter, for one vector λ there is no improvement of any component of G P sub (R(S L , S U , λ)).
Table 28 shows times of deriving upper shells averaged over all vectors λ for both tested algorithms.We observe a significant increase in these times for Chute2 compared to Chute1.It should be recalled here that Chute2 uses the Suboptimal algorithm, for which the stopping condition depends on the assumed for this algorithm time limit T S = 400 seconds.For Chute2, the average running time of the Suboptimal algorithm is given in parentheses.It can be seen that in this case a significant fraction of its running time is that of the Subotimal algorithm.In addition, for all γ values, the average running times of Chute2 are larger for Bi9.1 than for Three9.1, which is theoretically a harder problem to solve because it has one more objective function.The implication is that for Bi9.1, for all five lambda vectors, the Subotimal algorithm terminated due to the T S limit, while for Three9.1 -for four lambda vectors.This affected the average times.For details, see Tables 21 and 27.

Discussion
For all test instances of the MOMIP problem, with time limits set, algorithm Chute2 determines tighter upper bounds measured with the help of G P sub (R(S L , S U , λ)) than algorithm Chute1 in most cases.Yet, this comes at the expense of a significant increase in the computation time for deriving upper shells.So, we can observe a trade-off between the quality of the interval representation of the implicit Pareto optimal outcome for a given λ and computation time.In both the algorithms, for a given λ, tightness of upper bounds can be controlled by changing values of parameter γ.However, changing the γ value from lower to higher does not always guarantee an improvement in at least one component of G P sub (R(S L , S U , λ)).It may even happen that some of its components deteriorate.However, in all tested instances, when changing from the lowest to the highest value of parameter γ, no deterioration of any component of G P sub (R(S L , S U , λ)) has been recorded for all vectors λ.
The deterioration of some of the components of G P sub (R(S L , S U , λ)) after increasing γ may be due to the fact that increasing the value of γ does not preserve the elements of the set S U obtained for smaller γ, but generates a new, denser set S U , but different in general.These new S U elements may not be able to generate always better, but in some cases generete even slightly worse vectors of upper bounds than those obtained for smaller γ.During decision-making, one can store all the derived upper shells and use their elements in the Chute algorithm as helpers to determine tighter upper bounds for a given λ when the DM asks for them.
Parameters affecting the operation of algorithms Chute1 and Chute2 (in particular, time limits for optimization as well as parameter γ ) were arbitrarily set for the numerical experiments conducted on the selected test instances.We can not recommend the adopted parameter values (e.g., T L = 1200 seconds, T S = 400 seconds) for other instances of the MOMIP problem.The values of these parameters might depend on the problem to be solved, the available computational resources and the conditions of the decision-making process itself.
As Chute1 and Chute2 use a MIP solver as a black box, it is difficult to provide their theoretical performance, especially since they can work with any instance of the MOMIP problem that meets the very generic assumptions made in this work.During their operation, multiple instances of the single-objective MIP problem are solved, which are parameterized by λ in the case of Chute1 and (λ, µ) in the case of Chute2.Moreover, Chute2 uses the Suboptimal algorithm as a black box, and it is difficult to predict which termination condition of Suboptimal will occur as it runs for different instances of the single-objective MIP problem parametrized by λ.
The Chute algorithm returns not only the interval representation but also lower and upper shells.Let us assume that for a given set Λ := {λ 1 , λ 2 , λ 3 } the algorithm derives upper shells S U (λ 1 ), S U (λ 2 ), and S U (λ 3 ).S U := ⊕ S L := ⊕ 3 i=1 {IN C λ i } (where "⊕" is an operator of adding two sets and removing dominated elements) is a lower shell.One can use S L and S U to calculate interval representations of implicit Pareto optimal outcomes designated by λ / ∈ Λ.For test problem Bi6.1 and γ := 50, images of the lower and upper shells obtained this way (for five considered vectors λ) are shown in Figure 4.These images form a finite two-sided approximation of the Pareto front.The approximation does not fully cover the entire Pareto front, as it was derived to determine interval representations of implicit Pareto optimal outcomes designated by just the selected five vectors λ.
We can say that we obtained the two-sided approximation of the Pareto front, shaped by the DM's preferences expressed with the help of vectors λ.
Although we aim not to derive approximations of the entire Pareto front (as in multiobjective branch and bound, see, e.g., Przybylski and Gandibleux (2017), Forget et al. (2022)), with a fairly large set of evenly distributed vectors λ, one would imagine (for k = 2, 3) the corridor in which the Pareto front is located.

Limitations of the Chute algorithm and its possible enhancements
In the Chute algorithm, we have assumed that for all probing vectors λ ′ in the FindUpper-Shell algorithm, the same vector of multipliers µ is used.The Chute1 version inherently uses a single vector µ.Yet, for the Chute2 version, it is just a heuristic assumption that vector µ, set with the help of the Suboptimal algorithm for a given vector λ in line 4 of the Chute algorithm, provides a tight lower bound on values of the objective function of problem (2) for probing vectors λ ′ close to λ.However, this need not be the case, especially for vectors λ ′ , which are significantly different from λ (i.e., when they indicate a significantly different search direction in the objective space).
However, one can imagine version Chute3 of the Chute algorithm in which the determination of vector µ takes place in the FindUpperShell algorithm for each probing λ ′ considered in it (or, e.g., for λ ′ not close, in a sense, to a given λ).This, at the same time, would require adopting a reasonable time limit on optimization in the Suboptimal algorithm, as we expect many probing vectors λ ′ in the FindUpperShell algorithm.This time limit could be, e.g., a fraction of time T S adopted in Chute2.Since the number of probing vectors λ ′ is not a priori known, this time limit would have to be determined by some heuristic rule.It is not desirable that excessive time to determine all vectors µ is a barrier to the applicability of the proposed method.
In a real decision-making process using the Chute algorithm, it is possible to calculate a more adjusted value of parameter γ for a new vector λ based on the properties of the lower and upper shells obtained for previous vectors λ, and with which this algorithm was called.Let us look, for example, at Table 18.For λ 1 = (0.055, 0.945), |S U | = 26, Time S U = 91.44 seconds, but for λ 5 = (0.439, 0.561), |S U | = 7, Time S U = 39.82 seconds.To have the time of deriving an upper shell for some λ ′ close to λ 1 comparable to the time for λ 5 , it could be possible to lower the value of parameter γ from 50 to, e.g., 20.Such an overarching mechanism (with a set of rules based on statistics collected during the decision-making process) for controlling the behavior of the Chute algorithm could be useful when computation time is an important factor.
In the proposed method of deriving upper shells (algorithm FindUpperShell), there is no single parameter to limit optimization time for getting theirs.Yet, such a time limit can be incorporated relatively easily as an additional stop condition in FindUpperShell.More generally, it could be even desirable to introduce in the Chute algorithm a time limit for determining the interval representation of the implicit Pareto optimal outcome for a given vector λ.The DM would give, for example, in addition to λ and T L , time limit T I (e.g., T L = 1200 seconds, T I = 500 seconds).Then the Chute algorithm would have time limit T I k to derive an upper shell for calculating a single component of the interval representation of implicit Pareto optimal outcome designated by λ.Determination of suboptimal vectors µ in Chute2 and Chute3 would, of course, have to be within some fraction of T I .
Based on the above alone, one can imagine many schemes for budgeting calculations, leading to providing interval representations in a decision-making system based on the Chute algorithm.
In our approach, to find elements of the upper shell we solve to optimality the Chebyshev scalarization of the surrogate relaxation of the MOMIP problem.For instances of the MOMIP problem with a large number of constraints (e.g., 1000), even with a suboptimal vector of multipliers µ provided by the Suboptimal algorithm (that is, with a single constraint that mimics the original set of constraints of the MOMIP problem), the Find-UpperShell procedure may not derive elements x of the upper shell that f l (x) < y * l , l = 1, . . ., k.In this case, the upper bounds on components of Pareto optimal outcome designated by λ are not better than components of y * l .That is, images of elements of the upper shell in the objective space are very far from the Pareto front of the MOMIP problem, and do not provide better upper bounds than the components of y * .
To find (sub)optimal values of multipliers µ p , other algorithms can be used (see, e.g., Sikorski (1986)).To find elements of upper shells, sophisticated combined relaxation techniques for MIP problems, e.g., Lagrangean/surrogate heuristics (see Narciso and Lorena (1999)) can also be applied.In the current work, we consider the most general formulation of the MOMIP problem, but to find those elements, problem-specific techniques may help.The disadvantage of the proposed generic scheme Chute is that it does not take into account the specifics of a given instance of the MOMIP problem.However, by showing its Chute2 modification and pointing to the Chute3 option, it has been shown how this scheme can be modified.
Within the generic framework presented, other methods of deriving upper shells in the FindUpperShell procedure can also be applied, e.g., a method shown in Miroforidis (2021).

Final remarks
It has been shown how to algorithmically derive lower and upper shells to the MOMIP problem (for any k > 1) to get the interval representation of the Pareto optimal outcome designated by vector λ.On selected examples, it has been shown that with the help of the proposed method, one can find such interval representations for randomly selected vectors λ where there is a time limit for a MIP solver on deriving a single Pareto optimal solution.
We conducted some preliminary experiments with the Chute algorithm on instances of the MOMKP with four objective functions.However, due to the mechanism adopted in the FindUpperShell algorithm for changing the probing λ vectors, the results achieved were not satisfactory.
In our future work, we want to improve the method of populating an upper shell (in quest of finding its elements that can provides upper bounds) by changing the scheme of probing the objective space.We want it to determine upper shells with the desired properties for four and more objective functions.We also want to apply the presented generic approach to other instances of the MOMIP problem, especially ones connected to real-life problems.This would help verify the practicality of the proposed general method and identify those elements that could be tailored for specific instances of this problem.Possible modifications to the proposed method are indicated in Section 6.These are also worth considering in further work.

Fig. 1 .
Fig. 1.Components of R(S L , S U , λ): □, • -images of lower shell S L and upper shell S U elements, respectively, in the objective space, ▲ -vector of lower bounds, ■ -vector of upper bounds.

Fig. 2 .
Fig. 2. Deriving upper shell S 1 U whose element x λ ′′′ is a source of an upper bound, U 1 , for f 1 (x P opt (λ)) with some λ : • -image of upper shell S 1U in the objective space, ▲ -vector of lower bounds. λ on f 1 (x P opt (λ)) because f (x λ ′

Fig. 3 .
Fig. 3.The idea of deriving upper shell {x(μ)} whose element is a source of a better upper bound on f 2 (x P opt (λ)) than the element of upper shell {x(µ I )}.

Fig. 4 .
Fig. 4. A finite two-sided approximation of the Pareto front: □, • -images of lower shell S L and upper shell S U elements in the objective space, respectively, • -y * .