Results 11  20
of
233
Types for Modules
, 1998
"... The programming language Standard ML is an amalgam of two, largely orthogonal, languages. The Core language expresses details of algorithms and data structures. The Modules language expresses the modular architecture of a software system. Both languages are statically typed, with their static and dy ..."
Abstract

Cited by 69 (9 self)
 Add to MetaCart
The programming language Standard ML is an amalgam of two, largely orthogonal, languages. The Core language expresses details of algorithms and data structures. The Modules language expresses the modular architecture of a software system. Both languages are statically typed, with their static and dynamic semantics specified by a formal definition.
Efficient Representation and Validation of Proofs
, 1998
"... This paper presents a logical framework derived from the Edinburgh Logical Framework (LF) [5] that can be used to obtain compact representations of proofs and efficient proof checkers. These are essential ingredients of any application that manipulates proofs as firstclass objects, such as a Proof ..."
Abstract

Cited by 61 (7 self)
 Add to MetaCart
This paper presents a logical framework derived from the Edinburgh Logical Framework (LF) [5] that can be used to obtain compact representations of proofs and efficient proof checkers. These are essential ingredients of any application that manipulates proofs as firstclass objects, such as a ProofCarrying Code [11] system, in which proofs are used to allow the easy validation of properties of safetycritical or untrusted code. Our framework, which we call LF i , inherits from LF the capability to encode various logics in a natural way. In addition, the LF i framework allows proof representations without the high degree of redundancy that is characteristic of LF representations. The missing parts of LF i proof representations can be reconstructed during proof checking by an efficient reconstruction algorithm. We also describe an algorithm that can be used to strip the unnecessary parts of an LF representation of a proof. The experimental data that we gathered in the context of a Proof...
Unification and AntiUnification in the Calculus of Constructions
 In Sixth Annual IEEE Symposium on Logic in Computer Science
, 1991
"... We present algorithms for unification and antiunification in the Calculus of Constructions, where occurrences of free variables (the variables subject to instantiation) are restricted to higherorder patterns, a notion investigated for the simplytyped calculus by Miller. Most general unifiers and ..."
Abstract

Cited by 61 (15 self)
 Add to MetaCart
We present algorithms for unification and antiunification in the Calculus of Constructions, where occurrences of free variables (the variables subject to instantiation) are restricted to higherorder patterns, a notion investigated for the simplytyped calculus by Miller. Most general unifiers and least common antiinstances are shown to exist and are unique up to a simple equivalence. The unification algorithm is used for logic program execution and type and term reconstruction in the current implementation of Elf and has shown itself to be practical. The main application of the antiunification algorithm we have in mind is that of proof generalization. 1 Introduction Higherorder logic with an embedded simplytyped  calculus has been used as the basis for a number of theorem provers (for example [1, 19]) and the programming language Prolog [16]. Central to these systems is an implementation of Huet's preunification algorithm for the simplytyped calculus [12] which has shown it...
A Proof Theory for Generic Judgments
, 2003
"... this paper, we do this by adding the #quantifier: its role will be to declare variables to be new and of local scope. The syntax of the formula # x.B is like that for the universal and existential quantifiers. Following Church's Simple Theory of Types [Church 1940], formulas are given the type ..."
Abstract

Cited by 61 (14 self)
 Add to MetaCart
this paper, we do this by adding the #quantifier: its role will be to declare variables to be new and of local scope. The syntax of the formula # x.B is like that for the universal and existential quantifiers. Following Church's Simple Theory of Types [Church 1940], formulas are given the type o, and for all types # not containing o, # is a constant of type (# o) o. The expression # #x.B is ACM Transactions on Computational Logic, Vol. V, No. N, October 2003. 4 usually abbreviated as simply # x.B or as if the type information is either simple to infer or not important
System Description: Proof Planning in HigherOrder Logic with
 15th International Conference on Automated Deduction, volume 1421 of Lecture Notes in Artificial Intelligence
, 1998
"... Introduction Proof planning [4] is an approach to theorem proving which encodes heuristics for constructing mathematical proofs in a metatheory of methods. The Clam system, developed at Edinburgh [3], has been used for several years to develop proof planning, in particular proof plans for induction ..."
Abstract

Cited by 58 (8 self)
 Add to MetaCart
Introduction Proof planning [4] is an approach to theorem proving which encodes heuristics for constructing mathematical proofs in a metatheory of methods. The Clam system, developed at Edinburgh [3], has been used for several years to develop proof planning, in particular proof plans for induction. It has become clear that many of the theoremproving tasks that we would like to perform are naturally higherorder. For example, an important technique called middleout reasoning [6] uses metavariables to stand for some unknown objects in a proof, to be instantiated as the proof proceeds. Domains such as the synthesis and verification of software and hardware systems, and techniques such as proof critics [7], benefit greatly from such middleout reasoning. Since in these domains the metavariables often become instantiated with terms of function type, reasoning with them is naturally higherorder, and higherorder unification is a
Unification via Explicit Substitutions: The Case of HigherOrder Patterns
 PROCEEDINGS OF JICSLP'96
, 1998
"... In [6] we have proposed a general higherorder unification method using a theory of explicit substitutions and we have proved its completeness. In this paper, we investigate the case of higherorder patterns as introduced by Miller. We show that our general algorithm specializes in a very convenient ..."
Abstract

Cited by 56 (14 self)
 Add to MetaCart
In [6] we have proposed a general higherorder unification method using a theory of explicit substitutions and we have proved its completeness. In this paper, we investigate the case of higherorder patterns as introduced by Miller. We show that our general algorithm specializes in a very convenient way to patterns. We also sketch an efficient implementation of the abstract algorithm and its generalization to constraint simplification, which has yielded good experimental results at the core of a higherorder constraint logic programming language.
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
OracleBased Checking of Untrusted Software
, 2001
"... We present a variant of ProofCarrying Code (PCC) in which the trusted inference rules are represented as a higherorder logic program, the proof checker is replaced by a nondeterministic higherorder logic interpreter and the proof by an oracle implemented as a stream of bits that resolve the nondet ..."
Abstract

Cited by 55 (3 self)
 Add to MetaCart
We present a variant of ProofCarrying Code (PCC) in which the trusted inference rules are represented as a higherorder logic program, the proof checker is replaced by a nondeterministic higherorder logic interpreter and the proof by an oracle implemented as a stream of bits that resolve the nondeterministic interpretation choices. In this setting, ProofCarrying Code allows the receiver of the code the luxury of using nondeterminism in constructing a simple yet powerful checking procedure. This oraclebased 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. ...
Efficient resource management for linear logic proof search
 Proceedings of the 5th International Workshop on Extensions of Logic Programming
, 1996
"... The design of linear logic programming languages and theorem provers opens a number of new implementation challenges not present in more traditional logic languages such as Horn clauses (Prolog) and hereditary Harrop formulas (λProlog and Elf). Among these, the problem of efficiently managing the li ..."
Abstract

Cited by 54 (11 self)
 Add to MetaCart
The design of linear logic programming languages and theorem provers opens a number of new implementation challenges not present in more traditional logic languages such as Horn clauses (Prolog) and hereditary Harrop formulas (λProlog and Elf). Among these, the problem of efficiently managing the linear context when solving a goal is of crucial importance for the use of these systems in nontrivial applications. This paper studies this problem in the case of Lolli [HM94], though its results have application to other systems. We first give a prooftheoretic presentation of the operational semantics of this language as a resolution calculus. We then present a series of resource management systems designed to eliminate the nondeterminism in the distribution of linear formulas that undermines the efficiency of a direct implementation of this system. 1