one-dimensional cutting problems: models and algorithms

models and algorithms for

one-dimensional cutting problems

Fabrizio [email protected]

Università Tor Vergata

Roma, November 2013

Università Politecnica delle Marche


Fabrizio Marinelli - Cutting problems 2

Road map

A typology of cutting problems

The one-dimensional cutting stock problem

Complexity: NP-completeness and polynomial cases

Four integer program formulations

Solution methods: heuristics, approx results, exact algorithms

and topics packing


The problem


Cutting problem

“large objects” (stock) have to be cut up into

“small objects” (parts or part-types) in order to

fulfill a given requirement of parts.

Five sub-problems can be distinguished:

1. how select the stocks,

2. how select the parts,

3. how group the parts,

4. how allocate the groups of parts to stocks,

5. how lay out the parts on stocks.


An example

supply of Stocks (warehouse) demand of Parts (Production bill)

4

15

6

cutting pattern: a (geometric)

assignment of parts to stocks.

activation level

INPUT: geometric objects of given shape

OUTPUT: (unordered) set of cutting operations


[definition] A cutting pattern is a vector p Nn that describes how

to cut a single stock: the i-th component indicates how many parts

of type i are produced by adopting the pattern.

[definition] The activation level of a cutting pattern p is the

number of stocks processed according to p.

In math terms…


Cutting in industry

Textile - Missoni (Italy),…

Paper - Pine Falls (Canada) Stone Consolidated (Canada, UK), ...

Industrial woodworking – IKEA (Sweden),…

Steel bars – Hydro (Italy, Norway),…

Glass – Pilkington (Italy, France), ...

Rubber – Dayco (Italy, Belgium), ...

Logistics – Pallet Loading, assortment, pallet layout,…


Other applications: Multiprocessor scheduling

[problem] Multiprocessor Scheduling

n jobs, all released at time zero, each requiring a given processing time pi

m machines, each available for a time interval [0, D]

no due dates or precedence constraints; preemption is not allowed.

Is there a schedule which fits all n jobs onto the m machines?

We are asking whether n bars, with lengths pi ,

can be bin-packed into m bins of length D.


Other applications: Assembly Line Balancing

Task to workstation assignment (cutting plan)

t1 t2 t6 t5 t8 t3 t10 t4 t7 t9 t11

Workstations (bins)

Cycle time

t2 t6 t8

Tasks (production bill)

t1

t5

t3

t10

t4

t7 t9

t11

Generalized Bin Packing Problem


Geometrical characteristics

Dimensionality

Part Shape

Regular

Convex

Irregular

two-dimensional(sheet, panels, clothes)

Cut Shape

one-dimensional

(rods, bars) Rotation allowed

Guillotine

Nested


Combinatorial characteristics

Stocks and Parts Assortment

one Stock, many identical Stocks, distinct Stocks;

one type and many parts, few types and many parts per type,

many types and one or few parts per type.

Parts to Stocks Assignment

All stocks are required to obtain a selection of parts;

All parts must be produced by using a selection of stocks.


Dyckhoff, H, A typology of cutting and packing problems, 1990

4-fields notation / / /

Typology of cutting & packing problems

1. Dimensionality

(1) one-dimensional

(2) two-dimensional

(3) three-dimensional

(N) N-dimensional

2. Kind of assignment

(B) all stocks and a selection of parts

(V) a selection of stocks and all parts

3. Assortment of stocks

(O) single stock

(I) identical figure

(D) different figures

4. Assortment of parts

(F) few parts (of different types)

(M) many parts of many different types

(R) many parts of relatively few different parts

Some ambiguity problems, i.e., the well-known Vehicle Loading Problem is

coded both as 1/V/I/F and 1/V/I/M


Typology of cutting & packing problems

Wäsher et al.,

An Improved typology of cutting and packing problems, 2007

Criteria:

dimensionality:

1D, 2D, 3D;

kind of assignment:

output maximization, input minimization;

assortment of parts:

identical, weakly heterogeneous, strongly

heterogeneous;

assortment of stock: one, several;

shape of parts: regular, irregular.

Basic p

rob

lems

Interm

ediate p

rob

lems

Refin

ed p

rob

lems


Typology: basic problems

C&P problems

Output

maximization

Input

minimization

kind of

assignment

identicalweakly

heterog.

strongly

heterog.

all dimension fixed

Assortment

of parts

identical

item

packing

placement KnapsackOpen

dimension

Cutting

Stock

(CSP)

Bin

Packing

(BPP)

basic

problem

Arbitraryweakly

heterog.

strongly

heterog.

variable

dimension (s)

all dimension fixed


Typology: intermediate problems

Input minimization

parts

weakly heterogeneous strongly heterogeneous

stock

s

identical

weakly

heterogeneous

strongly

heterogeneous

all

dim

ensi

on f

ixed

One large stock

Variable

dimension(s)

Single Stock Size CSP

SSSCSP

Multiple Stock Size CSP

MSSCSP

Residual CSP

RCSP

Single Bin Size BPP

SSSBPP

Multiple Bin Size BPP

MBSBPP

Residual BPP

RBPP

Open Dimension Problem

ODP


Community

ESICUP (EURO Special Interest Group on Cutting and Packing)

Founded in 1988 and EURO Working Group since 2003

Around 500 members worldwide

Around 600 papers between 1995 and 2004

1D 2D 2D 3D totregular irregular

Input minimization 108 79 52 24 263

Output maximization 64 71 12 35 182

tot 172 150 64 59 445


The one-dimensional case


Cutting Stock Problem (CSP)

a sufficient number m of stocks of length L

a production bill Q consisting in n part-types. Part-type i is described by the

length li and the number di of items to be produced.

INPUT

OUTPUT

A set {p1,…, pK} of cutting patterns and relevant activation levels.

The problem is feasible if: li < L for all i


An example

L = 10 m

Stocks Production bill Q

l1 = 7

l3 = 4

l2 = 3

d1 = 5

d2 = 10

d3 = 5

(0,2,1)

(1,0,0)

5

5

= (0,10,5)

= (5,0,0)

[Solution 1]Cutting

patterns

Activation

levelProduction

(5,10,5)10Trim loss = 3 5 = 15m


An example

L = 10 m


l1 = 7

l3 = 4

l2 = 3

d1 = 5

d2 = 10

d3 = 5

(0,2,1)

(0,3,0)

1

1

= (0,2,1)

= (0,3,0)

[Solution 2]Cutting

patterns

Activation

levelProduction

(5,10,5)9

(1,1,0)

(0,0,2)

5

2

= (5,5,0)

= (0,0,4)

Trim loss = 2 2 + 1 1 = 5m


Some equivalent variants

TxLdltrimlossi

i

n

i

ii minminmin11

If stocks are identical, number of stocks minimization and trim loss

minimization are equivalent problems.

Let T = xi be the number of used stocks in an optimal solution:

Satisfy exactly or at least the demand of parts are equivalent problems

Clearly, the latter is a relaxation of the former and optimal solutions with

the same value can always be obtained from an optimal solution of the

latter by removing the surplus of parts.


Cutting Stock & Bin Packing

In principle, Bin Packing Problem (BPP) and CSP are equivalent.

The size of the input of a BPP instance is exponential in the size of

the corresponding instance of CSP

polynomial-time algorithm for BPP is not necessarily polynomial-

time for CSP

polynomial-size formulation for BPP is not necessarily polynomial-

size for CSP


Problem complexity: preliminaries

[definition] A Polynomial Time Approximation Scheme (PTAS) is an algorithm

which computes, for any given ε > 0, a solution zA within a factor 1 + ε of being

optimal, i.e., zA < (1 + ε) z*. The running time of a PTAS is required to be polynomial

in the size of the problem for every fixed ε.

[definition] A Fully Polynomial Time Approximation Scheme (FPTAS) is a PTAS

algorithm having a running time polynomial in the size of the problem and in 1/ε for

any ε > 0.

[definition] An Asymptotic Polynomial Time Approximation Scheme (APTAS) is a

PTAS algorithm only when z* > C(ε) for a given function C of ε.


Problem complexity

CSP is strongly NP-hard and is NP-hard to approximate within a

factor less than 3/2 (i.e., there is no PTAS algorithms for CSP unless

P = NP)

The decision version of CSP is in NP (EisenbrandShmonin, 2006)

CSP with n = 2 part-types is polynomial:

the algorithm by McCormick et al. (2001) runs in O(log2 L)

the algorithm by Agnetis Filippi (2005) runs in O(log L)

CSP with a fixed number n > 3 of part-types is polynomial (Goemans

– Rothvoss, 2013)


Problem complexity: NP-hardness



P = NP)

[Theorem] deciding if BPP has a solution with 2 bins is NP-complete

[proof] Let {l1,…,ln} be an instance of PARTITION. Consider an instance of BPP

with items {l1,…,ln} and 2 bins li / 2 long.

l1 lnl2

li / 2 li / 2

The BBP instance is a yes-instance iff the PARTITION instance is a yes-instance.





P = NP)

[Corollary] BPP is NP-hard to approximate with ratio < 3/2

[proof] an approximation algorithm with ratio < 3/2 should solve a yes-instance of

PARTITION in polynomial time (since 2 < 3 = 2 bins)





P = NP)

[Theorem] deciding if BPP has a solution with m bins is strongly NP-complete

[proof] Reduction from 3-DIMENSIONAL MATCHING

Given

3 finite disjoint sets X = {1,…,}, Y = {1,…,}, Z = {1,…,},

and a set T X × Y × Z of m triples,

the set M T is a 3-dimensional matching if

|M| =

xi ≠ xj, yi ≠ yj, and zi ≠ zj for any two distinct triples i = (xi, yi, zi) M and

j = (xj, yj, zj) M.


Problem complexity: NP-hardness (cont’d)



P = NP)

[Theorem] deciding if BPP has a solution with m bins is strongly NP-complete

[proof] Reduction from 3-DIMENSIONAL MATCHING

4

3

2

1

4

3

2

1

4

3

2

1

ZYX

T = {(1,1,2), (2,2,1), (3,4,3), (3,3,3), (4,4,4)}

M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}


Problem complexity: NP-hardness (cont’d)

Let (x1, y1, z1)…(xh, yh, zh)…(xm, ym, zm) be an arbitrary sequence of the triples in T

Define an instance I of BPP with

m bins

L = 404 + 15 ( is a large number, i.e., 100)

n = 4m items (4 items for each triple h = (xh, yh, zh) in T )Z

h

Y

h

X

hh llll ,,,

111

