Constraint Solving

Geometric computing is a rapidly evolving interdisciplinary field involving computer science, engineering and mathematics. It has relationships to many other areas within computer science such as computational geometry, computer-aided design, computer graphics, computer ...

Constraint satisfaction is becoming the paradigm of choice for solving many real-world problems. To date, most approaches to constraint satisfaction have focused on solving a problem using some form of backtrack search. Furthermore, the typical view is that a constraint satisfaction problem will be solved only once. However, in many real-world contexts, problems are solved repeatedly over time. Also such problems often exhibit some structure. This motivates the application of some form of learning to improve the performance of search from previously discovered solutions. In this paper we present an approach that uses knowledge about known solutions to a problem to improve search. The approach we present is based on a combination of decision tree learning and constraint satisfaction. We demonstrate that significant improvements, almost an order-of-magnitude, in search effort can be achieved using this hybrid approach over traditional search. We also show that the space complexity using this approach is almost negligible. This work is of interest in domains such as product configuration, and interactive constraint solving in general where the system takes the initiative by asking questions.

This paper presents a novel approach for automated test data generation of imperative programs containing integer, boolean and/or float variables. Our approach is based on consistency techniques integrating integer and float vari-ables. We handle statement, branch and path coverage ...

We present a computational origami system called Eos. Eos simu- lates what a human origamist would do with a piece of origami paper and by hands. Moreover, it assists us in reasoning about geometri- cal properties of an origami. We describe the basic capabilities of the system, which include symbolic and numeric constraints solving, automated theorem proving, visualization of an

We describe Huzita's origami axioms from the logical and algebraic points of view. Observing that Huzita's axioms are statements about the existence of certain origami constructions, we can generate basic origami constructions from those axioms. Origami construction is performed by repeated application of Huzita's axioms. We give the logical specification of Huzita's axioms as constraints among geometric objects of origami in the language of the firstorder predicate logic. The logical specification is then translated into logical combinations of algebraic forms, i.e. polynomial equalities, disequalities and inequalities, and further into polynomial ideals (if inequalities are not involved). By constraint solving, we obtain solutions that satisfy the logical specification of the origami construction problem. The solutions include fold lines along which origami paper has to be folded. The obtained solutions both in numeric and symbolic forms make origami computationally tractable for further treatments, such as visualization and automated theorem proving of the correctness of the origami construction.

Many real-world problems can be represented and solved as constraint satisfaction problems, but their solution requires the development of effective, efficient constraint solvers. A constraint solver’s success depends greatly upon the heuristics chosen to guide search. Some heuristics perform well on one class of problems, but are less successful on others. The solver described here learns a weighted combination of heuristic recommendations customized for a given class of problems. A pre-existing algorithm has weights learned for heuristics from the number of nodes explored during learning. We present here a new algorithm which learns weights for heuristics that consider the nuances of relative support for actions. The resultant performance is statistically significantly better than that of traditional individual heuristics.

We present cKanren, a framework for constraint logic programming (CLP) in Scheme. cKanren subsumes miniKanren, a logic programming language embedded in Scheme. cKanren allows programmers to easily use, define, and combine different kinds of constraints. We provide two example constraint systems: one over finite domains and one over trees.

. In the last years, UNIF has always been collocated with some other conferences, like the Int. Conf. on Rewriting Techniques and Applications, RTA, and the Int. Conf. on Automated Deduction, CADE. Unification is concerned with the problem of identifying given terms, either syntactically or modulo a special equational theory. It is a basic ingredient of many applications in rewriting, automated deduction and functional and logic programming. The topic is understood in a rather broad sense at these workshops, and includes: The aim of UNIF'06, as that of the previous meetings, was to bring together people interested in unification, present recent (even unfinished) work, and discuss new ideas and trends in unification and related fields in a relaxed atmosphere. The Program Committee selected for this edition eight regular papers and one extended abstract.

