Okay, guys. Discrete optimization, this is the, these

are the advanced topics now. They are beautiful.

You should really look at them. But, you know, they are really the

advanced topic of this class. Not strictly mandatory in a sense.

But, you know, they are really nice, so please look at them.

So, so I'm going to talk about column generation, okay?

So, and I'm going to give you a big intro it's kind of one-slide introduction to

tell you what the spirit of it is. And then I'm going to show you the

original example where this was introduced, which is cutting stock.

Okay? So, in a sense you can think about branch

and cut, as we are going to solve this MIP which has an exponential numbers of

constraints. But of course, we don't explore them or

we generate them, you know, one at a time.

Okay, on on demand based on the value of the linear relaxation okay.

So in the particle TSP we were generating the subtour constraints or is com

constraint on demand. Column generation is just another, is,

it's the same idea but reverse. Right so in solving exponentially many

constraints we going to have exponentially many variables.

Okay, and so we want to sort this LP with exponentially many variables.

Okay. Wow that looks crazy right.

But of course we want, we want to list all these variables we're going to

generate them on demand again. Right and so the key point here is that

the variables are not are going to represent complex object nor the simple

decisions that we had before. And I'll talk a little bit about branch

and price which is kind of the use of column generation in branching scheme at

the end. But a key idea would be essentially to do

a branch and bond but using column generation at every one of the nodes.

Okay? So, so this is, this is the cutting stock

example, once again. It came from Gilmore and Gomory.

The same Gomory as the Gomory course of course.

You know, a lot of contribution to coming out of optimization.

And this is, this is what the problem consists of.

So, you have large, you know, wood boards, okay?

Really large, okay? of a particular length.

Okay? And you have you know a large number of

them and you want to cut them into small shelves of different sizes.

Okay and these small shelves are what your customer require.

They don't want very long thing that they are to cut at home.

They, there are ones that are right you know more or less the right side.

the right size, okay? And so for every one of those different

types of shelves, okay. So you have a demand of the popular

customers. You have the length of these shelves and

then the demand of the customer, okay? And so what you need to do is to find how

many boards, you know, big boards you need to actually meet the demand of your

customers. And you, how, and also you want to know

how you have to cut the big boards to actually get to that solution.

Okay, so that's the problem. Okay I'm going to you know show it

visually because it's much more clearer visually.

So these are the big board, that are not that big in the example.

But these are the long boards okay. And these are the types of shelves that

you want to cut okay. So this board here is a length of 110

okay. And so the smallest shelf here is you

know is size 20 the largest is 75 and there are a variety of other sizes in

between. Okay?

And so for every one of these yes, you will have a demand.

Okay? Your customers want 48 of the small

shelf. They want eight of the longer, the

longest shelf. Okay?

And so, so, so, you want essentially to meet the demand of your customers and you

want us to know how you have to, how many of these big boards you want and how you

cut them. Okay?

So this is a particular way to cut them with two of the no, shelf size.

You know, shell size, size 20 and 75. And obviously, you know, the sum of this

is 95, so it fits in the big board. It's one of the valid, you know,

cuttings. This is another cutting which is, you

know, one of five. You know, 50 and 55.

And this is another cutting, you know, 20, 20, 20, 20, 20.

Okay? And so basically what you want to do is

look at these, look at these, look at the various ways you want to cut these

boards, so that you minimize the number of big boards that you are using.

Okay? So this is the first MIP model that I'm

going to show you. It's going to be a terrible model, okay?

But it's the first model that comes to mind, right?

So what you want to do is you want to decide if a particular board, you know

its selected in the optimal solution or not.

So board b is going to be selected. Okay and then you will have a particular

variable x as b which is, going to tells you tell you how many shelf of size s are

basically cut inside are basically available from the cutting of board b.

Okay so if you have for instance 20, 20, 20, 20 you know that's four times, lets

say 5 times 20, you know that's going to tell you that size 20 is cut 5 times in

this particular, in this particular board okay.

So you have five you know shelves of size 20 in that board okay.

Now the constraints that you will have to express inside the may bag are going to

be you know the typical constraint that your having you have these two types of

variables. One of them is going to say oh, I can you

