Results 1  10
of
100
Uniform proofs as a foundation for logic programming
 ANNALS OF PURE AND APPLIED LOGIC
, 1991
"... A prooftheoretic characterization of logical languages that form suitable bases for Prologlike programming languages is provided. This characterization is based on the principle that the declarative meaning of a logic program, provided by provability in a logical system, should coincide with its ..."
Abstract

Cited by 375 (109 self)
 Add to MetaCart
A prooftheoretic characterization of logical languages that form suitable bases for Prologlike programming languages is provided. This characterization is based on the principle that the declarative meaning of a logic program, provided by provability in a logical system, should coincide with its operational meaning, provided by interpreting logical connectives as simple and fixed search instructions. The operational semantics is formalized by the identification of a class of cutfree sequent proofs called uniform proofs. A uniform proof is one that can be found by a goaldirected search that respects the interpretation of the logical connectives as search instructions. The concept of a uniform proof is used to define the notion of an abstract logic programming language, and it is shown that firstorder and higherorder Horn clauses with classical provability are examples of such a language. Horn clauses are then generalized to hereditary Harrop formulas and it is shown that firstorder and higherorder versions of this new class of formulas are also abstract logic programming languages if the inference rules are those of either intuitionistic or minimal logic. The programming language significance of the various generalizations to firstorder Horn clauses is briefly discussed.
Logic Programming in a Fragment of Intuitionistic Linear Logic
"... When logic programming is based on the proof theory of intuitionistic logic, it is natural to allow implications in goals and in the bodies of clauses. Attempting to prove a goal of the form D ⊃ G from the context (set of formulas) Γ leads to an attempt to prove the goal G in the extended context Γ ..."
Abstract

Cited by 302 (39 self)
 Add to MetaCart
When logic programming is based on the proof theory of intuitionistic logic, it is natural to allow implications in goals and in the bodies of clauses. Attempting to prove a goal of the form D ⊃ G from the context (set of formulas) Γ leads to an attempt to prove the goal G in the extended context Γ ∪ {D}. Thus during the bottomup search for a cutfree proof contexts, represented as the lefthand side of intuitionistic sequents, grow as stacks. While such an intuitionistic notion of context provides for elegant specifications of many computations, contexts can be made more expressive and flexible if they are based on linear logic. After presenting two equivalent formulations of a fragment of linear logic, we show that the fragment has a goaldirected interpretation, thereby partially justifying calling it a logic programming language. Logic programs based on the intuitionistic theory of hereditary Harrop formulas can be modularly embedded into this linear logic setting. Programming examples taken from theorem proving, natural language parsing, and data base programming are presented: each example requires a linear, rather than intuitionistic, notion of context to be modeled adequately. An interpreter for this logic programming language must address the problem of splitting contexts; that is, when attempting to prove a multiplicative conjunction (tensor), say G1 ⊗ G2, from the context ∆, the latter must be split into disjoint contexts ∆1 and ∆2 for which G1 follows from ∆1 and G2 follows from ∆2. Since there is an exponential number of such splits, it is important to delay the choice of a split as much as possible. A mechanism for the lazy splitting of contexts is presented based on viewing proof search as a process that takes a context, consumes part of it, and returns the rest (to be consumed elsewhere). In addition, we use collections of Kripke interpretations indexed by a commutative monoid to provide models for this logic programming language and show that logic programs admit a canonical model.
A logic programming language with lambdaabstraction, function variables, and simple unification
 Extensions of Logic Programming. Springer Lecture Notes in Artificial Intelligence
, 1990
"... A meta programming language must be able to represent and manipulate such syntactic structures as programs, formulas, types, and proofs. A common characteristic of all these structures is that they involve notions of abstractions, scope, bound and free variables, substitution instances, and equality ..."
Abstract

Cited by 287 (25 self)
 Add to MetaCart
A meta programming language must be able to represent and manipulate such syntactic structures as programs, formulas, types, and proofs. A common characteristic of all these structures is that they involve notions of abstractions, scope, bound and free variables, substitution instances, and equality up to alphabetic changes of bound variables.
Logic Programming in the LF Logical Framework
, 1991
"... this paper we describe Elf, a metalanguage intended for environments dealing with deductive systems represented in LF. While this paper is intended to include a full description of the Elf core language, we only state, but do not prove here the most important theorems regarding the basic building b ..."
Abstract

Cited by 175 (50 self)
 Add to MetaCart
