# Lecture 8: Constraints: Search, Domain Reduction

Flash and JavaScript are required for this feature.

Description: This lecture covers map coloring and related scheduling problems. We develop pseudocode for the domain reduction algorithm and consider how much constraint propagation is most efficient, and whether to start with the most or least constrained variables.

Instructor: Patrick H. Winston

PATRICK WINSTON: It's too bad, in a way, that we can't paint everything black, because this map coloring problem sure would be a lot easier.

So I don't know what we're going to do about that.

How long is this going to take?

Here's what we're going to do.

We're going to wait till either all the laptops are closed, or this program terminates, whichever comes first.

So how long is this going to take?

I actually don't know.

I think it'll take more than the life time of the universe, but I'm not sure.

So let's take a look at a slightly easier map coloring problem.

We'll stop this one and change the map to something I call [? simplicia. ?]

There's 26 states, one for each letter in the alphabet.

And what we're going to do is we're going to do a depth first search for a suitable coloring of this map.

We're going to go in order, A, B, C, D, E. And as I've suggested here, at each level we're going to rotate the color choices so we don't over use any one color.

So if we launch this particular search, this depth first attempt to color this map.

There it goes.

And maybe we should wait until it terminates.

Or maybe we should just let it run and it'll terminate, perhaps, sometime within the lecture.

Or maybe we should just let it run over the weekend.

Or how long do you think we would have to wait, if we want to come back and watch it terminate?

At roughly 30 frames a second-- I'm calculating it all in my head, I don't want to bet my life on it-- but I think about 5,000 years.

And if we want to use as many states as there are in the United States, in this demonstration, you get up to numbers like 10 to the 17th years-- 17th, 18th, 16th, I'm not exactly sure.

I did a rough calculation.

And, of course, you could do some parallels into that, and it's not as bad as chess, where you need all the atoms in the universe and you still can't do it, and things like that.

Acting as computers.

But still, it's pretty horrendous.

The problem is, well the problem is illustrated by this diagram I put in back of me.

If you do a depth first search and you have a problem like Texas.

If you label... if you assign a color to Arizona, Oklahoma, Arkansas, and Louisiana first, and then wait around to Texas last, then you get yourself into a bind by your fourth choice, that you don't discover until you're 48th choice.

So what happens then, is that you start developing this tree like this, you get to those states surrounding Texas.

Texas is last state assigned a color and there's nothing left for it.

And that problem was there on the fourth choice, and you don't discover it until your 50th choice.

So you develop a horrendous, impossible, impossible search.

So you simply can't do it that way.

But now, not to worry.

I've come equipped with the idea of constraint propagation.

So we could just take a country with four states, like this.

Each can be labeled red, green, blue and yellow.

So just like in a case of line drawings, we'll pile up all the possible things that the value can be-- red, green, blue and yellow.

Red, green, blue and yellow.

And we start up constraint propagation.

So we say for the upper left hand corner state, is there any reason to believe that R is impossible?

Well we look at our neighbors and see what kind of constraint flows in from them.

And sure, this guy could be green, and this guy could be blue.

They don't have to be red, so there's nothing that rules out red.

And there's nothing the rules out blue.

And there's nothing that rules out yellow.

And there's nothing that rules out green.

So constraint propagation just sits there with its finger up its nose, doing nothing.

So it doesn't look like we can use either depth first search, or constraint propagation.

So we could just give up and cry.

But maybe there's some other approach that will help.

So let me actually work the Texas problem.

So with apologies to Houston and Tyler, here's a map of Texas.

There we are.

And here's, roughly speaking, Arizona is over here somewhere.

And we've got Oklahoma in there.

And old Bill Clinton's state, Arkansas.

And then Louisiana sticks out there a little bit.

So there's our map of that particular part of the country.

So we've got Arizona here, Oklahoma here, Arkansas here, and Louisiana here, and Texas here.

And we have elected to assign colors to these states, in that order.

So this is one, two, three, four.

And we're going to do that.

We're going to rotate our color choices, just so we don't over use any one color.

But we're going to also have a look at Texas as we go around.

