We describe a novel logic, called HiLog, and show that it provides a more suitable basis for logic programming than does traditional predicate logic. HiLog has a higher-order syntax and allows arbitrary terms to appear in places where predicates, functions and atomic formulas occur in predicate calculus. But its semantics is first-order and admits a sound and complete proof procedure. Applications of HiLog are discussed, including DCG grammars, higher-order and modular logic programming, and deductive databases.

We present a variant of Proof-Carrying Code (PCC) in which the trusted inference rules are represented as a higherorder logic program, the proof checker is replaced by a nondeterministic higher-order logic interpreter and the proof by an oracle implemented as a stream of bits that resolve the nondeterministic interpretation choices. In this setting, Proof-Carrying Code allows the receiver of the code the luxury of using nondeterminism in constructing a simple yet powerful checking procedure. This oracle-based variant of PCC is able to adapt quite naturally to situations when the property being checked is simple or there is a fairly directed search procedure for it. As an example, we demonstrate that if PCC is used to verify type safety of assembly language programs compiled from Java source programs, the oracles that are needed are on the average just 12% of the size of the code, which represents an improvement of a factor of 30 over previous syntactic representations of PCC proofs. ...

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 non-determinism, 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 paper 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 paper 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

Unnecessary backtracking is a principal source of inefficiency in Prolog execution. In order to avoid the overhead of the general backtracking mechanism, determinate programs should be executed deterministically. Achieving this requires an automatic means of extracting determinacy. We present a method in which determinacy is inferred from the success conditions and the calling contexts of predicates. Unlike previous approaches that rely on cuts or use a limited notion of test predicates, we propagate the conditions to detect determinacy, enabling us to handle a much larger class of programs. Since the conditions are propagated explicitly, the power of the method can be readily increased by increasing the expressiveness of these conditions. Moreover, our approach provides a uniform treatment of calling contexts and success conditions, and clearly spells out their roles in inferring determinacy. We also describe how determinacy information can be combined with state-of-the-art indexing t...

The efficiency of resolution-based logic programming languages, such as Prolog, depends critically on selecting and executing sets of applicable clause heads to resolve against subgoals. Traditional approaches to this problem have focused on using indexing to determine the smallest possible applicable set. Despite their usefulness, these approaches ignore the non-determinism inherent in many programming languages to the extent that they do not attempt to optimize execution after the applicable set has been determined. Unification factoring seeks to rectify this omission by regarding the indexing and unification phases of clause resolution as a single process. This paper formalizes that process through the construction of factoring automata. A polynomial-time algorithm is given for constructing optimal factoring automata which preserve the clause selection strategy of Prolog. More generally, when the clause selection strategy is not fixed, constructing an optimal automaton is shown to b...

Abstract not found

Devices]: Models of Computation---automata; F.2.2 [Analysis of Algorithms and Problem Complexity]: Nonnumerical Algorithms and Problems---pattern matching General Terms: Algorithms, Languages, Theory Additional Key Words and Phrases: Indexing, logic programming, trie minimization, unification 1. INTRODUCTION In logic programming languages, such as Prolog, a predicate is defined by a sequence of Horn clauses. A clause becomes applicable for resolution if its head unifies with a selected goal; and each applicable clause is invoked in textual order. Unification of a clause head with a goal involves two basic types of operations: elementary match operations and substitution operations for variables in the two A preliminary version of this article was presented at POPL '95. This work was supported in part by NSF grants CCR-9102159, CCR-9102989, CCR-9404921, CDA-9303181, CDA-9504275, INT-9314412, and ONR grant 400X116YIP01. Authors' addresses: S. Dawson, Computer Science Laboratory, SRI In...

Proof-Carrying Code (PCC) is a general mechanism for verifying that a code fragment can be executed safely on a host system. The key technical detail that makes PCC simple yet very powerful is that the code fragment is required to be accompanied by a detailed and precise explanation of how it satisfies the safety policy. This leaves the code receiver with the simple task of verifying that the explanation is correct and that it matches the code in question. Previous implementations of PCC used safety explanations in the form of explicit formal proofs of code safety, thus gaining leverage from a substantial amount of previous research in the area of proof representation and checking, but at the expense of poor scalability due to large proof sizes. In this paper we describe a series of changes that are necessary to achieve a truly scalable architecture for PCC. These include a new proof representation form along with a better integration of the various components of a PCC c...

: We derive a compiler for ML-style pattern matches. It is conceptually simple and produces reasonably good compiled matches. The derivation is inspired by the instrumentation and partial evaluation of naive string matchers. Following that paradigm, we first present a general and naive ML pattern matcher, instrument it to collect and exploit extra information, and show that partial evaluation of the instrumented general matcher with respect to a given match produces an efficient specialized matcher. We then discard the partial evaluator and show that a match compiler can be obtained just by slightly modifying the instrumented general matcher. The resulting match compiler is interesting in its own right, and naturally detects inexhaustive matches and redundant match rules. 1 Introduction Consel and Danvy [3] studied a general string matcher, taking two inputs: a pattern string to look for, and an object string to look in. The matcher finds the first occurrence (if any) of the pattern ...

While clause resolution is central to logic programming, practical efforts to optimize resolution have largely concerned efficient clause indexing. One recent exception is Unification Factoring [5], which optimizes backtracking through clause heads of a predicate. Now we consider the problem of optimizing clause resolution in a more general setting than Unification Factoring. One fundamental change is to use mode information to distinguish between elementary matching and unification operations that arise in unifying a term. In addition, we expand the traditional notion of clause resolution to allow for tabled predicates. The result is that our optimization technique becomes relevant for both top-down and bottom-up evaluations. Our technique uses Clause Resolution Automata (CRA), to model clause resolution in this expanded setting. The CRAs enable us to succinctly capture the cost of resolution. Furthermore, they can be readily implemented as a source transformation. After formally deve...