Showing papers on "Constraint programming published in 1986"

Prolog Programming for Artificial Intelligence

Abstract: From the Publisher: B> This best-selling guide to Prolog has been fully revised and extended to provide an even greater range of applications, enhancing its value as a stand-alone guide to Prolog, artificial intelligence, or AI programming. Ivan Bratko discusses natural language processing with grammar rules, planning, and machine learning. The coverage of meta-programming includes meta-interpreters and object-oriented programming in Prolog. The new edition includes coverage of: constraint logic programming; qualitative reasoning; inductive logic programming; recently developed algorithms; belief networks for handling uncertainty; and a major update on machine learning. This book is aimed at programmers who need to learn AI programming.

Constraint-based tools for building user interfaces

Abstract: A constraint describes a relation that must be maintained. Constraints provide a useful mechanism to aid in the construction of interactive graphical user interfaces. They can be used to maintain consistency between data and a view of the data, to maintain consistency among multiple views, to specify layout, and to specify relations between events and responses for describing animations of interactive systems and event-driven simulations. Object-oriented techniques for constraint representation and satisfaction are presented, and a range of examples that demonstrate the practical use of static and temporal constraints for such purposes is presented. These examples include animations of algorithms and physics simulations, and constructing user-interface elements such as file browsers, views onto statistical data, and an interactive monitor or a simulated operating system.

An experience with a Prolog-based object-oriented language

Abstract: This paper presents an experience with a programming language SPOOL which is based on the combination of object-oriented programming and logic programming This language inherits the capability of knowledge base organization from object-oriented programming and its expressive power from logic programmingThe experience of the application of SPOOL to the program annotation system showed that this combination was quite useful to formalize domain knowledge into declarative data types and make them reusable in different contexts It also showed the need for further study such as better linguistic support to exploit the full power of this combination

Merging objects and logic programming: relational semantics

Abstract: This paper proposes new semantics for merging object programming into logic programming. It differs from previous attempts in that it takes a relational view of method evaluation and inheritance mechanisms originating from object programming. A tight integration is presented, an extended rationale for adopting a success/failure semantics of backtrackable methods calls and for authorizing variable object calls is given. New method types dealing with non monotonicity and determinism necessary for this tight integration are discussed. The need for higher functions is justified from a user point of view. as well as from an implementation one. The system POL is only a piece of a more ambitious goal which is to merge logic programming, object programming and semantic data models which can be seen as an attempt to bridge the gap between Al and databases. The paper is restricted to a programming perspective.

Domains in logic programming

Abstract: When confronted with constraint satisfaction problems (CSP). the "generate & test" strategy of Prolog is particulary inefficient Also, control mechanisms defined for logic programming languages fall short in CSP because of their restricted use of constraints. Indeed. constraints are used passively for testing generated values and not for actively pruning the search space by eliminating combinations of values which cannot appear together in a solution. One remedy is to introduce the domain concept in logic programming language. This allows for an active use of constraints. This extension which does not impede the declarative (logic) reading of logic languages, consists in a modification of the unification, the redefinition of the procedural semantics of some built-in predicates (≠, ≤, ) and a new evaluable function and can be implemented efficiently. Without any change to the search procedure and without introducing a new control mechanism, look ahead strategies, more intelligent choices and consistency techniques can be implemented naturally in programs. Moreover, when combined with a delay mechanism, this leads directly to a strategy which applies active constraints as soon as possible.

Objects in concurrent logic programming languages

Abstract: Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.

A generalized constraint and exception handler for an object-oriented CAD-DBMS

Abstract: A generalized constraint and exception handler for object-oriented CAD databases is presented. The main features of the constraint and exception handler are: dynamic definition of new constraints without recompilation of the schema, deferred constraint checking, and homogeneous handling of constraints and their exceptions. In the paper we analyze first the constraints typically encountered in a CAD environment, discuss the problems of dynamic constraint definition and deferred evaluation and, based on that discussion, present design and implementation issues of the constraint handler which is currently being implemented.

Linear Programming: An Introduction

Abstract: Introduction Linear Programming Modeling Graphical Solution of Linear Programs in Two Variables The Simplex Method for Solving Linear Programs Sensitivity (or Postoptimality) Analysis Computer Solutions to Linear Programming Problems

Management Science: An Introduction

Abstract: Introduction to management science. Mathematical review. Breakeven analysis. Forecasting. Introduction to linear programming. Linear programming. Model formulations. LP simplex method. Sensitivity analysis and duality. PERT/CPM. Transportation and assignment models. Other network models. Goal programming. Integer programming. Inventory models. Probability review. Decision making. Decision mwdels. Markov processes. Game theory. Queuing analysis: waiting-line problems. Simulation. Dynamic programming. Calculus review. Non linear models. Implementation.

