Abstract: We extend the Constraint Logic Programming (CLP) formalism in order to handle semiringbased constraint systems. This allows us to perform in the same language both constraint solving and optimization. In fact, constraint systems based on semirings are able to model both classical constraint solving and more sophisticated features like uncertainty, probability, fuzzyness, and optimization. We then provide this class of languages with three equivalent semantics: model-theoretic, fixpoint, and proof-theoretic, in the style of CLP programs.

Abstract: The natural representation of employee timetabling problems (ETPs), as constraint networks (CNs), has variables representing tasks and values representing employees that are assigned to tasks. In this representation, ETPs have binary constraints of non-equality (mutual exclusion), the networks are non uniform, and variables have different domains of values. There is also a typical family of non-binary constraints that represent finite capacity limits. These features differentiate the networks of ETPs from random uniform binary CNs. Much experimental work has been done in recent years on random binary constraint networks (cf. [10,11, 9]) and the so called phase transitions have been connected with certain value combinations of the parameters of random binary CNs.

Abstract: This dissertation presents several new algorithms and heuristics for constraint satisfaction problems, as well as an extensive and systematic empirical evaluation of these new techniques. The goal of the research is to develop algorithms which are effective on large and hard constraint satisfaction problems. The dissertation presents several new combination algorithms. The BJ+DVO algorithm combines backjumping with a dynamic variable ordering heuristic that utilizes a forward checking style look-ahead. A new heuristic for selecting a value called Look-ahead Value Ordering (LVO) can be combined with BJ+DVO to yield BJ+DVO+LVO. A new learning, or constraint recording, technique called jump-back learning is described. Jump-back learning is particularly effective because it takes advantage of effort that has already been expended by BJ+DVO. This type of learning can be combined with either BJ+DVO or BJ+DVO+LVO. Learning is shown to be helpful for solving optimization problems that are cast as a series of constraint problems with successively tighter cost-bound constraints. The constraints recorded by learning are used in subsequent attempts to find a solution with a lower cost-bound. The algorithms are evaluated in the dissertation by their performance on three types of problems. Extensive use is made of random binary constraint satisfaction problems, which are generated according to certain parameters. By varying the parameters across a range of values it is possible to assess how the relative performance of algorithms is affected by characteristics of the problems. A second random problem generator creates instances modeled on scheduling problems from the electric power industry. Third, algorithms are compared on a set of DIMACS Challenge problems drawn from circuit analysis. The dissertation presents the first systematic study of the empirical distribution of the computational effort required to solve randomly generated constraint satisfaction problems. If solvable and unsolvable problems are considered separately, the distribution of work on each type of problem can be approximated by two parametric families of continuous probability distributions. Unsolvable problems are well fit by the lognormal distribution function, while the distribution of work on solvable problems can be roughly modelled by the Weibull distribution. Both of these distributions can be highly skewed and have a long, heavy right tail.

Abstract: A constraint satisfaction problem (CSP) involves a set of variables, a domain of potential values for each variable, and a set of constraints, which specifies the acceptable combinations of values. One popular approach is to represent the original problem as a constraint network where nodes represent variables and arcs represent constraints between variables. Node consistency and arc consistency techniques are first applied to prune the domains of variables. Constraint propagation techniques are then applied to solve the problem. Many AI and engineering problems can be formulated as CSPs and solved by various CSP algorithms such as constraint propagation, backtracking, forward checking, and hybrids. This paper gives an overview of these algorithms. In particular, we present a review of the interval constraint satisfaction problems. Real intervals or sets of discrete values label the variables. The constraint can be binary relationships or n-ary mathematical operations. The techniques for solving the interval constraint satisfaction problem such as Waltz filtering and tolerance propagation are presented.

Abstract: This paper proposes interval constraint network and interval propagation techniques for automatic tolerance design. A hierarchical representation is utilized in the interval constraint network. The consistency of a constraint is defined for the purpose of tolerance design. Forward and backward propagation techniques are introduced in the interval constraint network for tolerance analysis and synthesis, respectively. Both a propagation technique for a single constraint and a parallel propagation technique for multiple constraints between two adjacent levels in the network are introduced. Experiments conducted to illustrate the procedures of tolerance analysis and synthesis for the tank problem are described.

