Abstract: In this paper we describe and analyse an algorithm for solving the 3-satisfiability problem. If clauses are regarded as constraints of Constraint Satisfaction Problems, then every clause presents a constraint with a special property, namely subquadrangle. We show that the algorithm on subquadrangles guarantees a solution in time less than O(1.476n), which improves the current well-known 3-satisfiability algorithms. Tests have shown the number of steps to be significantly smaller also in the average compared with the other algorithms.

Abstract: In this paper, a method within the framework of propagation of interval constraints and based on the branch- and-bound optimization scheme for solving the job-shop scheduling problem will be presented. The goal is to provide a constraint program which is clean, flexible and robust. The design of the constraint program is based on an idea of sorting the release and due dates of tasks, which is a successful application of a previous but not yet published work on a distinct integers constraint. Based on the sorting constraint, by assembling redundant constraints and applying an efficient search strategy, the current program for the job-shop problem can solve the ten 10 × 10 instances in the paper of Applegate and Cook (1991) in satisfactory computational time. Moreover, good results have been achieved on some harder instances.

Abstract: Recent improvements in constraint programming have made it possible to tackle hard problems in a practical way. Before this, these problems were solved only by specialized programs often complex to implement. Scheduling problems and more especially the job-shop problem belong to this class. In this paper we explain a relatively simple constraint system, which enables us to solve 10 × 10 problems efficiently. The method described here, based on evaluations which come as close as possible to release and due dates of jobs to be scheduled, requires no prior knowledge of the problem being processed, in particular, no bounds over optimum value (consequently no specific algorithm to find approximate solutions). We also comment on the results of experiments on known problems. As far as we know, the system outlined here is the only one that, using just constraint solving and an exhaustive enumeration strategy, can completely solve orb3[AC91] in less than half an hour computational time.

Abstract: The techniques of constraint propagation have recently been successfully applied to feature-based design. Because of their speed, constraint propagation methods allow incremental design and rapid local modifications of the part. However, cyclic constraints cause serious problems to current constraint propagation algorithms. Variational geometric design systems can, in principle, manage these cases. Unfortunately, this typically requires complete re-evaluation of the underlying set of constraint equations, making the method unsuitable for interactive use. The proposed system aims to localize the problem of constraint solving and maintenance. The constraint graph of the part or assembly is divided into several independent partial graphs, subsystems. Afterwards, each subsystem is handled separately using a selected constraint solving technique for the subsystem.

Abstract: This paper describes subdefinite models as a variety of constraint satisfaction problems. The use of the method of subdefinite calculations makes it possible to solve overdetermined and underdetermined problems, as well as problems with uncertain, imprecise and incomplete data. Constraint propagation in all these problems is supported by a single data-driven inference algorithm. Several examples are given to show the capabilities of this approach for solving a wide class of problems.

Abstract: Euclidean geometrical configurations obtained with ruler, square and compass may be described as arithmetic constraint systems over rational numbers and consequently belong to the domain of CLP(R). Unfortunately, CLP based on linear constraint solvers which are efficient and can deal with geometrical constraints such as parallelism, perpendicularity, belonging to a line i.e. pseudo-linear constraints, cannot handle quadratic constraints introduced when using circles.

Abstract: Hierarchical Constraint Solving has been proposed as an adequate scheme to specify over-constrained problems where some of the constraints might remain unsatisfied. However it is often not clear which criteria should be adopted to select the “best” combination of constraints to be relaxed. In previous work we proposed IHCS — an Incremental Hierarchical Constraint Solver — but only with a single criterium. This paper presents IHCS as a general scheme to incrementally handle a hierarchy of constraints for a class of comparators using different criteria. The scheme is further extended with a satisfaction mode — given a threshold, this mode enables the search of “satisfactory” solutions to large problems whose optimization is not possible in acceptable time. This scheme can be integrated with different programming environments. In particular, we have integrated it with Prolog to produce an instance of an HCLP language. Because of its portability and incremental nature, IHCS is well suited for reactive systems, allowing the interactive introduction and removal of preferred constraints, illustrated in the examples presented in the paper.

