Calculus Of Constructions Research Articles

On the Formalization of the Modal μ-Calculus in the Calculus of Inductive Constructions

We present a natural deduction proof system for the propositional modal μ-calculus and its formalization in the calculus of inductive constructions. We address several problematic issues, such as the use of higher-order abstract syntax in inductive sets in the presence of recursive constructors, and the formalization of modal (sequent-style) rules and of context sensitive grammars. The formalization can be used in the system Coq, providing an experimental computer-aided proof environment for the interactive development of error-free proofs in the modal μ-calculus. The techniques we adopt can be readily ported to other languages and proof systems featuring similar problematic issues.

Semantics of constructions (I) — The traditional approach

It is well known that impredicative type systems do not have set theoretical semantics. This paper takes a look at semantics of inductive types in impredicative type systems. A generalized inductive type is interpreted as an omega set generated by effectivizing a certain rule set. The result provides a semantic justification of inductive types in the calculus of constructions.

A Gentzen-style sequent calculus of constructions with expansion rules

A Gentzen-style L-formulation of the calculus of constructions is presented and proved equivalent to a natural deduction formulation based on that of Seldin (1997). The L-rules corresponding to the conversion rules of the natural deduction system are expansion rules. Cut elimination follows from the equivalence to the natural deduction formulation and the normalization theorem for the latter.

On lists and other abstract data types in the calculus of constructions

The representation of the inductively defined abstract data type for lists was left incomplete in Seldin (1997, Section 9). Here that representation is completed, and it is proved that all extra axioms needed are consistent. Among the innovations of this paper is a definition of cdr, whose definition was left for future work in Seldin (1997, Section 9). The results are then extended to other abstract data types – those of Berardi (1993). The method used to define cdr for lists is extended to obtain the definition of an inverse for each argument of each constructor of an abstract data type. These inverses are used to prove the injective property for the constructors. Also, Dedekind's method of defining the natural numbers is used to define a predicate associated with each abstract data type, and the use of this predicate makes it unnecessary to postulate the induction principle. The only axioms left to be proved are those asserting the disjointness of the co-domains of different constructors, and it is shown that those axioms can be proved consistent.

Formalizing mathematics in higher-order logic: A case study in geometric modelling

An innovative attempt to develop formal techniques of specification, proof, and program extraction in geometric modelling is reported through the axiomatization of the mathematical model of the combinatorial maps in the calculus of inductive constructions (CIC), a variety of type theory well suited for mechanizing mathematics in higher-order logic. A hierarchical specification of ordered sorts is presented and validated by inductive proofs of consistency and completeness in the Coq system, a prover built on CIC. Automatic extraction of functional algorithms from constructive proofs is investigated through the development of a prototype. Classical difficulties in formal specification and theorem proving – like cohabitation of objects with their generalization in the same hierarchy, smooth handling of subtyping, completion of partial relations or objects, observationality vs. constructivism, and symmetry of relations – are addressed, not only at the formal specification and theorem proving level but also from the prototyping viewpoint. Geometrical modelling issues are thus solved in a new and unquestionable fashion, giving a great insight on the domain and a deep understanding of the model. A methodology of formal program development that could apply to other areas of computer science is then proposed.

The calculus of constructions as a framework for proof search with set variable instantiation

We show how a procedure developed by Bledsoe for automatically finding substitution instances for set variables in higher-order logic can be adapted to provide increased automation in proof search in the Calculus of Constructions (CC). Bledsoe's procedure operates on an extension of first-order logic that allows existential quantification over set variables. This class of variables can also be identified in CC. The existence of a correspondence between higher-order logic and higher-order type theories such as CC is well-known. CC can be viewed as an extension of higher-order logic where the basic terms of the language, the simply-typed λ-terms, are replaced with terms containing dependent types. We show how Bledsoe's techniques can be incorporated into a reformulation of a search procedure for CC given by Dowek and extended to handle terms with dependent types. We introduce a notion of search context for CC which allows us to separate the operations of assumption introduction and backchaining. Search contexts allow a smooth integration of the step which finds solutions to set variables. We discuss how the procedure can be restricted to obtain procedures for set variable instantiation in sublanguages of CC such as the Logical Framework (LF) and higher-order hereditary Harrop formulas (hohh). The latter serves as the logical foundation of the λProlog logic programming language.

On propositions-as-types in realizability models

It is well-known that one can build models of full higher-order dependent type theory (a.k.a. calculus of constructions) using partial equivalence relations and assemblies over a partial combinatory algebra. Using the propositions as types paradigm, one can then reason about the types and kinds. But one can also use the fact that assemblies embed into a realizability topos and use the logic of the topos to reason about types and kinds, as done by Reus in his dissertation. We show that, in a suitably precise sense, reasoning using the topos logic amounts to the same as reasoning via the propositions-as-types method.

