A simple, efficient and versatile objective space algorithm for multiobjective integer programming

Abstract

In the last years a multitude of algorithms have been proposed to solve multiobjective integer programming problems. However, only few authors offer open-source implementations. On the other hand, new methods are typically compared to code that is publicly available, even if this code is known to be outperformed. In this paper, we aim to overcome this problem by proposing a new state-of-the-art algorithm with an open-source implementation in C++. The underlying method falls into the class of objective space methods, i.e., it decomposes the overall problem into a series of scalarized subproblems that can be solved with efficient single-objective IP-solvers. It keeps the number of required subproblems small by avoiding redundancies, and it can be combined with different scalarizations that all lead to comparably simple subproblems. Our algorithm bases on previous results but combines them in a new way. Numerical experiments with up to ten objectives validate that the method is efficient and that it scales well to higher dimensional problems.

1 Introduction

Integer programming (IP) is a classical field of Operations Research with a wide range of economical and industrial applications. Prominent examples are knapsack and capital budgeting problems, assignment problems, routing problems and problems occuring in supply chain management applications. The practical success of integer programming is supported by the fact that highly efficient solvers are readily available. This is not the case for multiobjective integer programming (MOIP). Indeed, while there is a growing need for the consideration of multiple conflicting goals, including economical, ecological and robustness criteria, the development of MOIP solvers lags behind.

A simple yet efficient way to overcome this shortcoming can be seen in the recent trend towards so-called objective space methods or scalarization-based algorithms. Different from “purely” multiobjective approaches like, for example, multiobjective branch and bound algorithms, such methods rely on the iterative solution of appropriately defined single-objective IPs, hence taking advantage of the efficiency of single-objective IP solvers. Besides the fact that such methods largely benefit from the strength of single-objective IP solvers, they are independent of the particular problem structure and are thus very generally applicable, without the hassle of problem specific fine-tuning.

Objective space methods can be distinguished w.r.t. the way the objective space is decomposed and w.r.t. the way the subproblems are formulated. Both aspects, decomposition and subproblem formulation, have a direct impact on the computational efficiency of the overall method: The decomposition influences the number of solver calls, and the complexity of the subproblems has a decisive effect on the computational time required by each individual solver call. Different objective space methods have been proposed, e.g., in Klein and Hannan (1982); Sylva and Crema (2004); Laumanns et al. (2006); Sylva and Crema (2008); Lokman and Köksalan (2013); Özlen et al. (2014); Kirlik and Sayin (2014); Dächert and Klamroth (2015); Klamroth et al. (2015); Boland et al. (2016); Dächert et al. (2017); Boland et al. (2017b); Holzmann and Smith (2018); Tamby (2018); Turgut et al. (2019); Joswig and Loho (2020) and Tamby and Vanderpooten (2020). We review the most prominent approaches in the light of a generic algorithmic description in Sect. 4.

In the following subsections we first discuss the intrinsic difficulty of MOIP problems (Sect. 1.1) and then give a formal problem formulation and introduce the notation (Sect. 1.2). We provide a prototypical formulation of a generic scalarization-based algorithm in Sect. 2, discuss the geometric complexity of the associated decomposition, and briefly review scalarization methods that can be used in this context. Section 3 presents how the number of integer problems can be reduced when using the $\varepsilon$-constraint scalarization. In Sect. 4 we review the related literature and provide a summary of the leading objective space algorithms for MOIP. An extensive computational study comparing different approaches on instances of knapsack, assignment travelling salesman problems with up to ten objective functions is presented in Sect. 5. While the approach presented in this paper does not necessarily require the fewest number of integer programs to be solved, it is, nevertheless, the best with respect to CPU time.

1.1 Challenges in multiobjective integer programming

While MOIP problems are relatively well understood in the biobjective case, they are principally difficult in three and more dimensions (see, for example, Figueira et al. 2017). One reason for the specific role of biobjective problems is that in this case Pareto optimal solutions can be sorted such that their objective values are increasing in one objective and decreasing in the other objective. In this way, a natural ordering within the nondominated set is induced which facilitates central operations like, for example, decomposition, bound computations, and filtering for dominated solutions. This is used in the context of objective space methods, for example, in Aneja and Nair (1979); Chalmet et al. (1986); Ralphs et al. (2006). Since there is not such a natural ordering in the case of three and more objectives, many approaches do not directly transfer from the biobjective to the multiobjective case. Figure 1 illustrates this situation with the help of a simple example with two nondominated outcome vectors in the biobjective case (Fig. 1a) and in the three-objective case (Fig. 1b).

Fig. 1

Dominated region in the biobjective (a) and in the three-objective case (b) for two points $z^1=(4,6)$ and $z^2=(7,3)$ (a) and $z^1=(4,6,6)$ and $z^2=(7,3,4)$ (b), respectively. Note that a can be interpreted as a projection of b onto the $f_1-f_2$-plane

In addition, when increasing the number of objective functions then also the number of efficient solutions usually increases. Even though already biobjective problems are intractable in the sense that the size of the nondominated set may grow exponentially with the problem size (see, for example, Ehrgott 2005), in practice the percentage of nondominated outcome vectors largely depends on two model characteristics: The problem structure and coefficients, and the number of objective functions. Indeed, when extending an MOIP problem by an additional objective function, then all formerly efficient solutions remain efficient for the extended problem, and chances are high that further solutions become efficient if they perform well w.r.t. the additional objective. It is easy to see that when the solution set is finite it is always possible to define a finite number of objective functions so that all feasible solutions are efficient.

1.2 Problem formulation and notation

In the following, we give a brief introduction to multiobjective optimization and to the classical concept of Pareto dominance. For an extensive introduction into the field, we refer to the textbooks (Ehrgott 2005) and Miettinen (1999). Throughout this paper we use the following notation to compare two vectors $x^1,x^2\in \mathbb {R}^{n}$:

$$\begin{aligned} x^1 \leqq x^2\Leftrightarrow & {} x^1_i\le x^2_i \text {~for all~} i=1,\ldots , n\\ x^1 \leqslant x^2\Leftrightarrow & {} x^1_i\le x^2_i \text{ for } \text{ all } i=1,\ldots , n \text{ and } x^1\ne x^2\\ x^1< x^2\Leftrightarrow & {} x^1_i < x^2_i \text {~for all~} i=1,\ldots , n. \end{aligned}$$

The symbols $\geqq , \geqslant$ and > are used analogously.

We consider multiobjective integer programming problems (MOIP) with $p\ge 2$ functions given by

$$\begin{aligned} \min \{Cx\,: \, Ax \leqq b,\, x\in \mathbb {Z}^n\}, \end{aligned}$$

(MOIP)

where $C\in \mathbb {Z}^{p\times n}$ is the objective matrix, $A\in \mathbb {Z}^{m\times n}$ is the constraint matrix, $b\in \mathbb {Z}^m$ is the right-hand-side vector, and $X=\{x\in \mathbb {Z}^n:\, Ax\leqq b\}$ denotes the set of feasible solutions of MOIP. We assume that all coefficients are integer and that the variables may only take integer values. Non-negativity constraints can be included in the constraint system $Ax\leqq b$ when required. We note that multiobjective binary programming problems (MOBP) where the solution vectors are constrained to $x\in \{0,1\}^n$ are an important special case that is included in this formulation.

The p objective functions are given as a p-dimensional vector $f=(f_1,\dots ,f_{p})\,:\, X\rightarrow \mathbb {Z}^{p}$, where $p\ge 2$ denotes the number of objective functions and hence the dimension of the objective space. The ith objective function is given as a linear function with cost vector $c^i=(c_{i1},\dots ,c_{in})$, i.e., $f_i(x)=c^i x = \sum _{j=1}^n c_{ij}x_j$, $i=1,\dots ,p$. Since we assume that all coefficients are integer, the set of attainable (i.e., feasible) outcome vectors $Z=f(X)$ satisfies $Z\subseteq \mathbb {Z}^{p}$.

We focus on the determination of Pareto optimal (or efficient) solutions which are those solutions for which none of the objective values can be improved without deterioration of at least one other objective value. This concept is based on the partial ordering induced by the natural ordering cone $\mathbb {R}^{p}_{\geqslant }=\{z\in \mathbb {R}^{p}\,:\,z\geqslant 0\}=\mathbb {R}^{p}_{\geqq }{\setminus }\{0\}$, where $0\in \mathbb {R}^p$ denotes the p-dimensional zero-vector. Then $z^1\leqslant z^2$ (i.e., $z^1$ dominates $z^2$) if and only if $z^1\in z^2 - \mathbb {R}^{p}_{\geqslant }$, and ${\bar{x}}\in X$ is Pareto optimal if and only if there does not exist $x\in X$ such that $f(x)\in f({\bar{x}})-\mathbb {R}^{p}_{\geqslant }$.