Abstract: AI and OR approaches have complementary strengths: AI in domain-specific knowledge representation and OR in efficient mathematical computation. Constraint Logic Programming (CLP), which combines these complementary strengths of the AI and OR approach, is introduced as a new tool to formalize a special class of constraint satisfaction problems that include both qualitative and quantitative constraints. The CLP approach is contrasted with the Mixed Integer Programming (MIP) method from a model-theoretic view. Three relative advantages of CLP over MIP are analyzed: (1) representational economies for domain-specific heuristics, (2) partial solutions, and (3) ease of model revision. A case example of constraint satisfaction problems is implemented by MIP and CLP for comparison of the two approaches. The results exhibit those relative advantages of CLP with computational efficiency comparable to MIP.

Abstract: In this paper, we propose ordered constraint hierarchies and a non-trivial error function to model and solve over-constrained real-world problems adequately. We substantiate our proposition by an example. Then we present a new method to transform constraint hierarchies into equivalent ordinary constraint systems. For practical applications, we present a modified algorithm based on an incomplete finite domain constraint solver. We conclude with a prototype implementation of the method and some aspects about our future work.

Abstract: There are many new methods for solving constraint satisfaction problems proposed in recent years. Due to their complexity, a theoretical analysis on their average-case behaviours seems to be very difficult. Researchers tend to adopt an empirical approach to evaluate constraint satisfaction techniques. When empirical results are ready, statistical techniques are often employed for analysis. The question is which statistics to use. Some recent research uses parametric tests such as t-test and ANOVA. However those tests assume that the characteristic of the normal curve can be applied. In this paper, we provide evidence that the normality assumption is often not valid in the results produced by a range of constraint satisfaction algorithmheuristic combinations on random binary constraint satisfaction problems and 3-colouring problems, particularly when a problem is within the "mushy region", which are popular benchmark problems for evaluating CSP methods. The failure of normality assumption highlights the need for some statistics which do not rely on the normality assumption to analyse empirical results from CSP research. We believe that non-parametric techniques could be the right tools for that purpose.

Abstract: The possibility of deleting a piece of information is very convenient in many programming frameworks. However, this feature is not available in constraint languages such as Constraint Logic Programming or Concurrent Constraint Programming, which allow only for a monotonic accumulation of constraints. This is mainly due to its high complexity and also to its non-monotonic nature, which would make such a system much more complex to reason with. In this paper we consider the CLP framework over FD (finite domain) constraints, and we propose an incremental algorithm which deletes a constraint from a set of FD constraints, while maintaining partial arc-consistency. The algorithm follows the chain of dependencies among variables which are set by the nature of the FD constraints, and by doing so it updates only the part of the constraint set which is affected by the deletion. This makes constraint deletion in FD a feasible task that can be efficiently implemented.

Abstract: This paper proposes a number of models for integrating stochastic constraint solvers into constraint logic programming systems in order to solve constraint satisfaction problems efficiently. Stochastic solvers can solve hard constraint satisfaction problems very efficiently, and constraint logic programming allows heuristics and problem breakdown to be encoded in the same language as the constraints. Hence their combination is attractive. Unfortunately there is a mismatch in the kind of information a stochastic solver provides, and that which a constraint logic programming system requires. We study the semantic properties of the various models of constraint logic programming systems that make use of stochastic solvers, and give soundness and completeness results for their use. We describe an example system we have implemented using a modified neural network simulator, GENET, as a constraint solver. We briefly compare the efficiency of these models against the propagation based solver approaches typically used in constraint logic programming.

Abstract: We begin by formulating a general framework for constraint programming that we shall use to explain its specific aspects. First, we formulate our initial problem as a CSP. This in itself can be a non-trivial problem. In particular, at this stage we have to take decisions concerning the choice of variables, domains and constraints. As already mentioned in Chapter 1 this phase of constraint programming is called modelling and in contrast to programming in other programming styles it is more time consuming and more involved. Modelling is more an art than science and a number of rules of thumb and various heuristics are useful at this stage. Subsequently, we apply to the formulated CSP the following procedure:

