Towards Structuring the Constraint Store (original) (raw)

An Explanation-Based Constraint Debugger

Lecture Notes in Computer Science, 2011

Constraint programming systems are software systems that support the modeling and solving of problems using constraint programming. Such systems include constraint programming libraries and runtime systems for constraint programming languages. After two very successful workshops in 2000 (Singapore) and 2002 (Ithaca), this third iteration will again provide a forum for research in implementation of constraint programming systems. The workshop encourages submissions and participation from all members of the CP community and all people interested in the implementation of constraint programming systems. It provides a place at CP where useful results, practical tricks and preliminary work can be presented, which by itself may not be sufficent for a submission to the full conference but is still of interest to other CP practitioners. Third workshop on Techniques foR Implementing Constraint programming Systems (TRICS),

A visualization tool for constraint program debugging

14th IEEE International Conference on Automated Software Engineering, 1999

Constraint programming is an emerging technology that offers an original approach allowing for efficient and flexible solving of complex problems. Its main advantage relies in its ability to compute with partial information expressed in terms of constraints. These constraints are monotonically accumulated during the program execution in order to restrict the problem search space. In this paper we address one of the cornerstones of this technology, namely the current lack of debugging facilities. In particular, visualization and understanding of the underlying constraint system during program executions is very important. We propose to structure this huge, flat and intricate part of the execution data in order to provide access to high level examination of its evolution. More precisely, we present a means to hierarchically organize sets of constraints in order to divide them into manageable parts while preserving computation correctness. Soundness of our method is shown, an algorithm supporting it is given, and an implemented prototype exhibiting its effectiveness is described.

A tracer driver for versatile dynamic analyses of constraint logic programs

2005

Programs with constraints are hard to debug. In this paper, we describe a general architecture to help develop new debugging tools for constraint programming. The possible tools are fed by a single general-purpose tracer. A tracer-driver is used to adapt the actual content of the trace, according to the needs of the tool. This enables the tools and the tracer to communicate in a clientserver scheme. Each tool describes its needs of execution data thanks to event patterns. The tracer driver scrutinizes the execution according to these event patterns and sends only the data that are relevant to the connected tools. Experimental measures show that this approach leads to good performance in the context of constraint logic programming, where a large variety of tools exists and the trace is potentially huge.

CLP projection for constraint handling rules

Proceedings of the 13th international ACM SIGPLAN symposium on Principles and practices of declarative programming - PPDP '11, 2011

This paper introduces and studies the notion of CLP projection for Constraint Handling Rules (CHR). The CLP projection consists of a naive translation of CHR programs into Constraint Logic Programs (CLP). We show that the CLP projection provides a safe operational and declarative approximation for CHR programs. We demónstrate moreover that a confluent CHR program has a least model, which is precisely equal to the least model of its CLP projection (closing henee a ten year-old conjecture by Abdenader et al.). Finally, we illustrate how the notion of CLP projection can be used in practice to apply CLP analyzers to CHR. In particular, we show results from applying AProVE to prove termination, and CiaoPP to infer both complexity upper bounds and types for CHR programs.

Global analysis of constraint logic programs

ACM Transactions on Programming Languages and Systems, 1996

This paper presents and illustrates a practical approach to the dataflow analysis of constraint logic programming languages using abstract interpretation. It is first argued that, from the framework point of view, it suffices to propose relatively simple extensions of traditional analysis methods which have already been proved useful and practical and for which efficient fixpoint algorithms exist. This is shown by proposing a simple extension of Bruynooghe's traditional framework which allows it to analyze constraint logic programs. Then, and using this generalized framework, two abstract domains and their required abstract functions are presented: the first abstract domain approximates definiteness information and the second one freeness. Finally, an approach for combining those domains is proposed. The two domains and their combination have been implemented and used in the analysis of CLP() and Prolog-III applications. Results from this implementation showing its performance and accuracy are also presented.

Demonstration: Debugging constraint problems with portable tools

Lpe, 2003

This volume contains papers presented at WLPE 2003, the 13th International Workshop on Logic Programming Environments. The aim of WLPE is to provide an informal meeting for researchers working on tools for development and analysis of logic programming. This year, the emphasis is on the presentation, pragmatics and experiences of such tools.

A practical approach to the global analysis of CLP programs

1993

This paper presents and illustrates with an example a practical approach to the data ow analysis of programs written in constraint logic programming (CLP) languages using abstract interpretation. It is rst argued that, from the framework point of view, it su ces to propose relatively simple extensions of traditional analysis methods which have already been proved useful and practical and for which e cient xpoint algorithms have been developed. This is shown by proposing a simple but quite general extension of Bruynooghe's traditional framework to the analysis of CLP programs. In this extension constraints are viewed not as \suspended goals" but rather as new information in the store, following the traditional view of CLP. Using this approach, and as an example of its use, a complete, constraint system independent, abstract analysis is presented for approximating de niteness information. The analysis is in fact of quite general applicability. It has been implemented and used in the analysis of CLP(R) and Prolog-III applications. Results from the implementation of this analysis are also presented.

Fault Localization in Constraint Programs

2010

Constraint programs such as those written in highlevel modeling languages (e.g., OPL [15], ZINC [14], or COMET [16]) must be thoroughly verified before being used in applications. Detecting and localizing faults is therefore of great importance to lower the cost of the development of these constraint programs. In a previous work, we introduced a testing framework called CPTEST enabling automated test case generation for detecting non-conformities . In this paper, we enhance this framework to introduce automatic fault localization in constraint programs. Our approach is based on constraint relaxation to identify the constraint that is responsible of a given fault. CPTEST is henceforth able to automatically localize faults in optimized OPL programs. We provide empirical evidence of the effectiveness of this approach on classical benchmark problems, namely Golomb rulers, n-queens, social golfer and car sequencing.

Compiling Constraints in clp(FD

Journal of Logic Programming, 1996

We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints. We detail its implementation and present an abstract instruction set for the constraint solver that can be smoothly integrated into the WAM architecture. It is based on the use of a single primitive constraint X in r that embeds the core propagation mechanism. Complex user constraints such as linear equations or inequations are compiled into X in r expressions that 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 allows three main general optimizations that encompass many previous particular optimizations of "black-box" finite domain solvers. Implementation results show that this approach combines both simplicity and efficiency. Our clp(FD) system is about four times faster than CHIP on average, with peak speedup reaching eight. We also show that, following the "glass-box" approach, clp(FD) can be naturally enhanced with various new constraints such as constructive disjunction, boolean constraints, non-linear constraints and symbolic constraints. ¡ Address correspondence toPhilippe Codognet and Daniel Diaz, INRIA-Rocquencourt,