The sequence modeling method based on ECC in developing program specifications

This article discusses the developing process of the version sequences of specifications and the formal expressions of various reconstructions including the expansion and revision of the version at each stage. The author suggests using ECC (Extended Calculus of Construction) to describe the specifications of formal system and using functional language ML to implement this developing process.

A Full Formalization of SLD-Resolution in the Calculus of Inductive Constructions

This paper presents a full formalization of the semantics of definite programs, in the calculus of inductive constructions. First, we describe a formalization of the proof of first-order terms unification: this proof is obtained from a similar proof dealing with quasi-terms, thus showing how to relate an inductive set with a subset defined by a predicate. Then, SLD-resolution is explicitely defined: the renaming process used in SLD-derivations is made explicit, thus introducing complications, usually overlooked, during the proofs of classical results. Last, switching and lifting lemmas and soundness and completeness theorems are formalized. For this, we present two lemmas, usually omitted, which are needed. This development also contains a formalization of basic results on operators and their fixpoints in a general setting. All the proofs of the results, presented here, have been checked with the proof assistant Coq.

CPS Translations and Applications: The Cube and Beyond

Continuation passing style (CPS) translations of typed λ-calculi have numerous applications. However, the range of these applications has been confined by the fact that CPS translations are known for non-dependent type systems only, thus excluding well-known systems like the calculus of constructions (CC) and the logical frameworks (LF). This paper presents techniques for CPS translating systems with dependent types, with an emphasis on pure type-theoretical applications. In the first part of the paper we review several lines of work in which the need for CPS translations of dependent type systems has arisen, and discuss the difficulties involved with CPS translating such systems. One way of overcoming these difficulties is to work with so-called domain-free type systems. Thus, instead of Barendregt‘s λ-cube we shall consider the domain-free λ-cube, and instead of traditional pure type systems, we shall consider domain-free pure type systems. We therefore begin the second part by reviewing the domain-free λ-cube, which includes domain-free versions of CC and LF, and then present CPS translations for all the systems of the domain-free λ-cube. We also introduce Direct Style (DS) (i.e., inverse CPS) translations for all the systems of the domain-free λ-cube; such DS translations, which have been used in a number of applications, were previously formulated for untyped and simply-typed languages only. In the third part we review domain-free pure type systems and generalize the CPS translations of the domain-free λ-cube to a large class of domain-free pure type systems which includes most of the systems that appear in the literature, including those of the domain-free λ-cube. Many translations that appear in the literature arise as special cases of ours. In the fourth part of the paper we present two approaches to CPS translations of traditional pure type systems. The first, indirect, technique lifts the CPS translation of domain-free pure type systems to the analogous class of traditional pure type systems by using results that relate derivations in domain-free and traditional pure type systems. The second, direct, approach translates derivations, requiring a certain order on derivations to be well-founded. Both techniques yield translations for most of the systems that appear in the literature, including those of Barendregt‘s λ-cube.

Realizability Models for Type Theories

This tutorial aims at giving an account on the realizability models for several constructive type theories. These range from simply typed λ-calculus over second-order polymorphic λ-calculus to the Calculus of Constructions as an example of dependent type theory. The models are made from partial equivalence relations (pers) and realizability sets over an arbitrary partial combinatory algebra. Realizability semantics does not only provide intuitive models but can also be used for proving independence results of type theories. Finally, by considering complete extensional pers, an approach to bridge the gap from type theory to constructive domain theory is discussed.

Membership Equational Logic, Calculus of Inductive Constructions, and Rewrite Logic (Extended Abstract)

Many of the above ideas arose when discussing with people of the afore mentionned groups (Coq, Demons, Maude, PROTHEO), and especially with Gilles Dowek and Christine Paulin. Mitsuhiro Okada also deserves special thanks for introducing me to the Curry-Howard world, while I was introducing him to its Hurry-Coward counterpart.

Verifying programs in the calculus of inductive constructions

Abstract This paper deals with a particular approach to the verification of functional programs. A specification of a program can be represented by a logical formula [Con86, NPS90]. In a constructive framework, developing a program then corresponds to proving this formula. Given a specification and a program, we focus on reconstructing a proof of the specification whose algorithmic contents corresponds to the given program. The best we can hope is to generate proof obligations on atomic parts of the program corresponding to logical properties to be verified. First, this paper studies a weak extraction of a program from a proof that keeps track of intermediate specifications. From such a program, we prove the determinism of retrieving proof obligations. Then, heuristic methods are proposed for retrieving the proof from a natural program containing only partial annotations. Finally, the implementation of this method as a tactic of the Coq proof assistant is presented.

