Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the first-order, simply-typed case, but is in general undecidable in the presence of dependent types. In this paper we present a terminating algorithm for verifying coverage of higher-order, dependently typed patterns.

Abstract. Higher-order encodings use functions provided by one language to represent variable binders of another. They lead to concise and elegant representations, which historically have been difficult to analyze and manipulate. In this paper we present the ∇-calculus, a calculus for defining general recursive functions over higher-order encodings. To avoid problems commonly associated with using the same function space for representations and computations, we separate one from the other. The simply-typed λ-calculus plays the role of the representation-level. The computationlevel contains not only the usual computational primitives but also an embedding of the representation-level. It distinguishes itself from similar systems by allowing recursion under representation-level λ-binders while permitting a natural style of programming which we believe scales to other logical frameworks. Sample programs include bracket abstraction, parallel reduction, and an evaluator for a simple language with first-class continuations. 1

Syntax S. J. Ambler (S.Ambler@mcs.le.ac.uk) R. L. Crole (R.Crole@mcs.le.ac.uk) & A. Momigliano (A.Momigliano@mcs.le.ac.uk) Department of Mathematics and Computer Science, University of Leicester, Leicester, LE1 7RH, U.K.

We present the design and implementation of the strict and pure functional programming language Delphin. Its novel and distinctive features include a two-level design that distinguishes cleanly between the tasks of representing data and programming with data. One level is the logical framework LF [5], serving as Delphin's data representation language. The other level is # [15], a type theory designed to support programming using pattern matching and recursion. The main contribution of this work is therefore Delphin, in which one can program with higher-order, dependently-typed data structures such as proofs and typing derivations in a natural and intuitive way.

Reasoning by induction is common practice in computer science and mathematics. In formal logic, however, standard induction principles exist only for a certain class of inductively defined structures that satisfy the positivity condition. This is a major restriction considering that many structures in programming languages and logics are best expressed using higher-order representation techniques that violate exactly this condition. In this paper we develop induction principles for higherorder encodings in the setting of first-order intuitionistic logic. They differ from standard induction principles in that they rely on the concept of worlds [Sch01] which admits reasoning about open terms in regularly formed contexts. The soundness of these induction principles follows from external termination and coverage considerations about a realizability interpretation of proofs.

Over the years, logical framework research has produced various type theories designed primarily for the representation of deductive systems. Reasoning about these representations requires expressive special purpose meta logics, that are in general not part of the logical framework.

We investigate a framework for representing and reasoning about syntactic and semantic aspects of typed languages with variable binders.

We present an algorithm for verifying that some specified arguments of an inductively defined relation in a dependently typed #- calculus are uniquely determined by some other arguments. We prove it correct and also show how to exploit this uniqueness information in coverage checking, which allows us to verify that a definition of a function or relation covers all possible cases. In combination, the two algorithms significantly extend the power of the meta-reasoning facilities of the Twelf implementation of LF.

In this paper we show that the logical framework LF [6] extended by Σ-types serves as an excellent candidate for the representation of special syntax and hypothetical judgments. It has an elegant meta-theory and Σ-types prove enormously useful in the design of a functional programming language Delphin that permits programmers to work directly with those encodings. Applications of this work include predominantly deductive software development, special purpose theorem provers especially for proof carrying safety architectures such as proof carrying authentication PCA [2], foundational proof carrying code PCC [8, 1], and interpreters and compilers for experimental programming languages. This paper presents the underlying logical framework LF Σ and the functional programming language Delphin. 1

In this work, we propose a temporal logic with a past-time operator, show its soundness, and establish a Curry-Howard correspondence to a λ-calculus. Furthermore, we illustrate how it serves as a logical foundation for programming with dependently typed data, supports programming with higher-order abstract syntax and hypothetical judgments. Sample programs that we discuss in this paper include bracket abstraction.