Noname manuscript No.

(will be inserted by the editor)

Relaxations and discretizations for the pooling problem

Akshay Gupte · Shabbir Ahmed · Santanu S. Dey ·

Myun Seok Cheon

Received: date / Accepted: date

Abstract The pooling problem is a folklore NP-hard global optimization problem that finds appli-
cations in industries such as petrochemical refining, wastewater treatment and mining. This paper
assimilates the vast literature on this problem that is dispersed over different areas and gives unify-
ing arguments and new insights on prevalent techniques. We also present new ideas for computing
lower bounds on the global optimum by solving high-dimensional linear programs. Finally, we pro-
pose discretization methods for inner approximating the feasible region and obtaining good upper
bounds. Valid inequalities are derived for the discretized models, which are formulated as mixed
integer linear programs. The strength of our relaxations and usefulness of our discretizations is
empirically validated on random test instances. We report best known upper bounds on some of
the large-scale instances.
Keywords Pooling problem · Bilinear program · Lagrange relaxation · Reformulation Linearization
Technique · Discretization

1 Introduction

The classical minimum cost network flow problem seeks to find the optimal way of sending raw
materials from a set of suppliers to a set of customers via certain transshipment nodes in a di-
rected capacitated network. The blending problem, which typically arises in refinery processes in
the petroleum industry, is a type of minimum cost network flow problem with only two sets of
nodes: suppliers and customers. The raw material at each supplier possesses different specifica-
tions, examples being concentrations of chemical compounds such as sulphur, carbon, or physical
properties such as density, octane number. End products for the customers are created by directly
mixing raw materials available from different suppliers. The mixing process should occur in a way
such that the end products contain a certain minimum and maximum level of each specification.
The objective is to minimize the total cost of producing demand.
The pooling problem, a generalization of the blending problem, combines features of both the
classical network flow problem and the blending problem and can be stated in informal terms as
follows: Given a list of available suppliers (inputs) with raw materials containing known specifi-
cations (specs), what is the minimum cost way of mixing these materials in intermediate tanks
(pools) so as to meet the demand and spec requirements at multiple final blends (outputs)? Thus
the raw materials are allowed to be first mixed in intermediate tanks referred to as pools and then
sent forth from the pools to be mixed again at the output to form end products. It is also possible
to send flow directly from inputs to the outputs. Figure 1 illustrates the pooling problem as a
network flow problem over three sets of nodes: inputs, pools (or transshipment), and outputs. The
inflows, outflows, and specification values at each pool are decision variables in the optimization
model. Constraints that track specification level at each pool and that determine the level of spec
A. Gupte
Department of Mathematical Sciences, Clemson University
E-mail: [email protected]
S. Ahmed, S. S. Dey
School of Industrial and Systems Engineering, Georgia Institute of Technology
M. S. Cheon
ExxonMobil Research and Engineering Company
2 Gupte, Ahmed, Dey, Cheon

Input 1

Pool 1 Out 1

Input 2

Pool 2 Out 2

Input 3

Fig. 1 A sample pooling problem

available at each output are formulated as bilinear constraints. As a result, the pooling problem
is a bilinear program (BLP), which is a particular case of a nonconvex quadratic program with
quadratic constraints (QCQP). In contrast, the classical blending problem, due to the absence of
pools, can be formulated as a linear program (LP).
The pooling problem is a very important class of problems in the petrochemical industry [16].
The core problem features of pooling and blending appear in many different and important petro-
chemical optimization problems such as front-end scheduling, multi-period blending optimization,
feedstock delivery scheduling with blending, and refinery planning problem. The front-end schedul-
ing, also referred to as the crude oil operation scheduling by [38], is to find the optimal crude
tank operation strategy. Crude tanks have two different roles; one is a storage place where crudes
are stored and the other is a charging place where different crudes are mixed to meet specifica-
tion requirements for the refining operations. The mixed crudes are discharged to a refinery unit.
This optimization problem can be formulated as a mixed integer nonlinear programming problem
(MINLP) where the mixed integer variables are required to represent the tank operating restric-
tions such as on/off or semicontinuous flows. The nonlinear terms, mainly bilinear terms that are
exactly the same form as in the pooling problem, are required to keep track of the specification
changes (or crude composition) in each tank. A similar problem structure can be observed for the
final products and feedstock tank operations. The refinery planning problem refers to the short-
or mid-term planning problem that is designed to answer the optimal process control decisions in
order to maximize the profit of the complete system under a given cost structure for crudes and
final products. The process control decisions include operating conditions for each unit such as tem-
peratures and feed specifications as well as stream dispositions. The resulting mathematical model
at some units, especially the splitters and mixers, is exactly same as the pooling problem. Fur-
thermore, the refinery planning problem is often represented as a linear system with bilinear terms
[14], again analogous to the pooling problem. Applications also exist in other fields of chemical
engineering such as wastewater treatment [39], emissions regulation [26] and many others [37, 69].
Early efforts in solving the pooling problem were based on finding local optimal solutions using
methods such as recursive LP [36], successive LP [9], and an adaptation of the generalized Benders’
decomposition [22]. Sensitivity of local optimal solutions with respect to problem parameters was
analyzed in [25, 28]. More recently, global optimization algorithms based on reformulation and
spatial branch-and-bound [cf. 65] have been proposed by [7, 23, 58]. Studies in Lagrangian duality-
based approaches were carried out by [1, 6, 13]. The state-of-the-art technique seems to be to solve
the pooling problem using branch-and-cut algorithms developed for nonconvex MINLPs [12, 17]
and which are well-implemented in global solvers such as BARON, COUENNE, ANTIGONE. A specialized
branch-and-bound solver for pooling problems was implemented by [54].
Results on the pooling problem have been somewhat dispersed over different areas of optimiza-
tion and chemical engineering. One of our main contributions is to gather this vast literature spread
over many years and give unifying arguments. Furthermore, we provide new insights on folklore
techniques and present some new ideas for relaxing the problem. Our third contribution is to em-
pirically test discretization approaches for this problem. The paper can be divided into three main
sections. In §2, we present various optimization models for the pooling problem, prove their equiv-
alence to each other and compare their respective problem sizes. Complexity status of the problem
is also discussed. The second part §3 deals with relaxations for the pooling problem. Our aim is
to provide a comprehensive study of lower-bounding procedures and thereby extend the previous
surveys found in [7, 30, 50, 67]. The strengths of these relaxations are analytically investigated. The
third part §4 is about obtaining good upper bounds to the problem using discretization strategies
for a general BLP. Additional binary variables are added to convert the discretized BLP into a
mixed integer linear programming (MILP) problem. Different MILP models are obtained based on
choice and representation of discretized variable. Through extensive computational experiments,
Relaxations and discretizations for the pooling problem 3

we test the viability of obtaining good feasible solutions to the pooling problem by solving a MILP
approximation. Our empirical evidence demonstrates the effectiveness of this approach.
Henceforth, conv(·) denotes the convex hull of a set, 0 is a vector of zeros, < is the set of reals
and Z the set of integers. The orthogonal projection operator onto the subspace of x variables is
Projx (·). Frequently when encountering variables of the form xij , we use xi· to denote the vector of
variables obtained by fixing the first
Q index. Similarly for x·j . Cartesian product of a finite family
of sets X1 , . . . , Xm is denoted by m
i=1 Xi .

2 Problem Formulations

We use the same notation as that in [67, chap. 9]. Let G = (N , A) be a acyclic directed graph with
N = I ∪ L ∪ J as the set of nodes and A as the set of arcs. Here I denotes the set of inputs, L the
set of pools, and J the set of outputs. We assume that A ⊆ (I × L) ∪ (L × L) ∪ (L × J ) ∪ (I × J ), i.e.
there are no arcs between two inputs or two outputs and no backward arcs from pools to inputs or
outputs to inputs or outputs to pools. Note that we have allowed the presence of pool-pool arcs in
A. Traditionally, problem instances with A ∩ (L × L) = ∅ are referred to as standard pooling problems ;
otherwise they are generalized pooling problems. In this work, we mostly do not differentiate between
these two cases since we wish to present a unified treatment for all problem classes. If the need
arises to treat these two cases separately, then we explicitly state so. Since G is acyclic, there exists
a subset LI := {l ∈ L : (l0 , l) ∈/ A ∀l0 ∈ L \ l} of pools with incoming arcs only from some input
nodes.
For each (i, j ) ∈ A, let cij be the variable cost of sending a unit flow on this arc. For every
i ∈ N , let Ci be the capacity of this node. For a pool l ∈ L, its capacity Cl can be interpreted as
the volumetric size of the pool tank, whereas for input i ∈ I , Ci is the total available supply and
for output j ∈ J , Cj represents the maximum allowable flow. The upper bound on flow on arc (i, j )
is denoted by uij . Typically, uij = min{Ci , Cj }; however we allow the arcs in G to carry arbitrary
upper bounds.
Let K denote the set of specifications that are tracked across the problem. For i ∈ I and k ∈ K ,
λik denotes the level of specification k in raw material at input i. Likewise, µmin jk and µjk
max
are
the lower and upper bound requirements on level of k at output j . We will mostly assume that
λik , µmin max P P min P max
jk , µjk ≥ 0 and k λik , k µjk , k µjk ∈ (0, 1]. This assumption is consistent with the
physical meaning of these parameters since the sums denote the total concentration of all specs
within the flow available at a pool or output.
Let yij be the flow on arc (i, j ) ∈ A. For notational simplicity, we will always write equations
using the flow variables yij with the understanding that yij is defined only for (i, j ) ∈ A. At each
pool l ∈ L, the total amount of incoming flow must equal the total amount of outgoing flow.
X X
yil = ylj ∀l ∈ L. (1)
i∈I∪L j∈L∪J

The capacity constraints at each node in G are stated as

X X X
yij ≤ Ci ∀i ∈ I, ylj ≤ Cl ∀l ∈ L, yij ≤ Cj ∀j ∈ J. (2)
j∈L∪J j∈L∪J i∈I∪L

Finally, flows in G are bounded by individual arc capacities.

0 ≤ yij ≤ uij ∀(i, j ) ∈ A. (3)

|A|
Denote F := {y ∈ <+ : (1) − (3)} as the polyhedral set that defines feasible flows on G.

2.1 Concentration model : p-formulation

In the pooling problem we send flows from inputs, mix them in pool tanks, and finally send the mix-
ture from pools to outputs. Thus the mixtures in each pool and output carry specs
P whose concentra-
P
λ yij + l∈L plk ylj
tion values, denoted by pjk for j ∈ L ∪ J, k ∈ K , can be determined as pjk = i∈I ik
P
P P i∈I∪L yij
if i∈I∪L yij > 0 and equal to zero otherwise. Since 0 ≤ k∈K λik ≤ 1, it follows by recursion
4 Gupte, Ahmed, Dey, Cheon

P
that 0 ≤ k∈K pjk ≤ 1, for j ∈ L ∪ J, k ∈ K . Observe that the above expression for pjk can be
equivalently rewritten in a bilinear form:
X X X
λik yil + pl0 k yl0 l = plk ylj , ∀l ∈ L, k ∈ K (4a)
i∈I l0 ∈L j∈L∪J
X X X
λik yij + plk ylj = pjk yij , ∀j ∈ J, k ∈ K (4b)
i∈I l∈L i∈I∪L

The bilinear equalities in (4) will be referred to as the spec tracking constraints since they help
determine the concentration values of specs at each pool and output.

Note 1 We have assumed here that the mixing process follows linear blending, i.e. the total amount
of spec at a node is simply the sum of product of spec concentration value and total flow on each
input arc into this node. More general mixing processes where this assumption may not hold true
are discussed in the survey of Misener and Floudas [50]. In this paper, we will make the assumption
of linear blending at pools and outputs.

For every l ∈ L, let Il denote the subset of inputs from which there exists a directed path to l in
the graph G. The set Ij is defined similarly for every j ∈ J . Since all flows originate at the inputs
and the pools themselves do not have any supply or demand of flow, it is straightforward to see
that the level of specification at a pool l can be bounded as follows:

min λik =: ≤ pmin

lk ≤ plk ≤ pmax
lk := max λik ∀l ∈ L, k ∈ K. (5a)
i∈Il i∈Il

The above bounds are implied by the network structure and tracking constraints (4a) but nonethe-
less can be added to the problem formulation. Similarly we have

min λik =: ≤ pmin max

jk ≤ pjk ≤ pjk := max λik ∀j ∈ J, k ∈ K. (5b)
i∈Ij i∈Ij

We are now ready to formally state the pooling problem.

Definition 1 (Pooling problem) Given any acyclic directed graph G and its attributes, find a
minimum cost feasible flow y ∈ F such that there exist some concentration values p ∈ <(|L|+|J|)×|K|
that satisfy (4) and µmin max
jk ≤ pjk ≤ µjk for all j ∈ J, k ∈ K .

z ∗ = min
X
cij yij s.t. y ∈ F , (4), (5a), µmin max
jk ≤ pjk ≤ µjk ∀j ∈ J, k ∈ K. (Pooling)
y,p
(i,j )∈A

For every j ∈ J, k ∈ K , we can combine the spec tracking constraints (4b) and spec level require-
ments µmin
jk ≤ pjk ≤ µjk
max
to give bilinear inequality constraints of the form
X X X
λik yij + plk ylj ≤ µmax
jk yij ∀j ∈ J, k ∈ K (6a)
i∈I l∈L i∈I∪L
X X X
λik yij + plk ylj ≥ µmin
jk yij ∀j ∈ J, k ∈ K. (6b)
i∈I l∈L i∈I∪L

Note that the spec tracking constraints corresponding to the pools are retained. Thus we have the
following bilinear optimization model, introduced as the p-formulation in [36].

z ∗ = min
X
cij yij s.t. y ∈ F, (4a), (5a), (6). (P)
y,p
(i,j )∈A

We denote the p-formulation by P. With a slight abuse of notation and for convenience, we will
sometimes also refer to the feasible set of the p-formulation by P. A few basic observations about
optimizing the pooling problem are made below.

Observation 1 z ∗ = miny
P
(i,j )∈A cij yij s.t. y ∈ Projy P.

Observation 2 z ∗ ≤ 0 since 0 ∈ Projy P.

Henceforth, for nontriviality, we assume that z ∗ < 0.

Relaxations and discretizations for the pooling problem 5

Observation 3 For any j ∈ J such that the following system of linear inequalities
X X
µmin
jk ≤ λik γi ≤ µmax
jk ∀k ∈ K, γi = 1 , γ ≥ 0
i∈Ij i∈Ij
P
does not admit a solution in γ, the equality i∈I∪L yij = 0 is valid to the pooling problem and hence
output node j can be deleted from the graph.

