Forward Checking Research Articles

Generalised graph colouring by a hybrid of local search and constraint programming

The IMPASSE class of local search algorithms have given good results on many vertex colouring benchmarks. Previous work enhanced IMPASSE by adding the constraint programming technique of forward checking, in order to prune colouration neighbourhoods during search. On several large graphs the algorithm found the best known colourings. This paper extends the work by improving the heuristics and generalising the approach to bandwidth multicolouring. It is shown to give better results than a related search algorithm on an integer programming model, and to be competitive with published results. Experiments indicate that stronger constraint propagation further improves search performance, but that a symmetry breaking technique has unpredictable effects.

Asynchronous Forward-checking for DisCSPs

A new search algorithm for solving distributed constraint satisfaction problems (DisCSPs) is presented. Agents assign variables sequentially, but perform forward checking asynchronously. The asynchronous forward-checking algorithm (AFC) is a distributed search algorithm that keeps one consistent partial assignment at all times. Forward checking is performed by sending copies of the partial assignment to all unassigned agents concurrently. The algorithm is described in detail and its correctness proven. The sequential assignment method of AFC leads naturally to dynamic ordering of agents during search. Several ordering heuristics are presented. The three best heuristics are evaluated and shown to improve the performance of AFC with static order by a large factor. An experimental comparison of AFC to asynchronous backtracking (ABT) on randomly generated DisCSPs is also presented. AFC with ordering heuristics outperforms ABT by a large factor on the harder instances of random DisCSPs. These results hold for two measures of performance: number of non-concurrent constraints checks and number of messages sent.

Molecular Query Language (MQL)A Context-Free Grammar for Substructure Matching

We have developed a Java library for substructure matching that features easy-to-read syntax and extensibility. This molecular query language (MQL) is grounded on a context-free grammar, which allows for straightforward modification and extension. The formal description of MQL is provided in this paper. Molecule primitives are atoms, bonds, properties, branching, and rings. User-defined features can be added via a Java interface. In MQL, molecules are represented as graphs. Substructure matching was implemented using the Ullmann algorithm because of favorable run-time performance. The Ullmann algorithm carries out a fast subgraph isomorphism search by combining backtracking with effective forward checking. MQL software design was driven by the aim to facilitate the use of various cheminformatics toolkits. Two Java interfaces provide a bridge from our MQL package to an external toolkit: the first one provides the matching rules for every feature of a particular toolkit; the second one converts the found match from the internal format of MQL to the format of the external toolkit. We already implemented these interfaces for the Chemistry Development Toolkit.

Combining Systematic and Local Search for Approximately Solving Fuzzy Constraint Satisfaction Problems

A fuzzy constraint satisfaction problem (FCSP) is an extension of the classical CSP, a powerful tool for modeling various problems based on constraints among variables. Basically, the algorithms for solving CSPs are classified into two categories: the systematic search (complete methods based on search trees) and the local search (approximate methods based on iterative improvement). Both have merits and demerits. Recently, much attention has been paid to hybrid methods for integrating both merits to solve CSPs efficiently, but no such attempt has been made so far for solving FCSPs. In this paper, we present a hybrid, approximate method for solving FCSPs. The method, called the Spread-Repair-Shrink (SRS) algorithm, combines a systematic search with the Spread-Repair (SR) algorithm, a local search method recently developed by the authors. The SRS algorithm spreads (or expands) and shrinks a set of search trees in order to repair constraints locally until, finally, the satisfaction degree of the worst constraints (which are the roots of the trees) is improved. We empirically show that SRS outperforms the SR algorithm as well as the well-known methods such as Forward Checking and Fuzzy GENET, when the size of the problems is sufficiently large.

Classification of three-class association schemes using backtracking with dynamic variable ordering

We describe several techniques for the exhaustive computer generation of non-isomorphic association schemes with a given set of intersection numbers using a backtracking algorithm with forward checking and dynamic variable ordering. We have applied these techniques to the classification of certain open parameter sets for three-class association schemes listed by Van Dam in (Three-class association schemes, J. Algebraic Combin. 10 (1999) 69–107) for which we present several new results. Among these are some new (imprimitive) distance regular graphs of diameter 3.