1104

4

h

hX

hx

xl

for the first occurrence of xh in the sequence

for the subsequent occurrence of xh

211

21024

24

h

hY

hy

yl

for the first occurrence of yh in the sequence

for the subsequent occurrence of yh

48

41034

34

h

hZ

hz

zl

for the first occurrence of zh in the sequence

for the subsequent occurrence of zh

324810 hhhh zyxl


From a 3D-matching to a bin packing

A sequence of triples such that the triples of M contain only first occurrences and

the triples of T \ M contain only subsequent occurrences

T = {(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)}

M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}

(1,1,2), (2,2,1), (3,3,3), (4,4,4), (1,2,1), (1,2,3), (3,4,3)

An arbitrary sequence of triples

(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)

T \ MM

A packing into m bins is obtained by filling each bin with the items associated to

each triple. Indeed…


Length of triples

The length of a triple of all first occurrences equals the length of the bin

324810 hhhh zyxl

+

1104

h

X

h xl

21024 h

Y

h yl

41034 h

Z

h zl

+

+

=

15404 L

The length of a triple of all subsequent occurrences equals the length of the bin

1114

h

X

h xl

21124 h

Y

h yl

4834 h

Z

h zl

324810 hhhh zyxl

+

+

+

=

15404 L


From a bin packing to a 3D-matching

