Showing papers on "Constraint programming published in 1994"

Constraint logic programming : A survey

Abstract: Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

The Art of Prolog: Advanced Programming Techniques

Abstract: Part 1 Logic programs: basic constructs database programming recursive programming the computation model of logic programs theory of logic programs. Part 2 The Prolog language: pure Prolog programming in pure Prolog arithmetic structure inspection meta-logical predicates cuts and negation extra-logical predicates program development. Part 3 Advanced Prolog programming techniques: nondeterministic programming incomplete data structures second-order programming interpreters program transformation logic grammars search techniques. Part 4 Applications: game-playing programs a credit evaluation expert system an equation solver a compiler. Appendix: operators.

Contradicting Conventional Wisdom in Constraint Satisfaction

Abstract: Constraint satisfaction problems have wide application in artificial intelligence. They involve finding values for problem variables where the values must be consistent in that they satisfy restrictions on which combinations of values are allowed. Two standard techniques used in solving such problems are backtrack search and consistency inference. Conventional wisdom in the constraint satisfaction community suggests: 1) using consistency inference as preprocessing before search to prune values from consideration reduces subsequent search effort and 2) using consistency inference during search to prune values from consideration is best done at the limited level embodied in the forward checking algorithm. We present evidence contradicting both pieces of conventional wisdom, and suggesting renewed consideration of an approach which fully maintains arc consistency during backtrack search.

Constraint Programming

Abstract: Constraints allow programmers and users to state declaratively a relation that should be maintained, rather than requiring them to write procedures to maintain the relation themselves. They are thus useful in such applications as programming languages, user interface toolkits, and simulation packages. In many situations, it is desirable to be able to state both required and preferential constraints. The required constraints must hold. Since the other constraints are merely preferences, the system should try to satisfy them if possible, but no error condition arises if it cannot. A constmint hiemrchy consists of a set of constraints, each labeled as either required or preferred at some strength. An arbitrary number of different strengths is allowed. In the discussion of a theory of constraint hierarchies, we present alternate ways of selecting among competing possible solutions, and prove a number of propositions about the relations among these alternatives. We then outline algorithms for satisfying constraint hierarchies, and ways in which we have used constraint hierarchies in a number of programming languages and systems.

Implementation of resource constraints in ILOG SCHEDULE: a library for the development of constraint-based scheduling systems

Abstract: It has been argued that the use of constraint-based techniques and tools enables the implementation of precise, flexible efficient and extensible scheduling systems; precise and flexible as the system can take into account any constraint expressible in the constraint language; efficient in as much as highly optimised constraint propagation procedures are now available; extensible as the consideration of a new type of constraint may require (especially in an object-oriented framework) only an extension to the constraint system or, in the worst case, the implementation of additional decision-making modules (without needs for modification of the existing code). The paper presents ILOG SCHEDULE, a C++ library enabling the representation of a wide collection of scheduling constraints in terms of 'resources' and 'activities'. ILOG SCHEDULE is based on SOLVER, the generic software tool for object-oriented constraint programming from ILOG. SOLVER variables and constraints can be accessed from SCHEDULE activities and resources. As a result, SCHEDULE users can make use of SOLVER to represent specific constraints, and implement and combine the specific problem-solving strategies that are the most appropriate for the scheduling application under consideration. It is hoped-and expected-that object-oriented constraint programming tools like SCHEDULE will enable the industry to make decisive steps toward the implementation of 'state-of-the-art' highly flexible, constraint-based scheduling applications.

Constraint checking with partial information

Abstract: Constraints are a valuable tool for managing information across multiple databases, as well as for general purposes of assuring data integrity. However, efficient implementation of constraint checking is difficult. In this paper we explore techniques for assuring constraint satisfaction without performing a complete evaluation of the constraints. We consider methods that use only constraint definitions, methods that use constraints and updates, and methods that use constraints, updates, and “local” data.

Foundations of timed concurrent constraint programming

Abstract: We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denotational character. We show how programs may be compiled into finite-state machines with loop-free computations at each state, thus guaranteeing bounded response time. >

