This paper presents for the first time the semantic foundations of CLP in a self-contained and complete package. The main contributions are threefold. First, we extend the original conference paper by presenting definitions and basic semantic constructs from first principles, giving new and complete proofs for the main lemmas. Importantly, we clarify which theorems depend on conditions such as solution compactness, satisfaction completeness and independence of constraints. Second, we generalize the original results to allow for incompleteness of the constraint solver. This is important since almost all CLP systems use an incomplete solver. Third, we give conditions on the (possibly incomplete) solver which ensure that the operational semantics is confluent, that is, has independence of literal scheduling.

. We are investigating the use of a class of logical formulas to define constraint theories and implement constraint solvers at the same time. The representation of constraint evaluation in a declarative formalism greatly facilitates the prototyping, extension, specialization and combination of constraint solvers. In our approach, constraint evaluation is specified using multiheaded guarded clauses called constraint handling rules (CHRs). CHRs define determinate conditional rewrite systems that express how conjunctions of constraints propagate and simplify. In this paper we concentrate on CHRs as an extension for constraint logic programming languages. Into such languages, the CHRs can be tightly integrated. They can make use of any hard-wired solvers already built into the host language. Program clauses can be used to specify the non-deterministic behavior of constraints, i.e. to introduce search by constraints. In this way our approach merges the advantages of constraints (eager simp...

Abstract not found

Software Product Line (SPL) Engineering has proved to be an effective method for software production. However, in the SPL community it is well recognized that variability in SPLs is increasing by the thousands. Hence, an automatic support is needed to deal with variability in SPL. Most of the current proposals for automatic reasoning on SPL are not devised to cope with extra-functional features. In this paper we introduce a proposal to model and reason on an SPL using constraint programming. We take into account functional and extra-functional features, improve current proposals and present a running, yet feasible implementation.

Constraint Handling Rules (CHR) is a high-level rule-based programming language which is increasingly used for general purposes. We introduce the CHR machine, a model of computation based on the operational semantics of CHR. Its computational power and time complexity properties are compared to those of the well-understood Turing machine and Random Access Memory machine. This allows us to prove the interesting result that every algorithm can be implemented in CHR with the best known time and space complexity. We also investigate the practical relevance of this result and the constant factors involved. Finally we expand the scope of the discussion to other (declarative) programming languages.

Experience using constraint programming to solve real-life problems has shown that finding an efficient solution to the problem often requires experimentation with different constraint solvers or even building a problem-specific constraint solver. HAL is a new constraint logic programming language expressly designed to facilitate this process. It provides a well-defined solver interface, mutable global variables for implementing a constraint store, and dynamic scheduling which support combining, extending and writing new constraint solvers. Equally importantly, HAL supports semi-optional type, mode and determinacy declarations. These allow natural constraint specification by means of type overloading, better compile-time error checking and generation of more efficient run-time code.

Integer programming and constraint (logic) programming are two traditional techniques for solving combinatorial optimization problems; the former based on linear programming relaxations and the latter on constraint propagation. Attempts to combine them have mainly focused on incorporating either technique into the framework of the other traditional models have been left intact. We argue that a rethinking of our modeling traditions is necessary to achieve the greatest benet of such an integration. We propose a declarative modeling framework in which the structure of the constraints indicates how LP and CP can interact to solve the problem. 1 Introduction Linear programming (LP) and constraint propagation (CP) are two complementary techniques with potential for integration to benet the solution of combinatorial optimization problems. Integer programming (IP) has been successfully applied to a range of problems, such as capital budgeting, bin packing and traveling salesman pr...

: Constraint programming (CP) is an emergent software technology for declarative description and effective solving of large, particularly combinatorial, problems especially in areas of planning and scheduling. It represents the most exciting developments in programming languages of the last decade and, not surprisingly, it has recently been identified by the ACM (Association for Computing Machinery) as one of the strategic directions in computer research. Not only it is based on a strong theoretical foundation but it is attracting widespread commercial interest as well, in particular, in areas of modelling heterogeneous optimisation and satisfaction problems. In the paper, we give a survey of constraint programming technology and its applications starting from the history context and interdisciplinary nature of CP. The central part of the paper is dedicated to the description of main constraint satisfaction techniques and industrial applications. We conclude with the overview of limit...

We show how a range of role-based access control (RBAC) models may be usefully represented as constraint logic programs, executable logical specifications. The RBAC models that we define extend the “standard ” RBAC models that are described by Sandhu et al., and enable security administrators to define a range of access policies that may include features, like denials of access and temporal authorizations, that are often useful in practice, but which are not widely supported in existing access control models. Representing access policies as constraint logic programs makes it possible to support certain policy options, constraint checks and administrator queries that cannot be represented by using related methods (like logic programs). Representing an access control policy as a constraint logic program also enables access requests and constraint checks to be efficiently evaluated.

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 survey 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.