Sequent Calculus and Equational Programming

Proof assistants and programming languages based on type theories usually come in two flavours: one is based on the standard natural deduction presentation of type theory and involves eliminators, while the other provides a syntax in equational style. We show here that the equational approach corresponds to the use of a focused presentation of a type theory expressed as a sequent calculus. A typed functional language is presented, based on a sequent calculus, that we relate to the syntax and internal language of Agda. In particular, we discuss the use of patterns and case splittings, as well as rules implementing inductive reasoning and dependent products and sums.Comment: In Proceedings LFMTP 2015, arXiv:1507.0759

Set Unification

The unification problem in algebras capable of describing sets has been tackled, directly or indirectly, by many researchers and it finds important applications in various research areas--e.g., deductive databases, theorem proving, static analysis, rapid software prototyping. The various solutions proposed are spread across a large literature. In this paper we provide a uniform presentation of unification of sets, formalizing it at the level of set theory. We address the problem of deciding existence of solutions at an abstract level. This provides also the ability to classify different types of set unification problems. Unification algorithms are uniformly proposed to solve the unification problem in each of such classes. The algorithms presented are partly drawn from the literature--and properly revisited and analyzed--and partly novel proposals. In particular, we present a new goal-driven algorithm for general ACI1 unification and a new simpler algorithm for general (Ab)(Cl) unification.Comment: 58 pages, 9 figures, 1 table. To appear in Theory and Practice of Logic Programming (TPLP

Nonmonotonic Behavior Demonstrated by Stable

Nonmonotonic reasoning is a critical feature that robust reasoning systems must possess. Another important feature that robust reasoning systems must possess is the ability to reason about collections of objects (i.e., sets.) Logic programming presents us with a very powerful paradigm within which to represent and reason about knowledge. Developments in this field over recent years allow us to reason nonmonotonically, and allow us to reason about sets. Of the semantics introduced over recent years to allow logic programs to reason about sets, Stable{} is the newest and most expressive (i.e., comprehensive) approach to date. This paper examines the nonmonotonicity of Stable{}

Testing for the ground (co-)reducibility property in term-rewriting systems

AbstractGiven a term-rewriting system R, a term t is ground-reducible by R if every ground instance tσ of it is R-reducible. A pair (t, s) of terms is ground-co-reducible by R if every ground instance (tσ, sσ] of it for which tσ and sσ are distinct is R-reducible. Ground (co-)reducibility has been proved to be the fundamental tool for mechanizing inductive proofs, together with the Knuth-Bendix completion procedure presented by Jouannaud and Kounalis (1986, 1989).Jouannaud and Kounalis (1986, 1989) also presented an algorithm for testing ground reducibility which is tractable in practical cases but restricted to left-linear term-rewriting systems. The solution of the ground (co-)reducibility problem, for the general case, turned out to be surprisingly complicated. Decidability of ground reducibility for arbitrary term-rewriting systems has been first proved by Plaisted (1985) and independently by Kapur (1987). However, the algorithms of Plaisted and Kapur amount to intractable computation, even in very simple cases.We present here a new algorithm for the general case which outperforms the algorithms of Plaisted and Kapur and even our previous algorithm in case of left-linear term-rewriting systems. We then show how to adapt it to check for ground co-reducibility

From LCF to Isabelle/HOL

Interactive theorem provers have developed dramatically over the past four decades, from primitive beginnings to today's powerful systems. Here, we focus on Isabelle/HOL and its distinctive strengths. They include automatic proof search, borrowing techniques from the world of first order theorem proving, but also the automatic search for counterexamples. They include a highly readable structured language of proofs and a unique interactive development environment for editing live proof documents. Everything rests on the foundation conceived by Robin Milner for Edinburgh LCF: a proof kernel, using abstract types to ensure soundness and eliminate the need to store proofs. Compared with the research prototypes of the 1970s, Isabelle is a practical and versatile tool. It is used by system designers, mathematicians and many others

Continuation semantics for PROLOG with cut

We present a denotational continuation semantics for PROLOG with cut. First a uniform language B is studied, which captures the control flow aspects of PROLOG. The denotational semantics for B is proven equivalent to a transition system based operational semantics. The congruence proof relies on the representation of the operational semantics as a chain of approximations and on a convenient induction principle. Finally, we interpret the abstract language B such that we obtain equivalent denotational and operational models for PROLOG itself