Content uploaded by Marco Cococcioni

Author content

All content in this area was uploaded by Marco Cococcioni on Mar 13, 2022

Content may be subject to copyright.

Solving the Lexicographic Multi-Objective Mixed-Integer

Linear Programming Problem Using

Branch-and-Bound and Grossone Methodology

Marco Cococcionia, Alessandro Cudazzoa, Massimo Pappalardoa, Yaroslav D. Sergeyevb,c,∗

aUniversity of Pisa, Pisa (Italy)

bUniversity of Calabria, Rende (Italy)

cLobachevsky State University of Nizhni Novgorod (Russia)

Abstract

In the previous work (see [1]) the authors have shown how to solve a Lexicographic Multi-Objective

Linear Programming (LMOLP) problem using the Grossone methodology described in [2]. That al-

gorithm, called GrossSimplex, was a generalization of the well-known simplex algorithm, able to deal

numerically with inﬁnitesimal/inﬁnite quantities.

The aim of this work is to provide an algorithm able to solve a similar problem, with the addition

of the constraint that some of the decision variables have to be integer. We have called this problem

LMOMILP (Lexicographic Multi-Objective Mixed-Integer Linear Programming).

This new problem is solved by introducing the GrossBB algorithm, which is a generalization of the

Branch-and-Bound (BB) algorithm. The new method is able to deal with lower-bound and upper-bound

estimates which involve inﬁnite and inﬁnitesimal numbers (namely, Grossone-based numbers). After

providing theoretical conditions for its correctness, it is shown how the new method can be coupled with

the GrossSimplex algorithm described in [1], to solve the original LMOMILP problem. To illustrate how

the proposed algorithm ﬁnds the optimal solution, a series of LMOMILP benchmarks having a known

solution is introduced. In particular, it is shown that the GrossBB combined with the GrossSimplex is

able solve the proposed LMOMILP test problems with up to 200 objectives.

Keywords

Multi-Objective Optimization; Lexicographic Optimization; Mixed-Integer Linear Programming; Numer-

ical Inﬁnitesimals; Grossone Methodology

1. Introduction

It is well known that the Linear Programming, i.e., optimization of a linear function over a domain

being the intersection of linear inequalities has attracted a lot of attention since World War II. At the end

of ’90, multi-objective optimization problems with conﬂicting objectives started to be under an intense

investigation, especially using stochastic methods aiming at approximating the Pareto optimal frontier

(see [3, 4, 5] and references given therein). Recently, lexicographic multi-objective optimization problems

is gaining popularity (see [1, 6, 7, 8, 9]). The solution of the lexicographic multi-objective problem is

also an optimal in the Pareto sense, but, of course, not all the Pareto optimal solutions are lexicographic

optimal. Thus, being in general unique (when the problem is not multi-modal), the lexicographic opti-

mum is particularly interesting to ﬁnd. In a previous work [1], the lexicographic multi-objective linear

programming problem (LMOLP) has been solved by introducing the GrossSimplex algorithm being a gen-

eralization of the well-known simplex algorithm able to deal with inﬁnitesimal/inﬁnite quantities modeled

using Grossone methodology (see [2]). The main idea of that work was to transform the multi-objective

problem into a single-objective one, where the objectives were summed up with inﬁnitesimal weights, and

the order of the inﬁnitesimal weights decreased with the decrease of the importance of the objectives.

In the present work, we investigate the case where some of the decision variables are integer. We

have called such class of problems LMOMILP (Lexicographic Multi-Objective Mixed-Integer Linear Pro-

gramming). The integrality constraints hugely aﬀect the problem, similarly to what happens in the

∗Corresponding author. Tel.: +39 (0)984 494855.

Email addresses: marco.cococcioni@unipi.it (Marco Cococcioni), alessandro@cudazzo.com (Alessandro Cudazzo),

massimo.pappalardo@unipi.it (Massimo Pappalardo), yaro@dimes.unical.it (Yaroslav D. Sergeyev)

Preprint submitted to Elsevier December 24, 2019

single-objective case. Thus, we have decided to resort to the branch and bound (BB) approach, typically

used to solve MILP (Mixed-Integer Linear Programming) problems. The key idea here is to call the

GrossSimplex algorithm at each node visited by the BB algorithm to solve the relaxed problem (i.e., the

one without integer constraints). However, the BB algorithm needs to be generalized in order to work

with the GrossSimplex algorithm, since the latter returns as its output a bound for the optimal solution

at the current node which can be a number not only with ﬁnite but also with inﬁnitesimal components.

The BB algorithm able to manage Grossone-based numbers and called GrossBB is introduced here, its

pruning rules and the terminating conditions are described and studied. Finally, LMOMILP test prob-

lems having known solutions are proposed and it is shown on a number of numerical experiments that the

GrossBB algorithm coupled with the GrossSimplex algorithm successfully ﬁnd the correct solution. A

preliminary version of the present work, signiﬁcantly shorter and not containing the proof of the pruning

rules contained herein, has been presented at the NUMTA’19 conference (see [10]).

In order to start, let us recall the basics of Grossone, the enabling methodology of this work. The

numeral ¬called Grossone has been introduced (see a recent survey [2]) as a basic element of a pow-

erful numeral system allowing one to express not only ﬁnite but also diﬀerent inﬁnite and inﬁnitesimal

quantities (analogously, the numeral 1 is a basic element allowing one to express a variety of ﬁnite quan-

tities). From the foundational point of view, grossone has been introduced as an inﬁnite unit of measure

equal to the number of elements of the set Nof natural numbers (notice that the ¬-based computational

methodology is not related to non-standard analysis (see [11]) and its non-contradictory has been studied

in depth in [12, 13, 14]). From the practical point of view, this methodology has given rise both to a

new supercomputer patented in several countries (see [15]) and called Inﬁnity Computer and to a variety

of applications starting from optimization (see [1, 16, 17, 18, 19, 20, 21, 22]) and going through inﬁnite

series (see [2, 23, 24, 25, 26]), fractals and cellular automata (see [23, 27, 28, 29, 30, 31]), hyperbolic ge-

ometry and percolation (see [32, 33, 34]), the ﬁrst Hilbert problem and Turing machines (see [2, 35, 36]),

inﬁnite decision making processes, game theory, and probability (see [37, 38, 39, 40, 41, 42]), numerical

diﬀerentiation and ordinary diﬀerential equations (see [43, 44, 45, 46, 47]), etc.

The remaining text in the paper is structured as follows. In Section 2, the mixed-integer linear pro-

gramming problem (MILP) is stated and the standard BB algorithm is presented brieﬂy. In Section 3, the

Lexicographic Multi-Objective Mixed-Integer Linear Programming (LMOMILP) problem is formalized.

The Grossone methodology is brieﬂy presented in Section 4, while Section 5 presents the GrossBB algo-

rithm and its pruning rules, terminating conditions and branching rule. Section 6 presents ﬁve LMOMILP

test problems and their solutions obtained using the proposed algorithm, whereas Section 7 is devoted to

conclusions.

2. Mixed-Integer Linear Programming: MILP

An integer programming problem is a mathematical optimization problem in which some or all of

the variables are restricted to be integers. In many settings where both the objective function and the

constraints are linear the terminology is the following: integer linear programming (ILP), if all variables

in the problem statement should be integers; mixed-integer linear programming (MILP) if only a subset

of them should be integer.

2.1. The MILP problem

The MILP problem can be formalized as follows:

min cTx

s. t. Ax 6b,

x=p

qp∈Zk,q∈Rn−k,P

where cis a column vectors∈Rn,xis a column vector ∈Rn(but kvariables are constrained to be integer),

Ais a full-rank matrix ∈Rm×n,bis a column vector ∈Rm. Hereinafter we assume that the feasibility

region of problem Pis bounded and non-empty. As in any MILP problem, from the problem P, we can

deﬁne the polyhedron with linear constraints:

S ≡ {x∈Rn:Ax 6b}.(1)

2

Let us now introduce the new problem R, which is a relaxed version of problem P. Namely, it is obtained

from Pby removing the integrality constraint:

min cTx

s.t. Ax 6b,R

There are diﬀerent techniques to ﬁnd the optimal value of a MILP problem or an approximation, one

of these is the BB algorithm, which, as explained in the next subsection, solves the relaxed problems R

associated to a series of new sub-problems derived from P.

2.2. MILP solved using the LP-based BB algorithm

Before introducing the LMOMILP problem and the GrossBB algorithm, let us recall the MILP prob-

lem and its solution based on the BB algorithm, combined with an LP solver. When a MILP problem P

is bounded and non-empty (as we have assumed before), the total number of feasible solutions is ﬁnite.

The BB approach is based on the principle that the total set of feasible solutions can be partitioned into

smaller subsets of solutions. These smaller subsets can then be evaluated systematically until the best

solution is found. The BB approach is coupled with a Linear Programming (LP) solver when is used to

solve a MILP problem.

This method employs a tree structure (generally binary), nodes and branches are used as framework

for the solution process. We deﬁne the problem Pas the root problem and with Pij the problem at node

(ij), the nodes are enumerated and visited with the Breadth-First-Search (BFS) approach (Pij refers to

the j-th problem at level iof the tree). First of all, we will calculate the lower bound vI(P) by solving

the relaxation of Pand the upper bound vS(P) determined with a greedy algorithm (or we will assign

to it the value +∞).

The optimal solution v(P) will thus always be between these two values (integrality gap):

vI(P)6v(P)6vS(P).(2)

Hereinafter, since we shall use always binary trees, we will indicate with Pcthe current problem to

solve (the one at leaf node (Pc)), and with Pland Prthe corresponding sub-problems at its left and right,