Because Texas is a state that borders on the States they were choosing colors for.

So the only possible colors that Texas could be are red, green, blue, and yellow.

So as we make our choices around here, we'll say that-- we don't have to adhere to any particular style-- we can say that Arizona is going to get the colored red, R. That's going to rule out R over here for Texas, because no adjacent states can have the same color.

Then we go over to Oklahoma, and we're rotating our color choices, so we'll say that can be green.

And that's fine, because it's consistent with the red here, but it rules out the possibility that Texas could be green.

And then we go over here to Arkansas, red, green, blue.

That's fine, that's consistent with the green on Oklahoma, but if we look at its neighbors we know that Texas is forever forbidden to be blue, now.

So now we go over to Louisiana, and remember, we're rotating our color choices because we don't want to overuse them.

So this means that the first choice we're going to make here, for Louisiana, is yellow.

And that's fine because it's consistent with Arkansas, but it's not so fine because it's now ruled out the last possibility for Texas.

So even though Texas is going to be the 48th state that we color, we're going to say, at this point, there's no need in going on.

We'd better back up.

Because there's nothing left for Texas when we get around to coloring it.

So that means that this yellow is ruled out here.

This yellow reappears.

We select the next color in my line for Louisiana, which happens to be red.

And now that's consistent with this yellow that's still left for Texas.

And it's also consistent with the blue that's up here for Arkansas.

So that's cool.

I wonder if maybe we could make an algorithm out of that, and solve problems like this.

Do you see, sort of, the intuition of what we're doing?

We're actually using the martial arts principle, again.

Because the whole problem is that local constraints, undiscovered local constraints, are causing downstream problems.

So we're going to use the enemy's powers against him, and we're going to look at those local constraints as we go and make sure they're not going downstream, not going to get us later on.

So now I'm going to look like I'm getting a little formal, but I'm just getting a little bit more formal.

Because I want to have some language that I can use to describe what's going on, so that it's clear what the choices are.

So to start off with, we're going to have to have some vocabulary.

So let's start up our vocabulary here.

We're going to have a notion of a variable v. And that's something that can have an assignment.

And a value.

A value x is something that can be in assignment.

It's a little bit circular, but we're all in computer science so you know what I mean.

So the next thing is a little slightly less obvious, and that's the notion of a domain, d.

And that's going to be a bag of values.

OK.

So one more thing.

A constraint.

That's a constraint c, is a limit on-- in our examples it's mostly going to be pairs of variables, pairs of variable values.

But in general, it could be variable values.

So if we go back here to Texas we could say, OK, how does our vocabulary drape itself over that configuration?

And the answer is, the states have the role of variables, the colors have the role of values.

And the domains are the remaining color possibilities that we can still use on a particular state.

And the constraint, in this case, is the simple map coloring constraint that no states that share a boundary can have the same color.

So states are variables, colors are values, domains are bags of colors, and constraints-- there's only one-- adjacent states can't have the same color.

So that's how it fits with this vocabulary.

So now, what did I actually do here?

Well what I actually did here, I'm going to now formalize a little by writing it down in pseudo code.

So here we are, we're going to have a look at what we did here with our intuition, and we're going to reduce it to a procedure.

And here's the procedure.

Remember, we're doing depth first search on this stuff.

I did a depth first search.

We're going to do a depth first search, and for each depth first search assignment-- OK, so here I am, I'm labeling Arizona, and then Oklahoma, and then Arkansas, and then Louisiana.

When I give each one of those a label, a color, I'm going to do this procedure.

Every time I make one of those assignments.

The last one that caused trouble was coloring Louisiana yellow.

Each time I put one of those colors down, each time I make an assignment, I'm going to do this procedure.

So for each depth first search assignment, for each variable v, considered.

Now you don't know what I mean by considered.

But when I put a label, when I put up a value, show something as a color for Louisiana, I thought about Texas.

So I was considering the variable, Texas, when I made the assignment for Louisiana.

Now I'm going to be a little bit vague about what I mean by considered, right now.

Because there are lots of choices about how much stuff you actually consider.