mLm )1540(4

Let u(k) be the number of occurrences of k in the triples of T.

The total length of items is SUM( I ) =

=

Zk

kuk )(3mm 48)1(10

44

)810(4m +

ZkYjXi

kukjujiui )()()(32

+mm 44

11)1(10

Xi

iui )(

+mm 211)1(1044

Yj

juj )(2

Property 1: any solution exactly fills the m bins


Properties of the item lengths

The largest items is 41034

)(810324 The smallest items is

L4

1

4

1510

4

Property 2: in any solution, each bin contains exactly 4 items

L3

15

3

40 4


Properties of the item lengths (cont’d)

From Property 1 (any solution exactly fills the m bins) and L = 404 + 15

S = L and S mod =15

Let S be the sum of the item sizes in a bin.

15 must be obtained with the residuals 1, 2, 4, 8 of the item sizes.

There is only one way to obtain 15 by summing four numbers (Property 2:

(each bin contains exactly 4 items), with repetition allowed, out of 1, 2, 4, 8.

Each bin must contain (exactly) an item lh associated to a triple h = (xh, yh, zh),

an item liX , an item lj

Y and an item lkZ



14

i

X

i

X

i xCl +

810324 hhhh zyxl +

224 j

Y

j

Y

j yCl +

S mod 2 = 15

434 k

Z

k

Z

k zCl =

15)()()(324 hkhjhiS zzyyxxCS

(xi – xh) + 15 = 15 xi = xh

S mod 3 = 15

S mod 4 = 15

(yj – yh)2 + 15 = 15

(zk – zh)3 + 15 = 15

yj = yh

zk = zh

The bin must contain (exactly) an item lh associated to a triple h = (xh, yh, zh),

and the items lhX , lh

Y , lhZ associated to the components of h



14

i

X

i

X

i xCl

224 j

Y

j

Y

j yCl

434 k

Z

k

Z

k zCl

810324 hhhh zyxl

+

+

+

=

15)()()(324 hkhjhiS zzyyxxCS

40:10 Z

k

Y

j

X

iS CCCC

10 + 10 + 10 + 10 a triple of all first occurrences

10 + 11 + 11 + 8a triple of all subsequent occurrences

The bins containing triples of all first occurrences describe a 3D matching


A 3D matching

From a bin packing to a 3D-matching

T = {(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)}

M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}

An arbitrary

sequence of triples

1 1 2 1 3 3 4

1 2 2 2 4 3 4

2 1 1 3 3 3 4

A bin packing

l1 l2 l3 l4 l5 l6 l7

l1X l1

X l2X l1

X l3X l3

X l4X

l1Y l2

Y l2Y l2

Y l4Y l3

Y l4Y

l2Z l1

Z l1Z l3

Z l3Z l3

Z l4Z


Problem complexity: CSP2

CSP with n = 2 part-types is polynomial:

the algorithm by McCormick et al. (2001) runs in O(log2 L)

Given a CSP2 instance (decision version): l1, l2, d1, d2, m, L w.l.o.g. N \ {0}

Let P be the convex hull of all the feasible cutting patterns:

P = {p N2 | l1 p1 + l2p2 < L}

[definition] A triangle is unimodular if has integral vertices and area equal to 1/2.


Problem complexity: CSP2

[theorem] If the point M = (d1/m, d2/m) is in a unimodular triangle contained in P

then the CSP2 instance is feasible. If M is not in P the instance is infeasible.

Consider a unimodular triangle T = (p1, p2, p3) and the matrix

111

321

321

yyy

xxx

ppp

ppp

B

If M T then M is a convex combination of (p1, p2, p3), i.e., the system

B = [M, 1]T admits a non negative solution .

Let x = m

Since the area of T is ½ |det(B)|, then

T unimodular implies B unimodular.

[d1,d2, m] is integer.

m

d

d

x

x

x

ppp

ppp

yyy

xxx

2

1

3

2

1

321

321

111

x is integer


Algorithm by McCormick et al.: step 1

Step 1: compute the O(log L)

vertices of P by Harvey’s

Algorithm in O(logL) and draw

conv(P) in O(logL loglogL)

P = {p N2 | 3 p1 + 4 p2 < 25}



P = {p N2 | 3 p1 + 4 p2 < 25}

Step 2: if M is in P we have

done.

[example] for [d1,d2, m] = [10,

7, 3] we have M = [10/3, 7/3]

and M = [4, 3]

M

M

p1 p2

p3



P = {p N2 | 3 p1 + 4 p2 < 25}

Step 3: compute the axial

triangles in O(log L). An axial

triangle is prime if its sides are

coprime integers

The point M is in one of such

triangles.



Step 4: if M is in a not prime axial triangle T

with sides a and b, then decompose T in prime

axial triangles with sides

a′ = a / gdc(a,b) and

b′ = b / gdc(a,b) .

a = 4, b = 2

gdc(a,b) = 2

a′ = 2, b′ = 1

a

bT The point M is in one of such triangles.

If a′ = b′ = 1 we have done.



Step 5:

Bézout’s identity: gdc(a,b) = pa qb with p, q N

Consider the kS southeast step triangles:

from (0, b) in the direction (q,− p)

a = 3, b = 8

1 = 3a – 1b p = 3, q = 1

(a, 0)

(0, b)

pq

(1, 5)

(2, 2)



Step 5:

Bézout’s identity: gdc(a,b) = pa qb with p, q N

Consider the kN northwest step triangles:

from (a, 0) in the direction (q − a, b − p)

a = 7, b = 19

1 = 11a – 4b p = 11, q = 4

(a, 0)

(0, b)

b p

q a

(4, 8)

(1, 16)



[Proposition] Any steps triangle is unimodular.

[Proposition] min{kS , kN } = 1 and max{kS , kN } > 2

Step 5: w.l.o.g. suppose kS > 2

Case A: point M is in one of the steps triangles

(the check is made indirectly, without drawing the triangles)

(a, 0)

(0, b)

M



[Proposition] Any steps triangle is unimodular.

[Proposition] min{kS , kN } = 1 and max{kS , kN } > 2

(a, 0)

(0, b)

Step 5: w.l.o.g. suppose kS > 2

Case B: point M is in one of the new

axial triangles. Goto step 3

M


Algorithm by McCormick et al.

draw conv(P)O(logL loglogL)Step 1

yes

compute the axial triangles and

find that containing MStep 3 O(logL)

compute gdc(a,b) and decompose the triangle in prime axial triangles

Step 4 O(logL)

Step 5 M is in one of the steps trianglesO(logL)

check trivial casesStep 2 O(logL)

no

O(logL)


Problem complexity

The decision version of CSP is in NP (EisenbrandShmonin, 2006)

Not trivial since the number of cuts grows with the demand and therefore the size

of the optimal value could be exponential in the problem size.

The result is a direct consequence of the integer analogues of

[Carathéodory’s theorem] Let X Rn be a finite set. If b cone(X), there is a

subset Y of X consisting of n points such that b cone(Y)

[Theorem] Eisenbrand – Shmonin, 2006

Let X Zn be a finite set of nonnegative integer points. If b int.cone(X),

there exists a subset Y of X with |Y| < size(b) such that b int.cone(Y).

Let P Rn be a convex set. If b int.cone(X), there exists a subset Y of X

with |Y| < 2n such that b int.cone(Y).


Problem complexity: CSP with n > 3

CSP with a fixed number n > 3 of part-types is polynomial (2013)

decision version of CSP: can the demand d be expressed as an integer conic

combination ixi of the points in the set X = {x Nn | lTx < L}?

P = {x R2 | 3 x1 + 4 x2 < 20}

l = (3, 4), d = (7, 9), and L = 20

d

x1

x2

x3

1 = 2

2 = 1

3 = 1

Problems

Points in X are exponentially many in size(L)

Sizes of can be exponential in size(d)


Polynomiality for fixed number of part-types

1. Problem: points in X are exponentially many in size(L)

Solution: for fixed n, Eisenbrand and Shmonin showed that the integer

cone of X can be generated by a constant number of integer points in P

2. Problem: size() can be exponential in size(d)

Solution: uhm…

The problem cannot be directly formulated as an ILP with a constant

number of variables and then solved in polynomial time (Lenstra, 1983)

… unless you provide a bound of size() which only depends on n


Polynomiality for fixed number of part-types

[Theorem] Goemans – Rothvoss, 2013

Let P, Q Rn be two polytopes and X = P Nn .

Any y int.cone(X) Q can be expressed as an integer conic combination of

at most 22n + 1 points of X

The coefficients can be computed in time)1(2

)()()(

OQsizePsize

nO

[Corollary] CSP can be solved in polynomial time for any fixed number n of

part-types

By choosing P = {(x1, …, xn, 1) | lTx < L}

and Q = {d} [0, z] we can decide in

polynomial time whether z cuts suffice.

Then use binary search on [0, z]

P

(d,0)

Q

(d,z)


Thm by Goemans and Rothvoss (proof sketch)

Facts

X can be covered by at most N < mnnO(n)logn many integral parallelepipeds

in NO(1) time



Facts


in NO(1) time

3x

x

v1

v2

y1

= 1v1 + 6v2 + y1

2. Any integer point d = x, with N and x integer point of , can be rewrite

in terms of an integer conic combination of the vertices of plus the sum of at

most 2n integer points of



Facts


in NO(1) time

2. Any integer point d = x, with N and x integer point of , can be rewrite

in terms of an integer conic combination of the vertices of plus the sum of at

most 2n integer points of

3. Any point d int.cone(X) can be expressed as iyi with i N and

yi Y X, | Y | < 2n (Eisenbrand – Shmonin, 2006)

For any yi with i > 0, take the parallelepiped containing yi and rewrite iyi

by using 2.

d can be rewritten as an integer conic combination of at most 22n points of

X (vertices of parallelepipeds) plus at most 22n point of X (extra points)



P = {x Rn | Ax < b} Q = {x Rn | Dx < f} A(m n), D(m´ n)

Choose Y Ext() = vertices of parallelepipeds of P, |Y| < 22n, times

Coefficients of the integer conic combination and extra points are unknown but we

can compute them by an ILP with a constant number of variables

Extra points must be in P

d = sum of extra pts + y int.cone(Ext())

d must be in Q

nn

i

i

i

Y

n

i

i

Y

ibn

2

2

1

2

21

21 2

N

N

x

v

fDd

dxv

Ax

v

v

v

n

nN

22

2



Coefficients of the integer conic combination and extra points are unknown but we

can compute them by an ILP with a constant number of variables

nn

i

i

i

Y

n

i

i

Y

ibn

2

2

1

2

21

21 2

N

N

x

v

fDd

dxv

Ax

v

v

v

Variables Constraints

m22n

n

P = {x Rn | Ax < b} Q = {x Rn | Dx < f} A(m n), D(m´ n)

Choose Y Ext() = vertices of parallelepipeds of P, |Y| < 22n, times

m´

22n 22n

n22n n22n

constant polynomial

n

nN

22

2


Asymptotically exact algorithms

Karmarkar – Karp, 1982

zH < z* + O(log 2 n) AFPTAS

Jansen – Solis-Oba, 2011

zH < z* + 1 in O((log2 ∑di + log L)3 log5 ∑di)

Agnetis – Filippi, 2005

zH < z* + n – 2 in O(poly(log L))


Models


Literature

1960 - L. Kantorovich “Mathematical methods of organising and planning

production”, Management Science

1961 – 1963 - Gilmore, Gomory “A Linear Programming Approach to the

Cutting Stock Problem”, Operations Research

1981 - H. Dyckhoff, “A new linear programming approach to the cutting stock

problem”, Operations Research

1999 - J.M. Valério de Carvalho, “Exact solution of bin-packing problems using

column generation and branch-and-bound”, Annals of Operation Research

2003 - G. Belov, R. Weismantel. “A class of subpattern formulations for 1D stock

cutting”, tech. rep.


Notation

m = number of available stocks

L = stock length

Q = production bill

n = number of parts (n = |Q|)

di = demand of parts of type i (1 i n)

li = length of part-type i (1 i n)

z* = optimal value: minimum number of required stocks

P = set of all feasible cutting patterns (N = |P|)


Assignment model (Kantorovich, 1939)

xij N number of parts of type i cut from the stock item j

Decision variables

yj {0,1} 1 if the stock item j is used, 0 otherwise

part-type requirements

cut feasibility

[KAN] formulation:

mjLyxl

nidx

yz

j

n

i

iji

i

m

j

ij

m

j

j

1

1

min

1

1

1

* minimize the number of used stocks

n

i

idm1

n

i i

il

Ldm

1

/or


How many stocks?

m must be not less than the minimum number of required stocks.

n

i

idm1

n

i i

il

Ldm

1

/

max number of stocks required to cover the demand of part type i.

more precisely:

Parts of type i achievable from a single stock

trivially, one stock per part:


An example

m = 1 + 3 + 1 = 5

L = 10

Stocks

Production Bill Q

l1 = 7

l3 = 4

l2 = 3

d1 = 1

d2 = 8

d3 = 2

z* = min y1 + y2 + y3 + y4 + y5

Requirementsx11+ x12+ x13 + x14 + x15 1

x21+ x22+ x23 + x24+ x25 3

x31+ x32+ x33 + x34+ x35 1

Cut feasibility

7 x11 + 3 x21 + 4 x31 10 y1

7 x12 + 3 x22 + 4 x32 10 y2

7 x13 + 3 x23 + 4 x33 10 y3

7 x14 + 3 x24 + 4 x34 10 y4

7 x15 + 3 x25 + 4 x35 10 y5

Variable domains

xij N i = 1,…,3 j = 1,…,5

y1 y2 y3 y4 y5 {0,1}


Pattern-based model (Gilmore-Gomory, 1961)

Given the set P = {p1,…, pN} of all feasible cutting patterns, define the integer

variables

xj N indicating the activation level of cutting pattern pj

Decision variables

[GG] formulation:

nidxp i

N

j

jij

1 1

N

j

jxz1

*min


minimize the number of used stocks

)(L

nON

Compact form: z* = min{1Tx: Ax > d, x > 0, integer} A(n N), x NN


An example

L = 10

Stocks

Production bill Q

l1 = 7

l3 = 4

l2 = 3

d1 = 1

d2 = 8

d3 = 2

4 maximal cutting patterns:

0

1

1

1p

0

3

0

2p

1

2

0

3p

2

0

0

4p

z* = min x1 + x2 + x3 + x4

requirements

p1 x1 + p2 x2 + p3 x3 + p4 x4 d

Variable domains

x1 x2 x3 x4 N


An example

L = 10

Stocks

l1 = 7

l3 = 4

l2 = 3

d1 = 1

d2 = 8

d3 = 2

0

1

1

1p

0

3

0

2p

1

2

0

3p

2

0

0

4p

z* = min x1 + x2 + x3 + x4

requirements

x1 1

x1+ 3x2+ 2x3 8

x3 + 2x4 2

Variable domains

x1 x2 x3 x4 N

[note] in case of requirement constraints in terms of equality, also non-maximal

cutting patterns are required to guarantee feasibility.

4 maximal cutting patterns:

Production bill Q


0 2 31 4 5

Arc-flow model (de Carvalho, 1999)

Oriented acyclic graph G(V, A)

V = {0,1,2,…, L};

an edge between i < j if there is a part-type j i long;

Additional edges (k, k + 1), 0 < k < L 1, and (L , 0).

[example]

L = 5,

n = 2,

l1 = 2, l2 = 3

Any path from 0 to L describes a valid cutting pattern

A circulation of one unit flow describes a single cut.


Arc-flow model (de Carvalho, 1999)

xij N flow through the edge ( i , j )

Decision variables

[deC] formulation:

nkdx

Ljf

Lj

jf

xx

fz

k

Alii

lii

Akj

jk

Aji

ij

k

k

1

1,...,1 0

0

min

),(

,

),(),(

*



flow conservation, i.e., valid cutting patterns


An example

z* = min f

flow conservation

node 0: f x02 x03 x04 = 0

node 2: x02 x24 x25 x23 = 0

node 3: x35 + x34 x03 x23 = 0

node 4: x45 x24 x04 x34 = 0

node 5: f + x35 + x25 + x45 = 0

0 2 31 4 5

[Instance] L = 5, n = 3, l = (4,3,2) d = (1,8,2)

Requirements

x04 > 1

x03 + x25 > 8

x02 + x24 + x35 > 2


Sub-pattern model (BelovWeismantel, 2003)

Idea: patterns are not explicitly described. They are obtained by

combining subpatterns

0

0

2

...

0

0

4

0

0

2

0

0

1 1

11121110

K

Kpppp

phk = 2keh h = 1,…,n and k = 0,…,Kh

hh lLd /,minlog



h k

hkjhkj pp

4

0

0

0

2

0

0

0

0

0

2

0

0

0

0

2

0

0

0

1

j10 = j11= j21 = j41= j42 = 1

6

0

2

3

jp

Decision variables

xj N activation level of pattern pj j = 1 ,…, N´

jhk {0,1} 1 if subpattern phk is used to form pattern pj, 0 otherwise

yjhk N activation level of subpattern phk as part of pattern pj



[BW] formulation:

nhdy h

N

j

K

k

jhk

kh

1 21 0

N

j

jxz1

*min



size(d) + size(z*)

NjLln

h

K

k

jhkh

kh

1 21 0

jhkj yx

jhkk

hjhk

dy

2

cutting pattern feasibility

act. level of pj cannot be smaller than the act. levels of forming subpatterns

act. levels of phk in pattern j can be positive only if phk forms pj


What’s the best model?


some preliminaries :

Implicit Enumeration


Implicit enumeration

[principle] Divide et Impera

The problem P is recursively decomposed (branch) in subproblems

P1, …, Pk, smaller and easier to solve.

Not interesting subproblems, i.e., subproblems whose solutions are surely

suboptimal for P, are removed (bounding) from the enumeration tree

x1

x2

P

x1

x2

P1 P2

Subproblems are arranged

in an enumeration tree

P

P1 P2


Branch-and-bound algorithm

0. Initialization: l = P; x = ; zU =

1. Stop criteria: if l = then x is an optimal solution. STOP.

2. Subproblem selection: choose a subproblem Pi from l and remove it from l

3. Subproblem evaluation: if Pi is infeasible go to 1.

Let xiR be an optimal solution of Pi

R (relaxation of Pi)

4. Bounding: if c(xiR) > zU then go to 1.

if xiR is integer then zU = c(xi

R); x = xiR; go to 1.

5. Branching: decompose Pi into subproblems Pi1,…,Pik such that

Pi = jPij and add the subproblems to l; go to 1.


branch-and-bound: optimality gap

1

2

3

4

5 6

At a generic iteration, the list l contains the subproblem still to be solved (active

subproblems); they are the leaves of the current enumeration tree.

active

subproblems

zL = minil{c(xiR)}c(x1

R)

c(x2R) = c(x6

R)

c(x4R)

c(x3R)

c(x5R)

zU

optimality gap = zU zL

gap% =zU zL

zL


branch-and-bound: convergence

The gap decreases from above when the value zU is updated (by pruning for

optimality or by heuristics).

The gap eventually increases from below when a subproblem defining zL (best

bound) is selected from l.

zL = c(x0R)

zU

z

t

initial gap gap at time t


branch-and-bound efficiency

The efficiency of the algorithm strongly depends on several factors:

Search strategy

subproblem selection (step 2.),

Type of branching

branching variable (step 5.)

Formulation quality (size, tightness, symmetries,…)

Relaxations adopted to compute bounds

Heuristics adopted to compute incumbents

…


[KAN] model: discussion

Easy to handle.

The number of variables and constraints is exponential in the size

of the input (the numbers m + n of constraints and m(n + 1) of

variables grow with the total demand).

An optimal solution might be of exponential size.

The lower bound given by the continuous relaxation is very weak.

The model exhibits symmetries: solutions obtained by stock index

permutations are equivalent; bounding is ineffective.


[KAN] model: continuous relaxation

L

dlz

ii

R

*

[Theorem] Martello – Toth (1990), originally derived for BPP The lower

bound z*R given by the continuous relaxation of [KAN] is:

[proof for the BPP]

The value of the solution xii = 1, xij = 0 (i j), yi = li/L is

li / L

and clearly no solution can be lower than that. Round up, because the number

of stocks must be integer.

For instances with large loss the bound can be very poor, i.e. 2

** z

zR


continuous relaxation

of [KAN] model

zR* = min y1 + y2

x11+ x12 2

5.01 x11 10 y1

5.01 x12 10 y2

x11 , x12 > 0

0 < y1 , y2 < 1

[Instance] L = 10, n = 1, l1 = 5.01, d1 = 2.

2 stocks are required, therefore z* = 2.

[KAN] model: continuous relaxation

The optimality gap is nearly 50%

Solution x11= x12 = 1 and y1= y2 = 0.501 is feasible

and values 1.02, hence is optimal.

Clearly 02.111*

L

dlzR


[KAN] model: discussion

Easy to handle.

The number of variables and constraints is exponential in the size

of the input (the numbers m + n of constraints and m(n + 1) of

variables grow with the total demand).

An optimal solution might be of exponential size.

The lower bound given by the continuous relaxation is very weak.

The model exhibits symmetries: solutions obtained by stock index

permutations are equivalent; bounding is ineffective.


L = 10

Stocks

Production bill Q

l1 = 7

l3 = 4

l2 = 3

d1 = 5

d2 = 14

d3 = 3

The optimal value is 10. Demands can be

satisfied activating cutting patterns p1 and

p2 both at level five.

1

2

0

1p

0

1

1

2p

[KAN] model: symmetries


y1 = … = y10 = 1, yi = 0 i > 10

x11 = 0, x21 = 2, x31 = 1

x12 = 0, x22 = 2, x32 = 1

…

x15 = 0, x25 = 2, x35 = 1

x16 = 1, x26 = 1, x36 = 0

x17 = 1, x27 = 1, x37 = 0

…

x1,10 = 1, x2,10 = 1, x3,10 = 0


An optimal solution

y1 = … = y10 = 1, yi = 0 i > 10

x11 = 1, x21 = 1, x31 = 0

x12 = 0, x22 = 2, x32 = 1

…

x15 = 0, x25 = 2, x35 = 1

x16 = 0, x26 = 2, x36 = 1

x17 = 1, x27 = 1, x37 = 0

…

x1,10 = 1, x2,10 = 1, x3,10 = 0

All the permutations of stock indices 1,…,10 are (equivalent) optimal solutions...

The same solution obtained by swapping

the indices of stocks 1 and 6


… optimal solutions “evenly” spread among the leaves of the tree (red leaves in

the figure):

Since ziL < zi

* < zU for each subproblem i,

a node can be fathomed if its sub-tree has

not any optimal solution (independently

from the adopted exploration strategy).

Symmetries makes ineffective the

bounding; in practice, the search tree is

almost completely visited.



[GG] model: discussion

The number of variables is exponential in the size of the input. It is

O(nL/) where is the length of the smallest part-type.

There exists an optimal solution with a polynomial number of

activated patterns (Eisenbrand – Shmonin, 2006).

The lower bound given by the continuous relaxation dominate the

combinatorial bound by MartelloToth (Vanderbeck, 1999) and is

very tight.

The model does not exhibit symmetries.


The size of an optimal solution of [GG]

[Carathéodory’s theorem] Let X Rn be a finite set. If b cone(X), there is a

subset Y of X consisting of n points such that b cone(Y)

cone(X)

b

X

y1

y2



[Theorem] EisenbrandShmonin (2005)

Let X Zn be a finite set of nonnegative integer points. If b int_cone(X), there

exists a subset Y of X with |Y| < size(b) such that b int_cone(Y)

an upper bound for |Y| cannot be

given in terms of d

(1,4)

(1,2)

(1,1)

(3,7)



W.l.o.g. let Y X the smallest set s.t.

Yx

xxb x > 0, integer

Zx

xb Z Y

Points are nonnegative, hence the number of distinct points

resulting by the sum of points in Z Y is bounded by

n

i

ib1

1

If (by contradiction) than there exists a point p resulting by

the sum of two distinct subsets A, B of Y, i.e.

n

i i

Yb

112

BA xx

xxp

Let A´ = A \ B and B´ = B \ A.

Clearly A´ and B´ are disjoint and not empty, and

BA xxxx

BABBAA xxxx

xxxx



= min xA´{x}

AAYY x

x

x

x

x

x xxxb \

AAAY xx

x

x

x xxx )(\

BAAY xx

x

x

x xxx )(\

BABAY x

x

x

x

x

x xxx )()()(\

BA xxxx

one of these coefficients is 0, i.e. there

exists Z Y such that b int_cone(Z)

)(

1log2log1

bsizeY

bYn

i i

n

i i

Yb

112

contradiction



[Corollary] Let z* = min{cTx: Ax = b, x > 0} A(m n), aij N, x Nn, c Nn.

If this integer program has a finite optimum with optimal value z*, then there

exists an optimal solution x* with at most size(b) + size(z*) nonzero components.

[Proof]

m

n

mn

n

n

mm b

b

z

x

a

a

c

x

a

a

c

x

a

a

c

1

*

1

2

2

12

2

1

1

11

1

The integer vector (z*, b)T is an integer conic combination of the column vectors

of the matrix (c, A)T; the solution x corresponds to the coefficients of the

combination.



[Corollary] The size of an optimal solution x* of the [GG] model is

polynomial in the size of the problem.

[Proof]

z* < di since li < L, i

size(z*) = log(z*+ 1) < log((di + 1)) < log(di + 1) = size(d)

By the previous corollary supp(x*) < size(z*) + size(d)

therefore supp(x*) < 2 size(d)

[GG] z* = min{1Tx: Ax = d, x > 0} A(n N), x NN



The number O(nL) of variables is exponential in the size of the

input.





very tight.



Given an integer 0 < < L / 2 let

Martello & Toth combinatorial bound

I1 = {i : li > L – }

I2 = {i : L / 2 < li < L – }

I3 = {i : < li < L / 2}

L / 2

L

dl

d

dd

zIIi

ii

Ii

i

Ii

i

Ii

i

LB)( 32

1

21

max)(

each part in I1 and I2 requires a distinct bin; parts in I3 are neglected

continuous lower bound of parts in I2 and I3




I1 = {i : li > L – }

L / 2

I2 = {i : L / 2 < li < L – }

I3 = {i : < li < L / 2}

iLlzz iLBLB somefor 2/:)(max

The maximum value of zLB() is achieved for = li < L / 2


[Theorem] Vanderbeck, 1999 For any feasible solution x of [GG] and 0 < < L / 2

Martello & Toth bound vs [GG] bound

LB

Pi

i zx

[Proof]

Let Pk = {p P : pi > 0 for some i Ik}. Notice that P1 P2 = and P1 P3 =

)(\ 2121 PPPi

i

Pi

i

Pi

i

Pi

i xxxx

11 Ii

i

Ii Pj

jij dxp

22 Ii

i

Ii Pj

jij dxp because 121

IIi

ijp

for all patterns pj

in P1 and P2


Martello & Toth bound vs [GG] bound

2121 \)(\

,0maxPi

i

PPi

i

PPPi

i xxx

L

dlIIi

ii

)( 32

)( 32 IIi

iidl

2Ii

id

)( 32 IIi Pj

jiji xpl

1\PPj

jxL

1 32\ )(PPj

j

IIi

iji xpl


[GG] continuous relaxation

zR* = min x1

x1 2

x1 > 0

[GG] model: optimality gap

The optimal solution of the continuous relaxation is x1 = 2 and integer.

The unique maximal cutting pattern is

11 p

[Instance] L = 10, n = 1, l1 = 5.01, d1 = 2.

2 stocks are required, therefore z* = 2.

The optimality gap is 0%



In most cases the optimal solutions of the continuous relaxation of [GG] satisfy

the IRUP property (Integer Round Up Property):

z* zR* = 0

[Theorem] Marcotte, 1986

deciding if a given CSP instance has the IRUP property is NP-hard

[Theorem] Filippi, 2007

z* zR* < (n 1)/3 + 1



[Theorem] Marcotte, 1985 IRUP holds for instances with n = 2 but not for n > 3

[Proof sketch]

CSP: min{1Tx: Ax > d, x > 0, integer} A(2 N), x NN

Columns of A are maximal cutting patterns, i.e., maximal integer points of the

polyhedron P = conv(X) where X = {xN2 | l1x1 + l2x2 < L}.

P is integral;

P is lower comprehensive (x P and 0 < y < x y P);

P satisfies the integral decomposition (kN > 2 and for any integral ykP = {kx

| x P}, the point y can be expressed as the sum of k integral points of P)

CSP has the IRUP property (Baum – Trotter, 1981).



[Theorem] Marcotte, 1985

IRUP holds for instances with L < 8, and for instances having the

successive divisibility property

[Definition] A CSP problem is said to have the property of successive

divisibility if there exists an order of part types such that:

l1 | l2 | … | ln, i.e., li divides li + 1 for i = 1,…, n

[non IRUP instance]

l = (91, 26, 14), d = (1, 4, 12), and L = 182

z* = 3 and zR* = 1.9945


[GG] model: MIRUP

[Conjecture] Scheithauer – Terno, 1996

The optimal solutions of [GG] satisfy the Modified IRUP:

z* zR* < 1

[Theorem] The instances with n < 6 (Scheithauer – Terno,

1996) and n < 7 (Shmonin, 2008) satisfy the MIRUP

Largest gap known is z* zR* = 7/6



The number O(nL) of variables is exponential in the size of the

input.





very tight.



L = 10

Stocks

Production bill Q

l1 = 7

l3 = 4

l2 = 3

d1 = 5

d2 = 14

d3 = 3

The optimal value is 10. Demands can be

satisfied activating cutting patterns p1 and

p2 both at level five.

1

2

0

1p

0

1

1

2p

Such solution is described by [GG] model

in a unique way:

x1 = 5, x2 = 5, xi = 0 per i {1,2}

[GG] model: symmetries


[deC] model: discussion

The size is exponential in the size of the input (the numbers L + n +

1 of constraints and O(nL) of variables grow with the stock length).

The lower bounds given by the continuous relaxations of [deC] and

[GG] are the same.

It is easy to rewrite a solution of [GG] (activation levels of cutting

patterns) into a solution of [deC] (circulation on G) and vice-versa.

The model exhibits symmetries: several paths correspond to the same

cutting pattern.


From solutions of [deC] to solutions of [GG]

L = 10

Stocks

l1 = 5

l3 = 2

l2 = 3

d1 = 1

d2 = 8

d3 = 2

Production bill Q

0 2 31 4 5 6 8 97 10

Flow decomposition property: any feasible flow can be decomposed into

a sum of flows in paths from node 0 to node L plus

a sum of flows around cycles


From solutions of [deC] to solutions of [GG]

L = 10

Stocks

l1 = 5

l3 = 2

l2 = 3

d1 = 1

d2 = 8

d3 = 2

Production bill Q

0 2 31 4 5 6 8 97 10

[GG] solution

x1 = 1 x2 = 1 x3 = 2 x4 = 0

0

1

1

1p

0

3

0

2p

1

2

0

3p

2

0

0

4p

1 1

1+2 1+1+2

1 + 2 1 + 2

1

2

A solution with integer flow is

decomposed into an integer solution

of model [GG]


Models: pros & cons

mjLyxl

nidx

yz

j

n

i

iji

i

m

j

ij

m

j

jR

1

1

min

1

1

1

KAN[KAN]

nkdx

Ljf

Lj

jf

xx

fz

k

Alii

lii

Akj

jk

Aji

ij

R

k

k

1

1,...,1 0

0

min

),(

,

),(),(

deC[deC]

nidxp i

N

j

jij

1 1

N

j

jR xz1

GGmin

[GG]

Size Tightness Symmetries


Model reformulation

Dantzig-Wolfe decomposition

1960 - G. Dantzig, P. Wolfe, “Decomposition Principle for Linear Programs”, Operations Research

1958 - L. Ford, D. Fulkerson, “A suggested computation for maximal multi-commodity network flows”,

Management Science


[Teorema] Resolution Theorem (Weyl-Minkowski, 1936)

Let P be a non-empty polyhedron with at least one extreme point.

Then

P = conv(ext(P)) + rec(P)

P

v1

v2

v3

conv(Ext(P))

rec(P)

x

d

u

Inner representation of polyhedra


The decomposition principle

fDx

bAx

xcT

s.t.

min*

z

compact formulation

A(m1 n)

D(m2 n)

Q(D, f) = {x Rn | Dx > f}

Hp: Q(D,f ) is a non-empty polytope

Resolution Theorem (Weyl-Minkowski, 1936):

A point x belongs to Q(D,f ) if and only if it can be written as a

convex combination of the extreme points {v1,…,vq} of Q(D,f ) :

Q(D,f ) x = i ivi with i i = 1 and i > 0


Dantzig-Wolfe decomposition

qi

z

i

q

i

i

q

i

ii

q

i

iiDW

1 0

1

)( s.t.

)(min

1

1

1

*

bAv

vcT

extensive formulation

(master problem)

Both formulations have the same optimal value: z*DW = z*

The extensive formulation (in variables ) has fewer constraints

(only m1+1) but a huge number of variables (order of )

Substituting for x in the

compact formulation we

obtain an equivalent

2m

n


Convexification of an integer program

n

z

Z

s.t.

min*

x

fDx

bAx

xcT

Q(D, f)

Q(D, f) = {x Rn | Dx > f}

X = Q(D, f) Zn

Convexification (analogous of DW decomposition for IPs)

X = Q(D, f) Zn = conv(X) Zn

Q(D, f)


Convexification of an integer program

n

z

Z

s.t.

min*

x

fDx

bAx

xcT

conv(X)

If conv(X) Q(D,f) then the continuous relaxation of the

convexification is stronger than the continuous relaxation of the

original model.

n

C

Z

Xconv

z

x

x

bAx

xcT

)(

min*


An example

aTx = b

dTx = f

P = {aTx < b, dTx < f, x > 0, x Z2}


aTx = b

dTx = f

P = {aTx < b, dTx < f, x > 0, x Z2}

PR = {aTx < b, dTx < f, x > 0}

An example


dTx = fX = {dTx < f, x > 0, x Z2}

P = {aTx < b, dTx < f, x > 0, x Z2}

PR = {aTx < b, dTx < f, x > 0}

An example


X = {dTx < f, x > 0, x Z2}

P = {aTx < b, dTx < f, x > 0, x Z2}

PR = {aTx < b, dTx < f, x > 0}

x conv(X)

An example


aTx = b

X = {dTx < f, x > 0, x Z2}

P = {aTx < b, dTx < f, x > 0, x Z2}

PR = {aTx < b, dTx < f, x > 0}

x conv(X)

PC = {aTx < b, x conv(X) , x Z2}

An example


Convexification and lagrangian relaxation

nZX

P

x

bAx

xcT

s.t.

min :

convexification

lagrangian relaxation provide the

same bound

lagrangian dual problem )(minmaxTT

bAxuxcx0u

X

L

)(min)(TT

bAxuxcux

X

Llagrangian subproblem 0u ,

)(minmaxTT

)(bAxuxc

x0u

XconvL



Theorem of linear programming

)(minmaxTT

)(bAxuxc

x0u

XconvL

Reformulation of min

)(minmaxTT

bAvuvc0u

kkKk

L

0u

bAvuvc

)(

max

TTKkt

tL

kk

index set of ext(conv(X))

0u

vcbAvu

)(

max

TTKkt

tL

kk

General form



Dual problem

0λ

λ1

0bAv

vc

1

)(

)(min

T

T

Kk

kk

Kk

kk

λ

λ

0u

vcbAvu

)(

max

TTKkt

tL

kk

lagrangian dual problem of P

Convexification of P


Discretization of an integer program

n

z

Z

s.t.

min*

x

fDx

bAx

xcT Q(D, f) = {x Rn | Dx > f}

X = Q(D, f) Zn

Theorem (Nemhauser-Wolsey, 1988):

X is generated by a finite number of integer points {p1,…,pq} of X

X x = i ipi with i i = 1 and i {0,1}

Q(D, f)


discretization vs. convexification

PD = {aTx < b

x = i=1..8 ipi

i=1..8 i = 1

i {0,1}

x N2}

PD = {i=1..8aTpii < b

i=1..8 i = 1

i {0,1}}

conv(X)

p1

p2

p3p4 p5

p6

p7

p8

aTx = b

Discretization: X x = i ipi with i i = 1 and i {0,1}



PC = {aTx < b,

x = i=1..4 vii

i=1..4 i = 1

i > 0

x N2}

PC = {i=1..4 aTvi i < b,

i=1..4 i = 1

i N4}

conv(X)

v1

v2

v3v4 aTx = b

Convexification: X x = i ivi , integer with i i = 1 and i [0,1]



►Bounds: same polytope and therefore same bounds.

►Branching:

convexification: must be performed on the original variables x

discretization: can be performed directly on binary variables

►Convexification and discretization are equivalent only when all

the original variables are binaries, i.e., when the set of integer

points of conv(X) corresponds to the set of extreme points of

conv(X).


Discretization of [KAN] model

}1,0{

integer,0

1

1

min

1

1

1

*

j

ij

j

n

i

iji

i

m

j

ij

m

j

j

y

x

mjLyxl

nidx

yz

Each of the m polyhedra corresponding to the pattern feasibility

constraints is discretized:

}1,0{

1 1

1

j

k

q

k

j

k

q

k

j

k

j

kij

j

j

x

p

mjLplXn

i

ii

nj,...,1 N

1

p

qj = | X j |



Each of the m polyhedra corresponding to the pattern feasibility

constraints is discretized:

}1,0{

1 1

1 )(

min

1

1 1

1 1

*

j

k

q

k

j

k

i

m

j

q

k

i

j

k

j

k

m

j

q

k

j

kD

mj

nid

z

j

j

j

p

}1,0{

integer,0

1

1

min

1

1

1

*

j

ij

j

n

i

iji

i

m

j

ij

m

j

j

y

x

mjLyxl

nidx

yz



}1,0{

1 1

1 )(

min

1

1 1

1 1

*

j

k

q

k

j

k

i

q

k

m

j

j

kik

q

k

m

j

j

kD

mj

nid

z

p

Notice that X1 = ,…, = X m = X

pkm

kk pp ,...,1

and q1 =,...,= qm = qTherefore

replace with k > 0 integer

summation

mm

j

q

k

j

k 1 1



qk

m

nid

z

k

q

k

k

i

q

k

kik

q

k

kD

1 integer ,0

1 )(

min

1

1

1

*

p

0 X mq

k

k 1

redundant constraint

at the end we obtain the [GG] model


CSP models relationship

mjLyxl

nidx

yz

j

n

i

iji

i

m

j

ij

m

j

jR

1

1

min

1

1

1

KAN[KAN]

nkdx

Ljf

Lj

jf

xx

fz

k

Alii

lii

Akj

jk

Aji

ij

R

k

k

1

1,...,1 0

0

min

),(

,

),(),(

deC[deC]

nidxp i

N

j

jij

1 1

N

j

jR xz1

GGmin

[GG]

Discretization of

knapsack (fractional)

polyhedra

KANGG

RR zz

Discretization of flow conservation constraints (integer polyhedron)

deCGG

RR zz


Solution methods:

Lower bounds




I1 = {i : li > L – }

I2 = {i : L / 2 < li < L – }

I3 = {i : < li < L / 2}

L / 2

L

dl

d

dd

zIIi

ii

Ii

i

Ii

i

Ii

i

LB)( 32

1

21

max)(

each part in I1 and I2 requires a distinct bin; parts in I3 are neglected

continuous lower bound of parts in I2 and I3


Solution methods:

heuristics


Primal heuristics

low: constructive heuristics

high: rounding of the fractional sol. of the continuous relaxation of [GG]

First Fit Decreasing (FFD)

Best Fit Decreasing (BFD)

Sequential heuristics

Production volume (idi)

The number of operations

depends on the number of parts

The number of operations does not depend on the demand

(is O(n2L) on average)

Thanks to the IRUP property, the optimal solution approximates

the integer optimum as the demand gets larger


Low demand: on-line heuristics for BPP

Next Fit (NF): the next item is assigned to the current bin if it has a sufficient

residual capacity, otherwise a new bin is open.

zNF := 1 and S := 0

for i := 1 to n do

if S + li > L then zNF := zNF + 1 and S := 0

pos(i) := zNF and S := S + li

end for



[Theorem] zNF < 2li / L 1 < 2z* 1

]2,1[)(pos

ii:

i Ll1:

]4,3[)(pos

ii:

i Ll2:

],1[)(pos

NFNF zzii:

i LlzNF/2:

li > L zNF /2

zNF < 2li / L

zNF < 2li / L

zNF < 2li / L 1

zNF < 2z* 1worst instance: {2, L , 2, L ,…}



First Fit (FF): the next item is assigned to the bin with smallest index and

enough residual capacity. If there is none, a new bin is open.

for i := 1 to n do

pos(i) :=

end for

zFF := maxi=1,..,n pos(i)

jh

ihj

Lll)(posIN

minarg



Garey et al., 1976 zFF < 1.7 z*

Simchi-Levi, 1994 zFF < 1.75 z*

Asymptotic performance

Absolute performance

Boyar, 2012 zFF < 12/7 z* 1.7143 z*


Low demand: constructive heuristics

First Fit Decreasing (FFD): sort the items in non-increasing order and apply FF.

Best Fit Decreasing (BFD): sort the items in non-increasing order. Largest

unplaced item is assigned to the bin with smallest residual capacity, but still

sufficient to accommodate the item. If there is none, a new bin is open.

FFD and BFD have:

absolute performance zFFD < 3/2 z* (Simchi-Levi, 1994)

asymptotic performance zFFD < 11/9 z* + 4 (Johnson, 1974)

zFFD < 11/9 z* + 3 (Baker, 1985)

zFFD < 11/9 z* + 1 (Yue, 1991)

zFFD < 11/9 z* + 2/3 (Dósa, 2007)

If Successive Divisibility property holds then FFD is optimal (Coffman, 1987)


FFD: absolute performance

[Theorem] (Simchi-Levi, 1994) zFFD < 3/2 z*

j = 2/3 zFFD

1

1st case: the bin j contains an item k with lk > L/2

2

zFFD

Consider the bin j = 2/3 zFFD

k

bins i < j has no space for k

Since items are sorted in non-increasing order,

bins i < j contains items with length > L/2

At least j items has length > L/2

z* > j > 2/3zFFD


FFD: absolute performance

[Theorem] (Simchi-Levi, 1994) zFFD < 3/2 z*

j = 2/3 zFFD

1

zFFD

2

Consider the bin j = 2/3 zFFD

bins j, j + 1, …, zFFD contain at least 2(zFFD j) + 1

items

2(zFFD j) + 1 > 2(zFFD 2/3 (zFFD +1)) + 1 =

2/3zFFD 1/3 > j 1

Since, none of such (at least) j 1 items fits in the

first j 1 bins we have li > L( j 1)

z* > li / L > j > 2/3zFFD

2nd case: the bin j (and therefore the bins j +1,…, zFFD) contains no items

with length > L/2

worst instance: L = 10, l1 = l2 = 4, l3 = l4 = l5 = l6 = 3


FFD: asymptotic performance

L = 100


l1 = 51

l3 = 26

l2 = 27

d1 = 6

d2 = 6

d3 = 6

l4 = 23 d3 = 12

Optimal solution: 9 bins FFD solution: 11 bins


Low demand: constructive heuristics

Sequential heuristics: a solution is built up pattern after pattern by solving a

sequence of integer knapsack problems. In general, sequential heuristics provide

much better solutions than FFD or BFD

while some parts are left do

Solve the problem max{yTa | lTa < L, a Nn}

Cut mini:a > 0 d′i/ai stocks with the cutting pattern a

Update the demands d′

end while

i

SVC (BelovScheithauer, 2007)

i ii

p

iii

al

lLkyky 21

Fill Bin (Vanderbeck, 1999)

yi = li


High demand: [GG] rounding heuristics

Solve the residual problem

by FFD, BFD or by an exact

algorithm for BPP

x = solution of the

continuous relaxation of [GG] Column generation

y = Rounding of x

Residual demand = d Ay

round-up, round-down or a combination

of them

Sequential rounding of the most fractional

variable (and fixing of integer variables)

Removing of oversupply

Stadtler (1990), Waescher Gau (1996),

Belov Scheithauer (2002)

Absolute performance: zH < z + n


[GG] rounding heuristic: performance

[Theorem] (de la Vega - Lueker, 1981)

Let x be a basic solution (non necessarily optimal) of the continuous

relaxation of [GG]. A solution xH of CSP with

zH < z + (n 1)/2

cuts can be always obtained.

[proof]

x = round-down of x and x = round-up of x

R = residual instance and SUM(R) = iR li

► Solution of R

1) x x is a solution of R with at most n cuts (x is a FBS)