respectively.

The BB algorithm uses the following pruning rules, terminating conditions and branching rule:

Theorem 1 (Pruning rules).Let xopt be the best solution found so far for Pand let be vS(P) = cTxopt

be the current upper bound. Considering the current node (Pc)and the associated problem Pc:

1. If the feasible region of Pcis empty the sub-tree with root (Pc)has no feasible solutions with a value

lower than cTxopt. So we can prune this node.

2. If vI(Pc)>vS(P), then we can prune at node (Pc), since the sub-tree with root (Pc)cannot have

feasible solutions having a value lower than vS(P).

3. If vI(Pc)< vS(P)and the optimal solution ¯x of the relaxed problem Rcof problem Pcis feasible

for P, then ¯x is a better candidate solution for Pand thus we can update xopt (xopt =¯x)and the

value of the upper bound (vS(P) = vI(Pc)). Finally, prune this node according to the second rule.

It can be proved that the three pruning rules above are correct (see [48]).

Terminating conditions for the BB

1. All the remaining leaves have been visited: if all the leaves have been visited the BB algorithm

stops.

2. Maximum number of iteration reached: when a given maximum number of iterations (pro-

vided by the user at the beginning) has been reached, the BB stops.

3. ε−optimality reached: when the normalized diﬀerence between the global lower bound and the

global upper bound is close enough to zero, we can stop:

∆(P) = vS(P)−vI(P)

|vS(P)|6, (3)

where the global lower bound vI(P) can be computed at any step as the minimum of the lower bounds

in the queue of the problems to be solved.

3

Branching rule for the BB

If vI(Pc)< vS(P) and none of the pruning rules have been applied, take ¯x, the optimal solution of the

relaxation at that node and branch on the component having the highest fractional part among those

variables having integer restrictions. In case of ties, branch on the ﬁrst component. Thus we will create

two distinct sub-problems of the current problem, denoted as Pland Pr. The pseudo-code for the BB

algorithm is provided in Algorithm 1.

Algorithm 1 The LP-based BB Algorithm

Inputs: maxIter and a speciﬁc MILP problem |P|, to be put within the root node (P)

Outputs: xopt (the optimal solution), fopt (the optimal value)

Step 0. Insert |P|into a queue of the sub problems that must be solved. Put vS(P) = ∞,xopt = [ ],

and fopt =∞or use a greedy algorithm to get an initial feasible solution.

Step 1a. If all the remaining leaves have been visited (empty queue), or the maximum number of

iterations has been reached, or the ε−optimality condition holds, then goto Step 4. Otherwise

extract from the head of the queue the next problem to solve and call it Pc(current problem).

Remark: this policy of insertion of new problems at the tail of the queue and the extraction from

its head leads to a breadth-ﬁrst visit for the binary tree of the generated problems.

Step 1b. Solve Rc, the relaxed version of the problem Pcat hand, using the GrossSimplex and get ¯x

and fc( = cT¯x):

[¯x, fc,emptyPolyhedron]←LPSolver(Rc)

Step 2a. If the LP solver has found that the polyhedron is empty, then prune the sub-tree of (Pc)

(according to Pruning Rule 1) by going to Step 1a (without branching (Pc)). Otherwise, we have

found a new lower value for Pc:

vI(Pc) = fc

Step 2b. If vI(Pc)>vS(P), then prune the sub-tree under Pc(according to Pruning Rule 2), by going

to Step 1a (without branching Pc).

Step 2c. If vI(Pc)< vS(P) and all components of ¯x that must be integer are actually -integer (i.e., ¯x

is feasible), then we have found a better upper bound estimate. Thus we can update the value of

vS(P) as:

vS(P) = vI(Pc).

In addition we set xopt =¯x and fopt =vI(Pc).Then we also prune the sub-tree under (Pc) (according

to Pruning Rule 3) by going to Step 1a (without branching (Pc)).

Step 3. If vI(Pc)< vS(P) but not all components of ¯x that must be integer are actually -integer, we

have to branch. Select the component of ¯xtof ¯x having the greatest fractional part, among all the

components that must be integer. Create two new nodes (i.e., problems) with a new constraint for

this variable, one with a new 6constraint for the rounded down value of ¯xtand another with a

new >constraint for the rounded up value of ¯xt.Let us call the two new problems Pland Prand

put them at the tail of the queue of the problems to be solved, then goto Step 1a.

Step 4. End of the algorithm.

3. Lexicographic Multi-Objective Mixed-Integer Linear Programming: LMOMILP

In this section we introduce the LMOMILP problem, which is stated as follows:

lexmin c1Tx,c2Tx, ..., cr T x

s.t. Ax 6b,

x=p

qp∈Zk,q∈Rn−k

P

4

where ci, i = 1, ..., r, are column vectors ∈Rn,xis a column vector ∈Rn,Ais a full-rank matrix

∈Rm×n,bis a column vector ∈Rm. lexmin in Pdenotes Lexicographic Minimum and means that the

ﬁrst objective is much more important than the second, which is, on its turn, much more important than

the third one, and so on. Sometimes in literature this is denoted as c1Txc2Tx... cr T x.

As in any MILP problem, from the problem P, we can deﬁne the polyhedron deﬁned by the linear

constraints alone:

S ≡ {x∈Rn:Ax 6b}.(4)

Thus we can deﬁne problem R, the relaxation of a lexicographic (mixed) integer linear problem, obtained

from Pby removing the integrality constraint on each variable:

lexmin c1Tx,c2Tx, ..., cr T x

s.t. Ax 6b,R

Problem Ris called LMOLP (Lexicographic Multi-Objective Linear Problem), and can be solved, as

shown in [1], using the Grossone-based methodology from [2]). In addition, every thing we have said

above for the MILP problem is still valid for the LMOMILP.

Notice that the formulation of Pmakes no use of Gross-numbers or Gross-arrays involving ¬, namely,

it involves ﬁnite numbers only. Hereinafter we assume that Sis bounded and non-empty. In the next

section we brieﬂy introduce the Grossone methodology, that will be used in Section 5 to transform problem

Pinto an equivalent formulation, based on the use of Grossone, which will be solved by the GrossBB

algorithm to be introduced in Section 5.

4. The Grossone-based Methodology

In [2, 49, 50, 51] a computational methodology working with an inﬁnite unit of measure called Grossone

and indicated by the numeral ¬has been introduced as the number of elements of the set of natural

numbers N. On the one hand, this allows one to treat easily many problems related to the traditional

set theory operating with Cantor’s cardinals. In the new framework, instead of the usage of cardinals

the number of elements of inﬁnite sets using ¬-based numerals can be computed. For instance, the

following sets that the traditional cardinalities identify as countable can be measured more precisely (see

[2, 35, 50]). In fact, it can be shown that the set of even numbers Ehas ¬

2elements, namely, two times

less than the set of natural numbers having ¬elements. The set of integers Zhas 2¬+1 elements, the

set Gof square natural numbers

G={x:x=n2, x ∈N, n ∈N}

has b√¬celements, etc. Analogously, it becomes possible to discern among sets having the traditional

cardinality of continuum inﬁnite sets with diﬀerent number of elements. For instance, it follows that the

set of numbers x∈[0,1) expressed in the binary positional numeral system is equal to 2¬and the set of

numbers x∈[0,1) expressed in the decimal positional numeral system has 10¬>2¬elements (for more

examples see [2, 35, 50, 51]).

On the other hand, in the numeral system built upon Grossone, there is the opportunity to treat

inﬁnite and inﬁnitesimal numbers in a unique framework and to work with all of them numerically, i.e., by

executing arithmetic operations with ﬂoating-point numbers and the possibility to assign concrete inﬁnite

and inﬁnitesimal values to variables. This is one of the diﬀerences with Robinson’s Non-Standard Analysis

where non-standard inﬁnite numbers are discussed but, if Kis a non-standard inﬁnite integer, there is

no possibility to assign a value to K, it always remains just a symbol without any concrete numerical

value and only symbolic computations can be executed with it (see [11] for a detailed discussion).

The new numeral ¬is introduced by describing its properties (following the same approach that

lead to the introduction of zero in the past to switch from natural to integer numbers). To introduce

Grossone, three methodological postulates and The Inﬁnite Unit Axiom is added to the axioms of real

numbers (see [2]). In particular, this axiom states that for any given ﬁnite integer nthe inﬁnite number

¬

nis integer being larger than any ﬁnite number. Since the axiom is added to the standard axioms of

real numbers, all standard properties (commutative, associative, existence of inverse, etc.) also apply

to ¬and Grossone-based numerals. Instead of the usual symbol ∞diﬀerent inﬁnite and/or inﬁnitesimal

numerals can be used thanks to ¬. Indeterminate forms are not present and, for example, the following

5

relations hold for inﬁnite numbers ¬,¬2and inﬁnitesimals ¬−1,¬−2, as for any other (ﬁnite, inﬁnite,

or inﬁnitesimal) number expressible in the new numeral system:

0·¬=¬·0=0,¬−¬= 0,¬

¬= 1,¬0= 1,1¬= 1,0¬= 0,

0·¬−1=¬−1·0=0,¬−1>¬−2>0,¬−1−¬−1= 0,2¬−¬=¬,

¬−1

¬−1= 1,(¬−1)0= 1,¬·¬−1= 1,¬·¬−2=¬−1,

5¬−2

¬−2= 5,60.1¬2

¬= 60.1¬,¬−1

2¬−2= 0.5¬,¬2·¬−1=¬,¬2·¬−2= 1.

A general way to express inﬁnities and inﬁnitesimals is also provided in [2, 49, 50, 51] by using records

