Constraint Logic Programming System Research Articles

Declarative Representation and Solution of Vehicle Routing with Pickup and Delivery Problem

Recently we have proposed a multi-agent system that provides an intelligent logistics brokerage service focusing on the transport activity for the efficient allocation of transport resources (vehicles or trucks) to the transport applications. The freight broker agent has a major role to coordinate transportation arrangements of transport customers (usually shippers and consignees) with transport resource providers or carriers, following the freight broker business model. We focus on the fundamental function of this business that aims to find available trucks and to define their feasible routes for transporting requested customer loads. The main contribution of this paper is on formulating our scheduling problem as a special type of vehicle routing with pickup and delivery problem. We propose a new set partitioning model of our specific problem. Vehicle routes are defined on the graph of cities, rather than on the graph of customer orders, as typically proposed by set partitioning formulations. This approach is particularly useful when a large number of customer orders sharing a significantly lower number of pickup and delivery points must be scheduled. Our achievement is the declarative representation and solution of the model using ECLiPSe state-of-the-art constraint logic programming system.

Efficient generation of test data structures using constraint logic programming and program transformation

The goal of Bounded-Exhaustive Testing (BET) is the automatic generation of all test cases satisfying a given invariant, within a given size bound. When the test cases have a complex structure, the development of correct and efficient generators becomes a very challenging task. In this paper we use Constraint Logic Programming (CLP) to systematically develop generators of structurally complex test data structures. We follow a declarative approach which allows us to separate the issue of (i) defining the test data structure in terms of its properties, from that of (ii) efficiently generating data structure instances. This separation helps establish the correctness of the developed test case generators. We rely on a symbolic representation and we take advantage of efficient search strategies provided by CLP systems for generating test instances. Through a running example taken from the literature on BET, we illustrate our test generation framework and we show that CLP allows us to develop easily understandable and efficient test generators. Additionally, we propose a program transformation technique whose goal is to make the evaluation of these CLP-based generators much more efficient and we demonstrate its effectiveness on a number of complex test data structures.

Research on Mechanism of Variable Event in CLP System

Constraint inference engine as the core part of constraint logic programming system comprises variable set, temporary container and constraint filter and inference engine and adopts branching strategy, exploration strategy and node backtracking strategy to complete the inference task. This study introduces variable event to reduce the triggering times of constraint filter and analyzes the trigger probability of inference engine. The experiments show that variable event setting can enhance the efficiency of constraint inference engine.

Solving functional constraints by variable substitution

AbstractFunctional constraints and bi-functional constraints are an important constraint class in Constraint Programming (CP) systems, in particular for Constraint Logic Programming (CLP) systems. CP systems with finite domain constraints usually employ Constraint Satisfaction Problem(s)-based solvers which use local consistency, for example, arc consistency. We introduce a new approach which is based instead on variable substitution. We obtain efficient algorithms for reducing systems involving functional and bi-functional constraints together with other nonfunctional constraints. It also solves globally any CSP where there exists a variable such that any other variable is reachable from it through a sequence of functional constraints. Our experiments on random problems show that variable elimination can significantly improve the efficiency of solving problems with functional constraints.

Communicating sequential processes for distributed constraint satisfaction

CSPCONS is a programming language that supports program execution over multiple Prolog processes with constraints. The language is an extended version of C sp-ii, a version of Prolog that supports channel-based communicating processes and TCP/IP communication, that is based on the CSP model introduced by Hoare. C spcons inherits all the advanced features of C sp-ii and extends it by introducing constraint solving capabilities to the processes. In C spcons each Prolog process has one or more solvers attached and each solver is independent from the others, following the original C sp-ii model, thus resulting to a communicating sequential constraint logic programming system. Such a model can facilitate greatly the implementation of distributed CLP applications. This paper describes the original C sp-ii system along with details of the extensions that resulted to the C spcons system and presents an example demonstrating the applicability of the system to distributed constraint satisfaction problems.

CLPGUI: A Generic Graphical User Interface for Constraint Logic Programming

CLPGUI is a generic graphical user interface for visualizing and controlling the execution of constraint logic programs. CLPGUI has been designed to be used in different contexts: initially for teaching purposes, then for debugging complex programs of real-world scale, and recently for developing end-user interfaces. The challenge of developing a tool which is generic w.r.t. both the constraint logic programming system and the visualizers, is addressed by a client-server architecture for connecting a CLP process to a Java-based GUI process, and by a non-intrusive tracing and control method based on annotations in the CLP program. Arbitrary constraints and goals can be posted incrementally from the GUI in an interactive manner, and arbitrary states can be recomputed. We describe several generic 2D and 3D viewers of the variables and of the search tree, and argue that the 3D representation is best-suited to apprehend the shape of large search trees. We also illustrate the use of CLPGUI for developing application-oriented end-user interfaces on two placement problems, one in virtual reality.

Disunification in ACI1 Theories