The image of a Pareto optimal solution in the objective space is called nondominated point or nondominated outcome vector. The set of all Pareto optimal solutions (nondominated points) is referred to as the Pareto set (nondominated set) and denoted by $X_E\subseteq X$ and $Z_N\subseteq Z$, respectively. For a given nonempty set $N\subseteq Z$ of feasible outcome vectors, we refer to the set $N+\mathbb {R}^{p}_{\geqq }$ as the dominated region of the set N, see Fig. 1 for an illustration. Note that further nondominated outcome vectors of MOIP can only be located in the complement of the dominated region of the set N, i.e., in the set $S(N):=\mathbb {R}^{p}\setminus (N+\mathbb {R}^{p}_{\geqq })$ which we call the search region w.r.t. N. This is in fact true for every nonempty set $N\subseteq Z$, irrespective of the fact whether all points in N are nondominated or not. In the special case that $N=Z_N$ we additionally have that $N+\mathbb {R}^{p}_{\geqq } = Z + \mathbb {R}^{p}_{\geqq }$ and that $S(N)\cap Z=\emptyset$.

2 Generic scalarization-based algorithm

In this section, we provide a generic formulation of an objective space algorithm that is based on an appropriate decomposition of the search region and on the iterative solution of scalarized single-objective IPs using standard IP solvers. We emphasize that this method does not assume a specific (combinatorial) problem structure and that it takes advantage of the efficiency of readily available IP solvers.

Given an initial area of interest, i.e., an initial search region, each solver call either generates a new nondominated outcome vector (which, by removing the region it dominates, leads to a reduction of the search region) or returns the information that the corresponding subproblem is infeasible (and that the associated part of the search region does not contain any further nondominated outcome vectors and can be excluded from further evaluations).

Key operations are hence the description and update operation for the search region as the basis for its decomposition into search zones (Sect. 2.1) and the formulation of appropriate subproblems in the respective search zones which is usually realized through scalarizations (Sect. 2.2). A pseudocode formulation of the general algorithmic framework is given in Algorithm 1.

Algorithm 1

Generic Scalarization-Based Algorithm

As said before, the driving factors for the efficiency of Algorithm 1 are the number and the complexity of subproblems that are solved during the course of the algorithm. These two factors are interrelated: By formulating more complex subproblems, larger reductions of the search region can be achieved which can in turn be used to reduce the number of solver calls. However, this usually comes at the price of more expensive solver calls. This trade-off is analyzed in the numerical tests in Sect. 5. We note that an additional criterion when implementing Algorithm 1 is the avoidance of infeasible subproblems since detecting infeasibility often comes at a (slightly) higher computational cost.

2.1 The search region and its complexity

In this section we first focus on the mathematical description of the search region and show how it suggests a natural decomposition into non-redundant search zones. Towards this end, consider an arbitrary iteration of Algorithm 1 and let $N\ne \emptyset$ denote the set of nondominated points computed so far. Then the search region S(N) that potentially contains further nondominated points is formally defined as

$$\begin{aligned} \begin{array}{rcl} S(N) &{} = &{} \mathbb {R}^{p} \setminus (N+\mathbb {R}^{p}_{\geqq })\\ &{} = &{} \mathbb {R}^{p}\setminus \{z\in \mathbb {R}^{p}:\,\exists {{{\bar{z}}}}\in N\text {~with~}{{{\bar{z}}}}\leqq z\}. \end{array} \end{aligned}$$

A thorough analysis of the geometric structure of the search region and its concise description is given in Dächert and Klamroth (2015) for the three-objective case, and in Klamroth et al. (2015) and Dächert et al. (2017) for the general case. See also Joswig and Loho (2020) for an alternative yet equivalent interpretation based on monomial cones and tropical algebra.

We follow the exposition in Klamroth et al. (2015) and assume that the search region is restricted to a bounding box with lower bound $(m,\dots ,m)^T\in \mathbb {Z}^{p}$ and upper bound $(M,\dots ,M)^T\in \mathbb {Z}^{p}$ (with $m<M$). These bounds may be given by the decision maker or they may be derived, for example, from global bounds on the attainable objective function values. For example, the ideal point can be used to determine a global lower bound. For an MOIP problem the ideal point $z^I \in \mathbb {Z}^p$ is defined component-wise as

$$\begin{aligned} z^I_i = \min \{ c^i x: \, Ax \leqq b,\, x\in \mathbb {Z}^n\}, \; i=1,\dots ,p. \end{aligned}$$

(1)

To simplify the notation, we assume wlog that $m=0$. Moreover, let p dummy points $d^i=M\cdot e^i\in \mathbb {Z}^{p}$, $i=1,\dots ,p$ be included in the set N that delimit the bounding box, where $e^i$ denotes the ith unit vector in $\mathbb {R}^{p}$. Then the search region S(N) can be unambiguously described by a finite set of local upper bounds U(N) such that

$$\begin{aligned} \begin{array}{rcl} S(N) &{} = &{} \{z\in \mathbb {R}^{p}:\,\exists u\in U(N),\,z<u\}\\ &{} = &{} \bigcup _{u\in U(N)}C(u), \end{array} \end{aligned}$$

where $C(u)=u-\mathbb {R}^{p}_>$ denotes the search zone induced by the local upper bound u. Figure 2 illustrates the situation for the example problems from Fig. 1.

Fig. 2

Local upper bounds shown by filled circles in the biobjective (a) and in the three-objective case (b) for the two points introduced in Fig. 1. The empty circles in a show the projections ${\hat{u}}^{31}$ and ${\hat{u}}^{33}$ of the local upper bounds $u^{31}$ and $u^{33}$ that are only present in the three-objective case, see b

Intuitively, local upper bounds are the maximal points in the objective space that are not dominated by any of the points in N. As a consequence, all components $u_i$, $i=1,\dots ,p$, of a local upper bound $u\in U(N)$ are induced by a corresponding component $z_i^i$ of a point $z^i\in N$ that satisfies $z_i^i=u_i$ and $z^i_j < u_j$ for all $j\in \{1,\dots ,p\}{\setminus }\{i\}$. We call such a point a defining point for (component i of) the local upper bound u. Note that local upper bounds are thus also integer points, i.e., $U(N)\subset \mathbb {Z}^{p}$.

Moreover, as soon as at least one nondominated point z in the interior of the bounding box is found (this is usually the case after solving the first subproblem), then the global upper bound $(M,\dots ,M)^T$ is dominated and every local upper bound has at least one defining point that is not a dummy point.

More generally, whenever a new nondominated point ${\bar{z}}$ is found in U(N), then the set U(N) needs to be updated: For all $u\in U(N)$ with ${\bar{z}}<u$, u is replaced by p smaller local upper bounds $u^1, \dots , u^p$, where

