Showing papers on "Constraint programming published in 1987"

Constraint logic programming

Abstract: We address the problem of designing programming systems to reason with and about constraints. Taking a logic programming approach, we define a class of programming languages, the CLP languages, all of which share the same essential semantic properties. From a conceptual point of view, CLP programs are highly declarative and are soundly based within a unified framework of formal semantics. This framework not only subsumes that of logic programming, but satisfies the core properties of logic programs more naturally. From a user's point of view, CLP programs have great expressive power due to the constraints which they naturally manipulate. Intuition in the reasoning about programs is enhanced as a result of working directly in the intended domain of discourse. This contrasts with working in the Herbrand Universe wherein every semantic object has to be explicitly coded into a Herbrand term; this enforces reasoning at a primitive level. Finally, from an implementor's point of view, CLP systems can be efficient because of the exploitation of constraint solving techniques over specific domains.

Constraint Logic Programming and Option Trading

Abstract: Options are contracts whose value is contingent upon the value of underlying assets. We will focus on the most common types of options-those on common stocks. A call option gives owners the right to buy (exercise the option) a fixed number of shares at a fixed (exercise/strike) price until a certain (maturity/expiration) date. Conversely, aput option gives owners the right to sell shares at a fixed price. Option contracts are usually purchased in lots of 100 shares. Individuals creating or issuing options are known as sellers/writersand purchasers as holders/buyers-of options. For example, a call option on \"XYZ Jan 50\" at a cost of $800 will give buyers the right to purchase 100 shares of XYZ at $50 a share until January 18, 1988. At any time before this, holders can (1) sell the call at current market price, (2) exercise it by paying $5000 for 100 shares of XYZ, or (3) do nothing. If holders don't exercise the call by January 18, then it will either expire (worthless because XYZ is below $50) with a loss of $800 or, if XYZ is above $50 (say at $60), it will generate a profit of (6050)*100800 = $200. Option trading involves complex combinations of options together with shares, bonds, and other options.\" 2 For example, a butterfly consists of buying two calls-one at a lower strike price and one at a higher strike price-and of selling two calls at a middle strike price. While loss is limited if the stock moves by a large amount, a profit is made if the share stays around the middle strike price. The following features make option trading an interesting domain for expert system applications: * Options play a central role in modern financial practice; * Complex trading strategies are involved; * Returns are contingent on future, uncertain market states-presenting many possibilities for large portfolios; * Traders use heuristic and ad hoc techniques widely, basing their theory on many assumptions-assumptions often violated in practice; * Valuation techniques frequently involve significant numerical computation; and

CLP(R) and Some Electrical Engineering Problems.

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

Integrity Constraint Reformulation for Efficient Validation

Abstract: Constraint validation has bcc?n difficult to implement efficiently. The major reason for this difficulty lies in the state-dependent nature of integrity constraints and the rt~quiremcnt of both high-level spc&fication and cfficirnt runtimc cnforccmcnt. In this paper, we propose a constraint reformulation approach to rfficicnt constraint validation. We also demonstrate how this knowledge-basrd constraint rcfornmlation can be naturally accomplished in the gcncral framework of problem reformulation with the technique of antecedent derivation. We formalize thr reformulation of an integrity constraint as a tree-starch process where the search space is thtr set of all semantic-equivalent alternatives of the original constraint. We also develop control strategies and mcta-level rules for carrying out the search c?fficicntly. The major contribution of this work is a new promising approach to cfficirnt constraint validatiun and a general framework to accomplish it.

From Unification to Constraints

Abstract: The constraint paradigm plays a more and more important role in knowledge based systems and declarative programming. This is because because it caters for implicit information and the representation of fundamental domains of computation. In particular constraint solving can advantageously replace unification as it corresponds better to programming practice and existing trends in language design. Furthermore the introduction of constraints in Logic Programming preserves and enhances very naturally the desirable semantic properties of Logic Programs. We give here a brief exposition of the motivations that led to the CLP theory, an overview of the language CLP (ℛ), an example of application in Stock Options Trading and finally we mention a number of important activities in the area of Constraints and Logic Programming.

A theoretical framework for consistency techniques in logic programming

Abstract: While being a powerful paradigm for solving Constraint Satisfaction Problems (CSPs), Consistency Techniques (CTs) have never been taken into account during the design of declarative programming languages This paper defines a theoretical framework for using CTs inside logic programming Three inference rules are introduced and their formal properties are investigated Also, computation rules are defined which are worth considering wrt the inference rules As practical results, the programmer can write "generate & test" programs while the interpreter/compiler will use CTs for solving them (eg forward checking or arc consistency) This makes logic programming not only a good language for stating CSPs but also an efficient tool for solving them as confirmed by our first experiences

Specification and generation of constraint satisfaction systems