similar to traditional positional number systems, but with the radix ¬. A number ˜cin this new numeral

system (˜cwill be called Gross-scalar from here on) can be constructed by subdividing it into groups of

corresponding powers of ¬and thus can be represented as

˜c=cpm¬pm+... +cp1¬p1+cp0¬p0+cp−1¬p−1+... +cp−k¬p−k,

where m, k ∈N,exponents piare called Gross-powers (they can be numbers of the type of ˜c) with p0= 0,

and i=m, ..., 1,0,−1, ..., −k. Then, cpi6= 0 called Gross-digits are ﬁnite (positive or negative) numbers,

i=m, ..., 1,0,−1, ..., −k. In this numeral system, ﬁnite numbers are represented by numerals with the

highest Gross-power equal to zero, e.g., −6.2 = −6.2¬0. Inﬁnitesimals are represented by numerals

having negative ﬁnite or inﬁnite Gross-powers. The simplest inﬁnitesimal is ¬−1for which ¬−1·¬= 1.

We notice that all inﬁnitesimals are not equal to zero, e.g., ¬−1>0. A number is inﬁnite if it has at least

one positive ﬁnite or inﬁnite Gross-power. For instance, the number 43.6¬4.56¬+ 16.7¬3.6−3.2¬−2.1is

inﬁnite, it consists of two inﬁnite parts and one inﬁnitesimal part.

In the context of this paper the following deﬁnition is important. A Gross-number (Gross-scalar) is

said purely ﬁnite iﬀ the coeﬃcient associated with the zeroth power of Grossone is the only one to be

diﬀerent from zero. For instance, the number 3.4 is purely ﬁnite and 3.4−3.2¬−2.1is ﬁnite but not

purely ﬁnite since it has an inﬁnitesimal part.

5. LMOMILP solved using the GrossSimplex-based GrossBB algorithm

First of all, let us introduce the new problem ˜

P, formulated using Gross-numbers:

min ˜cTx

s.t. Ax 6b,

x=p

qp∈Zk,q∈Rn−k,

˜

P

where ˜c is a column Gross-vector having nGross-scalar components built using purely ﬁnite vectors ci

˜c =

r

X

i=1

ci¬−i+1 (5)

and ˜cTxis the Gross-scalar obtained by multiplying the Gross-vector ˜c by the purely ﬁnite vector x

˜cTx= (c1Tx)¬0+ (c2Tx)¬−1+... + (crT x)¬−r+1 ,(6)

where (6) can be equivalently written in the extended form as:

˜cTx= (c1

1x1+... +c1

nxn)¬0+ (c2

1x1+... +c2

nxn)¬−1+... + (cr

1x1+... +cr

nxn)¬−r+1.

What makes the new formulation ˜

Pattractive is the fact that its relaxed (from the integrality con-

straint) version is a Gross-LP problem (see [1]), which can be eﬀectively solved using a single run of

the GrossSimplex algorithm proposed in [1]. This means that the set of multiple objective functions is

mapped into a single (Gross-) scalar function to be optimized. This opens the possibility to solve the

6

integer-constrained variant of the problem using an adaptation of the BB algorithm (see Alg. 2), coupled

with the GrossSimplex. Of course, the GrossSimplex will solve the relaxed version of ˜

P:

min ˜cTx

s.t. Ax 6b

˜

R

The following Theorem 2 shows that problem ˜

Pis equivalent to problem Pdeﬁned in Section 3.

Theorem 2 (Equivalence of problem ˜

Pand problem P).Problem ˜

Pis equivalent to the problem Pand

both of them have the same solution.

Proof. The basic observation is that the integer relaxation Rof problem Pis an LMOLP problem, while

the integer relaxation of problem ˜

P, the ˜

Rproblem deﬁned above, is a Gross-LP problem. In [1] we

have already proved the equivalence of problems Rand ˜

R. Since problems Pand ˜

Phave equivalent

relaxations, the two will also share the same solutions when the same integrality constraints will be taken

into account on both.

In the next subsections we will provide the pruning rules, terminating conditions and the branching

rule. Then we will introduce the GrossBB algorithm being a generalization of the BB algorithm able to

work with Gross-numbers.

5.1. Pruning rules for the GrossBB

The pruning rules presented above can be adapted to the GrossBB algorithm as follows.

Theorem 3 (Pruning rules for the GrossBB).Let xopt be the best solution found so far for ˜

P , and

let ˜vS(˜

P) = ˜cTxopt be the current upper bound. Considering the current node (˜

Pc)and the associated

problem ˜

Pcthe following assertions hold:

1. If the feasible region of problem ˜

Pcis empty the sub-tree with root (˜

Pc)has no feasible solutions

having values lower than ˜cTxopt. So we can prune this node.

2. If ˜vI(˜

Pc)>˜vS(˜

P), then we can prune at node (˜

Pc), since the sub-tree with root (˜

Pc)cannot have

feasible solutions having a value lower than ˜vS(˜

P).

3. If ˜vI(˜

Pc)<˜vS(˜

P)and the optimal solution ¯x of the relaxed problem ˜

Rcis feasible for ˜

P, then ¯x

is a better candidate solution for ˜

P, and thus we can update xopt (xopt =¯x)and the value of the

upper bound (˜vS(˜

P) = ˜vI(˜

Pc)). Finally, prune this node according to the second rule.

Proof. Let us prove the correctness of the pruning rules introduced above.

[Pruning Rule 1]. If the feasible region of the current problem ˜

Rcis empty, then the one of ˜

Pcis

empty, too, since the domain of ˜

Pchas additional constrains (the integrality constraints). Furthermore,

all the domains of the problems in the leaves of the sub-tree having root in ˜

Pcwill be empty, as well, since

the domains of the leaves have all additional constrains with respect to ˜

Rc. This proves the correctness

of the ﬁrst pruning rule. Now let us prove the second pruning rule.

[Pruning Rule 2]. Let us consider a generic leaf Pleaf of the sub-tree having root ˜

Pc. Let us indicate

with ˜v(˜

Pc) the optimal value of the current problem ˜

Pc(the one with the integer constraints). Then the

values at the leaves below ˜

Pcmust be greater than or equal to ˜v(˜

Pc):

˜v(˜

Pleaf )>˜v(˜

Pc)∀leaf in SubTree( ˜

Pc).

In fact, the domain of ˜

Pcincludes the ones of all the ˜

Pleaf , being each problem ˜

Pleaf obtained by enriching

˜

Pcwith additional constraints. On the other hand, it follows that

˜v(˜

Pc)>˜vI(˜

Pc),

since ˜vI(˜

Pc) is obtained as the optimal solution of ˜

Rc, a problem having a domain which includes the one

of ˜

Pc. Thus, the following chain of inequalities always holds:

˜v(˜

Pleaf )>˜v(˜

Pc)>˜vI(˜

Pc)∀leaf in SubTree( ˜

Pc)

Now, if ˜vI(˜

Pc)>˜vS(˜

P), we can add an element to the chain:

˜v(˜

Pleaf )>˜v(˜

Pc)>˜vI(˜

Pc)>˜vS(˜

P)∀leaf in SubTree( ˜

Pc)

7

from which we can conclude that

˜v(˜

Pleaf )>˜vS(˜

P)∀leaf in SubTree( ˜

Pc).

This means that all the leaves of the current node will contain solutions that are worse (or equivalent)

than the current upper bound. Thus the sub-tree rooted in ˜

Pccan to be pruned (i.e., not explicitly

explored). This proves the correctness of the second pruning rule.

Before proving the pruning rule 3, let us observe how the pruning rule above prevents from solving

multi-modal problems, in the sense that with such pruning rule we are only able to ﬁnd a single optimum,

not all the solutions that might have the same cost function. In other words, the proposed pruning rule

does not allow one to solve multi-modal problems, because we are deciding not to explore the sub-tree at

a given node that could contain solutions having the same current optimal objective function value. To

solve multi-modal problems, that rule must be applied only when

˜vI(˜

Pc)>˜vS(˜

P).(7)

[Pruning Rule 3 ]. If ˜vI(˜

Pc)<˜vS(˜

P) and ¯x is feasible for ˜

P, (i.e., if all the components of ¯x that

must be integer are actually -integer), we have found a better estimate for the upper bound of ˜

P, and

thus we can update it:

˜vS(˜

P) = ˜vI(˜

Pc).

As a result, now ˜vI(˜

Pc) = ˜vS(˜

P), and thus:

˜v(˜

Pleaf )>˜v(˜

Pc)>˜vI(˜

Pc) = ˜vS(˜

P)∀leaf in SubTree( ˜

Pc).

Then again we have that the sub-tree having root ˜

Pccannot contain better solutions than ¯x:

˜v(˜

Pleaf )>˜vS(˜

P)∀leaf in SubTree( ˜

Pc).

This proves the correctness of the third pruning rule.

5.2. Terminating conditions for the GrossBB

Let us now discuss the terminating conditions for the GrossBB algorithm. The ﬁrst two are exactly

the same of the classical BB, while the third requires some attention.

The terminating conditions are:

1. All the remaining leaves have been visited: if all the leaves have been visited the GrossBB

algorithm stops.

2. Maximum number of iteration reached: when a given maximum number of iterations (pro-

vided by the user at the beginning) has been reached, the GrossBB stops.

3. ˜−optimality reached: when the normalized diﬀerence between the global lower bound and the

global upper bound at the i-th iteration is close enough to zero, the GrossBB stops:

˜

∆i(˜

P) = ˜vS(˜

P)−˜vI(˜

P)

|˜vS(˜

P)|˜, (8)

where is the component-wise less than or equal to operator deﬁned among two Gross-scalars and