Analog and mixed signal (AMS) designs are an important part of embedded systems that link digital designs to the analog world. Due to challenges associated with its verification process, AMS designs require a considerable portion of the total design cycle time. In contrast to digital designs, the verification of AMS systems is a challenging task that requires lots of expertise and deep understanding of their behavior. Researchers started lately studying the applicability of formal methods for the verification of AMS systems as a way to tackle the limitations of conventional verification methods like simulation. This paper surveys research activities in the formal verification of AMS designs as well as compares the different proposed approaches.

Analog and mixed signal (AMS) designs are an important part of embedded systems that link digital designs to the analog world. Due to challenges associated with its verification process, AMS designs require a considerable portion of the total design cycle time. In contrast to digital designs, the verification of AMS systems is a challenging task that requires lots of expertise and deep understanding of their behavior. Researchers started lately studying the applicability of formal methods for the verification of AMS systems as a way to tackle the limitations of conventional verification methods like simulation. This paper surveys research activities in the formal verification of AMS designs as well as compares the different proposed approaches.

We present cKanren, a framework for constraint logic programming (CLP) in Scheme. cKanren subsumes miniKanren, a logic programming language embedded in Scheme. cKanren allows programmers to easily use, define, and combine different kinds of constraints. We provide two example constraint systems: one over finite domains and one over trees. The cKanren framework is designed to encourage an especially pure style of logic programming in which goals can be reordered arbitrarily without affecting a program’s semantics (with an important decidability-related caveat). We develop the complete implementation of the cKanren framework, written in RRS Scheme extended with SRFI 39 parameters. We present the implementation of cKanren’s finite domain and disequality constraint solvers, and we provide introductions to miniKanren, cKanren, and numerous example programs, including the Send More Money cryptarithmetic puzzle and N-Queens.

Origami (paper folding) has a long tradition in Japan's culture and education. We are developing a computational origami system, based on symbolic computation system Mathematica, for performing and reasoning about origami on the computer. This system is based on the implementation of the six fundamental origami folding steps (origami axioms) formulated by Huzita. In this paper, we show how our system performs origami folds by constraint solving, visualizes each step of origami construction, and automatically proves general theorems on the result of origami construction using algebraic methods. We illustrate this by a simple example of trisecting an angle by origami. The trisection of an angle is known to be impossible by means of a ruler and a compass. The entire process of computational origami shows nontrivial combination of symbolic constraint solving, theorem proving and graphical processing.

Malic acid production, degradation, and storage during fruit development have been modelled. The model assumes that malic acid content is determined essentially by the conditions of its storage in the mesocarp cells, and provides a simplified representation of the mechanisms involved in the accumulation of malate in the vacuole and their regulation by thermodynamic constraints. Solving the corresponding system of equations made it possible to predict the malic acid content of the fruit as a function of organic acids, potassium concentration, and temperature. The model was applied to peach fruit, and parameters were estimated from the data of fruit development monitored over 2 years. The predictions were in good agreement with experimental data. Simulations were performed to analyse the behaviour of the model in response to variations in composition and temperature.

We wish to thank all the authors who submitted papers and demonstrations to this workshop, the members of the programme committee, the invited speaker, and the CP-2005 Tutorial and Workshop Chairs, Alan Frisch and Ian Miguel. We would like to especially acknowledge the financial sponsorship received from

Multi-set constraint rewriting allows for a highly parallel computational model and has been used in a multitude of application domains such as constraint solving, agent specification etc. Rewriting steps can be applied simultaneously as long as they do not interfere with each other. We wish that that the underlying constraint rewrite implementation executes rewrite steps in parallel on increasingly popular becoming multi-core architectures. We design and implement efficient algorithms which allow for the parallel execution of multi-set constraint rewrite rules. Our experiments show that we obtain some significant speed-ups on multi-core architectures.