So let me just say consider, and then we'll open that up and talk about the options in a moment, so for each variable v considered for-- let's call that variable v sub i-- for each x sub i, for each value in the domain of that variable, consider each of the things that still surviving.

For each of those, for each constraint c, that's between x sub i, and some x sub j, where x sub j is an element of the domain of j.

Now that sounds awfully fancy, but this just says, in the case of Texas up there, whenever I consider one of the values that's still remaining as a choice for Texas, I want to consider all of the constraints between that variable and the adjacent states.

And I want to be sure that anything I leave in the domain is OK for some selection in the other states, some remaining choices in the other states.

So that's why we're getting pretty nested here.

But we're doing depth first search.

We are considering the variables in a certain collection of variables.

For each one of those where considering all the values that still remain in the domains of those variables.

And then for each of those values, we're checking to see if it satisfies this some constraint, satisfies the constraint that are placed upon it.

So for each of these constraints if there does not exist an x sub j, such that, the constraint between x sub i and x sub j is satisfied, well if in that adjacent place there's nothing that is consistent with a value, then we've got to get rid of it.

If that's true.

If there does not exist some value in an adjacent variable such that that constraint is satisfied, we're hosed.

We've got to get rid of that value.

So we're going to remove x sub i from d sub i.

OK.

Now, that's fine.

That's sort of what I did with Texas.

As soon as I plopped down a value for Louisiana I said, well what are the possible values in Texas?

Red, green, blue and yellow.

Let's consider red.

Let's consider the constraints between Texas and all adjacent states.

One of those constraints says it can't be the same color as Arizona.

The only color I've got available for Arizona, since I've already made the assignment is red.

Red is not consistent with red, so I've got to get rid of it.

So it looks complicated, but it's just intuition.

So what do we do if we get to a situation where the domain is empty?

That means whenever we get around to making assignment to it, there won't be anything left.

So if that ever happens, if the domain ever becomes empty, then what do we do?

We've got to back up.

So the intuition is clear.

This is the algorithm.

The algorithm when you work through it, think about whether it makes sense and what not.

How it fits with Texas.

Yeah, it sure does.

All we're doing is we're making these death first assignments.

And in the neighborhood of those depth first assignments we're looking around to see if the values that are possible include something.

And if they don't include anything, we know we made and irrevocable blunder, and we have to back up.

So that's the essence of the idea.

Now, how well does it work?

Well a little bit depends on what we choose for considered.

There are lots of choices for what we consider.

So let me enumerate some of those choices and then we'll have a look and see what they do.

Oh I guess one possibility is to consider nothing.

Let's try it out.

So our type of search is going to be no checks.

What do you think is going to happen?

We're not even checking the assignment.

That's pretty fast.

Unfortunately, since we haven't even check the most recent assignment, we get lots of places where there are states that are adjacent to each other that have the same color.

That's no good.

So another thing we can do is consider everything everything.

That's no good, because that would say, as soon as we color our first state, we check to make sure that all 47 other states can be colored.

That seems like it over doing it a little bit.

But in any case, at least we want to check the assignment.

So if we go back here and check the assignment, let's see what happens.

Type assignments, assignments only.

Boom.

Aw, gees, that's where I got in trouble before.

This is the thing is going to run for 17 billion years at nanosecond or something like that.

It's only a billion years if you run it at nanosecond speed, so I guess maybe you could do that.

Have a fast computer.

But this isn't going to work because of our unfortunate choice of Texas as the last state to be considered, and the unfortunate coloring of the four surrounding states right up front.

And our unfortunate decision to rotate the color so as to avoid overdoing any one color.

So this doesn't work.

We know we went to the trouble of working out the business with Texas by hand, using the domain reduction algorithm.

Better make a note that this is the domain reduction algorithm.

And what we're going to do is we're going to check the neighbors of the assignments.

Just like we did here.

We checked Texas each time we made one of those four choices, because it's a neighbor of all of the choices of the states that we made.

So one thing to do is to check neighbors.

This is one, two, three, now let's see what happens.

Check neighbors only, go.

Shoot, I don't know.

It's OK with Texas, right?

Because it didn't color the states around Texas with all of the four color choices.

