Propositional Satisfiability (SAT) and Constraint Programming (CP) have developed as two relatively independent threads of research, cross-fertilising occasionally. These two approaches to problem solving have a lot in common, as evidenced by similar ideas underlying the branch and prune algorithms that are most successful at solving both kinds of problems. They also exhibit differences in the way they are used to state and solve problems, since SAT’s approach is in general a black-box approach, while CP aims at being tunable and programmable. This survey overviews the two areas in a comparative way, emphasising the similarities and differences between the two and the points where we feel that one technology can benefit from ideas or experience acquired

Abstract not found

Soft constraints are a generalization of classical constraints, which allow for the description of preferences rather than strict requirements.

Soft constraints are a generalization of classical constraints, where constraints and/or partial assignments are associated to preference or importance levels, and constraints are combined according to combinators which express the desired optimization criteria. Constraint Handling Rules (CHRs) constitute a high-level natural formalism to specify constraint solvers and propagation algorithms. In this paper we present a framework to design and specify soft constraint solvers by using CHRs. In this way, we extend the range of applicability of CHRs to soft constraints rather than just classical ones, and we provide a straightforward implementation for soft constraint solvers. Keywords Constraint reasoning algorithms, constraint programming 1.

Abstract. Hybrid algorithms combining local and systematic search often use nondeterminism in fundamentally different ways. They may differ in the strategy to explore the search tree and/or in how computation states are represented. This paper presents nondeterministic control structures to express a variety of hybrid search algorithms concisely and elegantly. These nondeterministic abstractions describe the search tree and are compiled in terms of first-class continuations. They are also parameterized by search controllers that are under user control and specify the state representation and the exploration strategy. The resulting search language is thus high-level, flexible, and directly extensible. The abstractions are illustrated on a jobshop scheduling algorithm that combines tabu search and a limited form of backtracking. Preliminary experimental results indicate that the control structures induce small, often negligible, overheads. 1

We describe SCIL. SCIL introduces symbolic constraints into branch-and-cut-and-price algorithms for integer linear programs. Symbolic constraints are known from constraint programming and contribute signi cantly to the expressive power, ease of use, and e ciency of constraint programs.

Many real life problems can be formulated as constraint satisfaction problems (CSPs). Backtracking search algorithms are usually employed to solve CSPs and in backtracking search the choice of branching strategies can be critical since they specify how a search algorithm can instantiate a variable and how a problem can be reduced into subproblems; that is, they define a search tree. In spite of the apparent importance of the branching strategy, there have been only a few empirical studies about di#erent branching strategies and they all have been tested exclusively for numerical constraints. In this thesis, we employ the three most commonly used branching strategies in solving finite domain CSPs. These branching strategies are described as follows: first, a branching strategy with strong commitment assigns its variables in the early stage of the search as in k-Way branching; second, 2-Way branching guides a search by branching one side with assigning a variable and the other with eliminating the assigned value; third, the domain splitting strategy, based on the least commitment principle, branches by dividing a variable's domain rather than by assigning a single value to a variable. In our experiments, we compared the e#ciency of di#erent branching strategies in terms of their execution times and the number of choice points in solving finite domain CSPs. Interestingly, our experiments provide evidence that the choice of branching strategy for finite domain problems does not matter much in most cases---provided we are using an e#ective variable ordering heuristic---as domain splitting and 2-Way branching end up simulating k-Way branching. However, for an optimization problem with large domain size, the branching strategy with the least commitment principle can be more e#...

Soft constraints are a generalization of classical constraints, where constraints and/or partial assignments are associated to preference or importance levels, and constraints are combined according to combinators which express the desired optimization criteria. Constraint Handling Rules (CHR) constitute a high-level natural formalism to specify constraint solvers and propagation algorithms. In this paper we present a framework to design and specify soft constraint solvers by using CHR. In this way, we extend the range of applicability of CHR to soft constraints rather than just classical ones, and we provide a straightforward implementation for soft constraint solvers. Keywords: constraint solving algorithms, soft constraints, constraint handling rules. 1

In this paper we present and evaluate a search strategy called Decomposition Based Search (DBS) which is based on two steps: subproblem generation and subproblem solution. The generation of subproblems is done through value ranking and domain splitting. Subdomains are explored so as to generate, according to the heuristic chosen, promising subproblems first.

Abstract. In this paper, we show that in a rule-based modeling language, search tree ordering heuristics can be specified declaratively by pattern matching on left-hand sides of rule definitions. As opposed to other modeling languages able to express search heuristics, such as OPL and Comet, heuristics are expressed here purely declaratively. That eliminates the need of changing data structures or introducing intermediary objects. The price to pay for this ease of modeling is in the compilation process which we describe here with a formal system. We analyze the complexity of the transformation and present some performance figures on the compilation process and on the generated constraint programming code. 1