Genetic algorithm (GA) optimisation applied to water systems with multiple contaminants and several contaminated sources is presented. This approach generates the overall optimal water network topology with respect to the minimum supply water usage, complying, in the same time, with all restrictions. An optimal water network could be viewed as an oriented graph, starting from unit operations which must not have contaminants at entrance (inlet contaminants-free unit operations), every next unit operation i receiving streams from the previous operations j only (j Z 1, 2,.,iÿ1), and sending streams to the next operations j (j Z i C 1, i C 2,.,N). The mathematical model describing the unit i is based upon total and contaminant species' mass balances, together with the input and output constraints. Solving this optimisation problem is not trivial, since the unknowns' number, determines the number of equations. The GA optimisation uses each network's internal flow as a gene, assembling the topology into a chromosome. The restrictions, in terms of minimum and maximum allowable flows for each gene, are dealt with naturally, during the population generation, simply rejecting those genes outside their feasible domain. The individuals are interbred according to their frequency of selection, using the one-point crossover method, and then mutations are applied to randomly selected individuals. The objective function is the total supply water consumption, which should be minimised.

This thesis describes a methodology for automating routine design problems. The research applied for developing this methodology consisted in three steps. Firstly, different types of complexity in routine design were investigated. Secondly, methods were developed to manage each type of complexity. Thirdly, the obtained methods were integrated into one methodology for routine design automation. The resulting methodology consists of the following five steps: 1. Determine a formal model of the components, parameters and relations of the design problem to automate. 2. Decompose the design problem into different levels of detail by analyzing its functional and physical structure. 3. Translate the obtained problem model into a TARD representation. TARD representations were developed in this research as a means of describing how components, relations and parameters can be used for designing an artifact. 4. Determine the Topology System of Equations (ToSE) of the model. ToSE was developed w...

In order to facilitate automated reasoning about large Boolean combinations of non- linear arithmetic constraints involving transcendental functions, we provide a tight inte- gration of recent SAT solving techniques with interval-based arithmetic constraint solv- ing. Our approach deviates substantially from lazy theorem proving approaches in that it directly controls arithmetic constraint propagation from the SAT solver rather than del- egating

We describe constraint solving using a rule-based ap- proach. The distinction made between deduction rules and strategies by computational systems allows us to improve our understanding of the existing algorithms for solving Bi - nary CSP once they are expressed as rewriting rules coor- dinated by strategies.

Formal CAD solvers often produce many solutions for a constraint system. It is very time-consuming to examine each of them to determine which one is the closest to the user's will. In our formal approach a construction plan is produced as a mean to represent all the ...

Forward symbolic execution is a program analysis technique that allows using symbolic inputs to explore program executions. The traditional applications of this technique have focused on programs that manipulate primitive data types, such as integer or boolean. Recent extensions have shown how to handle reference types at their representation level. The extensions have favorably been backed by advances in constraint solving technology, and together they have made symbolic execution applicable, at least in theory, to a large class of programs. In practice, however, the increased potential for applications has created significant issues with scalability of symbolic execution to programs of non-trivial size-the ensuing path conditions rapidly become unfeasibly complex.

We report on the development of a two-dimensional geometric constraint solver. The solver is a major component of a new generation of CAD systems that we are developing based on a high-level geometry representation. The solver uses a graph-reduction directed algebraic approach, and achieves interactive speed. We describe the architecture of the solver and its basic capabilities. Then, we discuss in detail how to extend the scope of the solver, with special emphasis placed on the theoretical and human factors involved in nding a solution | in an exponentially large search space | so that the solution is appropriate to the application and the way of nding it is intuitive to an untrained user.

In this paper, a Constraint Logic Programming (CLP) approach is used to solve an Air Traffic Flow Management (ATFM) problem, the aircraft departure slot allocation. Moreover, our purpose is to show that CLP, combining the declarativity of logic programming with the efficiency of constraint solving, is well suited to model many combinatorial optimization problems involved in the ATFM domain. clp(FD), a Constraint Logic Programming language with Finite Domain constraints has been chosen to implement our practical application.

