Pascal Van Hentenryck

The OPL optimization programming language

Part 1 The language: a short tour of OPL models data modelling expressions and constraints formal parameters search display. Part 2 The application areas: linear and integer programming constraint programming scheduling.

A Two-Stage Hybrid Local Search for the Vehicle Routing Problem with Time Windows

The vehicle routing problem with time windows is a hard combinatorial optimization problem that has received considerable attention in the last decades. This paper proposes a two-stage hybrid algorithm for this transportation problem. The algorithm first minimizes the number of vehicles, using simulated annealing. It then minimizes travel cost by using a large neighborhood search that may relocate a large number of customers. Experimental results demonstrate the effectiveness of the algorithm, which has improved 10 (17%) of the 56 best published solutions to the Solomon benchmarks, while matching or improving the best solutions in 46 problems (82%). More important perhaps, the algorithm is shown to be very robust. With a fixed configuration of its parameters, it returns either the best published solutions (or improvements thereof) or solutions very close in quality on all Solomon benchmarks. Very preliminary results on the extended Solomon benchmarks are also given.

Design, implementation, and evaluation of the constraint language cc (FD)

This paper describes the design, implementation, and applications of the constraint logic language cc(FD). cc(FD) is a declarative nondeterministic constraint logic language over finite domains based on the cc framework [33], an extension of the Constraint Logic Programming (CLP) scheme [21]. Its constraint solver includes (nonlinear) arithmetic constraints over natural numbers which are approximated using domain and interval consistency. The main novelty of cc (FD) is the inclusion of a number of general-purpose combinators, in particular cardinality, constructive disjunction, and blocking implication, in conjunction with new constraint operations such as constraint entailment and generalization. These combinators significantly improve the operational expressiveness, extensibility, and flexibility of CLP languages and allow issues such as the definition of nonprimitive constraints and disjunctions to be tackled at the language level. The implementation of cc (FD) (about 40,000 lines of C) includes a WAM-based engine [44], optimal are-consistency algorithms based on AC-5 [40], and incremental implementation of the combinators. Results on numerous problems, including scheduling, resource allocation, sequencing, packing, and hamiltonian paths are reported and indicate that cc(FD) comes close to procedural languages on a number of combinatorial problems. In addition, a small cc(FD) program was able to find the optimal solution and prove optimality to a famous 10/10 disjunctive scheduling problem [29], which was left open for more than 20 years and finally solved in 1986

Constraint programming

1. Integrating research findings in software reliability engineering and software measurement to assess and improve software quality and reliability over extended development phases and application domains. 2. Developing analysis techniques and tools to effectively analyze early measurement data. 3. Practical implementation of this integrated approach and adaptation of it to a wide variety of software development environments in collaboration with our industrial partners.

Solving large combinatorial problems in logic programming

Abstract Many problems in operations research and hardware design are combinatorial problems which can be seen as search problems with constraints. We present an application of CHIP ( C onstraint H andling I n P rolog) to large problems in disjunctive scheduling, graph coloring, and firmware design. chip is a constraint logic-programming language combining the declarative aspects of PROLOG with the efficiency of constraint-solving techniques. It is shown that it allows a natural expression of problems to be executed as efficiently as special-purpose programs written in procedural languages.

Experimental evaluation of a generic abstract interpretation algorithm for PROLOG

Abstract interpretation of PROLOG programs has attracted many researchers in recent years, partly because of the potential for optimization in PROLOG compilers and partly because of the declarative nature of logic programming languages that make them more amenable to optimization than procedural languages. Most of the work, however, has remained at the theoretical level, focusing on the developments of frameworks and the definition of abstract domains. This paper reports our effort to verify experimentally the practical value of this area of research. It describes the design and implementation of the generic abstract interpretation algorithm GAIA that we originally proposed in Le Charlier et al. [1991], its instantiation to a sophisticated abstract domain (derived from Bruynooghe and Janssens [1988]) containing modes, types, sharing, and aliasing, and its evaluation both in terms of performance and accuracy. The overall implementation (over 5000 lines of Pascal) has been systematically analyzed on a variety of programs and compared with the complexity analysis of Le Charlie et al. [1991] and the specific analysis systems of Hickey and Mudambi [1989], Taylor [1989; 1990], Van Roy and Despain [1990], and Warren et al. [1988].