know the board is going to be cut if I. If I actually, board b has is to be cut,

if I'm actually, you know, delivering some shelf from it.

Okay? The second thing that you want is to make

sure that the sum of the things that are basically cut from a bottle of board

don't exceed the size of the board, and then you have to meet the demand of the

customer, okay? So, and the objective of course is to

minimize the number of boards. So, this is a MIP okay, which is

describing that, okay, so you look at the boards, okay?

The set of boards, okay, and you basically minimize the number of them

that you select, okay, simple objective function, [UNKNOWN] zero one variables.

Whether I use a, board b or not, okay. Now, if I'm, so the first set of

constraints is basically telling you that if you are not using board B, you can't

get anything from it. That's what this constraint is using, we

use a big M notation then you basically have you know, x, yb, yb you know,

multiply by M and that basically constraint the value yb multiply by M and

that constraint the value of x as b so if yb is equal to 0, x sb has to be equal to

0, okay? The second type of constraint, second set

of constraint that you have there is basically a capacity constraint.

For every bin, if you sum. The set of the, if you sum the set of

the, of the, of the, if you sum the set of the shelf that you're cutting from

this board, you know, it has to be smaller than the length of the board,

okay? And then you have essentially here the

constraint that is saying you have to meet the demands and then you have the

basically the 0, 1 variables that you have there.

Okay. So, this is the first model that comes,

you know, to mind and one of the things that you see here, is, yeah, so you see

all the, all the types of constraints. And you wonder, you can wonder, is this a

good model or not? Okay?

And the answer is no, this is a terrible model, it has a very bad linear

relaxation. Okay?

And one of the things that you can notice immediately, is that it will have a lot

of symmetries. Okay?

So, essentially, all the boards here. Okay?

All these boards are basically interchangeable.

Which basically means, that if I ever can't figure a cutting with some of these

boards I can just permute this and I have you know a another set of boards.

And as soon as you have something like that in the MIP it's terrible because the

MIP can, you know, even if you have a good bonding you still have to explore

this, you know, rhythm and solution. So you will have to try to break the

symmetries as well. So this is a very bad model actually.

Okay, now one of the question you may ask yourself is that, oh, you know, how many

board do I need, okay. Now there is a very simple upper bounce

of the number of board that you need and you just sum, you know, the demands and

in the worst case you would have board for every one of the demand okay.

So in a sense there is easy upper bound for every one of these things but even

that upper bound this is a very bad model okay.

So what we going to do is move to hyper space okay.

So like in star wars. Okay so we are going to change completely

the way we view this problem okay. And instead of adding these binary

variable you know zero, one whether I use that board or how many items you know how

many shelf of that type I'm cutting with in that board.

I'm going to reason about cutting configuration okay.

So I'm going to say okay this is one way of cutting this board okay.

Do how many of these guys do I select. So I'm not looking, it's very simple

object here. I'm going to look at really complex

object that tells me how I can cut the big board okay.

And so once you have that okay, so will decide which of these cuttings you will

select. To meet the demand, okay?

Now, how is one of these configurations selected, or represented, or

characterized? Essentially, what you have to say is, oh,

this is a configuration that cuts this amount of shelf one, this amount of shelf

two, this amount of shelf n, and so on. Okay?

So, what you need to do is basically specify only, oh, I have a cutting.

This cutting is providing me that many shelves of this type, that many shelves

of that type, and so on. Okay.

That's what I'm going to reason about. Okay.

So, every one of these configurations is basically telling me the various shelves

that I get from it. Okay.

And so, we can find all these configurations.

Okay. We going to discuss how to do that.

But we can find all these configurations. Okay.

And so now, instead of reasoning about, you know, whether I can, how many, he's

just bored, use, and how is, you know, how many of these types of shelves are

cut in the board I'm really using this configuration.

I don't want to reason about these cuttings anymore.

I'm just reasoning I have them, I'm just reasoning about the, the which

configuration I'm going to select. Okay the decision variables are going to

be for a particular configuration c, Xc that's going to be the decision variable

and Xc is going to denote how many times in the optimal solution or in a high

quality solution. I'm selecting that particular type of

configuration okay? So, this is the model, very simple now,

