Execution Of Logic Programs Research Articles

Вбудування сімейства логічних мов із можливостями перепрограмування монадичної уніфікації в SCALA

The paper proposes a framework for embedding logic programming and constraint programming methods in Scala by building a logical object-oriented language around the unification of typed logic based on monads. Two types of API are considered — high-level for language embeddings and low-level for organization of the bidirectional flow of data during the execution of logic programs. Differences in the capabilities of logical mechanisms can be expressed as subclasses of the class of unification monad types. This design makes it possible to share the implementation of custom unification between different frameworks and to use other languages’ embeddings in Scala from the declarative side. The monadic API provides the application developer with a simple and intuitive tool to implement custom logic within the unification. Our frameworks provide a clear representation of logical deduction: Scala code is only used for ad hoc unification. But the overall goal execution is an external interpretation that can implement different strategies. This design provides modularity and good integration with the rest of the ecosystem.

Engineering domain-specific languages with formula 2.0

Domain-specific languages (DSLs) are useful for capturing and reusing engineering expertise. They can formalize industrial patterns and practices while increasing the scalability of verification, because input programs are written at a higher level of abstraction. However, engineering new DSLs with custom verification is a non-trivial task in its own right, and usually requires programming language, formal methods, and automated theorem proving expertise. In this tutorial we present FORMULA 2.0, which is formal framework for developing DSLs. FORMULA specifications are succinct descriptions of DSLs, and specifications can be immediately connected to state-of-the-art analysis engines without additional expertise. FORMULA provides: (1) succinct specifications of DSLs and compilers, (2) efficient compilation and execution of input programs, (3) program synthesis and compiler verification. We take a unique approach to provide these features: Specifications are written as strongly-typed open-world logic programs. These specifications are highly declarative and easily express rich synthesis / verification problems. Automated reasoning is enabled by efficient symbolic execution of logic programs into quantifier-free sub-problems, which are dispatched to the state-of-the-art SMT solver Z3. FORMULA has been applied within Microsoft to develop DSLs for verifiable device drivers and protocols. It has been used by the automotive / embedded systems industries for software / hardware co-design and design-space exploration under hard resource allocation constraints. It is being used to develop semantic specifications for complex cyber-physical systems.

PAN: A portable, parallel Prolog: Its design, realisation and performance

PAN is a general purpose, portable environment for executing logic programs in parallel. It combines a flexible, distributed architecture which is resilient to software and platform evolution with facilities for automatically extracting and exploiting AND and OR parallelism in ordinary Prolog programs. PAN incorporates a range of compile-time and run-time techniques to deliver the performance benefits of parallel execution while retaining sequential execution semantics. Several examples illustrate the efficiency of the controls that facilitate the execution of logic programs in a distributed manner and identify the class of applications that benefit from distributed platforms like PAN.

Parallel execution of prolog programs

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

Termination of Simply-Moded Well-Typed Logic Programs under a Tabled Execution Mechanism

Tabled logic programming is receiving increasing attention in the Logic Programming community. It avoids many of the shortcomings of SLD(NF) execution and provides a more flexible and often extremely efficient execution mechanism for logic programs. In particular, tabled execution of logic programs terminates more often than execution based on SLD-resolution. So, if a program can be proven to terminate under SLD-resolution, then the program will trivially also terminate under SLG-resolution, the resolution principle of tabling. But, since there are SLG-terminating programs which are not SLD-terminating, more effective proof techniques can be found. One of the few approaches studying termination of tabled logic programs was developed by Decorte et al. They present necessary and sufficient conditions for two notions of termination under LG-resolution, i.e. SLG-resolution with left-to-right selection rule: quasi-termination and (the stronger notion of) LG-termination. Starting from these necessary and sufficient conditions, we introduce sufficient conditions for quasi-termination and LG-termination which are stated fully at the clause level and are easy to automatize. To this end, we use mode and type information: we consider simply-moded, well-typed programs and queries. We point out how our termination conditions can be automatized, by extending the recently developed, constraint-based, automatic termination analysis for SLD-resolution of Decorte and De Schreye. Finally, we present a result on substitution-closedness of quasi-termination and LG-termination for the class of simply-moded, well-typed programs and queries.