Disunification is the problem of deciding satisfiability of a system of equations and disequations with respect to a given equational theory. In this paper we study the disunification problem in the context of ACI1 equational theories. This problem is of great importance, for instance, for the development of constraint solvers over sets. Its solution opens new possibilities for developing automatic tools for static analysis and software verification. In this work we provide a characterization of the interpretation structures suitable to model the axioms in ACI1 theories. The satisfiability problem is solved using known techniques for the equality constraints and novel methodologies to transform disequation constraints to manageable solved forms. We propose four solved forms, each offering an increasingly more precise description of the set of solutions. For each solved form we provide the corresponding rewriting algorithm and we study the time complexity of the transformation. Remarkably, two of the solved forms can be computed and tested in polynomial time. All these solved forms are adequate to be used in the context of a Constraint Logic Programming system—e.g., they do not introduce universal quantifications, as instead happens in some of the existing solved forms for disunification problems.

CGLIB—a constraint‐based graphics library

AbstractCGLIB is a high‐level graphics library for B‐Prolog, a constraint logic programming system. The library provides primitives for creating and manipulating graphical objects and a set of constraints including not‐overlap, grid, table and tree constraints that facilitate the specification of the layouts of objects. The library adopts a construct called action rules which is available in B‐Prolog for creating agents and programming interactions among agents or between agents and the user. The library is a fully working system implemented in B‐Prolog, Java and C. It can be used in many areas such as drawing editors, interactive user interfaces, document authoring, animation, information visualization, intelligent agents and games. The high‐level abstraction of the library and the use of constraints and action rules in the specification of layouts and behaviors can significantly enhance the productivity of the development of graphics. We demonstrate through several examples the effectiveness of the library as a tool for developing graphics‐rich and interactive user interfaces. Copyright © 2003 John Wiley & Sons, Ltd.

Precise goal-independent abstract interpretation of constraint logic programs

We present a goal-independent abstract interpretation framework for constraint logic programs, and prove the sufficiency of a set of conditions for abstract domains to ensure that the analysis will never lose precision. Along the way, we formally define constraint logic programming systems, give a formal semantics that is independent of the actual constraint domain and the details of the proof algorithm, and formally define the maximally precise abstraction of a constraint logic program.

An Overview of MSR( [formula omitted]): A CLP-based Framework for the Symbolic Verification of Parameterized Concurrent Systems

In recent works we have defined a general framework for the validation of parameterized concurrent systems based on the combination of multiset rewriting and constraints. The class of systems we are interested in consists of concurrent systems parametric in the number of individual components.Our framework provides the following features: 1.a specification language for the class of concurrent systems taken into consideration;2.an assertional language to finitely represent infinite sets of configurations; and3.a sound and fully automatic verification method based on symbolic state exploration.The verification procedure has been implemented in a Constraint Logic Programming systems, namely Sicstus Prolog and the clp(Q,R) library. CLP provides in fact all necessary operations to manipulate multisets and constraints both as uninterpreted and interpreted objects. Operations over constraints are delegated in fact to the clp(Q,R) library, and encapsulated into Sicstus Prolog predicates. The method can be applied to solve validation problems for communication protocols, and (potentially) of security and authentication protocols and abstractions of concurrent programs.In this paper we overview the main features of our framework and comment on some of the more interesting applications.

Constraint-based deductive model checking

We show that constraint logic programming (CLP) can serve as a conceptual basis and as a practical implementation platform for the model checking of infinite-state systems. CLP programs are logical formulas (built up from constraints) that have both a logical interpretation and an operational semantics. Our contributions are: (1) a translation of concurrent systems (imperative programs) into CLP programs with the same operational semantics; and (2) a deductive method for verifying safety and liveness properties of the systems which is based on the logical interpretation of the CLP programs produced by the translation. We have implemented the method in a CLP system and verified well-known examples of infinite-state programs over integers, using linear constraints here as opposed to Presburger arithmetic as in previous solutions.

Precise Goal-Independent Abstract Interpretation of Constraint Logic Programs

We present a goal-independent abstract interpretation framework for pure constraint logic programs, and prove the sufficiency of a set of conditions for abstract domains to ensure that the analysis will never lose precision. Along the way, we formally define pure constraint logic programming systems, give a formal semantics that is independent of the actual constraint domain, and formally define the maximally precise abstraction of a pure constraint logic program.

A Comparative Study of Eight Constraint Programming LanguagesOver the Boolean and Finite Domains

This paper compares the efficiency of a number of Constraint Logic Programming (CLP) systems in the setting of finite domains as well as a specific aspect of their expressiveness (that concerning reification and meta-constraints). There are two key reasons for adopting CLP technology for solving a problem. The first is its expressiveness enabling a declarative solution with readable code which is vital for maintenance and the second is the provision of an efficient implementation for the computationally expensive procedures. However, CLP systems differ significantly both in how solutions may be expressed and the efficiency of their execution and it is important that both these factors are taken into account when choosing the best CLP system for a particular application. This paper aids this choice by illustrating differences between the systems, indicating their particular strengths and weaknesses.

Attributed Variables in XSB