oh, you know, we got rid of all these variables.

Okay. So, what we are saying here is that we

want to minimize the number of boards that we cut, that Xc for every one of the

configuration, how many of these do I select?

You take the sum of this, you want to minimize that.

Okay. Minimize how many of these, of these you

know configuration I'm selecting. So, that's what, you need to think about

them, okay? So this is the number of configuration of

type C. Okay?

The sum is the old, the total number of configurations that I'm cutting.

I want to minimize that. Okay?

And then your only really one constraint. Okay?

Which is how many, you know I need to meet the demands.

Okay. Well how do you do that?

Well you know you have the number of configuration of type you know of type Xc

that you that you are cutting. Okay everyone for every one of the types

of shots that you are requesting is going to give you a number which is NCS.

Okay, NCS is telling you the number of shelf of type S, that configuration c is

providing. Okay, so if you multiply these two, you

have the number of type shelf, of shelves of type S, that are produced by all the

configurations C that I'm producing, that I'm carrying.

And then that has to be greater than the demand for, you know, shelves of type S,

okay? And that's what these constraints is

doing. So once I have this configuration, you

know, I want to minimize the number of them, okay, that I'm selecting, and I

want to meet the demand, okay? And obviously, you know, these values

have to be integers. Okay?

The number of shelves that I'm cutting. Okay?

So this is a much simpler, this is a much simpler model, MIP model okay?

It has also a very strong relaxation. Okay?

And so one of the things that you have to see here is that we got rid entirely on

the capacity constraints on the big board.

Why? Because they are built inside the

configuration. My configuration are valued cuttings.

Okay? So I know that these are rep, that these

are good cuttings. Okay?

They are valid cuttings, they are cutting the big board.

Okay? In pieces.

Okay? And the only thing that I am doing is

really selecting which one I want. Okay and then there are no symmetries

here. All these configuration are different.

I'm just picking the right sub set of configuration.

So I got rid of all the symmetries. I got rid of all the capacity constraints

and I have a beautiful strong relaxation. Okay?

Now I told you that we moved to hyper space right?

So we are basically looking to this the, to the cutting configurations, okay?

Now it's simple zero one variables, okay? How do we find this configuration?

The only thing that we need to do is basically satisfy these capacity

constraints. Every one of these configuration when it

provides a number of shelves of different types that it's providing has to satisfy

this configuration. And this is a very simple constraint,

right. So if we are trying to characterize some

configuration. Okay.

We are going to look at this number and ask, so how many of shelves, of type S,

are we producing in that configuration. And we obviously want to make sure that

when you take the, this type S multiply by size ls, you want to be sure that your

smaller than the length of the big board okay.

So you want so every one of these configuration is going to satisfy that

okay. So we can enumerate the order.

So it's very easy to find this as kind of a simple nap sack constaint with no

objective right. So we can enumerate all these constraints

but in a practical problem, okay. So you will have billions and billions

and billions of them. And so we can't generate them all at the

beginning. And just solve you know the MIP problems

that I've shown you before. So we going to do is you know the same

trick as we did for branch and cut. We are gene-, we are going to generate

these configurations you know one at a time on the mat okay.

So we're going to solve a linear relaxation and then we're going to say

ooh, can I improve this linear relaxation by generating a new configuration okay.

And what happened so, this is the essence of column generation, okay.

It's basically saying, ooh, are these the next configuration?

Or in terms of the linear programming relaxation, it's going to be, what is the

next column that I have to generate? Okay?

So, so this the tableau at a higher level, right?

So you see in this particular case all the variables, which represent the

configurations. So, every one of these column, in a sense

is a configuration, and that configuration is telling you, you know,

how many of this types of shelf, you know, we are producing.

Okay in that particular configuration. So in a sense this big matrix here is

telling you, you know, for a particular configuration how many of these various

types of shelves I'm producing. Okay, and of course, the decision

variables are these Xi, how many of these things we do.

And obviously when you try to have a, you know, the constraint that you are

representing is that the sum of these guys on a particular row has to be

greater than or equal to the demand, okay?

So let's say that we have a bunch of configurations, we solve the LP, we get a