On the complexity of or-parallelism

We formalize the implementation mechanisms required to support or-parallel execution of logic programs in terms of operations on dynamic data structures. Upper and lower bounds are derived, in terms of the number of operationsn performed on the data structure, for the problem of guaranteeing correct semantics during or-parallel execution. The lower bound Ω(lgn) formally proves the impossibility of achieving an ideal implementation (i.e., parallel implementation with constant time overhead per operation). We also derive an upper bound of $$\tilde O\left( {\sqrt[3]{n}} \right)$$ per operation for or-parallel execution. This upper bound is far better than what has been achieved in the existing or-parallel systems and indicates that faster implementations may be feasible.

OASys: An AND/OR parallel logic programming system

The OASys (Or/And SYStem) is a software implementation designed for AND/OR-parallel execution of logic programs. In order to combine these two types of parallelism, OASys considers each alternative path as a totally independent computation (leading to OR-parallelism) which consists of a conjunction of determinate subgoals (leading to AND-parallelism). This computation model is motivated by the need for the elimination of communication between processing elements (PEs). OASys aims towards a distributed memory architecture in which the PEs performing the OR-parallel computation possess their own address space while other simple processing units are assigned with AND-parallel computation and share the same address space. OASys execution is based on distributed scheduling which allows either recomputation of paths or environment copying. We discuss in detail the OASys execution scheme and we demonstrate OASys effectiveness by presenting the results obtained by a prototype implementation, running on a network of workstations. The results show that speedup obtained by AND/OR-parallelism is greater than the speedups obtained by exploiting AND or OR-parallelism alone. In addition, comparative performance measurements show that copying has a minor advantage over recomputation.

Polytypic unification

Unification, or two-way pattern matching, is the process of solving an equation involving two first-order terms with variables. Unification is used in type inference in many programming languages and in the execution of logic programs. This means that unification algorithms have to be written over and over again for different term types. Many other functions also make sense for a large class of datatypes; examples are pretty printers, equality checks, maps etc. They can be defined by induction on the structure of user-defined datatypes. Implementations of these functions for different datatypes are closely related to the structure of the datatypes. We call such functions polytypic. This paper describes a unification algorithm parametrised on the type of the terms, and shows how to use polytypism to obtain a unification algorithm that works for all regular term types.

Massively parallel execution of logic programs: A static approach

A static model for the parallel execution of logic programs on MIMD distributed memory systems is presented where a refutation is implemented through a process network returned by the compilation of the logic program. The model supports Restricted-AND, OR and stream parallelism and it is integrated with a set of static analyses to optimise the process network. Altogether, the processes interact according to a static data driven model with medium grain operators. Data flowing in the network is tagged to distinguish bindings belonging to the same refutation. A scheduling strategy to integrate low level scheduling and message flow control has been defined. Performance figures are presented.

Parallel execution of logic programs by load sharing

Execution of a logic program can be sped up by load sharing among a group of interconnected processors. Network contention and load imbalance are two potentially limiting factors that must be dealt with carefully. In this paper, we discuss a task scheduling scheme in which processors share the workload by voluntarily following a universal task distribution rule. Communication is reduced by having processors cooperate without frequent exchange of information. However, load balancing is rendered more difficult. We propose solutions to the problem by altering the shape of a search space to remove the so-called structural imbalance, and by following a statistically even task distribution rule. Simulation and experimental data indicate that the method is effective for a number of programs for which existing scheduling methods tend to generate overly fine-grained tasks that lead to heavy traffic in the network. Speed-up factors by the proposed technique are comparable to, or better than, that by a typical system which relies solely on dynamic task migration to balance the workload. The scheme appears to be particularly suitable for implementation on loosely coupled parallel platforms.