A constraint propagation heuristic for the single-hoist, multiple-products scheduling problem

A heuristic algorithm for solving the single-hoist, multiple-product scheduling problem is presented. The algorithm uses a non-standard Constraint Satisfaction Problem model and employs variable ordering, forward checking and backtracking. Computational results, including comparison with existing algorithms in terms of solution quality and speed, are presented.

Solution Techniques for Constraint Satisfaction Problems

A wide range of problems in Artificial Intelligence can be represented as instances of the Constraint Satisfaction Problem (CSP), and then be solved using some of the existing techniques for solving CSPs. In this paper, we start by defining the concept of CSP and showing how some combinatorial problems can be modelled as CSPs. Next, we give a detailed description of the basic techniques for constraint satisfaction: constraint propagation algorithms (node consistency, arc consistency, and kconsistency), search algorithms (generate and test, backtracking, backjumping, and conflict-directed backjumping), and hybrid algorithms (forward checking, and maintaining arc consistency).

On forward checking for non-binary constraint satisfaction

Solving non-binary constraint satisfaction problems, a crucial challenge today, can be tackled in two different ways: translating the non-binary problem into an equivalent binary one, or extending binary search algorithms to solve directly the original problem. The latter option raises some issues when we want to extend definitions written for the binary case. This paper focuses on the well-known forward checking algorithm, and shows that it can be generalized to several non-binary versions, all fitting its binary definition. The classical non-binary version, proposed by Van Hentenryck, is only one of these generalizations.

Binary vs. non-binary constraints

There are two well known transformations from non-binary constraints to binary constraints applicable to constraint satisfaction problems (CSPs) with finite domains: the dual transformation and the hidden (variable) transformation. We perform a detailed formal comparison of these two transformations. Our comparison focuses on two backtracking algorithms that maintain a local consistency property at each node in their search tree: the forward checking and maintaining arc consistency algorithms. We first compare local consistency techniques such as arc consistency in terms of their inferential power when they are applied to the original (non-binary) formulation and to each of its binary transformations. For example, we prove that enforcing arc consistency on the original formulation is equivalent to enforcing it on the hidden transformation. We then extend these results to the two backtracking algorithms. We are able to give either a theoretical bound on how much one formulation is better than another, or examples that show such a bound does not exist. For example, we prove that the performance of the forward checking algorithm applied to the hidden transformation of a problem is within a polynomial bound of the performance of the same algorithm applied to the dual transformation of the problem. Our results can be used to help decide if applying one of these transformations to all (or part) of a constraint satisfaction model would be beneficial.

Backjump-based backtracking for constraint satisfaction problems

The performance of backtracking algorithms for solving finite-domain constraint satisfaction problems can be improved substantially by look-back and look-ahead methods. Look-back techniques extract information by analyzing failing search paths that are terminated by dead-ends. Look-ahead techniques use constraint propagation algorithms to avoid such dead-ends altogether. This paper describes a number of look-back variants including backjumping and constraint recording which recognize and avoid some unnecessary explorations of the search space. The last portion of the paper gives an overview of look-ahead methods such as forward checking and dynamic variable ordering, and discusses their combination with backjumping.

Coloration Neighbourhood Search With Forward Checking

Two contrasting search paradigms for solving combinatorial problems are i>systematic backtracking and i>local search. The former is often effective on highly structured problems because of its ability to exploit consistency techniques, while the latter tends to scale better on very large problems. Neither approach is ideal for all problems, and a current trend in artificial intelligence is the hybridisation of search techniques. This paper describes a use of forward checking in local search: pruning coloration neighbourhoods for graph colouring. The approach is evaluated on standard benchmarks and compared with several other algorithms. Good results are obtained; in particular, one variant finds improved colourings on geometric graphs, while another is very effective on equipartite graphs. Its application to other combinatorial problems is discussed.

Combining the Scalability of Local Search with the Pruning Techniques of Systematic Search

