CLPGUI: a generic graphical user interface for constraint logic programming over finite domains

CLPGUI is a graphical user interface for visualizing and interacting with constraint logic programs over finite domains. In CLPGUI, the user can control the execution of a CLP program through several views of constraints, of finite domain variables and of the search tree. CLPGUI is intended to be used both for teaching purposes, and for debugging and improving complex programs of realworld scale. It is based on a client-server architecture for connecting the CLP process to a Java-based GUI process. Communication by message passing provides an open architecture which facilitates the reuse of graphical components and the porting to different constraint programming systems. Arbitrary constraints and goals can be posted incrementally from the GUI. We propose several dynamic 2D and 3D visualizations of the search tree and of the evolution of finite domain variables. We argue that the 3D representation of search trees proposed in this paper provides the most appropriate visualization of large search trees. We describe the current implementation of the annotations and of the interactive execution model in GNU-Prolog, and report some evaluation results.Comment: 16 pages; Alexandre Tessier, editor; WLPE 2002, http://xxx.lanl.gov/abs/cs.SE/020705

Associative-commutative unification

Résumé disponble dans les fichiers attaché

Le système KB : présentation et bibliographie,mise en oeuvre

Résumé disponble dans les fichiers attaché

Experiments in reactive constraint logic programming1This paper is the complete version of a previous paper published in [14].1

AbstractIn this paper we study a reactive extension of constraint logic programming (CLP). Our primary concerns are search problems in a dynamic environment, where interactions with the user (e.g. in interactive multi-criteria optimization problems) or interactions with the physical world (e.g. in time evolving problems) can be modeled and solved efficiently. Our approach is based on a complete set of query manipulation commands for both the addition and the deletion of constraints and atoms in the query. We define a fully incremental model of execution which, contrary to other proposals, retains as much information as possible from the last derivation preceding a query manipulation command. The completeness of the execution model is proved in a simple framework of transformations for CSLD derivations, and of constraint propagation seen as chaotic iteration of closure operators. A prototype implementation of this execution model is described and evaluated on two applications

Closures are Needed for Closed Module Systems

In a classical paper of D.H.D. Warren, the higher-order extensions of Prolog were questioned as they do not really provide more expressive power than meta-programming predicates. Without disputing this argumentation in the context of a logic programming system without modules, we show that the situation is different in a closed module system. By closed we mean the property that the module system is able to prevent any call to the private predicates of a module from the other modules, in particular through meta-programming predicates. We show that this property necessitates to distinguish the execution of a term (meta-programming predicate call) from the execution of a closure (higher order). We propose a module system for Constraint Logic Programming with a notion of closures inspired from Linear Concurrent Constraint programming. This module system is quite simple and pretty independent of a precise language (it is currently implemented for GNU-Prolog). Although this system can be seen as a simple layer of syntactic sugar, it does provide a discipline for naming predicates and hiding code, making possible the development of libraries and facilitating the safe re-use of existing code. Furthermore we provide the module system with logical and operational semantics. This formal setting is used in the paper to compare our approach to the other module systems proposed for Prolog, which generally do not ensure full code protection

Reifying Global Constraints

Global constraints were introduced two decades ago as a means to model some core aspects of combinatorial problems with one single constraint for which an efficient domain filtering algorithm can be provided, possibly using a complete change of representation. However, global constraints are just constraint schemas on which one would like to apply usual constraint operations such as reification, i.e. checking entailment, disentailment and negating the constraint. This is currently not the case in state-of-the-art tools and was not considered in the global constraint catalog until recently. In this paper, we propose a general framework for reifying global constraints and apply it to some important constraints of the catalog, such as the cumulative constraint for instance. We show that several global constraints that were believed to be hard to negate can in fact be efficiently negated, and that entailment and disentailment can be efficiently tested. We also point out some new global constraints that are worth studying from this point of view and provide some performance figures obtained with an implementation in Choco.Les contraintes globales ont été introduites il y a une vingtaine d'années afin de modéliser certains aspects centraux des problèmes combinatoires avec une seule contrainte dotée d'un algorithme de filtrage efficace, au besoin via un changement complet de représentation. Cependant, les contraintes globales ne sont que des schémas de contraintes sur lesquelles on souhaiterait pouvoir appliquer les opérations usuelles des contraintes comme la réification, ce qui suppose de tester l'implication et de nier la contrainte. Ceci n'est pas le cas dans les outils de l'état de l'art et n'a été considéré que récemment dans le catalogue des contraintes globales. Dans cet article nous proposons un cadre général pour réifier les contraintes globales, et l'appliquons aux principales contraintes du catalogue, comme par exemple la contrainte cumulative. Nous montrons que plusieurs contraintes réputées difficiles à nier peuvent l'être efficacement, et que l'implication peuvent être testée efficacement. Nous montrons aussi que de nouvelles contraintes globales vaudraient la peine d'être étudiées de ce point de vue, et fournissons une évaluation préliminaire des performances obtenues avec une implémentation en Choco

Un système de types pour CHR

http://www710.univ-lyon1.fr/~csolnonNous proposons un système de types général pour le langage des Constraint Handling Rules (CHRs), un langage de règles de réécriture destiné à l'implantation de solveurs de contraintes. Les CHRs étant en fait une extension de haut niveau d'un langage hôte, tel que Prolog ou Java, le système de types est ainsi paramétré par le système de types du langage hôte. Nous montrons la cohérence du système de types pour les CHRs par rapport à leur sémantique opérationnelle. Nous étudions également le cas particulier où le langage hôte est un langage de programmation en logique avec contraintes, typé avec le système de types prescriptif que nous avons développé dans nos précédents travaux. En particulier nous montrons que le système résultant est cohérent avec le modèle d'exécution étendu CLP+CHR. Ce système est implanté à travers une extension du logiciel TCLP de typage des programmes logiques avec contraintes. Nous exposons nos résultats expérimentaux sur la vérification des types de solveurs et programmes utilisant les CHRs, dont le logiciel TCLP lui-même

Des règles aux contraintes avec le langage de modélisation Rules2CP

National audienceDans cet article, nous montrons que le paradigme de représentation des connaissances règles métier, large- ment utilisé dans l'industrie, peut être développé comme un langage de modélisation pour la programmation par contraintes. Nous présentons un langage de modélisation général à base de règles, nommé Rules2CP, et décrivons sa compilation vers des programmes de contraintes sur les domaines finis avec contraintes réifiées et contraintes globales, basée sur la réécriture de termes et l'évaluation partielle. Nous prouvons la conuence de ces transformations et fournissons une borne de complexité sur la taille des programmes de contraintes génerés. L'expressivité de Rules2CP est illustrée avec une librairie complète de modélisation des problèmes de placement, appellée PKML, qui, en plus des problèmes purs Bin Packing et Bin Design, gère des règles de bon sens portant sur des contraintes de poids, de gravité et d'équilibre, ainsi que des règles métiers spécifiques compilées efficacement en des programmes de contraintes