diﬀerent from the usual operator 6deﬁned for ¬-based numbers. In particular, equation (8) requires

that all the Gross-digits of ˜

∆i(˜

P) are less or equal to Gross-digits of ˜. Let us make more comments upon

computations executed in (8). It ﬁrst involves the diﬀerence between two Gross-scalars. This intermediate

result must be divided by the absolute value of ˜vS(˜

P). While computing the absolute value of a Gross-

scalar is straightforward, division (as it happens also in the traditional ﬂoating point arithmetic) requires

more eﬀorts (see [2]). The result of the Gross-division is a Gross-scalar that must be compared with the

Gross-scalar ˜, which has the form

˜=0+1¬−1+2¬−2+... +r−1¬−r+1 .

Obviously, it is possible to chose 0=1=2... =, to simplify the presentation.

In order to illustrate the situation, let us see an example below. Suppose that we have a problem

with three objectives (r=3) and = 10−6has been chosen. Given the following

˜

∆i(˜

P)=1.1·10−7+ 5 ·10−3¬−1+ 1.7·10−8¬−2

it follows that ˜

∆i(˜

P)6˜but ˜

∆i(˜

P)6 ˜

because the ﬁrst-order inﬁnitesimal component of ˜

∆i(˜

P), namely (5 ·10−3), is not less or equal to . Thus

in this case the GrossBB algorithm cannot terminate: it will continue, trying to make all the components

less or equal to .

8

5.3. Branching rule for the GrossBB

When the sub-tree below ˜

Pccannot be pruned (because it could contain better solutions), its sub-tree

must be explored. Thus we have to branch the current node into Pland Prand to add these two new

nodes to the tail of the queue of the sub-problems to be analyzed and solved by the GrossSimplex.

Algorithm 2 provides a pseudo-code for the GrossBB algorithm. Thus, the GrossBB algorithm using

internally the GrossSimplex algorithm and the rules (pruning, terminating, branching) provided above is

able to solve a given ˜

PLMOMILP problem.

5.4. Final considerations before testing the algorithm

Let us conclude this section by introducing the concept of “epsilon integrality” and by commenting

upon the usage of division among Gross-numbers in the next two subsections.

5.4.1. Epsilon integrality

The concept of −integrality used in pruning rule 3 can be formalized as follows. A vector xis

−integer when all its components are −integer. Its generic component xiis −integer when

xi− bxic< ε or dxie − xi< ε.

5.4.2. Division among Gross-numbers could be avoided

Division among Gross-numbers used in equation (8) can be avoided, by multiplying the two sides of

the inequality by |˜vS(˜

P)|:

˜vS(˜

P)−˜vI(˜

P)˜· |˜vS(˜

P)|

This multiplication allows us to create a division-free variant of the GrossBB algorithm. We thank

one of the anonymous reviewers for pointing this out. However, we guess that the use of division is

still interesting from the theoretical point of view, because it allowed us to clarify better the concept of

a Gross-number being “near zero”. Furthermore, the impact of division in equation (8) on the overall

computing time of the algorithm is not critical, since the overall computing time is mainly aﬀected by

the time required to compute solutions of the relaxed LMOLP problems.

Algorithm 2 The GrossBB Algorithm using GrossSimplex method internally

Inputs: maxIter and a speciﬁc LMOMILP problem ˜

|P|, to be put within the root node ( ˜

P)

Outputs: xopt (the optimal solution, a purely ﬁnite vector), ˜

fopt (the optimal value, a Gross-scalar)

Step 0. Insert ˜

|P|into a queue of the sub problems that must be solved. Put ˜vS(˜

P) = ¬,xopt = [ ],

and ˜

fopt =¬or use a greedy algorithm to get an initial feasible solution.

Step 1a. If all the remaining leaves have been visited (empty queue), or the maximum number of

iterations has been reached, or the ˜-optimality condition holds, then goto Step 4. Otherwise

extract from the head of the queue the next problem to solve and call it ˜

Pc(current problem).

Remark: this policy of insertion of new problems at the tail of the queue and the extraction from

its head leads to a breadth-ﬁrst visit for the binary tree of the generated problems.

Step 1b. Solve ˜

Rc, the relaxed version of the problem ˜

Pcat hand, using the GrossSimplex and get ¯x

and ˜

fc( = ˜cT¯x):

[¯x,˜

fc,emptyPolyhedron]←GrossSimplex(˜

Rc)

Step 2a. If the LP solver has found that the polyhedron is empty, then prune the sub-tree of ( ˜

Pc)

(according to Pruning Rule 1) by going to Step 1a (without branching ( ˜

Pc)). Otherwise, we have

found a new lower value for ˜

Pc:

˜vI(˜

Pc) = ˜

fc

Step 2b. If ˜vI(˜

Pc)>˜vS(˜

P), then prune the sub-tree under ˜

Pc(according to Pruning Rule 2), by going

to Step 1a (without branching ˜

Pc).

9

Step 2c. If ˜vI(˜

Pc)<˜vS(˜

P) and all components of ¯x that must be integer are actually -integer (i.e., ¯x

is feasible), then we have found a better upper bound estimate. Thus we can update the value of

˜vS(˜

P) as:

˜vS(˜

P) = ˜vI(˜

Pc).

In addition, we set xopt =¯x and ˜

fopt = ˜vI(˜

Pc).Then we also prune the sub-tree under ( ˜

Pc)

(according to Pruning Rule 3) by going to Step 1a (without branching ( ˜

Pc)).

Step 3. If ˜vI(˜

Pc)<˜vS(˜

P) but not all components of ¯x that must be integer are actually -integer, we

have to branch. Select the component ¯xtof ¯x having the greatest fractional part, among all the

components that must be integer. Create two new nodes (i.e., problems) with a new constraint for

this variable, one with a new 6constraint for the rounded down value of ¯xtand another with a

new >constraint for the rounded up value of ¯xt.Let us call the two new problems ˜

Pland ˜

Prand

put them at the tail of the queue of the problems to be solved, then goto Step 1a.

Step 4. End of the algorithm.

6. Experimental results

In this section, we ﬁrst introduce ﬁve LMOMILP test problems having known solution. Then we

verify that the GrossBB combined with the GrossSimplex is able to successfully solve these problems.

6.1. Test problem 1: the “kite” in 2D

This problem is a variation of the 2D problem with 3 objectives described in [8]:

lexmax 8x1+ 12x2,14x1+ 10x2, x1+x2

s.t. 2x1+ 1x26120

2x1+ 3x26210 + 2.5

4x1+ 3x26270

x1+ 2x2>60

−200 6x1, x26+200,x∈Zn

|T1|

The polygon Sassociated to this problem is shown in Fig. 1 (left sub-ﬁgure). The integer points

(feasible solutions) are shown as black spots whereas the domain of the relaxed problem (i.e., without

the integer constraints) is shown in light grey.

It can be seen that the ﬁrst objective vector c1= [8,12]Tis orthogonal to segment [α, β] (α=

(0,70.83), β = (28.75,51.67)) shown in the same ﬁgure. All the nearest integer points parallel to this

segment are optimal for the ﬁrst objective (see the right sub-ﬁgure in Fig. 1). Since the solution is not

unique, there is the chance to try to improve the second objective vector (c2= [14,10]T).

Figure 1: An example in two dimensions with three objectives. The black points on the left ﬁgure are all the feasible

solutions. All the nearest integer points parallel to the segment [α, β] (there are many), are optimal for the ﬁrst objective,

while point (28,52) is the unique lexicographic optimum for the given problem (i.e., if the second objective is considered,

too). The third ob jective plays no role in this case. On the right, a zoom around point βis provided, with some optimal

solutions for the ﬁrst objective highlighted (the ones with a bigger black spot).

10

Let us see now what happens when we solve this problem using the GrossBB Algorithm with the

GrossSimplex. notice, that since the |T1|problem is lexmax-formulated, we have to provide −˜

cto the

GrossBB algorithm.

Initialization. ˜vS(˜

P) = ¬,xopt = [ ],˜

fopt =¬and insert |T1|into a queue of the sub-problems

that must be solved.

Iteration 1. The GrossBB extracts from the queue of problems to be solved the only one present, and

denotes it as the current problem: ˜

Pc≡ |T1|). Then the algorithm solves its relaxed version: the solution

of ˜

Rcis ¯x = [28.7500,51.6667]T,with ˜vI(˜

Pc) = −850¬0−919.167¬−1−80.4167¬−2. As already seen on

the MILP example, in this case we have to branch using the component having the highest fractional part

(among the variables with integer restrictions, of course). In this case, it is the ﬁrst component, and thus

the new sub-problem on the left ˜

Plwill have the additional constraint x1628, while the new on the right

˜

Prwill have the additional constraint x1>29. This split makes the current solution [28.7500,51.6667]T

not optimal neither for problems ˜

Plnor for ˜

Pr(see Fig. 2).

Figure 2: Situation at the end of iteration 1, for problem |T1|.

Iteration 2. At this step the queue is composed by [ ˜

Pl,˜

Pr],the problems generated in the previous

iteration. The GrossBB extracts now the next problem from the top of the queue (breadth-ﬁrst visit),

