GA-easy and GA-hard constraint satisfaction problems

The exponential-time hypothesis (ETH) states that 3-SAT is not solvable in subexponential time, i.e. not solvable in O(c^n) time for arbitrary c > 1, where n denotes the number of variables. Problems like k-SAT can be viewed as special cases of the constraint satisfaction problem (CSP), which is the problem of determining whether a set of constraints is satisfiable. In this paper we study the worst-case time complexity of NP-complete CSPs. Our main interest is in the CSP problem parameterized by a constraint language Gamma (CSP(Gamma)), and how the choice of Gamma affects the time complexity. It is believed that CSP(Gamma) is either tractable or NP-complete, and the algebraic CSP dichotomy conjecture gives a sharp delineation of these two classes based on algebraic properties of constraint languages. Under this conjecture and the ETH, we first rule out the existence of subexponential algorithms for finite domain NP-complete CSP(Gamma) problems. This result also extends to certain infinite-domain CSPs and structurally restricted CSP(Gamma) problems. We then begin a study of the complexity of NP-complete CSPs where one is allowed to arbitrarily restrict the values of individual variables, which is a very well-studied subclass of CSPs. For such CSPs with finite domain D, we identify a relation SD such that (1) CSP({SD}) is NP-complete and (2) if CSP(Gamma) over D is NP-complete and solvable in O(c^n) time, then CSP({SD}) is solvable in O(c^n) time, too. Hence, the time complexity of CSP({SD}) is a lower bound for all CSPs of this particular kind. We also prove that the complexity of CSP({SD}) is decreasing when |D| increases, unless the ETH is false. This implies, for instance, that for every c>1 there exists a finite-domain Gamma such that CSP(Gamma) is NP complete and solvable in O(c^n) time.

In this paper, Coevolutionary Genetic Algorithm for solving Constraint Satisfaction Problems (CSPs) is proposed. It consists of two Genetic Algorithms (GAs): a traditional GA and another GA to search for good schemata in the former GA. These GAs evolve in two levels, i.e., phenotype-level and schema-level, and affect with each other through genetic operations. To search for solutions effectively, we devise new genetic operator by utilizing search mechanism of solution synthesis approach used in CSP community. Computational results on general CSPs confirm the effectiveness of our approach.

p-Hub location-allocation problem is one of the most interesting subjects in the location theory. Hubs act as switching points to reduce the transportation cost. In this study, two new solution methods, a constraint programming (CP) based model and a hybrid of k-means and genetic algorithm (KGA), are developed to generate exact and approximate solutions, respectively. The proposed CP formulation is more understandable and straightforward in comparison with the MIP model. The experimental results indicate that the CP model uses the memory of the computer (RAM) more efficiently, which enables us to solve the medium size problems. But, in terms of run time, this method cannot be superior to the MIP model. The CP formulation is also extended for the multi allocation p-hub location problem. K-means algorithm, a well-known algorithm for clustering data, is used to generate initial solutions of GA. Furthermore, a new adaptive crossover operator, which is based on the k-means algorithm, is proposed. The experimental results indicate that the KGA algorithm is superior to the GA, regarding time, objective value, and quality of solution measures.

