Results 1  10
of
66
A Generic ArcConsistency Algorithm and its Specializations
 Artificial Intelligence
, 1992
"... Consistency techniques have been studied extensively in the past as a way of tackling constraint satisfaction problems (CSP). In particular, various arcconsistency algorithms have been proposed, originating from Waltz's filtering algorithm [26] and culminating in the optimal algorithm AC4 of ..."
Abstract

Cited by 190 (7 self)
 Add to MetaCart
Consistency techniques have been studied extensively in the past as a way of tackling constraint satisfaction problems (CSP). In particular, various arcconsistency algorithms have been proposed, originating from Waltz's filtering algorithm [26] and culminating in the optimal algorithm AC4 of Mohr and Henderson [15]. AC4 runs in O(ed 2 ) in the worst case, where e is the number of arcs (or constraints) and d is the size of the largest domain. Being applicable to the whole class of (binary) CSP, these algorithms do not take into account the semantics of constraints. In this paper, we present a new generic arcconsistency algorithm AC5. This algorithm is parametrized on two specified procedures and can be instantiated to reduce to AC3 and AC4. More important, AC5 can be instantiated to produce an O(ed) algorithm for a number of important classes of constraints: functional, antifunctional, monotonic and their generalization to (functional, antifunctional, and monotonic) piecewise constraints. We also show that AC5 has an important application in constraint logic programming over finite domains [23]. The kernel of the constraint solver for such a programming language is an arcconsistency algorithm for a set of basic constraints. We prove that AC5, in conjunction with node consistency, provides a decision procedure for these constraints running in time O(ed).
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 154 (6 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 ...
Compiling Constraints in clp(FD)
, 1996
"... We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints... ..."
Abstract

Cited by 147 (19 self)
 Add to MetaCart
We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints...
Foundations of Timed Concurrent Constraint Programming
 Proceedings of the Ninth Annual IEEE Symposium on Logic in Computer Science
, 1994
"... We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denota ..."
Abstract

Cited by 87 (10 self)
 Add to MetaCart
We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denotational character. We show how programs may be compiled into finitestate machines with loopfree computations at each state, thus guaranteeing bounded response time. 1 Introduction and Motivation Reactive systems [12,3,9] are those that react continuously with their environment at a rate controlled by the environment. Execution in a reactive system proceeds in bursts of activity. In each phase, the environment stimulates the system with an input, obtains a response in bounded time, and may then be inactive (with respect to the system) for an arbitrary period of time before initiating the next burst. Examples of reactive systems are controllers and signalprocessing systems. The primary issu...
A Minimal Extension of the WAM for clp(FD)
 Proceedings of the Tenth International Conference on Logic Programming
, 1993
"... We present an abstract instruction set for a constraint solver over finite domains, which can be smoothly integrated in the WAM architecture. It is based on the use of a single primitive constraint X in r which embeds the core propagation mechanism. Complex user constraints such as linear equations ..."
Abstract

Cited by 67 (7 self)
 Add to MetaCart
We present an abstract instruction set for a constraint solver over finite domains, which can be smoothly integrated in the WAM architecture. It is based on the use of a single primitive constraint X in r which embeds the core propagation mechanism. Complex user constraints such as linear equations or inequations are compiled into X in r expressions which encode the propagation scheme chosen to solve the constraint. The uniform treatment of a single primitive constraint leads to a better understanding of the overall constraint solving process and makes possible three main global optimizations which encompass many previous particular optimizations of "black box" finite domains solvers. Implementation results show that this approach combines both simplicity and efficiency. Our clp(FD) system is more than twice as fast as CHIP on average, with peak speedup reaching seven. 1 Introduction Constraint Logic Programming (CLP) has shown to be a very active field of research over recent years, ...
Timed Default Concurrent Constraint Programming
 Journal of Symbolic Computation
, 1996
"... Synchronous programming (Berry (1989)) is a powerful approach to programming reactive systems. Following the idea that "processes are relations extended over time" (Abramsky (1993)), we propose a simple but powerful model for timed, determinate computation, extending the closureoperator m ..."
Abstract

Cited by 61 (11 self)
 Add to MetaCart
Synchronous programming (Berry (1989)) is a powerful approach to programming reactive systems. Following the idea that "processes are relations extended over time" (Abramsky (1993)), we propose a simple but powerful model for timed, determinate computation, extending the closureoperator model for untimed concurrent constraint programming (CCP). In (Saraswat et al. 1994a) we had proposed a model for this called tcc here we extend the model of tcc to express strong timeouts: if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in synchronous programming languages. The fundamental conceptual difficulty posed by these operations is that they are nonmonotonic. We provide a compositional semantics to the nonmonotonic version of concurrent constraint programming (Default cc) obtained by changing the underlying logic from intuitionistic logic to Reiter's default logic...
Efficient constraint propagation engines
 Transactions on Programming Languages and Systems
"... This paper presents a model and implementation techniques for speeding up constraint propagation. Three fundamental approaches to improving constraint propagation based on propagators as implementations of constraints are explored: keeping track of which propagators are at fixpoint, choosing which p ..."
Abstract

Cited by 40 (6 self)
 Add to MetaCart
This paper presents a model and implementation techniques for speeding up constraint propagation. Three fundamental approaches to improving constraint propagation based on propagators as implementations of constraints are explored: keeping track of which propagators are at fixpoint, choosing which propagator to apply next, and how to combine several propagators for the same constraint. We show how idempotence reasoning and events help track fixpoints more accurately. We improve these methods by using them dynamically (taking into account current domains to improve accuracy). We define prioritybased approaches to choosing a next propagator and show that dynamic priorities can improve propagation. We illustrate that the use of multiple propagators for the same constraint can be advantageous with priorities, and introduce staged propagators that combine the effects of multiple propagators with priorities for greater efficiency. 1
Design and Implementation of the GNU Prolog System
 Journal of Functional and Logic Programming
, 2001
"... In this paper we describe the design and the implementation of the GNU Prolog system. This system draws on our previous experience of compiling Prolog to C in the wamcc system and of compiling finite domain constraints in the clp(FD) system. The compilation scheme has however been redesigned in orde ..."
Abstract

Cited by 34 (7 self)
 Add to MetaCart
In this paper we describe the design and the implementation of the GNU Prolog system. This system draws on our previous experience of compiling Prolog to C in the wamcc system and of compiling finite domain constraints in the clp(FD) system. The compilation scheme has however been redesigned in order to overcome the drawbacks of compiling to C. In particular, GNUProlog is based on a lowlevel miniassembly platformindependent language that makes it possible to avoid compiling C code, and thus drastically reduces compilation time. It also makes it possible to produce small standalone executable files as the result of the compilation process. Interestingly, GNU Prolog is now compliant to the ISO standard, includes several extensions (OS interface, sockets, global variables, etc) and integrates a powerful constraint solver over finite domains. The system is efficient and in terms of performance is comparable with commercial systems for both the Prolog and constraint aspects.
Programming in Timed Concurrent Constraint Languages
, 1994
"... This paper explores Lhc expressive power of Lhc tcc paradigm. The origin of Lhc work in Lhc inLcgraLion of synchronous and consLrainL programming is described. The basic conceptual and maLhcmaLical framework developed in Lhc spirk of Lhc modelbased approach characLcrisLic of LhcorcLical compuLcr sc ..."
Abstract

Cited by 33 (4 self)
 Add to MetaCart
This paper explores Lhc expressive power of Lhc tcc paradigm. The origin of Lhc work in Lhc inLcgraLion of synchronous and consLrainL programming is described. The basic conceptual and maLhcmaLical framework developed in Lhc spirk of Lhc modelbased approach characLcrisLic of LhcorcLical compuLcr science is reviewed. Wc show LhaL a range of consLrucLs for expressing LimcouLs, prccmpLion and oLhcr complicaLcd paLLcrns of Lcmporal acLivky arc expressible in the basic model and languageframework. Indeed, we present a single construct on processes, definable in the language, that can simulate the effect of other preemption constructs