Results 1  10
of
200
Constraint Logic Programming: A Survey
"... 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 differe ..."
Abstract

Cited by 864 (25 self)
 Add to MetaCart
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.
Concurrent Constraint Programming
, 1993
"... This paper presents a new and very rich class of (concurrent) programming languages, based on the notion of comput.ing with parhal information, and the concommitant notions of consistency and entailment. ’ In this framework, computation emerges from the interaction of concurrently executing agent ..."
Abstract

Cited by 502 (16 self)
 Add to MetaCart
This paper presents a new and very rich class of (concurrent) programming languages, based on the notion of comput.ing with parhal information, and the concommitant notions of consistency and entailment. ’ In this framework, computation emerges from the interaction of concurrently executing agents that communicate by placing, checking and instantiating constraints on shared variables. Such a view of computation is interesting in the context of programming languages because of the ability to represent and manipulate partial information about the domain of discourse, in the context of concurrency because of the use of constraints for communication and control, and in the context of AI because of the availability of simple yet powerful mechanisms for controlling inference, and the promise that very rich representational/programming languages, sharing the same set of abstract properties, may be possible. To reflect this view of computation, [Sar89] develops the cc family of languages. We present here one member of the family, CC(.L,+) (pronounced “cc with Ask and Choose”) which provides the basic operations of blocking Ask and atomic Tell and an algebra of behaviors closed under prefixing, indeterministic choice, interleaving, and hiding, and provides a mutual recursion operator. cc(.L,t) is (intentionally!) very similar to Milner’s CCS, but for the radically different underlying concept of communication, which, in fact, pro’ The class is founded on the notion of “constraint logic programming ” [JL87,Mah87], fundamentally generalizes concurrent logic programming, and is the subject of the first author’s dissertation [Sar89], on which this paper is substantially based.
Theory and Practice of Constraint Handling Rules
, 1998
"... Constraint Handling Rules (CHR) are our proposal to allow more flexibility and applicationoriented customization of constraint systems. CHR are a declarative language extension especially designed for writing userdefined constraints. CHR are essentially a committedchoice language consisting of mu ..."
Abstract

Cited by 459 (36 self)
 Add to MetaCart
Constraint Handling Rules (CHR) are our proposal to allow more flexibility and applicationoriented customization of constraint systems. CHR are a declarative language extension especially designed for writing userdefined constraints. CHR are essentially a committedchoice language consisting of multiheaded 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.
Constraint Query Languages
, 1992
"... We investigate the relationship between programming with constraints and database query languages. We show that efficient, declarative database programming can be combined with efficient constraint solving. The key intuition is that the generalization of a ground fact, or tuple, is a conjunction ..."
Abstract

Cited by 380 (44 self)
 Add to MetaCart
(Show Context)
We investigate the relationship between programming with constraints and database query languages. We show that efficient, declarative database programming can be combined with efficient constraint solving. The key intuition is that the generalization of a ground fact, or tuple, is a conjunction of constraints over a small number of variables. We describe the basic Constraint Query Language design principles and illustrate them with four classes of constraints: real polynomial inequalities, dense linear order inequalities, equalities over an infinite domain, and boolean equalities. For the analysis, we use quantifier elimination techniques from logic and the concept of data complexity from database theory. This framework is applicable to managing spatial data and can be combined with existing multidimensional searching algorithms and data structures.
Semantic foundations of concurrent constraint programming
, 1990
"... Concurrent constraint programming [Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of storeasconstraint and process as information transducer. The storeasvaluation conception of von Neumann computing is replaced by the notion that the store is a constr ..."
Abstract

Cited by 282 (27 self)
 Add to MetaCart
(Show Context)
Concurrent constraint programming [Sar89,SR90] is a simple and powerful model of concurrent computation based on the notions of storeasconstraint and process as information transducer. The storeasvaluation conception of von Neumann computing is replaced by the notion that the store is a constraint (a finite representation of a possibly infinite set of valuations) which provides partial information about the possible values that variables can take. Instead of “reading” and “writing ” the values of variables, processes may now ask (check if a constraint is entailed by the store) and tell (augment the store with a new constraint). This is a very general paradigm which subsumes (among others) nondeterminate dataflow and the (concurrent) (constraint) logic programming languages. This paper develops the basic ideas involved in giving a coherent semantic account of these languages. Our first contribution is to give a simple and general formulation of the notion that a constraint system is a system of partial information (a la the information systems of Scott). Parameter passing and hiding is handled by borrowing ideas from the cylindric algebras of Henkin, Monk and Tarski to introduce diagonal elements and “cylindrification ” operations (which mimic the projection of information induced by existential quantifiers). The se;ond contribution is to introduce the notion of determinate concurrent constraint programming languages. The combinators treated are ask, tell, parallel composition, hiding and recursion. We present a simple model for this language based on the specificationoriented methodology of [OH86]. The crucial insight is to focus on observing the resting points of a process—those stores in which the process quiesces without producing more information. It turns out that for the determinate language, the set of resting points of a process completely characterizes its behavior on all inputs, since each process can be identified with a closure operator over the underlying constraint system. Very natural definitions of parallel composition, communication and hiding are given. For example, the parallel composition of two agents can be characterized by just the intersection of the sets of constraints associated with them. We also give a complete axiomatization of equality in this model, present
Linear Objects: logical processes with builtin inheritance
, 1990
"... We present a new framework for amalgamating two successful programming paradigms: logic programming and objectoriented programming. From the former, we keep the declarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their ..."
Abstract

