DOCSLIB.ORG

Type Theory in Type Theory Using Quotient Inductive Types ∗

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Type Theory in Type Theory Using Quotient Inductive Types ∗ Type Theory in Type Theory using Quotient Inductive Types ∗ Thorsten Altenkirch Ambrus Kaposi School for Computer Science, University of Nottingham, United Kingdom rtifact Comple * A t * te n * te A is W s E * e n l {txa,auk} cs.nott.ac.uk C @ l o L D C o P * * c u e m s O E u e e P n R t v e o d t * y * s E a a l d u e a t Abstract data Ty : Set where We present an internal formalisation of a type heory with dependent ι : Ty types in Type Theory using a special case of higher inductive types _)_ : Ty ! Ty ! Ty from Homotopy Type Theory which we call quotient inductive types (QITs). Our formalisation of type theory avoids referring data Con : Set where to preterms or a typability relation but defines directly well typed • : Con objects by an inductive definition. We use the elimination principle _,_ : Con ! Ty ! Con to define the set-theoretic and logical predicate interpretation. The data Var : Con ! Ty ! Set where work has been formalized using the Agda system extended with zero : Var (Γ , σ) σ QITs using postulates. suc : Var Γ σ ! Var (Γ , τ) σ Categories and Subject Descriptors D.3.1 [Formal Definitions data Tm : Con ! Ty ! Set where and Theory]; F.4.1 [Mathematical Logic]: Lambda calculus and var : Var Γ σ ! Tm Γ σ related systems _@_ : Tm Γ(σ ) τ) Keywords Higher Inductive Types, Homotopy Type Theory, Log- ! Tm Γ σ ! Tm Γ τ ical Relations, Metaprogramming, Agda Λ: Tm (Γ , σ) τ ! Tm Γ(σ ) τ) 1. Introduction Figure 1. Simply typed λ-calculus We would like to reflect the syntax and typing rules of Type The- ory in itself. This offers exciting opportunities for typed metapro- gramming to support interactive theorem proving. We can also im- tages: in typed metaprogramming we only want to deal with typed plement extensions of Type Theory by providing a sound interpre- syntax and it avoids the need to prove subject reduction theorems tation giving rise to a form of template Type Theory. This paper separately. But more importantly this approach reflects our type- describes a novel approach to achieve this ambition. theoretic philosophy that typed objects are first and preterms are Within Type Theory it is straightforward to represent the simply designed at a 2nd step with the intention that they should contain typed λ-calculus as an inductive type where contexts and types are enough information so that we can reconstruct the typed objects. defined as inductive types and terms are given as an inductively Typechecking can be expressed in this view as constructing a par- defined family indexed by contexts and types (see figure 1 for a tial inverse to the forgetful function which maps typed into untyped definition in idealized Agda). syntax (a sort of printing operation). Here we inductively define Types (Ty) and contexts (Con) Naturally, we would like to do the same for the language we which in a de Bruijn setting are just sequences of types. We define are working in, that is we would like to perform typed metapro- the families of variables and terms where variables are typed de gramming for a dependently typed language. There are at least two Bruijn indices and terms are inductively generated from variables complications: using application (_@_) and abstraction (Λ). 1 In this approach we never define preterms and a typing rela- (1) types, terms and contexts have to be defined mutually but also tion but directly present the typed syntax. This has technical advan- depend on each other, (2) due to the conversion rule which allows us to coerce terms along ∗ Supported by EPSRC grant EP/M016951/1. type-equality we have to define the equality mutually with the 1 We are oversimplifying things a bit here: we would really like to restrict syntactic typing rules: operations to those which preserve βη-equality, i.e. work with a quotient of Tm. Γ ` A = B Γ ` t : A Γ ` t : B (1) can be addressed by using inductive-inductive definitions [6] (see section 2.1) – indeed doing Type Theory in Type Theory was one of the main motivations behind introducing inductive-inductive types. It seemed that this would also suffice to address (2), since This is the author’s version of the work. It is posted here for your personal use. Not for we can define the conversion relation mutually with the rest of the redistribution. The definitive version was published in the following publication: syntax. However, it turns out that the overhead in form of type- POPL’16, January 20–22, 2016, St. Petersburg, FL, USA theoretic boilerplate is considerable. For example terms depend on ACM. 978-1-4503-3549-2/16/01... both contexts and types, we have to include special constructors http://dx.doi.org/10.1145/2837614.2837638 which formalize the idea that this is a setoid indexed over two 18 given setoids. Moreover each constructor comes with a congruence into a model, but also more general because we are not limited to rule. In the end the resulting definition becomes unfeasible, almost any particular class of models. impossible to write down explicitly but even harder to work with in Our definition of the internal syntax of Type Theory is very practice. much inspired by categories with families (CwFs) [16, 19]. Indeed, This is where Higher Inductive Types [31] come in, because one can summarize our work by saying that we construct an initial they allow us to define constructors for equalities at the same CwF using QITs. That something like this should be possible in time as we define elements. Hence we can present the conversion principle was clear since a while, however, the progress reported relation just by stating the equality rules as equality constructors. here is that we have actually done it. Since we are defining equalities we don’t have to formalize any The style of the presentation can also be described as a gener- indexed setoid structure or explicitly state congruence rules. This alized algebraic theory [11] which has been recently used by Co- second step turns out to be essential to have a workable internal quand to give very concise presentations of Type Theory [8]. Our definition of Type Theory. work shows that it should be possible to internalize this style of Indeed, we only use a rather simple special case of higher in- presentation in type theory itself. ductive types, namely we are only interested in first order equal- Higher Inductive Types are described in chapter 6 in [31], and ities and we are ignoring higher equalities. This is what we call it is shown that they generalize quotient types, e.g. see [18, 25]. Quotient Inductive Types (QITs). From the perspective of Homo- topy Type Theory QITs are HITs which are truncated to be sets. The main aspect of HITs we are using is that they allow us to in- troduce new equalities and constructors at the same time. This has already been exploited in a different way in [31] for the definition 2. The Type Theory We Live In of the reals and the constructible hierarchy without having to use the axiom of choice. We are working in a Martin-Löf Type Theory using Agda as a ve- hicle. That is our syntax is the one used by the functional program- 1.1 Overview of the Paper ming language and interactive proof assistant Agda [2, 27]. In the paper, to improve readability we omit implicitly quantified vari- We start by explaining in some detail the type theory we are using ables whose types can be inferred from the context (in this respect as a metatheory and how we implement it using Agda in section 2. we follow rather Idris [9]). In particular we are reviewing inductive-inductive types (section In Agda, Π-types are written as (x:A) ! B for Π(x : A):B, 2.1) and we motivate the importance of QITs as simple HITs implicit arguments are indicated by curly brackets fx:Ag ! B, (section 2.2). Then, in section 3 we turn to our main goal and these can be omitted if Agda can infer them from the types of later define the syntax of a basic type theory with only Π-types and an arguments. Agda supports mixfix notation, eg. function space can uninterpreted universe with explicit substitutions. We explain how be denoted _)_ where the underscores show the placement of ar- a general recursor and eliminator can be derived. As a warm-up we guments. Underscores can also be used when defining a function if define formally the standard interpretation which interprets every we are not interested in the value of the argument eg. the constant piece of syntax by the corresponding metatheoretic construction in function can be defined as const x = x. The keyword data section 4. Our main real-world example (section 5) is to formally is used to define inductively generated families and the keyword give the logical predicate translation which has been introduced record is for defining dependent record types (iterated Σ-types) by by Bernardy [7] to explain parametricity for dependent types. The listing their fields after the keyword field. Records are automati- constructions presented in this paper have been formalized in Agda, cally modules (separate name spaces) in Agda, this is why they can this is available as supplementary material [3]. be opened using the open keyword. In this case the field names be- come projection functions.
Load more

Recommended publications
  • Countability of Inductive Types Formalized in the Object-Logic Level
    Countability of Inductive Types Formalized in the Object-Logic Level QinxiangCao XiweiWu * Abstract: The set of integer number lists with finite length, and the set of binary trees with integer labels are both countably infinite. Many inductively defined types also have countably many ele- ments. In this paper, we formalize the syntax of first order inductive definitions in Coq and prove them countable, under some side conditions. Instead of writing a proof generator in a meta language, we develop an axiom-free proof in the Coq object logic. In other words, our proof is a dependently typed Coq function from the syntax of the inductive definition to the countability of the type. Based on this proof, we provide a Coq tactic to automatically prove the countability of concrete inductive types. We also developed Coq libraries for countability and for the syntax of inductive definitions, which have value on their own. Keywords: countable, Coq, dependent type, inductive type, object logic, meta logic 1 Introduction In type theory, a system supports inductive types if it allows users to define new types from constants and functions that create terms of objects of that type. The Calculus of Inductive Constructions (CIC) is a powerful language that aims to represent both functional programs in the style of the ML language and proofs in higher-order logic [16]. Its extensions are used as the kernel language of Coq [5] and Lean [14], both of which are widely used, and are widely considered to be a great success. In this paper, we focus on a common property, countability, of all first-order inductive types, and provide a general proof in Coq’s object-logic.
    [Show full text]
  • Certification of a Tool Chain for Deductive Program Verification Paolo Herms
    Certification of a Tool Chain for Deductive Program Verification Paolo Herms To cite this version: Paolo Herms. Certification of a Tool Chain for Deductive Program Verification. Other [cs.OH]. Université Paris Sud - Paris XI, 2013. English. NNT : 2013PA112006. tel-00789543 HAL Id: tel-00789543 https://tel.archives-ouvertes.fr/tel-00789543 Submitted on 18 Feb 2013 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. UNIVERSITÉ DE PARIS-SUD École doctorale d’Informatique THÈSE présentée pour obtenir le Grade de Docteur en Sciences de l’Université Paris-Sud Discipline : Informatique PAR Paolo HERMS −! − SUJET : Certification of a Tool Chain for Deductive Program Verification soutenue le 14 janvier 2013 devant la commission d’examen MM. Roberto Di Cosmo Président du Jury Xavier Leroy Rapporteur Gilles Barthe Rapporteur Emmanuel Ledinot Examinateur Burkhart Wolff Examinateur Claude Marché Directeur de Thèse Benjamin Monate Co-directeur de Thèse Jean-François Monin Invité Résumé Cette thèse s’inscrit dans le domaine de la vérification du logiciel. Le but de la vérification du logiciel est d’assurer qu’une implémentation, un programme, répond aux exigences, satis- fait sa spécification. Cela est particulièrement important pour le logiciel critique, tel que des systèmes de contrôle d’avions, trains ou centrales électriques, où un mauvais fonctionnement pendant l’opération aurait des conséquences catastrophiques.
    [Show full text]
  • Inductive Types an Proof Assistants
    Inductive Types Proof Assistants Homotopy Type Theory Radboud University Lecture 4: Inductive types an Proof Assistants H. Geuvers Radboud University Nijmegen, NL 21st Estonian Winter School in Computer Science Winter 2016 H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 1 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Outline Inductive Types Proof Assistants Homotopy Type Theory H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 2 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Curry-Howard-de Bruijn logic ∼ type theory formula ∼ type proof ∼ term detour elimination ∼ β-reduction proposition logic ∼ simply typed λ-calculus predicate logic ∼ dependently typed λ-calculus λP intuitionistic logic ∼ . + inductive types higher order logic ∼ . + higher types and polymorphism classical logic ∼ . + exceptions H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 3 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Inductive types by examples from the Coq system • booleans • natural numbers • integers • pairs • linear lists • binary trees • logical operations H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 5 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Inductive types • types • recursive functions • definition using pattern matching • ι-reduction = evaluation of recursive functions • recursion principle • proof by cases proof by induction • induction principle H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 6 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Booleans: type Coq definition: Inductive bool : Set := | true : bool | false : bool. Coq produces: bool rec. bool rect. bool ind. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 7 / 58 Inductive Types Proof Assistants Homotopy Type Theory Radboud University Booleans: elimination Check bool ind.
    [Show full text]
  • A Core Language for Dependently Typed Programming
    DRAFT ΠΣ: A Core Language for Dependently Typed Programming Thorsten Altenkirch Nicolas Oury University of Nottingham {txa,npo}@cs.nott.ac.uk Abstract recursion and hence is, without further restrictions, unsuitable as We introduce ΠΣ, a core language for dependently typed program- a logical system. It is, after all, intended to be primarily a core ming. Our intention is that ΠΣ should play the role extensions of language for programming, not for reasoning. Apart from Σ- and System F are playing for conventional functional languages with Π-types our language has only a few more, namely: polymorphism, like Haskell. The core language incorporates mu- Type : Type This is the simplest choice, the most general form of tual dependent recursive definitions, Type : Type, Π- and Σ-types, impredicative polymorphism possible. It is avoided in systems finite sets of labels and explicit constraints. We show that standard used for reasoning because it destroys logical consistency. We constructions in dependently typed programming can be easily en- don’t care because we have lost consistency already by allowing coded in our language. We address some important issues: having recursion. an equality checker which unfolds recursion only when needed, avoiding looping when typechecking sensible programs; the sim- Finite types A finite type is given by a collection of labels, e.g. { , } plification of type checking for eliminators like case by using equa- true false to define the type of Booleans. Our labels are tional constraints, allowing the flexible use of case expressions a special class and can be reused, opening the scope for a within dependently typed programming and the representation of hereditary definition of subtyping.
    [Show full text]
  • The Strength of Some Martin–Löf Type Theories
    The Strength of Some Martin{LÄofType Theories Michael Rathjen¤y Abstract One objective of this paper is the determination of the proof{theoretic strength of Martin{ LÄof's type theory with a universe and the type of well{founded trees. It is shown that this type system comprehends the consistency of a rather strong classical subsystem of second order 1 arithmetic, namely the one with ¢2 comprehension and bar induction. As Martin-LÄofintended to formulate a system of constructive (intuitionistic) mathematics that has a sound philosophical basis, this yields a constructive consistency proof of a strong classical theory. Also the proof- theoretic strength of other inductive types like Aczel's type of iterative sets is investigated in various contexts. Further, we study metamathematical relations between type theories and other frameworks for formalizing constructive mathematics, e.g. Aczel's set theories and theories of operations and classes as developed by Feferman. 0 Introduction The intuitionistic theory of types as developed by Martin-LÄofis intended to be a system for formalizing intuitionistic mathematics together with an informal semantics, called \meaning expla- nation", which enables him to justify the rules of his type theory by showing their validity with respect to that semantics. Martin-LÄof's theory gives rise to a full scale philosophy of constructivism. It is a typed theory of constructions containing types which themselves depend on the constructions contained in previously constructed types. These dependent types enable one to express the general Cartesian product of the resulting families of types, as well as the disjoint union of such a family.
    [Show full text]
  • An Introduction to Lean
    An Introduction to Lean Jeremy Avigad Leonardo de Moura Gabriel Ebner and Sebastian Ullrich Version 1fc176a, updated at 2017-01-09 14:16:26 -0500 2 Contents Contents 3 1 Overview 5 1.1 Perspectives on Lean ............................... 5 1.2 Where To Go From Here ............................. 12 2 Defining Objects in Lean 13 2.1 Some Basic Types ................................ 14 2.2 Defining Functions ................................ 17 2.3 Defining New Types ............................... 20 2.4 Records and Structures ............................. 22 2.5 Nonconstructive Definitions ........................... 25 3 Programming in Lean 27 3.1 Evaluating Expressions .............................. 28 3.2 Recursive Definitions ............................... 30 3.3 Inhabited Types, Subtypes, and Option Types . 32 3.4 Monads ...................................... 34 3.5 Input and Output ................................ 35 3.6 An Example: Abstract Syntax ......................... 36 4 Theorem Proving in Lean 38 4.1 Assertions in Dependent Type Theory ..................... 38 4.2 Propositions as Types .............................. 39 4.3 Induction and Calculation ............................ 42 4.4 Axioms ...................................... 45 5 Using Automation in Lean 46 6 Metaprogramming in Lean 47 3 CONTENTS 4 Bibliography 48 1 Overview This introduction offers a tour of Lean and its features, with a number of examples foryou to play around with and explore. If you are reading this in our online tutorial system, you can run examples like the one below by clicking the button that says “try it yourself.” #check "hello world!" The response from Lean appears in the small window underneath the editor text, and also in popup windows that you can read when you hover over the indicators in the left margin. Alternatively, if you have installed Lean and have it running in a stand-alone editor, you can copy and paste examples and try them there.
    [Show full text]
  • Collection Principles in Dependent Type Theory
    This is a repository copy of Collection Principles in Dependent Type Theory. White Rose Research Online URL for this paper: http://eprints.whiterose.ac.uk/113157/ Version: Accepted Version Proceedings Paper: Azcel, P and Gambino, N orcid.org/0000-0002-4257-3590 (2002) Collection Principles in Dependent Type Theory. In: Lecture Notes in Computer Science: TYPES 2000. International Workshop on Types for Proofs and Programs (TYPES) 2000, 08-12 Dec 2000, Durham, UK. Springer Verlag , pp. 1-23. ISBN 3-540-43287-6 © 2002, Springer-Verlag Berlin Heidelberg. This is an author produced version of a conference paper published in Lecture Notes in Computer Science: Types for Proofs and Programs. Uploaded in accordance with the publisher's self-archiving policy. Reuse Items deposited in White Rose Research Online are protected by copyright, with all rights reserved unless indicated otherwise. They may be downloaded and/or printed for private study, or other acts as permitted by national copyright laws. The publisher or other rights holders may allow further reproduction and re-use of the full text version. This is indicated by the licence information on the White Rose Research Online record for the item. Takedown If you consider content in White Rose Research Online to be in breach of UK law, please notify us by emailing [email protected] including the URL of the record and the reason for the withdrawal request. [email protected] https://eprints.whiterose.ac.uk/ Collection Principles in Dependent Type Theory⋆ Peter Aczel1 and Nicola Gambino2 1 Departments of Mathematics and Computer Science, University of Manchester, e-mail: [email protected] 2 Department of Computer Science, University of Manchester, e-mail: [email protected] Abstract.
    [Show full text]
  • Polymorphism All the Way Up! from System F to the Calculus of Constructions
    Programming = proving? The Curry-Howard correspondence today Second lecture Polymorphism all the way up! From System F to the Calculus of Constructions Xavier Leroy College` de France 2018-11-21 Curry-Howard in 1970 An isomorphism between simply-typed λ-calculus and intuitionistic logic that connects types and propositions; terms and proofs; reductions and cut elimination. This second lecture shows how: This correspondence extends to more expressive type systems and to more powerful logics. This correspondence inspired formal systems that are simultaneously a logic and a programming language (Martin-Lof¨ type theory, Calculus of Constructions, Pure Type Systems). 2 I Polymorphism and second-order logic Static typing vs. genericity Static typing with simple types (as in simply-typed λ-calculus but also as in Algol, Pascal, etc) sometimes forces us to duplicate code. Example A sorting algorithm applies to any list list(t) of elements of type t, provided it also receives then function t ! t ! bool that compares two elements of type t. With simple types, to sort lists of integers and lists of strings, we need two functions with dierent types, even if they implement the same algorithm: sort list int :(int ! int ! bool) ! list(int) ! list(int) sort list string :(string ! string ! bool) ! list(string) ! list(string) 4 Static typing vs. genericity There is a tension between static typing on the one hand and reusable implementations of generic algorithms on the other hand. Some languages elect to weaken static typing, e.g. by introducing a universal type “any” or “?” with run-time type checking, or even by turning typing o: void qsort(void * base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); Instead, polymorphic typing extends the algebra of types and the typing rules so as to give a precise type to a generic function.
    [Show full text]
  • Type Theory & Functional Programming
    Type Theory & Functional Programming Simon Thompson Computing Laboratory, University of Kent March 1999 c Simon Thompson, 1999 Not to be reproduced i ii To my parents Preface Constructive Type theory has been a topic of research interest to computer scientists, mathematicians, logicians and philosophers for a number of years. For computer scientists it provides a framework which brings together logic and programming languages in a most elegant and fertile way: program development and verification can proceed within a single system. Viewed in a different way, type theory is a functional programming language with some novel features, such as the totality of all its functions, its expressive type system allowing functions whose result type depends upon the value of its input, and sophisticated modules and abstract types whose interfaces can contain logical assertions as well as signature information. A third point of view emphasizes that programs (or functions) can be extracted from proofs in the logic. Up until now most of the material on type theory has only appeared in proceedings of conferences and in research papers, so it seems appropriate to try to set down the current state of development in a form accessible to interested final-year undergraduates, graduate students, research workers and teachers in computer science and related fields – hence this book. The book can be thought of as giving both a first and a second course in type theory. We begin with introductory material on logic and functional programming, and follow this by presenting the system of type theory itself, together with many examples. As well as this we go further, looking at the system from a mathematical perspective, thus elucidating a number of its important properties.
    [Show full text]
  • Failure Is Not an Option an Exceptional Type Theory
    Failure is Not an Option An Exceptional Type Theory Pierre-Marie Pédrot1 and Nicolas Tabareau2 1 MPI-SWS, Germany 2 Inria, France Abstract. We define the exceptional translation, a syntactic translation of the Calculus of Inductive Constructions (CIC) into itself, that covers full dependent elimination. The new resulting type theory features call- by-name exceptions with decidable type-checking and canonicity, but at the price of inconsistency. Then, noticing parametricity amounts to Kreisel’s realizability in this setting, we provide an additional layer on top of the exceptional translation in order to tame exceptions and ensure that all exceptions used locally are caught, leading to the parametric ex- ceptional translation which fully preserves consistency. This way, we can consistently extend the logical expressivity of CIC with independence of premises, Markov’s rule, and the negation of function extensionality while retaining η-expansion. As a byproduct, we also show that Markov’s prin- ciple is not provable in CIC. Both translations have been implemented in a Coq plugin, which we use to formalize the examples. 1 Introduction Monadic translations constitute a canonical way to add effects to pure functional languages [1]. Until recently, this technique was not available for type theories such as CIC because of complex interactions with dependency. In a recent pa- per [2], we have presented a generic way to extend the monadic translation to dependent types, using the weaning translation, as soon as the monad under con- sideration satisfies a crucial property: being self-algebraic. Indeed, in the same way that the universe of types i is itself a type (of a higher universe) in type theory, the type of algebras of a monad T ΣA : i: T A ! A needs to be itself an algebra of the monad to allow a correct translation of the universe.
    [Show full text]
  • Type Systems for Programming Languages1 (DRAFT)
    Type Systems for Programming Languages1 (DRAFT) Robert Harper School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213-3891 E-mail: [email protected] WWW: http://www.cs.cmu.edu/~rwh Spring, 2000 Copyright c 1995-2000. All rights reserved. 1These are course notes Computer Science 15–814 at Carnegie Mellon University. This is an incomplete, working draft, not intended for publication. Citations to the literature are spotty at best; no results presented here should be considered original unless explicitly stated otherwise. Please do not distribute these notes without the permission of the author. ii Contents I Type Structure 1 1 Basic Types 3 1.1 Introduction . 3 1.2 Statics . 3 1.3 Dynamics . 4 1.3.1 Contextual Semantics . 4 1.3.2 Evaluation Semantics . 5 1.4 Type Soundness . 7 1.5 References . 8 2 Function and Product Types 9 2.1 Introduction . 9 2.2 Statics . 9 2.3 Dynamics . 10 2.4 Type Soundness . 11 2.5 Termination . 12 2.6 References . 13 3 Sums 15 3.1 Introduction . 15 3.2 Sum Types . 15 3.3 References . 16 4 Subtyping 17 4.1 Introduction . 17 4.2 Subtyping . 17 4.2.1 Subsumption . 18 4.3 Primitive Subtyping . 18 4.4 Tuple Subtyping . 19 4.5 Record Subtyping . 22 4.6 References . 24 iii 5 Variable Types 25 5.1 Introduction . 25 5.2 Variable Types . 25 5.3 Type Definitions . 26 5.4 Constructors, Types, and Kinds . 28 5.5 References . 30 6 Recursive Types 31 6.1 Introduction . 31 6.2 G¨odel’s T ..............................
    [Show full text]
  • Arxiv:Cs/0610066V2 [Cs.LO] 16 Sep 2013 Eusv Entos Ye Lambda-Calculus
    Inductive Data Type Systems Fr´ed´eric Blanqui, Jean-Pierre Jouannaud LRI, Bˆat. 490, Universit´eParis-Sud 91405 Orsay, FRANCE Tel: (33) 1.69.15.69.05 Fax: (33) 1.69.15.65.86 http://www.lri.fr/~blanqui/ Mitsuhiro Okada Department of Philosophy, Keio University, 108 Minatoku, Tokyo, JAPAN Abstract In a previous work (“Abstract Data Type Systems”, TCS 173(2), 1997), the last two authors presented a combined language made of a (strongly normalizing) algebraic rewrite system and a typed λ-calculus enriched by pattern-matching definitions following a certain format, called the “General Schema”, which gen- eralizes the usual recursor definitions for natural numbers and similar “basic inductive types”. This combined language was shown to be strongly normaliz- ing. The purpose of this paper is to reformulate and extend the General Schema in order to make it easily extensible, to capture a more general class of inductive types, called “strictly positive”, and to ease the strong normalization proof of the resulting system. This result provides a computation model for the combi- nation of an algebraic specification language based on abstract data types and of a strongly typed functional language with strictly positive inductive types. Keywords: Higher-order rewriting. Strong normalization. Inductive types. Recursive definitions. Typed lambda-calculus. arXiv:cs/0610066v2 [cs.LO] 16 Sep 2013 1. Introduction This work is one step in a long term program aiming at building formal spec- ification languages integrating computations and proofs within a single frame- work. We focus here on incorporating an expressive notion of equality within a typed λ-calculus.
    [Show full text]