2) Next Fit solves R with at most 2 SUM(R)/L 1 cuts


[GG] rounding heuristic: performance (cont’d)

► By combining 1) and 2), the number of required cuts is

zR = min{n, 2 SUM(R)/L 1} < (n 1)/2 + SUM(R)/L

min{a,b} < mean(a,b)

R

N

j

jH zxz 1

N

j

n

i

iijjj lpL

xx1 1

1

N

j

jj xx1

N

j

jj

N

j

jH xxn

xz11

2

1

N

j

jxn

12

1 z

n

2

1

L

RSUMn )(

2

1


Solution of [GG]: column generation

Several problems (cutting stock, crew scheduling, clustering,…)

admit a natural formulation with exponentially many variables.

For such integer programs, even the continuous relaxation can be

hard to solve. Indeed, it is already impractical to write down the

program: the [GG] model has 50 constraints and much more than

250 (i.e., 1.125.899.906.842.624) variables for an instance with 50

part types.


Col Gen: the restricted master problem

[Idea] we solve a restricted version of [MP] (the Restricted Master Problem

[RMP]) defined on a subset R of A and we dynamically generate only the

columns of A that are part of the optimal solution or that guide the search toward

the optimal solution.

master problem [MP] z*R = min{cTx: Ax = b, x > 0} A(n N), x RN

[Observation] an optimal solution is an FBS (Feasible Base Solution): regardless

the number N of variables, it has at most n << N non-zero components.


Col Gen: the algorithm

while there exists a column Aj in A \ R with negative reduced cost do

Add the column Aj to the matrix R

Solve the new Restricted Master Problem

end while

The optimal solution of [RMP] is the optimal solution of [MP]

Explicit scan of A \ R is impractical.

If the mathematical structure of columns is known, a new optimization problem

(pricing problem) that computes the most attractive column of A \ R, i.e., that with

minimum reduced cost, can be defined.


Col Gen: pricing problem

Restricted Master Problem

zR = min{cRxR | RxR = b, xR > 0}

Pricing Problem

* = min{cj TAj | Aj A\R}

dual variables

attractive column Aj

* < 0

* > 0

END

(xR, 0N r)

optimal solution

(xR, 0N r) is feasible for [MP]

If * > 0 then is feasible for the dual of [MP].

zR = Tb and therefore (xR, 0N r) is optimal for [MP] (strong duality)

The efficiency of column generation strictly depends on

the complexity of the pricing problem


Column generation for [GG] model

The continuous relaxation of [GG] model is:

Let yi be the number of parts of type i in a column (cols of A are cutting patterns)

[GGR] z*R = min{1Tx: Ax > d, x > 0} A(n N), x RN

011

n

i

ii y The column is an attractive cutting pattern if

Lyln

i

ii 1

The column is a feasible cutting pattern if

integer,0,1min11

*

i

n

i

ii

n

i

ii yLylyPricing Problem:


Column generation for [GG] model

The pricing problem is a (bounded) integer knapsack

solved by:

dynamic programming in O(nL)

branch-and-bound: (Pisinger, MartelloToth, HorowitzSahni)

integer,0,1min11

*

i

n

i

ii

n

i

ii yLylyPricing Problem:

integer,0,max111

*

i

n

i

ii

n

i

ii yLyly


An example

L = 8


l1 = 4

l3 = 2

l2 = 3

d1 = 5

d2 = 4

d3 = 8

A starting feasible solution (required to provide starting duals) can be easily

obtained by considering a maximal cutting pattern for each part type:

0

0

2

1p

0

2

0

2p

4

0

0

3p


An example: 1st iteration

zR = min x1 + x2 + x3

2x1 5

2x2 4

4x3 8

x1 x2 x3 > 0

First restricted master problem on patterns p1, p2 e p3 :

The optimal solution is xR = (2.5, 2.0, 2.0)

and its value is zR = 6.5. The corresponding

dual solution is = (0.5, 0.5, 0.25)

The pricing problem is:

* = 1 max{0.5 y1 + 0.5 y2 + 0.25 y3 | 4 y1 + 3 y2 + 2 y3 < 8, y1 y2 y3 N}

The optimal solution is y = (0, 2, 1) with * = 0.25: the cutting pattern A = (0, 2, 1)

has a negative reduced cost and hence is a candidate for entering in the basis of the

restricted master problem.


An example: 2nd iteration

zR = min x1 + x2 + x3 + x4

2x1 5

2x2 + 2x4 4

4x3 + x4 8

x1 x2 x3 > 0

The new restricted master problem is:

The optimal solution is xR = (2.5, 0.0, 1.5, 2.0)


dual solution is = (0.5, 0.375, 0.25)

The pricing problem is:

* = 1 max{0.5 y1 + 0.375 y2 + 0.25 y3 | 4 y1 + 3 y2 + 2 y3 < 8, y1 y2 y3 N}

The optimal solution is y = (2, 0, 0) with * = 0.0: there are no cutting patterns with

negative reduced cost, therefore xR = (2.5, 0.0, 1.5, 2.0) is an optimal solution of the

continuous relaxation of [GG] model.


Solution methods:

back to

approximation results


Asymptotically exact algorithms

de la Vega – Lueker, 1981

zH < (1+)z* + 1/2 0 < < 1/2


zH < z* + 1 in O((log2 ∑di + log L)3 log5 ∑di)

for fixed number of part-types

Karmarkar – Karp, 1982

zH < z* + O(log 2 n) AFPTAS


de la Vega Lueker, 1981

0 < < 1/2

Km1K0 K1 Km2 RF

= L /( + 1)

L/2

|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1

ym

ym1

ym2y2

y1



Let

M = K0 K1 … Km1

Q = {y1, …, y1, y2, …, y2,…, ym, …, ym}

h1 h1 h1

CSP instance with m part-types

0 < < 1/2

= L /( + 1)

F K0 K1 Km2 Km1 R

L/2

|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1

ym

ym1

ym2y2

y1



Clearly z*Q < z*

Compute by [GG] a packing of Q with zQ < z*Q + (m 1)/2.

The number of cutting patterns is a constant N = O(mL/) therefore [GG] can be

solved in polynomial time (Lenstra, 1983)

0 < < 1/2

= L /( + 1)

F K0 K1 Km2 Km1 R

L/2

|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1

ym

ym1

ym2y2

y1



0 < < 1/2

= L /( + 1)

F K0 K1 Km2 Km1 R

L/2

1) Since |R| = |Km1| = …= |K1| > |K0| and ym > l l Km1 , … , y1 > l l K0