good value, okay, okay? And then we say, ooh, can we improve this

linear relaxation? And what you do is basically say, ooh,

can I find a new column, which when I add that column, okay, I'm going to get a

better linear relaxation? Okay, so you don't want to generate

arbitrary, you know, configuration, you want to generate some of them that will

improve the value of the objective function.

Some of them maybe completely terrible, they are cutting face that you don't

need. You want to just to look at the

particular configuration that because they have a good mix of different types

of self, will improve the linear relaxation.

Okay, that's the goal. Okay, so how do we do that?

Okay, so essentially, you know, a configuration is a column inside the

linear relaxation. Okay, so what is an interesting

configuration? Well, it has to be a co-, a conf-, a

column that whose variable, when I'm adding it inside the linear relaxation,

is going to enter the basis. Okay?

It's going to improve the linear relaxation.

If it's not entering the basis, you know, why would we put it in there.

If it's already optimal, we are adding a column, you know that's basically, not

entering the basis, going to stay the same place, that's terrible right.

So what you want, is to add this column so that they enter the basis and improve

the value of the linear relaxation. Okay, so essentially the way you know

because we cover linear programming before we know that to do that you need

essentially a configuration with a negative reduce cost okay.

So if it's positive it's not going to to enter the basis, if you want a negative

you know reduce cost. What is this cost, this is the ugly ugly

formula that we saw in linear programming, actually it's beautiful but

it's kind of messy. Okay.

So, we going to ignore the constant term, we goonna look only at this term.

Okay. So, let's zoom on it.

Okay? So, this is the part of it which is

really interesting. Okay?

The constant, you know, part, we are not interesting to for, interested in for

generating the new column. You look at this thing, okay, you

specialize it to the problem, which basically means that the constant here,

the C, is going to be one, that's, you know, the cost of one particular

configuration. Okay.

They are all the same, these boards okay and then this the configuration right.

So the configuration is going to specify okay how many of the various types of

shots we will be producing okay. And then you multiply that by CB and you

know the inverse of the basis at this point in the linear relaxation okay.

So we are looking at this thing okay. But what is this guy okay.

We know this guy right? So we know this is essentially you know

the simplex multiper or the dual varibles of the linear relaxation.

Okay, so when we are looking at this, this is essentially, this is essentially

what we will want to become negative okay.

We will want to find a configuration here, you know, which produce these

different types of shelfs which when multiplying by the multiplier I'm

going to make this whole expression negative such that it enter the basis.

OK of course I don't know this and so this is what I want to compute.

I want to compute this really nice configuration such that this expression

using the dual variables are going to give me a number such that that

configuration is going to enter the basis.

Okay so in a sense these multipliers these simplex these dual variables, I

have them. Okay they are already inside my tableau.

Right so I told you how to get that when we talked about linear programming.

So I have these guys, okay so I'm looking at defining these values here, I have

these guys and I have one, okay. And I, I and I know I can try to find

these ends you know using this, you know durable variables search that I will be

able to have a configuration which end to the basis, okay.

So what I'm really doing here is solving an optimization problem, right so I want

these two conditions I want you know a valid, you know cutting of this board.

And I want you know that particular cutting, that particular column to enter

the basis as soon as well when I put it inside the simplex table.

So the feasibility is what I told you before you know I told you that we could

generate billion and billions they have to satisfy this constraint which

basically means the cutting is valid this ns times Ls.

You know, when you sum that, it has to be smaller than the big board, okay and then

I have this quality criteria which say. Ooh, you know, this ns that I'm looking

for, you know, when I, when I used to do variables, when I computed reduced costs,

there, this reduced cost has to be negative, and therefore this part of the

configuration is going to enter the basis, which means we're going to select

that configuration. Right?

And so what you end up doing is solving this beautiful, you know, optimization

problem again, okay. And so this is a problem here where we

are basically basically solving a pro, so we're basically minimizing the value of

the reduced cost. Okay.

So we are trying to meet you know, the capacity constraints of the way, you are

making sure that we are cutting this board in the right fashion.

And obviously this ns has to be integer value.

So this is, this is a, this is a mid problem that we are solving, okay?

Now, if we optimize this, okay, if we optimize this map again, okay, and the