Abstract: This work reports on the implementation of a two-dimensional, variational geometric constraint solver based on a constructive approach. The solver computes a solution in two phases. First, using rewrite rules, the solver builds a sequence of construction steps. Then the construction steps are carried out to generate an instance of the geometric object for the current dimension values. We discuss some issues concerning the data representation and the rules used. Then a simple example illustrates how the solver works. Finally we give a correctness proof of the solver.

Abstract: : The proceedings of the conference 'Principles and Practice of Constraint Programming -- CP 96' are attached. Partial Contents include: (1) An Empirical Study of Dynamic Variable Ordering Heuristics for the Constraint Satisfaction Problem; (2) Empirical Studies of Heuristic Local Search for Constraint Solving; (3) Inference Duality as a Basis for Sensitivity Analysis; (4) Transformation Between HCLP and PCSP; (5) A New Approach for Weighted Constraint Satisfaction: Theoretical and Computational Results; (6) Towards a More Efficient Stochastic Constraint Solver; (7) A View of Local Search in Constraint Programming; (8) From Quasi-Solutions to Solution: An Evolutionary Algorithm to Solve CSP; (9) Logical Semantics of Concurrent Constraint Programming; (10) Constraint Logic Programming over Unions of Constraint Theories; (11) On Query Languages for Linear Queries Definable with Polynomial Constraints; (12) Analysis of Heuristic Methods for Partial Constraint Satisfaction Problems; (13) Solving Satisfiability Problems Using Field Programmable Gate Arrays: First Results; and (14) A Constraint Program for Solving the Job-Shop Problem

Abstract: Constraint-based reasoning is a problem-solving approach based on deductive reasoning. In this approach, a problem is modeled in terms of hypotheses and conclusion constraints, and it is solved via constraint satisfaction. The ability to handle linear and nonlinear algebraic constraints is essential for successful application of constraint-based reasoning in engineering. Due to the scarcity of algebraic techniques for satisfying nonlinear constraints, little attention has been paid to the use of constraint-based reasoning for solving nonlinear problems. This paper examines the use of the Grobner Bases method for satisfying nonlinear constraints in the context of constraint-based reasoning. After a brief introduction to the Grobner Bases method and its role in constraint-based reasoning, two examples are presented. The first example illustrates the use of Grobner bases, in the context of constraint-based reasoning, for reasoning about the behavior of beams. The second example illustrates the geometry configuration of truss structures via constraint-based reasoning.

Abstract: This paper describes general approaches to solving two classes of problems using the DISCO constraint database system. The first class of problems occurs when distinct values from a subset of the integers must be assigned to the variables of a constraint satisfaction problem. The second occurs when a group of items must be selected from a subset of the integers such that each of a set of constraints holds.

Abstract: The average running time used by backtracking on random constraint satisfaction problems is studied. This time is polynomial when the ratio of constraints to variables is large, and it is exponential when the ratio is small. When the number of variables goes to infinity, whether the average time is exponential or polynomial depends on the number of variables per constraint, the number of values per variable, and the probability that a random setting of variables satisfies a constraint. A method for computing the curve that separates polynomial from exponential time and several methods for approximating the curve are given. The version of backtracking studied finds all solutions to a problem, so the running time is exponential when the number of solutions per problem is exponential. For small values of the probability, the curve that separates exponential and polynomial average running time coincides with the curve that separates an exponential average number of solutions from a polynomial number. For larger probabilities the two curves diverge. Random problems similar to those that arise in understanding line drawings with shadows require a time that is mildly exponential when they are solved by simple backtracking. Slightly more sophisticated algorithms (such as constraint propagation combined with backtracking) should be able to solve these rapidly.

Abstract: In this paper, we consider Constraint Optimization Problems in a Resource-Bounded context. We observe that both exact and approximate methods produce only an anytime upper bound of the optimum (in case of minimization). No lower bound, and thus no quality is available at run time. For a meta-reasoning system, it is difficult to reason on the basis of a so poor piece of information. Therefore, we discuss some ways of producing an anytime lower bound. In the Valued Constraint Saris]action Problem framework, we develop some of them, based on the complete solving of problem simplifications, and we present experimental results.

