The CIAO multiparadigm compiler and system: A progress report

Abstract is not available

Constraint Propagation in Presence of Arrays

We describe the use of array expressions as constraints, which represents a consequent generalisation of the "element" constraint. Constraint propagation for array constraints is studied theoretically, and for a set of domain reduction rules the local consistency they enforce, arc-consistency, is proved. An efficient algorithm is described that encapsulates the rule set and so inherits the capability to enforce arc-consistency from the rules.Comment: 10 pages. Accepted at the 6th Annual Workshop of the ERCIM Working Group on Constraints, 200

The CIAO Multi-Dialect Compiler and System: An Experimentation Workbench for Future (C)LP Systems

CIAO is an advanced programming environment supporting Logic and Constraint programming. It offers a simple concurrent kernel on top of which declarative and non-declarative extensions are added via librarles. Librarles are available for supporting the ISOProlog standard, several constraint domains, functional and higher order programming, concurrent and distributed programming, internet programming, and others. The source language allows declaring properties of predicates via assertions, including types and modes. Such properties are checked at compile-time or at run-time. The compiler and system architecture are designed to natively support modular global analysis, with the two objectives of proving properties in assertions and performing program optimizations, including transparently exploiting parallelism in programs. The purpose of this paper is to report on recent progress made in the context of the CIAO system, with special emphasis on the capabilities of the compiler, the techniques used for supporting such capabilities, and the results in the áreas of program analysis and transformation already obtained with the system

Logic programming in the context of multiparadigm programming: the Oz experience

Oz is a multiparadigm language that supports logic programming as one of its major paradigms. A multiparadigm language is designed to support different programming paradigms (logic, functional, constraint, object-oriented, sequential, concurrent, etc.) with equal ease. This article has two goals: to give a tutorial of logic programming in Oz and to show how logic programming fits naturally into the wider context of multiparadigm programming. Our experience shows that there are two classes of problems, which we call algorithmic and search problems, for which logic programming can help formulate practical solutions. Algorithmic problems have known efficient algorithms. Search problems do not have known efficient algorithms but can be solved with search. The Oz support for logic programming targets these two problem classes specifically, using the concepts needed for each. This is in contrast to the Prolog approach, which targets both classes with one set of concepts, which results in less than optimal support for each class. To explain the essential difference between algorithmic and search programs, we define the Oz execution model. This model subsumes both concurrent logic programming (committed-choice-style) and search-based logic programming (Prolog-style). Instead of Horn clause syntax, Oz has a simple, fully compositional, higher-order syntax that accommodates the abilities of the language. We conclude with lessons learned from this work, a brief history of Oz, and many entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic Programming

Monomial right ideals and the Hilbert series of noncommutative modules

In this paper we present a procedure for computing the rational sum of the Hilbert series of a finitely generated monomial right module $N$ over the free associative algebra $K\langle x_1,\ldots,x_n \rangle$. We show that such procedure terminates, that is, the rational sum exists, when all the cyclic submodules decomposing $N$ are annihilated by monomial right ideals whose monomials define regular formal languages. The method is based on the iterative application of the colon right ideal operation to monomial ideals which are given by an eventual infinite basis. By using automata theory, we prove that the number of these iterations is a minimal one. In fact, we have experimented efficient computations with an implementation of the procedure in Maple which is the first general one for noncommutative Hilbert series.Comment: 15 pages, to appear in Journal of Symbolic Computatio

Automatic compile-time parallelization of CLP programs by analysis and transformation to a concurrent constraint language.

The concept of independence has been recently generalized to the constraint logic programming (CLP) paradigm. Also, several abstract domains specifically designed for CLP languages, and whose information can be used to detect the generalized independence conditions, have been recently defined. As a result we are now in a position where automatic parallelization of CLP programs is feasible. In this paper we study the task of automatically parallelizing CLP programs based on such analyses, by transforming them to explicitly concurrent programs in our parallel CC platform (CIAO) as well as to AKL. We describe the analysis and transformation process, and study its efficiency, accuracy, and effectiveness in program parallelization. The information gathered by the analyzers is evaluated not only in terms of its accuracy, i.e. its ability to determine the actual dependencies among the program variables, but also of its effectiveness, measured in terms of code reduction in the resulting parallelized programs. Given that only a few abstract domains have been already defined for CLP, and that none of them were specifically designed for dependency detection, the aim of the evaluation is not only to asses the effectiveness of the available domains, but also to study what additional information it would be desirable to infer, and what domains would be appropriate for further improving the parallelization process

Finite domain constraint programming systems

Tutorial at CP'2002, Principles and Practice of Constraint Programming. Powerpoint slides.</p

Multigraded Hilbert Series of noncommutative modules

In this paper, we propose methods for computing the Hilbert series of multigraded right modules over the free associative algebra. In particular, we compute such series for noncommutative multigraded algebras. Using results from the theory of regular languages, we provide conditions when the methods are effective and hence the sum of the Hilbert series is a rational function. Moreover, a characterization of finite-dimensional algebras is obtained in terms of the nilpotency of a key matrix involved in the computations. Using this result, efficient variants of the methods are also developed for the computation of Hilbert series of truncated infinite-dimensional algebras whose (non-truncated) Hilbert series may not be rational functions. We consider some applications of the computation of multigraded Hilbert series to algebras that are invariant under the action of the general linear group. In fact, in this case such series are symmetric functions which can be decomposed in terms of Schur functions. Finally, we present an efficient and complete implementation of (standard) graded and multigraded Hilbert series that has been developed in the kernel of the computer algebra system Singular. A large set of tests provides a comprehensive experimentation for the proposed algorithms and their implementations.Comment: 28 pages, to appear in Journal of Algebr

A geometric constraint over k-dimensional objects and shapes subject to business rules

This report presents a global constraint that enforces rules written in a language based on arithmetic and first-order logic to hold among a set of objects. In a first step, the rules are rewritten to Quantifier-Free Presburger Arithmetic (QFPA) formulas. Secondly, such formulas are compiled to generators of k-dimensional forbidden sets. Such generators are a generalization of the indexicals of cc(FD). Finally, the forbidden sets generated by such indexicals are aggregated by a sweep-based algorithm and used for filtering. The business rules allow to express a great variety of packing and placement constraints, while admitting efficient and effective filtering of the domain variables of the k-dimensional object, without the need to use spatial data structures. The constraint was used to directly encode the packing knowledge of a major car manufacturer and tested on a set of real packing problems under these rules, as well as on a packing-unpacking problem

Encapsulated search and constraint programming in Oz

Oz is an attempt to create a high-level concurrent programming language providing the problem solving capabilities of logic programming (i.e., constraints and search). Its computation model can be seen as a rather radical extension of the concurrent constraint model providing for higher-order programming, deep guards, state, and encapsulated search. This paper focuses on the most recent extension, a higher-order combinator providing for encapsulated search. The search combinator spawns a local computation space and resolves remaining choices by returning the alternatives as first-class citizens. The search combinator allows to program different search strategies, including depth-first, indeterministic one solution, demand-driven multiple solution, all solutions, and best solution (branch and bound) search. The paper also discusses the semantics of integer and finite domain constraints in a deep guard computation model