The attributed variable data type plays an important role in many extensions to the basic Logic Programming language. It provides a flexible mechanism to implement constraint solvers over different domains in a standard logic programming system. To combine the technique of constraint solving with tabling and build a tabled constraint logic programming system, special work has to be done to handle attributed variables when they are copied into and out of tables. In this paper, we describe the implementation of attributed variables in XSB — a tabled logic programming system.We first introduce the internal representation of attributed variables and the interface between the internal representation and the user defined high level unification handler. Then, as the primary focus of the paper, we describe how the tabling mechanism in XSB can be extended to efficiently handle attributed variables. To save attributed variables in tables, the structure of subgoal table and answer table is modified, and the tabling engine itself requires extension as well.

A new approach to integrating mixed integer programming and constraint logicprogramming

This paper represents an integration of Mixed Integer Programming (MIP) and ConstraintLogic Programming (CLP) which, like MIP, tightens bounds rather than adding constraintsduring search. The integrated system combines components of the CLP system ECLiPSe[7] and the MIP system CPLEX [5], in which constraints can be handled by either one orboth components. Our approach is introduced in three stages. Firstly, we present an automatictransformation which maps CLP programs onto such CLP programs that any disjunction iseliminated in favour of auxiliary binary variables. Secondly, we present improvements ofthis mapping by using a committed choice operator and translations of pre‐defined non‐linearconstraints. Thirdly, we introduce a new hybrid algorithm which reduces the solutionspace of the problem progressively by calling finite domain propagation of ECLiPSe aswell as dual simplex of CPLEX. The advantages of this integration are illustrated by efficientlysolving difficult optimisation problems like the Hoist Scheduling Problem [23]and the Progressive Party Problem [27].

Optimizing compilation of CLP( ℛ )

Constraint Logic Programming (CLP) languages extend logic programming by allowing the use of constraints from different domains such as real numbers or Boolean functions. They have proved to be ideal for expressing problems that require interactive mathematical modeling and complex combinatorial optimization problems. However, CLP languages have mainly been considered as research systems, useful for rapid prototyping, by not really competitive with more conventional programming languages where efficiency is a more important consideration. One promising approach to improving the performance of CLP systems is the use of powerful program optimizations to reduce the cost of constraint solving. We extend work in this area by describing a new optimizing compiler for the CLP language CLP(ℛ). The compiler implements six powerful optimizations: reordering of constraints, removal of redundant variables, and specialization of constraints which cannot fail. Each program optimization is designed to remove the overhead of constraint solving when possible and keep the number of constraints in the store as small as possible. We systematically evaluate the effectiveness of each optimization in isolation and in combination. Our empirical evaluation of the compiler verifies that optimizing compilation can be made efficient enough to allow compilation of real-world programs and that it is worth performing such compilation because it gives significant time and space performance improvements.

The semantics of constraint logic programs

The Constraint Logic Programming (CLP) Scheme was introduced by Jaffar and Lassez. The scheme gave a formal framework, based on constraints, for the basic operational, logical and algebraic semantics of an extended class of logic programs. This paper presents for the first time the semantic foundations of CLP in a self-contained and complete package. The main contributions are threefold. First, we extend the original conference paper by presenting definitions and basic semantic constructs from first principles, giving new and complete proofs for the main lemmas. Importantly, we clarify which theorems depend on conditions such as solution compactness, satisfaction completeness and independence of constraints. Second, we generalize the original results to allow for incompleteness of the constraint solver. This is important since almost all CLP systems use an incomplete solver. Third, we give conditions on the (possibly incomplete) solver which ensure that the operational semantics is confluent, that is, has independence of literal scheduling.

Modelling Discrete Optimisation Problems in Constraint Logic Programming

Constraint logic programming has become a promising new technology for solving complexcombinatorial problems. In this paper, we investigate how (constraint) logic programmingcan support the modelling part when solving discrete optimisation problems. First, we showthat the basic functionality of algebraic modelling languages can be realised very easily ina pure logic programming system like PROLOG and that, even without using constraints,various additional features are available. Then we focus on the constraint-solving facilitiesoffered by constraint logic programming systems. In particular, we explain how the constraintsolver of the constraint logic programming language CLP(PB) can be used in modelling0 - 1 problems.

Global Energy Minimization of Small Molecules Combining Constraint Logic Programming and Molecular Mechanics

The paper presents an approach to molecular energy minimization using Constraint Logic Programming (CLP) as a preprocessor to a molecular mechanics minimization program such as CHARMM. The use of CLP enables the definition of simple constraints that sufficiently describe relations in a molecule, thus limiting the search space of the globally optimal solution. The approach was used on the problem of minimizing the energy of the alanine dipeptide and N-methylalanylacetamide. An approximate 3-D structure produced by a CLP system was used as an initial structure for the CHARMM program that considers all relations in such a structure and performs energy optimization. With this initial structure, computed in about 1 min of CPU time, the optimal solution (global minimum) was found in only a few seconds, while calculating the same solution with CHARMM alone took 15 h. All calculations were performed on HP/735.

Some Challenges for Constraint Programming

We propose a number of challenges for future constraint programming systems, including improvements in implementation technology (using global analysis based optimization and parallelism), debugging facilities, and the extension of the application domain to distributed, global programming. We also briefly discuss how we are exploring techniques to meet these challenges in the context of the development of the CIAO constraint logic programming system.