Some Lambda Calculus and Type Theory Formalized

"This paper is about our hobby." That is the first sentence of [MP93], the first report on our formal development of lambda calculus and type theory, written in autumn 1992. We have continued to pursue this hobby on and off ever since, and have developed a substantial body of formal knowledge, including Church-Rosser and standardization<br />theorems for beta reduction, and the basic theory of<br />Pure Type Systems (PTS) leading to the strengthening theorem and type checking algorithms for PTS. Some of this work is reported in [MP93, vBJMP94, Pol94b, Pol95]. In the present paper we survey this work, including some new proofs, and point out what we feel has been learned about the general issues of formalizing mathematics. On the technical side, we describe an abstract, and simplified, proof of standardization for beta reduction, not previously published, that does<br />not mention redex positions or residuals. On the general issues, we emphasize the search for formal definitions that are convenient for formal proof and convincingly represent the intended informal concepts. The LEGO Proof Development System [LP92] was used to check the work in an implementation of the Extended Calculus of Constructions<br />(ECC) with inductive types [Luo94]. LEGO is a refinement style<br />proof checker, publicly available by ftp and WWW, with a User's Manual [LP92] and a large collection of examples. Section 1.3 contains information on accessing the formal development described in this paper. Other interesting examples formalized in LEGO include program specification and data refinement [Luo91], strong normalization of System F [Alt93], synthetic domain theory [Reu95, Reu96], and operational semantics for imperative programs [Sch97].

Abstract data type systems

This paper is concerned with the foundations of an extension of pure type systems by abstract data types, hence the name of Abstract Data Type Systems. ADTS generalize inductive types as they are defined in the calculus of constructions, by providing definitions of functions by pattern matching on the one hand, and relations among constructors of the inductive type on the other. It also generalizes the first-order framework of abstract data types by providing function types and higher-order equations. The first half of the paper describes the framework of ADTS, while the second half investigates cases where ADTS are strongly normalizing. This is shown to be the case for the polymorphic lambda calculus (with possibly subtypes) enriched by higher-order algebraic rules obeying a strong generalization of primitive recursion of higher type that we call the general schema. This covers in particular the case of inductive types whose constructors do not have functional arguments. We conjecture that this result holds true for all calculi of the so-called Barendregt's cube. On the other hand, the definition of a schema for the higher-order rules allowing for more general inductive types is left open.

Formalizing process algebraic verifications in the calculus of constructions

AbstractThis paper reports on the first steps towards the formal verification of correctness proofs of real-life protocols in process algebra. We show that such proofs can be verified, and partly constructed, by a general purpose proof checker. The process algebra we use isμCRL, ACPτaugmented with data, which is expressive enough for the specification of real-life protocols. The proof checker we use is Coq, which is based on the Calculus of Constructions, an extension of simply typed lambda calculus. The focus is on the translation of the proof theory ofμCRL andμCRL-specifications to Coq. As a case study, we verified the Alternating Bit Protocol.

On the proof theory of Coquand's calculus of constructions

The calculus of constructions is formulated as a natural deduction system in which deductions follow the constructions of the terms to which types are assigned. Strong normalization is proved for deductions. This strong normalization result implies the consistency of the underlying system, but it is still possible to make contradictory assumptions. A number of assumption sets useful in implementations are proved consistent, including certain sets of assumptions whose types are negations, negations of certain equations, arithmetic, classical logic, classical arithmetic, and the existence of power sets. All results are given with complete proofs.

Proof-irrelevance out of excluded-middle and choice in the calculus of constructions

AbstractWe present a short and direct syntactic proof of the fact that adding the axiom of choice and the principle of excluded-middle to Coquand–Huet's Calculus of Constructions gives proof-irrelevance.

Exceptions considered harmless

Program extraction is a well known technique for developing correct functional programs from a constructive proof of their specification. This paper shows how to deal with exceptions in such a framework. We propose a modular (and impredicative) formalization in the calculus of constructions and we illustrate the technique on three examples.

Computation and reasoning: a type theory for computer science

Preface Introduction 1. The extended calculus of constructions 2. Basic meta-theoretic properties 3. Strong normalisation 4. The internal logic and decidability 5. A set-theoretic model 6. Computational and logical theories 7. Specification and development of programs 8. Towards a unifying theory of dependent types Bibliography Notation and symbols Index