Path for AND-parallel execution of logic programs

An efficient backward execution method for AND-parallelism in logic programs is proposed. It is devised through a close examination of some relation over literals, which can be represented by paths in the data dependency graphs. The scheme is more efficient than other works in the sense that it performs less unfruitful resetting (and consequently, canceling) operations. Its rationale is also intuitively clear and natural. Furthermore, the relevant analyses needed for the proposal are largely achieved at compile time, which alludes to actual efficiency.

A review of exploitation of AND-parallelism and combined AND/OR-parallelism in logic programs

Logic programs provide many opportunities for parallel execution. Among different forms of parallelism found in logic programs, AND-parallelism and OR-parallelism have shown to be most effective in speeding up the execution of logic programs. This paper offers a review of major activities in exploiting AND-parallelism and combined AND/OR-parallelism. Full version of this paper (23 pages) can be retrieved through anonymous ftp from ftp.mpce.mq.edu.au.

Machine independent AND and OR parallel execution of logic programs. II. Compiled execution

For pt.I. see ibid., p. 170-80. In pt.I, we presented a binding environment for the AND and OR parallel execution of logic programs. This environment was instrumental in rendering a compiler for the AND and OR parallel execution of logic programs machine independent. In this paper, we describe a compiler based on the Reduce-OR process model (ROPM) for the parallel execution of Prolog programs, and provide performance of the compiler on five parallel machines: the Encore Multimax, the Sequent Symmetry, the NCUBE 2, the Intel i860 hypercube and a network of Sun workstations. The compiler is part of a machine independent parallel Prolog development system built on top of a run time environment for parallel programming called the Chare kernel, and runs unchanged on these multiprocessors. In keeping with the objectives behind the ROPM, the compiler supports both on and independent AND parallelism in Prolog programs and is suitable for execution on both shared and nonshared memory machines. We discuss the performance of the Prolog compiler in some detail and describe how grain size can be used to deliver performance that is within 10% of the underlying sequential Prolog compiler on one processor, and scale linearly with increasing number of processors on problems exhibiting sufficient parallelism. The loose coupling between parallel and sequential components makes it possible to use the best available sequential compiler as the sequential component of our compiler.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Hierarchical representation of legal knowledge with metaprogramming in logic

We present an application of metaprogramming in logic that, unlike most metaprogramming applications, is not primarily concerned with controlling the execution of logic programs. Metalevel computation is used to define theories from schemata that were either given explicitly or obtained by abstraction from other theories. Our main application is a representation of legal knowledge in a metalogic programming language. We argue that legal knowledge is multilayered and therefore a single level representation language lacks the needed expressiveness. We show that legal rules can be partitioned into primary, secondary, tertiary, quaternary, and higher level rules. Our classification enables us to define a multilevel model of legal knowledge and a one-to-one correspondence with levels of metaprogramming in logic. We show that this framework has a potential for capturing important legal interpretation principles such as analogia legis, lex specialis legi generali derogat, etc. We have a running example from commercial law that utilizes rules up to the tertiary level, emphasizing analogia legis. The example is expressed in a multilevel metalogic programming language that provides a naming convention and employs reflection between levels.

Machine independent AND and OR parallel execution of logic programs. I. The binding environment

We describe a binding environment for the AND and OR parallel execution of logic programs that is suitable for both shared and nonshared memory multiprocessors. The binding environment was designed with a view of rendering a compiler using this binding environment machine independent. The binding environment is similar to closed environments proposed by J. Conery. However, unlike Conery's scheme, it supports OR and independent AND parallelism on both types of machines. The term representation, the algorithms for unification and the join algorithms for parallel AND branches are presented in this paper. We also detail the differences between our scheme and Conery's scheme. A compiler based on this binding environment has been implemented on a platform for machine independent parallel programming called the Chare Kernel.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

And—or parallelism on shared-memory multiprocessors