Records for logic programming

Abstract: CFT is a new constraint system providing records as logical data structure for constraint (logic) programming. It can be seen as a generalization of the rational tree system employed in Prolog II, where finer-grained constraints are used and where subtrees are identified by keywords rather than by position. CFT is defined by a first-order structure consisting of so-called feature trees. Feature trees generalize the ordinary trees corresponding to first-order terms by having their edges labeled with field names called features. The mathematical semantics given by the feature tree structure is complemented with a logical semantics given by five axiom schemes, which we conjecture to comprise a complete axiomatization of the feature tree structure. We present a decision method for CFT, which decides entailment and disentailment between possibly existentially quantified constraints. Since CFT satisfies the independence property, our decision method can also be employed for checking the satisfiability of conjunctions of positive and negative constraints. This includes quantified negative constraints such as ∀ y ∀ z(x≠f(y,z)) . The paper also presents an idealized abstract machine processing negative and positive constraints incrementally. We argue that an optimized version of the machine can decide satisfiability and entailment in quasilinear time.

Hierarchical constraint logic programming

Abstract: A constraint describes a relation to be maintained; it states what the relationship is as opposed to how to maintain it. In many applications, such as interactive graphics, planning, document formatting, and decision support, one needs to express preferences as well as strict requirements. Such constraints are sometimes called soft constraints; the required ones are called hard constraints. We allow an arbitrary number of levels of preference, each successive level being more weakly preferred than the previous one. A collection of constraints at various levels of preference is known as a constraint hierarchy. Constraint Logic Programming (CLP) is a general scheme for extending logic programming to include constraints. It is parameterized by ${\cal D},$ the domain of the constraints. However, CLP(${\cal D}$) languages, as well as most other constraint systems, only allow the programmer to specify constraints that must hold. If we wish to make full use of the constraint paradigm, we need ways to represent these defaults and preferences declaratively, as constraints, rather than encoding them in the procedural parts of the language. We describe a scheme for extending CLP(${\cal D}$) to include both required and preferential constraints. We present a theory of constraint hierarchies, and an extension, Hierarchical Constraint Logic Programming, of the CLP scheme to include constraint hierarchies. We give an operational, model theoretic and fixed-point semantics for the HCLP scheme. Finally, we describe two interpreters we have written for instances of the HCLP scheme, give example programs, and discuss related work.

Constraint Programming and Database Query Languages