namely [ ˜

Pland denotes it as ˜

Pc, the current problem to solve. The optimal solution for the relaxed

problem ˜

Rcis ¯x = [28.25,52]T,with ˜vI(˜

Pc) = −850¬0−915.5¬−1−80.25¬−2. We have to branch

again, as we did during iteration 1, thus, a new left and right problems will be generated and added to

the queue. The new left problem will have the additional constraint x1628, while the new right problem

will have the additional constraint x1>29. The length of the queue is now 3.

Iteration 3. Extract the next problem from the top of the queue and denote it as ˜

Pc. The optimal

solution of ˜

Rcis ¯x = [29.25,51]Tand the associated ˜vI(˜

Pc) = −846¬0−919.5¬−1−80.25¬−2. We

have to branch, new left and right problems will be generated, both will be added to the queue. The

left problem will have the additional constraint x1629, while the new on the right ˜

Prwill have the

additional constraint x1>30. The length of the queue is now 4.

Iteration 4. Extract the next problem from the queue and indicate it as ˜

Pc. Solve ˜

Rc, the relaxation

of ˜

Pc, using the GrossSimplex. Since ˜

Rchas an empty feasible region, prune this node by applying the

ﬁrst pruning rule. The length of the queue is now 3.

Iteration 5. Extract the next problem from the top of the queue and denote it as ˜

Pc. The optimal

solution of ˜

Rcis ¯x = [28,52.1667]Tand the associated ˜vI(˜

Pc) = −850¬0−913.6667¬−1−80.1667¬−2. We

have to branch: new left and right problems will be generated and added to the queue. The left problem

will have the additional constraint x1652, while the right one will have the additional constraint x1>53.

The length of the queue is now 4.

Iteration 6. Extract the next problem from the queue and indicate it as ˜

Pc. This time the

GrossSimplex returns an integer solution, i.e., a feasible solution for the LMOMILP initial problem

|T1|:

¯x = [30,50]Tand ˜vI(˜

Pc) = −840¬0−920¬−1−80¬−2

Since ˜vI(˜

Pc)<˜vS(˜

P), then we can update ˜vS(˜

P) = ˜vI(˜

Pc), xopt =¯x. Finally we can prune this node,

according to the third pruning rule.

Iteration 7. Extract the next problem from the queue and denote it as ˜

Pc. Again the GrossSimplex

returns an integer solution:

¯x = [29,51]Tand ˜vI(˜

Pc) = −844¬0−916¬−1−80¬−2

Since ˜vI(˜

Pc)<˜vS(˜

P), then we can update ˜vS(˜

P) = ˜vI(˜

Pc), xopt =¯x. Finally we can prune this node,

according to the third pruning rule.

Iteration 8. Extract the next problem from the top of the queue and indicate it as ˜

Pc. The optimal

solution of ˜

Rcis ¯x = [26.75,53]T,with ˜vI(˜

Pc) = −850¬0−904.5¬−1−79.75¬−2. We have to branch:

11

new left and right problems will be generated and added to the queue. The left problem will have the

additional constraint x1626, while the new on the right ˜

Prwill have the additional constraint x1>27.

The length of the queue is now 4.

Iteration 9. Extract the next problem from the queue ( ˜

Pc) and denote it as the current problem ˜

Pc.

Solve its relaxation using the GrossSimplex. In this case, the returned solution is feasible for the initial

LMOMILP problem |T1|because it has all integral components:

¯x = [28,52]Tand ˜vI(˜

Pc) = −848¬0−912¬−1−80¬−2.

Since ˜vI(˜

Pc)<˜vS(˜

P), then update both ˜vS(˜

P) = ˜vI(˜

Pc) and xopt =¯x. Finally, prune this node by

applying the third pruning rule.

Iteration 10. Extract the next problem from the queue and indicate it as ˜

Pc. Solve ˜

Rc, the relaxation

of ˜

Pc, using the GrossSimplex. Since ˜

Rchas an empty feasible region, prune this node by applying the

ﬁrst pruning rule.

Iterations 11-79. The GrossBB algorithm is not able to ﬁnd a better solution than the ¯x = [28,52]T

already found, but continues to branch and explore the tree, until only two nodes remain in the queue.

The processing of the last two nodes is discussed in the last two iterations 80 and 81, below.

Iteration 80. Extract the next problem from the queue and indicate it as ˜

Pc. Solve ˜

Rcusing the

GrossSimplex. Since ˜

Rchas an empty feasible region, prune this node by applying the ﬁrst pruning rule.

Iteration 81. At this point there is one last unsolved problem from the queue. Extract this problem

and denote it as ˜

Pc. The optimal solution of ˜

Rcis:

¯x = [1,70]T,with ˜vI(˜

Pc) = −848¬0−714¬−1−71¬−2.

Since ˜vI(˜

Pc)≥˜vS(˜

P), prune this last node according to the third pruning rule. Being now the tree

empty, the GrossBB algorithm stops according to the ﬁrst terminating condition and returns the optimal

solution found so far: xopt = [28,52]T.The optimal value of the objective function is ˜cTxopt = 848¬0+

912¬−1+ 80¬−2.

Table 1 provides a synthesis of the iterations performed by the GrossBB algorithm and described in

detail above.

6.2. Test problem 2: the unrotated “house” in 3D

This illustrative example is in three dimensions with three objectives:

lexmax x1,−x2,−x3

s.t. −10.26x1610.2

−10 6x2610.2

−10.26x3610.2

−x1−x262

−x1+x262

−20 6xi620, i = 1, ..., 3,x∈Z3

|T2|

with the domain being the cube shown in Fig. 3. It can be immediately seen that by considering the ﬁrst

objective alone (maximize x1), all the nearest integer points parallel to square having vertices α,β,γ,

δare optimal for the ﬁrst objective function (see Fig. 3). Since the optimum is not unique, the second

objective function can be considered in order to improve it without deteriorating the ﬁrst objective.

Then, all the integer points close to the segment [β,γ] are all optimal for the second objective, too (see

Fig. 4, which provides the plant-view of Fig. 3 with x3=−10). Again, the optimum in not unique, and,

therefore, the third objective is considered. This allows us to select the nearest integer point to γas

the unique solution that maximizes all the three objectives. The point [10,−10,−10] is the lexicographic

optimum to this problem.

The problem can be solved with GrossBB algorithm, as shown in Tab. 2. The solution xopt =

[10,−10,−10]Tis actually found after 5 iterations. The optimal value of the objective function is

computed in the form ˜

cTxopt = 10¬0+ 10¬−1+ 10¬−2.

6.3. Test problem 3: the rotated “house” in 5D

Algorithm 3 shows how to add a small rotation along the axis perpendicular to the plane containing

the ﬁrst two variables x1and x2, for the “house” problem seen in previous example, after generalizing it

to the n-dimensional case with n= 5.

12

Table 1: Iterations performed by the GrossBB Algorithm using GrossSimplex during solving problem |T1|

Iteration result at node(iteration)

Initialize - ˜vS(˜

P) = ¬

- Queue len. 1 (add the root problem to the queue)

1 ˜vI(˜

Pc): −850¬0−919.167¬−1−80.4167¬−2. Queue length : 0

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 2

-˜

∆ = 100¬0+ 100¬−1+ 100¬−2

2 ˜vI(˜

Pc): −850¬0−915.5¬−1−80.25¬−2. Queue length: 1

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 3

-˜

∆ = 100¬0+ 100¬−1+ 100¬−2

3 ˜vI(˜

Pc): −846¬0−919.5¬−1−80.25¬−2. Queue length: 2

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 4

-˜

∆ = 100¬0+ 100¬−1+ 100¬−2

4 prune node: rule 1, empty feasible region. Queue length: 3

5 ˜vI(˜

Pc): −850¬0−913.667¬−1−80.1667¬−2. Queue length: 2

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 4

-˜

∆ = 100¬0+ 100¬−1+ 100¬−2

6 ˜vI(˜

Pc): −840¬0−920¬−1−80¬−2. Queue length: 3

- A feasible solution has been found: xopt = [30,50]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

-˜

∆=0.0119048¬0−0.00688406¬−1+ 0.00208333¬−2

7 ˜vI(˜

Pc): −844¬0−916¬−1−80¬−2. Queue length: 2

- A feasible solution has been found: xopt = [29,51]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

-˜

∆=0.354191¬0−0.127528¬−1+ 0.104058¬−2

8 ˜vI(˜

Pc): −850¬0−904.5¬−1−79.75¬−2. Queue length: 1

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 3

-˜

∆=0.007109¬0−0.00254731¬−1+ 0.00208333¬−2

9 ˜vI(˜

Pc): −848¬0−912¬−1−80¬−2. Queue length: 2

- A feasible solution has been found: xopt = [28,52]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

-˜

∆=0.00235849¬0−0.00822368¬−1−0.003125¬−2

10 prune node: rule 1, empty feasible region. Queue length: 1

... ... ... ... ... ....

80 prune node: rule 1, empty feasible region. Queue length: 1

81 ˜vI(˜

Pc): −848¬0−714¬−1−71¬−2. Queue length: 0

- ˜vI(˜

Pc)>˜vS(˜

P) prune node: rule 2

result Iteration 81. Optimization ended. Optimal solution found:

xopt = [28,52]T

˜

fopt =−848¬0−912¬−1−80¬−2

˜

∆=0¬0+ 0¬−1+ 0¬−2

The problem consists of the lexicographic optimization of x1,−x2, ..., −x5. The method used to

generate a randomly rotated benchmark is shown in Alg. 3 (the generated rotation matrix Qis reported

in Appendix A). After the rotation, the following lower and upper bounds were added

−2ρ6xi62ρ, i = 1, ..., 5.

As a result, the following problem (A0,b0) has been generated:

lexmax x1,−x2, ..., −x5

s.t. x0∈Z5:A0x06b0|T3|

where C0,A0and vector b0are reported in Appendix A as well.

The lexicographic optimum for this problem is xopt = [1000,−999,−1000,−1000,−1000]T.The

problem can be solved with GrossBB algorithm. After 11 steps, the algorithm has found the correct

lexicographic optimum (see Tab. 3 in Appendix B).

Algorithm 3 Generation of a randomly rotated “house” problem in Rn

Step 1. Let {Ax 6b,x∈Zn}be the initial, unrotated problem, in n-dimensions. The problems is

formulated as follow (ρis a parameter that controls the size of the house):

13

Figure 3: The 3D unrotated “house” problem.

Figure 4: Section view of Fig. 3 with x3=−10 (left) and its top-right zoom (right).

lexmax x1,−x2, ..., −xn

s.t. −ρ+ 0.26x16ρ+ 0.2,

−ρ6x26ρ+ 0.2

−ρ+ 0.26xi6ρ+ 0.2, i = 3, ..., n

−x1−x262

−x1+x262

x∈Zn

Step 2. Use as rotation matrix Qwith a random little rotation:

rA = 0.0002;

rB = 0.0005;

φ= (rB-rA).*rand(1) + rA;

Q=

cos (φ) sin (φ) 0 0 .. 0

−sin (φ) cos (φ) 0 0 ... 0

0 0 1 0 ... 0

0 0 0 1 ... 0

... ... ... ... ... ...

0 0 0 0 ... 1

∈Rn×n

Step 3. Rotate the polytope: A0=AQ (band Cdoes not change under rotations: b0=band

C0=C) and then add these additional constraints as lower and upper bound for every variables to

A0(they are twice the size of the house, in order to fully contain it):

−2ρ6xi62ρ, i = 1, ..., n

14

Table 2: Iterations performed by GrossBB algorithm on test problem |T2|

Iteration result at node(iteration)

Initialize - ˜vS(˜

P) = ¬

- Queue len. 1 (add the root problem to the queue)

1 ˜vI(˜

Pc): −10.2¬0−10¬−1−10.2¬−2. Queue length: 0

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 2

-˜

∆ 100¬0+ 100¬−1+ 100¬−2

2 prune node: rule 1, empty feasible region. Queue length: 1

3 ˜vI(˜

Pc): −10¬0−10¬−1−10.2¬−2. Queue length: 0

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 2

-˜

∆ 100¬0+ 100¬−1+ 100¬−2

4 ˜vI(˜

Pc): −10¬0−10¬−1−10¬−2. Queue length: 1

- A feasible solution has been found: xopt = [10,−10,−10]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

-˜

∆: 0¬0+ 0¬−1+ 0.02¬−2

5 prune node: rule 1, empty feasible region. Queue length: 0

result Iteration 5. Optimization ended. Optimal solution found:

xopt = [10,−10,−10]T

˜

fopt =−10¬0−10¬−1−10¬−2

˜

∆=0¬0+ 0¬−1+ 0¬−2

Step 4 For the unrotated problem the optimal integer solution is xopt = [ρ, −ρ, −ρ, −ρ, ..., −ρ]T.

When a rotation is applied, if the rotation is between a suﬃciently small range of angles the optimal

solution is: xopt = [ρ, 1−ρ, −ρ, −ρ, ..., −ρ]T.

The optimal value is computed as: ˜

fopt =˜cTxopt , where ˜c is derived from C.

6.4. Test problem 4: the randomly rotated hypercube in 7D

Algorithm 4 describes how to generate a test problem in Rn, based on a randomly rotated hypercube

having side 2000 and centered in the origin. The feasible region is further constrained to be within an

unrotated hypercube, with lower side (200.4), centered in the origin, too. The randomly rotated external

hypercube does not play any role, since the feasible region is governed by the inner hypercube, but adds

complexity to the problem (i.e., it challenges more the GrossBB algorithm).

As an example, let us consider a hypercube in seven dimension. The corresponding rotation matrix

Q, matrix A0, and vector b0are reported in Appendix A. The resulting problem (|T4|) can be written as

follows

lexmax c01·x0,c02·x0, ..., c07·x0,

s.t. x0∈Z7:A0x06b0,|T4|

where c01Tis the ﬁrst row of C0reported in Appendix A, c02Tis its second row, and so on. The

lexicographic optimum for this problem is

xopt = [100,100,100,100,100,100,100]T.

The GrossBB algorithm has been applied and the optimum has been obtained after 15 iterations, as

shown in Tab. 4 (see Appendix C).

Algorithm 4 Generation of a randomly rotated hypercube in Rn

Step 1. Let {Ax 6b,x∈Zn}be the initial, unrotated hypercube problem, in n-dimensions. The

problem is formulated as follow:

lexmax x1, x2, ..., xn

s.t. −1000 6xi61000, i = 1, ..., n

x∈Zn

Step 2. Generate a random rotation matrix Q. It can be computed using a QR factorization utility,

applied to a random matrix T. In particular, Tmust be an n-by-nmatrix having entries randomly

generated according to the normal distribution (zero mean and unitary variance). In Matlab the

15

matrix Qcan be obtained in this way:

T = randn(n);

[Q, R] = qr(T);

Step 3. Rotate the polytope: A0=AQ (bdoes not change under rotations: b0=band C0=C) and

then add the inner hypercube by adding these constraints to A0:

−(100 + 0.2) 6xi6(100 + 0.2), i = 1, ..., n.

Step 4. Compute the LMOMILP optimum:

xopt = [100,100,...,100]T

˜

fopt =˜cTxopt , where ˜c is derived from C.

6.5. Test problem 5: the randomly rotated hypercube in 200D

As a stress test for the GrossBB algorithm, we have applied it on a rotated hypercube problem with

200 objectives in R200 generated using Algorithm 4. The behaviour of the GrossBB is exactly the same as

in the previous test problem in R7, but this time the solution is found after 401 iterations (= 1 + 200·2)

instead of after 15 (= 1+ 7·2), where the number one is due to the fact that the problem is always solved

at the root. Each time a problem is solved, two new sub-problems are generated by branching (the left

and right ones). Due to this fact the number of iterations is twice the number of dimensions (other than

the ﬁrst iteration, of course). Indeed, for this particular problem, the left problems will always have an

empty solution (once relaxed), while the right ones will always have feasible solutions (when relaxed), but

these solutions will not be epsilon-integer. By construction, however, the feasible solution of the 200st

right problem will be epsilon-integer, i.e., will be feasible for the original integer-constrained problem,

and thus the algorithm will stop (this solution will be the vector xopt ∈R200 equal to [100,100, ..., 100]T).

For these reasons, the iterations of the GrossBB for this problem look very similar to those reported on

Table 4 in Appendix C and thus we decided not to report them here due to space limitations. In this

case, the GrossBB needed 32 hours and 13 min to complete the 401 iterations on an Intel i7 920 with 4

cores (8 threads) at 3.6 Ghz.

7. A brief conclusion

In the previous work [1], the lexicographic multiple objective linear programming problem (LMOLP)

has been considered. To solve it, the GrossSimplex algorithm being a generalization of the simplex algo-

rithm able to work with inﬁnitesimals and inﬁnities using the Grossone methodology has been proposed.

In the present paper, the Lexicographic Multi-Objective Mixed-Integer Linear Programming Problem

(called LMOMILP) has been considered. To solve it, the GrossBB algorithm has been introduced. This

method is a generalization of the branch and bound to the case where not only ﬁnite but also inﬁnitesimal

and inﬁnite numbers expressible in the numeral system using ¬can be treated. It has been proved that

the proposed pruning rules and the terminating conditions ensure the correct functioning of the GrossBB

algorithm. Finally, ﬁve LMOMILP test problems having known solutions have been proposed and it was

shown that the introduced GrossBB algorithm solves all of them successfully.

Acknowledgments

The authors would like to thank the anonymous reviewers for their helpful comments.

16

Appendix A - Additional information for third and fourth test problems

This appendix reports information related to test problems 3 and 4. In order to construct the 5-dimensional problem

|T3|the following rotation matrix Q, matrices A0,C0, and vector b0have been used:

A0=

0.9999999087 0.0004273220262 0 0 0

−0.0004273220262 0.9999999087 0 0 0

0 0 1.0 0 0

0 0 0 1.0 0

0 0 0 0 1.0

−0.9999999087 −0.0004273220262 0 0 0

0.0004273220262 −0.9999999087 0 0 0

0 0 −1.0 0 0

0 0 0 −1.0 0

0 0 0 0 −1.0

−0.9995725867 −1.000427231 0 0 0

−1.000427231 0.9995725867 0 0 0

−1.0 0 0 0 0

0−1.0 0 0 0

0 0 −1.0 0 0

0 0 0 −1.0 0

0 0 0 0 −1.0

1.0 0 0 0 0

0 1.0 0 0 0

0 0 1.0 0 0

0 0 0 1.0 0

0 0 0 0 1.0

b0=

1000.2

1000.2

1000.2

1000.2

1000.2

1000.2

1000.0

1000.2

1000.2

1000.2

4.0

4.0

2000.0

2000.0

2000.0

2000.0

2000.0

2000.0

2000.0

2000.0

2000.0

2000.0

Q=

0.9999999087 0.0004273220262 0 0 0

−0.0004273220262 0.9999999087 0 0 0

0 0 1.0 0 0

0 0 0 1.0 0

0 0 0 0 1.0

C0=

c1T

c2T

...

c5T

="1 0 .. 0

0−1... 0

... ... ... ...

0 0 ... −1#∈R5×5

The following matrices and vector are related to test problem |T4|in 7 dimensions:

A0=

−0.3399 −0.1993 −0.1513 −0.1745 0.1464 0.1863 0.8575

0.1419 −0.7158 −0.1318 0.6014 0.2768 −0.1028 −0.03592

−0.1374 0.3492 −0.2176 0.6205 −0.5398 −0.2576 0.2627

0.3681 0.08162 −0.1831 −0.26 0.2269 −0.8112 0.2172

−0.4154 −0.1865 0.7852 0.02297 −0.09166 −0.407 0.03933

0.5363 0.3372 0.4952 0.3105 0.2907 0.2384 0.3401

0.4998 −0.4133 0.1307 −0.2414 −0.6828 0.08847 0.1733

0.3399 0.1993 0.1513 0.1745 −0.1464 −0.1863 −0.8575

−0.1419 0.7158 0.1318 −0.6014 −0.2768 0.1028 0.03592

0.1374 −0.3492 0.2176 −0.6205 0.5398 0.2576 −0.2627

−0.3681 −0.08162 0.1831 0.26 −0.2269 0.8112 −0.2172

0.4154 0.1865 −0.7852 −0.02297 0.09166 0.407 −0.03933

−0.5363 −0.3372 −0.4952 −0.3105 −0.2907 −0.2384 −0.3401

−0.4998 0.4133 −0.1307 0.2414 0.6828 −0.08847 −0.1733

−1.0 0 0 0 0 0 0

0−1.0 0 0 0 0 0

0 0 −1.0 0 0 0 0

000−1.0 0 0 0

0 0 0 0 −1.0 0 0

0 0 0 0 0 −1.0 0

0 0 0 0 0 0 −1.0

1.0 0 0 0 0 0 0

0 1.0 0 0 0 0 0

0 0 1.0 0 0 0 0

0 0 0 1.0 0 0 0

0 0 0 0 1.0 0 0

0 0 0 0 0 1.0 0

0 0 0 0 0 0 1.0

b0=

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

1000.0

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

100.2

Q=

−0.34 −0.199 −0.151 −0.175 0.146 0.186 0.857

0.142 −0.716 −0.132 0.601 0.277 −0.103 −0.0359

−0.137 0.349 −0.218 0.621 −0.54 −0.258 0.263

0.368 0.0816 −0.183 −0.26 0.227 −0.811 0.217

−0.415 −0.187 0.785 0.023 −0.0917 −0.407 0.0393

0.536 0.337 0.495 0.31 0.291 0.238 0.34

0.5−0.413 0.131 −0.241 −0.683 0.0885 0.173

C0=

c1T

c2T

...

c7T

="1 0 .. 0

0 1 ... 0

... ... ... ...

0 0 ... 1#∈R7×7

17

Appendix B - Table 3 (GrossBB iterations on test problem |T3|)

Iter. result at node(iteration)

Initialize - ˜vS(˜

P) = ¬

- Queue len. 1 (add the ro ot problem to the queue)

1 ˜vI(˜

Pc): −1000.63¬0−999.573¬−1−1000.2¬−2−1000.2¬−3−1000.2¬−4. Queue length: 0

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4

2 ˜vI(˜

Pc): −1000.63¬0−999¬−1−1000.2¬−2−1000.2¬−3−1000.2¬−4. Queue length: 1

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 3

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4

3 prune node: rule 1, empty feasible region. Queue length: 2

4 prune node: rule 1, empty feasible region. Queue length: 1

5 ˜vI(˜

Pc): −1000¬0−999¬−1−1000.2¬−2−1000.2¬−3−1000.2¬−4. Queue length: 0

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4

6 ˜vI(˜

Pc): −1000¬0−999¬−1−1000¬−2−1000.2¬−3−1000.2¬−4. Queue length: 1

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 3

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4

7 prune node: rule 1, empty feasible region. Queue length: 2

8 ˜vI(˜

Pc): −1000¬0−999¬−1−1000¬−2−1000¬−3−1000.2¬−4. Queue length: 1

- no pruning rules applied, branch ˜

Pcin two sub-problems. Queue length: 3

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4

9 prune node: rule 1, empty feasible region. Queue length: 2

10 ˜vI(˜

Pc): −1000¬0−999¬−1−1000¬−2−1000¬−3−1000¬−4. Queue length: 1

- A feasible solution has been found: ˜xopt = [1000 −999 −1000 −1000 −1000]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

-˜

∆=0¬0+ 0¬−1+ 0¬−2+ 0¬−3+ 0.0002¬−4

11 prune no de: rule 1, empty feasible region. Queue length: 2

result Iteration 11. Optimization ended. Optimal solution found:

xopt = [1000,−999,−1000,−1000,−1000]T

˜

fopt =−1000¬0−999¬−1−1000¬−2−1000¬−3−1000¬−4

˜

∆=0¬0+ 0¬−1+ 0¬−2+ 0¬−3+ 0¬−4

Appendix C - Table 4 (GrossBB iterations on test problem |T4|)

Iter. result at node(iteration)

Initialize - ˜vS(˜

P) = ¬

- Queue len. 1 (add the ro ot problem to the queue)

1 ˜vI(˜

Pc): −100.2¬0−100.2¬−1−100.2¬−2−100.2¬−3−100.2¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

2 prune node: rule 1, empty feasible region Queue length: 1

3 ˜vI(˜

Pc): −100¬0−100.2¬−1−100.2¬−2−100.2¬−3−100.2¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

4 prune node: rule 1, empty feasible region Queue length: 1

5 ˜vI(˜

Pc): −100¬0−100¬−1−100.2¬−2−100.2¬−3−100.2¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

6 prune node: rule 1, empty feasible region Queue length: 1

7 ˜vI(˜

Pc): −100¬0−100¬−1−100¬−2−100.2¬−3−100.2¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

8 prune node: rule 1, empty feasible region Queue length: 1

9 ˜vI(˜

Pc): −100¬0−100¬−1−100¬−2−100¬−3−100.2¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

10 prune no de: rule 1, empty feasible region Queue length: 1

11 ˜vI(˜

Pc): −100¬0−100¬−1−100¬−2−100¬−3−100¬−4−100.2¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

12 prune no de: rule 1, empty feasible region Queue length: 1

13 ˜vI(˜

Pc): −100¬0−100¬−1−100¬−2−100¬−3−100¬−4−100¬−5−100.2¬−6

- Queue length: 0

- no pruning rules applied, branch ˜

Pcin two subproblem: Queue length: 2

- Delta 100¬0+ 100¬−1+ 100¬−2+ 100¬−3+ 100¬−4+ 100¬−5+ 100¬−6

14 prune no de: rule 1, empty feasible region Queue length: 1

15 ˜vI(˜

Pc): −100¬0−100¬−1−100¬−2−100¬−3−100¬−4−100¬−5−100¬−6

- Queue length: 0

- A feasible solution has been found: xopt = [100,100,100,100,100,100,100]T

- update ˜vS(˜

P) = ˜vI(˜

Pc), prune node: rule 3

- Delta 0¬0+ 0¬−1+ 0¬−2+ 0¬−3+ 0¬−4+ 0¬−5+ 0¬−6

result Iteration 15. Optimization ended. Optimal solution found:

xopt = [100,100,100,100,100,100,100]T

˜

fopt =−100¬0−100¬−1−100¬−2−100¬−3−100¬−4−100¬−5−100¬−6

˜

∆=0¬0+ 0¬−1+ 0¬−2+ 0¬−3+ 0¬−4+ 0¬−5+ 0¬−6

[1] M. Cococcioni, M. Pappalardo, and Y. D. Sergeyev, “Lexicographic multi-objective linear programming using grossone

methodology: Theory and algorithm,” Applied Mathematics and Computation, vol. 318, pp. 298–311, 2018.

[2] Y. D. Sergeyev, “Numerical inﬁnities and inﬁnitesimals: Methodology, applications, and repercussions on two Hilbert

problems,” EMS Surveys in Mathematical Sciences, vol. 4, pp. 219–320, 2017.

[3] K. Deb, Multi-Objective Optimization Using Evolutionary Algorithms. John Wiley & Sons Inc, 2 ed., 2001.

18

[4] M. Cococcioni, P. Ducange, B. Lazzerini, and F. Marcelloni, “A new multi-objective evolutionary algorithm based on

convex hull for binary classiﬁer optimization,” in Proc. 2007 IEEE Congress on Evolutionary Computation (IEEE-

CEC’07), pp. 3150–3156, 2007.

[5] P. M. Pardalos, A. ˇ

Zilinskas, and J. ˇ

Zilinskas, Non-Convex Multi-Objective Optimization. Springer International

Publishing, 2017.

[6] S. Khosravani, M. Jalali, A. Khajepour, A. Kasaiezadeh, S. K. Chen, and B. Litkouhi, “Application of lexicographic

optimization method to integrated vehicle control systems,” IEEE Transactions on Industrial Electronics, vol. 65,

no. 12, pp. 9677–9686, 2018.

[7] E. Weber, A. Rizzoli, R. Soncini-Sessa, and A. Castelletti, “A lexicographic optimization in water resource planning:

the case of lake verbano, italy,” in Proc. 1st Biennial Meeting of the International Environmental Modelling and

Software Society (IEMSS), 2002.

[8] I. Stanimirovic, “Compendious lexicographic method for multi-objective optimization,” Facta universitatis - series:

Mathematics and Informatics, vol. 27, no. 1, pp. 55–66, 2012.

[9] J. Marques-Silva, J. Argelich, A. Gra¸ca, and I. Lynce, “Boolean lexicographic optimization: algorithms & applications,”

Annals of Mathematics and Artiﬁcial Intelligence, vol. 62, no. 3, pp. 317–343, 2011.

[10] M. Cococcioni, A. Cudazzo, M. Pappalardo, and Y. D. Sergeyev, “Grossone methodology for lexicographic mixed-

integer linear programming problems,” in In Proc. of the the 3rd International Conference and Summer School on

Numerical Computations: Theory and Algorithms, June 2019.

[11] Y. D. Sergeyev, “Independence of the grossone-based inﬁnity methodology from non-standard analysis and comments

upon logical fallacies in some texts asserting the opposite,” Foundations of Science, vol. 24, no. 1, pp. 153–170, 2019.

[12] G. Lolli, “Metamathematical investigations on the theory of grossone,” Applied Mathematics and Computation,

vol. 255, pp. 3–14, 2015.

[13] M. Margenstern, “Using grossone to count the number of elements of inﬁnite sets and the connection with bijections,”

p-Adic Numbers, Ultrametric Analysis and Applications, vol. 3, no. 3, pp. 196–204, 2011.

[14] F. Montagna, G. Simi, and A. Sorbi, “Taking the Pirah˜a seriously,” Communications in Nonlinear Science and

Numerical Simulation, vol. 21, no. 1–3, pp. 52–69, 2015.

[15] Y. D. Sergeyev, Computer system for storing inﬁnite, inﬁnitesimal, and ﬁnite quantities and executing arithmetical

operations with them. USA patent 7,860,914, 2010.

[16] M. Cococcioni, M. Pappalardo, and Y. D. Sergeyev, “Towards lexicographic multi-objective linear programming using

grossone methodology,” in Proc. of the 2nd Intern. Conf. “Numerical Computations: Theory and Algorithms” (S. Y.

D., K. D. E., D. F., and M. M. S., eds.), vol. 1776, p. 090040, New York: AIP Publishing, 2016.

[17] L. Lai, L. Fiaschi, and M. Cococcioni, “Solving mixed pareto-lexicographic many-objective optimization problems:

The case of priority levels,” submitted to Swarm and Evolutionary Computation, 2019.

[18] R. De Leone, G. Fasano, and Y. D. Sergeyev, “Planar methods and grossone for the conjugate gradient breakdown in

nonlinear programming,” Computational Optimization and Applications, vol. 71, pp. 73–93, 2018.

[19] S. De Cosmis and R. De Leone, “The use of grossone in mathematical programming and operations research,” Applied

Mathematics and Computation, vol. 218, no. 16, pp. 8029–8038, 2012.

[20] R. De Leone, “Nonlinear programming and grossone: Quadratic programming and the role of constraint qualiﬁcations,”

Applied Mathematics and Computation, vol. 318, pp. 290–297, 2018.

[21] M. Gaudioso, G. Giallombardo, and M. S. Mukhametzhanov, “Numerical inﬁnitesimals in a variable metric method

for convex nonsmooth optimization,” Applied Mathematics and Computation, vol. 318, pp. 312–320, 2018.

[22] Y. D. Sergeyev, D. E. Kvasov, and M. S. Mukhametzhanov, “On strong homogeneity of a class of global optimiza-

tion algorithms working with inﬁnite and inﬁnitesimal scales,” Communications in Nonlinear Science and Numerical

Simulation, vol. 59, pp. 319–330, 2018.

[23] F. Caldarola, “The Sierpinski curve viewed by numerical computations with inﬁnities and inﬁnitesimals,” Applied

Mathematics and Computation, vol. 318, pp. 321–328, 2018.

[24] Y. D. Sergeyev, “Numerical point of view on Calculus for functions assuming ﬁnite, inﬁnite, and inﬁnitesimal values

over ﬁnite, inﬁnite, and inﬁnitesimal domains,” Nonlinear Analysis Series A: Theory, Methods &Applications, vol. 71,

no. 12, pp. e1688–e1707, 2009.

[25] Y. D. Sergeyev, “Numerical inﬁnities applied for studying Riemann series theorem and Ramanujan summation,” in

AIP Conference Proceedings of ICNAAM 2017, vol. 1978, p. 020004, New York: AIP Publishing, 2018.

[26] A. Zhigljavsky, “Computing sums of conditionally convergent and divergent series using the concept of grossone,”

Applied Mathematics and Computation, vol. 218, no. 16, pp. 8064–8076, 2012.

[27] F. Caldarola, “The exact measures of the Sierpinski d-dimensional tetrahedron in connection with a diophantine

nonlinear system,” Communications in Nonlinear Science and Numerical Simulation, vol. 63, pp. 228–238, 2018.

19

[28] L. D’Alotto, “A classiﬁcation of two-dimensional cellular automata using inﬁnite computations,” Indian Journal of

Mathematics, vol. 55, pp. 143–158, 2013.

[29] Y. D. Sergeyev, “Evaluating the exact inﬁnitesimal values of area of Sierpinski’s carpet and volume of Menger’s sponge,”

Chaos, Solitons &Fractals, vol. 42, no. 5, pp. 3042–3046, 2009.

[30] Y. D. Sergeyev, “Using blinking fractals for mathematical modelling of processes of growth in biological systems,”

Informatica, vol. 22, no. 4, pp. 559–576, 2011.

[31] Y. D. Sergeyev, “The exact (up to inﬁnitesimals) inﬁnite perimeter of the Koch snowﬂake and its ﬁnite area,” Com-

munications in Nonlinear Science and Numerical Simulation, vol. 31, no. 1–3, pp. 21–29, 2016.

[32] D. Iudin, Y. D. Sergeyev, and M. Hayakawa, “Interpretation of percolation in terms of inﬁnity computations,” Applied

Mathematics and Computation, vol. 218, no. 16, pp. 8099–8111, 2012.

[33] D. Iudin, Y. D. Sergeyev, and M. Hayakawa, “Inﬁnity computations in cellular automaton forest-ﬁre model,” Commu-

nications in Nonlinear Science and Numerical Simulation, vol. 20, no. 3, pp. 861–870, 2015.

[34] M. Margenstern, “Fibonacci words, hyperbolic tilings and grossone,” Communications in Nonlinear Science and

Numerical Simulation, vol. 21, no. 1–3, pp. 3–11, 2015.

[35] Y. D. Sergeyev, “Counting systems and the First Hilbert problem,” Nonlinear Analysis Series A: Theory, Methods &

Applications, vol. 72, no. 3-4, pp. 1701–1708, 2010.

[36] Y. D. Sergeyev and A. Garro, “Single-tape and multi-tape Turing machines through the lens of the Grossone method-

ology,” Journal of Supercomputing, vol. 65, no. 2, pp. 645–663, 2013.

[37] L. Fiaschi and M. Cococcioni, “Numerical asymptotic results in game theory using Sergeyev’s Inﬁnity Computing,”

Int. Journal of Unconventional Computing, vol. 14, no. 1, pp. 1–25, 2018.

[38] L. Fiaschi and M. Cococcioni, “Generalizing pure and impure iterated prisoners dilemmas to the case of inﬁnite

and inﬁnitesimal quantities,” in In Proc. of the the 3rd International Conference and Summer School on Numerical

Computations: Theory and Algorithms, June 2019.

[39] L. Fiaschi and M. Cococcioni, “Non-archimedean game theory: a numerical approach,” in preparation, 2019.

[40] D. Rizza, “A study of mathematical determination through Bertrand’s Paradox,” Philosophia Mathematica, vol. 26,

no. 3, pp. 375–395, 2018.

[41] D. Rizza, “Numerical methods for inﬁnite decision-making processes,” Int. Journal of Unconventional Computing,

vol. 14, no. 2, pp. 139–158, 2019.

[42] C. S. Calude and M. Dumitrescu, “Inﬁnitesimal probabilities based on grossone,” SN Computer Science, 2020.

[43] P. Amodio, F. Iavernaro, F. Mazzia, M. S. Mukhametzhanov, and Y. D. Sergeyev, “A generalized Taylor method of

order three for the solution of initial value problems in standard and inﬁnity ﬂoating-point arithmetic,” Mathematics

and Computers in Simulation, vol. 141, pp. 24–39, 2017.

[44] Y. D. Sergeyev, “Higher order numerical diﬀerentiation on the Inﬁnity Computer,” Optimization Letters, vol. 5, no. 4,

pp. 575–585, 2011.

[45] Y. D. Sergeyev, “Solving ordinary diﬀerential equations by working with inﬁnitesimals numerically on the Inﬁnity

Computer,” Applied Mathematics and Computation, vol. 219, no. 22, pp. 10668–10681, 2013.

[46] Y. D. Sergeyev, M. S. Mukhametzhanov, F. Mazzia, F. Iavernaro, and P. Amodio, “Numerical methods for solving

initial value problems on the Inﬁnity Computer,” Int. Journal of Unconventional Computing, vol. 12(1), pp. 3–23,

2016.

[47] F. Iavernaro, F. Mazzia, M. S. Mukhametzhanov, and Y. D. Sergeyev, “Conjugate-symplecticity properties of Euler-

Maclaurin methods and their implementation on the Inﬁnity Computer,” Applied Numerical Mathematics, 2020.

[48] M. Pappalardo and M. Passacantando, Ricerca Operativa. Pisa University Press, 2012.

[49] Y. D. Sergeyev, “Lagrange Lecture: Methodology of numerical computations with inﬁnities and inﬁnitesimals,” Ren-

diconti del Seminario Matematico dell’Universit`a e del Politecnico di Torino, vol. 68, no. 2, pp. 95–113, 2010.

[50] Y. D. Sergeyev, “Un semplice modo per trattare le grandezze inﬁnite ed inﬁnitesime,” Matematica nella Societ`a e

nella Cultura: Rivista della Unione Matematica Italiana, vol. 8, no. 1, pp. 111–147, 2015.

[51] Y. D. Sergeyev, Arithmetic of Inﬁnity. CS: Edizioni Orizzonti Meridionali, 2003, 2nd ed. 2013.

20