Cited by 211 (6 self)
 Add to MetaCart
We present a new framework for amalgamating two successful programming paradigms: logic programming and objectoriented programming. From the former, we keep the declarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their internal state during the computation; (ii) the structured representation of knowledge, generally obtained via inheritance graphs among classes of objects. We start with the approach, introduced in concurrent logic programming languages, which identifies objects with proof processes and object states with arguments occurring in the goals of a given process. This provides a clean, sideeffect free account of the dynamic behavior of objects in terms of the search tree  the only dynamic entity in logic programming languages. We integrate this view of objects with an extension of logic programming, which we call Linear Objects, based on the possibility of having multiple literals in the head of a program clause. This contains within itself the basis for a flexible form of inheritance, and maintains the constructive property of Prolog of returning definite answer substitutions as output of the proof of nonground goals. The theoretical background for Linear Objects is Linear Logic, a logic recently introduced to provide a theoretical basis for the study of concurrency. We also show that Linear Objects can be considered a constructive restriction of full Classical Logic. We illustrate the expressive power of Linear Objects compared to Prolog by several examples from the objectoriented domain, but we also show that it can be used to provide elegant solutions for problems arising in the standard style of logic programming.
An OpenEnded Finite Domain Constraint Solver
, 1997
"... We describe the design and implementation of a finite domain constraint solver embedded in a Prolog system using an extended unification mechanism via attributed variables as a generic constraint interface. The solver is essentially a scheduler for indexicals, i.e. reactive functional rules encodin ..."
Abstract

Cited by 196 (8 self)
 Add to MetaCart
We describe the design and implementation of a finite domain constraint solver embedded in a Prolog system using an extended unification mechanism via attributed variables as a generic constraint interface. The solver is essentially a scheduler for indexicals, i.e. reactive functional rules encoding local consistency methods performing incremental constraint solving or entailment checking, and global constraints, i.e. general propagators which may use specialized algorithms to achieve a higher degree of consistency or better time and space complexity. The solver has an openended design: the user can introduce new constraints, either in terms of indexicals by writing rules in a functional notation, or as global constraints via a Prolog programming interface. Constraints defined in terms of indexicals can be linked to 0/1variables modeling entailment; thus indexicals are used for constraint solving as well as for entailment testing. Constraints can be arbitrarily combined using the ...
DESIGN, IMPLEMENTATION, AND EVALUATION OF THE CONSTRAINT LANGUAGE cc(FD)
 J. LOGIC PROGRAMMING 1994:19, 20:1679
, 1994
"... This paper describes the design, implementation, and applications of the constraint logic language cc(FD). cc(FD) is a declarative nondeterministic constraint logic language over finite domains based on the cc framework [33], an extension of the CLP scheme [21]. Its constraint solver includes (nonl ..."
Abstract

Cited by 188 (11 self)
 Add to MetaCart
This paper describes the design, implementation, and applications of the constraint logic language cc(FD). cc(FD) is a declarative nondeterministic constraint logic language over finite domains based on the cc framework [33], an extension of the CLP scheme [21]. Its constraint solver includes (nonlinear) arithmetic constraints over natural numbers which are approximated using domain and interval consistency. The main novelty of cc(FD) is the inclusion of a number of generalpurpose combinators, in particular cardinality, constructive disjunction, and blocking implication, in conjunction with new constraint operations such as constraint entailment and generalization. These combinators significantly improve the operational expressiveness, extensibility, and flexibility of CLP languages and allow issues such as the definition of nonprimitive constraints and disjunctions to be tackled at the language level. The implementation of cc(FD) (about 40,000 lines of C) includes a WAMbased engine [44], optimal arcconsistency algorithms based on AC5 [40], and incremental implementation of the combinators. Results on numerous problems, including scheduling, resource allocation, sequencing, packing, and hamiltonian paths are reported and indicate that cc(FD) comes close to procedural languages on a number of combinatorial problems. In addition, a small cc(FD) program was able to find the optimal solution and prove optimality to a famous 10/10 disjunctive scheduling problem [29], which was left open for more than 20 years and finally solved in 1986.
Compiling Constraints in clp(FD)
, 1996
"... We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints... ..."
Abstract

Cited by 174 (24 self)
 Add to MetaCart
We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints...
Constraint Hierarchies
 LISP AND SYMBOLIC COMPUTATION
, 1992
"... Constraints allow programmers and users to state declaratively a relation that should be maintained, rather than requiring them to write procedures to maintain the relation themselves. They are thus useful in such applications as programming languages, user interface toolkits, and simulation package ..."
Abstract

Cited by 164 (15 self)
 Add to MetaCart
Constraints allow programmers and users to state declaratively a relation that should be maintained, rather than requiring them to write procedures to maintain the relation themselves. They are thus useful in such applications as programming languages, user interface toolkits, and simulation packages. In many situations, it is desirable to be able to state both required and preferential constraints. The required constraints must hold. Since the other constraints are merely preferences, the system should try to satisfy them if possible, but no error condition arises if it cannot. A constraint hierarchy consists of a set of constraints, each labeled as either required or preferred at some strength. An arbitrary number of different strengths is allowed. In the discussion of a theory of constraint hierarchies, we present alternate ways of selecting among competing possible solutions, and prove a number of propositions about the relations among these alternatives. We then outline algorit...