But it's still getting into trouble in other places.

Like the states like Missouri, Kentucky, Virginia, Tennessee, states with lots of boundaries.

So I don't know whether this is going to-- oh, there it finally worked.

It went through a lot of effort, though.

For the sake of comparison, we might make a note that it ran into 9,139 dead ends.

But it did do some good.

It didn't take a length of time longer than the remaining part of the universe.

But if it's a good idea to check the neighbors, if we make a change to the neighbors, what might that suggests that we do in addition?

Well it might suggest that if we make a change to a neighbor, that we check its neighbors, too, make sure they're all right.

So another choice is to propagate.

So propagate through variables with reduced domains.

Let's see how that works.

Wait a minute.

I must have made a mistake.

Let's try that again.

Oh, maybe we better slow it down.

All that grey stuff is showing the limit of the propagation.

Man it's, let's see at four second of 40, that's about 10 seconds.

Boom.

And it was a lot faster.

I didn't happen to notice how many constraints were checked on that other thing, I think it was around 20,000 or so.

This is a lot less.

So this looks like a good idea.

But why did I label it number five?

Well because there's something between this and number three.

So number four is, through v with d reduced to one value.

So we're not going to propagate through all of the variables which have their domains shrunk a little bit.

We're only going to propagate through those that have the greater shrinkage, all the way down to a single value.

So let's see how that might work.

Anybody want to place any bets on this one?

Let's see.

We checked 2,623 constraints last time.

Let's see what happens this time.

You can see that the extent of the gray is less, because it's not propagating so far.

And as we breathily await the answer, I'd say we've found our winner.

As this does a couple of dead ends, but the number of constraint checked is less than 1,000.

So in general, with problems this, you have all of these choices for what you consider.

You don't want to consider nothing, because then you're not honoring your constraints.

You'll certainly want to consider the things you just made assignments for, because otherwise you'll construct a solution that violates a constraint.

You don't want to do everything, because that's excessive work.

And so checking the neighbors is a good idea, but it's always better in practice.

In practice, inevitably it's the case that it's better to do some propagation through the things that you've changed.

How much propagation?

It doesn't seem to do much good to propagate through things are just changed.

But it does seem to do some good to propagate through the things that have changed and been reduced to a single value.

So as soon as you get a neighbor of some assignment you just made that has its domain reduced to a single value, then you check its neighbors, too.

So you check the neighbors, of the neighbors, of the neighbors, of the neighbors, on and on and on, as long as you've found a domain being reduced.

And not only being reduced, but reduced to a signal value.

All right?

So that's the demand reduction algorithm.

And I guarantee you a problem like that.

And I know you don't know how to work those problems yet, because this is a little bit abstract.

And to work these problems in the exam setting you need to know a little bit about how to keep track of the variable values that remain in the domain, and that sort of thing.

So we could go home except that there are few little flourishes to deal with here.

And those flourishes, include some dirty, filthy little secrets.

For example, I've chosen, as my classroom example, to pick on Texas.

And arranged for this situation to be especially ugly.

So I could arrange the states in a different way.

We have highly constrained states, that have a lot of bordering states around them.

And we have other states, like Maine, up there, that only borders on one other state.

So I don't know.

Will, what do you think?

Should we arrange the states for our death first search in the order of least constrained to most constrained, or most constrained to least constrained?

In other words, should we start with Missouri, or Tennessee, or Kentucky, or something like that?

What do you think?

You have a 50% chance of getting it right, just by [? looking ?] at points.

PROF.

PATRICK WINSTON: He thinks we should start with the most constraint first.

Do we have a volunteer who wants to suggest that we start with the least constraint first?

That's the way I always work on stuff.

I'm working on a book or something, I have 500 things to fix, I'll always choose to work on the easiest stuff first, so that I feel like I'm making the list a lot smaller.

Leave the hardest things to last.

But we don't have any volunteers who want to bet on that idea of least constraint first?

OK.

Jason wants to suggest that we should work on least constraint first.

Well we have ground truth, because we can just try it out.

I guess we'll stick with our shrinking to one value thing, here.

