Extended Logic Programs Research Articles

CAL: A theoretical background of constraint logic programming and its applications

Constraint logic programming (CLP) is an extension of logic programming by introducing the facility of writing and solving constraints in a certain domain. CAL (Contrainte avec Logique) is a CLP language in which (possibly non-linear) polynomial equations can be written as constraints, while almost all the other CLP languages proposed so far have concentrated only on linear equations and inequations. This paper describes a general semantics of CLP including CAL, and shows the validity of CAL in this framework.

A logico-algebraic approach to the model theory of knowledge

In this paper we combine concepts from algebraic semantics and first-order logic programming in order to build an extended logic programming framework. This framework is applied to obtain a computational formalization of the model theory of knowledge of McCarthy et al. (1978).

FRIL: A Support Logic Programming System

FRIL: A Support Logic Programming System is principally an extension of Prolog designed to facilitate the modelling of uncertainty in applications which are suitable for Prolog and need to allow for probabilistic, evidential or vague reasoning. This review was carried out on an Amstrad 1640HD. The product runs on IBM PC, XT, AT and PS/2 computers and compatibles running MS‐DOS 3.0 or higher, with 640 Kb RAM. It also runs on a variety of workstations and minicomputers such as the Sun and VAX range. Prices of currently available versions are as follows: PC single user: £495 PC single user with expanded memory (2 Mb): £995 PC networks (up to ten PCs): £1495 SUN, Apollo HP300 workstations: £2500 MicroVax and VAX workstations (UNIX or VMS): £5000 VAX 11/730, 11/750, 11/780 (UNIX or VMS): £6000. The product is available from FRIL Systems Ltd, Bristol ITeC, St Anne's House, St Anne's Road, Bristol BS4 4AB, England. Telephone: (0272) 713481. FRIL Systems launched version 4.0 of FRIL in late 1988.

CS-PROLOG on multitransputer systems

This paper presents a concurrent extension of prolog called cs-prolog ∗ ∗ cs-prolog is a joint development between Multilogic Computing Ltd, Brainware Gmbh and Densitron Computers (Communicating Sequential prolog) which explicitly involves the concept of communicating sequential processes and is intended to be implemented on distributed (nonshared memory) parallel computers, mainly on transputer networks. cs-prolog can also be considered as a distributed simulation language. First, an informal introduction to cs-prolog summarizes the main features of the language. The power of the language is illustrated by solving some simple problems. The scheduling principles of cs-prolog on single transputers and on multiple transputer systems are described in detail. The cs-prolog distributed backtracking algorithm is defined and the details of distributed implementation on multitransputer systems are explored. cs-prolog is currently available on monoputers and multiputers connected to PC-compatible hosts.

A prolog technology theorem prover: Implementation by an extended prolog compiler

A Prolog technology theorem prover (PTTP) is an extension of Prolog that is complete for the full first-order predicate calculus. It differs from Prolog in its use of unification with the occurs check for soundness, the model-elimination reduction rule that is added to Prolog inferences to make the inference system complete, and depth-first iterative-deepening search instead of unbounded depthfirst search to make the search strategy complete. A Prolog technology theorem prover has been implemented by an extended Prolog-to-LISP compiler that supports these additional features. It is capable of proving theorems in the full first-order predicate calculus at a rate of thousands of inferences per second.

Partial evaluation of metaprograms in a “multiple worlds” logic language

This paper describes a partial evaluation system specifically designed to be used as an automatic compilation tool for metaprograms in a KBMS (EPSILON) based on Prolog. EPSILON main underlying concepts are the extension of Prolog with theories (“multiple worlds”) and the use of metaprogramming as the basic technique to define new inference engines and tools. Our partial evaluator is oriented towards theories and metainterpreter specialization. Being designed to be used as an automatic compiler, it does not require declarations from the user to control the unfolding process. It handles full Prolog and provides also an elegant solution to the problem of the partial evaluation of incomplete and self-modifying programs, by exploiting the multiple worlds feature added to Prolog. EPSILON partial evaluation system turned out to be a very useful and powerful tool to combine the low cost and the flexibility of metaprogramming with the performance requirements of a practical knowledge based system.

Non-Horn clause logic programming without contrapositives