Proof Based on the network structure, tracking constraints (4b) and bounds (5b), we know that
P min max
Pi∈I∪L yij > 0 implies pj· ∈ conv(∪i∈Ij λi· ). Hence if conv(∪i∈Ij λi· ) ∩ [µj· , µj· ] = ∅ we know that
i∈I∪L yij must be equal to zero. This feasibility check is exactly the proposed linear system. u t

Henceforth, we assume that for every output j , the linear system in Observation 3 is feasible.
Observation 4 For any j ∈ J, k ∈ K such that pmax jk ≤ µmax
jk (resp. pmin min
jk ≥ µjk ), inequality (6a)
(resp. (6b)) is redundant to the pooling problem.
We say µmax
jk (resp. µmin max max
jk ) has a trivial value if pjk ≤ µjk (resp. pmin min
jk ≥ µjk ).

Observation 5 In the absence of (6), or equivalently if the values of µminjk and µjk
max
are trivial for all
j, k, the pooling problem becomes separable across pools and is simply a capacitated network flow problem
that can be solved as an LP.
Henceforth, we assume that for any j ∈ J and k ∈ K , at least one of µmin max
jk and µjk has a nontrivial
value.
Observation 6 If the out-degree of each pool is exactly one, i.e. |{j ∈ N : (l, j ) ∈ A}| = 1 for all l ∈ L,
then the pooling problem can be solved as an LP.

Proof The sole purpose of having the plk variables in P is to enforce that all the outgoing arcs from
pool l carry the same concentration value for spec k. Substitute a new variable wlkj for bilinear
terms plk ylj in (4a) and (6). If each pool has only one outgoing arc, we do not need to enforce the
spec consistency constraint wlkj = plk ylj and can eliminate the p variables. Thus the P formulation
can be completely linearized in this special case and solved as a single LP. u
t

2.1.1 Complexity

In general, the pooling problem is a bilinear program which is a nonconvex problem and a general-
ization of the strongly NP-hard linear maxmin problem [8]. Recently, a formal proof was provided
for its NP-hardness.

Proposition 1 (Alfaki and Haugland [5]) The standard pooling problem with a single pool is NP-
hard.

Proof (Sketch of proof.) The proof is via a polynomial reduction from the maximum stable set
problem, which is well-known to be NP-hard, to an instance of the standard 0
pooling problem with
|L| = 1, |I| = |J| = n, where n = |V| is the number of nodes in the graph G = (V, E ) for the stable
set problem. The set of arcs is A = (I × L) ∪ (L × J ) with all arc capacities equal to 1. Arc costs
are -1 for each arc from pool to output. The set of specs is K = {1, . . . , 2n} and the key idea is
to define a suitable set of specification values: for any i ∈ I , λii = 1, λi,n+i = −1, 0 otherwise;
µmin max max
jk = −1 ∀j, k ; and for any j ∈ J , µj,n+j = −1/n, µjk = 1 for k = 1, . . . , n such that (j, k ) ∈ / E,
min max
0 otherwise. It is not difficult to show using the constructed values of λ, µ , µ that for any
feasible solution (p0 , y 0 ) of the pooling problem, the subset V 0 := {v = 1, . . . , n : ylv
0
> 0} is a stable
0
set in G of cardinality at least n 0
P
v =1 ylv . u
t

Remark 1 The pooling instance constructed in Proposition 1 has redundant values for µmin
jk and
negative values for some λik and µmax max
jk . A similar reduction but with λik , µjk ≥ 0 and nontrivial
values of µmin
jk was presented in Dey and Gupte [21].

We summarize several results related to complexity. The standard pooling problem with
1. a single pool and no direct arcs from inputs to outputs is equivalent to a 0/1 MILP [21, Appendix
A] and is polynomially time solvable for fixed |K| [5],
2. a single pool is polynomially time solvable for fixed |J| [35],
3. a single pool is as hard to approximate as a stable set problem [21],
4. in-degree of each node at most 2 is NP-hard [35]. Similarly for out-degree at most 2.
6 Gupte, Ahmed, Dey, Cheon

2.2 Alternate formulations

2.2.1 Proportion model : q-formulation

The q -formulation was proposed by Ben-Tal et al. [13] for standard pooling problems wherein (6)
is modeled using proportion variables qil to denote P the fraction of incoming flow to pool P l that is
contributed
P by input i . By definition, we have q
i∈I il = 1 for all l ∈ L and yil = qil i0 ∈I yi0 l =
qil j∈L∪J ylj for all i ∈ I, l ∈ L. Then we can eliminate P the p variables from (P) to obtain the
so-called q -formulation. In fact, (4) implies that plk = i∈I λik qil ∀l ∈ L, k ∈ K . For generalized
pooling problems, a straightforward extension of this idea will be to define proportion variables qil
for l ∈ L, i ∈ I ∪ L. However, not only does this involve using O(|L|2 + |I||L|) proportion variables,
but we also introduce bilinear terms of the form qil qi0 l0 thereby losing the disjoint bilinear structure
(i.e. all nonlinearities being qil ylj ). Instead, Alfaki and Haugland [4] proposed a q -formulation by
defining qil as the fraction of incoming flow to pool l that originated from some input i and not
distinguishing between flows that started at i and reached l along different paths. This formulation
has O(|I||L|) proportion variables. Also, all bilinear terms are of the form qil ylj as explained next.
Let q·l denote the vector (qil )i∈Il . We have
X
q·l ∈ ∆|Il | := {q·l ≥ 0 : qil = 1} ∀l ∈ L, (7)
i∈Il

Since we send flows from inputs to outputs via pools, we can create a super-sink node that connects
to all outputs and consider each input i ∈ I to be a unique commodity1 . The flow of commodity
i on arc (l, j ) is given by vilj = qil ylj for l ∈ L, j ∈ L ∪ J, i ∈ Il . In order to ensure flow balance of
commodity i at pool l, we must add the constraint
X X
yil + qil0 yl0 l = qil ylj ∀l ∈ L, i ∈ Il . (8)
l0 ∈L:i∈Il0 j∈L∪J

Observation 7 Equations (7) and (8) render the flow balance constraint (1) redundant.
P
For l ∈ LI and i ∈ Il , equation (8) reads: yil = qil j ylj .
The spec level requirement constraints at the output are modeled as
X X X
λik yij + λik qil ylj ≥ µmin
jk yij , ∀j ∈ J, k ∈ K. (9a)
i∈I l∈L,i∈Il i∈I∪L
X X X
λik yij + λik qil ylj ≤ µmax
jk yij , ∀j ∈ J, k ∈ K (9b)
i∈I l∈L,i∈Il i∈I∪L

The q -formulation for pooling problem can now be stated as follows.

z ∗ = min
X
cij yij s.t. y ∈ F , (7) − (9). (Q)
y,p
(i,j )∈A

In the case of standard pooling problems, the above formulation reduces to the one proposed
by [13]. Based on the above ideas, two new formulations for the standard pooling problem were
developed in [5]: (TP) that uses proportions of flows traveling from a pool l to an output j and
(STP) that combines the proportion variables from both (Q) and (TP) and consequently, has more
variables and bilinear terms.

2.2.2 pq-formulation

The pq -formulation was introduced in [67, chap. 9] for standard pooling problems and is obtained by
appending some valid inequalities to (Q). These inequalities can be derived from the Reformulation
Linearization Technique (RLT) [63] by multiplying (7) with ylj and the pool capacity constraints
in (2) with qil , respectively. For both standard and generalized problem, the valid inequalities can
be stated as follows:
X X
qil ylj = ylj ∀l ∈ L, j ∈ L ∪ J, qil ylj ≤ Cl qil ∀l ∈ L, i ∈ Il . (10)
i∈Il j∈L∪J

1 For the p-formulation, specifications serve the role of commodities and (4a) is a commodity balance constraint.
Relaxations and discretizations for the pooling problem 7

Addition of (10) to (Q) yields formulation (PQ).

z ∗ = min
X
cij yij s.t. y ∈ F, (7) − (9), (10). (PQ)
y,p
(i,j )∈A

In §3.2.1, we give an insight into the conventional wisdom behind (PQ) being a strong formulation
for the pooling problem and hence a formulation of choice for solving (standard) problem instances.

2.2.3 Hybrid formulation

Audet et al. [7] suggested a model that combined the p and q variables along with the y variables.
The motivation was to avoid having bilinear terms of the form qil qjl0 that would arise by a straight-
forward extension of the Ben-Tal et al. model to the case of generalized pooling problems. In this
so-called hybrid model, proportion variables are used for pools in LI and concentration variables
are used for pools in L \ LI . We skip the details of this hybrid formulation (HYB) since it can be
easily obtained by combining the previous sections.

2.2.4 Equivalence of formulations

We now formally prove the correctness of the forgoing formulations for the pooling problem. Al-
though the proof is straightforward for standard problems, a little bit of work is required for
generalized problems where we have arcs between two pools and there may exist multiple paths
from an input to a pool. This tedious exercise was skipped in [4] and is formally presented here
for completeness. We say that two formulations are equivalent if for every feasible point in one
formulation, there exists a feasible point with same objective value in the other formulation and
vice versa.

Proposition 2 Formulations (P), (Q), (PQ), and (HYB) are equivalent.

Proof First let us show that for any feasible point P (q, y ) in (Q) there exists some p such that (p, y )
satisfies (4a) and (6). Observe that if we set plk = i∈Il λik qil for all l ∈ L, k ∈ K , then (9) implies
(6). It remains to verify that with this choice of p, (8) implies (4a). Fix some l ∈ P L, k ∈ K . For
every i ∈ Il , multiply both sides of (8) with λik . Summing over i ∈ Il gives us i∈Il λik yil +
P P P
P 0
0
l ∈L λ q 0
i∈Il0 ∩Il ik il l l y 0 = λ
i∈Il ik ilq j∈L∪J ljy . Since for any ( l , l ) ∈ A ∩ L × L, we have
P P P 
Il0 ⊆ Il and hence Il0 ∩ Il = Il0 , the equality becomes i∈Il λ ik y il + 0
l ∈L i∈Il0 λ ik q il 0 yl 0 l =
P
P
i∈Il λik qil i∈I∪L yil , where on the right hand side Pwe have also used the flow balance equality
(1). It follows that (4a) is satisfied by choosing plk = i∈Il λik qil .
Now wePshow the converse, i.e. for any feasible point (p, y ) in (P), there exists some q satisfying
(7), plk = i∈Il λik qil for all l ∈ L, k ∈ K , and such that P(q, y ) satisfies P(8) and (9). As before, (6)
⇒ (9) is obvious. Fix some l ∈ L. First suppose that y
i∈I∪L il = j∈L∪J ylj = 0. Here (8) is
trivially true. By problem definition, all flows originate with specification values only at the input
nodes and since (1) balances total flow at each pool in G and we assume linear blending in (4a),
it must be thatP (plk )k∈K ∈ conv{(λik )k∈K : i ∈ Il }. Thus,P there exists a vector (qil )i∈Il satisfying
(7) and plk P = i∈I l
λ ik q il ∀k . Henceforth assume that j∈L∪J ylj > 0. For j ∈ L ∪ J , define
ξlj := ylj / j∈L∪J ylj to be the fraction of outgoing flow from l directed towards j . Let Til be the
set of directed paths between i ∈ Il and l. Since G is acyclic, Til is a finite set. Take a directed
path τ := {i, τ1 , . . . , τr , l} ∈ Til . Then the total flow from i that reaches l along path τ is equal to
P τ
τ Q r −1 τ ∈Til σil
σil := yiτ1 ξτr l o=1 ξτo τo+1 . Construct the q variables as follows: qil = P 0 . The flow balance
i ∈I∪L yi0 l
equations (1) P implyP that there is no supply at pools and all the supply originates at inputs. Hence,
τ
the quantity i∈Il τ ∈TilPσil , which designates P the total flow from all inputs to l must equal the
total flow into l whichPis i0 ∈I∪L yi0 l . Hence i∈Il qil = 1.P Similarly, the total quantity of spec k
P τ
at pool l is given by i∈Il λik τ ∈Til σil and hence plk = i∈Il λik qil . Now the left hand side of
(8) is
X X τ P yl 0 l X X τ
X τ0 X
yil + σil 0 = yil + σil l l =
0ξ 0 σil = qil ylj
l0 ∈L:i∈Il0 τ ∈Til0 i0 ∈I∪L yi0 l0 l0 ∈L:i∈Il0 τ ∈Til0 τ 0 ∈Til j∈L∪J

where the second equality follows from the following observations: 1) yil is defined if and only if
(i, l) ∈ A, 2) any non-direct path between i and l must pass through intermediate pools l0 such that
8 Gupte, Ahmed, Dey, Cheon

i ∈ Il0 , (3) by construction of σ τ , the quantity σil

τ
l l denotes the total flow from i to l along the
0ξ 0
0 0
path τ = τ ∪ (l , l) ∈ Til .
Thus, we have shown that (P) and (Q) are equivalent formulations of the pooling problem. The
equivalence of (Q) and (PQ) is obvious due to the validity of (10). The correctness of (HYB) can
be shown using the above proof for pools in LI . u
t

2.3 Problem sizes

The alternate formulations of §2.2 present different ways of modeling the p-formulation of the
pooling problem obtained from Definition 1. All these equivalent formulations use the same flow
variables on the arc set A and they only differ in the use of non-flow variables and additional con-
straints. Since bilinearities are responsible for making the problem hard to solve, Table 1 mentions
the number of bilinear terms and bilinear constraints along with the number of non-flow variables.

Form- Non-flow Bilinear terms Bilinear constraints

ulation variables Eq. Ineq.

P |K||L| |K||L| O(|L| + |J|) |K||L| 2|K||J|

P P P
Q l∈L |Il | l∈L |Il | O(|L| + |J|) l∈L |Il | 2|K||J|
P P P
PQ l∈L |Il | l∈L |Il | O(|L| + |J|) l∈L |Il | + 2|K||J|
P
|L| O(|L| + |J|) + l∈L |Il |
P hP i P
HYB |Il |
l∈LI |Il | + |K||L \ LI |
l∈LI l∈LI |Il | + 2|K||J|
P
+ |K||L \ LI | × O(|L \ LI | + |J|) |K||L \ LI | + + l∈LI |Il |
|LI | O(|L \ LI | + |J|)

Table 1 Comparing problem sizes for various formulations of the pooling problem.

2.4 Variants