Abstract: The declarative programming paradigms used in constraint languages can lead to powerful extensions of Codd''s relational data model. The development of constraint database query languages from logical database query languages has many similarities with the development of constraint logic programming from logic programming, but with the additional requirements of data efficient, set-at-a-time, and bottom-up evaluation. In this overview of constraint query languages (CQLs) we first present the framework of [KKR]. The principal idea is that: ``the k-tuple (or record) data type can be generalized by a conjunction of quantifier-free constraints over k variables''''. The generalization must preserve various language properties of the relational data model, e.g., the calculus/algebra equivalence, and have time complexity polynomial in the size of the data. We next present an algebra for dense order constraints that is simpler to evaluate than the calculus described in [KKR], and we sharpen some of the related data complexity bounds. We note that CQLs are applicable to spatial databases. This is because these languages have ``spatial point set'''' as the semantics of their record data type and because existing multi-dimensional searching data structures can support I/O efficient access to sets of records. Finally, we observe that CQLs can be augmented with complex object data types, aggregate operations, and null-values, just like the relational data model. P. C. Kanellakis, G. M. Kuper, P. Z. Revesz, ``Constraint Query Languages'''', Proc. 9th ACM PODS, 1990, pp. 299-313. Full version available as Brown Univ. Tech. Rep. CS-92-50; to appear in JCSS.

Skyblue: a multi-way local propagation constraint solver for user interface construction

Abstract: Many user interface toolkits use constraint solvers to maintain geometric relationships between graphic objects, or to connect the graphics to the application data structures. One efficient and flexible technique for maintaining constraints is multi-way local propagation, where constraints are represented by sets of method procedures. To satisfy a set of constraints, a local propagation solver executes one method from each constraint.SkyBlue is an incremental constraint solver that uses local propagation to maintain a set of constraints as individual constraints are added and removed. If all of the constraints cannot be satisfied, SkyBlue leaves weaker constraints unsatisfied in order to satisfy stronger constraints (maintaining a constraint hierarchy). SkyBlue is a more general successor to the DeltaBlue algorithm that satisfies cycles of methods by calling external cycle solvers and supports multi-output methods. These features make SkyBlue more useful for constructing user interfaces, since cycles of constraints can occur frequently in user interface applications and multi-output methods are necessary to represent some useful constraints. This paper discusses some of applications that use SkyBlue, presents times for some user interface benchmarks and describes the SkyBlue algorithm in detail.

Interval Constraint Logic Programming

Abstract: In this paper, we present an overview on the use of interval arithmetic to process numerical constraints in Constraint Logic Programming. The main principle is to approximate n-ary relations over IR with Cartesian products of intervals whose bounds are taken in a finite subset of IR. Variables represent real values whose domains are intervals defined in the same manner. Narrowing operators are defined from approximations. These operators compute, from an interval and a relation, a set included in the initial interval. Sets of constraints are then processed thanks to a local consistency algorithm pruning at each step values from initial intervals. This algorithm is shown to be correct and to terminate, on the basis of a certain number of properties of narrowing operators. We focus here on the description of the general framework based on approximations, on its application to interval constraint solving over continuous and discrete quantities, we establish a strong ling between approximations and local consistency notions and show that arc-consistency is an instance of the approximation framework. We finally describe recent work on different variants of the initial algorithm proposed by John Cleary and developped by W. Older and A. Vellino which have been proposed in this context. These variants address four particular points: generalization of the constraint language, improvement of domain reductions, efficiency of the computation and finally, cooperation with other solvers. Some open questions are also identified.

Solving constraint satisfaction problems using genetic algorithms

Abstract: This article discusses the applicability of genetic algorithms (GAs) to solve constraint satisfaction problems (CSPs). We discuss the requirements and possibilities of defining so-called heuristic GAs (HGAs), which can be expected to be effective and efficient methods to solve CSPs since they adopt heuristics used in classical CSP solving search techniques. We present and analyse experimental results gained by testing different heuristic GAs on the N-queens problem and on the graph 3-colouring problem. >

Constraint-based reasoning

Abstract: The Logic of Constraint Satisfaction, A.K. Mackworth partial constraint satisfaction, E.C. Freuder, R.J. Wallace constraint reasoning based on interval arithmetic: the tolerance propagation approach, E. Hyvonen constraint satisfaction using constraint logic programming, P. Van Hentenryck et al minimizing conflicts - a heuristic repair method for constraint satisfaction and scheduling problems, S. Minton et al arc consistency - parallelism and domain dependence, P.R. Cooper and M.J. Swain structure identification in relational data, R. Dechter and J. Pearl learning to improve constraint-based scheduling, M. Zweben et al reasoning about qualitative temporal information, P. van Beek a geometric constraint engine, G.A. Kramer a theory of conflict resolution in planning, Q. Yang.

Conjunto: constraint logic programming with finite set domains

Abstract: Combinatorial problems involving sets and relations are currently tackled by integer programming and expressed with vectors or matrices of 0-1 variables. This is efficient but not flexible and unnatural in problem formulation. Toward a natural programming of combinatorial problems based on sets, graphs or relations, we define a new CLP language with set constraints. This language Conjunto aims at combining the declarative aspect of Prolog with the efficiency of constraint solving techniques. We propose to constrain a set variable to range over finite set domains specified by lower and upper bounds for set inclusion. Conjunto is based on the inclusion and disjointness constraints applied to set expressions which comprise the union, intersection and diffirence symbols. The main contribution herein is the constraint handler which performs constraint propagation by applying consistency techniques over set constraints.

In search of the best constraint satisfaction search

Abstract: We present the results of an empirical study of several constraint satisfaction search algorithms and heuristics. Using a random problem generator that allows us to create instances with given characteristics, we show how the relative performance of various search methods varies with the number of variables, the tightness of the constraints, and the sparseness of the constraint graph. A version of backjumping using a dynamic variable ordering heuristic is shown to be extremely effective on a wide range of problems. We conducted our experiments with problem instances drawn from the 50% satisfiable range.

Set Constraints and Set-Based Analysis

Abstract: The calculus of set constraints was presented, and its history of basic results and applications briefly described. The approach of set-based analysis was then presented in an informal style, with a focus on the breadth of applicability of the technique. The relationship between set constraints and set-based analysis is roughly that the approximation of a program by ignoring inter-variable dependencies can be captured by set constraints. It was then argued that set-based analysis can provide accurate and efficient program analysis.

Constraint satisfaction using constraint logic programming

Abstract: 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.

Encapsulated search for higher-order concurrent constraint programming

Abstract: The paper presents an extension of the concurrent constraint model providing for higher-order programming, deep guards, and encapsulated search. The paper focuses on a higher-order combinator providing for encapsulated search. The search combinator spawns a local computation space and resolves remaining choices by returning the alternatives as rst-class citizens. The search combinator allows to program diierent search strategies, including depth-rst, indeterministic one solution, demand-driven multiple solution, all solutions, and best solution (branch and bound) search. The described computation model is realized in Oz, a programming language and system under development at DFKI.

Prolog++: The Power of Object-Oriented and Logic Programming

Abstract: 1. Object-Oriented Programming * Introduction * The Evolution of Object-Oriented Programming * What is Object-Oriented Programming? * The Declarative Challenge * Handling Change * Prolog and Objects 2. A Prolog Primer * Introduction * Facts and Rules * Predicates and Variables - Datalog * Compound Terms * Recursive and Iteration * Negation and the Cut * MetaProgra * Side Effects 3. Declarative Prolog ++ Programming * Objects and Attributes * Object Identity * Functional Notation * Multiple Inheritance * Built-In Object 4. Dynamic Prolog ++ * Objects and Instances * Abstract Datatypes * Database * Transactions * Passivation and Activation 5. Graphical User Interfaces * Smalltalk, Mac, GKS and X-Windows * Building Pictures as Objects * Windows and their Properties * A Prolog ++ Graphical System * Iconic User Interfaces 6. Objects and Program Design * Extended Boolean Queries Example * A Sentence Reader * Developing the Design for Efficiency * Adding More Intelligence 7. Concurrency * Introduction * Concurrent Prolog and State-Change * Basic Object Capabilities * Inheritance versus Delegation * Prolog ++ and Step 8. Objects - The Way Ahead * Modularity in Prolog and its Problems * Entities and Relationships * Persistence and Object-Oriented Databases * Other OOLP Systems

Encapsulated Search and Constraint Programming in Oz

Abstract: Oz is an attempt to create a high-level concurrent programming language providing the problem solving capabilities of logic programming (i.e., constraints and search). Its computation model can be seen as a rather radical extension of the concurrent constraint model providing for higher-order programming, deep guards, state, and encapsulated search. This paper focuses on the most recent extension, a higher-order combinator providing for encapsulated search. The search combinator spawns a local computation space and resolves remaining choices by returning the alternatives as first-class citizens. The search combinator allows to program different search strategies, including depth-first, indeterministic one solution, demand-driven multiple solution, all solutions, and best solution (branch and bound) search. The paper also discusses the semantics of integer and finite domain constraints in a deep guard computation model.

A Foundation for Higher-order Concurrent Constraint Programming

Abstract: We present the γ-calculus, a computational calculus for higher-order concurrent programming. The calculus can elegantly express higher-order functions (both eager and lazy) and concurrent objects with encapsulated state and multiple inheritance. The primitives of the γ-calculus are logic variables, names, procedural abstraction, and cells. Cells provide a notion of state that is fully compatible with concurrency and constraints. Although it does not have a dedicated communication primitive, the γ-calculus can elegantly express one-to-many and many-to-one communication. There is an interesting relationship between the γ-calculus and the π-calculus: The γ-calculus is subsumed by a calculus obtained by extending the asynchronous and polyadic π-calculus with logic variables. The γ-calculus can be extended with primitives providing for constraint-based problem solving in the style of logic programming. A such extended γ-calculus has the remarkable property that it combines first-order constraints with higher-order programming.

Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system

Abstract: We informally discuss several issues related to the parallel execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argue that, under this view, a large number of the actual systems and models can be explained through the application, at different leveis of granularity, of only a few basic principies: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermediate kernel language.

Constraint satisfaction using constraint logic programming

Abstract: Constraint logic programming (CLP) is a new class of declarative programming languages whose primitive operations are based on constraints (eg constraint solving and constraint entailment) CLP languages naturally combine constraint propagation with nondeterministic choices As a consequence, they are particularly appropriate for solving 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

Managing dynamic temporal constraint networks

Abstract: This paper concerns the specialization of arc-consistency algorithms for constraint satisfaction in the management of quantitative temporal constraint networks. Attention is devoted to the design of algorithms that support an incremental style of building solutions allowing both constraint posting and constraint retraction. In particular, the AC-3 algorithm for constraint propagation, customized to temporal networks without disjunctions, is presented, and the concept of dependency between constraints described. The dependency information is useful to dynamically maintain a trace of the more relevant constraints in a network. The concept of dependency is used to integrate the basic AC-3 algorithm with a sufficient condition for inconsistency detection that speeds up its performance, and to design an effective incremental operator for constraint retraction.

Logic Programming: Formal Methods and Practical Applications

Abstract: Part 1 Foundations: goal-directed forward chaining - a tuple-oriented bottom-up approach, W. Burgard from magic sets to a tuple-oriented approach comparing magic sets and goal-directed forward chaining computing relevant atoms GDFC-resolution termination of GDFC-resolution efficiency of GDFC-resolution the WAM - definition and compiler correctness, E. Borger and D. Rosenzweig evolving algebras prolog - tree and stack models predicate structure clause structure term structure. Appendices: rules for prolog tree model rules for compiled predicate structure rules for compiled clause structure rules for the WAM automatic verification of parallel logic programs - termination, L. Plumer basic notions directed programs and oriented derivations well-formed programs program transformation automatic termination proofs derivation of linear predicate inequalities for well-formed programs final remarks. Part 2 Language aspects and methodology: logic program modules for interoperable information systems, A.B. Cremers et al interoperability EPSILON building interoperable systems with links concepts, implementation, and applications of a typed logic programming language, C. Beierle concepts of PROTOS-L the PROTOS-L system planning applications further work polymorphic feature types, G. Meyer types and subtyping typed logic programming parametric polymorphism and feature types formal aspects further work efficient object-oriented programming in prolog, P. Schachte and G. Saab the objects package - a precursor to classes the second version - the classes package implementation of classes results examples future work related work. Part 3 Constraints: combinatorial problem solving in constraint logic programming with cooperating solvers, H. Beringer and B. De Backer a primer to constraint logic programming using CLP as a tool for combinatorial problem solving the domain reduction solver the real linear solver making the different solvers communicate using constraint logic programming for industrial scheduling problems, S. Breitinger and H.C.R. Lock constraints in scheduling problems disjunctive constraints heuristics - a guide to search related work. Part 4 Applications: a generic scheduling framework developed in prolog, L. Sterling and V. Srinivasan the scheduling problem - a generic solution specification of scheduler clusters schedule generation evaluation of experiments scheduling and meta-scheduling, J. Sauer the scheduling problem scheduling in PROTOS meta-scheduling dynamic and meta-scheduling knowledge representation of scheduling knowledge by heuristics META_PLAN - using dynamic scheduling knowledge robot control systems as contextual logic programs, E. Denti et al contextual logic programming systems the CARA robot programming support. (Part contents).