Systematic backtracking is used in many constraint solvers and combinatorial optimisation algorithms. It is complete and can be combined with powerful search pruning techniques such as branch-and-bound, constraint propagation and dynamic variable ordering. However, it often scales poorly to large problems. Local search is incomplete, and has the additional drawback that it cannot exploit pruning techniques, making it uncompetitive on some problems. Nevertheless its scalability makes it superior for many large applications. This paper describes a hybrid approach called Incomplete Dynamic Backtracking, a very flexible form of backtracking that sacrifices completeness to achieve the scalability of local search. It is combined with forward checking and dynamic variable ordering, and evaluated on three combinatorial problems: on the n-queens problem it out-performs the best local search algorithms; it finds large optimal Golomb rulers much more quickly than a constraint-based backtracker, and better rulers than a genetic algorithm; and on benchmark graphs it finds larger cliques than almost all other tested algorithms. We argue that this form of backtracking is actually local search in a space of consistent partial assignments, offering a generic way of combining standard pruning techniques with local search.

Determining if (FC-) (conflict-directed) backjumping visits a given node is NP-hard

Conflict-directed backjumping is a modification of the backtracking algorithm that can outperform forward checking in non-pathological examples. We prove it is in general NP-hard to determine if backjumping or conflict-directed backjumping or their forward checking hybrids visit a given node of a search space. This shows that these algorithms are fundamentally more complex to analyze than backtracking and forward checking. We conclude by describing how similar results can be proved for versions of the Maintaining Arc Consistency algorithm.

Modular lazy search for Constraint Satisfaction Problems

We describe a unified, lazy, declarative framework for solving constraint satisfaction problems, an important subclass of combinatorial search problems. These problems are both practically significant and computationally hard. Finding solutions involves combining good general-purpose search algorithms with problem-specific heuristics. Conventional imperative algorithms are usually implemented and presented monolithically, which makes them hard to understand and reuse, even though new algorithms often are combinations of simpler ones. Lazy functional languages, such as Haskell, encourage modular structuring of search algorithms by separating the generation and testing of potential solutions into distinct functions communicating through an explicit, lazy intermediate data structure. But only relatively simple search algorithms have been treated this way in the past. Our framework uses a generic generation and pruning algorithm parameterized by a labeling function that annotates search trees with conflict sets. We show that many advanced imperative search algorithms, including conflict-directed backjumping, backmarking, minimal forward checking, and fail-first dynamic variable ordering, can be obtained by suitable instantiation of the labeling function. More importantly, arbitrary combinations of these algorithms can be built by simply composing their labeling functions. Our modular algorithms are as efficient as the monolithic imperative algorithms in the sense that they make the same number of consistency checks, and most of our algorithms are within a constant factor of their imperative counterparts in runtime and space usage. We believe our framework is especially well-suited for experimenting to find good combinations of algorithms for specific problems.

Domain Filtering Consistencies

Enforcing local consistencies is one of the main features of constraint reasoning. Which level of local consistency should be used when searching for solutions in a constraint network is a basic question. Arc consistency and partial forms of arc consistency have been widely studied, and have been known for sometime through the forward checking or the MAC search algorithms. Until recently, stronger forms of local consistency remained limited to those that change the structure of the constraint graph, and thus, could not be used in practice, especially on large networks. This paper focuses on the local consistencies that are stronger than arc consistency, without changing the structure of the network, i.e., only removing inconsistent values from the domains. In the last five years, several such local consistencies have been proposed by us or by others. We make an overview of all of them, and highlight some relations between them. We compare them both theoretically and experimentally, considering their pruning efficiency and the time required to enforce them.

On the relations between SAT and CSP enumerative algorithms

We show the equivalence between the so-called Davis–Putnam procedure (Davis et al., Comm. ACM 5 (1962) 394–397; Davis and Putnam (J. ACM 7 (1960) 201–215)) and the Forward Checking of Haralick and Elliot (Artificial Intelligence 14 (1980) 263–313). Both apply the paradigm choose and propagate in two different formalisms, namely the propositional calculus and the constraint satisfaction problems formalism. They happen to be strictly equivalent as soon as a compatible instantiation order is chosen. This equivalence is shown considering the resolution of the clausal expression of a CSP by the Davis–Putnam procedure.

Decomposable constraints