We have already mentioned two types of pooling problems - standard and generalized, depending
on the absence or presence of arcs between pools, respectively. There are many variants of these two
basic types. A broader class of network flow problems with bilinear terms is described by [42, 58, 61].
Nonlinear blending rules have also been proposed, see [50] for a discussion and [59] for one specific
example of nonlinear blending where the bilinear terms in the pooling problem are replaced by
cubic terms. A variant of the standard problem, where total flow into each output is fixed to some
nonzero constant, was studied by [62]. An extended pooling problem that imposes upper bounds
on emissions from outputs was introduced in [52]. Other examples of MINLP models can be found
in [20, 49, 51, 56, 69]. These MINLP variants arise mainly by including binary decision variables
related to the use of each arc or node in the graph or forcing the flows to be semicontinuous.
Pooling problems also find applications in the mining industry [15]. Stochastic versions of the
standard problem that model uncertainty in the input specification levels λ’s were proposed by
[43, 44].
We describe one variant that arises after imposing finite time periods and inventory balance
requirements at each node. A somewhat related model was considered in the blend scheduling
problem of [41].

2.4.1 Time indexed pooling problems

Consider a generalized pooling problem and let T be a set of time periods. For each time period
t ∈ T , we have to make the following decisions: 1) semicontinuous flow yijt on arc (i, j ) ∈ A, 2) sit
amounts of inventory to be held at a node i ∈ N , 3) xin out
lt = 1 iff there is inflow at pool l, 4) xlt = 1
iff there is outflow at pool l, 5) zlt = 1 iff pool l is used for mixing. Some additional parameters
are required for this model. Let ait and djt be the supply at input i ∈ I and demand at output
j ∈ J , respectively, at time t ∈ T . Let hl be the fixed cost of using a pool l ∈ L. The set of pools is
partitioned into two categories - Lc and L \ Lc . A pool l ∈ Lc is allowed to be leased on a contract
Relaxations and discretizations for the pooling problem 9

basis for a fixed period τl and can only be used under contract. Typically, τl ≤ |T | and the contracts
are renewable. For a pool l ∈ Lc , the fixed cost hl is associated with the entire contract.
We first state the p-formulation (P-Inv) of this problem. plkt denotes the concentration value of
spec k at pool l at time t.

X X XX
min cij yijt + hl zlt
y,s,x,z
t∈T (i,j )∈A t∈T l∈L
X
ait + si(t−1) = yilt + sit ∀i ∈ I, t ∈ T
l∈L∪J
X X
yilt + sl(t−1) = slt + yljt ∀l ∈ L, t ∈ T
i∈I∪L j∈L∪J
X
yljt + sj (t−1) = sjt + djt ∀j ∈ J, t ∈ T
l∈I∪L
 
X X X
λik yilt + pl0 kt yl0 lt + plk(t−1) sl(t−1) = plkt  yljt + slt  ∀l ∈ L, k ∈ K, t ∈ T
i∈I 0 j∈L∪J
l ∈L
min
X X X X
µjk yijt ≤ λik yijt + plkt yljt ≤ µmax
jk yijt ∀j ∈ J, k ∈ K, t ∈ T
i∈I∪L i∈I l∈L i∈I∪L
in out
(y, s, x , x , z ) ∈ Z, 0 ≤ slt ≤ Cl ∀l ∈ L, t ∈ T,

where Z represents the set of combinatorial constraints that make this optimization model a mixed
integer bilinear program (MIBLP).
n
Z := (y,s, xin , xout , z ) : yilt ≤ uil xin out
lt , yljt ≤ ulj xlt ∀l ∈ L, i ∈ I ∪ L, j ∈ L ∪ J, t ∈ T (11)

zlt ∀l ∈ L \ Lc
xin out
lt + xlt ≤ n P o ∀t ∈ T (12)
min 1, t0 ∀l ∈ Lc
t =t+1−τl zlt
0