Cut and Paste - defining the impure Primitives of Prolog

Abstract: Prolog consists of the Horn Clause subset of predicate logic interpreted by a fixed (left to right, depth first) evaluation strategy and a number of non-logical primitive predicates. The most fundamental of these are ‘cut’ for control of execution, ‘assert’ and ‘retract’ for changing the database, and input-output. Whatever the desirability of these features for the logic programming languages of the future there is general agreement as to the need of these for Prolog as a practical programming language for today.

A heuristic programming approach in estimating efficient target levels in goal programming

Abstract: A heuristic programming approach in estimating efficient target levels in goal programming is described. The approach is designed to improve the computational efficiency of defining the decision space of a goal programming problem. An illustrative example is used to describe the procedure. The sample problem used was adopted from a previous study.

GKS-based graphics programming in PROLOG

Abstract: It is evident that every computer language needs a graphics extension for the same reason as it needs input and output functions. Graphics may be seen as a powerful extension of the input and output facilities. This is even more evident for interactive languages like PROLOG. PROLOG is a computer language widely accepted for the purpose of symbolic computation. It is gaining popularity because of its simplicity and the new descriptive way of programming. A PROLOG program is a description of a problem in the form of some assertions and rules about how the solution may be inferred from the facts. It also provides some powerful data processing mechanisms, mainly relational data base facilities, tree searching with backtracking, and pattern matching. All these advantages make PROLOG suitable for many applications such as relational data bases, architectural design, natural language understanding and other AI fields. Most of the applications mentioned above also need computer graphics. Thus, integration of graphics into PROLOG can be seen as a step towards providing a more intelligent environment for these applications. The design of the graphics extension described in this paper is based on the principles and concepts of the Graphical Kernel System (GKS) [8], GKS provides all capabilities required by most of the PROLOG applications that produce computer generated pictures. It provides a suitable methodological framework for the creation of computer graphics programs because of its consistency, completeness, and compactness.

Multiway merge with constant delay in Concurrent Prolog

Abstract: Multiway dynamic mergers with constant delay are an essential component of a parallel logic programming language. Previous attempts to defined efficient mergers have required complex optimising compilers and run-time support.

Engineering design: applications of goal programming and multiple objective linear and geometric programming‡

Abstract: In this paper we show how the standard goal programming approach to engineering design can be enhanced by the use of multiple objective linear and geometric programming formulations. For simple formulations a logarithmic transformation may be adequate to allow problems to be solved using linear programming and multiple objective linear programming methods. For some more complex forms, geometric programming can be used.

Pitfalls in PROLOG programming

Abstract: A programming language is an intermediate medium between the human user and the machine. Ideally it should reduce the gap between human reasoning and the machine's processing mechanism to the minimum. Accordingly, none of the contemporaryprogramming languages can be said to be ideal. Prolog is no exception. However, it is usually emphasized that programming in Prolog is very easy, even a beginner can handle it within a few hours of learning. The rationale behind this conception is that Prolog clauses are actually some logical statements, and logic is the basis of every rational subject. The problem arises in that Prolog programming is not equivalent to logic programming. Prolog still shares the effect of the influence of the fundamental Von Neumann computer architecture on conventional programming languages. If a user wants to write a Prolog program just according to his logical reasoning, he will probably fall into an unexpected trap of the language.

Automatic resource allocation in industrial multirobot systems

Abstract: The paper proposes a methodology for robot programming, based on the concept of automatically assigning available physical resources to the tasks to be performed during program execution, rather than specifying them in the user program. This is specially useful in multirobot systems, when several similar machines are included in the same robotized cell, and when the system has to cope with unpredictable length operations. The most interesting feature of the system appears to be its capability of maintaining good performance in those situations where, due to faulty robots, to sudden changes in the production cycle, etc., traditional scheduling and optimization techniques fail to succeed. The paper includes a discussion of the main advantages and drawbacks of the technique, together with some experimental results.

Linear programming optimizes unit negotiations

Abstract: A method that applies linear programming to the problem of negotiating unit equity is described, developed, and demonstrated. The unit negotiation process is discussed, and two linear programming models are compared in a simple example problem. The appendix presents in detail the derivation of an algorithm to solve the linear programming models with bidirectional constraints and negative constraint bounds.

Implementing an Interior Point Method in a Mathematical Programming System. I

Abstract: : This paper considers the integration of an interior point algorithm with a large-scale commercial MPS. Exploitation of existing features of the MPS and transition to an optimum basic solution are discussed. Preliminary computational results are presented. Keywords: Auxiliary Processing; Simplex method; Linear programming.