Abstract: This paper presents a method called relational constraint for finding binary relations among the variables and constants of a program. The method constructs a table of binary relations and treats the program as a collection of constraints on tuples of relations in the table. An experimental optimizer called Thinner uses this method to analyze programs of size n in O(n2) time.

Abstract: An efficient neural network technique is presented for the solution of binary constraint satisfaction problems. The method is based on the application of a double-update technique to the operation of the discrete Hopfield-type neural network that can be constructed for the solution of such problems. This operation scheme ensures that the network moves only between consistent states, such that each problem variable is assigned exactly one value, and leads to a fast and efficient search of the problem state space. Extensions of the proposed method are considered in order to include several optimisation criteria in the search. Experimental results concerning many real-size instances of the Radio Links Frequency Assignment Problem demonstrate very good performance.

Abstract: We address the problem of solving a constraint satisfaction problem (CSP) by treating a constraint logic program (CLP) as a network of constraints. We attempt to show that each computation in a CLP becomes a sequence of linear steps, since the check satisfiability of the system of constraints is applied at each resolution step which is linear in the size of the current constraint problem. Thus, the constraint propagation information is performed at each step during any CLP derivation. The major issues we address here are the identification (using logic interpretation) of constraints that can be added within the program rules to reduce the size of intermediate states and how to use the previous steps of the computation as a guidance for CLP derivations.

Abstract: Using a framework inspired by Schaefer's generalized satisfiability model [Sch78], Cohen, Cooper and Jeavons [CCJ94] studied the computational complexity of constraint satisfaction problems in the special case when the set of constraints is closed under permutation of labels and domain restriction, and precisely identified the tractable (and intractable) cases. Using the same model we characterize the complexity of three related problems: 1. counting the number of solutions. 2. structure identification (Dechter and Pearl [DP92]). 3. approximating the maximum number of satisfiable constraints.

Abstract: Part I (see ibid., pp. 414-421) provided a rigorous definition of the CSL (constraint specification language) algebra as a language to model the general n-ary logical constraint satisfaction problem (LCSP). In this paper, the majority of our discussions focus on design and implementational issues that arose while building software for compiling the language into executable data structures. The primary objective of the CSL compiler is to efficiently compile a CSL program (for a user-defined LCSP) into a form that can be solved by binary constraint satisfaction problem (CSP) algorithms.

Abstract: An attractive approach to specifying programs is to represent a computation as a set of constraints upon the state variables that define the solution and to choose an appropriate subset of the state variables as the input set. But, there has been little success in attaining efficient execution of parallel programs derived from constraint representations. There are, however, both motivations for continuing research in this direction and reasons for optimism concerning success. Constraint systems have attractive properties for compilation to parallel computation structures. A constraint system gives a control flow-free and dataflow-free specification of a computation, thereby offering the compiler freedom of choice in deriving control structures. All types of parallelism (AND, OR, task, data) can be derived. Either effective or complete programs can be derived from constraint systems on demand. Programs for different computations can be derived from the same constraint specification through different choices of the input set of variables. This dissertation reports on the compilation of constraint systems into task level parallel programs in a procedural language. This is the only research, of which we are aware, which attempts to generate efficient parallel programs for numerical computations from constraint systems. Computations are expressed as constraint systems. A dependence graph is derived from the constraint system and a set of input variables. The dependence graph, which exploits the parallelism in the constraints, is mapped to the target language CODE, which represents parallel computation structures as generalized dependence graphs. Finally, parallel C programs are generated. To extract parallel programs of appropriate granularity, the following features have been included. (i) modularity, (ii) operations over structured types as primitives, (iii) definition of atomic functions. A prototype compiler has been implemented. The execution environment or software architecture is specified separately from the constraint system. The domain of matrix computations has been targeted for applications. Performance results for example programs are very encouraging. The feasibility of extracting efficient and portable parallel programs from domain-specific constraint systems has been established.

Abstract: In most of the existing linear CLP systems, a projection is employed for the answer presentation in order to eliminate the dead variables not occuring in the query. But projection is more than an ornament of the answer presentation. We have shown that there are planning problems that depend heavily on an early projection. While it is not clear how to integrate early projection in the presence of backtrack-ing, the concept of constraint query languages, or bottom-up evaluation, even demands projection of the constraint set of every materialized fact on the fact's variables. We investigate possible environments for an eecient top-down, resp. bottom-up, evaluation of projection-intensive problems.

