Constraint Logic Programming Scheme Research Articles

CLP(H):Constraint logic programming for hedges

AbstractCLP(H) is an instantiation of the general constraint logic programming scheme with the constraint domain of hedges. Hedges are finite sequences of unranked terms, built over variadic function symbols and three kinds of variables: for terms, for hedges, and for function symbols. Constraints involve equations between unranked terms and atoms for regular hedge language membership. We study algebraic semantics of CLP(H) programs, define a sound, terminating, and incomplete constraint solver, investigate two fragments of constraints for which the solver returns a complete set of solutions, and describe classes of programs that generate such constraints.

Simulation Reduction as Constraint

The simulation relation is largely used in Model Checking where it allows to reduce Kripke structures, on which verification takes place, while preserving significant fragments of Temporal Logic. Our approach to the problem of simulation computation here has two aims: on the one hand we want to provide a framework in which developing algorithms competitive with the best ones in the literature, on the other hand we want to show how it is extremely natural to view such algorithms as constraint solving procedures to be easily implemented in a constraint logic programming scheme.

CLP( χ) for automatically proving program properties

Various proof methods have been proposed to solve the implication problem, i.e. proving that properties of the form: ∀( P→ Q) – where P and Q denote conjunctions of atoms – are logical consequences of logic programs. Nonetheless, it is commonplace to say that it is still quite a difficult problem. Besides, the advent of the constraint logic programming scheme constitutes not only a major step towards the achievement of efficient declarative logic programming systems but also a new field to explore. By recasting and simplifying the implication problem in the constraint logic programming (CLP) framework, we define a generic proof method for the implication problem, which we prove sound from the algebraic point of view. We present four examples using CLP( N ), CLP( RT ), CLP( Σ ∗ ) and RISC-CLP( R ). The logical point of view of the constraint logic programming scheme enables the automation of the proof method. At last, we prove the unsolvability of the implication problem, we point out the origins of the incompleteness of the proposed proof method and we identify two classes of programs for which we give a decision procedure for the implication problem.

A hybrid approach of linear programming and logic modeling for the market core of sealed bid auctions

This paper presents a hybrid approach for sealed bid auction that integrates linear programming and logic modeling techniques. A linear programming model for the sealed bid auction considers only prices for transaction arrangements and yields multiple market cores when goods from sellers are equally attractive to many buyers. The hybrid approach takes into account ordinal preferences of traders as well to find the best market core. On the one hand, the hybrid approach uses a linear programming model to maximize total surplus of market participants based on the bid and ask prices. On the other hand, it employs a logical inferencing approach to satisfy traders' ordinal preferences that are not included in a single combination of bid and ask prices. A constraint logic programming scheme, which combines a mathematical program with a logical inferencing technique in an integrated formalism, is introduced to implement the hybrid approach. The hybrid approach is validated through market simulations, where a set of computer-generated trading data is applied to both the hybrid approach and the linear programming model for their market performance comparison.

Hybrid knowledge bases

Deductive databases that interact with, and are accessed by, reasoning agents in the real world (such as logic controllers in automated manufacturing, weapons guidance systems, aircraft landing systems, land-vehicle maneuvering systems, and air-traffic control systems) must have the ability to deal with multiple modes of reasoning. Specifically, the types of reasoning we are concerned with include, among others, reasoning about time, reasoning about quantitative relationships that may be expressed in the form of differential equations or optimization problems, and reasoning about numeric modes of uncertainty about the domain which the database seeks to describe. Such databases may need to handle diverse forms of data structures, and frequently they may require use of the assumption-based nonmonotonic representation of knowledge. A hybrid knowledge base is a theoretical framework capturing all the above modes of reasoning. The theory tightly unifies the constraint logic programming scheme of Jaffar and Lassez (1987), the generalized annotated logic programming theory of Kifer and Subrahmanian (1989), and the stable model semantics of Gelfond and Lifschitz (1988). New techniques are introduced which extend both the work on annotated logic programming and the stable model semantics.

Towards a meaning of life

LIFE is an experimental programming language proposing to integrate three orthogonal programming paradigms proven useful for symbolic computation. From the programmer's standpoint, it may be perceived as a language taking after logic programming, functional programming, and object-oriented programming. From a formal perspective, it may be seen as an instance (or rather, a composition of three instances) of a Constraint Logic Programming scheme due to Höhfeld and Smolka refining that of Jaffar and Lassez. We start with an informal overview demonstrating LIFE as a programming language, illustrating how its primitives offer rather unusual, and perhaps (pleasantly) startling, conveniences. The second part is a formal account of LIFE's object unification seen as constraint-solving over specific domains. We build on work by Smolka and Rounds to develop type-theoretic, logical, and algebraic renditions of a calculus or order-sorted feature approximations.

Hierarchical constraint logic programming

Constraint logic programming (CLP) is a general scheme for extending logic programming to include constraints. It is parametrized by D , the domain of the constraints. However, CLP( D ) languages, as well as most other constraint systems, only allow the programmer to specify constraints that must hold. In many applications, such as interactive graphics, planning document formatting, and decision support, one needs to express preferences as well as strict requirements. 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( D ) to include both required and preferential constraints. An arbitrary number of strengths of preference are allowed. We present a theory of such constraint hierarchies, and an extension, hierarchical constraint logic programming (HCLP), 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.

CLP(?) and some electrical engineering problems

The Constraint Logic Programming Scheme defines a class of languages designed for programming with constraints using a logic programming approach. These languages are soundly based on a unified framework of formal semantics. In particular, as an instance of this scheme with real arithmetic constraints, the CLP(ℜ) language facilitates and encourages a concise and declarative style of programming for problems involving a mix of numeric and non-numeric computation. In this paper we illustrate the practical applicability of CLP(ℜ) with examples of programs to solve electrical engineering problems. This field is particularly rich in problems that are complex and largely numeric, enabling us to demonstrate a number of the unique features of CLP(ℜ). A detailed look at some of the more important programming techniques highlights the ability of CLP(ℜ) to support well-known, powerful techniques from constraint programming. Our thesis is that CLP(ℜ) is an embodiment of these techniques in a language that is more general, elegant and versatile than the earlier languages, and yet is practical.

The CLP( ℛ ) language and system

The CLP( ℛ ) programming language is defined, its underlying philosophy and programming methodology are discussed, important implementation issues are explored in detail, and finally, a prototype interpreter is described. CLP( ℛ ) is designed to be an instance of the Constraint Logic Programming Scheme, a family of rule-based constraint programming languages defined by Jaffar and Lassez. The domain of computation ℛ of this particular instance is the algebraic structure consisting of uninterpreted functors over real numbers. An important property of CLP( ℛ )is that the constraints are treated uniformly in the sense that they are used to specify the input parameters to a program, they are the only primitives used in the execution of a program, and they are used to describe the output of a program. Implementation of a CLP language, and of CLP( ℛ ) in particular, raises new problems in the design of a constraint-solver. For example, the constraint solver must be incremental in the sense that solving additional constraints must not entail the resolving of old constraints. In our system, constraints are filtered through an inference engine, an engine/solver interface, an equation solver and an inequality solver. This sequence of modules reflects a classification and prioritization of the classes of constraints. Modules solving higher priority constraints are isolated from the complexities of modules solving lower priority constraints. This multiple-phase solving of constraints, together with a set of associated algorithms, gives rise to a practical system.