In this paper, we present a network conscious approach to designing distributed real-time systems. Given a task graph design of the system, the end-to-end constraints on the inputs and outputs, and the task allocation on a given distributed platform, we automatically generate task attributes (e.g., periods and deadlines) such that (i) the task set is schedulable, and (ii) the end-to-end constraints are satis®ed. The method works by ®rst transforming the end-to-end constraints into a set of intermediate constraints on task attributes, and then solving the intermediate constraints. The complexity of constraint solving is tackled by reducing the problem into more tractable parts, and then solving each subproblem using heuristics to enhance schedulability. The methodology presented in this process can be mostly automated, and provides useful feedback to a designer when it fails to ®nd a solution. We expect that the techniques presented in this paper will help reduce the laborious process of designing a real-time system, by bringing resource contention and schedulability aspects early into the design process. Ó

We address the problem of computing the exact abstraction of a program with respect to a given set of predicates, a key computation step in Counter-Example Guided Abstraction Refinement. We build on a recently proposed approach that integrates BDD-based quantification techniques with SMT-based constraint solving to compute the abstraction. We extend the previous work in three main directions. First, we propose a much tighter integration of the BDD-based and SMT-based reasoning where the two solvers strongly collaborate to guide the search. Second, we propose a technique to reduce redundancy in the search by blocking already visited models. Third, we present an algorithm exploiting a conjunctively partitioned representation of the formula to quantify. This algorithm provides a general framework where all the presented optimizations integrate in a natural way. Moreover, it allows to overcome the limitations of the original approach that used a monolithic BDD representation of the formula to quantify. We experimentally evaluate the merits of the proposed optimizations, and show how they allow to significantly improve over previous approaches.

Due to the recent advancement in procedural generation techniques, games are presenting players with ever growing cities and terrains to explore. However most sandbox-style games situated in cities, do not allow players to wander into buildings. In past research, space planning techniques have already been utilized to generate suitable layouts for both building floor plans and room layouts. We introduce

Today's computer animators have access to many systems and techniques to author high-quality motion. Unfortunately, available techniques typically produce a particular motion for a specific character. In this paper we present a constraint-based approach to adapt previously created motions to new situations and characters. We combine constraint methods that compute changes to motion to meet specified needs with motion signal processing methods that modify signals yet preserve desired properties of the original motion. The combination allows the adaptation of motions to meet new goals while retaining much of the motion's original quality.

This paper addresses constraint solving over continuous domains in the context of decision making, and discusses the trade-off between precision in the definition of the solution space and the computational effort required. In alternative to local consistency, which is usually maintained in handling continuous constraints, we discuss maintaining global hull-consistency. Experimental results show that this may be an appropriate choice, achieving acceptable precision with relatively low computational cost. The approach relies on efficient algorithms and the best results are obtained with the integration of a local search procedure within interval constraint propagation.

Types are often used to control and analyze computer programs. Intersection types give great flexibility, but have been difficult to implement. The ! operator, used to distinguish between linear and non-linear types, has good potential for better resource-usage tracking, but has not been as flexible as one might want and has been difficult to use in compositional analysis. We introduce System E, a type system with expansion variables, linear intersection types, and the ! type constructor for creating non-linear types. System E is designed for maximum flexibility in automatic type inference and for ease of automatic manipulation of type information. Expansion variables allow postponing the choice of which typing rules to use until later constraint solving gives enough information to allow making a good choice. System E removes many difficulties that expansion variables had in the earlier System I and extends expansion variables to work with ! in addition to the intersection type constructor. We present subject reduction for call-by-need evaluation and discuss program analysis in System E.