Abstract: We describe the design and implementation of a finite domain constraint solver embedded in a Prolog system using an extended unification mechanism via attributed variables as a generic constraint interface. The solver is essentially a scheduler for indexicals, i.e. reactive functional rules encoding local consistency methods performing incremental constraint solving or entailment checking, and global constraints, i.e. general propagators which may use specialized algorithms to achieve a higher degree of consistency or better time and space complexity.

Abstract: This paper studies constraint satisfaction over connected row-convex (CRC) constraints. It shows that CRC constraints are closed under composition, intersection, and transposition, the basic operations of path-consistency algorithms. This establishes that path consistency over CRC constraints produces a minimal and decomposable network and is thus a polynomial-time decision procedure for CRC networks. This paper also presents a new path-consistency algorithm for CRC constraints running in time O(n(3)d(2)) and space O(n(2)d), where n is the number of variables and d is the size of the largest domain, improving the traditional time and space complexity by orders of magnitude. The paper also shows how to construct CRC constraints by conjunction and disjunction of a set of basic CRC constraints, highlighting how CRC constraints generalize monotone constraints and presenting interesting subclasses of CRC constraints. Experimental results show that the algorithm behaves well in practice. (C) 1999 Elsevier Science B.V. All rights reserved.

Abstract: We describe an effective generic method for solving constraint problems, based on Tarski’s relation algebra, using pathdconsistency as a pruning technique. We investigate the performance of this method on interval constraint problems. Time performance is affected strongly by the pathdconsistency calculations, which involve the calculation of compositions of relations. We investigate various methods of tuning composition calculations, and also pathdconsistency computations. Space performance is affected by the branching factor during search. Reducing this branching factor depends on the existence of ‘nice’ subclasses of the constraint domain. Finally, we survey the statistics of consistency properties of interval constraint problems. Problems of up to 500 variables may be solved in expected cubic time. Evidence is presented that the ‘phase transition’ occurs in the range 6 <= n·c <=15, where n is the number of variables, and c is the ratio of nondtrivial constraints to possible constraints.

Abstract: We are interested in defining a general evolutionary algorithm to solve constraint satisfaction problems, which takes into account both advantages of the systematic and traditional methods and of characteristics of the CSP. In this context knowledge about properties of the constraint network has allowed us to define a fitness function, for evaluation (Riff, 1996). We introduce two new operators which look at the constraint network during evolution. The first one is a bisexual operator like crossover denominated arc-crossover, for exploitation. The second one is an operator like mutation called arc-mutation, for exploration. These operators are used to improve the stochastic search.

Abstract: Randomly-generated binary constraint satisfaction problems go through a phase transition as the constraint tightness varies. Loose constraints give an 'easy-soluble' region, where problems have many solutions and are almost always easy to solve. However, in this region, systematic search algorithms may occasionally encounter problems which are extremely expensive to solve. It has been suggested that in these cases, the first few instantiations made by the algorithm create an insoluble subproblem; an exhaustive search of the subproblem to prove its insolubility accounts for the high cost. We propose a model for the occurrence of such subproblems when using the backtracking algorithm. We calculate the probability of their occurrence and estimate their cost. From this, we derive the theoretical cost distribution when the constraint graph is complete and show that it matches the observed cost distribution in this region. We suggest that a similar model would also account for the exceptionally hard problems that have been observed using more sophisticated algorithms.

Abstract: It has commonly been acknowledged that solving constrained problems with a variety of complex constraints is a challenging task for genetic algorithms (GA). Existing methods to handle constraints in GA are often computationally expensive, problem dependent or constraint specific. We introduce an idea of constraint consistent GA (CCGA) as an attempt to overcome those drawbacks. Constraint handling is based on general constraint consistency methods that prune the search space and thus reduce the search effort in CCGA. Unfeasible solutions are detected and eliminated from the search space at each stage of the CCGA simulation process to support genetic operations in producing feasible solutions. A number of well known standard genetic operators are adapted to take advantage of provided constraint consistency during initialization, crossover and mutation. Initial experiments indicate that in the terms of the solution quality and the number of iterations the constraint consistency based approach in CCGA can outperform other constraint handling methods in GA for a number of selected test problems.