Prolog Programming Environments: Architecture and Implementation

Abstract: It is widely recognized that programming environments affect the productivity of programmers in a quite significant way. Sometimes, even the system designers' productivity in the qualitative aspects might be greatly influenced by the availability of reasonable programming environments. This is not only true when programs are developed in conventional procedural languages, but also true when logic programming languages are used.

A method for compiling efficient constraint checks in database programming languages (semantic integrity constraints)

Abstract: A three stage method that uses semantic integrity constraints to build efficient constraint checks for arbitrarily complex transactions is presented. A transaction is viewed as a set of paths. The first stage creates a compile-time description of the pre-updated and updated databases for each path. The second stage uses these descriptions to evaluate the semantic integrity constraints, at compile-time. Both the prefix and the matrix of a constraint are analyzed at this time. Constraint checks are created when a constraint cannot be completely evaluated. The third stage decides whether a constraint check should be a precondition or a postcondition of the transaction. The advantages of this method are: (1) It applies to any transaction language. In particular, the language may have loops and other control statements. (2) It is fast. Instead of a general purpose theorem prover, rapidly accessed rules are used to evaluate the constraints at compile-time. The rules are sound but not complete. A prototype implementation indicates a speed up of 50 over a theorem prover based method. (3) It builds constraint checks whose structure reveals why the check is needed. This helps the transaction designer understand why certain semantic integrity constraints are jeopardized by the transaction and may help to reveal design flaws in the transaction. (4) It is relatively easy to extend the method to incorporate new rules for the compile-time evaluation of constraints.

Application of a micro computer in investment decisions using dynamic programming

Abstract: Organizations and individuals are often faced with the problem of allocation of limited resources to a number of competing projects. The tendency in the past has been towards the use of cost-benefit analysis which is unsuitable for handling indivisible projects or ventures. The acceptance of much more appropriate mathematical programming techniques such as dynamic programming has been slow due to their relative computational difficulty. This paper presents an interactive microcomputer program, MAXRETURN, applicable to all types of projects, indivisible or otherwise, using dynamic programming techniques. It does not require the user to have prior knowledge of dynamic programming or optimization techniques. Use of the program is illustrated with an example.

Prolog: A programming language for fifth-generation computing

Abstract: A description is given of Prolog, a contraction of PROgramming in LOGic, which uses the formalism of mathematical logic as its primary design principle. The structure of Prolog is examined, and a database program is described to illustrate its application. An application to an artificial intelligence problem, the Towers of Hanoi, is also given.

A rule based computer aided design system

Abstract: A Computer Aided Design (CAD) system is presented which supports the iterative process of design, the dimensional continuity between mating parts, and the hierarchical structure of the parts in their assembled configuration. Prolog, an interactive logic programming language, is used to represent and interpret the data base. The solid geometry representing the parts is defined in parameterized form using the swept volume method. The system is demonstrated with a design of a spring piston.

Logic Programming '85 : proceedings of the 4th Conference, Tokyo, Japan, July 1-3, 1985

Abstract: Architecture and evaluation of a Reduction-based Parallel Inference Machine : PIM-R.- Hardware simulator of Reduction-Based Parallel Inference Machine PIM-R.- A note on the elementary execution unit in a parallel inference machine.- Parallel Prolog machine PARK: Its hardware structure and prolog system.- Heuristics applied in tree manipulation algorithm synthesis.- Analogical reasoning using transformations of rules.- Synchronization and communication in the 'subject'.- Zero : Frame + prolog.- PRESET - A debugging environment for Prolog.- Proedit - a screen oriented Prolog programming environment.- Software prototyping with MENDEL.- Retrieval of software module functions using first-order predicate logical formulae.- Temporal logic programming language Tokio programming in Tokio.- Implementation of temporal logic programming language Tokio.- Heuristic prolog: Logic program execution by heuristic search.- And-or queuing in Extended Concurrent Prolog.- Guarded horn clauses.- TDProlog: An extended Prolog with term description.- Design and evaluation of a Prolog compiler.- The program characteristics in logic programming language ESP.- Extended Prolog and its application to an integrated parser for text understanding.- A travel consultation system: Towards a smooth conversation in Japanese.- A Prolog-based Korean-English Machine Translation System and its efficient method of dictionary management.- Using the temporal logic programming language Tokio for algorithm description and automatic CMOS gate array synthesis.- A parallel logic simulator based on Concurrent Prolog.- A method of representing processes in a constraint solver.- KRIP: A knowledge representation system for laws relating to industrial property.- Consultation system for diagnosis of headache and facial pain: "Rhinos".- Knowledge realization and transformation in KRISP.