The Constraint Satisfaction Problem (CSP) is a central and generic computational problem which provides a common framework for many theoretical and practical applications. A central line of research is concerned with the identification of classes of instances for which CSP can be solved in polynomial time; such classes are often called “islands of tractability.” A prominent way of defining islands of tractability for CSP is to restrict the relations that may occur in the constraints to a fixed set, called a constraint language , whereas a constraint language is conservative if it contains all unary relations. Schaefer’s famous Dichotomy Theorem (STOC 1978) identifies all islands of tractability in terms of tractable constraint languages over a Boolean domain of values. Since then, many extensions and generalizations of this result have been obtained. Recently, Bulatov (TOCL 2011, JACM 2013) gave a full characterization of all islands of tractability for CSP and the counting version #CSP that are defined in terms of conservative constraint languages. This article addresses the general limit of the mentioned tractability results for CSP and #CSP, that they only apply to instances where all constraints belong to a single tractable language (in general, the union of two tractable languages is not tractable). We show that we can overcome this limitation as long as we keep some control of how constraints over the various considered tractable languages interact with each other. For this purpose, we utilize the notion of a strong backdoor of a CSP instance, as introduced by Williams et al. (IJCAI 2003), which is a set of variables that when instantiated, moves the instance to an island of tractability, that is, to a tractable class of instances. We consider strong backdoors into scattered classes , consisting of CSP instances where each connected component belongs entirely to some class from a list of tractable classes. Figuratively speaking, a scattered class constitutes an archipelago of tractability . The main difficulty lies in finding a strong backdoor of given size k ; once it is found, we can try all possible instantiations of the backdoor variables and apply the polynomial time algorithms associated with the islands of tractability on the list component-wise. Our main result is an algorithm that, given a CSP instance with n variables, finds in time f ( k ) n O (1) a strong backdoor into a scattered class (associated with a list of finite conservative constraint languages) of size k or correctly decides that there is not such a backdoor. This also gives the running time for solving (#)CSP, provided that (#)CSP is polynomial-time tractable for the considered constraint languages. Our result makes significant progress towards the main goal of the backdoor-based approach to CSPs—the identification of maximal base classes for which small backdoors can be detected efficiently.

Constraint programming offers a declarative approach to solving problems modeled as constraint satisfaction problems (CSPs). However, the precise specification of a set of constraints is sometimes not available, but may have to be learned, for instance, from a set of examples of its solutions and non-solutions. In general, one may wish to learn generalized CSPs involving classical, fuzzy, weighted or probabilistic constraints, for example. This paper introduces a unifying framework for CSP learning. The framework is generic in that it can be instantiated to obtain specific formulations for learning classical, fuzzy, weighted or probabilistic CSPs. In particular, a new formulation for classical CSP learning, which minimizes the number of examples violated by candidate CSPs, is obtained by instantiating the framework. This formulation is equivalent to a simple pseudo-boolean optimization problem, thus being efficiently solvable using many optimization tools.

We discuss a coevolutionary genetic algorithm for constraint satisfaction. Our basic idea is to explore effective genetic information in the population, i.e., schemata, and to exploit the genetic information in order to guide the population to better solutions. Our coevolutionary genetic algorithm (CGA) consists of two GA populations; the first GA, called searches for the solutions in a given environment (problem), and the second GA, called P-GA, searches for effective genetic information involved in the H-GA, namely, good schemata. Thus, each individual in P-GA consists of alleles in H-GA or don't care symbol representing a schema in the H-GA. These GA populations separately evolve in each genetic space at different abstraction levels and affect with each other by two genetic operators: superposition and transcription. We then applied our CGA to constraint satisfaction problems (CSPs) incorporating a new stochastic repair operator for P-GA to raise the consistency of schemata with the (local) constraint conditions in CSPs. We carried out two experiments: First, we examined the performance of CGA on various general CSPs that are generated randomly for a wide variety of density and tightness of constraint conditions in the CSPs that are the basic measures of characterizing CSPs. Next, we examined structured CSPs involving latent cluster structures among the variables in the CSPs. For these experiments, computer simulations confirmed us the effectiveness of our CGA.

Handbook of Constraint Programming

An Iterative local-search framework for solving constraint satisfaction problem