t+1
X
0 ≤ slt ≤ Cl zlt0 ∀l ∈ Lc , t ∈ T (13)
t0 =t+1−τl
o
yijt ∈ {0} ∪ [`ij , uij ] ∀(i, j ) ∈ A, t ∈ T, xin out
lt , xlt , zlt ∈ {0, 1} ∀l ∈ L, t ∈ T . (14)

The combinatorial constraints can be explained as follows. Equation (14) states variable definitions
for semicontinuous flows and binary variables. Here, zlt = 1 for l ∈ Lc implies that a new contract
for pool l was started at time t whereas zlt = 1 for l ∈ L \ Lc implies that pool l was used at time t.
Equation (12) models either inflow or outflow at each pool and for l ∈ Lc , ensures that there should
be no flow if the contract has expired. Equation (11) imposes variable upper bound constraints on
incoming and outgoing flows at each pool. Equation (13) clears inventory at a pool if its contract
is not renewed.
In order to obtain a q0-formulation, observe that time indexing can be treated in the 0
same manner
0
as pool-pool0
arcs.
0
Let G be a new graph whose nodes are partitioned into inputs I , pools L , and
0
outputs J . I consists of |I||T | nodes, one for each input-time pair [i, t] for i ∈ I, t ∈ T . Similarly, L
0 0
and J have |L||T | and |J||T | nodes, respectively. Consider a node [l, t] ∈ L . Then the set of inputs
0 0 0 0 0
in G from which there exists a directed path to [l, t] is given by I[l,t] = {[i, t ] ∈ I : i ∈ Il , t ≤ t},
i.e. all the input nodes in I that had a path to l and time index before t. Thus the proportion
variable qilt0 t denotes the fraction of incoming flow at pool l at time t which is contributed by
0
input i ∈ I from time t ≤ t. For any outflow arc (l, j ) ∈ A from pool l, we have the bilinear terms
s
viljt0 t = qilt0 t yljt and vilt0
t
= qilt0 t slt . We can now formulate the time indexed pooling problem
using the q - or pq -formulations of §2.2. Note that even for medium size graphs with |T | not too
large, the size of the q -formulation may become prohibitively large.

3 Polyhedral relaxations

The pooling problem, as defined by its formulations in §2, involves bilinear terms in equations
(4a) and (6) ((8) and (9) for PQ) thereby making its optimization computationally challenging. A
10 Gupte, Ahmed, Dey, Cheon

popular methodology for solving nonconvex problems is the spatial branch-and-bound algorithm
where tight relaxations of the original problem play a critical role in convergence behavior. Global
optimization solvers use different bound tightening techniques that are updated at each node of the
branch-and-bound tree. LP relaxations are a popular choice for lower bounding the optimum due
to their scalability and ease of solvability. Semidefinite relaxations have been studied for nonconvex
QCQPs [11] and applied to small-sized pooling problems [24, 56] but they do not scale well even
with modest increases in problem size. In §3.1 we review known approaches for relaxing general
bilinear constraints using polyhedral sets and in §3.2.1 and §3.2.2, we present some new insights
into properties of the commonly used relaxations for the pooling problem. The remaining sections
discuss some new relaxation techniques that, to the best of our knowledge, have not been considered
before.

3.1 General bilinear programs

Given any continuous nonconvex function f : C 7→ < with a convex domain C ⊆ <n , a popular
relaxation for C := {x ∈ C : f (x) = b } is the superset C env := {x ∈ C : (cvx f )(x) ≤ b ≤ (conc f )(x)},
where (cvx f )(·) is the convex envelope (the tightest convex under-estimator) of f over C and
(conc f )(·) is the concave envelope (the tightest concave over-estimator) of f over C . For relaxing a
≥ (resp. ≤) inequality, we use only (cvx f )(·) (resp. (conc f )(·)). Let Wf := {(x, γ ) ∈ C ×< : f (x) = γ}
denote the graph of f . It is well-known that conv(Wf ) is equal to {(x, γ ) ∈ C × < : (cvx f )(x) ≤
γ ≤ (conc f )(x)} and hence C env is the strongest possible relaxation for C based on convexifying
the graph of f . Generating envelopes of arbitrary nonlinear functions is in general a hard problem
and the literature is rife with results for general and specialized functions; see for example [67] for
details. For bilinear (and general multilinear) functions, several important results are known [cf.
46]. We restrict our attention to the bipartite case of the bilinear function, wherein all bilinear
terms appear as a product between two types of variables - x and y, since the bilinear equality and
inequality constraints in the pooling problem exhibit such structure.
First of all, a classical result due to McCormick [48] states that the envelopes of a single bilinear
term f (x , y) = axy with a > 0, x ∈ [`x , u x ], y ∈ [`y , u y ] are:

(cvx f )(x , y) = a max{u y x + u x y − u y u x , `y x + `x y − `x `y } (15a)

y x x y y x y x
(conc f )(x , y) = a min{u x + ` y − ` u , ` x + u y − ` u }. (15b)

Later, an equivalent statement was independently proved by [2]: the convex hull of {(x , y , ω ) : x ∈
[`x , u x ], y ∈ [`y , u y ], ω = axy } is described by four inequalities

γ/a ≥ u y x + u x y − u y u x , γ/a ≥ `y x + `x y − `x `y ,
(16)
γ/a ≤ u y x + `x y − `x u y , γ/a ≤ `y x + u x y − `y u x .
P
Now let f (x , y) = i,j Aij xi yj be a bilinear function with domain X × Y for some polytopes
X and Y . It is known [60, 64] that (cvx f )(·) and (conc f )(·) are polyhedral functions and can
be evaluated at each point by optimizing an exponential sized LP formulation that triangulates
f over the extreme points of X × Y . Bao et al. [10], Misener et al. [53] have implemented and
tested dynamic cut generating procedures for adding the violated facets of conv(Wf ) by solving a
separation problem over the high-dimensional LP. Thus the theoretical strength provided by C env
can be computationally obtained by recursively solving large LPs. A common choice for building
an a priori compact LP relaxation is to use the McCormick envelopes separately for each bilinear
term Aij xi yj . It was proved in [19, 29] that if Aij ≥ 0 ∀i, j and X = [0, 1]m , Y = [0, 1]n , then such
a single-term relaxation indeed yields the convex hull of Wf . Later Luedtke et al. [46] generalized
this result to arbitrary hyper-rectangles and also proved that for A matrices with negative or mixed
sign entries or for general polytopes X and Y , the McCormick relaxation can be significantly weak.
Related to finding the envelopes of f , another set of interest is the convex hull of

W := {(x , y , ω ) : x ∈ X , y ∈ Y, ωij = xi yj ∀i, j} (17)

P
It is clear that conv(Wf ) = Projx ,y ,γ {(x , y , ω, γ ) : γ = i,j Aij ωij , (x , y , ω ) ∈ W}. Hence for any
given pair of polytopes X and Y , convexifying W is equivalent to finding the envelopes of f over
X × Y whereas the knowledge of (cvx f )(·) and (conc f )(·) for specific values of A does not imply a
complete description of conv(W ).
PIn general, an explicit closed-form representation remains elusive
for the polyhedral envelopes of i,j Aij xi yj and for conv(W ).
Relaxations and discretizations for the pooling problem 11

The four facets in (16) are level-1 RLT inequalities [63] produced by taking pairwise multipli-
cations between the bound factors for x (x − `x , u x − x ) and bound factors for y (y − `y , u y − y). Now
let x ∈ <m , y ∈ <n for m, n ≥ 2. If X and Y are hyper-rectangles, the corresponding 4mn level-1
RLT inequalities (i.e. the single-term McCormick envelopes) yield a strict relaxation of conv(W ),
as should be apparent from Luedtke et al.’s result. However when at least one of either X or Y ,
say X , is an arbitrary simplex, then a recent proof exploits the algebraic properties of a simplex to
argue that the only nontrivial facets of conv(W ) are the RLT inequalities obtained by multiplying
every facet of X with every facet of Y and substituting ωij = xi yj ∀i, j .

Theorem 1 (Gupte [32]) Let X be a κ-dimensional simplex in <m for some κ ≤ m and Y be a
polyhedron in <n . Then the closure convex hull of W is equal to its level-1 RLT relaxation RLT1(W )
obtained by multiplying every equation defining X with yj ∀j and every inequality defining X with every
inequality defining Y and subsequently replacing ωij = xi yj for all i, j.

An immediate implication of this theorem is the following corollary, which is analogous to Rikun
[60, Theorem 1.4] for sum decomposition of convex envelopes.
QT
Corollary 1 (Gupte [32]) Let X be a simplex and Y = t=1 Yt be a Cartesian product of polytopes
Yt ⊂ <nt ∀t. Denote W = ∩T t t t t t t t
t=1 W , where W = {(x , (y )t , (ω )t ) : x ∈ X , y ∈ Yt , ωij = xi yj ∀i, j}.
T t T t
Then conv(W ) = ∩t=1 conv(W ) = ∩t=1 RLT1(W ).

Thus bilinear functions can be convexified over simplicial constraints using a polytope in a
polynomial sized extended space. This implication is pertinent to the pooling problem due to the
presence of the standard simplex (7).
We close this section with the following remark.

Remark 2 Let C = {(x , y) ∈ X × Y :

P
i,j Aij xi yj ≤ b }. Since the bilinear
 
function f (x , y) =
 
P > x 1 0 A
i,j A ij xi y j can be reformulated into a nonconvex quadratic as (x , y) Q , where Q = 2 A> 0 ,
y
the set C can be relaxed by applying methods that are known in literature for general QCQPs.
An exhaustive study of these techniques is beyond the scope of this paper; see Burer and Saxena
[18] for a review. A common method [40] is to write Q = Q1 − Q2 , where Q1 and Q2 are two
positive semidefinite matrices; such a decomposition   is always possible – for example, using the
> x
eigenvalues of Q. Denote gi (x , y) := (x , y) Qi , for i = 1, 2, as two convex quadratics. We have
y
f (x , y) = g1 (x , y) − g2 (x , y) and C = {(x , y) ∈ X × Y : g1 (x , y) ≤ g2 (x , y)}.

For example in PQ, inequality (9b) can be reformulated in two ways. Denote λ̆ijk := λik −
+ −
µmax
jk , Iljk := {i ∈ Il : λ̆ijk > 0} and Iljk := {i ∈ Il : λ̆ijk < 0}. Then (9b) is equivalent to either
of the following:
X X X
λik yij + λ̆ijk (qil + ylj )2 + λ̆ijk (qil − ylj )2
i + −
l∈L,i∈Iljk l∈L,i∈Iljk
X X
≤ λ̆ijk (qil − ylj )2 + λ̆ijk (qil + ylj )2 ,
+ −
l∈L,i∈Iljk l∈L,i∈Iljk

X X X
λik yij + (λ̆ijk qil + ylj )2 ≤ (λ̆ijk qil − ylj )2 .
i∈I l∈L,i∈Il l∈L,i∈Il

It can be verified that the second inequality corresponds to the eigenvalue decomposition of the
Q-matrix in (9b).

The set C qcqp := {(x , y) ∈ X ×Y : g1 (x , y) ≤ (conc g2 )(x , y)} gives a convex relaxation of C . Note that
(conc g2 )(·) is a affine function obtained by convexifying g2 (·) over the extreme points of X ×Y . Since
g1 (·) is convex, it follows that C qcqp = {(x , y) ∈ X × Y : (cvx g1 )(x , y) − (conc g2 )(x , y) ≤ 0}. Now the
fact that convex envelopes do not sum-decompose in general [cf. 66] leads to (cvx f )(·) ≥ (cvx g1 )(·)+
(cvx −g2 )(·) = (cvx g1 )(·) − (conc g2 )(·), implying that C qcqp is a (possibly strict) superset of the
envelope relaxation C env . Since C env is a polyhedral relaxation for bilinear functions and can
be obtained computationally through a cutting plane procedure, this decomposition method for
nonconvex QCQPs does not present any additional advantages over convexifying the entire bilinear
function.
12 Gupte, Ahmed, Dey, Cheon

3.2 Relaxing feasible sets

The special structure of the pooling problem implies that when convexifying the individual bilin-
ear functions with respect to the variable bounds, then the single-term McCormick inequalities
(16) yield the best possible relaxation.
P This can P be observed as follows.
P For the P formulation,
we have the bilinear functions l0 ∈L pl0 k yl0 l − plk j∈L∪J ylj and l∈L plk ylj in (4a) and (6), re-
spectively, with bounds given by P (5a) and (3).PSince the bilinear terms in the second function are
separable,
P it is obvious that Pcvx( l plk ylj ) = l cvx(plk ylj ) (similarly for P
conc). The two summa-
tions in l0 ∈L pl0 k yl0 l − plk j∈L∪J ylj are separable; the P first summand k yl0 l is further
l0 ∈L pl0P
completely
P separable whereas the second summand p lk j∈L∪J y lj obeys cvx( p lk j∈L∪J ylj ) =
j∈L∪J
P cvx( p lk y lj ) due to [46, PTheorem 3.11]. Analogous arguments
P hold
P for Q and PQ, where we
have l0 ∈L:i∈I 0 qil0 yl0 l in (8), l∈L,i∈Il λik qil ylj in (9) and i∈Il qil ylj , j∈L∪J qil ylj in (10).
l

Proposition 3 (Sum decomposition rule) For the pooling problem, envelopes of bilinear functions
taken over the bounds - equations (5a) and (3) and qil ∈ [0, 1] ∀l ∈ L, i ∈ Il , on the associated variables
can be obtained from single term McCormick inequalities.

Besides variable bounds, the problem formulations in §2 contain additional linear constraints
given by (1), (2) and (7). If we consider the question of convexifying the associated bilinear func-
tions over some or all of these constraints along with variable bounds, then we need (many more)
inequalities in addition to the McCormick inequalities (16). Hereafter, we turn our attention to
finding good relaxations for constraints in the pooling problem by discussing various relaxations
that are based on convexifying sets of the form (17). Different relaxations arise depending on which
subset of constraints (1) - (3), (7) is used for defining the domains X and Y . The objective function,
being linear in y , is left unchanged for each of these relaxations.

3.2.1 p- and pq-relaxations

First, we are interested in studying a relaxation of the feasible set that arises at each pool. For P
and Q, relaxations of the feasible sets corresponding to pool l are denoted by the sets Pl and Ql ,
respectively, and are defined as

Pl := (pl· , yl· , wl·· ) : wlkj = plk ylj ∀k ∈ K, j ∈ L ∪ J, plk ∈ [pmin max


lk , plk ] ∀k ∈ K, yl· ∈ Yl ,

Ql := (q·l , yl· , v·l· ) : vilj = qil ylj ∀i ∈ Il , j ∈ L ∪ J, q·l ∈ ∆|Il | , yl· ∈ Yl , where
P
where Yl is the set of feasible capacitated flows at pool l and is given by Yl := {yl· : j∈L∪J ylj ≤
Cl , ylj ∈ [0, ulj ] ∀j ∈ L ∪ J}. These single pool relaxations are constructed by dropping the (i)
incoming arcs at pool l along with their respective bounds, (ii) commodity balance constraints (4a)
and (8) for P and Q, respectively. Observe that we have also included new variables wlkj and vilj
for the bilinear terms. Using these new variables, the bilinear constraints (4a) and (6) (resp. (8)
and (9)) in P (resp. Q) can be linearized as
X X X
λik yil + wl0 kl = wlkj ∀l ∈ L, k ∈ K (19a)
i∈I l0 ∈L j∈L∪J
min
X X X X
µjk yij ≤ λik yij + wlkj ≤ µmax
jk yij ∀j ∈ J, k ∈ K. (19b)
i∈I∪L i∈I l∈L i∈I∪L

X X
yil + vil0 l = vilj ∀l ∈ L, i ∈ Il (20a)
l0 ∈L : i∈Il0 j∈L∪J
X X X X
µmin
jk yij ≤ λik yij + λik vilj ≤ µmax
jk yij ∀j ∈ J, k ∈ K. (20b)
i∈I∪L i∈I l∈L,i∈Il i∈I∪L

The valid inequalities (10) added to PQ are similarly linearized as

X
vilj = ylj ∀l ∈ L, j ∈ L ∪ J, (20c)
i∈Il
X
vilj ≤ Cl qil ∀l ∈ L, i ∈ Il . (20d)
j∈L∪J

Equation (19a) was also motivated by [45] using the Reduced RLT (RRLT) procedure.
Relaxations and discretizations for the pooling problem 13

It is obvious that PQ is a stronger formulation than Q since the former contains additional valid
inequalities (10). The feasible sets of P and PQ formulations are reformulated in the lifted space as
follows:
P = {(p, y, w) : y ∈ F , (19), Pl ∀l ∈ L}, PQ = {(q, y, v ) : y ∈ F , (20), Ql ∀l ∈ L}. (21)
The p-relaxation is obtained using the level-1 RLT relaxation of Pl for all l.
P := (p, y, w) : y ∈ F , (19), RLT1(Pl ) ∀l ∈ L .

(p-relax)

Note 2 Traditionally, the set P is obtained using (19) and the McCormick envelopes (15) for
lj appearing in each Pl . However we prefer to work with our definition of P since we
wlkj = plk yP
also have j ylj ≤ Cl , which may not be redundant, in Pl and (15) is a subset of level-1 RLT
inequalities.
The pq -relaxation is obtained using (15) for vilj = qil ylj in each Ql and (10).
PQ := (q, y, v ) : y ∈ F , ql ∈ ∆|Il | ∀l ∈ L, (20), 0 ≤ vilj ≤ ulj qil ∀i, l, j .

(pq -relax)

Note 3 In the definition of PQ , note that we have included only 2 out of the 4 envelopes from
P
(15). The concave envelope vilj ≤ ylj is redundant since it is the sum of i vilj = yljP and −vi0 lj ≤
0 ∀i0 =
P
6 i. The convex envelope vilj ≥ ulj qil + ylj − ulj is a sum of i vilj = ylj , −ulj i qil = −ulj
and −vi0 lj + ulj qi0 l ≥ 0 ∀i0 =
6 i.
Both P and PQ are polyhedral relaxations of the respective formulations.
Proposition 4 The strength of PQ is equivalent to convexifying Ql for all l ∈ L and hence PQ is a
stronger relaxation than P in the sense that for any c ∈ <|A| ,
z pq := min{c> y : (q, y, v ) ∈ PQ} ≥ z p := min{c> y : (p, y, w) ∈ P}.
Proof Since ∆|Il | is a standard simplex, a direct application of Theorem 1 with X = ∆|Il | and
Y = Yl gives us
 X X
conv(Ql ) = (q·l , yl· , v·l· ) : ql ∈ ∆|Il | , vilj ≤ Cl qil ∀i ∈ Il , vilj = ylj ∀j ∈ L ∪ J,
j∈L∪J i∈Il (22)

0 ≤ vilj ≤ ulj qil ∀i ∈ Il , j ∈ L ∪ J .
Note that the two additional inequalities, besides the McCormick envelopes vilj ≤ ulj qil and vilj ≥ 0,
that define conv(Ql ) are exactly the valid inequalities (20c), (20d) that were added to strengthen
the PQ formulation. Thus PQ gives at least the same relaxation strength as conv(Ql ),
PQ = (q, y, v ) : y ∈ F , (20), conv(Ql ) ∀l ∈ L .

(23)
P
As seen in the
P proof of Proposition 2, there exist linear mappings, of the form plk = i∈Il λik qil
and wlkj = i∈Il λik vilj , between points in Ql and Pl . It follows that
{(q, y, v ) : y ∈ F, (20), conv(Ql ) ∀l} = {(p, y, w) : y ∈ F , (19), conv(Pl ) ∀l}.
The set Pl has similar structure to that of the set W (cf. (17)) with the vector yl· playing the
role of y and pl· playing the role of x . The McCormick inequalities for wlkj = plk ylj ∀k, j yield a
relaxation of conv(Pl ) and this inclusion is strict because the bounds pl· ∈ [pmin max
l· , pl· ] define a
hyper-rectangle Hence
P ⊇ (p, y, w) : y ∈ F , (19), conv(Pl ) ∀l ∈ L


=⇒ Projy P ⊇ Projy (p, y, w) : y ∈ F , (19), conv(Pl ) ∀l ∈ L



= Projy {(q, y, v ) : y ∈ F , (20), conv(Ql ) ∀l}

= Projy PQ.
Thus Projy PQ ⊆ Projy P , which is equivalent to the proposed statement. u
t
Remark 3 Based on (23), it follows that PQ is equivalent in strength to the relaxation obtained by
convexifying the bilinear functions in PQ over the domain defined by simplex (7), pool capacities
in (2) and flow upper bounds (3).
Since Proposition 4 argued that conv(Ql ) is a tighter relaxation than the McCormick relaxation of
Pl , our result is stronger than previous results for standard [67, chap. 9] and generalized [4] pooling
problems. The single pool argument that we adopted here extends to the hybrid formulation of
§2.2.3 where the relaxations corresponding to pools with proportion variables are stronger than
the relaxations of these pools in the p-formulation. Hence it follows that the strength of the HYB
formulation is between that of P and PQ. There is no dominance between P and Q formulations.
14 Gupte, Ahmed, Dey, Cheon

3.2.2 Piecewise linear relaxations

The strength of the McCormick envelopes (15) for a single bilinear term xi yj depends on the bounds
[`xi , uix ] and [`yj , ujy ] for xi and yj , respectively. Tighter bounds lead to stronger relaxations. Hence,
partitioning the intervals of one or both the variables and then constructing McCormick envelopes
in each interval gives a much stronger relaxation than simply including equations (15) based on the
entire interval. Of course, the level of partitioning determines the strength of this new relaxation.
To enforce validity of this relaxation, we need to add extra binary variables to turn on/off each
partition with exactly one partition being turned on. This gives rise to a piecewise linear MILP
relaxation of {(xi , yj , ωij ) ∈ [`xi , uix ] × [`yj , ujy ] × < : ωij = xi yj } for every i, j . Note that PQ , which
is an LP, can be interpreted as a trivial piecewise linear relaxation wherein the domain of each
variable has a single partition. Such piecewise linear McCormick relaxations were used by [49, 51]
to solve some generalized pooling problems and [27] performed an extensive computational study
on small scale standard pooling problems to investigate different partitioning levels and MILP
models. Recently, [54] implemented a branch-and-bound based solver for pooling problems that
uses piecewise linear MILP relaxations to generate lower bounds in the enumeration tree.
An interesting theoretical question is to determine the error introduced by partitioning the
variable domains as a function of the number of partitions. There are two related questions here:
the first one is to determine the distance between partitions so that we minimize the total error
calculated as sum of squares (or absolute values) of errors between ωij = xi yj and the McCormick
envelopes (15) in each partition. It was shown in [34] that the best strategy is to locate the partitions
of equal length and this result is applicable to any bilinear problem. A more pertinent question
is to find out how the piecewise linear relaxation schemes affect the quality of the lower bound
with respect to z ∗ , the optimal value of the pooling problem. This was recently answered by Dey
and Gupte [21, Theorem 1] who proved that for standard problems, the ratio of z ∗ to the optimal
value of any piecewise linear McCormick relaxation is at most |J|, where |J| denotes the number
of output nodes. Notice that this performance guarantee is independent of the number of and the
distance between partitions in each variable domain. They also proved that this approximation factor
is tight, i.e. there are problem instances where this ratio gets arbitrarily close to |J| for all piecewise
linear relaxations.

3.2.3 An extended pq-relaxation

Recall the PQ formulation. The kth spec requirement constraints at output j are given by (20b)
where vilj = qil ylj and qil denotes the ratio of incoming flow to pool l that originated at input i.
Notice that each output j may itself be treated as a pool node since linear blending takes place
at j as per equation (20b). Suppose that we introduce a new variable qij to denote the ratio of
incoming flow to output j that originated at input i. Then the kth spec level at j is i∈Ij λik qij .
P

Equation (20b) can now be modeled as

X
µmin
jk ≤ λik qij ≤ µmax
jk , q·j ∈ ∆|Ij | ∀j ∈ J. (24a)
i∈Ij

To guarantee correctness, we introduce new commodity balance constraints and bilinear terms
X X
yij + vilj = ξitj ∀j ∈ J, i ∈ Ij , (24b)
l∈L : i∈Il t∈N

ξitj = qij ytj ∀j ∈ J, (t, j ) ∈ A, i ∈ Ij . (24c)

0
We let PQ := {(q, y, v, ξ ) : y ∈ F , (20a), (24), Ql ∀l ∈ L} denote this extended pq -formulation where
all the bilinear terms are present in equality constraints (20a) and (24b).
Proposition 5 For any (y, v ) ∈ Projy,v PQ, there exist values for qij and ξitj for all j ∈ J, (t, j ) ∈
A, i ∈ Ij such that (q, y, v, ξ ) satisfies (24).
P
Proof Choose some j ∈ J . If t ytj = 0, which implies left hand side of (24b) is zero, set ξitj =
0
P ∀i, t, j and we know from Observation
P 3 that thereP exists some q·j ∈ ∆|Ij | that satisfies (24a). Let
t y tj > 0. Construct qij = (yij + v
l∈L : i∈Il ilj ) / t ytj and ξitjP= qij ytj , thus satisfying (24b).
Equation (20b) of PQ and construction of qij imply that µmin jk ≤ max
i∈Ij λik qij ≤ µjk is satisfied.
Finally,
   
X 1 X X X 1 X X
qij = P  yij + vilj  = P  yij + vilj  = 1,
i∈Ij t ytj i∈I i∈Ij l∈L : i∈Il t ytj i∈I l∈L,i∈Il
Relaxations and discretizations for the pooling problem 15

vilj = ylj being valid to PQ .

P
where the last equality is due to i∈Il u
t

This tells us that since PQ convexifies the set Ql for each l ∈ L, we would not gain any additional
strength by convexifying the set defined by the constraints in (24). That being said, since PQ
relaxes vilj = qil ylj , we may be able to improve the lower bound by PQ using valid inequalities for
 
X X X X X
λik yij + λik qil ylj =  λik qij  ytj , ytj ≤ Cj , y·j ≥ 0, (24a),
i∈I l∈L,i∈Il i∈Ij t∈N t∈N

for a given j ∈ J, k ∈ K . We leave this idea open for future research. From Remark 2 it follows that
the convex hull of the above set will present a stronger relaxation than simple relaxation methods
for nonconvex QCQPs.

3.3 Partial RLT relaxations

Recall that PQ is a partial level-1 RLT relaxation since the valid inequalities (20c), (20d) for
conv(Ql ) are generated via a RLT procedure. Here we discuss some new partial level-1 RLT relax-
ations to further strengthen PQ , albeit at the expense of adding many more auxiliary variables.
First observe that in the definition of Ql , we dropped the variables yil for i ∈ I ∪ L. We could
have retained these variables along with their bounds and applied Theorem 1 to obtain a tighter
relaxation than the one presented in (22). However, this stronger relaxation comes at a cost of
introducing McCormick inequalities for new bilinear terms of the form vi00 il = qil yi0 l for i, i0 ∈ Il ,
which are not present elsewhere in the PQ formulation. This increases the size of the relaxation
considerably.

R1 := (q, y, v, v 0 ) : (q, y, v ) ∈ PQ, 0 ≤ vii 0 0


0 l ≤ ui0 l qil ∀l ∈ L, i, i ∈ Il ,

vii0 l = yi0 l ∀l ∈ L, i0 ∈ Il .
X

i∈Il

Second, recall that in Proposition 4, PQ was shown to be equivalent in strength to l∈L conv(Ql )
Q
where Ql is a relaxation of the feasible set corresponding to pool l. A second strengthening over
PQ can be obtained by performing a level-1 RLT P over multiple pools that are all connected to the
same output. For every j ∈ J , let Yj := {y·j : i∈I∪L yij ≤ Cj , yij ∈ [0, uij ] ∀i ∈ I ∪ J} denote the
flow set corresponding to input flows at j . We use level-1 RLT inequalities for the convex hull of

Sj := (q, y·j , v·j ) : q·l ∈ ∆|Il | ∀l ∈ L : (l, j ) ∈ A, y·j ∈ Yj , vilj = qil ylj ∀l ∈ L : (l, j ) ∈ A, i ∈ Il

for every j ∈ J . Note that conv(Sj ) is equivalent Q in strength to the relaxation obtained by
convexifying the bilinear functions in PQ over l ∆|Il | × Yj . Since a Cartesian product of sim-
plices is not a simplex itself, we cannot apply Theorem 1 to obtain conv(Sj ) and we only have
conv(Sj ) ⊆ RLT1(Sj ), unless uij ≥ Cj ∀i in which case Yj becomes a simplex and we get
conv(Sj ) = RLT1(Sj ). Our second RLT relaxation is

R2 := (q, y, v, v 0 ) : (q, y, v ) ∈ PQ, (q, y·j , v, v·j

0

) ∈ RLT1(Sj ) ∀j ∈ J ,
 0 0
where RLT1(Sj ) := (q, y·j , v, v·j ) : vilij = vilj ∀l ∈ L : (l, j ) ∈ A, i ∈ Il ,
X 0
vili0 j = yi0 j ∀l ∈ L : (l, j ) ∈ A, (i0 , j ) ∈ A
i∈Il
0 0
0 ≤ vili0 j ≤ ui0 j qil ∀l ∈ L : (l, j ) ∈ A, i ∈ Il , (i , j ) ∈ A
X
vili0 j ≤ Cj qil ∀l ∈ L : (l, j ) ∈ A, i ∈ Il .
i0 : (i0 ,j )∈A

The third polyhedral relaxation, denoted as R3 , is the RLT relaxation for the convex hull of

S̃ := {(q, y, v ) : q·l ∈ ∆|Il | ∀l ∈ L, y ∈ F , vilj = qil ylj ∀j ∈ J, l ∈ L, i ∈ Il }, (25)

Once again, the set S̃ does not have the simplicial structure of Theorem 1 and in general, we do not
know an inequality description of conv(S̃ ) (simple examples suggest that this set has exponentially
many facets). R3 is a stronger relaxation than R1 and R2 but also has the highest number of
auxiliary variables.
16 Gupte, Ahmed, Dey, Cheon

3.4 Value function and Lagrangian relaxations

For the standard pooling problem, various Lagrangian relaxations have been proposed over the
years. A Lagrangian dual of Q was used by [13] to generate a converging sequence of lower bounds
in a branch-and-bound algorithm. For P, all constraints except the bounds (5a) and (3) on p’s and
y ’s, respectively, were dualized by [1] whereas [6] went one step further by dualizing only the bilinear
constraints in P and PQ and solving a big-M MILP formulation as a subproblem. We first present
the value function of [13] as applied to a generalized pooling problem and use it to show that the
pq -relaxation is equivalent to a specific Lagrangian dual of the pooling problem. This establishes
a direct connection between the two and also extends [67, Proposition 9.9] to generalized pooling
problems. We also present additional Lagrangian relaxations and discuss their strength.
Consider the bilinear
Q formulation PQ and suppose that we treat q as aQ parameter to obtain an
LP for every q ∈ l∈L ∆|Il | . This LP is not decomposable over L. Let φ : l∈L ∆|Il | 7→ <− denote
the optimal value of this LP. This function is not only nonsmooth but also discontinuous on its
domain since q appears on both left and right hand side of the constraints. The pooling problem
can then be equivalently stated as the global optimization problem

z ∗ = min{φ(q ) : q·l ∈ ∆|Il | ∀l ∈ L} (26)

q

Now suppose that we substitute every bilinear term qil ylj in PQ with a new variable vilj and add
the McCormick envelopes 0 ≤ vilj ≤ uQ lj qil and inequalities (20c), (20d). This gives us an LP and
we denote its value function by φM : l∈L ∆|Il | 7→ <− . Since the q and y variables are separable
in this feasible and bounded LP, It follows that φM (·) is a polyhedral function. Also it is evident
that φM (·) ≤ φ(·) and z pq = minq {φM (q ) : q·l ∈ ∆|Il | ∀l ∈ L}.

Example 1 We illustrate the two functions φM (·) and φ(·) on the Haverly [36] standard pooling
problem with 3 inputs, 1 pool, 2 outputs, and 1 specification. The solitary pool accepts flows from
the first two inputs, whereas the third input is connected directly to the two outputs. Hence we
have q1 + q2 = 1. Figure 2 plots φ(q1 ) and φM (q1 ).

100 100
100 !(q)
!(q)
!(q) 0 0 !M(q)
!M(q)
!M(q)
0 −100 −100

−200 −200
−100
−300 −300

−400 −400
−200
!(q)
!(q)
!(q)

−500 −500

−300 −600
−600

−700
−700
−400
−800
−800
−900
−500 −900
−1000
0 0.1 0.2 0.25 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 0.1 0.2 0.25 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
0 0.1 0.2 0.25 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 q: Fraction of flow from input1 to pool1
q: Fraction of flow from input1 to pool1
q: Fraction of flow from input1 to pool1

(a) Haverly1 (b) Haverly2 (c) Haverly3

Fig. 2 Value functions φ(q1 ) (solid line) and φM (q1 ) (dotted line) for Haverly instances. For all three instances,
φ(q1 ) is lower semicontinuous at q1 = 0.25 and z pq < z ∗ . Observe that Haverly3 has discontinuity of φ(q1 ) at its
optimal solution.

Since φ(·) is defined by an LP as φ(q ) = miny,v {c> y : y ∈ F, (20), vilj = qil ylj ∀i, l, j}, strong
duality dictates that
P φ(q ) is equal to the value
P of the Lagrangian bound obtained by dualizing
constraints (20), j yij ≤ Ci for all iP
∈ I and i yij ≤ Cj for all j ∈ J . Observe that the constraints
that haven’t been dualized, namely j ylj ≤ Cl for all l ∈ L and 0 ≤ yij ≤ uij for all (i, j ) ∈ A, are
separable across pools. Hence this Lagrangian dual can be written as
X
φ(q ) = max min ϕ(ρ, τ, {yij }i∈I ) + ψl (ρ, τ, q·l , yl· , v·l· )
ρ≥0,τ y,v
l∈L
X (27)
s.t. ylj ≤ Cl ∀l ∈ L, 0 ≤ yij ≤ uij ∀(i, j ) ∈ A, vilj = qil ylj ∀i, l, j
j

where ϕ(ρ, τ, ·) and ψl (ρ, τ, ·, ·, ·) are affine functions for fixed multipliers ρ, τ . Substituting the
representation of φ(q ) from (27) into the global optimization in (26) and invoking saddle point
Relaxations and discretizations for the pooling problem 17

duality to interchange outermost min and max produces a lower bound z LAG1 on z ∗ :

z ∗ ≥ z LAG1 := max min ϕ(ρ, τ, {yij }i∈I ) +

X
ψl (ρ, τ, q·l , yl· , v·l· )
ρ≥0,τ q,y,v
l∈L
s.t. 0 ≤ yij ≤ uij ∀(i, j ) ∈ A, i ∈ I, (q·l , yl· , v·l· ) ∈ Ql ∀l ∈ L.

Clearly z LAG1 is a Lagrangian lower bound obtained by dualizing all constraints, except the ones in
Ω , in the PQ formulation. For every fixed ρ, τ , the two functions ϕ and ψ do not share any common
variables and are hence separable. This along with separability of ψl ’s across l ∈ L implies that the
inner minimization problem for z LAG1 is sum-decomposable. Thus we obtain
X
z LAG1 = max min ϕ(ρ, τ, {yij }i∈I ) + min ψl (ρ, τ, q·l , yl· , v·l· )
ρ≥0,τ y q,y,v
l∈L
s.t. 0 ≤ yij ≤ uij ∀(i, j ) ∈ A, i ∈ I s.t. (q·l , yl· , v·l· ) ∈ Ql
Since ψl is a affine function for every fixed ρ and τ , the second minimization is equivalent to
optimizing ψl over conv(Ql ) and this convex hull was obtained in equation (22). Hence,
X
z LAG1 = max min ϕ(ρ, τ, {yij }i∈I ) + min ψl (ρ, τ, q·l , yl· , v·l· )
ρ≥0,τ y q,y,v
l∈L
s.t. 0 ≤ yij ≤ uij ∀(i, j ) ∈ A, i ∈ I s.t. Inequalities from (22).
Finally, observe that the above problem is a Lagrangian dual of the LP associated with the pq -
relaxation and hence by strong duality, its value must be equal to z pq . Thus we have argued the
following.
Proposition 6 Let z LAG1 be the Lagrangian
P lower bound on z ∗ obtained
P by dualizing the following
constraints in the PQ formulation: (i) j yij ≤ Ci for all i ∈ I, (ii) i yij ≤ Cj for all j ∈ J, and (iii)
Equations (20). Then z LAG1 = z pq .
The above result is possible due to two key steps: the decomposition of the problem across pools
after dualizing the appropriate constraints and the strength of the valid inequalities (20c), (20d)
as proved in equation (22).
Now suppose that we dualize only the bilinear constraints (20) (recall that vilj replaces the
bilinear term qil ylj in (8) and (9)), as was proposed in [6]. Then the value of this Lagrangian lower
bound, denoted by z LAG2 , is equal to
z LAG2 = min{c> y : (q, y, v ) ∈ conv(S̃ ), (20)}, (28)
LAG2
where S̃ was defined in (25). This explicit LP representation of z is possible due to the
polyhedrality of the convex hull of S̃ and well-established results for Lagrangian duality [cf. 55,
§II.3.6]. Also note that:
Observation 8 If Ci and Cj are redundant for all i ∈ I, j ∈ J, then z LAG2 = z pq .
It is not clear how to solve the LP for z LAG2 since a complete inequality description of conv(S̃ )
is unknown. Instead, one may have to resort to a subgradient algorithm that formulates the La-
grangian subproblem as a 0\1 MILP [6]. However it is worth noting we can Q possibly tighten the
lower bound z pq using any valid inequality for conv(S̃ ) that is not valid to l conv(Ql ).
A third Lagrangian relaxation can be obtained by dualizing only the consistency constraints
vilj = qil ylj ∀i, l, j and (20d) in PQ so that for the remaining constraints, neither are there any
product terms between q ’s and y ’s nor are q ’s and v ’s present in the same constraint (cf. equation
(21)). This allows us to follow standard duality arguments and use polyhedrality of the convex hull
of
Š = {(q, y, v, ξ ) : q·l ∈ ∆|Il | ∀l ∈ L, y ∈ F , (20a) − (20c)}. (29)
to express the lower bound corresponding to this Lagrangian dual as
z LAG3 = min{c̃> y : (q, y, v, ξ ) ∈ conv(Š ), (20d), ξilj = vilj ∀l ∈ L, i ∈ Il , j ∈ L ∪ J}. (30)
By construction, it follows that
z ∗ ≥ z LAG3 , and z ∗ ≥ z LAG2 ≥ z R3 ≥ z LAG1 = z pq . (31)
LAG3 LAG2 LAG1
There is no dominance relation between z and z or z since the third Lagrangian
dualizes vilj = qil ylj whereas the first two do not. In our computational experiments, we used
disjunctive formulations for the second and third Lagrangian relaxations to test the quality of the
lower bounds produced by z LAG2 and z LAG3 .
18 Gupte, Ahmed, Dey, Cheon

4 Variable Discretizations

The discretization strategies for the pooling problem can be broadly classified into two categories:
(i) restrict some of the variables appearing in the problem to take one amongst a finite set of
pre-specified values within their respective domains, or (ii) discretize the consistency requirements
at each pool in the network. The two strategies result in MILP approximations of the pooling
problem; the first strategy is applicable to any bilinear program whereas the second strategy, which
was proposed by Dey and Gupte [21], specifically exploits the structure of the pooling problem to
obtain a network flow MILP restriction. Other heuristics [3, 7, 9] for finding feasible solutions to the
pooling problem have been proposed in literature. In §5, we empirically compare the performance
of our variable discretizations against the feasible solutions obtained from other methods.
In this section, we focus on obtaining feasible solutions to the pooling problem by discretizing
some of its variables. We illustrate our approach in the context of a (possibly mixed integer) bilinear
program. Then we extend our ideas to the pooling problem by highlighting different choices for
selecting a variable to discretize. Our motivation for studying discretization methods is based on the
fact that MILP solvers are more mature in terms of branching strategies, cutting planes, heuristics
etc. than global optimization solvers and hence it is more likely that we can solve a MILP faster
than a BLP or MIBLP.

4.1 Overview

The general idea behind variable discretizations is as follows. Consider a bilinear program where
each bilinear term can be represented by the set defined in (17): W = {(x , y , ω ) : ω = xy , x ∈
[0, u x ], y ∈ [0, u y ]}. For the sake of simplicity, we assume the lower bounds on x and y to be zero
and u x to be a positive integer. Although we assumed that both x and y are continuous variables,
the presented ideas can be easily extended to the case when the original problem is a mixed
integer bilinear program and one or both x and y are integer variables. Now suppose that we
discretize y, i.e. restrict y to take only integer values within its bounds [0, u y ]. This produces
an approximation of W denoted by W y := {(x , y , ω ) ∈ W : y ∈ Z}. Substituting W y for every
occurrence of W produces a MIBLP approximation of the BLP. Note that for u y ≥ 2 we have
W y ( M(W y ) = conv(W y ) [cf. 33, Proposition 2.1], where M(W y ) represents the McCormick
relaxation of W y obtained using (15). There are various approaches for modeling the requirement
y ∈ {0, 1, . . . , u y } using additional 0\1 variables - two common methods are the unary and the binary
formulation. The former, denoted by U (W y ), adds u y + 1 0\1 variables whereas the latter, denoted
by B(W y ), adds only `(u y ) := blog2 u y c + 1 many 0\1 variables.

y y y
n u
X u
X u
X
y
U (W ) := (x , y , ω, ζ, ν ) : ω = rνr , y = rζr , ζr = 1, x ∈ [0, u x ],
r =0 r =0 r =0
o
(x , ζr , νr ) ∈ M({νr = x ζr }) ∀r, ζr ∈ {0, 1} ∀r
n `(u y ) `(u y ) `(u y )
X X X
B(W y ) := (x , y , ω, ζ, ν ) : ω = 2r−1 νr , y = 2r−1 ζr , 2r−1 ζr ≤ u y , x ∈ [0, u x ],
r =1 r =1 r =1
o
(x , ζr , νr ) ∈ M({νr = x ζr }) ∀r, ζr ∈ {0, 1} ∀r

In the above, M({ν Pr = x ζr }) denotes the McCormick relaxation (16) for νr = x ζr . Note that
ζr ∈ {0, 1}, ∀r and r ζr = 1 imply a SOS-1 constraint in U (W y ), which can be reformulated using
a logarithmic number of 0\1 variables and constraints as shown by [68]. This log unary formulation
L(W y ) may sometimes exhibit faster computational performance in a branch-and-bound algorithm.
The reformulation sizes of U (·), L(·), B(·) can be compared as follows: the number of 0\1 variables
is u y + 1, `(u y ), `(u y ), respectively; B(·) has the least number of continuous variables and constraints
whereas L(·) has the most of each. The LP relaxations of U (·) and B(·) were compared in [33]
and it was proven that in general, neither dominates the other. Substituting any one of U (W y ) or
B(W y ) for every occurrence of W y produces a MILP approximation of BLP. In a recent study [33],
facet-defining inequalities were proposed for B(W y ) and it was empirically shown that the binary
reformulation MILP is sometimes solved faster than the MIBLP corresponding to W y .
Relaxations and discretizations for the pooling problem 19

4.2 Application to the pooling problem

The variable discretization approach for obtaining feasible solutions to the pooling problem was
first studied in [57] wherein the authors presented the unary MILP model for discretizing the p
variables in P. Here we apply the discussion of the previous section and present a comprehensive
list of discretized versions of the P and PQ formulations (L(·) is not considered since it did not
present any significant benefits over B(·) in our computational experiments.). In PQ, each bilinear
term is of the form vilj = qil ylj and the corresponding set for this bilinear term is
PQ
Wilj := {(qil , ylj , vilj ) : vilj = qil ylj , qil ∈ [0, 1], ylj ∈ [0, ulj ]} l ∈ L, i ∈ Il , j ∈ L ∪ J.
We have two choices here: either discretize y = qil or y = ylj . Similarly, the set representing a single
bilinear term in P is
P
Wlkj := {(plk , ylj , wlkj ) : wlkj = plk ylj , plk ∈ [pmin max
lk , plk ], ylj ∈ [0, ulj ]} l ∈ L, k ∈ K, j ∈ L ∪ J,
and we may discretize either plk or ylj . We explain the discretized models for PQ and remark that
suitable counterparts are defined for P.
PQ PQ
The flow discretized feasible set, which is obtained by replacing Wilj with Wilj ∩ (<+ × Z × <+ )
for every l ∈ L, i ∈ Il , j ∈ L ∪ J , is denoted by FPQ and its binary MILP reformulation is B(FPQ).
Thus we only discretize the outgoing flows from each pool. Since the range [0, ulj ] of ylj is typically
of high order, we only consider the binary expansion of ylj in order to avoid adding too many
extra 0\1 variables. We assume that Cl and ulj are integers, for all l ∈ L, j ∈ L ∪ J , otherwise they
can be replaced with bCl c and bulj c, respectively. In case of the ratio variables, although the qil ’s
can be discretized into different intervals, for the ease of exposition, we assume that they all are
uniformly discretized into n ≥ 1 intervals of equal length within [0, 1]. Unlike the flow discretization
where restricting the ylj ’s to integer values within their respective bounds seemed like a reasonable
method, in this case there is no clear intuition behind a suitable choice of n. In our computations, we
will experiment with different values of n. Given a positive integer n, for every l ∈ L, i ∈ Il , j ∈ L∪J ,
we have (note the dependence on n)
{(qil , ylj , vilj ) : vilj = qil ylj , nqil ∈ [0, n] ∩ Z, ylj ∈ [0, ulj ]}
PQ PQ
as the ratio discretization of Wilj . Substituting Wilj with the above set for each i, l, j gives us
RPQn and its MILP reformulations U (RPQn ) and B(RPQn ).

4.2.1 Flow discretization

We derive some valid inequalities for B(FPQ) by exploiting the fact that FPQ does not discretize
the ratio variables and hence the domain of q·l is still a simplex ∆|Il | . Recall the sets Ql and Yl
from §3.2.1 and denote

FQl := (q·l , yl· , v·l· ) ∈ Ql : ylj ∈ Z ∀j ∈ L ∪ J}
as the flow discretized counterpart of Ql . From Theorem 1 and integrality of the polytope {yl· ∈
Yl : ylj ∈ Z ∀j ∈ L ∪ J}, it follows that conv(FQl ) = conv(Ql ). The convex hull of B(FQl ) though
is nontrivial. An explicit description of all the facets of conv(B(Yl )), where
 
 X `(X ulj ) `(ulj )
X 
B(Yl ) := ζ·l· : 2r−1 ζrlj ≤ Cl , 2r−1 ζrlj ≤ ulj ∀j ∈ L ∪ J, ζrlj ∈ {0, 1} ∀r, j ,
 
j∈L∪J r =1 r =1

and Theorem 1 would imply the convex hull of B(FQl ). However, the convex hull of B(Yl ) in the
ζ -space is unknown in general. We use suitable relaxations of this set to derive valid inequalities
for B(F Ql ).
Proposition 7 For every l ∈ L, j ∈ L ∪ J, let Tlj be a subset of {1, 2, . . . , `(ulj )} such that ulj =
P r−1
r∈Tlj 2 . Then for every l ∈ L, we have conv(B(FQl )) ⊆ Tl where

