This paper presents Newton, a branch & prune algorithm to find all isolated solutions of a system of polynomial constraints. Newton can be characterized as a global search method which uses intervals for numerical correctness and for pruning the search space early. The pruning in Newton consists in enforcing at each node of the search tree a unique local consistency condition, called box-consistency, which approximates the notion of arc-consistency well-known in artificial intelligence. Box-consistency is parametrized by an interval extension of the constraint and can be instantiated to produce the Hansen-Segupta's narrowing operator (used in interval methods) as well as new operators which are more effective when the computation is far from a solution. Newton has been evaluated on a variety of benchmarks from kinematics, chemistry, combustion, economics, and mechanics. On these benchmarks, it outperforms the interval methods we are aware of and compares well with state-of-the-art continuation methods. Limitations of Newton (e.g., a sensitivity to the size of the initial intervals on some problems) are also discussed. Of particular interest is the mathematical and programming simplicity of the method.

We start with a mathematical definition of a real interval as a closed, connected set of reals. Interval arithmetic operations (addition, subtraction, multiplication and division) are likewise defined mathematically and we provide algorithms for computing these operations assuming exact real arithmetic. Next, we define interval arithmetic operations on intervals with IEEE 754 floating point endpoints to be sound and optimal approximations of the real interval operations and we show that the IEEE standard’s specification of operations involving the signed infinities, signed zeros, and the exact/inexact flag are such as to make a correct and optimal implementation more efficient. From the resulting theorems we derive data that are sufficiently detailed to convert directly to a program for efficiently implementing the interval operations. Finally we extend these results to the case of general intervals, which are defined as connected sets of reals that are not necessarily closed. 1

We discuss floating-point filters as a means of restricting the precision needed for arithmetic operations while still computing the exact result. We show that interval techniques can be used to speed up the exact evaluation of geometric predicates and describe an efficient implementation of interval arithmetic that is strongly influenced by the rounding modes of the widely used IEEE 754 standard. Using this approach we engineer an efficient floating-point filter for the computation of the sign of a determinant that works for arbitrary dimensions. We validate our approach experimentally, comparing it with other static, dynamic and semi-static filters. 1

We discuss interval techniques for speeding up the exact evaluation of geometric predicates and describe a C++ implementation of interval arithmetic that is strongly influenced by the rounding modes of the widely used IEEE 754 standard. Using this approach we engineer an efficient floating point filter for the computation of geometric predicates. We validate our approach experimentally, comparing it with other static, dynamic and semi-static filters.

CLIP is an implementation of CLP(Intervals) which has been designed to be verifiably correct in the sense that the answers it returns are mathematically correct solutions to the underlying arithmetic constraints. This fundamental design criteria affects many aspects of the implementation from the input and output of decimal constants to the design of the interval arithmetic libraries and the constraint solving algorithms. In particular, to enhance verifiability, CLIP employs the simplest model of constraint solving in which constraints are decomposed into sets of primitive constraints which are then solved using a library of primitive constraint contractors. This approach results in a simple constraint solver whose correctness is relatively straightforward to verify, but the solver is only able to solve relatively simple constraints. In this paper, we present the syntax, semantics, and implementation of CLIP, and we show how to use metalevel techniques to enhance the power of the CLIP constraint solver while preserving the simple structure of the system. In particular, we demonstrate that several of the box-narrowing algorithms from the Newton and Numerica systems can be easily implemented in CLIP. The principal advantages of this approach are (1) the resulting solvers are relatively easy to prove correct, (2) new solvers can be rapidly prototyped since the code is more concise and declarative than for imperative languages, and (3) contractors can be implemented directly from mathematical formulae without having to first prove results about interval arithmetic operators. Finally, the source code for the system is publicly available, which is a clear prerequisite for public, independent verifiability.

