OK, so let's restart.

We have been talking about constraint propagation problems

in the last lectures.

The idea is that we're doing search

on factored representations.

And that allows us, factored representations

are essentially what constraint satisfaction problems are.

We have a bunch of variables.

We have a bunch of domains.

And the thing with a solution is that you

give each variable a value in its domain

without violating any constraints.

So the solution here is what we call a variable assignment.

We're assigning values to variables.

And the constraints are just basically

that we are not totally free, but we

can do it in certain ways.

So the method of choice, if we're only doing search,

is extending assignments.

Those are the actions.

And we do search over those.

And that's the naive method.

Works very well, especially if you add a couple of heuristics.

And here the heuristics are not problem-specific,

but method-specific.

Remember, the minimum remaining value is heuristic.

It's just basically you look at all,

you look at the internal structure of all

the successor nodes in your search tree.

And then you look at how many values they can still have.

Just a little counting thing, very efficient.

And it gives you very good search guidance.

So if you have, and that's the art in this,

if you have a way of making your problem into a constraint

satisfaction problem, that's what the agent designer does,

then the solving method becomes extremely efficient.

Much more efficient than if you have black box states.

But of course, designing a factored representation

means that you have to choose what your variables are going

to be, what your attributes are, and whether they completely

describe what you do.

Imagine scheduling Bundesliga and forgetting

a couple of variables.

Horrible chaos.

The designer does the work.

And once you've cast the problem into a CSP,

then chances are that you can just basically

take a constraint solver from the shelf,

download it from the network, bring your CSP

into their input syntax, press a button,