$$\begin{aligned} u^i_j = \left\{ \begin{array}{cc} {\bar{z}}_j, &{} j = i \\ u_j, &{} j \ne i \end{array}\qquad \text {for~}i=1,\dots ,p. \right. \end{aligned}$$

(2)

I.e., to compute $u^i$, the i-th component of u is replaced by the value of the nondominated point ${\bar{z}}$ in component i while all other components remain unchanged. Hence, $u^i\leqslant u$ for all $i=1,\dots ,p$, that is, the search region is reduced. For convenience we call the resulting local upper bound $u^i$ an i-child of u. Note that ${\bar{z}}<u$ may be satisfied for more than one local upper bound in U(N). In this case, some of the generated i-children may be redundant for the description of $U(N\cup \{{\bar{z}}\})$ and can be removed. The detection of redundant local upper bounds is described in detail in Dächert and Klamroth (2015), Klamroth et al. (2015) and Dächert et al. (2017).

In the biobjective case (see Fig. 2a for an illustration), the set U(N) is immediately obtained from the points in N by first sorting these points, for example, w.r.t. $f_1$, and then combining their respective components in increasing order of $f_1$ (in Fig. 2a, this yields $U(N)=\{u^1,u^2,u^3\}$). Figure 2b illustrates the set $U(N)=\{u^1,u^{21},u^{22},u^{31},u^{33}\}$ for an example problem with three objectives that was computed by recursively introducing the outcome vectors $z^1$ and $z^2$. Efficient operations to iteratively update the set U(N) when further nondominated points are added to N are described in Klamroth et al. (2015) and Dächert et al. (2017).

Given the set U(N), a single-objective subproblem can be solved for each of the associated search zones $C(u)=u-\mathbb {R}^{p}_{>}$ to either find a new (mutually nondominated) point, or to show that the corresponding search zone does not contain any further nondominated points. The cardinality of the set U(N) is thus decisive for the number of subproblems that need to be solved in Algorithm 1. A worst case bound on |U(N)| can be derived from results of Boissonnat et al. (1998) and Kaplan et al. (2008) from the field of algorithmic geometry: The number of local upper bounds is bounded by

$$\begin{aligned} |U(N)|=O\left( |N|^{\lfloor \frac{p}{2}\rfloor }\right) \qquad \text {for~}p\ge 2. \end{aligned}$$

(3)

This bound is tight in the sense that there are instances where this bound is attained. However, in practice the value of |U(N)| is often much smaller, often even by orders of magnitude. In the special case of two objectives ($p=2$) the number of local upper bounds is exactly $|U(N)|=|N|+1$, irrespective of the considered problem instance. Moreover, Dächert and Klamroth (2015) showed that for three objectives ($p=3$) it holds that $|U(N)|=2|N|+1$ (under the assumption that no two points in N share the same value in one of their components). Hence, for $p=3$ the number of search zones still grows only linearly with the number of nondominated points.

We argue that the decomposition of the search region S(N) into |U(N)| pairwise non-redundant search zones C(u), $u\in U(N)$, is a natural decomposition that immediately leads to the formulation of associated pairwise non-redundant single-objective subproblems. The efficiency of this method is validated in the numerical tests presented in Sect. 5. While other decompositions of the search region are of course possible and have other pros and cons, the structure of the set U(N) and particularly its cardinality remain decisive for the computational complexity of the respective methods.

Indeed, when the number of objective functions p is fixed and when the natural decomposition is combined with a suitable scalarization method, then (3) implies a polynomial bound on the overall number of iterations of Algorithm 1. In this situation we call a scalarization method suitable if and only if either a new nondominated point is found or the respective search zone is identified as an empty zone (which can be excluded from further consideration) when solving an appropriate scalarization in a search zone. This property is, e.g., satisfied by the frequently applied $\varepsilon$-constraint scalarization and by the weighted Tchebychev scalarization, see Sect. 2.2 below for further details.

Theorem 1

When the natural decomposition of the search region into non-redundant search zones is combined with a suitable scalarization method, then the overall number of iterations of Algorithm 1 can be bounded by

$$\begin{aligned} O\left( |Z_N|^{\lfloor \frac{p}{2}\rfloor }\right) \qquad \text {for~}p\ge 2, \end{aligned}$$

(4)

which is polynomial in the size of the nondominated set $|Z_N|$ when p is fixed.

Proof

First consider the case where the $|Z_N|$ nondominated points are found within the first $|Z_N|$ iterations, and after that the remaining search zones are investigated which are empty. In this case, the number of subproblems solved by Algorithm 1 is bounded by

$$\begin{aligned} O\left( |Z_N|+|Z_N|^{\lfloor \frac{p}{2}\rfloor }\right) =O\left( |Z_N|^{\lfloor \frac{p}{2}\rfloor }\right) \qquad \text {for~}p\ge 2, \end{aligned}$$

(5)

i.e., $|Z_N|$ iterations in each of which a nondominated point is determined, and at most $O(|Z_N|^{\lfloor \frac{p}{2}\rfloor })$ iterations to detect that all search zones induced by these points are empty. C.f. (3) for the corresponding bound on the number of search zones induced by $Z_N$.

Now consider the general case where empty search zones may be detected at any time. In this case the above argumentation still holds since an empty search zone is never changed in later iterations, irrespective from the fact whether it is detected earlier or later during the procedure. Indeed, only those search zones are updated and split that contain a newly detected nondominated point, and this situation can not occur when the considered search zone is empty. Therefore, the iteration at which an empty search zone is detected does not matter. $\square$

Note that Theorem 1 relies on two central properties: (a) The complexity of the decomposition used in Algorithm 1 grows only polynomially with the number of nondominated points (which is guaranteed in the case of the natural decomposition), and (b) the employed scalarization must be tailored for the respective search zones in the sense that with each solver call, either a new nondominated point is found or the search zone is excluded. We will focus on this property when discussing suitable scalarizations, tailored for the natural decomposition, in the following section.

To the best of our knowledge the above approach is the only objective space method that has a provably polynomial bound on the number of required solver calls while keeping these solver calls simple, i.e., without relying on disjunctive constraints and/or additional integer variables.

2.2 Scalarization methods

We now assume that an intermediate set N of already computed nondominated points and a decomposition of the associated search region into a finite set of search zones is given. We exemplify the following discussion at the natural decomposition described in Sect. 2.1 above, where each search zone C(u), $u\in U(N)$, corresponds to a hyperrectangle with lower bound 0 and upper bound u.

Algorithm 1 then iteratively selects a search zone in order to decide whether it is feasible and hence contains further nondominated points–in this case, such a nondominated point has to be computed–or whether it is infeasible and can be excluded from further consideration. This is realized by formulating an appropriate single-objective subproblem. For search zones with a simple structure as in the case of the natural decomposition, this can be realized by appropriate scalarizations, see, for example, Ehrgott (2006) for a survey in the context of multiobjective integer programming problems. In the following, we focus on $\varepsilon$-constraint scalarizations and weighted Tchebychev scalarizations since they are particularly well suited in this setting.

2.2.1 $\varepsilon$-constraint scalarization

The most commonly used scalarization in this context is the $\varepsilon$-constraint scalarization: Given a search zone C(u) with local upper bound u, the associated $\varepsilon$-constraint subproblem w.r.t. the ith objective, $i\in \{1,\dots ,p\}$, is given by

where $J_i:=\{1,\dots ,p\}\setminus \{i\}$ denotes the index set of all non-selected objective functions. Figure 4a illustrates the additional constraints together with an exemplary level curve of the objective function. The following lemma illuminates the role of the defining points of the local upper bound u for the associated $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$). We refer to Tamby and Vanderpooten (2020) for a similar result.

Lemma 1

Let C(u) be a search zone from the natural decomposition of the search region, let $i\in \{1,\dots ,p\}$ be a selected objective function such that $u_i$ is not defined by a dummy point, and let $z^i$ be a defining point for the i-th component of u with pre-image $x^i\in X$. Then it holds:

• 1. $x^i$ is a feasible solution for the $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$).

• 2. If $x^i$ is an optimal solution of ($P^{\varepsilon }_i(u)$), then the search zone C(u) does not contain any further nondominated points.

Proof

Since $z^i\in N\setminus \{d^1,\dots ,d^{p}\}$ is a defining point of u we have that $z^i_j< u_j$ for all $j\in J_i$. Since in addition $z^i=Cx^i$ with $x^i\in X$, it follows that $z^i\in \mathbb {Z}^{p}$ and hence $z^i_j=c^jx^i\le u_j-1$ for all $j\in J_i$. Thus, $x^i$ is feasible for problem ($P^{\varepsilon }_i(u)$).

Now let $x^i$ be an optimal solution of problem ($P^{\varepsilon }_i(u)$). Then there is no ${\bar{x}}\in X$ with $c^j{\bar{x}} < u_j$, $j\in J_i$ (recall that $c^j{\bar{x}}$ is integral for all $j\in \{1,\dots ,p\}$) and $c^i{\bar{x}}<z^i_i=u_i$, and hence $Z\cap C(u)=\emptyset$. $\square$

If the $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$) is solved by an IP-solver that can be sped up when providing a feasible starting solution, then Lemma 1 suggests to select a minimization objective $f_i$, $i\in \{1,\dots ,p\}$, such that the corresponding defining point $z^i$ is not a dummy point since then a corresponding pre-image $x^i\in X$ with $Cx^i=z^i$ is already known and can be used as a feasible starting solution when solving problem ($P^{\varepsilon }_i(u)$). Moreover, problem ($P^{\varepsilon }_i(u)$) is then feasible which usually has a positive effect on the computational time (as compared to infeasible subproblems).

The following properties are well-known; we refer to the textbook (Ehrgott 2005) for further details.

Lemma 2

Every optimal solution ${\bar{x}}\in X$ of an $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$) is weakly efficient for MOIP, and at least one of the optimal solutions of ($P^{\varepsilon }_i(u)$) is efficient for MOIP.

When combining the results of Lemmas 1 and 2 we can conclude that if an $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$) returns an optimal solution ${\bar{x}}\in X$ with $c^i{\bar{x}}<z^i_i$, then this solution is in the search zone C(u) and it is at least weakly efficient for ($P^{\varepsilon }_i(u)$). In this case, $Z_N\cap C(u)\ne \emptyset$ and a nondominated point in C(u) can be found by, for example, performing a lexicographic optimization over the set of optimal solutions of problem ($P^{\varepsilon }_i(u)$). The latter can be realized, e.g., by solving a second-stage problem