In many industries including metallurgy, petrochemicals, paper, aerospace, pharmaceutical, electronics, ceramic and automotive manufacturing, the production system can contain a machine bottleneck which processes, in some cases, all the jobs. The management of this machine is crucial for the enterprise because it is responsible for delays in customers' orders delivery. The jobs scheduling on this machine is a way of approaching the problem and treats the whole production system. The single machine model provides a basis for more complicated environment such those seen in many real cases. Also, several studies have shown that several jobs, if not all, have time-dependent setup times. So, decision makers must therefore organize the jobs scheduling on this single machine by trying to minimize downtime while respecting the different deadlines. On the other hand, several resolution methods have been developed in literature to solve this kind of problem using approaching methods like metaheuristics or hybrid methods integrating exact methods. This thesis is in this direction. In this research, we propose several effective approaches to solve the single machine scheduling problem with sequence-dependent setup times with the objective to minimize total tardiness of the jobs. First, a new crossover operator in a genetic algorithm is proposed. This algorithm shows its ability to be competitive with the best approaches found in the literature on benchmark problems. We thus highlight the importance of incorporating specific problem knowledge into genetic operators, even if classical genetic operators could be used. However, the results obtained show that the proposed genetic algorithm is less efficient in comparison to the best resolution method found in the literature. Indeed, we noticed that the proposed algorithm lacks an intensification process for enhancing its. To overcome this shortcoming, we explore resolution class methods that showed promising prospects in the last decade. Even, the hybrid algorithms have achieved very good results in a wide variety of problems. In recent years, several researchers have introduced the hybridization of metaheuristics with exact methods. In fact, this kind of hybridization can be an attractive alternative because both methods have very different characteristics that can be combined to produce better results. Thus we explore the design of hybrid genetic algorithms improving the intensification process of the proposed genetic algorithm by integrating an exact method and mechanisms from other resolution methods to improve the performance. However, we find few approaches hybridizing metaheuristics and constraint programming in the literature to solve scheduling problems. In a second step, we propose a modeling for the total tardiness single machine with setup-dependent times scheduling problem using the constraint-based scheduling and the ILOG C++ API. The related experiments show that algorithm efficiency improves with specific tree search strategies and heuristic scheduling variables. Under prohibitive time computing, the proposed approach results are generally far from the best known solutions. However, we got interesting performance on small instances to consider allowing its hybridization with other resolution methods. In a third step, we introduce a hybrid approach based on the integration between genetic algorithm and constraint based scheduling approaches. This latter approach is integrated in the reproduction and the intensification processes of a genetic algorithm autonomously. Finally, we propose a hybrid algorithm which integrates several concepts from constraint programming, multi-objective optimization and ant colonies optimization in a crossover operator into a genetic algorithm. The proposed hybrid algorithms show excellent performance on benchmark problems from the literature by improving many of the best known solutions for some of them.

We use the Constraint Satisfaction Problem (CSP) framework to model and solve the problem of designing substitution functions for substitutionpermutation (SP) networks as proposed by Shannon for the architecture of ciphers. Many ciphers are designed using the SP pattern, and differ mainly by two parametrized functions: substitution and permutation. The most difficult of the two is the substitution function, which has to be nonlinear (a requirement that was difficult to define and quantify). Over time, researchers such as Nyberg, Pieprzyk and Matsui have proposed various metrics of nonlinearity that make the function robust to modern attacks. Before us, people have attempted various ways to design functions that respect these metrics. In the past people hand-picked substitution tables (S-boxes) by trying various values. Recently they use difficult to analyze constructs (such as Bent functions, spectral inversion, inverses in Galois fields) whose outputs are tested for nonlinearity. While efficient, such techniques are neither exhaustive (optimal), nor did they manage to generate better substitutions than the ones hand-picked in the past. We show that Matsui's nonlinearity requirement can be naturally modelled using CSPs. Based on a combination of existing CSP techniques and some new filtering operators that we designed specially for the new types of constraints, we manage to obtain better S-boxes than any previously published ones. The simplicity of the CSP framework and availability of general CSP solvers like ours, makes it easy for more people to design their own ciphers with easy to understand security parameters. Here we report on this new application of CSPs.

