Abstract not found

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 higher-order patterns, a notion investigated for the simply-typed -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 anti-unification algorithm we have in mind is that of proof generalization. 1 Introduction Higher-order logic with an embedded simply-typed - 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 pre-unification algorithm for the simply-typed -calculus [12] which has shown it...

In this paper, we present the results of an ongoing effort in building user interfaces for proof systems. Our approach is generic: we are not constructiong a user interface for a particular proof system, rather we have developed techniques and tools...

Abstract. We describe an algorithm for deciding the first-order multisorted theory BAPA, which combines 1) Boolean algebras of sets of uninterpreted elements (BA) and 2) Presburger arithmetic operations (PA). BAPA can express the relationship between integer variables and cardinalities of a priory unbounded finite sets, and supports arbitrary quantification over sets and integers. Our motivation for BAPA is deciding verification conditions that arise in the static analysis of data structure consistency properties. Data structures often use an integer variable to keep track of the number of elements they store; an invariant of such a data structure is that the value of the integer variable is equal to the number of elements stored in the data structure. When the data structure content is represented by a set, the resulting constraints can be captured in BAPA. BAPA formulas with quantifier alternations arise when verifying programs with annotations containing quantifiers, or when proving simulation relation conditions for refinement and equivalence of program fragments. Furthermore, BAPA constraints can be used for proving the termination of programs that manipulate data structures, and have applications in constraint databases. We give a formal description of a decision procedure for BAPA, which implies the decidability of BAPA. We analyze our algorithm and obtain an elementary upper bound on the running time, thereby giving the first complexity bound for BAPA. Because it works by a reduction to PA, our algorithm yields the decidability of a combination of sets of uninterpreted elements with any decidable extension of PA. Our algorithm can also be used to yield an optimal decision procedure for BA through a reduction to PA with bounded quantifiers. We have implemented our algorithm and used it to discharge verification conditions in the Jahob system for data structure consistency checking of Java programs; our experience with the algorithm is promising. 1

Second-order unification is undecidable in general. Miller showed that unification of so-called higher-order patterns is decidable and unitary. Weshow that the unification of a linear higher-order pattern s with an arbitrary second-order term that shares no variables with s is decidable and finitary. A few extensions of this unification problem are still decidable: unifying two second-order terms, where one term is linear, is undecidable if the terms contain bound variables but decidable if they don't.

In automated deduction systems that are intended for human use, the presentation of a proof is no less important than its discovery. For most of today’s automated theorem proving systems, this requires a non-trivial translation procedure to extract human-oriented deductions from machine-oriented proofs. Previously known translation procedures, though complete, tend to produce unintuitive deductions. One of the major flaws in such procedures is that too often the rule of indirect proof is used where the introduction of a lemma would result in a shorter and more intuitive proof. We present an algorithm, symmetric simplification, for discovering useful lemmas in deductions of theorems in first- and higher-order logic. This algorithm, which has been implemented in the TPS system, has the feature that resulting deductions may no longer have the weak subformula property. It is currently limited, however, in that it only generates lemmas of the form C ∨ ¬C ′ , where C and C ′ have the same negation normal form. 1

In this paper we are interested in using a first order theorem prover to prove theorems that are formulated in some higher order logic. To this end we present translations of higher order logics into first order logic with flat sorts and equality and give a sufficient criterion for the soundness of these translations. In addition translations are introduced that are sound and complete with respect to L. Henkin's general model semantics. Our higher order logics are based on a restricted type structure in the sense of A. Church, they have typed function symbols and predicate symbols, but no sorts.

In automated reasoning, there is a perceived trade-o between expressiveness and automation. Higher-order logic is typically viewed as expressive but resistant to automation, in contrast with rstorder logic and its fragments. We argue that higher-order logic and its variants actually achieve a happy medium between expressiveness and automation, particularly when used as a front-end to a wide range of decision procedures and deductive procedures. We illustrate the discussion with examples from PVS, but some of the observations apply to other variants of higher-order logic as well.

The first part of this paper introduces an extension for a variant of Huet's higher-order resolution calculus [Hue72, Hue73] based upon classical type theory (Church's typed -calculus [Chu40]) in order to obtain a calculus which is complete with respect to Henkin models [Hen50]. The new rules connect higher-order pre-unification with the general refutation process in an appropriate way to establish full extensionality for the whole system. The general idea of the calculus is discussed on different examples. The second part introduces the Leo system which implements the discussed extensional higher-order resolution calculus. This part mainly focus on the embedding of the new extensionality rules into the refutation process and the treatment of higher-order unification. 1 Introduction Many mathematical problems can be expressed shortly and elegantly in higher order logic whereas they often lead to unnatural and inflated formulations in first-order logic, e.g., when coding them into axio...

. In most cases higher-order logic is based on the - calculus in order to avoid the infinite set of so-called comprehension axioms. However, there is a price to be paid, namely an undecidable unification algorithm. If we do not use the -calculus, but translate higher-order expressions into firstorder expressions by standard translation techniques, we have to translate the infinite set of comprehension axioms, too. Of course, in general this is not practicable. Therefore such an approach requires some restrictions such as the choice of the necessary axioms by a human user or the restriction to certain problem classes. This paper will show how the infinite class of comprehension axioms can be represented by a finite subclass, so that an automatic translation of finite higher-order problems into finite first-order problems is possible. This translation is sound and complete with respect to a Henkin-style general model semantics. 1 Introduction First-order logic is a powerful tool for ...