Uppaal is a tool suite for automatic verification of safety and bounded liveness properties of real-time systems modeled as networks of timed automata. It includes: a graphical interface that supports graphical and textual representations of networks of timed automata, and automatic transformation from graphical representations to textual format, a compiler that transforms a certain class of linear hybrid systems to networks of timed automata, and a model-checker which is implemented based on constraint-solving techniques. Uppaal also supports diagnostic model-checking providing diagnostic information in case verification of a particular real-time systems fails. The current version of Uppaal is available on the World Wide Web via the Uppaal home page

Analog and mixed signal (AMS) designs are an important part of embedded systems that link digital designs to the analog world. Due to challenges associated with its verification process, AMS designs require a considerable portion of the total design cycle time. In contrast to digital designs, the verification of AMS systems is a challenging task that requires lots of expertise and deep understanding of their behavior. Researchers started lately studying the applicability of formal methods for the verification of AMS systems as a way to tackle the limitations of conventional verification methods like simulation. This paper surveys research activities in the formal verification of AMS designs as well as compares the different proposed approaches.

Computational origami is the computer assisted study of mathematical and computational aspects of origami. An origami is constructed by a finite sequence of fold steps, each consisting in folding along a fold line. We base the fold methods on Huzita's axiomatization, and show how folding an origami can be formulated by a conditional rewrite system. A rewriting sequence of origami structures is viewed as an abstraction of origami construction. We also explain how the basic concepts of constraint and functional and logic programming are related to this computational construction. Our approach is not only useful for computational construction of an origami, but it leads us to automated theorem proving of the correctness of the origami construction.

We present an extension of Scala that supports constraint programming over bounded and unbounded domains. The resulting language, Kaplan, provides the benefits of constraint programming while preserving the existing features of Scala. Kaplan integrates constraint and imperative programming by using constraints as an advanced control structure; the developers use the monadic ’for’ construct to iterate over the solutions of constraints or branch on the existence of a solution. The constructs we introduce have simple semantics that can be understood as explicit enumeration of values, but are implemented more efficiently using symbolic reasoning. Kaplan programs can manipulate constraints at run-time, with the combined benefits of type-safe syntax trees and first-class functions. The language of constraints is a functional subset of Scala, supporting arbitrary recursive function definitions over algebraic data types, sets, maps, and integers. Our implementation runs on a platform combin...

This article presents EXE, an effective bug-finding tool that automatically generates inputs that crash real code. Instead of running code on manually or randomly constructed input, EXE runs it on symbolic input initially allowed to be anything. As checked code runs, EXE tracks the constraints on each symbolic (ie, input-derived) memory location. If a statement uses a symbolic value, EXE does not run it, but instead adds it as an input-constraint; all other statements run as usual. If code conditionally checks a symbolic ...

This thesis describes a methodology for automating routine design problems. The research applied for developing this methodology consisted in three steps. Firstly, different types of complexity in routine design were investigated. Secondly, methods were developed to manage each type of complexity. Thirdly, the obtained methods were integrated into one methodology for routine design automation. The resulting methodology consists of the

The KRAFT project aims to investigate how a distributed architecture can support the transformation and reuse of a particular class of knowledge, namely constraints, and to fuse this knowledge so as to gain added value, by using it for constraint solving or data retrieval.

This paper describes our efforts to provide a collaborative problem solving architecture driven by semantic-based worko w orchestration and con- straint problem solving. These technologies are based on shared ontologies that allows two systems of very different natures to communicate, perform specialised tasks and achieve common goals. We give an account of our approach for the worko w assisted collaboration

We present a novel approach to the automatic verification and falsification of LTL requirements of non-linear discrete-time hybrid systems. The verification tool uses an interval-based constraint solver for non-linear robust constraints to compute incrementally refined abstractions. Although the problem is in general undecidable, we prove termination of abstraction refinement based verification and falsification of such properties for the class of robust non-linear hybrid systems, thus significantly extending previous semi-decidability results. We argue, that safety critical control applications are robust hybrid systems. We give first results on the application of this approach to a variant of an aircraft collision avoidance protocol.