The paper presents a new verified optimization method for the problem of finding the densest packing of non-overlapping equal circles within a square. In order to provide reliable numerical results, the developed algorithm is based on interval analysis. As one of the most efficient parts of the algorithm, an interval-based version of a previous elimination procedure is introduced. This method represents the remaining areas still of interest as polygons fully calculated in a reliable way. The most promising strategy of finding optimal circle packing configurations is currently the partitioning of the original problem into subproblems. Still as a result of the highly increasing number of subproblems, earlier computer-aided methods were not able to solve problem instances where the number of circles was greater than 27. The present paper provides a carefully developed technique resolving this difficulty by eliminating large groups of subproblems together. As a demonstration of the capabilities of the new algorithm the problems of packing 28, 29, and 30 circles were solved within very tight tolerance values. Our verified procedure decreased the uncertainty in the location of the optimal packings by more than 700 orders of magnitude in all cases.

CLIP is an implementation of CLP(Intervals) built on top of Prolog. It has been developed using the simplest model of constraint solving in which constraints are decomposed into sets of primitive constraints and a simple constraint queue is used to repeatedly apply primitive constraint contractions until some termination condition applies (e.g. no significant change occurs, or a preset limit on the number of contractions is reached). The simple semantics and implementation make it relatively straightforward to prove that the system is sound. In this paper we show how to implement more complex constraint solvers in CLIP. In particular, we demonstrate that several of the box-narrowing algorithms from the Newton and Numerica systems can be easily implemented in CLIP. The principal advantages of this approach are (1) the resulting solvers are relatively easy to prove correct, (2) new solvers can be rapidly prototyped since the code is more concise and declarative than for imperative languages, and (3) contractors can be implemented directly from mathematical formulae without having to first prove results about interval arithmetic operators.

This paper is an introduction to Newton, a constraint programming language over nonlinear real constraints. Newton originates from an eort to reconcile the declarative nature of constraint logic programming (CLP) languages over intervals with advanced interval techniques developed in numerical analysis, such as the interval Newton method. Its key conceptual idea is to introduce the notion of box-consistency, which approximates arc-consistency, a notion well-known in articial intelligence. Box-consistency achieves an eective pruning at a reasonable computation cost and generalizes some traditional interval operators. Newton has been applied to numerous applications in science and engineering, including nonlinear equation-solving, unconstrained optimization, and constrained optimization. It is competitive with continuation methods on their equation-solving benchmarks and outperforms the interval-based methods we are aware of on optimization problems. Key words: Constraint Programming, Nonlinear Programming, Interval Reasoning 1 Introduction Many applications in science and engineering (e.g., chemistry, robotics, economics, mechanics) require nding all isolated solutions to a system of nonlinear real constraints or nding the minimum value of a nonlinear function subject to nonlinear constraints. These problems are dicult due to their inherent computational complexity (i.e., they are NP-hard) and due to the numerical issues involved to guarantee correctness (i.e., nding all solutions or the global optimum) and to ensure termination. Preprint submitted to Elsevier Preprint 11 June 2001 Newton is a constraint programming language designed to support this class of applications. It originates from an attempt to reconcile the declarative nature of CLP(Intervals) languag...

Interval analysis is a powerful tool which allows to design branch-and-bound algorithms able to solve many global optimization problems. In this paper we present new adaptive multisection rules which enable the algorithm to choose the proper multisection type depending on simple heuristic decision rules. Moreover, for the selection of the next box to be subdivided, we investigate new criteria. Both the adaptive multisection and the subinterval selection rules seem to be specially suitable for being used in inequality constrained global optimization problems. The usefulness of these new techniques is shown by computational studies.

The paper deals with the problem class of finding the densest packings of non-overlapping equal circles within a unit square. We introduce a new interval branch-and-bound algorithm designed specifically for this optimization problem. After a brief description of the applied algorithmic tools, the capabilities of the algorithm are shown by solving the previously unsolved problem of packing 28 circles. The result confirms the optimality of an earlier found approximate solution and shows that it is unique in a structural sense. Moreover, the algorithm corrects the earlier reported imprecise optimum value.