n `(ulj ) `(ulj )
X X
Tl := (q·l , yl· , v·l· , ζ·l· , ν·l· ) : q·l ∈ ∆|Il | , ylj = 2r−1 ζrlj ∀j, vilj = 2r−1 νrilj ∀i, j
r =1 r =1
X
0 ≤ νrilj ≤ qil ∀i, j, r, νirlj = ζrlj ∀j, r
i∈Il
0 0
X o
νrilj + νr0 ilj ≤ |{r ∈ Tlj : r > r}| qil ∀i ∈ Il , r ∈
/ Tlj .
r 0 ∈Tlj : r 0 >r
20 Gupte, Ahmed, Dey, Cheon

P
Furthermore if j ulj ≤ Cl then conv(B(FQl )) = Tl .
P Q
Proof Dropping the capacity constraint j ylj ≤ Cl from Yl gives us Yl ⊆ j [0, ulj ] and hence
Q P`(ulj ) r−1
B ( Yl ) ⊆ j B ([0, ulj ]) where B ([0, ulj ]) := {ζ·lj : r =1 2 ζrlj ≤ ulj , ζrlj ∈ {0, 1} ∀r}. Define
Tlj := {(q·l , ylj , v·lj ) : q·l ∈ ∆|Il | , ylj ∈ [0, ulj ] ∩ Z, vilj = qil ylj ∀i ∈ Il } for all l ∈ L, j ∈ L ∪ J . Clearly,
e
F Ql ⊆ ∩j Telj and hence conv(B(FQl )) ⊆ conv(∩j B(Telj )).
The nontrivial facets of B([0, ulj ]) are given in [31, 33] and are known to be the minimal cover
P 0 0
inequalities ζrlj + r0 ∈Tlj : r0 >r ζr0 lj ≤ |{r ∈ Tlj : r > r}| for all r ∈ {1, . . . , `(ulj )} \ Tlj . Theorem 1
then implies that the convex hull of B(Telj ) is equal to its level-1 RLT relaxation. Using conv(B(Telj ))
for all j and applying Corollary 1 to ∩j B(Telj ) leads to conv(∩j B(Telj )) = ∩j RLT1(B(Telj )), and the
latter is exactly the proposed relaxation Tl . Finally, if the value of Cl is trivial, then it follows from
our derivation of Tl that conv(B(FQl )) is equal to Tl . u
t

