Symbolic model checking and constraint logic programming: A cross-fertilization

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 incorporation of global program analysis into recent compilers for Constraint Logic Programming (CLP) languages has greatly improved the efficiency of compiled programs. We present a global analyser based on abstract interpretation. Unlike traditional optimizers, whose designs tend to be ad hoc, the analyser has been designed with flexibility in mind. The analyser is incremental, allowing substantial program transformations by a compiler without requiring redundant re-computation of analysis data. The analyser is also generic in that it can perform a large number of different program analyses. Furthermore, the analyser has an object-oriented design, enabling it to be adapted to different applications easily and allowing it to be used with various CLP languages with simple modifications. As an example of this generality, we sketch the use of the analyser in two different applications involving two distinct CLP languages: an optimizing compiler for CLP(R) programs and an application for detecting occur-check problems in Prolog programs. © 1998 John Wiley & Sons Ltd.

In recent years, several constraintdbased temporal reasoning frameworks have been proposed. They consider temporal points or intervals as domain elements linked by temporal constraints. Temporal reasoning in these systems is based on constraint propagation. In this paper, we argue that a language based on constraint propagation can be a suitable tool for expressing and reasoning about temporal problems. We concentrate on Constraint Logic Programming (CLP) which is a powerful programming paradigm combining the advantages of Logic Programming and the efficiency of constraint solving. However, CLP presents some limitations in dealing with temporal reasoning. First, it uses an “arc consistency” propagation algorithm which is embedded in the inference engine, cannot be changed by the user, and is too weak in many temporal frameworks. Second, CLP is not able to deal with qualitative temporal constraints. We present a general meta CLP architecture which maintains the advantages of CLP, but overcomes these two main limitations. Each architectural level is a finite domain constraint solver (CLP(FD)) that reasons about constraints of the underlying level. Based on this conceptual architecture, we extend the CLP(FD) language and we specialize the extension proposed on Vilain and Kautz’s Point Algebra, on Allen’s Interval Algebra and on the STP framework by Dechter, Meiri and Pearl. In particular, we show that we can cope effectively with disjunctive constraints even in an intervaldbased framework.

We propose a model checking scheme for a semantically complete fragment of CTL by combining techniques from constraint logic programming, a restricted form of constructive negation and tabled resolution. Our approach is symbolic in that it encodes and manipulates sets of states using constraints; it supports local model checking using goal-directed computation enhanced by tabulation. The framework is parameterized by the constraint domain and supports any finite constraint domain closed under disjunction, projection and complementation. We show how to encode our fragment of CTL in constraint logic programming; we outline an abstract execution model for the resulting type of programs and provide a preliminary evaluation of the approach.

CAL: A theoretical background of constraint logic programming and its applications

A general constraint-based formulation for the analysis and partial synthesis of two-dimensional truss structures is presented. This formulation is general in that it handles statically determinate and statically indeterminate trusses with pin and roller supports, and concentrated joint loads. The formulation is constraint-based in that the physical behavior of truss components is declaratively represented using constraints.The analysis and partial synthesis of a truss structure manifest themselves in proving the satisfiability of the constraints associated with the structural components. An artificial intelligence approach called constraint logic programming is used for representing and satisfying constraints. A constraint logic programming language, called CLP(R), is used for implementing the formulation. The implemented program consists of sixteen rules. These rules are used for both the analysis and partial synthesis of truss structures. Several truss analysis and synthesis examples using the formulation are presented.

In this paper, we show a validity of a new programming paradigm called constraint logic programming by constructing a robot structure design support system. The design process of a robot structure is divided into a fundamental structure design and a internal structure design. A fundamental structure design is a process that determines a framework of the robot such as a degree of freedom, a number of joint, etc. We mainly support a fundamental structure design. This design system is constructed by constraint logic programming language. The Buchberger algorithm is used to calculate the nonlinear equation in this language. Our design system generates an analysis program independent of robot structure easily. The result of analysis is also gotten in the form of expression. The constraint can be appended incrementally. By constructing such a system, we can achieve remarkable reduction of designer's work in design process.

Constraint logic programming (CLP) has demonstrated its ability to handle difficult problems coming from operation research. We think that this approach is relevant to perform program analyses too. However, program analysis often requires solvers for second order constraints, i.e. mainly fixpoint equations, that are not available in CLP languages. In this paper, we present, the language Toupie that is designed to solve such constraints. Toupie uses an extension of Bryant's binary decision diagrams to encode relations which makes it possible to handle relations with huge numbers of elements.

The concept of Expert Decision Support Systems is based on the integration of Decision Support Systems and Expert Systems, providing the decision maker with features from both types of systems (e.g. simulation, explanations, control of reasoning). Constraint logic programming languages, such as CLP(R) or CHIP, achieve this integration by merging logic programming, a paradigm of Artificial Intelligence and Expert Systems, with constraint solving techniques similar to those used in Operations Research and Decision Support Systems. Their embedded constraint solver extends the expressive power of logic programming languages, most notably on the domain of numerical expressions. The paper illustrates how constraint logic programming may be used in EDSS development by presenting a small classroom scheduling problem developed with CLP(R), and compares this approach to more traditional Operations Research techniques.

There are two main paradigms for model checking: symbolic model checking, as is performed by the tool RuleBase, and explicit state model checking, as is performed by Spin. It is often accepted that the former is better for verifying hardware systems, while the latter has advantages for verifying software. We examine this piece of common wisdom in light of experience in verifying the software of a disk controller using both symbolic and explicit state model checking.

We have described the constraint logic programming language CS-Prolog. CS-Prolog is written in PROLOG about 1,500 lines. This is a very small as oppose to similar system CLP which is written in C about 12,000 lines, but less efficient than CLP. However, CS-Prolog solves equations and inequations in reasonable time and this paper shows the simple approach to constraint logic programming using PROLOG and this technique is very useful for constraint logic programming language system on top of PROLOG machine.

This paper presents new techniques in two different areas. Firstly, it proposes a solution to the problem of testing embedded processors. Towards this end, it discusses the automatic generation of executable test programs from a specification of test patterns for processor components. Secondly, the paper shows how constraint logic programming (CLP) improves the software production process for design automation tools. The advantages of CLP languages include: built-in symbolic variables and the built-in support for constraints over finite domains such as integers and Booleans.

In [1] we presented the language TOY(FD) that integrates the best features of existing functional and logic languages, as well as finite domain (FD) constraint solving. We believe that TOY(FD) is more flexible and expressive than the existing approaches of constraint logic programming on finite domain (CLP(FD)) as it integrates FD constraint solving, lazy evaluation, higher order applications of functions and constraints, polymorphism, type checking, composition of functions (and, in particular, constraints), combination of relational and functional notation, and a number of other characteristics. These features allow to write more concise programs, therefore increasing the expressivity level.

Handbook of Constraint Programming

Declarative and Mathematical Programming approaches to Decision Support Systems for food recycling