But we will reorder things so that we have the least constrained first.

So right away, we got a color for Maine.

Maybe we ought to speed this up a little bit.

Well, that's a good idea.

Jason suggested this and we only 1,732 constraints and we had 59 dead ends.

So let's try the other way around, and we'll go back to four frames a second.

So we're working, kind of from the middle of the country out, with this one.

We're going to deal with Maine, I guess, last.

Which is better.

Too bad, I think it looks like this is better.

In fact, let's not be so aggressive with the use of constraint propagation.

Let's just check the assignments only.

If we go back to an arrangement where we have least constrained first, and we'll crank up the speed.

Well actually, we would have to crank it up pretty big, because the states like Missouri, Tennessee, Kentucky, they're going to be like Texas.

And so were kind of back to the length of the universe type problem, here.

With the least constraint first, and no use of constraints, other than to check the current assignment.

So let's stop that, though, and check the most constrained first, assignments only.

I don't know how long's this going to take.

That's the dirty little secret.

If we had arranged our states from most constrained to least constrained, ordinary depth first search with none of this stuff we talked about today would work just fine.

All right.

So it's a little bit like games.

Do you use progressive deepening, or do you use alpha beta?

You use everything you've got to deal with the problems.

And depending on the problem, one or another of the things you incorporate into your approach will work just great, if you're lucky.

So now, I promise that this is useful not only for people who want to color maps.

God, who wants to do that?

We know it can be done with four colors.

But it's also useful for doing all kinds of resource planning problems.

So I want to show you a resource planning problem, and I want you think about-- while I'm doing it-- think about whether it's actually analogous to the map coloring problem.

All right?

So here's the deal.

You have just landed a summer job with the Jet Green, a new airline.

And Jet Green is a low cost, no frills, hardly any maintenance type of airline.

And they want to fly mostly between Boston and New York.

Occasionally they want to fly to Los Angeles.

And they're trying to get by with the smallest number of airplanes.

So that's why we have a kind of resource allocation problem with Jet Green.

So I'm going to write down what their schedule looks like.

They have one flight, F1, that goes from Boston to JFK, like so.

It's an early in the day flight.

Then they want to have another one, F2, that flies from JFK to Boston.

And then they want to have another flight a little later in the day that flies from Boston to JFK.

And a little later than that, they want to have another flight that goes from JFK to Boston.

They're going to start off mostly as a shuttle airline in the beginning.

So that's F1, F2, F3, and F4.

And they have a fifth flight, F5, that goes from Boston to Los Angeles, that takes a long time.

So it looks like this on the schedule.

Of course we have time going that way.

So that's Boston to LAX.

Now your job is to determine if they can fly this schedule with four aircraft?

And naturally you don't want to over use any one aircraft, because you would like to have even wear on them.

Right?

So as you make your choices, you'll rotate the aircraft.

So you'll assign to this one to A1, aircraft number one.

This one will be A2.

This one will be A3.

And this one will be A4.

And, oops, there's no aircraft left for the flight to Los Angeles, because you only have four.

So, it's obvious, right?

This is 100%, exactly, the map coloring problem, even down to the four choices.

Because, you have the constraint, the no single physical aircraft can fly two flights at the same time.

Just like no two adjacent states can be colored the same.

So there's a no same time constraint, like so.

So if you were assigning aircraft to these flights, you would get down to F4, the fourth flight, and you would say, well, let's see, this guy down here can be A1, A2, A3, or A4.

But if I choose A4 for that fourth flight, then there would be nothing left in its domain.

So you've thus set the problem up to be identical to the map coloring problem.

And, of course, you can enrich it with other kinds of constraints.

So, for example, you might have-- this is a not same time constraint-- and these, I mean, this is at JFK.

And it flies out of JFK, so maybe you can use the same aircraft for those.

But not if they're right up against each other, because you have a minimum ground time rule.

So there's a minimum ground time constraint here.

And there's a minimum ground time constraint here.

There's a minimum ground time constraint here.

And if these are at the same city, then you've got to allow enough time for them to fly between the two cities that are involved.