The relaxation in Proposition 7 can be strengthened using the following family of valid inequal-
ities that take into account the pool capacity constraint.

Proposition 8 Denote βl := maxj `(ulj ). The inequality

βl  
X X Cl
2r−t νrilj ≤ qil
2t−1
r =t j : r≤`(ulj )

is valid to conv(B(FQl )) for all i ∈ Il and t = 1, 2, . . . , βl .

P P`(ulj )
Proof The capacity constraint j r =1 2r−1 ζrlj ≤ Cl can be rearranged to

βl
X X
2r−1 ζrlj ≤ Cl . (34)
r =1 j : r≤`(ulj )

(34) represents a divisible knapsack βr=1

P l r−1 0
Inequality 2 ζr ≤ Cl upon the variable substitution
ζr0 = j ζrlj . Marcotte [47] presents the convex hull of such divisible knapsacks using βl rounding
P
inequalities:
βl  r−1   
X 2 0 Cl
ζ ≤ ∀t = 1, 2, . . . , βl .
2t−1 r 2t−1
r =1

Back substituting for ζr0 gives us valid inequalities for (34) (but not the convex hull since we relaxed
the bound ζr0 ≤ |{j : r ≤ `(ulj )}|). A subsequent application of Theorem 1 with the simplex ∆|Il |
yields the proposed inequalities. u
t

5 Computational Experiments

In this section we report computational results on several test instances of the pooling problem.
The general approach is to solve the original pooling problem using a state-of-the-art global solver
and compare the lower and upper bounds after a specified time limit with the lower bounds from §3
and upper bounds from §4. In our experiments, we do not implement our discretization strategies
as part of a heuristic in solving the pooling problem. We simply want to determine which discretiza-
tion strategy empirically seems to work best on the pooling problem. Once we have a good enough
understanding of a suitable set of variables to discretize, then we can possibly use dynamic dis-
cretization, by iteratively refining the level of discretization, as a heuristic in a branch-and-bound
algorithm. We leave this work for future research; see Kolodziej et al. [41] for one computational
study of dynamically updating base-10 discretizations of mixed integer variants of the pooling
problem.
For flow discretization, we discretized ylj within its bounds [0, ulj ] for all l ∈ L, j ∈ L ∪ J and
considered only the binary reformulation MILP B(·). Ratio and spec discretizations were tested
for n ∈ {1, 2, 4, 7, 15, 31}. Clearly as n increases, there is a tradeoff between finding good feasible
solutions versus being unable to solve the model to optimality due to its large size. In our preliminary
computations, we did not observe any significant benefit with the L(·) model. Based on the relative
performance of the MILPs, we report U (·) for n ∈ {1, 2, 4}, whereas for n ∈ {7, 15, 31}, we report
B(·).
Relaxations and discretizations for the pooling problem 21

We used CPLEX 12.6 as the LP and MILP solver and BARON 13.1 as the BLP and MIBLP
solver. We used SNOPT 7.2 as the NLP solver with BARON. BARON was run with a time limit of 6
hours on the NEOS server whereas CPLEX was run with a time limit of 1 hour on a Linux machine
having a 64-bit x86 processor and 32GB of RAM. Since BARON is a branch-and-cut based global
solver whose algorithm finds feasible solutions among many other things, such as tight bounds via
node relaxations, variable bounding tightening, branching decisions etc., it is impossible to know
exactly how much time was spent by BARON in finding feasible solutions. Hence, for the sake of
fair comparison, we gave BARON a much longer time limit. To ensure numerical consistency between
BARON and CPLEX, we used the following algorithmic parameters: feasibility tolerance = 10−6 ,
integrality tolerance = 10−5 , relative optimality gap = 0.01%, and absolute optimality gap
= 10−3 . For CPLEX, we also set Threads = 1 and MIPEmphasis = 1 (feasibility). The MIPEmphasis
parameter is used to aid CPLEX in finding good feasible solutions at the expense of proof of optimality.
We do not know of a similar parameter for BARON. Valid inequalities of §4.2.1 were added as user
cuts to CPLEX.

Test instances. The pooling instances commonly used in literature mostly comprise the small-scale
problems proposed many years ago [1, 13, 36]. Since these problems are solved in a matter of seconds
by BARON, they are not of particular interest to us and are only used for demonstrating the strength
of the Lagrangian relaxations in §5.1. Also, we test more extensively on the standard problem than
the generalized problem since the former already seems to be a computationally hard problem to
solve. We test on 70 randomly generated medium- to large-scale instances of the standard pooling
problem - 20 of these were created in [5] and are labeled std* and the remaining 50 were created
in [21] and are labeled randstd*. There are 10 generalized pooling instances2 in our test set - 3 of
these were used in [49] and we randomly generated 7 instances of the time indexed pooling problem
described in §2.4.1. All 10 are formulated
P as MIBLPs. P In the instances
 ofP[49], the spec tracking
constraints (4a) are formulated as ηlk λ y
i∈I ik il + 0 p 0 y
l ∈L l k l l0 = p lk j∈L∪J ylj where ηlk is
an absorption coefficient of spec k at pool l. Hence, to write the PQ formulation of this problem, we
τ τ
need to define ratio variables qil along each path τ such that qil denotes the ratio of incoming flow
to l along path τ starting from input i. This makes the formulation extremely large in size due to its
path dependency. Similar reasoning prevails for the time-indexed pooling problems. Indeed while
experimenting on the generalized instances, the PQ formulation and its corresponding relaxations
and discretizations exhibited a poor performance owing to their extremely large size. Hence we
consider the P formulation for the 10 generalized instances.

5.1 Results for relaxations

As expected from Proposition 4, the lower bound from PQ is far superior than that due to P .
First, we tested the two new Lagrangian relaxations proposed in §3.4. Since our goal is to simply
test the quality of these lower bounds, we formulated an exponential-sized LP for each of these
Lagrangians instead of obtaining the lower bounds using an iterative method such as the subgradient
algorithm. These LP formulations arise from disjunctive programming after observing that conv(S̃ )
and conv(Š ) can each be written as the convex hull of the union of finitely many polytopes, where
each polytope is obtained by fixing q to an extreme point of l∈L ∆|Il | . Hence each LP has O(|I||L| )
Q
many variables, which means that we can computationally test these disjunctive representations for
only small-scale instances. Table 2 reports the performance of z LAG3; we observed  that z
LAG2
was
LAG3 pq
pq LAG3 z −z
always equal to z . Here the % gap closed by z is equal to 100 × z ∗ −z pq . We note that our
third Lagrangian relaxation provides a significant improvement over PQ on most of the instances.
Hence we expect that it will perform quite well in practice, if some strong valid inequalities for
conv(Š ) can be separated in polynomial time. For RT2, we have z LAG3 < z pq which can happen as
mentioned towards the end of §3.4.
For the medium- and large-scaled standard instances, we tested the three RLT relaxations –
R1 , R2 , R3 , that were proposed in §3.3. R1 did not improve upon the lower bound of PQ (quite
possibly due to the fact that on these instances, the variable bounds uil ’s are mostly dominated by
the capacity constraints) whereas R3 was too large in size and did not work well in practice. R2
did increase the lower bound on some of the instances as noted below, but also took considerably
longer to solve owing to its large size. Table 3 reports these lower bounds, the % gap closed by
them and the amount of CPU time in comparison to the pq -relaxation. To compute % gap closed,
2 Some generalized instances can also be found in [4] but in our experience the pq-formulations of these instances

were solved by BARON in less than 15 minutes and hence seem to be relatively ease.
22 Gupte, Ahmed, Dey, Cheon

# z pq z LAG3 % gap closed

to z ∗
Haverly1 -500 -400 100
Haverly2 -1000 -600 100
Haverly3 -800 -793.75 12.50
BenTal4 -550 -450 100
Bental5 -3500 -3500 -
Adhya1 -840.27 -688.56 52.23
Adhya2 -574.78 -565.85 35.74
Adhya3 -574.78 -568.55 45.38
Adhya4 -961.93 -900.62 72.75
RT2 -6030.34 -6691.88 -

Table 2 Lower bounds from Lagrangian relaxation.

we use the best-known upper bound on z ∗ (including results of next section) in case z ∗ itself is
unknown.

# PQ R2 % gap closed
z pq Time (sec.) z R2 Time (sec.) to z ∗
stdA0 -37772.75 0.19 -37760.08 0.20 0.65
stdA1 -31516.93 0.11 -31503.61 0.14 0.59
stdA2 -23898.81 0.25 -23884.36 0.38 1.69
stdA3 -42066.64 0.22 -42027.12 1 1.50
randstd12 -58120.52 2 -57970.40 57 24.73
randstd16 -65639.73 4 -65517.76 16 19.01
randstd25 -75952.80 17 -75918.04 31 2.91
randstd27 -57084.07 7 -56994.45 38 5.62
randstd31 -104796.77 15 -104773.07 39 1.68
randstd32 -98374.73 15 -98249.31 110 7.77
randstd37 -94255.66 35 -93903.92 54 16.40
randstd41 -89315.91 10 -89276.38 860 0.63
randstd42 -99160.20 11 -98997.69 1089 2.03
randstd43 -108040.19 15 -107567.58 329 10.57
randstd47 -108611.61 16 -108512.79 912 1.63
randstd50 -143113.27 2 -142725.99 924 5.28
randstd54 -88157.35 15 -87767.20 510 36.82
randstd59 -159035.34 3 -159000.87 401 1.63

Table 3 Lower bounds from RLT relaxation.

5.2 Results for discretizations

We first compare the quality of the best feasible solution from discretization against those obtained
from global solve with BARON (for 6hr), local solve with SNOPT (for 1hr) and the flow augmentation
heuristic of Alfaki and Haugland [3]. This gives us an estimate of how well discretization methods
might perform if implemented as a heuristic in a branch-and-cut algorithm. For each instance I
(I )
and method M , we report the percentage gap calculated as ωM (I ) = 100 ×|1 − νM `(I ) |, where `(I )
is the lower bound obtained from BARON (after 6hr) and νM (I ) is the upper bound returned upon
termination of M . We observed that on standard instances, the performance of PQ formulation,
for both discretized and non-discretized models, was far superior than that of P3 . However for
the generalized instances, this dominance did not hold. Accordingly, the results are summarized
in Tables 4 and 5. In Table 5, a † indicates that only a finite upper bound was returned by the
solver without finding a feasible solution whereas − means that neither any feasible solution nor
any finite upper bound was found within the time limit. If a method produces a feasible solution
that is provably optimal, i.e. has 0.01% gap, then the total solution time in seconds for this method
is noted in parenthesis.
3 Amongst the various choices for discretizing P, flow discretization was by far the best choice but the solutions

from solving B(FP) were still very poor in comparison to discretizing PQ.
Relaxations and discretizations for the pooling problem 23

In Table 4, discretization of PQ provided better solutions than solving PQ itself mostly for the
large-scale instances. There does not seem to be an obvious candidate for a good discretization
model. Note that U (RPQ1 ) imposes the restriction that there is no mixing at pools. Hence if these
MILPs yielded good solutions, then it may well be an artifact of the specific instance and may
not work well in general. For the generalized instances (Table 5), the spec and ratio discretizations
were mostly either provably infeasible or unable to find a solution within 1 hour. The P formulation
and its discretizations performed better than its PQ counterparts for our randomly generated Inst*
instances. This is perhaps to be expected because the pq -formulation of these time indexed problems
is much larger in size than the p-formulation, as explained in § 2.4.1. B(FP) was able to find good
quality feasible solutions in a shorter time on 5 out of 7 of these instances. BARON was unable to
find feasible solutions while solving P or PQ in 5 instances (markd with a † ). However we note that
on Inst6 and Inst7, none of our discretization models yielded a feasible solution nor did CPLEX
return any finite upper bound. On the meyer* instances, solving P with BARON outperformed all
discretization approaches.

# Best of BARON, Best discretization # Best of BARON, Best discretization

SNOPT, [3] of PQ SNOPT, [3] of PQ
% gap % gap MILP % gap % gap MILP
stdA0 0.60 0.69 B(FPQ) randstd26 0.00 0.08 B(RPQ15 )
stdA1 2.72 2.74 B(FPQ) randstd27 4.69 1.62 B(FPQ)
stdA2 0.00 0.03 B(FPQ) randstd28 0.08 0.51 B(RPQ7 )
stdA3 0.96 0.64 B(FPQ) randstd29 1.30 1.59 B(FPQ)
stdA4 3.44 4.22 B(FPQ) randstd30 5.73 0.79 B(RPQ31 )
stdA5 1.26 2.39 B(RPQ15 ) randstd31 2.26 1.62 B(FPQ)
stdA6 0.67 1.01 B(FPQ) randstd32 13.00 2.75 B(RPQ7 )
stdA7 0.73 1.08 B(RPQ15 ) randstd33 2.85 2.99 B(FPQ)
stdA8 0.32 0.20 B(FPQ) randstd34 2.33 1.59 B(FPQ)
stdA9 0.00 0.13 B(FPQ) randstd35 1.53 1.67 B(FPQ)
stdB0 6.08 6.29 B(RPQ15 ) randstd36 0.26 0.34 B(RPQ15 )
stdB1 3.19 4.00 B(RPQ7 ) randstd37 2.10 2.30 B(RPQ7 )
stdB2 3.94 4.75 B(RPQ2 ) randstd38 8.71 3.86 B(FPQ)
stdB3 5.18 0.72 B(RPQ1 ) randstd39 15.00 2.45 B(RPQ7 )
stdB4 0.10 0.11 B(RPQ2 ) randstd40 13.00 10.00 B(RPQ15 )
stdB5 0.62 1.19 B(RPQ1 ) randstd41 15.00 13.00 B(FPQ)
stdC0 29.00 20.00 B(RPQ7 ) randstd42 22.00 16.00 B(RPQ1 )
stdC1 40.00 22.00 B(RPQ1 ) randstd43 22.00 24.00 B(RPQ7 )
stdC2 31.00 13.00 B(RPQ1 ) randstd44 6.25 6.00 B(RPQ15 )
stdC3 18.00 6.25 B(RPQ1 ) randstd45 9.40 2.83 B(RPQ1 )
randstd11 13.00 13.00 B(FPQ) randstd46 22.00 33.00 B(RPQ7 )
randstd12 0.58 2.26 B(FPQ) randstd47 34.00 25.00 B(RPQ7 )
randstd13 1.56 2.51 B(FPQ) randstd48 15.00 15.00 B(RPQ1 )
randstd14 0.23 0.36 B(RPQ15 ) randstd49 40.00 28.00 B(RPQ1 )
randstd15 0.57 2.41 B(RPQ15 ) randstd50 18.00 36.00 B(RPQ15 )
randstd16 0.12 0.14 B(FPQ) randstd51 13.00 6.21 B(RPQ1 )
randstd17 1.19 1.30 B(RPQ7 ) randstd52 5.45 13.00 B(RPQ7 )
randstd18 0.78 1.23 B(FPQ) randstd53 7.04 5.73 B(RPQ7 )
randstd19 0.56 10.00 B(FPQ) randstd54 1.96 1.28 B(RPQ7 )
randstd20 0.12 0.19 B(FPQ) randstd55 6.49 18.00 B(RPQ1 )
randstd21 3.94 4.00 B(FPQ) randstd56 5.57 2.17 B(FPQ)
randstd22 0.01 0.04 B(RPQ31 ) randstd57 24.00 9.51 B(FPQ)
randstd23 1.64 2.96 B(RPQ7 ) randstd58 4.89 3.82 B(FPQ)
randstd24 0.12 0.76 B(FPQ) randstd59 12.00 3.07 B(FPQ)
randstd25 0.88 2.35 B(RPQ7 ) randstd60 11.00 4.47 B(FPQ)

Table 4 Discretizations for standard pooling problems. % gap of best feasible solution and corresponding MILP
model for PQ formulation of each instance.

Tables 4 and 5 do not provide any a priori information on which discretization to choose given
a new instance, especially if the new instance is of the standard type where there does not seem
to be a overwhelmingly best model. To compare the overall quality of the solutions returned by
the different discretizations of standard instances, we plot performance profiles for the different
MILPs in Figure 3. We see that B(RPQ7 ) provides the most dominant profile followed by B(FPQ).
Although BARON produces best solutions on most number of instances (recall that global solve was
given 6 hours), its performance quickly deteriorates because it gives poor solutions on the large-scale
standard instances.
24 Gupte, Ahmed, Dey, Cheon

# P Best discretization of P PQ Best discretization of PQ

% gap % gap MILP % gap % gap MILP
meyer4 0.01 (6562) 2.38 B(FP) Not applicable
meyer10 26.02 68.76 B(FP) Not applicable
meyer15 36.52 51.68 B(FP) Not applicable
Inst1 969.20† 9.68 B(FP) 969.20† 9.68 B(FPQ)
Inst2 1242.26† 0.17 B(FP) 1242.26† 3.14 B(RPQ7 )
Inst3 0.01 (7585) 0.01 (35) B(FP) 9.33 0.01 (110) B(FPQ)
Inst4 0.01 (21594) 0.01 (149) B(FP) 0.76 0.01 (817) B(FPQ)
Inst5 462.58† 13.98 B(FP) 462.58† − −
Inst6 391.14† − − 391.14† − −
Inst7 382.82† − − 382.82† − −

Table 5 Discretizations for generalized pooling problems. % gap of best feasible solution and corresponding
MILP model for each instance.

0.8

0.6

0.4

Flow n=1 n=2

n=4 n=7 n = 15
0.2
n = 31 BARON SNOPT
Alfaki-Haugland

0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

Fig. 3 Performance profiles of the best feasible solutions for the standard instances. Only most significant dis-
cretization models shown; values of n denote discretization level for RPQn .

Next, we analyze the relative effort with which CPLEX is able to find feasible solutions of the
different MILPs. We focus on the standard instances since on generalized instances, ratio and
spec discretizations did not perform very well. Since we provided a starting solution y = 0, CPLEX
was able to obtain a improved feasible solution after spending a small time solving its root node
heuristic. Hence the first nontrivial solution was found by CPLEX normally within a few seconds.
For each discretization, Table 6 presents the geometric average of the % gap ωM (I ) for the best
solution versus the geometric average of the CPU time at which CPLEX found this best solution.
A good discretization model will be one that produces solutions with smallest % gap in shortest
amount of time. First observe that the solutions from the discretization of P formulations are found

Discretization Time (sec.) Gap (%) Discretization Time (sec.) Gap (%)
B(FPQ) 511 3.29 B(FP) 7.27 57.23
U (RPQ1 ) 161 4.37 U (SP1 ) 0.51 69.54
U (RPQ2 ) 902 4.30 U (SP2 ) 0.83 69.54
U (RPQ4 ) 965 5.57 U (SP4 ) 1.19 69.54
B(RPQ7 ) 1462 3.42 B(SP7 ) 1.02 69.54
B(RPQ15 ) 1202 4.83 B(SP15 ) 2.53 68.00
B(RPQ31 ) 1411 4.26 B(SP31 ) 1.25 69.54

Table 6 Geometric averages for optimality gap of best solution and time at which the solution was found.
Relaxations and discretizations for the pooling problem 25

very quickly but CPLEX is unable to improve upon them and hence the MILP solutions for P are
extremely poor in quality, as was mentioned before. For PQ, U (RPQ1 ) provides good solutions
very quickly. Since U (RPQ1 ) discretizes each qil ∈ {0, 1}, the short time required for finding these
solutions is perhaps to be expected. However, it is surprising that such a naive discretization gives
fairly good solutions on random instances. The next best MILP in terms of finding solutions quickly
is B(FPQ) and this model also produces the best quality solutions on average (albeit B(RPQ7 ) is a
close second).
Finally, we remark that an alternate discretization strategy, which does not depend on explicitly
discretizing the variables in the pooling problem, was analytically studied by Dey and Gupte [21]
recently and these MILP approximations produced very good feasible solutions on the 70 standard
test instances. Our discretization approaches improve the previous best known upper bounds [21,
Appendix D] on 6 out of these 70 instances, as noted in Table 7.

# Lower Bound Upper Bound

BARON Previous Best [21] New Discretization
stdA3 -39681.80 -39301.98 -39429.60 B(FPQ)
stdA8 -30666.87 -30569.03 -30604.28 B(FPQ)
randstd27 -56406.56 -55213.20 -55490.76 B(FPQ)
randstd30 -81110.45 -78505.72 -80472.19 B(RPQ31 )
randstd34 -90621.44 -88506.19 -89178.30 B(FPQ)
randstd51 -137423.00 -126741.65 -128894.46 U (RPQ1 )

Table 7 Improved upper bounds.

6 Conclusions

In this work, we first described the pooling problem, presented alternate formulations for it along
with their properties, and gave some new results on the various polyhedral relaxations for this
problem. We discussed different discretization methods to obtain inner approximations and pre-
sented some valid inequalities for the MILPs. These ideas were computationally tested on random
instances. On the lower bounding side, the Lagrangian relaxations seem to be more promising
than the RLT relaxations; however there still remains the significant hurdle of obtaining tractable
polyhedral formulations or separation algorithms for the former. Many of our discretization models
were able to find good quality feasible solutions in a relatively short amount of time. One can
possibly further improve the performance of these discretizations by fine tuning the heuristics in a
MILP solver or by using dynamic discretization strategies. Our experiments suggest that discretiza-
tion seems to be a promising approach especially for large-scale standard or generalized pooling
problems.

References

1. Adhya, N., Tawarmalani, M., Sahinidis, N.: A Lagrangian approach to the pooling problem.
Industrial and Engineering Chemistry Research 38(5), 1956–1972 (1999)
2. Al-Khayyal, F., Falk, J.: Jointly constrained biconvex programming. Mathematics of Opera-
tions Research 8(2), 273–286 (1983)
3. Alfaki, M., Haugland, D.: A cost minimization heuristic for the pooling problem. Annals of
Operations Research pp. 1–15 (2013). DOI 10.1007/s10479-013-1433-1
4. Alfaki, M., Haugland, D.: A multi-commodity flow formulation for the generalized pooling
problem. Journal of Global Optimization 56(3), 917–937 (2013)
5. Alfaki, M., Haugland, D.: Strong formulations for the pooling problem. Journal of Global
Optimization 56(3), 897–916 (2013)
6. Almutairi, H., Elhedhli, S.: A new Lagrangean approach to the pooling problem. Journal of
Global Optimization 45(2), 237–257 (2009)
7. Audet, C., Brimberg, J., Hansen, P., Le Digabel, S., Mladenović, N.: Pooling problem: Alternate
formulations and solution methods. Management Science 50(6), 761–776 (2004)
8. Audet, C., Hansen, P., Jaumard, B., Savard, G.: A symmetrical linear maxmin approach to
disjoint bilinear programming. Mathematical Programming 85(3), 573–592 (1999)
26 Gupte, Ahmed, Dey, Cheon

9. Baker, T., Lasdon, L.: Successive linear programming at Exxon. Management Science pp.
264–274 (1985)
10. Bao, X., Sahinidis, N., Tawarmalani, M.: Multiterm polyhedral relaxations for nonconvex,
quadratically constrained quadratic programs. Optimization Methods and Software, 24 4(5),
485–504 (2009)
11. Bao, X., Sahinidis, N., Tawarmalani, M.: Semidefinite relaxations for quadratically constrained
quadratic programming: A review and comparisons. Mathematical Programming 129(1), 129–
157 (2011)
12. Belotti, P., Kirches, C., Leyffer, S., Linderoth, J., Luedtke, J., Mahajan, A.: Mixed-integer
nonlinear optimization. Acta Numerica 22, 1–131 (2013). DOI 10.1017/S0962492913000032
13. Ben-Tal, A., Eiger, G., Gershovitz, V.: Global minimization by reducing the duality gap. Math-
ematical Programming 63(1), 193–212 (1994)
14. Biegler, L., Grossmann, I., Westerberg, A.: Systematic methods for chemical process design.
International Series in the Physical and Chemical Engineering Sciences. Prentice Hall (1997)
15. Bley, A., Boland, N., Froyland, G., Zuckerberg, M.: Solving mixed integer nonlinear pro-
gramming problems for mine production planning with stockpiling (2012). Preprint at
http://www.optimization-online.org/DB_HTML/2012/11/3674.html
16. Bodington, C., Baker, T.: A history of mathematical programming in the petroleum industry.
Interfaces 20(4), 117–127 (1990)
17. Burer, S., Letchford, A.N.: Non-convex mixed-integer nonlinear programming: a survey. Surveys
in Operations Research and Management Science 17(2), 97–106 (2012)
18. Burer, S., Saxena, A.: The MILP road to MIQCP. In: Lee, J., Leyffer, S. (eds.) Mixed Integer
Nonlinear Programming, IMA Volumes in Mathematics and its Applications, vol. 154, pp. 373–
405. Springer (2012)
19. Crama, Y.: Concave extensions for nonlinear 0–1 maximization problems. Mathematical Pro-
gramming 61(1-3), 53–60 (1993)
20. D’Ambrosio, C., Linderoth, J., Luedtke, J.: Valid inequalities for the pooling problem with
binary variables. In: Günlük, O., Woeginger, G. (eds.) Integer Programming and Combinatorial
Optimization, Lecture Notes in Computer Science, vol. 6655, pp. 117–129. Springer (2011)
21. Dey, S., Gupte, A.: Analysis of MILP techniques for the pooling problem. Operations Research
to appear (2015). Preprint at http://people.clemson.edu/~agupte/PoolingApproxIP.pdf
22. Floudas, C., Aggarwal, A.: A decomposition strategy for global optimum search in the pooling
problem. ORSA Journal on Computing 2(3), 225–235 (1990)
23. Foulds, L., Haugland, D., Jörnsten, K.: A bilinear approach to the pooling problem. Optimiza-
tion 24(1), 165–180 (1992)
24. Frimannslund, L., El Ghami, M., Alfaki, M., Haugland, D.: Solving the pooling problem with
lmi relaxations. In: TOGO10 – GLOBAL OPTIMIZATION WORKSHOP, pp. 51–54 (2010)
25. Frimannslund, L., Gundersen, G., Haugland, D.: Sensitivity analysis applied to the pooling
problem. Tech. Rep. 380, University of Bergen (2008)
26. Furman, K., Androulakis, I.: A novel MINLP-based representation of the original complex
model for predicting gasoline emissions. Computers & Chemical Engineering 32(12), 2857–
2876 (2008)
27. Gounaris, C., Misener, R., Floudas, C.: Computational comparison of piecewise-linear relax-
ations for pooling problems. Industrial & Engineering Chemistry Research 48(12), 5742–5766
(2009)
28. Greenberg, H.: Analyzing the pooling problem. ORSA Journal on Computing 7(2), 205–217
(1995)
29. Günlük, O., Lee, J., Leung, J.: A polytope for a product of real linear functions in 0/1 vari-
ables. In: Lee, J., Leyffer, S. (eds.) Mixed Integer Nonlinear Programming, IMA Volumes in
Mathematics and its Applications, vol. 154, pp. 513–529. Springer (2012)
30. Gupte, A.: Mixed integer bilinear programming with applications to the pooling problem. Ph.D.
thesis, Georgia Institute of Technology, Atlanta, GA (2012). URL https://smartech.gatech.
edu/handle/1853/45761
31. Gupte, A.: Convex hull of superincreasing knapsacks and lexicographic orderings (2013). under
review, Preprint at Optimization Online and arXiv
32. Gupte, A.: Bilinear programming with simplicial constraints (2015). URL http://people.
clemson.edu/~agupte/BilinSimpl.pdf. Working paper
33. Gupte, A., Ahmed, S., Cheon, M., Dey, S.: Solving mixed integer bilinear problems using MILP
formulations. SIAM Journal on Optimization 23(2), 721–744 (2013)
34. Hasan, M., Karimi, I.: Piecewise linear relaxation of bilinear programs using bivariate parti-
tioning. AIChE Journal 56(7), 1880–1893 (2010)
Relaxations and discretizations for the pooling problem 27

35. Haugland, D.: The hardness of the pooling problem. In: Casado, L., Garcı́a, I., Hendrix, E.
(eds.) Proceedings of the XII GLOBAL OPTIMIZATION WORKSHOP: Mathematical and
Applied Global Optimization (MAGO), pp. 29–32. Malaga (2014)
36. Haverly, C.: Studies of the behavior of recursion for the pooling problem. ACM SIGMAP
Bulletin 25, 19–28 (1978)
37. Kallrath, J.: Solving planning and design problems in the process industry using mixed integer
and global optimization. Annals of Operations Research 140(1), 339–373 (2005)
38. Karuppiah, R., Furman, K., Grossmann, I.: Global optimization for scheduling refinery crude
oil operations. Computers & Chemical Engineering 32(11), 2745–2766 (2008)
39. Karuppiah, R., Grossmann, I.: Global optimization for the synthesis of integrated water systems
in chemical processes. Computers and Chemical Engineering 30(4), 650–673 (2006)
40. Kim, S., Kojima, M.: Second order cone programming relaxation of nonconvex quadratic opti-
mization problems. Optimization Methods and Software 15(3-4), 201–224 (2001)
41. Kolodziej, S.P., Grossmann, I.E., Furman, K.C., Sawaya, N.W.: A discretization-based ap-
proach for the optimization of the multiperiod blend scheduling problem. Computers & Chem-
ical Engineering 53, 122–142 (2013)
42. Lee, S., Grossmann, I.: Global optimization of nonlinear generalized disjunctive programming
with bilinear equality constraints: applications to process networks. Computers & chemical
engineering 27(11), 1557–1575 (2003)
43. Li, X., Armagan, E., Tomasgard, A., Barton, P.I.: Stochastic pooling problem for natural gas
production network design and operation under uncertainty. AIChE Journal 57(8), 2120–2135
(2011)
44. Li, X., Tomasgard, A., Barton, P.I.: Decomposition strategy for the stochastic pooling problem.
Journal of Global Optimization 54(4), 765–790 (2012)
45. Liberti, L., Pantelides, C.: An exact reformulation algorithm for large nonconvex NLPs involv-
ing bilinear terms. Journal of Global Optimization 36(2), 161–189 (2006)
46. Luedtke, J., Namazifar, M., Linderoth, J.: Some results on the strength of relaxations of mul-
tilinear functions. Mathematical Programming 136(2), 325–351 (2012)
47. Marcotte, O.: The cutting stock problem and integer rounding. Mathematical Programming
33(1), 82–92 (1985)
48. McCormick, G.: Computability of global solutions to factorable nonconvex programs: Part I.
convex underestimating problems. Mathematical Programming 10(1), 147–175 (1976)
49. Meyer, C., Floudas, C.: Global optimization of a combinatorially complex generalized pooling
problem. AIChE journal 52(3), 1027–1037 (2006)
50. Misener, R., Floudas, C.: Advances for the pooling problem: Modeling, global optimization,
and computational studies. Appl. Comput. Math 8(1), 3–22 (2009)
51. Misener, R., Floudas, C.: Global optimization of large-scale generalized pooling problems:
Quadratically constrained MINLP models. Industrial & Engineering Chemistry Research
49(11), 5424–5438 (2010)
52. Misener, R., Gounaris, C., Floudas, C.: Mathematical modeling and global optimization of
large-scale extended pooling problems with the (EPA) complex emissions constraints. Com-
puters & Chemical Engineering 34(9), 1432–1456 (2010)
53. Misener, R., Smadbeck, J.B., Floudas, C.A.: Dynamically generated cutting planes for mixed-
integer quadratically constrained quadratic programs and their incorporation into GloMIQO
2. Optimization Methods and Software 30(1), 215–249 (2015)
54. Misener, R., Thompson, J., Floudas, C.: APOGEE: Global optimization of standard, general-
ized, and extended pooling problems via linear and logarithmic partitioning schemes. Comput-
ers & Chemical Engineering 35, 876–892 (2011)
55. Nemhauser, G., Wolsey, L.: Integer and combinatorial optimization, Discrete Mathematics and
Optimization, vol. 18. Wiley-Interscience (1988)
56. Nishi, T.: A semidefinite programming relaxation approach for the pooling problem. Master’s
thesis, Department of Applied Mathematics and Physics, Kyoto University (2010). URL http:
//www-optima.amp.i.kyoto-u.ac.jp/result/masterdoc/21nishi.pdf
57. Pham, V., Laird, C., El-Halwagi, M.: Convex hull discretization approach to the global opti-
mization of pooling problems. Industrial and Engineering Chemistry Research 48(4), 1973–1979
(2009)
58. Quesada, I., Grossmann, I.: Global optimization of bilinear process networks with multicom-
ponent flows. Computers and Chemical Engineering 19(12), 1219–1242 (1995)
59. Realff, M., Ahmed, S., Inacio, H., Norwood, K.: Heuristics and upper bounds for a pooling prob-
lem with cubic constraints. In: Foundations of Computer-Aided Process Operations. Savannah,
GA (2012). URL http://focapo.cheme.cmu.edu/2012/proceedings/data/papers/056.pdf
28 Gupte, Ahmed, Dey, Cheon

60. Rikun, A.: A convex envelope formula for multilinear functions. Journal of Global Optimization
10(4), 425–437 (1997)
61. Ruiz, J., Grossmann, I.: Exploiting vector space properties to strengthen the relaxation of
bilinear programs arising in the global optimization of process networks. Optimization Letters
5(1), 1–11 (2011)
62. Ruiz, M., Briant, O., Clochard, J., Penz, B.: Large-scale standard pooling problems with con-
strained pools and fixed demands. Journal of Global Optimization pp. 1–18 (2012)
63. Sherali, H., Adams, W.: A reformulation-linearization technique for solving discrete and con-
tinuous nonconvex problems, Nonconvex Optimization and its Applications, vol. 31. Kluwer Aca-
demic Publishers (1998)
64. Sherali, H.D.: Convex envelopes of multilinear functions over a unit hypercube and over special
discrete sets. Acta mathematica vietnamica 22(1), 245–270 (1997)
65. Smith, E.M., Pantelides, C.C.: A symbolic reformulation/spatial branch-and-bound algorithm
for the global optimisation of nonconvex minlps. Computers & Chemical Engineering 23(4),
457–478 (1999)
66. Tardella, F.: Existence and sum decomposition of vertex polyhedral convex envelopes. Opti-
mization Letters 2(3), 363–375 (2008)
67. Tawarmalani, M., Sahinidis, N.: Convexification and global optimization in continuous and
mixed-integer nonlinear programming: theory, algorithms, software, and applications. Kluwer
Academic Publishers (2002)
68. Vielma, J., Nemhauser, G.: Modeling disjunctive constraints with a logarithmic number of
binary variables and constraints. Mathematical Programming 128, 49–72 (2011)
69. Visweswaran, V.: MINLP: Applications in blending and pooling problems. In: Floudas, C.,
Pardalos, P. (eds.) Encyclopedia of Optimization, pp. 2114–2121. Springer (2009)