Spiro Michaylov

CLP( R ) 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.

An abstract machine for CLP( R )

An abstract machine is described for the CLP(<inline-equation> <f><sc>R</sc></f> </inline-equation>) programming language. It is intended as a first step toward enabling CLP(<inline-equation> <f><sc>R</sc></f> </inline-equation>) programs to be executed with efficiency approaching that of conventional languages. The core Constraint Logic Arithmetic Machine (CLAM) extends the Warren Abstract Machine (WAM) for compiling Prolog with facilities for handling real arithmetic constraints. The full CLAM includes facilities for taking advantage of information obtained from global program analysis.

Natural semantics and some of its meta-theory in Elf

Natural semantics, a form of operational semantics, provides a high-level and elegant means of specifying interpreters for programming languages. In this paper we investigate the use of the logic programming language Elf to implement and reason about natural semantics. We illustrate our techniques by giving type checking rules and operational semantics for Mini-ML, a small functional language based on a simply typed λ-calculus with polymorphism, products, conditionals, and recursive function definitions. We also partially internalize proofs for some meta-theoretic properties of Mini-ML, the most difficult of which is subject reduction.

A methodology for managing hard constraints in CLP systems

In constraint logic programming (CLP) systems, the standard technique for dealing with hard constraints is to delay solving them until additional constraints reduce them to a simpler form. For example, the CLP (7?) system delays the solving of nonlinear equations until they become linear, when certain variables become ground. In a naive implement ation, the overhead of delaying and awakening constraints could render a CLP system impractical. In this paper, a framework is developed for the specification of wakeup degrees which indicate how far a hard constraint is from being awoken. This framework is then used to specify a runtime structure for the delaying and awakening of hard constraints. The primary implementation problem is the timely awakening of delayed constraints in the context of temporal backtracking, which requires changes to internal data structures be reversible. This problem is resolved efficiently in our struct ure, Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice end the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to rewblish, reauires a fee andlor snecific r)ermission. @“l 991 ACM O-89791 -4i8-7/

PARTHENON: a parallel theorem prover for nonHorn clauses

jl /0005 /0306 ...

Meta-programming in CLP(R)☆

1 .50 1 [ I Proceedings of the ACM SIGPLAN ’91 Conference cm I 1

The CLP(R) language and system: an overview

A parallel resolution theorem prover, called Parthenon, that handles first-order logic is described. Parthenon is apparently the first general-purpose theorem prover to be developed for a multiprocessor. The system is based on a modification of D.H.D. Warrens SRI model (Int. Symp. on Logic Prog., pp.92-101, 1987) for OR-parallelism and implements a variant of D.W. Lovelands (J. ACM, vol.15, pp.236-51, 1968) model elimination procedure. It has been evaluated on various shared memory multiprocessors, including a 16-processor Encore Multimax. The authors have found that typical theorem-proving problems exhibit a great deal of potential parallelism. Parthenon has been able to exploit much of this parallelism, producing both impressive absolute run times and near-linear speed-up curves.<<ETX>>

The CLP( R ) language and system

Abstract A widely used property of Prolog is that it is possible to write Prolog programs to construct and manipulate other Prolog programs in a very general manner. Unfortunately, this property is not carried over to richer languages such as CLP(R>)—the manipulation of CLP(R) programs in CLP(R) is quite limited. The reason is that the equality of terms in CLP(R) is not based on their syntactic structure. We propose an extended language, CLP(R + M), in which programs may be represented and structurally manipulated. Importantly, CLP(R + M) is not just a meta-language for CLP(R), but it can also be used as its own meta-language. We present a decision algorithm for (R + M) constraints, discuss implementation issues, and describe the implementation of a subclass of (R + M) constraints. Finally, by building on the extended language, we present an integrated set of system predicates and a methodology for practical meta-programming.

Methodology and Implementation of a CLP System.

The basics of the CLP(R) language are reviewed, and some important programming techniques are described. A brief overview of the implementation of the CLP(R) interpreter is given. The operational model of the CLP(R) language is based on the amalgamation of two main procedures: a logic programming engine and a constraint solver for the domain of uninterpreted terms and arithmetic terms. In CLP(R) programs, constraints are used to specify the input parameter, appear dynamically during execution, and are output as answer constraints. Three clearly identifiable paradigms of CLP(R) programming methodology are described: hierarchical reasoning and constraint propagation, constraints as output, and a constrain-and-generate methodology for combinatorial search problems.<<ETX>>