over the set of optimal solutions of problem ($P^{\varepsilon }_i(u)$). Note that a feasible starting solution is readily available by the optimal solution from the first stage problem.

Note that this two-stage approach requires two solver calls whenever a search zone contains further nondominated points. This can be avoided by adding an appropriate augmentation term to problem ($P^{\varepsilon }_i(u)$), leading to an augmented $\varepsilon$-constraint scalarization

which returns an efficient solution of MOIP. Here, $\rho >0$ is an appropriately chosen small augmentation parameter. We refer to Ehrgott and Ruzika (2008) for a detailed discussion on augmented $\varepsilon$-constraint scalarizations and appropriate choices of $\rho$.

Remark 1

Since an optimal solution ${\bar{x}}$ of the $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$) minimizes the selected objective function $f_i$ in the search zone C(u), there can not be any further nondominated points in C(u) that have an even better value in objective $f_i$. As a consequence, when updating the decomposition w.r.t. the new point ${\bar{z}}=C{\bar{x}}$, search zones $C({\bar{u}})$ with ${\bar{u}}\le u$ and ${\bar{u}}_i\le {\bar{z}}_i$ are known to be empty and can be removed from the search region without further consideration. Depending on the applied decomposition, this fact usually results in a reduction of solver calls and is thus an advantage of using $\varepsilon$-constraint scalarizations. In the example depicted in Fig. 3, $u^{11} \le u^1$ and $u^{11}_1 \le z^3_1$, hence, $u^{11}$ can be removed without further inspection. We discuss the realization of such a reduction in detail in Sect. 3 below.

Fig. 3

a The 3d situation from Fig. 2b before solving the next subproblem; b 2-dimensional projection of the $\varepsilon$-constraint scalarization ($P^{\varepsilon }_1(u^1)$) in $C(u^1)$ minimizing $f_1$ with feasible set constrained by $c^jx\le u^1_j-1$, $j=2,3$ (shaded) and level curve associated to an optimal point $z^3=(3,4,8)$ (dashed) for the problem shown in a; c 3d situation with updated local upper bounds for the same problem after adding the newly generated point $z^3=(3,4,8)$ to the set N

2.2.2 Weighted Tchebychev scalarization

The weighted Tchebychev scalarization minimizes a weighted Tchebychev distance $l_{\infty }^w(z,z^r)=\max _{j=1,\dots ,p} |w_j(z_j-z_j^r )|$ between a reference point $z^r$ and the closest feasible point $z\in Z$ in the objective space.

In order to determine whether a given search zone C(u) with $u\in U(N)$ contains further nondominated points, a natural choice for the reference point is the origin, i.e., $z^r=0$. The weights $w_j>0$, $j=1,\dots ,p$ of the weighted Tchebychev distance are then set such that the level set of level 1 passes through all defining points of u and has its upper right corner in u, see Fig. 4b for an illustration. This yields $w_j=\frac{1}{u_j}$, $j=1,\dots ,p$. Note that we assume wlog that $u>0$ for all $u\in U(N)$ so that these weights are well-defined. Since we assume that the bounding box is contained in $\mathbb {R}^{p}_\geqq$ we can omit all absolute values and formulate the weighted Tchebychev scalarization w.r.t. the search zone C(u) as

Note that the second, constrained reformulation can be immediately passed to a standard IP-solver.

Lemma 3

Let C(u) be a search zone from the natural decomposition of the search region. Then it holds:

• 1. Every pre-image $x^i\in X$ of a defining point $z^i$ of u, $i\in \{1,\dots ,p\}$, that is not a dummy point is a feasible solution for the weighted Tchebychev scalarization ($P^{T}(u)$) with objective value 1.

• 2. If the optimal objective value of problem ($P^{T}(u)$) is 1, then the search zone C(u) does not contain any further nondominated points.

Proof

Since every solution in X is feasible for problem ($P^{T}(u)$) this is also true for every pre-image $x^i$ of a defining point $z^i$ of u, $i\in \{1,\dots ,p\}$. Since $z^i_i=c^ix^i=u_i$ and $z^i_j=c^jx^i<u_j$ for all $j\in J_i$ it follows that $\max _{j=1,\dots ,p} w_j\, c^jx^i = \max _{j=1,\dots ,p} \frac{c^jx^i}{u_j}=\frac{c^ix^i}{u_i}=1$.

Now suppose that the optimal objective value of problem ($P^{T}(u)$) is 1. Then there is no solution ${\bar{x}}\in X$ that satisfies $c^jx<u_j$ for all $j=1,\dots ,p$, and hence $Z\cap C(u)=\emptyset$. $\square$

Fig. 4

(a) $\varepsilon$-constraint scalarization in $C(u^1)$ minimizing $f_1$ with feasible set constrained by $f_2(x)=c^2x\le u^1_2-1$ (shaded) and level curve (dashed) through $z^1$, which can be used as feasible starting solution; (b) weighted Tchebychev scalarization in $C(u^1)$ with feasible set (shaded) and level curve (dashed) passing through $u^1$, using also $z^1$ as feasible starting solution

Note that different from the $\varepsilon$-constraint scalarization ($P^{\varepsilon }_i(u)$), all previously determined solutions, and hence in particular all defining points of the considered search zone or its upper bound, respectively, that are not dummy points, can be used as (relatively good) feasible starting solutions for the weighted Tchebychev scalarization ($P^{T}(u)$).

In general, the theoretical properties of the weighted Tchebychev scalarization and of the $\varepsilon$-constraint scalarization are very similar. We refer again to the textbook (Ehrgott 2005) for the following result.

Lemma 4

Every optimal solution ${\bar{x}}\in X$ of a weighted Tchebychev scalarization ($P^{T}(u)$) is weakly efficient for (MOIP), and at least one of the optimal solutions of ($P^{T}(u)$) is efficient for (MOIP).

Similar to the case of the $\varepsilon$-constraint scalarization, weakly efficient solutions can be avoided by solving a second-stage problem

over the set of optimal solutions of problem ($P^{T}(u)$), where ${\bar{\alpha }}$ denotes the optimal objective value of problem ($P^{T}(u)$). Again, a feasible starting solution for this second stage problem is known from solving the first stage problem.

Rather than solving two IP-problems, the original problem can also be extended by an augmentation term to the objective, yielding an augmented weighted Tchebychev scalarization

We emphasize that the augmentation parameter $\rho >0$ has to be chosen carefully. Indeed, while $\rho$ has to be chosen small enough such that no efficient solution is missed, an overly small choice of $\rho$ may lead to numerical problems. A detailed analysis with a concrete suggestion for an “optimal” choice of the augmentation parameter when $p=2$ is given in Dächert et al. (2012).

Figure 4 illustrates the additional constraints added to the problem in the respective scalarizations ($\varepsilon$-constraint versus weighted Tchebychev). In addition, exemplary level curves of the respective objective functions are shown.

3 Reduction of the search region when using the $\varepsilon$-constraint method

If we use the $\varepsilon$-constraint scalarization in Line 3 of Algorithm 1, we can reduce the search region further. This is due to a specific property of the the $\varepsilon$-constraint scalarization which allows to remove one newly created search zone directly in every iteration in which a new nondominated point is found. However, to make use of this additional reduction, we cannot select the zone in which we search for a new nondominated point arbitrarily but have to select it according to some criterion. Note that the idea itself is not new but has already been elaborated in Dächert and Klamroth (2015) for the tricriteria case.

In the following we present a selection criterion that is valid for any number of criteria. We prove that this selection criterion allows to reduce the total number of evaluated search zones by the number of nondominated points. In the proof we make use of certain results from Dächert et al. (2017), namely Lemma 3.8 and Proposition 4.3, which we recall below before stating and proving the selection criterion. They use both the notion of a neighbor from Definition 3.6 in Dächert et al. (2017) which we present in a shorter form below.

Definition 1