Strategic directions in constraint programming

A constraint can be thought of intuitively as a restriction on a space of possibilities. Mathematical constraints are precisely specifiable relations among several unknowns (or variables), each taking a value in a given domain. Constraints restrict the possible values that variables can take, representing some (partial) information about the variables of interest. For instance, “The second side of a sheet of a paper must be imaged 9000 milliseconds after the time at which the first side is imaged,” relates two variables without precisely specifying the values they must take. One can think of such a constraint as standing for (a possibly infinite) set of values, in this case the set {^0, 9000&, ^1500, 10500&, . . .}. Constraints arise naturally in most areas of human endeavor. They are the natural medium of expression for formalizing regularities that underlie the computational and (natural or designed) physical worlds and their mathematical abstractions, with a rich tradition going back to the days of Euclidean geometry, if not earlier. For instance, the three angles of a triangle sum to 180 degrees; the four bases that make up DNA strands can only combine in particular orders; the sum of the currents flowing into a node must equal zero; the trusses supporting a bridge can only carry a certain static and dynamic load; the pressure, volume, and temperature of an enclosed gas must obey the “gas law”; Mary, John, and Susan must have different offices; the relative position of the scroller in the window scroll-bar must reflect the position of the current text in the underlying document; the derivative of a function is positive at zero; the function is monotone in its first argument, and so on. Indeed, whole subfields of mathematics (e.g., theory of Diophantine equations, group theory) and many celebrated conjectures of mathematics (e.g., Fermat’s Last Theorem) deal with whether certain constraints are satisfiable. Constraints naturally enjoy several interesting properties. First, as previously remarked, constraints may specify partial information—a constraint need not uniquely specify the value of its variables. Second, they are additive: given a constraint c1, say, X 1 Y

Constraint satisfaction using constraint logic programming

Z, another constraint c2 can be added, say, X 1 Y # Z. The order of imposition of constraints does not matter; all that matters at the end is that the conjunction of constraints is in effect. Third,

Type analysis of prolog using type graphs

Cosytec, Parc Club Orsay-University, 4, rue Jean-Rostand, 91893 Orsay Cedex, France Abstract Van Hentenryck, P., H. Simonis and M. Dincbas, Constraint satisfaction using constraint logic programming, Artificial Intelligence 58 (1992) 113-159. Constraint logic programming (CLP) is a new class of declarative programming lan- guages whose primitive operations are based on constraints (e.g. constraint solving and constraint entailment). CLP languages naturally combine constraint propagation with nondeterministic choices. As a consequence, they are particularly appropriate for solv- ing a variety of combinatorial search problems, using the global search paradigm, with short development time and efficiency comparable to procedural tools based on the same approach. In this paper, we describe how the CLP language cc(FD), a successor of CHIP using consistency techniques over finite domains, can be used to solve two practical applications: test-pattern generation and car sequencing. For both applications, we present the cc(FD) program, describe how constraint solving is performed, report experimental results, and compare the approach with existing tools. 1.

A Linear-Programming Approximation of AC Power Flows

Abstract Type analysis of Prolog is of primary importance for high-performance compilers since type information may lead to better indexing and to sophisticated specializations of unification and built-in predicates, to name a few. However, these optimization often require a sophisticated type inference system capable of inferring disjunctive and recursive types, and hence expensive in computation time. The purpose of this paper is to describe a type analysis system for Prolog based on abstract interpretation and type graphs (i.e., disjunctive rational trees) with this functionality. The system (about 15,000 lines of C) consists of the combination of a generic fixpoint algorithm, a generic pattern domain, and a type graph domain. The main contribution of the paper is to show that this approach can be engineered to be practical for medium-sized programs without sacrificing accuracy. The main technical contribution to achieve this result is a novel widening operator for type graphs which appears to be accurate and effective in keeping the sizes of the graphs, and hence the computation time, reasonably small.