A Brief on "Constraint Networks" by Rina Dechter and "Constraint Satisfaction" by Alan Mackworth

Constraint Satisfaction Problems (CSPs) represent an important class of problems. One of the most important aspects of CSPs is that a problem can be formulated in a "declarative" manner, i.e. (as the name suggests) the problem can be presented as a list of constraints. Each constraint is made up of one or more variables (whose relationship to each other within the constraint is problem dependent; typically these relationships are created in first order logic). Each variable may appear in one or more constraints and has a domain of possible values. A solution to a CSP requires that all constraints have a legal assignment to each of their variables (i.e. a value from the variables domain) that does not violate any of the relationships that the constraints establish.

As noted above CSPs are formulated in a declarative manner, which is to say that the problem is presented to some "black-box" solution engine (in what ever language that the engine understands) as an "equation". The engine then attempts to solve this equation using whatever technique(s) that the engine embodies. This is an important distinction from the more traditional problem solving methods of computer science of coding explicit mechanisms or procedures for solving specific problem. The separation of problem representation and problem solution mechanism in CSP has lead to a wide variety of mechanisms. One of the earliest methods developed to solve CSPs is that of depth-first search with backtracking. Unfortunately the shear size of the search space of a CSP may make even this technique impractical. Which brings us to two articles "Constraint Networks" and "Constraint Satisfaction" which provide more robust techniques for CSP solution engines.

The first article "Constraint Networks" by Rina Dechter presents CSPs solution mechanisms in the context of graph or network. This takes the form of creating a graph where the nodes are variables and the arcs are dependencies between variables (i.e. the two connected variables appear in the same constraint). By representing the overall CSP as a graph structure driven algorithms can be use topological features of the graph to guide the search. A large number of techniques for improving the search are presented. These include pre-processing the graph to derive a more tree-like structure (tree's being easier to solve, as they lack the interdependency that comes with cycles) by removing arcs to derive acyclic graphs that are consistent with the original graph, or adding constraints to create a "backtrack-free" graph via enforced directional consistency. Another method is to decompose the graph into non-separable sub-graphs that can then be solved independently or as independently as possible (i.e. recognizing variables between otherwise independent sub-graphs). In addition this sub-graph independence can be used to take advantage of the greater ease of solution of trees by recognizing when a sub-graph is a tree thus allowing the switching over to tree-based search methods.

Graphs can also be used to find a location to directly backtrack to (i.e. backjumping) over variables which might take on other values but which do not lead to a solution or in other words avoid an exhaustive search of the local solution space when this can be determined that it does not include a solution. Another technique is constraint-recording (or dependency-directed backtracking) which allows the assertion of new constraints based on some sub-set of the variable assignments that caused the dead end. As this sub-set of variable assignments may have been costly to explore in the first place, a significant savings can be achieved by recording the new constraint.

"Constraint Satisfaction" by Alan K. Mackworth gives the other half of CSPs, that of problem representation more attention than does Dechter by presenting a more detailed representation scheme using first order logic. Mackworth also spends more time explaining some of the problems with backtracking, such as it can be very slow given the typical size of the search space or the fact that it can "trash", which is to say that backtracking can repeatedly move through the same set of solutions in a local area of the search space that is ultimately a dead end. Mackworth suggests several techniques for avoiding these problems including dependency-directed backtracking (as Dechter presents) and belief maintenance systems).

Mackworth also presents another important class of search methods called consistency algorithms which are complementary to backtracking. This technique, which is based on graphical representations of CSPs as presented by Dechter, removes local inconsistencies (i.e. partial variable assignments) that will never lead to an overall solution to the problem (much like new constraint recording) which is propagated through the constraint graph.

In conclusion, both Mackworth and Dechter consider the topological theory and analysis that the graph representation of CSPs allows to be an important area of exploration. They consider the topology of the constraint graph to be a critical factor in the solution of CSPs.