We present an extension of Prolog-style Horn clause logic programming to full first order logic. This extension has some advantages over other such extensions that have been proposed. We compare this method with the model elimination strategy which Stickel has recently implemented very efficiently, and with Loveland's extension of Prolog to near-Horn clauses. This new method is based on the author's “simplified problem reduction format” but permits a better control of the splitting rule than does the simplified problem reduction format. In contrast to model elimination, this new method does not require the use of contrapositives of clauses, permitting a better control of the search. This method has been implemented in C Prolog and has turned out to be a respectable and surprisingly compact first-order theorem prover. This implementation uses depth-first iterative deepening and caching of answers to avoid repeated solution of the same subgoal. We show that the time and space used by this method are polynomial functions of certain natural parameters of the search space, unlike other known methods. We discuss the relation of these upper bounds to Savitch's theorem relating nondeterministic time to deterministic space.

A constraint approach to mastermind in logic programming

Logic programming is a convenient tool for stating combinatorial problems due to its nondeterminism and its relational form. It is not surprising that simple and declarative programs can be written for problems like mastermind. However, due to their search strategy, logic languages are also very inefficient for solving the natural formulation of problems. Moving away from this natural formulation leads to much programming effort and to less modifable and extensible programs. This paper shows, on the mastermind example, that it is possible to write very declarative programs which will be executed efficiently by an extended logic programming language. The key idea is to embed consistency techniques inside logic programming. Within this approach, constraints are used actively to prune the search space in an "a priori" way instead of the passive way (for testing values) of usual languages. The resulting program outperforms all the proposed algorithms and achieves a speed-up of 40 over Shapiro's program in the average and a speed-up of 72 on Powers' benchmark.

Semantically extended logic programming environment for CAD/CAPP applications: Vesselin I. KirovINTERPROGRAMA Software R & D Institute, Sofia, Bulgaria

Semantically extended logic programming environment for CAD/CAPP applications: Vesselin I. KirovINTERPROGRAMA Software R & D Institute, Sofia, Bulgaria

Computationally extended logic programming

In this paper we describe some novel features that have been introduced into a logic programming language. These include: (1) an increased level of clause expressiveness through the introduction of constructors for addition and multiplication, resulting in a system capable of being programmed to solve systems of linear equations; and (2) a search that produces a stream of bindings, permitting a higher degree of user interaction. The new language, referred to as CELP (computationally extended logic programming) has been implemented in Scheme, a dialect of Lisp. The version Scheme 84, developed at Indiana University and written in Franz Lisp, was used as the source language for our system.

MOLOG: A system that extends PROLOG with modal logic

In this paper we present an extension of PROLOG using modal logic. A new deduction method is also given based on a rule closer to the classical inference rule of PROLOG.

N-Prolog: An extension of prolog with hypothetical implication. II. Logical foundations, and negation as failure

We shall see that success in the N-PROLOG computation of a goal G from the database P means logically that P h G in intuitionistic logic. We will also introduce an additional computational rule called the restart rule (allowing one to replace, at any time of the computation, the current goal by the original goal). Success of an onginal goal G from a database P through a computation in N-PROLOG with the restart rule means that P IG in classical logic. The restart rule can be modified to yield many logics intermediate between classical and intuitionistic logic. In my lecture notes [1], I use these ideas to present classical logic procedurally, in a PROLOG-hke way. My paper with K. Broda and F. Kriwaczek [2] describes a theorem prover based on these ideas and compares this theorem prover with SL resolution and other forms of resolution. Modal and temporal logics can also be represented in N-PROLOG in certain ways, and especially appUed to database deletion, temporal updating, and management. This will be dealt with in paper III of this series.

Meta-level programming and knowledge representation

The nature of a metalevel extension of Prolog is outlined. The key features include the treatment of theories (databases) and metalevel names as first-class objects which may be the values of variables. The use of the power of these constructs in traditional knowledge representation is explored. In particular, it is shown how frames, semantic nets, scripts, message passing, and non-standard control can be represented.

A Prolog technology theorem prover

An extension of Prolog, based on the model elimination theorem-proving procedure, would permit production of a logically complete Prolog technology theorem prover capable of performing inference operations at a rate approaching that of Prolog itself.

N-Prolog: An extension of Prolog with hypothetical implications. I.

An extension of PROLOG called N-PROLOG is presented. N-PROLOG allows hypothetical implications in the clauses. For clauses without implication, N-PROLOG acts like PROLOG. Examples are given to show the need for N-PROLOG. N-PROLOG is a self-reflecting language; it is equal to its own metalanguage. N-PROLOG is more suitable for expressing temporal behavior (change in time). Ordinary PROLOG is conceptually weaker than N-PROLOG.

A prolog extension for handling negative knowledge

Pure prolog has certain defects as a programming language. To resolve such problems, some extensions of prolog which go beyond horn logic, or alternatively, some non-logical mechanisms need to be introduced. Non-logical mechanisms, however, often do not work as the programmer expects.