Abstract: Constraint languages are declarative languages that have been used in various applications such as simulation, modeling, and graphics. Unfortunately, despite their benefits, existing constraint languages tend to be application-specific, have limited extensibility, and are difficult to implement. This dissertation presents a general-purpose computer language that makes it much easier to describe and implement constraint satisfaction systems. This language, called Bertrand, supports a rule-based programming methodology and also includes a form of abstract datatype. It is implemented using a new inference mechanism called augmented term rewriting, which is an extension of standard term rewriting. Using rules, a Bertrand programmer can describe new constraint satisfaction mechanisms, including equation solvers. Rules can also be used to define new types of objects and new constraints on these objects. Augmented term rewriting uses these rules to find a model that satisfies a set of user-specified constraints. The simple semantics of augmented term rewriting makes it possible to take advantage of several known techniques for optimizing execution speed, such as fast pattern matching, compilation, constant propagation, and concurrency. Consequently, Bertrand programs can be executed efficiently using an interpreter or compiled to run on a conventional or parallel processor. This dissertation surveys existing constraint satisfaction techniques and languages, and shows how they can be implemented in Bertrand. It also gives a precise operational semantics for augmented term rewriting. Techniques for efficient execution, including interpretation and compilation, are presented. Finally, examples are given using Bertrand to solve problems in algebra such as word problems and computer aided engineering, and problems in graphics, such as computer aided design, illustration, and mapping.

Extending logic programming to object programming: the system lap

Abstract: Object oriented programming aims at code lisibility and conciseness via abstract data type declarations and takes advantage from setting the objects (ie data) in the center of the application, instead of procedures or demonstrations. Just as in Logic programming, where describing the properties of the solution of some problem is (theoreticaly) enough to allow the program to compute the solution, Object programming proceeds from the fact that purely declarative information leads to more procedural behaviour. It appears that Logic programming and Object programming are complementary in the sense that the first is very suitable for expressing subtle reasoning, but rather weak as a formalism for describing complex structures, and conversely for the second. These considerations led us, at the IIRIAM, to combine Logic and Object programming in order to use the advantages of both. Our research effort resulted In the system LAP, an extension of Prolog to object programming, giving a new dimension to the latter, through logic programming concepts: processing of partially known data and non determinism applied at the object level. The first part of this paper introduces the main characteristics of LAP, faced with the requirements of AI application development. The second part illustrates some of these capabilities through simple examples.

Amalgamating Multiple Programming Paradigms in PROLOG.

Abstract: This paper discusses the issues in amalgamating multiple programming paradigms in the logic programming language, Prolog. It is shown that multiple paradigms can be incorporated without disturbing logic programming language features and efficiency. It also introduces a new programming paradigm called the relation-oriented paradigm. The research results are reflected in the implementation of the Prolog-based knowledge programming system PEACE, which is used to realize an expert system in a diagnostic domain. PEACE provides a relation-oriented programming paradigm, as well as previously discussed paradigms, such as object-oriented, data-oriented, and rule-oriented paradigms. These paradigms are nicely amalgamated in Prolog language and can be used intermixedly.

A parallel logic programming language for PEPSys

Abstract: This paper describes a new parallel Logic Programming language designed to exploit the OR- and Independent AND-parallelisms. The language is based on conventional Prolog but with natural extensions to support handling of multiple solutions and expression of parallelism.

Linear Programming Models

Abstract: Publisher Summary This chapter describes the linear programming models. Linear programming is a technique for the mathematical solution of a constrained optimization problem. As such, it has been used in educational planning by formulating an objective function to be maximized or minimized subject to a set of resource constraints. Linear programming applied to education has been formulated in dynamic form or in a static form depending on whether the solution refers to a series of years over the period of the plan, or to a single year, respectively. Linear programming models applied to education have remained mostly academic rather than being used in the actual planning of school systems. The main reason for this being so is the lack of data required for formulating the relationships in the model. Linear programming uses a set of assumptions that might not correspond to the real world. Linear programming may be a good technique at the level of the firm, for example, to define a sales strategy that would maximize profits. However, when applied to education wide or even economy wide problems, data acquisitions and specification, if nothing else, become exceedingly difficult tasks. Linear programming models provide a rare case in which a social welfare function is actually quantified. Linear programming models applied to education have remained mostly academic rather than being used in the actual planning of school systems. The main reason for this being so is the lack of data required for formulating the relationships in the model.

CS-Prolog: a generalized unification based constraint solver

Abstract: We have described the constraint logic programming language CS-Prolog. CS-Prolog is written in PROLOG about 1,500 lines. This is a very small as oppose to similar system CLP which is written in C about 12,000 lines, but less efficient than CLP. However, CS-Prolog solves equations and inequations in reasonable time and this paper shows the simple approach to constraint logic programming using PROLOG and this technique is very useful for constraint logic programming language system on top of PROLOG machine.

Constraint analysis for the design of semantic database update operations