value is small, is negative, then we know, okay?

We know we have a column that's going to enter the basis.

So, great! So, we have a new variable, in a sense.

Okay which will enter the basis and improve the linear relaxation.

Okay? Otherwise, that means that none of them

exist. You could have, you know, exponentially

many of these things. It's billions of things that remain.

You will never improve the linear relaxations.

That means that you have the best linear relaxation at this point.

Okay? So now look at this MIP problem, okay,

can we solve it efficiently? What does it remind you of?

You know once again this is going to be an outside problem.

Okay and so we can solve this problem very very quickly and therefore you know

essentially generating a new column here which can enter the basis is going to

mean I have to solve this outside problem.

Once again we are basically closing the loop with the first lecture, right?

So this how we do column generation then. Okay you generate an initial set of

configuration. For instance we can use one configuration

for it's shelf type and try to pack as many shelf of that type.

Okay. Then you solve the linear program, okay.

So using the existing configuration, if you have an integer solution of [UNKNOWN]

stop, okay. otherwise what you're trying to do is

basically trying to see if you know find a new column find new variable that will

improve the linear relaxation. To do that we have to solve this simple

knapsack problem okay. And so if you solve, if you find these

new column okay, you'll repeat at step two and then you'll continue improving

the linear relaxation adding more and more and more variables.

Okay? Now, once you can't do that, okay, so

what you do, essentially, is that you, one of the things that you can do, and

you do for cutting stock because the linear relaxation is very strong, is to

simply round up all the value of the shelf, of the end variables okay.

Because essentially, you know, that will increase a little bit the number of

shelves that you can because these variables can be fractional.

Okay. so this is an example, so we basically

have this big board. You have the various types of various

demands for various types of shelf. Okay.

We start with a very simple set of configurations.

Okay. We take shelf of size 20, you know we cut

them, we cut as many of them as possible. We do the same thing for 45, for 50, 55,

75 okay. So these are my set of inital

configuration. I solve the linear relaxation.

I was going to select you know a mix of these things okay.

And then I start doing column generation. Can I add new configuration that going to

help me improve the value of the linear relaxation.

The first one that I'm going to find is something that counts 20 and 75 at the

same time. Then something that count 20, 45, and 45

and then another one which is 20, 20, 20, 50.

Okay that's a nice one because it cuts the board you know perfectly and that's

going to be enough to actually find the optimal solution to this linear you know

linear problem with exponential variables.

This is the value of the objective constraints.

This is what you are cutting for everyone of these typical configuration you see

that some of them are fractional right? So for finding a feasible solution you

will have to run that up. Okay?

Which means that in this particular case the value that we'll find the integer

solution is going to be 48. Okay this of usually lower bound okay.

Now if you try to solve this problem optimally okay so this is what you get.

Okay, so this is the first you know so lets say you use the first, you use the

first formulation that I've shown you to solve it optimally you will get 47.

Okay, now what is interesting is the time okay.

The column generation is very very tiny example right.

Is going to take 0.03 in of the systems that we are using okay.

The MIP system, the first MIP formulation is going to take about 4 seconds, that's

about two orders of magnitude right? And so that's essentially the basic.

The basic feature of column generation. It's a very nice technique for scaling up

to very large, for, for large scale problems.

Okay? And so that basically gives you the

essence of column generation. If you want to do branch and price, is

the same idea except that column generation is at one particular node of

the tree. Okay?

So in a sense you have to think about column generation.

Is giving you a very, very good lower bound at every one of the nodes, by

generating variables on the fly. Okay?

And as soon as you do a branching decision, you can start regenerating new

column, okay, for improving the value of the linear relaxation.

Okay? So you basically iterate, you know,

branching, and then doing column generation to find a really nice lower

bound. To that to a very nice lower bound or

upper bound I mean a relaxation a very good relaxation to the particular node

okay. So this is you know a branch, your cum

generation, branch and price very useful in practice.

There are a lot of extension to these things in practice that work very well in

different settings. It's a very interesting setting when you

know you have different kinds of complex objects that you have to manipulate.

Okay, thank you very much, next lecture is going to be on [UNKNOWN] and

scheduling.