Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

Constraint Handling Rules (CHR) are our proposal to allow more flexibility and application-oriented customization of constraint systems. CHR are a declarative language extension especially designed for writing user-defined constraints. CHR are essentially a committed-choice language consisting of multi-headed guarded rules that rewrite constraints into simpler ones until they are solved. In this broad survey we aim at covering all aspects of CHR as they currently present themselves. Going from theory to practice, we will define syntax and semantics for CHR, introduce an important decidable property, confluence, of CHR programs and define a tight integration of CHR with constraint logic programming languages. This survey then describes implementations of the language before we review several constraint solvers - both traditional and non- standard ones - written in the CHR language. Finally we introduce two innovative applications that benefited from using CHR.

We present the fl-calculus, a computational calculus for higher-order concurrent programming. The calculus can elegantly express higher-order functions (both eager and lazy) and concurrent objects with encapsulated state and multiple inheritance. The primitives of the fl-calculus are logic variables, names, procedural abstraction, and cells. Cells provide a notion of state that is fully compatible with concurrency and constraints. Although it does not have a dedicated communication primitive, the fl-calculus can elegantly express one-to-many and many-to-one communication. There is an interesting relationship between the fl-calculus and the ß-calculus: The fl-calculus is subsumed by a calculus obtained by extending the asynchronous and polyadic ß-calculus with logic variables. The fl-calculus can be extended with primitives providing for constraint-based problem solving in the style of logic programming. A such extended fl-calculus has the remarkable property that it combines first-or...

Constraint Logic Programming (CLP) is a new class of programming languages combining the declarativity of logic programming with the efficiency of constraint solving. New application areas, amongst them many different classes of combinatorial search problems such as scheduling, planning or resource allocation can now be solved, which were intractable for logic programming so far. The most important advantage that these languages offer is the short development time while exhibiting an efficiency comparable to imperative languages. This tutorial aims at presenting the principles and concepts underlying these languages and explaining them by examples. The objective of this paper is not to give a technical survey of the current state of art in research on CLP, but rather to give a tutorial introduction and to convey the basic philosophy that is behind the different ideas in CLP. It will discuss the currently most successful computation domains and provide an overview on the different consi...

This paper describes an application of constraint handling rules to temporal reasoning and illustrates the conceptual simplicity and flexibility of the approach. Following the framework of Meiri, temporal reasoning is viewed as a constraint satisfaction problem about location of temporal variables along the time line. Temporal variables may be points or intervals and temporal constraints are disjunctions of qualitative or quantitative primitive binary temporal relations. We use constraint logic programming extended with constraint handling rules to define an incremental, flexible general purpose solver for disjunctive binary constraints based on path consistency and backtrack search. We show how this approach supports rapid prototyping and experimentation with different kinds of temporal reasoning and constraint satisfaction techniques in general. Keywords: Constraint-Based Reasoning, Temporal Reasoning, Logic Programming. This work was supported by ESPRIT Project 5291 CHIC. This repor...

In current constraint logic programming systems, constraint solving is hard-wired in a "black box". We are investigating the use of logic programs to define and implement constraint solvers 1 . The representation of constraint evaluation in the same formalism as the rest of the program greatly facilitates the prototyping, extension, specialization and combination of constraint solvers. In our approach, constraints are specified by definite clauses provided by a host language, while constraint evaluation is specified using multi-headed guarded clauses called constraint simplification rules (SiRs) 2 . SiRs define determinate conditional rewrite systems that express how conjunctions of constraints simplify. They have been used to encode a range of constraint solvers in our prototype implementation. Additionally, the definite clauses specifying a constraint can be evaluated in the host language, if the constraint is "callable" and no SiR can simplify it further. In this way our appr...

Terminological knowledge representation formalisms in the tradition of kl-oneenable one to define the relevant concepts of a problem domain and their interaction in a structured and well-formed way. Recently, M. Schmidt-Schauß and G. Smolka proposed a new methodology for constructing sound and complete inference algorithms for terminological logics. The consistency test of assertions is the basis for all terminological reasoning services. We propose constraint handling rules (CH rules) as an implementation language for terminological reasoning. CH rulesare a flexible means to implement `user-defined' constraints on top of existing host languages like Prolog and Lisp. The implementation results in a natural combination of three layers: (i) a constraint layer that reasons in well-understood domains such as rationals or finite domains, (ii) a terminological layer providing a tailored, validated vocabulary on which (iii) the application layer can rely. As an application example, a configur...

The semantics of constraint logic programming languages with coroutining facilities (e.g., "freeze," suspension, residuation) cannot be fully declarative. Thus, an operational semantics has to be taken as the defining one. We give a formal operational semantics for a Prolog-like language with cut and entailment-based conditional. Our approach is derived from those used for concurrent calculi. We use congruence laws and tree-rewriting rules to define the semantics. We model the execution of a program by a sequence of abstract-tree rewriting steps. This semantics serves as a defining tool for the language designer and as the interface between the language designer and implementor; it allows the programmer to check his intuition with a formal execution model and it gives him a performance measure for the execution of programs. We have used the semantics to make precise, for the first time, the critical interaction between sequential execution (including backtracking and cut pruning) and c...

Traditionally the integration of functional and logic languages is performed by attempting to integrate their semantic logics in some way. Many languages have been developed by taking this approach, but none manages to exploit fully the programming features of both functional and logic languages and provide a smooth integration of the two paradigms. We propose that improved integrated systems can be constructed by taking a broader view of the underlying semantics of logic programming. A novel integrated language paradigm, Definitional Constraint Programming (DCP), is proposed. DCP generalises constraint logic programming by admitting user-defined functions via a purely functional subsystem and enhances it with the power to solve constraints over functional programs. This constraint approach to integration results in a homogeneous unified system in which functional and logic programming features are combined naturally. 1 Introduction During the past ten years the integration of funct...

LIFE is an experimental programming language proposing to integrate logic programming, functional programming, and object-oriented programming. It replaces first-order terms with ψ-terms, data structures which allow computing with partial information. These are approximation structures denoting sets of values. LIFE further enriches the expressiveness of ψ-terms with functional dependency constraints. We must explain the meaning and use of functions in LIFE declaratively as solving partial information constraints. These constraints do not attempt to generate their solutions but behave as demons filtering out anything else.