Mats Carlsson

An Open-Ended Finite Domain Constraint Solver

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 Aurora or-parallel Prolog system

Aurora is a prototype or-parallel implementation of the full Prolog language for shared-memory multiprocessors, developed as part of an informal research collaboration known as the “Gigalips Project”. It currently runs on Sequent and Encore machines. It has been constructed by adapting Sicstus Prolog, a fast, portable, sequential Prolog system. The techniques for constructing a portable multiprocessor version follow those pioneered in a predecessor system, ANL-WAM. The SRI model was adopted as the means to extend the Sicstus Prolog engine for or-parallel operation. We describe the design and main implementation features of the current Aurora system, and present some experimental results. For a range of benchmarks, Aurora on a 20-processor Sequent Symmetry is 4 to 7 times faster than Quintus Prolog on a Sun 3/75. Good performance is also reported on some large-scale Prolog applications.

Parallel execution of prolog programs: a survey

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

Deriving filtering algorithms from constraint checkers

This article deals with global constraints for which the set of solutions can be recognized by an extended finite automaton whose size is bounded by a polynomial in n, where n is the number of variables of the corresponding global constraint. By reformulating the automaton as a conjunction of signature and transition constraints we show how to systematically obtain a filtering algorithm. Under some restrictions on the signature and transition constraints this filtering algorithm achieves arc-consistency. An implementation based on some constraints as well as on the metaprogramming facilities of SICStus Prolog is available. For a restricted class of automata we provide a filtering algorithm for the relaxed case, where the violation cost is the minimum number of variables to unassign in order to get back to a solution.

Global Constraint Catalogue: Past, Present and Future

The catalogue of global constraints is reviewed, focusing on the graph-based description of global constraints. A number of possible enhancements are proposed as well as several research paths for the development of the area.

Sweep as a Generic Pruning Technique Applied to the Non-overlapping Rectangles Constraint

We firstpresen ta generic pruning technique which aggregates several constraints sharing some variables. The method is derived from an idea called sweep which is extensively used in computational geometry. A first benefit of this technique comes from the fact that it can be applied to several families of global constraints. A second advantage is that it does not lead to any memory consumption problem since it only requires temporary memory which can be reclaimed after each invocation of the method.We then specialize this technique to the non-overlapping rectangles constraint, describe several optimizations, and give an empirical evaluation based on six sets of test instances with different characteristics.

A New Multi-resource cumulatives Constraint with Negative Heights

This paper presents a newcumulatives constraint, which generalizes the original cumulative constraint in different ways. The two most important aspects consist in permitting multiple cumulative resources as well as negative heights for the resource consumption of the tasks. This allows modeling in an easy way workload covering, producer-consumer, and scheduling problems. The introduction of negative heights has forced us to come up with new filtering algorithms and to revisit existing ones. The first filtering algorithm is derived from an idea called sweep, which is extensively used in computational geometry; the second algorithm is based on a combination of sweep and constructive disjunction; while the last is a generalization of task intervals to this new context. A real-life crew scheduling problem originally motivated this constraint which was implemented within the SICStus finite domain solver and evaluated against different problem patterns.

Finite domain constraint programming systems

Publisher Summary This chapter focuses on the propagation-based finite domain constraint programming systems—that is, systems that solve problems using constraint propagation involving variables ranging over some finite set of integers. The focus on finite domain constraint programming systems coincides with both practical relevance and known principles and techniques: systems at least offer services for finite domains; much of the known principles and techniques are conceived and documented for finite domains. The chapter! concludes that finite-domain constraint programming systems are proved to be useful tools for solving many problems in a wide range of application areas. Several useful techniques for the implementation of constraint systems are available, both for constraint propagation as well as for search. However, because of the change of available hardware platforms, the advent of new methods for problem solving and new constraints and propagators, and new requirements for systems, it is clear that the development of constraint programming systems will be faced with many new and difficult challenges.

A generic geometrical constraint kernel in space and time for handling polymorphic k-dimensional objects

This paper introduces a geometrical constraint kernel for handling the location in space and time of polymorphic k-dimensional objects subject to various geometrical and time constraints. The constraint kernel is generic in the sense that one of its parameters is a set of constraints on subsets of the objects. These constraints are handled globally by the kernel. We first illustrate how tomodel several placement problems with the constraint kernel. We then explain how new constraints can be introduced and plugged into the kernel. Based on these interfaces, we develop a generic k-dimensional lexicographic sweep algorithm for filtering the attributes of an object (i.e., its shape and the coordinates of its origin as well as its start, duration and end in time) according to all constraints where the object occurs. Experiments involving up to hundreds of thousands of objects and 1 million integer variables are provided in 2, 3 and 4 dimensions, both for simple shapes (i.e., rectangles, parallelepipeds) and for more complex shapes.

Revisiting the Cardinality Operator and Introducing the Cardinality-Path Constraint Family

This paper revisits the classical cardinality operator introducing new propagation rules that operate on variables that occur in more than one constraint. It also introduces a restricted case of the cardinality operator which is characterized by a structure of sliding constraints on consecutive variables. We call it cardinality-path and take advantage of these restrictions in order to come up with more efficient propagation algorithms. From an application point of view the cardinality-path constraint allows to express a host of regulation constraints occurring in personnel planning problems. We have used the metaprogramming services of Prolog in order to implement the cardinality-path constraint within SICStus Prolog.