Many constraint satisfaction problems can be naturally and efficiently modelled using non-binary constraints like the “all-different” and “global cardinality” constraints. Certain classes of these non-binary constraints are “network decomposable” as they can be represented by binary constraints on the same set of variables. We compare theoretically the levels of consistency which are achieved on non-binary constraints to those achieved on their binary decomposition. We present many results about the level of consistency achieved by the forward checking algorithm and its various generalizations to non-binary constraints. We also compare the level of consistency achieved by arc-consistency and its generalization to non-binary constraints, and identify special cases of non-binary decomposable constraints where weaker or stronger conditions, than in the general case, hold. We also analyze the cost, in consistency checks, required to achieve certain levels of consistency, and we present experimental results on benchmark domains that demonstrate the practical usefulness of our theoretical analysis.

Backtracking algorithms for disjunctions of temporal constraints

We extend the framework of simple temporal problems studied originally by Dechter, Meiri and Pearl to consider constraints of the form x 1−y 1≤r 1 ∨⋯∨ x n−y n≤r n , where x 1,…,x n,y 1,…,y n are variables ranging over the real numbers, r 1,…,r n are real constants, and n≥1 . This is a wide class of temporal constraints that can be used to model a variety of problems in temporal reasoning, scheduling, planning, and temporal constraint databases. We have implemented several progressively more efficient algorithms for the consistency checking problem for this class of temporal constraints: backtracking, backjumping, three variations of forward checking, and forward checking with backjumping. We have partially ordered the above algorithms according to the number of visited search nodes and the number of performed consistency checks. Although our problem is non-binary, our results agree with the results of Kondrak and van Beek who consider only binary constraints. We have also studied the performance of the above algorithms experimentally using randomly generated sets of data and job shop scheduling problems. The experiments with random instances allowed us to locate the hard region for this class of problems. The results show that hard problems occur at a critical value of the ratio of disjunctions to variables.

Planning Graph as a (Dynamic) CSP: Exploiting EBL, DDB and other CSP Search Techniques in Graphplan

This paper reviews the connections between Graphplan's planning-graph and the dynamic constraint satisfaction problem and motivates the need for adapting CSP search techniques to the Graphplan algorithm. It then describes how explanation based learning, dependency directed backtracking, dynamic variable ordering, forward checking, sticky values and random-restart search strategies can be adapted to Graphplan. Empirical results are provided to demonstrate that these augmentations improve Graphplan's performance significantly (up to 1000x speedups) on several benchmark problems. Special attention is paid to the explanation-based learning and dependency directed backtracking techniques as they are empirically found to be most useful in improving the performance of Graphplan.

Dynamic variable ordering in graph based backjumping algorithms for csps

Constraint Satisfaction Problems (CSPs) belong to the class of NP-Complete problems. Backtracking algorithm is generally used for solving these problems. However, it is not very useful as the class of problems it can solve within practical resource limits is small. Researchers have developed a large number of algorithms for enhancing the performance of backtracking algorithm. The Graph Based Backjumping (GBJ) algorithm proposed by Dechter [2] improves its performance by using the knowledge extracted from the graphical representation of CSPs called the constraint graph. That is, whenever a dead-end occurs at a particular variable X, the algorithm backs up to the most recent variable connected to X in the graph. This avoids the algorithm from performing redundant consistency checks which is one of the measures of performance for CSPs. Prosser [18] has proposed the hybrids of this algorithm namely the Backmarking with GBJ (BM-GBJ) and Forward Checking with GBJ (FC-GBJ) as further improvements of GBJ. P. V. Run [ 2] has proposed a methodology for implementing the Dynamic Variable Ordering (DVO) [9,11] in tree search algorithms and have shown that it results in a significant improvements in many of them. In this paper, we have investigated the implementation of Dynamic Variable Ordering (DVO) heuristic of instantiating next the variable with the Minimum Remaining Values (MRV) in the graph based backjumping algorithms. The three new algorithms developed are GBJvar, BM-GBJvar and FC-GBJvar. The empirical performance of these algorithms with and without DVO on Zebra problem, TV-queens problems and on random CSPs are tested. Our results demonstrate that without DVO, BM-GBJ is the best algorithm than GBJ and FC-GBJ in all the problems tested. However, when DVO is implemented in them then FC-GBJvar is found to be the best algorithm to solve all the problem.