a packing of M can be easily obtained from a packing of Q, hence zM = zQ

2) Moreover, parts in R can be packed in |R| bins, hence zR = h – 1

3) Pack F in the bins used for packing M and R (by any heuristic, e.g. FF)

4) Pack F´ (the residual of F after step 3.) by Next Fit



Case 1: F´

since l < , l F, each bin is filled for at least L (except possibly the

last)

*

1

)1)(( LzlzLn

i

iH

11 *

LzL

zH

2

** 1)1(1)1(

zzzH

= L /( + 1)



n

i

ilh1

h

FnLm

||

Case 2: F´ =

Let zH <2

1

**

mzz

2

1 )1(

*

mz

2

11

L

Fn

FnL

zH <2

2*

2

1 )1(

z

n

i

il

FnL

h

FnL

1

2

* 1 )1(

z

zH = zM + zR 12

1*

h

mz



Split the instance into big and small parts L = 100

big parts B = {i | li > L}

small parts S = {i | li < L}12

1

n

L = 14.28

l1 = 35

l2 = 25

l3 = 12

l4 = 9

Split each pattern into a big and a small sub-pattern

p

pB pS

PB = set of big sub-patterns (including the empty subpattern)

PS = set of small sub-patterns



N

ji

i

Pj

jij

i

Pj

jij

Pj

j

B

jj

i

i

yx

Sidxp

Bidy

zy

Pjyx

j

Bj

Bj

jBi

,

:

:

:

*

:

:

p

σ

σ

σp

σ

[GGD]: activation level of big sub-patterns

The total number of cuts must be z*

big parts must be covered by big

sub-patterns

small parts must be covered

[Proposition] The solution x is optimal for [GG] if and only if (x, y) is feasible

for [GGD]



the formulation [GG] always admits an optimal solution x with at most 2n

activated cutting patterns (EisenbrandShmonin, 2005).

Relax the integrality constraints

Choose < diz

Choose a set of 2n big sub-patternsPB

BPzMILP ,

z

PB

PB

PB

xi > 0N

j

i

j

jij

i

j

jij

j

j

jj

i

i

y

Sidxp

Bidy

y

jyx

Bj

j

j

jBi

:

:

:

:

:

p

σ

σ

σp

σ

PB



[Remark] has a constant number (2n) of integer variables but an

exponential number, |P| = O((di)n), of continuous variables.

BPzMILP ,

Solvable in polynomial time by the Lenstra’s algorithm and the ellipsoid method

where the separation oracle is a knapsack with a constant number of variables.

Let (x*, y*) a solution of MILP(z*, PB*)

Integer variables y* describe an assignment of big parts to z* stocks

Continuous variables x* describe a fractional assignment of small parts

[Theorem] All the small parts can be assigned by using at most one additional

stock



any optimal solution x´ has at most

Y + n positive variables

*

:

**

:

:

: 0

:

min

*

BB

jj

i

Pj

jij

B

jj

i

i

Pj

j

Pjx

Sidxp

Pjyx

x

BBj

jBi

j

p

σ

p

σp

p

small parts assignment

Y + n positive variables for Y constraints

at least Y n are integer

Y constraints (one for each positive yj* )

at most n constraints

< 2n fractional variables



12 nxx ii the unpacked small parts require at most stocks

Apply Next Fit algorithm to 2n – 1 stocks of the solution (those without small

parts) in order to assign such small parts. At the end of the procedure:

all the small parts have been assigned to stocks. We have done

some small parts still have to be assigned

the residual of the 2n – 1 stocks is at most (2n – 1) L = (2n – 1)L /(2n – 1)

the residual small parts require at most one additional stock


Set = 1/(2n – 1) and z* = di


For each set of 2n

big sub-patterns

PB

Find = min{1,2,…,z*} such that

has a solution (x*, y*) BPzMILP ,

z

Update z*

Rounding of (x*, y*) with at most

one additional stock

O(log(di)) MILP

(binary search)

n

n

2

/1 times


Solution methods:

exact algorithms

Solution of [GG] by means of

column generation + implicit enumeration


Literature

1996 – P. H. Vance, “Branch-and-price algorithms for the one-dimensional

cutting stock problem”, Computational Optimization and Applications (n < 20)

1998 – J. M. de Carvalho, “Exact solution of cutting stock problems using column

generation and branch-and-bound”, International Transactions in Operational

Research

1999 – F. Vanderbeck, Computational study of a column generation algorithm

for bin packing and cutting stock problems, Mathematical Programming (n < 50)

2006 – G. Belov and G. Scheithauer, “A branch-and-cut-and-price algorithm for

one-dimensional stock cutting and two-dimensional two-stage cutting”, European

Journal of Operational Research

2008 – C. Alves, J. M. de Carvalho, “A stabilized branch-and-price-and-cut

algorithm for the multiple length cutting stock problem”, Computers &

Operations Research (n < 100 and 4 stock sizes)


Branch-and-Price

Master problem initialization

Master problem solution

Node selection strategies

Branching


Master problem initialization

Initialization for CSP

A maximal cutting pattern for each part-type (Vance, De Carvalho)

A unique super-pattern with bigM coeff. in the o.f. (Degraeve, Vanderbeck)

Primal solutions computed by FFD, BFD and Fill Bin heuristics (Vanderbeck)

Feasibility of the master problem must be guaranteed at each node of the

enumeration tree.

Irrelevant or poorly chosen initial columns may cause the heading-in effect

(Vanderbeck, 2005)


Master problem solution

Complexity: an LP model with an exponential number of

variables is polynomially solvable by column generation if and

only if the pricing problem is polynomial.

Algorithms: simplex, dual simplex, subgradient, hybrid

methods simplex-subgradient (Barahona Jensen, 1998

Degraeve Peeters, 2003).

Running time: tailing-off effect

(slow convergence and degeneracy)


Master problem solution: tailing-off

iterations

*

Rz

master problem solutions zR

lower bound zL

The number of iterations can be reduced by:

interrupting the generation of columns (early termination)

increasing the convergence speed (acceleration techniques)


Early termination: lower bound’s lower bound

Let A* be the column with minimum reduced cost

1 TA* < 1 TAj for any column j

TAj < TA*

TAj / TA* < 1

( / TA*)TAj < 1

dual feasible solution

the corresponding value Tb / TA* is a lower bound to z*R

optimal solution zR of the

current master problem

optimal solution * of

the pricing problem


Early termination: lower bound’s lower bound

*

* R

R

L zz

z

If zL = zR then early termination (because z*R = zR )

If zL > zU then pruning for bounding

[Remark] the bound zL is not monotone throughout the column generation

(Farley, 1990) a lower bound zL of the master problem optimal value z*R is:

master problem current value

current pricing optimal value


Acceleration techniques

General methods:

Trust region (Madsen, 1975): box constraints on dual variables

Stabilization (Ben Amor 2002, Du Merle et al. 1999): perturbation of RHS by

means of surplus and slack variables and penalization of their usage

Problem specific methods:

Dual cuts (de Carvalho, 2000) adding of valid dual cuts to the master problem

before starting column generation

Slow convergence is mainly due to the oscillation of dual variable values

throughout the column generation.

The bounding of the dual space speeds-up the convergence


Acceleration techniques: stabilization

0x

bAx

xc

minT

Add surplus and slack variables y and y+

Variables y and y+ account for a perturbation of

b by [, +] helping to reduce degeneracy

The perturbation is penalized by and +

+ Ty + +

Ty+

y+ + y

y [0, ]

y+ [0, +]

An optimal solution of the perturbed problem is an optimal solution of the

original problem when the best reduced cost is > 0 and y+ = y = 0

Select starting value of to form a box containing an estimated dual solution

Solve the model.

If the new dual u is in the box [, +] reduce its size and increase the penalty ,

otherwise enlarge the box and decrease the penalty.


Acceleration techniques: stabilization

0ww

wδuwδ

cuA

wεwεub

,

max

T

TTT

Dual perspective

Dual variables u are restricted to the box

[, +]

the deviation w or w+ of u from the box is

penalized by and + respectively.


Dual cuts

A dual cut is an inequality that cuts the dual space. From the primal point of view, a

dual cut is a new variable u :

extended master problem [MPE]

0ux

bDuAx

udx1

,

minTT*

REz

[Theorem] an optimal solution for [MP] can be obtained from any optimal

solution of [MPE] If there exists a map between solutions of [MPE] and [MP]

that preserves the value of the objective function.

hence, in general, [MPE] is a relaxation of

the master problem [MP], but

restricting the dual relaxing the primal

We are interested in dual cuts that preserve at least one optimal dual solution


Dual cuts for CSP

For each part-type i and for each set S Si = {s | ls < li} one has:

i

Ss

s

0 Ss

si is a dual cut

[primal interpretation] a produced part of length li can be used for producing

(at zero cost) a set of parts whose total length is no greater than li

[Property] Let 1, 2 ,…,n be the dual variables of [GG]. If l1 < l2 <…< ln then

1 < 2 <…< n for any optimal solution.

i

Ss

s ll


An example

[Instance] L = 9, n = 2, l = (2,3) d = (d1,d2)

z* = min 1x1 + 1x2 + 1x3 + 1x4

4x1+ 3x2+ 1x3 d1

1x2+ 2x3+ 3x4 d2

x1 x2 x3 x4 > 0[Primal]

w* = max d11 + d22

4 1 < 1

31 + 12 < 1

11 + 22 < 1

32 < 1

1 , 2 > 0[Dual]

[Pricing] {y N2 | 2y1+3y2 < 9}

Dual space1

241 = 1

11 + 22=1

31 + 2=1

32 = 1

2 + 1 < 0Dual cut


From a solution of [MPE] to a solution of [MP]

L = 20

l1 = 3

l2 = 4

l3 = 5

l4 = 7

l5 = 8

2

0

0

2

0

pattern p

xp = 0.3

1

1

0

-1

0

+

dual cut u

u = 0.5 z = 0.3

=

1.1

0.5

0

0.1

0

2

0

0

2

0

pattern p

xp = 0.05

4

2

0

0

0

+

pattern q

xq = 0.25 z = 0.3

=

1.1

0.5

0

0.1

0


From a solution of [MPE] to a solution of [MP]

0 3 6 7 13 20

0.5 0.5

0.5

0.05 0.05 0.05 0.05

0.3

2

0

0

2

0

p

0 3 6 9 1613 20

0.25 0.25 0.25 0.25 0.25 0.25

A dual cut is a cycle where the longest edge is traversed backward

cycles can be combined with paths in order to produce new paths

0.3 0.3 0.3 0.3

0.3

2

0

0

2

0

p

1

1

0

-1

0

u

4

2

0

0

0

q


Dual cuts for CSP

Dual cuts are exponentially many.

De Carvalho uses only those with | S | < 2

i + i + 1 < 0 i = 1,…, n – 1

i + j + k < 0 i, j, k : lj + lk < li

Results:

Beasley, BPP instances: reduction in number of columns (43%) and in running

time (20%).

Vance, CSP instances: reduction in number of columns (76%), in running time

(78%) and in degenerate pivot (from 39.8% to 8.5%).

Belov, Multiple Lenght CSP instances: reduction in number of branch-and-

bound nodes (70%) and in running time (50%)


Node selection strategies

The optimal value of IRUP instances is already known

at the root node.

non-IRUP instances are uncommon.

The problem admits a lot of equivalent optimal solutions

Depth-first search


Branching

A valid branching rule must

cut the current fractional solution,

ensure the finiteness of the algorithm.

A good branching rule should

keep the search space balanced,

preserve the structure of the pricing problem (robustness).

branching rule for CSP

Dichotomy on variables of the pattern-based model (Belov, Degraeve)

Generalization of the Ryan-Foster rule (Vance)

General scheme (Vanderbeck)

Dichotomy on variables of the arc-flow model (de Carvalho)


Branching: dichotomy on pattern variables

*

jj xx

1* jj xx

Easy to implement (by setting bounds on variable) but produces an unbalanced

enumeration tree (up-branching corresponds to a very small sub-tree)

up-branching does not destroy the structure of the pricing problem (the up-

branching node corresponds to a residual CSP)

A variable with upper bound (set by down-branching) may correspond to the

most attractive column generated by the pricing problem. Pricing problem

turns out to be a k-knapsack problem.

*

jx

down-branching

up-branching


Ryan-Foster’s branching rule

Branching rule for the set-partitioning ILP (and for BPP)

min{cTx: Ax = 1, x {0,1}}

101:

skrk aak

kxsame column1

1:

skrk aak

kx

different columns01:

skrk aak

kx

For any fractional solution x one can always identify two rows r and s such that:

Same column: rows r and s must be covered by the same column

Different columns: rows r and s must be covered by different columns


Ryan-Foster’s branching rule: example

0 1 0 1 0 1 1 1 0 0 0 0

1 1 0 0 1 0 0 0 1 0 0 0

1 0 1 1 0 0 1 0 0 1 0 0

0 0 0 1 1 1 1 0 0 0 1 0

1 1 1 0 1 0 1 0 0 0 1 1

= 1

= 1

= 1

= 1

= 1

0.3 0.3 0 0.7 0.3 0 0 0 0 0 0 0

x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12

r

s

0 1

1 1

0 1 1 0 0 0

1 0 0 1 0 0

0 1 0 0 1 0

1 1 0 0 0 1

1 1 0 0 0 1

x5 x7 x8 x9 x10 x11

11: 54

kk aak

kx

0 1 0 1 1 1 0 0 0

1 1 0 0 0 0 1 0 0

1 0 1 1 0 0 0 1 0

0 0 0 1 1 0 0 0 0

1 1 1 0 0 0 0 0 1

x1 x2 x3 x4 x6 x8 x9 x10 x12

01: 54

kk aak

kx

x =

same rows: smaller problem

disjoint rows: easier problem


Ryan-Foster’s branching rule: pricing

0 1 1 0 0 0

1 0 0 1 0 0

0 1 0 0 1 0

1 1 0 0 0 1

1 1 0 0 0 1

x5 x7 x8 x9 x10 x11

0 1 0 1 1 1 0 0 0

1 1 0 0 0 0 1 0 0

1 0 1 1 0 0 0 1 0

0 0 0 1 1 0 0 0 0

1 1 1 0 0 0 0 0 1

x1 x2 x3 x4 x6 x8 x9 x10 x12

11: 54

kk aak

kx

01: 54

kk aak

kx

r

s

duals

1

2

3

r

s

c max{Ty | (y1 y2 y3 1 1) feas. cols.)

pricing

c max{Ty | (y1 y2 y3 yr ys) feas. cols.

and yr + ys < 1 } r

s


Ryan-Foster’s branching rule: correctness

►[Theorem] Ryan-Foster (1981)

For any fractional feasible basic solution x there always exists two rows r and

s such that:10

1:

skrk aak

kx

[proof]

►Suppose xi fractional and select row r such that ari = 1

(a such row always exists)

►Since arTx = 1 and xi fractional, there must exist some

other basic column j such that 0 < xj < 1 and arj = 1.

►Since there are no duplicate columns in the basis, there

must exist some row s such that asi = 1 or asj = 1 but not

both.

1:1:

1

skrkrk aak

k

ak

k xx

xj

1

1 = 1……s 0…

… …… = 1

xi

r 1


Branching: generalization of Ryan-Foster

For any fractional solution x* one can always identify a sub-pattern S (i.e. a

set of rows S (branching set) and a set of integers {i, i S}) such that:

S

j

j

SSj

x αa:

*

down-branching S

j

j

SSj

x αa:

*

Summation boils down to one (fractional) variable x*k if the master problem

consists of only maximal cutting patterns and one chooses S = ak

up-branching 1:

*

S

j

j

SSj

x αa

fractional

branching dichotomy on pattern variables


Branching: general scheme

matrix A of the master problem is converted into a matrix Ab whose columns are

the binary encode of the columns of A.

For any fractional solution x* one can always identify a sub-pattern S (i.e., a set

of rows S of Ab and a vector of bits {i, i S}) such that:

If S = [1] the pricing problem remains a binary knapsack

down-branching S

j

j

SSj

x αa

b:

*

up-branching 1b

:

*

S

j

j

SSj

x αa

S

j

j

SSj

x αa

b:

*

fractional


Branching: dichotomy on arc-flow variables

Our most valuable source of information are the original

variables of the compact formulation; they must be integer, and

they are what we branch and cut on

(Lübbecke Desrosiers, 2005)

Solve [GG] model but branch on

arc-flow variables of [deC] model



For any solution x* of [GG] one can always obtain a solution y* of [deC].

In particular, the flow yij on edge (i, j) is:

Pk

kij xy** P′ = set of cutting patterns

with part-type of length j – i

in position i

Branching dichotomy on

arc-flow variables

*

ijy

*

ijy 1*

ijy

Branching constraints on

[GG] model

*

ijy

Pk

kx*

1*

Pk

kx



robust branch-and-price

Branching constraints do not change

the structure of the pricing problem

(max path on acyclic graph)

j jR xz min

GG

[GG] constraintsnidxp ij jij 1

Branching constraints UpBklx klklj j

j

),( 1),(),(:

p

DwBklx klklj jj

),( ),(),(:

p

Duals

i :

lk :

lk :

In the pricing problem, the cost of edge (l, k) with k l = i is

UpBkl

lk

DwBkl

lkilkc),(),(


An example

L = 8


l1 = 4

l3 = 2

l2 = 3

d1 = 5

d2 = 4

d3 = 8

0

0

2

1p

0

2

0

2p

4

0

0

3p

zR = min x1 + x2 + x3 + x4

2x1 5

2x2 + 2x4 4

4x3 + x4 8

x1 x2 x3 > 0

The optimal solution is xR = (2.5, 0.0, 1.5, 2.0)


dual solution is = (0.5, 0.375, 0.25)

1

2

0

4p


An example

0 2 31 4 5 6 87

2.52.5

1.5 1.5 1.5 1.5

2 2

2

Also y02 , y04 , y24 , y46 and y48 are candidate branching variables

0

0

2

0

2

0

4

0

0

2.5 0.0 1.5 2.0

1

2

0

y68 = 2 + 1.5 = 3.5

y68 > 4y68 < 3

Branching arc-flow variable

x3 + x4 = 3.5

x3 + x4 > 4x3 + x4 < 3

Branching constraints on [GG] model


Research directions

Theoretical issues

Is CSP polynomial for each given n? yes

Is MIRUP property true?

Algorithmic and application issues

Solution of non-IRUP instances

Problem extension (multiple lengths, technological

constraints, integration with scheduling issues)


Some other references

2002 – C. Arbib, F. Di Iorio, F. Marinelli, F. Rossi, “Cutting and Reusing: an Application

from Automobile Component Manufacturing”, Operations Research

2005 – C. Arbib, F. Marinelli, “Integrating Process Optimization and Inventory Planning

in Cutting-Stock with Skiving Option: an Optimization Model and its Application”,

European Journal of Operational Research

2007 – C. Arbib, F. Marinelli, “An Optimization Model for Trim Loss Minimization in an

Automotive Glass Plant”, European Journal of Operational Research

2009 – C. Arbib, F. Marinelli, “Exact and Asymptotically Exact Solutions for a Class of

Assortment Problems”, INFORMS Journal on Computing

2011 – A. Aloisio, C. Arbib, F. Marinelli “On LP Relaxations for the Pattern

Minimization Problem”, Networks

2011 – A. Aloisio, C. Arbib, F. Marinelli, “Cutting Stock with No Three Parts per Pattern:

Work-in-process and Pattern Minimization”, Discrete Optimization

2012 – C. Arbib, F. Marinelli, F. Pezzella, “An LP-based tabu search for batch scheduling

in a cutting process with finite buffers”, International Journal of Production Economics


models and algorithms for

one-dimensional cutting problems

Fabrizio [email protected]

Università Tor Vergata

Roma, November 2013


one-dimensional cutting problems: models and algorithms

Engineering

parts assortment

cutting pattern p

selection of parts

groups of parts

operations fabrizio

parts of type i

stocks assignment

geometric assignment