this paper we describe Elf, a metalanguage intended for environments dealing with deductive systems represented in LF. While this paper is intended to include a full description of the Elf core language, we only state, but do not prove here the most important theorems regarding the basic building blocks of Elf. These proofs are left to a future paper. A preliminary account of Elf can be found in [26]. The range of applications of Elf includes theorem proving and proof transformation in various logics, definition and execution of structured operational and natural semantics for programming languages, type checking and type inference, etc. The basic idea behind Elf is to unify logic definition (in the style of LF) with logic programming (in the style of Prolog, see [22, 24]). It achieves this unification by giving types an operational interpretation, much the same way that Prolog gives certain formulas (Hornclauses) an operational interpretation. An alternative approach to logic programming in LF has been developed independently by Pym [28]. Here are some of the salient characteristics of our unified approach to logic definition and metaprogramming. First of all, the Elf search process automatically constructs terms that can represent objectlogic proofs, and thus a program need not construct them explicitly. This is in contrast to logic programming languages where executing a logic program corresponds to theorem proving in a metalogic, but a metaproof is never constructed or used and it is solely the programmer's responsibility to construct objectlogic proofs where they are needed. Secondly, the partial correctness of many metaprograms with respect to a given logic can be expressed and proved by Elf itself (see the example in Section 5). This creates the possibilit...
Higherorder logic programming
 HANDBOOK OF LOGIC IN AI AND LOGIC PROGRAMMING, VOLUME 5: LOGIC PROGRAMMING. OXFORD (1998
"... ..."
Unification under a mixed prefix
 Journal of Symbolic Computation
, 1992
"... Unification problems are identified with conjunctions of equations between simply typed λterms where free variables in the equations can be universally or existentially quantified. Two schemes for simplifying quantifier alternation, called Skolemization and raising (a dual of Skolemization), are pr ..."
Abstract

Cited by 123 (13 self)
 Add to MetaCart
Unification problems are identified with conjunctions of equations between simply typed λterms where free variables in the equations can be universally or existentially quantified. Two schemes for simplifying quantifier alternation, called Skolemization and raising (a dual of Skolemization), are presented. In this setting where variables of functional type can be quantified and not all types contain closed terms, the naive generalization of firstorder Skolemization has several technical problems that are addressed. The method of searching for preunifiers described by Huet is easily extended to the mixed prefix setting, although solving flexibleflexible unification problems is undecidable since types may be empty. Unification problems may have numerous incomparable unifiers. Occasionally, unifiers share common factors and several of these are presented. Various optimizations on the general unification search problem are as discussed. 1.
Lexical scoping as universal quantification
 In Sixth International Logic Programming Conference
, 1989
"... Abstract: A universally quantified goal can be interpreted intensionally, that is, the goal ∀x.G(x) succeeds if for some new constant c, the goal G(c) succeeds. The constant c is, in a sense, given a scope: it is introduced to solve this goal and is “discharged ” after the goal succeeds or fails. Th ..."
Abstract

Cited by 65 (18 self)
 Add to MetaCart
Abstract: A universally quantified goal can be interpreted intensionally, that is, the goal ∀x.G(x) succeeds if for some new constant c, the goal G(c) succeeds. The constant c is, in a sense, given a scope: it is introduced to solve this goal and is “discharged ” after the goal succeeds or fails. This interpretation is similar to the interpretation of implicational goals: the goal D ⊃ G should succeed if when D is assumed, the goal G succeeds. The assumption D is discharged after G succeeds or fails. An interpreter for a logic programming language containing both universal quantifiers and implications in goals and the body of clauses is described. In its nondeterministic form, this interpreter is sound and complete for intuitionistic logic. Universal quantification can provide lexical scoping of individual, function, and predicate constants. Several examples are presented to show how such scoping can be used to provide a Prologlike language with facilities data types, and encapsulation of state.
HigherOrder Horn Clauses
 JOURNAL OF THE ACM
, 1990
"... A generalization of Horn clauses to a higherorder logic is described and examined as a basis for logic programming. In qualitative terms, these higherorder Horn clauses are obtained from the firstorder ones by replacing firstorder terms with simply typed #terms and by permitting quantification ..."
Abstract

Cited by 61 (20 self)
 Add to MetaCart
A generalization of Horn clauses to a higherorder logic is described and examined as a basis for logic programming. In qualitative terms, these higherorder Horn clauses are obtained from the firstorder ones by replacing firstorder terms with simply typed #terms and by permitting quantification over all occurrences of function symbols and some occurrences of predicate symbols. Several prooftheoretic results concerning these extended clauses are presented. One result shows that although the substitutions for predicate variables can be quite complex in general, the substitutions necessary in the context of higherorder Horn clauses are tightly constrained. This observation is used to show that these higherorder formulas can specify computations in a fashion similar to firstorder Horn clauses. A complete theorem proving procedure is also described for the extension. This procedure is obtained by interweaving higherorder unification with backchaining and goal reductions, and constitutes a higherorder generalization of SLDresolution. These results have a practical realization in the higherorder logic programming language called λProlog.
From operational semantics to abstract machines
 Mathematical Structures in Computer Science
, 1992
"... We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediatelevel specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctnesspreserving t ..."
Abstract

Cited by 58 (5 self)
 Add to MetaCart
We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediatelevel specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctnesspreserving transformations to operational semantics until the resulting specifications have the form of abstract machines. Though not automatable in general, this approach to constructing machine implementations can be mechanized, providing machineverified correctness proofs. As examples we present the transformation of specifications for both callbyname and callbyvalue evaluation of the untyped λcalculus into abstract machines that implement such evaluation strategies. We also present extensions to the callbyvalue machine for a language containing constructs for recursion, conditionals, concrete data types, and builtin functions. In all cases, the correctness of the derived abstract machines follows from the (generally transparent) correctness of the initial operational semantic specification and the correctness of the transformations applied. 1.
Unification of simply typed lambdaterms as logic programming
 In Eighth International Logic Programming Conference
, 1991
"... The unification of simply typed λterms modulo the rules of β and ηconversions is often called “higherorder ” unification because of the possible presence of variables of functional type. This kind of unification is undecidable in general and if unifiers exist, most general unifiers may not exist ..."
Abstract

Cited by 56 (3 self)
 Add to MetaCart
The unification of simply typed λterms modulo the rules of β and ηconversions is often called “higherorder ” unification because of the possible presence of variables of functional type. This kind of unification is undecidable in general and if unifiers exist, most general unifiers may not exist. In this paper, we show that such unification problems can be coded as a query of the logic programming language Lλ in a natural and clear fashion. In a sense, the translation only involves explicitly axiomatizing in Lλ the notions of equality and substitution of the simply typed λcalculus: the rest of the unification process can be viewed as simply an interpreter of Lλ searching for proofs using those axioms. 1