An instance of the Constraint Satisfaction Problem (CSP) is given by a family of constraints on overlapping sets of variables, and the goal is to assign values from a xed domain to the variables so that all constraints are satised. In the optimization version, the goal is to maximize the number of satised constraints. An approximation algorithm for CSP is called robust if it outputs an assignment satisfying an (1????g("))-fraction of constraints on any (1????")-satisable instance, where the loss function g is such that g(") ! 0 as " ! 0. We study how the robust approximability of CSPs depends on the set of constraint relations allowed in instances, the so-called constraint language. All constraint languages admitting a robust polynomial-time algorithm (with some g) have been characterised by Barto and Kozik, with the general bound on the loss g being doubly exponential, specically g(") = O((log log(1="))= log(1=")). It is natural to ask when a better loss can be achieved: in particular, polynomial loss g(") = O("1=k) for some constant k. In this paper, we consider CSPs with a constraint language having a nearunanimity polymorphism. This general condition almost matches a known necessary condition for having a robust algorithm with polynomial loss. We give two randomized robust algorithms with polynomial loss for such CSPs: one works for any near-unanimity polymorphism and the parameter k in the loss depends on the size of the domain and the arity of the relations in ????, while the other works for a special ternary near-unanimity operation called dual discriminator with k = 2 for any domain size. In the latter case, the CSP is a common generalisation of Unique Games with a xed domain and 2-Sat. In the former case, we use the algebraic approach to the CSP. Both cases use the standard semidenite programming relaxation for CSP.

Currently the parameters in a constraint solver are often selected by hand by experts in the field; these parameters might include the level of preprocessing to be used and the variable ordering heuristic. The efficient and automatic choice of a preprocessing level for a constraint solver is a step towards making constraint programming a more widely accessible technology. Self-learning sexual genetic algorithms are a new approach combining a self-learning mechanism with sexual genetic algorithms in order to suggest or predict a suitable solver configuration for large scale problems by learning from the same class of small scale problems. In this paper, Self-learning Sexual genetic algorithms are applied to create an automatic solver configuration mechanism for solving various constraint problems. The starting population of self-learning sexual genetic algorithms will be trained through experience on small instances. The experiments in this paper are a proof-of-concept for the idea of combining sexual genetic algorithms with a self-learning strategy to aid in parameter selection for constraint programming.

This paper presents a VLSI design for a competitive neural network model, known as GENET (Wang and Tsang 1991), for solving Constraint Satisfaction Problems (CSP). The CSP is a mathematical abstraction of the problems in many AI application domains. In essence, a CSP can be defined as a triple (Z, D, C), where Z is a finite set of variables, D is a mapping from every variable to a domain, which is a finite set of arbitrary objects, and C is a set of constraints. Each constraint in C restricts the values that can be simultaneously assigned to a number of variables in Z. If the constraints in C involve up to but no more than n variables it is called an n-ary CSP. The task is to assign one value per variable satisfying all the constraints in C (Mackworth 1977). In addition, associated with the variable assignments might be costs and utilities. This turns CSPs into optimization problems, demanding CSP solvers to find a set of variable assignments that would produce a maximum total utility at a minimal cost. Furthermore, some CSPs might be over-constrained, i.e. not all the constraints in C can be satisfied simultaneously. In this case, the set of assignments to a maximum number of variables without violating any constraints in C, or the set of assignments to all the variables which violates a minimal number of constraints might be sought for.

Constraint Satisfaction Problems (CSP) provide a modelling framework for many computer aided decision making problems. Many of these problems are associated to an optimization criterion. Solving a CSP consists in finding an assignment of values to the variables that satisfies the constraints and optimizes a given objective function (in case of an optimization problem). In this paper, we extend our framework for genetic algorithms (GA) as suggested by the reviewers of our previous ICLP paper [5]. Our purpose is not to solve efficiently the Balanced Academic Curriculum Problem (BACP) [2] but to combine a genetic algorithm with constraint programming techniques and to propose a general modelling framework to precisely design such hybrid resolution process and highlight their characteristics and properties.

Conventional techniques for the constraint satisfaction problem (CSP) have had considerable success in their applications. However, there are many areas in which the performance of the basic approaches may be improved. These include heuristic ordering of certain tasks performed by the CSP solver, hybrids which combine compatible solution techniques and graph based methods which exploit the structure of the constraint graph representation of a CSP. Also, conventional constraint satisfaction techniques only address problems with hard constraints (i.e. each of which are completely satisfied or completely violated, and all of which must be satisfied by a valid solution). Many real applications require a more flexible approach which relaxes somewhat these rigid requirements. To address these issues various approaches have been developed. This paper attempts a systematic review of them.