So the constraints can get a little bit more complicated, but the idea is the same.

So you say to me, I don't trust you, show me.

OK.

So let me show you.

Oh, by the way, there's one more way to make this map coloring problem easier, right?

Let's see.

The arrangement is going to be alphabetical, the type is going to be assignments only, and we know that's a loser.

But not if we use a whole lot of colors.

So it's the use of four colors that got us into trouble.

Now that's an aside, but it'll be coming back in a moment or two.

Scheduling, here's that problem.

Boom.

You can almost see it working just like the map coloring thing.

But that's maybe too easy.

Let's do this one.

See this is just like [? simplicia. ?]

We've kind of got a goofy arrangement here that's guaranteed to lose at the bottom because of choices made at the top.

But that's OK.

We can that we can stop this, and we can change to check neighbors only.

And boom, there it goes.

Or alternatively, let me see if I can do it this way.

Most constrained first, type will be assignments only.

Boom.

That worked fine, too.

So you might choose to have a slightly harder problem, like this.

And we can search away.

Actually I don't know if this will complete or not.

This is a randomly generated example.

But you're going to lose your summer job if you can't figure out whether you can do this, or not.

So what are you going to do?

[? Elliott, ?] you got any thoughts about how you're going to save your job?

So here's the question you've been asked.

How many airplanes does Jet Green need?

And you decide, well, four seemed to work before, so we'll try four here.

You're not sure if it's going to terminate or not, I mean, in your lifetime, let alone in your summer job.

[? Elliott, ?] let me give you a hint.

Look at the outline.

The outline up here, on the board, the last item.

[? ELLIOTT: [INAUDIBLE] ?]

PROF.

PATRICK WINSTON: Yeah, what's that mean?

What's the maximum number of airplanes we're going to need?

Suppose we've got five flights, what's the maximum number of airplanes we would ever need?

Five.

What's the minimum number of airplanes we'll need?

One.

So let's try it with a small number of airplanes and a large number of airplanes.

So that showed us very fast that we can't do it with one airplane.

That showed us very fast we can do it with ten airplanes.

SPEAKER 1: [INAUDIBLE]

amount of overlappage from up [INAUDIBLE].

PROF.

PATRICK WINSTON: Volunteer?

What are we going to do to find the actual number, as fast as possible.

And at least give our boss a reasonable answer, even if not necessarily the exact number very fast?

It's easy, right?

We're going to start up here with one computer, and we're going to start down here with another computer, and see what happens.

So let's see if we can do it with nine.

Let's see if we can do it with eight.

Let's see if we can do it with seven.

These take almost zero time, right?

Because they're under constraint.

Wow, that's good, seven.

Let's try six.

Actually let's try two.

It loses fast.

Let's try three.

I don't know.

Maybe if you let it run one long enough three will work.

I doubt it.

While we're at it though, we might as well go back here and try it with six.

Remember seven worked real fast.

Gees, six, that was six, right?

Yeah.

So let's try it with five.

OK.

So it runs real fast with five.

It terminates real quick with two, so we got three and four left.

So we could tell our boss, a la any time algorithm, that you're not real sure, but you know it's going to be either three or four.

And then, you got two computers.

You can let both run and see if either one terminate.

So you have three and four.

My guess is that three will eventually give up.

But of course, there's another little problem here.

We haven't used the most constraint first.

If we did that, we might be able to do it even faster.

Actually, I don't think I can make that switch without getting another random assignment, but let's see what happens.

Maybe so.

SPEAKER 2: [INAUDIBLE]

PROF.

OK.

So it didn't help to actually switch.

And I think I've got a new schedule to work here.

So that's the end of the story.

You can do good resource allocation if you do several things are once.

Number one, you always want to use most constraint first.

Number two you want to propagate through domains produced to a single algorithm.

And number three, if you really try to figure out what the minimum number of resources needed is, you do this under over business and you can quickly converge on a narrow range where the search is taking a long time, and be sure that it lies within that narrow range.

Because when you over resource, it's fast to complete, and when you under resource, it's fast to terminate.

So you can just squeeze it right down into a very small range.

And that is the end of the story.