Results 11  20
of
316
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 ..."
Abstract

Cited by 78 (20 self)
 Add to MetaCart
(Show Context)
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
Implementing Tactics and Tacticals in a HigherOrder Logic Programming Language
 Journal of Automated Reasoning
, 1993
"... We argue that a logic programming language with a higherorder intuitionistic logic as its foundation can be used both to naturally specify and implement tactic style theorem provers. The language extends traditional logic programming languages by replacing firstorder terms with simplytyped terms ..."
Abstract

Cited by 70 (15 self)
 Add to MetaCart
(Show Context)
We argue that a logic programming language with a higherorder intuitionistic logic as its foundation can be used both to naturally specify and implement tactic style theorem provers. The language extends traditional logic programming languages by replacing firstorder terms with simplytyped terms, replacing firstorder unification with higherorder unification, and allowing implication and universal quantification in queries and the bodies of clauses. Inference rules for a variety of inference systems can be naturally specified in this language. The higherorder features of the language contribute to a concise specification of provisos concerning variable occurrences in formulas and the discharge of assumptions present in many inference systems. Tactics and tacticals, which provide a framework for highlevel control over search for proofs, can be directly and naturally implemented in the extended language. This framework serves as a starting point for implementing theorem provers an...
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 70 (16 self)
 Add to MetaCart
(Show Context)
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...
Nominal Unification
 Theoretical Computer Science
, 2003
"... We present a generalisation of firstorder unification to the practically important case of equations between terms involving binding operations. A substitution of terms for variables solves such an equation if it makes the equated terms #equivalent, i.e. equal up to renaming bound names. For the a ..."
Abstract

Cited by 68 (28 self)
 Add to MetaCart
(Show Context)
We present a generalisation of firstorder unification to the practically important case of equations between terms involving binding operations. A substitution of terms for variables solves such an equation if it makes the equated terms #equivalent, i.e. equal up to renaming bound names. For the applications we have in mind, we must consider the simple, textual form of substitution in which names occurring in terms may be captured within the scope of binders upon substitution. We are able to take a `nominal' approach to binding in which bound entities are explicitly named (rather than using nameless, de Bruijnstyle representations) and yet get a version of this form of substitution that respects #equivalence and possesses good algorithmic properties. We achieve this by adapting an existing idea and introducing a key new idea. The existing idea is terms involving explicit substitutions of names for names, except that here we only use explicit permutations (bijective substitutions). The key new idea is that the unification algorithm should solve not only equational problems, but also problems about the freshness of names for terms. There is a simple generalisation of the classical firstorder unification algorithm to this setting which retains the latter's pleasant properties: unification problems involving #equivalence and freshness are decidable; and solvable problems possess most general solutions.
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 64 (11 self)
 Add to MetaCart
(Show Context)
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
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 63 (8 self)
 Add to MetaCart
(Show Context)
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...
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 63 (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
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 60 (5 self)
 Add to MetaCart
(Show Context)
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. ...
Explaining Type Inference
 Science of Computer Programming
, 1995
"... Type inference is the compiletime process of reconstructing missing type information in a program based on the usage of its variables. ML and Haskell are two languages where this aspect of compilation has enjoyed some popularity, allowing type information to be omitted while static type checking is ..."
Abstract

Cited by 60 (0 self)
 Add to MetaCart
(Show Context)
Type inference is the compiletime process of reconstructing missing type information in a program based on the usage of its variables. ML and Haskell are two languages where this aspect of compilation has enjoyed some popularity, allowing type information to be omitted while static type checking is still performed. Type inference may be expected to have some application in the prototyping and scripting languages which are becoming increasingly popular. A difficulty with type inference is the confusing and sometimes counterintuitive diagnostics produced by the type checker as a result of type errors. A modification of the HindleyMilner type inference algorithm is presented, which allows the specific reasoning which led to a program variable having a particular type to be recorded for type explanation. This approach is close to the intuitive process used in practice for debugging type errors. 1 Introduction Type inference refers to the compiletime process of reconstructing missing t...