[Neighbor] Two local upper bounds $u,u' \in U(N)$ are neighbors if they share $p-1$ defining points, among which exactly one changes its position from some $j \in \{1,\dots ,p\}$ to some $k \in \{1,\dots ,p\}, k \ne j$. That is, there are two indices j, k with $j \ne k$ such that $z^j(u) = z^k(u')$ while $z^i(u) = z^i(u'$) for all $i \in \{1,..., p\}\backslash \{j,k$}. We then say that u is a j-neighbor of $u'$, and that $u'$ is a k-neighbor of u.

Lemma 5

(Dächert et al. 2017) Let $u, u' \in U(N)$ be local upper bounds such that $u'$ is a k-neighbor of u, and u is a j-neighbor of $u'$. Then, we have $u_j < u'_j$, $u_k > u'_k$ and $u_i=u'_i$ for $i \ne j,k$.

Proposition 1

(Dächert et al. 2017) Let $u \in U_{{\bar{z}}} = \{ u' \in U(N): {\bar{z}} < u' \}$. Then, for every $k=1,\dots , p$, one of the following two assertions holds exclusively:

• 1. $u^k \in U(N \cup \{ {\bar{z}} \} )$, where $u^k$ denotes the k-child of u

• 2. $u' \in U_{{\bar{z}}}$, where $u'$ is the k-neighbor of u.

Theorem 2

(Min-component selection criterion) If, in every iteration of Algorithm 1, we select a search zone ${\bar{u}}$ which is minimal in some component $i \in \{1,\dots ,p\}$, i.e., for which

$$\begin{aligned} {\bar{u}}_i = \min \{ u_i: u \in U(N) \} \end{aligned}$$

(6)

for some $i \in \{1,\dots ,p\}$ holds, and if we then solve an $\varepsilon$-constraint problem of the form $P^{\varepsilon ,2}_i({\bar{u}})$ or $P^{\varepsilon ,\rho }_i({\bar{u}})$, then, whenever there is a solution ${\bar{z}} \in Z_N$ with ${\bar{z}} < {\bar{u}}$, the i-child of ${\bar{u}}$ exists, i.e., ${\bar{u}}^i \in U(N \cup \{ {\bar{z}} \})$. Moreover, ${\bar{u}}^i$ can not contain further nondominated points, i.e., $\{ z \in Z_N: z < {\bar{u}}^i \}= \emptyset$.

Proof

We first show that ${\bar{u}}^i \in U(N \cup \{ {\bar{z}} \})$. Since ${\bar{z}} < {\bar{u}}$, using the notation of Proposition 1, ${\bar{u}} \in U_{{\bar{z}}}$ holds.

Assume that ${\bar{u}}^i \notin U(N \cup \{ {\bar{z}} \})$. Then, due to Proposition 1, the i-neighbor $u'$ of ${\bar{u}}$ contains ${\bar{z}}$. According to Lemma 5, $u'_i < {\bar{u}}_i$ holds for the i-neighbor $u'$ of ${\bar{u}}$. However, this is a contradiction to ${\bar{u}}$ being minimal with respect to component i. Hence, ${\bar{u}}^i \in U(N \cup \{ {\bar{z}} \})$ must hold.

It remains to show that ${\bar{u}}^i$ does not contain further nondominated points. Assume that there is a $z' \in Z_N$ with $z' < {\bar{u}}^i$. Then, in particular, $z'_i < {\bar{u}}^i_i = {\bar{z}}_i$ would hold. This, however, is a contradiction to ${\bar{z}}$ being optimal for the $\varepsilon$-constraint problem $P^{\varepsilon ,2}_i({\bar{u}})$ or $P^{\varepsilon ,\rho }_i({\bar{u}})$. $\square$

Thanks to Theorem 2 we can remove one search zone per iteration, in which a new nondominated point is detected, when using the $\varepsilon$-constraint scalarization. The presented selection criterion is simple but not the only possible one. Another one is presented as a heuristic in Tamby and Vanderpooten (2020) (see their Section 3.3). In the following we formally prove that also their criterion yields the desired result of avoiding to solve unnecessary scalarizations.

Tamby and Vanderpooten (2020) select a search zone $u^*$ by computing

$$\begin{aligned} (i^*,u^*) = \left\{ \begin{array}{ll} (1,(M,\dots ,M)) &{} \quad \text {if} \; N=\emptyset , \\ \displaystyle \mathop {\mathrm {arg\,max}}\limits _{\begin{array}{c} u \in U(N),\\ i \in \{1,\dots ,p\},\\ u_i \ne M \end{array}} \{ h(i,u) \}&\quad \text {otherwise,} \end{array} \right. \end{aligned}$$

(7)

where

$$\begin{aligned} h(i,u) = \prod _{j \ne i} \left( u_j - z_j^I \right) \end{aligned}$$

and $z^I$ denotes the ideal point, see (1). The index $i^*$ serves to make use of starting solutions. If we ignore this additional feature, their selection criterion for a fixed index i reads

$$\begin{aligned} u^* = \left\{ \begin{array}{ll} (M,\dots ,M) &{} \quad \text {if} \; N=\emptyset , \\ \displaystyle \mathop {\mathrm {arg\,max}}\limits _{\begin{array}{c} u \in U(N),\\ u_i \ne M \end{array}} \left\{ \prod _{j \ne i} \left( u_j - z_j^I \right) \right\}&\quad \text {otherwise,} \end{array} \right. \end{aligned}$$

(8)

for a certain $i \in \{1,\dots ,p\}$. Note that, except in the first iteration, a product consisting of $p-1$ terms has to be computed for every search zone with $u_i \ne M$ to find the search zone with the largest projected hypervolume.

Theorem 3

[Max-projected-volume selection criterion] If, in every iteration of Algorithm 1, we select a search zone ${\bar{u}}$ according to (8), and if we then solve an $\varepsilon$-constraint problem of the form $P^{\varepsilon ,2}_i({\bar{u}})$ or $P^{\varepsilon ,\rho }_i({\bar{u}})$, then, whenever there is a solution ${\bar{z}} \in Z_N$ with ${\bar{z}} < {\bar{u}}$, the i-child of ${\bar{u}}$ exists, i.e., ${\bar{u}}^i \in U(N \cup \{ {\bar{z}} \})$. Moreover, ${\bar{u}}^i$ can not contain further nondominated points, i.e., $\{ z \in Z_N: z < {\bar{u}}^i \}= \emptyset$.

Proof

The proof is similar to the proof of Theorem 2. Assume that ${\bar{u}}^i \notin U(N \cup \{ {\bar{z}} \})$. Then, due to Proposition 1, the i-neighbor $u'$ of ${\bar{u}}$ contains ${\bar{z}}$. According to Lemma 5, we then have $u'_i < {\bar{u}}_i$, $u'_k > {\bar{u}}_k$ for some $k \ne i$ and $u'_j={\bar{u}}_j$ for $j \ne i,k$. However, then

$$\begin{aligned} \prod _{j \ne i} \left( u'_j - z_j^I \right) > \prod _{j \ne i} \left( {\bar{u}}_j - z_j^I \right) \end{aligned}$$

would hold, a contradiction to ${\bar{u}}$ satisfying (8). Hence, ${\bar{u}}^i \in U(N \cup \{ {\bar{z}} \})$ must hold.

The rest of the proof is the same as for Theorem 2. $\square$

Theorem 3 demonstrates that the heuristic selection criterion of Tamby and Vanderpooten (2020) has indeed the same beneficial property as our selection criterion (6). However, ours is much simpler, since it is solely based on one component value of a search zone, an information that is available anyway. It does not require any computation of additional figures as, e.g., the projected hypervolumes computed in Tamby and Vanderpooten (2020).

As done in (7), we could additionally choose the index i which then determines the index to be optimized in the $\varepsilon$-constraint problem. Then, previously generated nondominated points can be used as starting solutions as discussed in Lemma 1.

4 Search strategies in objective space methods

Objective space methods can be distinguished w.r.t. the way in which they search for nondominated outcome vectors in the objective space and, in particular, in the search region. While the previous sections focused on a formal description of the search region and its decomposition into (rectangular) search zones, which naturally implies decomposition-based methods, we will also review alternative search strategies and provide a brief summary of some of the most successful objective space methods. We classify these methods into three categories: Decomposition, recursive dimension reduction and disjunctive constraints. However, some methods can not be assigned clearly to one of these categories, wherefore we also discuss hybrid approaches in the end.

4.1 Decomposition

The concept of decomposition relies on the idea that the search region can be described by the union of rectangular sets which in turn can be described based on already generated nondominated points. In every iteration, one of these rectangular sets can be investigated which results in a rather simple IP to be solved. A natural and efficient decomposition of the search region was described in Sect. 2.1 above. However, there are different ways of decomposing the search region which will be briefly reviewed in the following.

One way consists in subdividing the search region into disjoint cells each of which is defined by a lower and upper bound vector. When a new nondominated point is generated, its components are inserted as axis-parallel “hyper-cuts” to all (concerned) cells. Dominated cells can be deleted immediately. Nevertheless, the number of remaining cells grows quickly. The union of all disjoint cells represents the search region. This idea is used in Laumanns et al. (2006, 2005), and Kirlik and Sayin (2014). The performance of an algorithm based on such a disjoint decomposition highly depends on the order in which the cells are investigated. Kirlik and Sayin (2014) select the box with the largest volume, where the volume is defined by the upper bound of the cell and the ideal point. Thereby they can avoid the generation of dominated points. However, without further enhancement strategies, it might happen that a nondominated point is computed more than once.

Other algorithms use a non-disjoint decomposition which leads to a smaller number of boxes to be saved and investigated. In this case, the boxes are usually only defined by upper bound vectors. Przybylski et al. (2010) use the idea of upper bounds in the second phase of their algorithm. They remove redundant upper bounds by a filtering step in every iteration. Lokman and Köksalan (2013) also implicitly use a sort of a non-disjoint decomposition by varying the right-hand side vectors of the constraints on the objective vectors in a systematic way based on all already generated nondominated points. Dächert and Klamroth (2015) propose a non-disjoint decomposition for tricriteria optimization problems which results in a number of upper bound vectors that depends linearly on the number of nondominated points. Klamroth et al. (2015) present a constructive algorithm that generates the set of local upper bound vectors based on a stable set of points, i.e., mutually nondominated points. The main idea is to use this stable set of points as defining points and to formulate a criterion which guarantees that the number of local upper bounds is minimal. This method will be referred to as the defining point algorithm (DPA) in Sect. 5 below. Another non-disjoint decomposition is proposed in Dächert et al. (2017) that is based on the inherent neighborhood structure between nondominated points and local upper bounds. Different to most other recursive and decomposition approaches, Dächert and Klamroth (2015), Klamroth et al. (2015) and Dächert et al. (2017) can guarantee that each nondominated point is only generated once during the algorithm which implies that no strategy based on the examination of all previously generated nondominated points is needed. Moreover, the DPA approach is not restricted to the application of $\varepsilon$-constraint scalarizations for the solution of subproblems. A specific implementation of the DPA approach is presented in Tamby and Vanderpooten (2020). It uses the particular properties of $\varepsilon$-constraint scalarizations in combination with a strategy for choosing the next search zone, which allows to use feasible starting solutions for the next IP to be solved. Holzmann and Smith (2018) suggest to use modified augmented weighted Tchebychev scalarizations to solve the subproblems, both in combination with simple non-disjoint decompositions including redundancies, and in combination with the DPA approach. Numerical tests confirm the clear superiority of the non-redundant decomposition from DPA.

4.2 Recursive dimension reduction

The idea of recursion is to reduce the dimension of the objective space (and hence the search region) until single criterion or bicriteria (sub-)problems are obtained. The results of lower level formulations are then used as bounds in the next higher level problem in a systematic way.

There are different ways how to organize the recursion. One way consists in selecting two objectives (typically the first and the second) and computing all points that are nondominated with respect to these two objectives. All other objectives are bounded from above, where the upper bounds are narrowed iteratively in every level of recursion. This is the basic idea of Chalmet et al. (1986), Özlen and Azizoğlu (2009) and Özlen et al. (2014).

Others also compute all possible combinations of recursions. Given a multiobjective optimization problem with ${p}$ objectives they consider all ${p}$ corresponding $({p}-1)$-dimensional optimization problems and so on. Therefore, a tree is created with bicriteria optimization problems in its leaf nodes. It is shown in Ehrgott and Tenfelde-Podehl (2003) that the points obtained by solving all $({p}-1)$-criteria problems represent a subset of the nondominated set of the original problem. This way of recursion has been used, e.g., in Tenfelde-Podehl (2003) and as a subprocedure in Dhaenens et al. (2010) and Przybylski et al. (2010).

A drawback of recursive algorithms is the fact that nondominated points are typically computed several times since they are often optimal for multiple recursive subproblems. Since the solution of IPs is costly, it is critical for the performance to avoid the repeated generation of already known nondominated points. In order to deal with this issue the information from all problems solved before can be stored. More precisely, this requires to save the right-hand side values of the bounded objectives as well as the result of the corresponding optimization run, i.e., the optimal solution of the problem or the information that it is infeasible. Before solving a new problem, the list of already solved problems is scanned. This idea is implemented in Özlen et al. (2014) and improved the number of solved IPs drastically.

4.3 Disjunctive constraints

Using disjunctive constraints is a general concept in optimization that is tailored for the case that the feasible set is non-convex. Typically, artificial binary variables are used to activate or deactivate parts of the feasible set. We refer, e.g., to the textbook Nemhauser and Wolsey (1999) for the general concept.

In the context of multiobjective optimization problems this concept is useful to describe the search region, which is a non-convex set. It is then possible to consider all remaining parts of the search region (that are not already known to be empty) simultaneously, i.e., to search for a new nondominated point by solving one single IP formulated over the complete (non-convex) search region. In this case, every nondominated point is computed exactly once. However, with every new nondominated point, the number of constraints and artificial binary variables increases which makes this approach computationally demanding and hardly ever competitive. Disjunctive constraints are used in Klein and Hannan (1982), Sylva and Crema (2004) and Lokman and Köksalan (2013).

4.4 Hybrid approaches

There are also hybrid methods that combine ideas from the three categories mentioned above. Boland et al. (2016) propose a method called L-shape search method for tricriteria problems that is a hybrid of disjunctive constraints and decomposition. The idea is to use disjunctive constraints only with respect to the lastly generated nondominated point which results in an L-shape element that is investigated with priority, i.e., shrunk quickly towards the ideal point. During the procedure, unexplored rectangular sets are saved and investigated in the later phase of the algorithm. Boland et al. (2017a) extend the L-shape search method to any number of objectives. The approach of Boland et al. (2017b) for tricriteria optimization problems can be seen as a hybrid of recursion and decomposition. It deals with upper bound vectors similar to other decomposition approaches. However, for a certain sequence of problems to be solved it keeps the bound on one of the objectives fixed as in a recursive method.

Bektaş (2018) presents a hybrid approach for multiobjective IPs that combines disjunctive constraints, inspired by Klein and Hannan (1982) and Sylva and Crema (2004), with decomposition. The disjunctive single-objective IPs use fewer variables than the original approaches, and the number of solver-calls (i.e., single-objective IPs solved) is reduced as compared to pure decomposition methods. However, the higher complexity of the individual solver calls still counteracts the speed-up obtained from solving fewer IPs.

5 Numerical study

For our numerical study we provide an implementation of the defining point algorithm (DPA) in C++. The source files as well as our own test files can be downloaded from https://github.com/kerstindaechert/DefiningPointAlgorithm. For the test files taken from other authors we refer to the respective urls. We compare our implementation to three state-of-the-art algorithms for which open source code is available and which are also implemented in C++. Moreover, all three methods invoke the commercial solver CPLEX to solve the single-objective scalarizations. Note that the respective implementations are of different types according to the classification shown in Sect. 4: disjoint decomposition (method “Epsilon” by Kirlik and Sayin 2014), recursive dimension reduction (method “AIRA” by Özlen et al. 2014) and a hybrid of disjunctive constraints and decomposition (method “DCM” by Boland et al. 2017a), supplemented by our “DPA ” implementation which is a pure non-disjoint and non-redundant decomposition method.

We acknowledge that there are several other objective space methods that could be used for further comparisons, such as, for example, Bektaş (2018), Holzmann and Smith (2018), Tamby and Vanderpooten (2020). Our comparison are focused on the above methods Epsilon, AIRA and DCM for the following reasons: (1) C++ implementations are available for these methods, and they can be combined with the same versions of single-objective solvers (CPLEX in our case). This leads to a fair comparison and avoids bias resulting from translations from other programming languages and/or re-implementations of existing code in C++. (2) The selected methods are representative in the sense that they cover different variants of objective space methods as discussed in Sect. 4 above. (3) In particular, Epsilon, the disjoint decomposition method of Kirlik and Sayin (2014), is used in a majority of all comparative studies on objective space methods. It can thus be seen as a general reference and may provide information on the relative performance w.r.t. other methods that are not included in this study.

In Sect. 5.1 we present our implementation in more detail. In Sect. 5.2 we state the benchmark algorithms with their current sources. We present the test instances in Sect. 5.3, followed by the discussion of the numerical results in Sect. 5.4.

5.1 Implementation

We implement the defining point algorithm (DPA) in C++. It is based on the original implementation of Klamroth et al. (2015) in C which has been designed to find and insert discrete sets of (nondominated) points. Hence, our main adjustment besides the translation to C++ is to make it applicable to solve multiobjective integer programming problems. To do so we add an interface to the commercial solver CPLEX to solve $\varepsilon$-constraint scalarizations. Moreover, we implement the enhancement discussed in Sect. 3.

Algorithm 2 shows the pseudocode of our implementation. Note that it has the same structure as Algorithm 1, the Generic Scalarization-Based Algorithm. We read the MOIP problem from a textfile and transform it into minimization format if needed. In ObtainBounds we compute the ideal point $z^I$ as well as a global upper bound $z^M$ by minimizing or maximizing each objective function individually, respectively. The values of $z^M$ incremented by 1 are used to define the upper bound u of the initial box. We initialize the list of boxes U by appending the initial box. As long as U is not empty, we select a box in SelectBoxToRefine. While it is possible to select any box here, in order to make use of Theorem 2, we select a box with minimal value $u_i$ according to (6), where the index i has been specified by the user and is part of the Input of Algorithm 2.

Algorithm 2

Defining Point Algorithm with $\varepsilon$-constraint scalarization

We then solve a scalarization, more precisely a two-stage or augmented $\varepsilon$-constraint method as presented in Sect. 2.2. We call the resulting variants DPA-TS and DPA-A, respectively. Note that we do not make use of the option of feeding the solver with a feasible starting solution. However, the defining point of the selected local upper bound ${\bar{u}}$ in component i is typically a feasible solution for ($P^{\varepsilon }_i(u)$) and ($P^{\varepsilon ,\rho }_i(u)$) and might be the result of the scalarization when the box is empty. Hence, in case of feasibility, we additionally check whether $z^s_i < {\bar{u}}_i$. We append $z^s$ only to the list N if the inequality is satisfied, otherwise we remove ${\bar{u}}$ from U.

In case a new nondominated point has been found, the list of local upper bounds is updated in UpdateList$(U, z^s)$ which is basically a re-implementation of Algorithm 5 of Klamroth et al. (2015), however, without generating the i-child of ${\bar{u}}$ which yields an empty search zone according to Theorem 2. For the pseudocode and justification of this routine we refer to Klamroth et al. (2015).

5.2 Benchmark algorithms

In our numerical study we take into account recently proposed algorithms that offer an open-source implementation in C++ and invoke the commercial solver CPLEX to solve scalarizations. To the best of our knowledge the following algorithms satisfy these requirements:

• Epsilon (Kirlik and Sayin 2014): http://home.ku.edu.tr/~moolibrary/

• AIRA (Özlen et al. 2014, Pettersson and Ozlen 2019): An implementation in C is available at https://bitbucket.org/melihozlen/moip_aira (last update 2017). A parallelized version of this code in C++ is available at https://github.com/WPettersson/moip_aira. It can also be used in a non-parallel fashion, hence, we used this implementation for our comparison.

• DCM ( Boland et al. (2017a): http://www.eng.usf.edu/~hcharkhgard/

5.3 Instances

For problems with three to five objectives we use publicly available benchmark instances of knapsack, assignment and travelling salesman instances. For our tests with up to ten objectives we create new instances of knapsack and assignment problems.

5.3.1 Knapsack problem

We use knapsack instances from http://home.ku.edu.tr/~moolibrary/ which have been used as a benchmark in Kirlik and Sayin (2014) and are still used for comparison in recent publications. These instances include problems with three objectives and $10, 20, \dots , 100$ items, problems with four objectives and 10, 20, 30, 40 items as well as problems with five objectives and 10 and 20 items. For each problem size there are 10 instances, so in total this set consists of 160 test files.

In order to create instances with six to ten criteria we used the test problem creator from https://github.com/wpettersson/ProblemGenerator.

5.3.2 Assignment problem

Assignment instances are also available at http://home.ku.edu.tr/~moolibrary/. These instances include problems with three objectives and $5, 10, \dots , 50$ items. Again, for each problem size there are 10 instances.

We also created instances with more criteria with the help of the test problem creator from https://github.com/wpettersson/ProblemGenerator.

5.3.3 Travelling salesman problem

We use instances with three and four objectives from Pettersson and Ozlen (2019). Thereby, the problems with three objectives are available under the direct link https://figshare.com/articles/3_objective_problem_test_cases/4814695.   The problems with four objectives are available here: https://figshare.com/articles/4_objective_problem_test_cases/4814698.

5.4 Numerical results

All algorithms are implemented in C++ and compiled for the Microsoft Windows 64 Bit operation system. For solving the optimization problems, the IBM CPLEX Optimizer 12.10 solver is used. The comparisons were executed on an Intel Core i7–7500U @2.90 GHz with 16GB of RAM, which is a rather slow computer in comparison to most popular processors. However, it demonstrates that the described algorithms also run on personal laptops and do not require high-performance compute clusters. All algorithms generate a textfile as output that contains the generated nondominated points. We compare these output files to make sure that all algorithms work correctly.

Some of the compared algorithms measure the runtime when executing, others do not. Since we do not want to alter the algorithms, we measure runtime as the time between calling the main routine until its termination. In order to avoid excessive runtimes we use the following timeout rule for all knapsack and assignment instances: We measure the runtime of DPA-TS and use it as a reference. The maximum runtime for all other algorithms is at least 30 minutes and at most ten times the reference runtime. For the TSP instances we reduce the upper bound of the timeout to three (instead of ten) times the runtime of DPA-TS to obtain shorter overall running times. In order to obtain stable run times, we run every benchmark instance twice and compute the average runtime.

Table 1 CPU times (absolute) on knapsack instances from Kirlik and Sayin (2014). If not all of the 10 problems in one instance could be solved within the given time, the number of solved problems is indicated in parentheses

Table 2 Number of solved IPs (absolute) on knapsack instances from Kirlik and Sayin (2014). If not all of the 10 problems in one instance could be solved within the given time, the number of solved problems is indicated in parentheses

Table 3 Relative CPU times (deviation from the fastest) on knapsack instances from Kirlik and Sayin (2014). If not all of the 10 problems in one instance could be solved within the given time, we do not indicate relative figures since this would be misleading

5.4.1 Knapsack instances from Kirlik and Sayin (2014)

We first study the knapsack instances with three to five objectives in Tables 1, 2, 3 and 4. Thereby, Table 1 shows CPU times, Table 2 the number of calls to CPLEX, thus, the number of solved IPs. For better comparison, the following two Tables 3 and 4 show the same results but this time relative w.r.t. the best performing algorithm per problem, which means relative CPU time with respect to the fastest and the relative number of IP calls with respect to the one with the smallest number of IPs. Note that since we are showing average figures, it might happen that none of the algorithms reaches a value of 1 which means that it is not superior in all of the 10 problems.

Considering CPU times we note that DPA outperforms the three benchmark algorithms Epsilon, DCM and AIRA considerably, especially for large instance sizes. With growing problem size, the superiority of DPA becomes more pronounced. For example, for $p=3$ and $n=100$, AIRA requires a relative runtime of 2.17, EPS a relative runtime of 2.64 and DCM a relative runtime of even 7.22 compared to DPA-A. Expressed in absolute terms, this means a runtime of 758.72 s for DPA-A, 1613.51 s for AIRA, 2220.52 s for EPS and 5753.29 s for DCM.

Note that EPS ran out of the given time limit of ten times the runtime of DPA-TS in 13 of the 160 problems, all of them from instances 4–30, 4–40 and 5–20. To some extent this matches the results presented in Kirlik and Sayin (2014), where for 4–40 only five of the ten problems could be solved within a time limit of 25000 s of CPU time. AIRA and DCM solve all problems reliably.

Comparing DPA within its two variants, DPA-A is fastest in most of the instances. The two-stage variant DPA-TS requires between 1.12 up to 1.43 times longer CPU times. This goes in line with the fact that the two-stage variants solve one IP more per nondominated point compared to the augmented variant.

Comparing the number of CPLEX calls in Tables 2 and 4, DCM solves less IPs than all the other algorithms for the small instances. This is not surprising since DCM uses disjunctive programs to search multiple rectangular boxes at once. This reduces the number of CPLEX calls on the one hand, but yields more complicated models involving additional binary variables on the other hand. As can be seen from the CPU times, the strategy of solving less but more complicated problems does not pay off. Even if DPA-A solves much more IPs in some instances, it requires considerably less CPU time.

Table 4 Relative number of solved IPs (deviation from the smallest) on knapsack instances from Kirlik and Sayin (2014). If not all of the 10 problems in one instance could be solved within the given time, we do not indicate relative figures since this would be misleading

5.4.2 Assignment instances from Kirlik and Sayin (2014)

The results obtained for the benchmark assignment instances with three objectives are given in Tables 5, 6, 7, and 8. Again, we depict absolute CPU times and number of solved IPs as well as their relative conterparts. While the average number of nondominated points of these instances is similar to those of the knapsack instances, it is common knowledge that assignment problems are much harder to solve.

With respect to CPU time, the DPA algorithms perform best again. For instance 3–50 EPS requires 1.69 more runtime than DPA-A, followed by AIRA with a factor of 1.97 and DCM with a factor of 10.26. While DCM does not only consume much more CPU time than all other algorithms for this instance, it also does not find all nondominated points reliably. More precisely, for the ten problems contained in 3–50, it misses on average around $10\%$ of the nondominated set.

With respect to the number of IPs, DPA-A solves the smallest number in all instances, followed by DCM, DPA-TS, EPS and AIRA, respectively.

Table 5 CPU times (absolute) on assignment instances from Kirlik and Sayin (2014). For instance 3–50, DCM only found on average $90\%$ of the nondominated points, marked by $*$

Table 6 Number of solved IPs (absolute) on assignment instances from Kirlik and Sayin (2014). For instance 3–50, DCM only found on average $90\%$ of the nondominated points, marked by $*$

Table 7 Relative CPU times (deviation from the fastest) on assignment instances from Kirlik and Sayin (2014). For instance 3–50, DCM only found on average $90\%$ of the nondominated points, marked by $*$

Table 8 Relative number of solved IPs (deviation from the smallest) on assignment instances from Kirlik and Sayin (2014). For instance 3–50, DCM only found on average $90\%$ of the nondominated points, marked by $*$

5.4.3 Travelling salesman instances from Pettersson and Ozlen (2019)

As a third test bed we use travelling salesman instances with three and four objectives. Note that each problem size consists of five instances. Moreover, we set the timeout here to at most three times the runtime of DPA-TS (but again at least 30 min). The results are shown in Tables 9, 10, 11, and 12. The results are in line with the results for knapsack and assignment instances, and, thus, confirm the general behavior for three and four objectives: DPA-A is fastest in nearly all instances, followed by DPA-TS. The behavior of the three remaining algorithms depends on the problem size. For smaller problems, EPS is faster than DCM, which in turn is faster than AIRA. At some problem size, AIRA gets better than DCM. For large problems, AIRA outperforms DCM and EPS.

Table 9 CPU times (absolute) on TSP instances from Pettersson and Ozlen (2019). For instance size 4–15 we only solve three of the five problems. If not all of the 5 (3) problems in one instance could be solved within the given time (at most three times the runtime of DPA-TS), the number of solved problems is indicated in parentheses

Table 10 Number of solved IPs (absolute) on TSP instances from Pettersson and Ozlen (2019). For instance size 4–15 we only solve three of the five problems. If not all of the 5 (3) problems in one instance could be solved within the given time (at most three times the runtime of DPA-TS), the number of solved problems is indicated in parentheses

Table 11 Relative CPU times (deviation from the fastest) on TSP instances from Pettersson and Ozlen (2019). For instance size 4–15 we only solve three of the five problems. If not all of the 5 (3) problems in one instance could be solved within the given time (at most three times the runtime of DPA-TS), the number of solved problems is indicated in parentheses

Table 12 Relative number of solved IPs (deviation from the smallest) on TSP instances from Pettersson and Ozlen (2019). For instance size 4–15 we only solve three of the five problems. If not all of the 5 (3) problems in one instance could be solved within the given time (at most three times the runtime of DPA-TS), the number of solved problems is indicated in parentheses

5.4.4 High-dimensional instances

Finally we investigate how the algorithms perform when applied to instances with up to 10 objectives. To the best of our knowledge, we are the first to present results for problems with more than six objectives by exact algorithms. Since the computational effort increases considerably with an increasing number of objectives, we restrict the number of knapsack items (variables) to at most 15. For the assignment instances with six to ten objectives we present results for 5 items, i.e., 25 variables. Moreover, we evaluate only five or three problems per instance.

The results of the knapsack instances are shown in Tables 13 and 14. First we state that both variants, DPA-TS and DPA-A, solve all instances reliably. Moreover, we observe that the main difference between both variants, the saving of $|Z_N|$ integer programs when using the augmented variant, looses importance with increasing number of objectives. This also translates to the CPU times. Considering the results of EPS we observe that it can only solve the smaller instances within the given time frame. While, e.g., DPA-TS solves instance 7–10 with on average 81.8 nondominated points within 34.67 s, EPS can not provide the nondominated set within half an hour. The smaller instances 6–5, 6–10, 7–5, 8–5 and 9–5 can be solved by EPS, but in all but one instance EPS is the slowest algorithm. AIRA also shows difficulties with the larger instances. In general, it performs better than EPS (except for instance 6–5) but worse than the DPA variants and DCM. DCM outperforms the DPA variants with respect to CPU times for the smaller instances 6–5, 7–5, 8–5, 9–5 and 10–5, for which the solution time is less than 1 s or slightly above. However, the DPA variants show their superiority in all larger instances. DCM can only partially solve these instances. The average figures shown in Table 13 only take the solved problems into account. Even for these, the average CPU times are, in general, higher than those of the DPA variants. Looking at the number of IPs, DCM solves significantly less IPs than both DPA variants in all high-dimensional instances. This underlines again that the number of IPs is not the main figure to look at but that the structure of these IPs, in particular the number of the involved integer variables, is decisive for the CPU time.

The results of the assignment instances are given in Tables 15 and 16. In general, the results are similar to the knapsack results. However, the DPA variants perform even better. Again, DPA-TS and DPA-A solve all instances reliably and are, apart from instances 4–5 and 5–5, clearly the fastest algorithms compared to the other three algorithms. However, different to the knapsack results, DCM is outperformed by the DPA variants also for most of the smaller instances. Besides, AIRA performs better for the assignment instances. It outperforms DCM in the larger instances 4–15, 4–20 and 5–10 with respect to CPU time, but is still inferior to the DPA variants.

Table 13 CPU times (absolute) on high-dimensional knapsack instances. The number of evaluated problems per instance size changes with p and n; it is reported in parentheses in the third column. The sign “−” means stopped by timeout

Table 14 Number of solved IPs (absolute) on high-dimensional knapsack instances. The number of evaluated problems per instance size changes with p and n; it is reported in parentheses in the third column. The sign“−” means stopped by timeout

Table 15 CPU times (absolute) on high-dimensional assignment instances. The number of evaluated problems per instance size changes with p and n; it is reported in parentheses in the third column. The sign “−” means stopped by timeout. For instance 4–20, DCM only found 28,869 of the 33,672 points, marked by $*$

Table 16 Number of solved IPs (absolute) on high-dimensional assignment instances. The number of evaluated problems per instance size changes with p and n; it is reported in parentheses in the third column The sign “−” means stopped by timeout. For instance 4–20, DCM only found 28,869 of the 33,672 points, marked by $*$

6 Summary and further ideas

In this paper we combine the defining point algorithm (DPA) introduced in Klamroth et al. (2015) with suitable scalarization methods to obtain a new versatile approach to compute the nondominated set of multiobjective integer programming problems. Our theoretical and numerical analysis provide evidence that DPA finds a competitive balance between the number of required solver calls on the one hand, and the numerical complexity of each individual solver call on the other hand. Indeed, we show that the number of solver calls can be bounded by a polynomial in the number of nondominated points in the worst case. At the same time, subproblems are kept simple by using basic $\varepsilon$-constraint or weighted Tchebychev scalarizations. Two variants of DPA are implemented in C++ and compared to available state-of-the-art open-source solvers. We demonstrate the clear superiority of DPA with respect to CPU time on common benchmark instances as well as newly generated instances with up to ten objectives. Setting a time limit of at most ten times the solution time of the fastest algorithm, respectively, only DPA solves all instances reliably.

We present our algorithm as versatile and modular in the sense that it can be combined with any scalarization. Our numerical study concentrates on the $\varepsilon$-constraint scalarization due to the advantages described in Sect. 3 when the goal is to find every efficient solution. A numerical comparison using an $\varepsilon$-constraint scalarization and additionally a weighted Tchebychev scalarization has been presented in Dächert and Klamroth (2015). The algorithm therein is structurally similar to the defining point approach used in this paper, so the findings can be transferred directly. It is shown that when the goal is to generate the entire nondominated set, the (augmented) $\varepsilon$-constraint scalarization is always superior to the weighted Tchebychev scalarization due to its reduced number of IPs. However, when the goal is to generate only a subset of the nondominated set, a so-called incomplete representation, then other scalarizations as, e.g., the weighted Tchebychev scalarization promise to be more useful. We refer to Doğan et al. (2022) for an implementation in the context of multi-objective mixed-integer linear programming (MOMILP) problems. An adaptation of DPA to other types of representations is a promising direction for future research. This topic is, however, beyond the scope of this paper and left for further research.

Our study also shows that with an increasing number of objectives, the computational time increases as well. Therefore, in the future, a parallel variant should be developed. Parallel variants based on other algorithms have already been proposed in Pettersson and Ozlen (2019) and Turgut et al. (2019). It remains to be studied how a parallel defining point algorithm competes with these approaches.