Abstract: As more emphasis is placed on expressing the semantics of an application in a declarative form, as in a semantic data model with an associated constraint language, it is important for a designer to understand how such constraints affect operations against the data. This research investigates the analysis of constraints as a tool for the definition of update semantics against abstract objects in an object-oriented database. The inherent constraints of a semantic data model are made explicit by using the model as a self-describing data model. The inherent constraints coupled with explicit constraints, expressed in a first order logic constraint language, form the complete set of constraints to be analyzed, uniformly represented in Horn clause form. To support the analysis of constraints, a representation known as constraint graphs is introduced based on a relationship between the clauses of a constraint known as the dominates relation. Constraint graphs provide a way to analyze the clauses of a constraint in a controlled and logical manner. Constraint graphs are augmented with an additional representation known as assumption lists. An assumption list provides a way to organize the predicates of a clause and its dominated clauses to support the analysis process. The structure of an assumption list is shown to correctly support the analysis of a set of clauses and to support the detection of design alternatives associated with satisfying the clauses. The research also demonstrates how recursive constraint analysis coupled with symbolic evaluation can be used to enhance the explanation of constraints. A tool for viewing abstract objects, known as perspectives, is also introduced. Constraint analysis is used to support the formation of perspectives and to define actions to be taken in response to constraint violations on operations against perspectives.

Hierarchical Programming With Fuzzy Objectives and Constraints

Abstract: Procedures of hierarchical programming with fuzzy objectives and constraints are proposed in this paper. Compromise solutions are determined through a sequential optimization procedure by which the objectives are optimized according to their descending order of priorities. In each step, a fuzzy objective function is optimized subject to the fuzzy constraints and the trade-off functions constructed from the permissible trade-offs for the current objective with respect to the higher order objectives. The more stringent the decision makers are on the tradeoffs, the more favorable the compromise solution is to the higher order objectives.

Prolog and expert systems

Abstract: The first part of the thesis provides an introduction to the logic programming language Prolog and some areas of current research The use of compilation to make Prolog faster and more efficient is studied and a modified representation for complex structures is presented Two programming tools are also presented The second part of the thesis focuses on one problem which arises when implementing an Expert System using Prolog A practical three-valued Prolog implementation is described An interpreter accepts three-valued formulae and converts these into a Prolog representation Formulae are in clausal form which allows disjunctive conclusions to rules True and false formulae are stated explicitly and therefore the interpreter is able to perform useful consistency checks when information is added to the data base

A Logic Programming Approach to Building Planning and Simulation Models

Abstract: Logic programming, including languages like Prolog and its variants, is becoming popular for AI applications such as natural language processing and expert systems. These tools may also benefit more traditional management science applications such as planning and simulation. A framework is proposed for describing the problem domain (’model base’) of planning and simulation problems in logical form, separate from the inferencing mechanisms applied to them. Applications are to dynamic programming, decision trees, PERT networks, and discrete event simulation.

Goal Programming, Method of Weighted Residuals, and Optimal Control Problems

Abstract: The feasibility of utilizing goal programming, a management science originated technique, in solving optimal control problems is investigated. The basic idea is to recast the problem in a pre-emptive goal programming model via the use of hard and soft constraints (or stiff and weak springs) in linear programming (or mechanics). It is found that the goal programming technique for solving the optimal control problem is fundamentally more general than the method of weighted residuals. An example is included to illustrate the methodology.

Prolog for VLSI Layout: Experiences in the Design and Implementation of Topolog, A Prolog Based Module Generation and Layout System

Abstract: : The Topolog module generator is the major circuit-design component of the ASP silicon compiler. Topolog is an attempt to determine the utility of Prolog specifically and logic programming generally for the programming of solutions to large-scale VLSI circuit design problems. We have verified that Prolog's clause-based programming style permits easy extensibility of VLSI module generators for new technologies and user-written macroblocks. We have demonstrated that Prolog, even without the well-known assert, retract, and write operators is not a pure applicative language. We have devised a method of type definition in Prolog, and have preliminary evidence that our method is superior in efficiency to the general term unification method commonly found in the literature. (Author)

Update Propagation Network - A Framework for Constraint Programming

Abstract: As a framework for constraint programming, a Network model named CellR while the former is generating a hypothesis dynamically, the latter evaluates it and controls the propagation. Some heuristics are incorporated to localize the effects of the propagation. An extension to Prolog, named Constraint Prolog, is also included to deal with hypothetical reasoning and lazy evaluation. Constraint Prolog is the interpreter of the update propagation mechanism.

Design of the CONSUL Programming Language.

Abstract: : The problem of automatically exploiting parallelism in computer programs, with particular emphasis on linguistic barriers to parallelism detection is studied. Although functional languages and Prolog have many desirable characteristics in this respect, they are not entirely ideal. We therefore offer constraint-based programming as a generalization of logic programming. By virtue of the more flexible ways in which they allow relations to be defined, constraint languages support more natural descriptions of potentially parallel algorithms than do existing logic or functional languages. We introduce a prototype constraint language called CONSUL, which demonstrates features that we feel make constraint languages well-suited for general-purpose programming of multi-processors. The extra expressiveness of constraint languages comes at a price, namely that satisfaction of general constraints can be much more difficult than satisfaction of predicates for a language like Prolog. Nonetheless, we believe that effective compilers for constraint languages can be built, and we outline some ideas on which they could be based.