This paper presents an extended and—or tree and an extended WAM (Warren Abstract Machine) for efficiently supporting both and-parallel and or-parallel execution of logic programs on shared-memory multiprocessors. Our approach for exploiting both and- and or-parallelism is based on the binding-arrays method for or-parallelism and the RAP (Restricted And-Parallelism) method for and-parallelism, two succesful methods for implementing or-parallelism and and-parallelism, respectively. Our combined and—or model avoids redundant computations when goals exhibit both and- and or-parallelism, by representing the cross product of the solutions from the and—or parallel goals rather than recomputing them. We extend the classical and—or tree with two new nodes: a “sequential” node (for RAPs sequencial goals), and a “cross-product” node (for the cross product of solutions from and—or parallel goals). The paper also presents an extension of the WAM, called AO—WAM, which is used to compile logic programs for and—or parallel execution based on the extended and—or tree. The AO—WAM incorporates a number of novel features: (i) inclusion of a base array with each processor's binding array for constant-time access to variables in the presence of and-parallelism, (ii) inclusion of new stack frames and instructions to express solution sharing, and (iii) novel optimizations which minimize the cost of binding-array updates in the presence of and-parallelism.

Efficient bottom-up execution of logic programs using abstract interpretation

abstract universe of a program P is defined by Ufl = p(Ue). Abstract base Bff of a program P is defined by Atoms~'/~ where Atoms ~ = {p( tf , . . . , tff)[ p ~ Pred, {tA, . . . , tn A} C Uil}. The abstraction function aa : B e ~ Bff is de- fined by Ota(P(t a .... , tn)) = [p(p(t 1) ..... p(tn))]~, and can be extended to a~ :go(B e) ~ go(Bff) which is defined by aa(I) = {a~(A)[ A ~ I}. The corresponding concretization function 3'~ :go(Bff) ~ go(B e) is 3a(I ~') = ( A' ~ Be] A ~ ~ I ~¢, Ot a( A') =A~}. Lemma 8. ((go(Bp), ___), aa, (go(B~'), c_), 3a) is a Galois insertion. An abstract substitution is a substitution 0 A :V-)Uil where V is a set of variables. Given a substitution 0 = {tl/x a ..... tn/Xn}, Oto is defined by a~,(O) = 0 ~¢ = {p(ta)/Xp..., p(t,)/x,}. The abstract operator Til e approximates T e. Definition 9 [2]. Til : go(Bff) ~ go(Bff), C =A ,-'- B 1 .... ,B,, ~P, '~

Execution of logic programs by iterative-deepening A* SLD-tree search

The depth-first search strategy used by PROLOG is supplemented by depth-first iterative-deepening A*, which is complete, i.e. it always succeeds in executing a correct program if enough time and space is available. Iterative-deepening A* is only used for predicates that can be executed faster with iterative-deepening A* instead of depth-first.

And/Or parallel execution of logic programs

This paper proposes a new And/Or parallel execution model (FORDAP) for logic programs which can not only exploit full Or- and independent And-parallelism, but also can exploit dependent And-parallelism with a limited increment of runtime cost. A synchronization mechanism is constructed on a shared variable between its producer and its consumers and a consumer with a large granularity is decomposed further to let its subgoals independent to that producer to execute without delay. A granularity computation algorithm is presented for the control of a goal's decomposition.

Distributed last call optimization for portable parallel logic programming

A difficult but challenging problem is the efficient exploitation of AND and OR parallelism in logic programs without making any assumptions about the underlying target machine(s). In earlier papers, we described the design of a binding environment for AND and OR parallel execution of logic programs on shared and nonshared memory machines and the performance of a compiler (called ROLOG) using this binding environment on a range of MIMD parallel machines. In this paper, we present an important optimization for portable parallel logic programming, namely distributed last-call optimization , an analog of the tail recursion optimization for sequential Prolog. This scheme has been implemented in the ROLOG compiler, which ports unchanged on several shared memory and nonshared memory machines. We describe the effect of this optimization on several OR, AND/OR and AND parallel benchmark programs.