Abstract: We describe constraint solving using a rule-based approach. The distinction made between deduction rules and strategies by computational systems allows us to improve our understanding of the existing algorithms for solving binary CSPs (constraint satisfaction problems) once they are expressed as rewriting rules coordinated by strategies.

Abstract: In this paper, the texture classification problem is projected as a constraint satisfaction problem. The focus is on the use of a probabilistic neural network for representing the distribution of feature vectors of each texture class in order to generate a feature-label interaction constraint. This distribution is assumed as a Gaussian mixture model. The feature-label interactions and a set of label-label interactions are represented on a constraint satisfaction neural network. A stochastic relaxation strategy is used to obtain an optimal classification of the textured image.

Abstract: In this paper, we present a complete design framework for an adaptive multiple agent fuzzy constraint-based controller (MAFCC) based on fuzzy penumbra constraint processing in each fuzzy constraint subnetwork collaborating with a connected constraint network and its corresponding semantic modeling in a first-order predicate calculus (FOPC) language, with application to a complex hydraulic system. The concept of “multiple agent” and “fuzzy constraint subnetwork” in a complex control system is introduced and some basic definitions of penumbra fuzzy constraint processing in a constraint subnetwork and the collaboration with an overall connected constraint network and its semantic modeling are addressed. As a result, a human agent interacts with system agents and allows the constraints to be added or deleted on-line according to the constraints imposed from the outside environment. Near-optimal system performance is accomplished by restricting all the penumbra constraints to be satisfied in each constraint subnetwork simultaneously which are interconnected as a result of constraints that exist between each of them. Following the principle of constraint satisfaction and fuzzy local propagation reasoning, each individual system agent is now constrained to behave in a certain fashion as dictated by the overall constraint network. In addition, the constraint network in MAFCC system provides an update strategy which makes a real time adaptive hydraulic control for all 20 cities possible.

Abstract: Rule-based systems have long been widely used for building expert systems to perform practical knowledge intensive tasks. One important issue that has not been addressed satisfactorily is the disjunction, and this significantly limits their problem solving power. In this paper, we show that some important types of disjunction can be modeled with Constraint Satisfaction Problem (CSP) techniques, employing their simple representation schemes and efficient algorithms. A key idea is that disjunctions are represented as constraint variables, relations among disjunctions are represented as constraints, and rule chaining is integrated with constraint solving. In this integration, a constraint variable or a constraint is regarded as a special fact, and rules can be written with constraints and information about constraints. Chaining of rules may trigger constraint propagation, and constraint propagation may cause firing of rules. A prototype system (called CFR) based on this idea has been implemented.

Abstract: This paper describes the first results from research 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. The granularity of the derived dependence graphs depends upon the complexity of the operations represented in the type system of the constraint specification language. 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 sequential C functions. A prototype of the 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. Some examples have been programmed. Initial results are very encouraging.

Abstract: We consider a class of constraint logic programs including negation that can be executed bottom up without constraint solving, by replacing constraints with tests and assignments. We show how to optimize the bottom-up evaluation of queries for such programs using transformations based on analysis obtained using abstract interpretation. Although the paper concentrates on a class of efficiently executable programs, the optimizations we describe are correct and applicable for arbitrary constraint logic programs. Our approach generalizes earlier work on constraint propagation.

Abstract: In this paper we advocate for more flexible and user-friendly constraint solving environments, as well as for constraint programming languages which have great expressive power while maintaining a formal semantics based on few crucial concepts. We cite some of our work in these directions and we hint at subjects of our future research.

Abstract: Existing methods to handle constraints in genetic algorithms (GA) are often computationally expensive or problem domain specific. In this paper, an approach to handle constraints in GA with the use of constraint satisfaction principles is proposed to overcome those drawbacks. Each chromosome representing a set of constrained variables in GA is interpreted as an instance of the same constraint satisfaction problem represented by a constraint network. Dynamic constraint consistency checking and constraint propagation is performed during the main GA simulation process. Unfeasible solutions are detected and eliminated from the search space at early stages of the GA simulation process without requiring the problem specific representation or generation operators to provide feasible solutions. Constraint satisfaction is applied actively in GA during initialisation, crossover and mutation operations to advantage.