DOCSLIB.ORG

Dependent Type Theory Lecture 1

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Dependent Type Theory Lecture 1 Dependent Type Theory Lecture 1 Nicola Gambino MGS - Leicester 2009 Nicola Gambino Dependent Type Theory References B. Nordstöm, K. Petersson, and J. M. Smith Martin-Löf’s Type Theory Handbook of Logic in Computer Science, Vol. 5 Oxford University Press, 2001. B. Nordström, K. Petersson, and J. M. Smith Programming in Martin-Löf’s Type Theory Oxford University Press, 1990. Nicola Gambino Dependent Type Theory Outline 1 Preliminaries 2 The dependent type theory ML Nicola Gambino Dependent Type Theory Categorical judgements There are four forms of categorical judgements: A ∈ Type A = B ∈ Type a ∈ A a = b ∈ A These express, respectively, that: A is a type A and B are definitionally equal types a is an element of A a and b are definitionally equal elements of A. Nicola Gambino Dependent Type Theory Hypothetical judgements (I) There are four forms of hypothetical judgements: (Γ) A ∈ Type (Γ) A = B ∈ Type (Γ) a ∈ A (Γ) a = b ∈ A. Here Γ is a context of variable declarations of the form (Γ) = x0 ∈ A0, x1 ∈ A1(x0),..., xn ∈ An(x0,..., xn−1) . Nicola Gambino Dependent Type Theory Hypothetical judgements (II) For the context Γ to be well-formed we need to know that the judgements A0 ∈ Type (x0 ∈ A0) A1(x0) ∈ Type . x0 ∈ A0,..., xn−1 ∈ An−1(x0,..., xn−2) An(x0,..., xn−1) ∈ Type are derivable. Nicola Gambino Dependent Type Theory Deduction rules Deduction rules have the form (Γ1) J1 ··· (Γn) Jn (Γ) J We often omit contexts that are common to premisses and conclusion. Nicola Gambino Dependent Type Theory Outline √ 1 Preliminaries 2 The dependent type theory ML Nicola Gambino Dependent Type Theory The dependent type theory ML (I) Two groups of rules: General deduction rules, e.g. (Γ) A ∈ Type (Γ, x ∈ A) x ∈ A Deduction rules for the following forms of type: 0 , 1 , Nat , A + B , IdA(a, b) , (Σx ∈ A)B(x) , (Πx ∈ A)B(x) . Nicola Gambino Dependent Type Theory The dependent type theory ML (II) For each form of type, we give four groups of deduction rules: Formation rules Introduction rules Elimination rules Computation rules Nicola Gambino Dependent Type Theory Deduction rules for the type of natural numbers (I) Formation rule: Nat ∈ Type Introduction rules: n ∈ Nat 0 ∈ Nat succ(n) ∈ Nat Nicola Gambino Dependent Type Theory Deduction rules for the type of natural numbers (II) Elimination rule: c ∈ Nat d ∈ C(0)(x ∈ Nat, y ∈ C(x)) e(x, y) ∈ C(succ(x)) natrec(c, d, e) ∈ C(c) Computation rules: d ∈ C(0)(x ∈ Nat, y ∈ C(x)) e(x, y) ∈ C(succ(x)) natrec(0, d, e) = d ∈ C(0) n ∈ Nat d ∈ C(0)(x ∈ Nat, y ∈ C(x)) e(x, y) ∈ C(succ(x)) natrec(succ(n), d, e) = e(n, natrec(n, d, e)) ∈ C(succ(n)) Nicola Gambino Dependent Type Theory Deduction rules for the unit type (I) Formation rules: 1 ∈ Type Introduction rule: ∗ ∈ 1 Nicola Gambino Dependent Type Theory Deduction rules for the unit type (II) Elimination rule: c ∈ 1 d ∈ C(∗) rec(c, d) ∈ C(c) Computation rule: d ∈ C(∗) rec(∗, d) = d ∈ C(∗) Nicola Gambino Dependent Type Theory Deduction rules for the empty type (I) Formation rule: 0 ∈ Type Introduction rules: Nicola Gambino Dependent Type Theory Deduction rules for the empty type (II) Elimination rule: c ∈ 0 rec(c) ∈ C(c) Computation rules: Nicola Gambino Dependent Type Theory Deduction rules for sum types (I) Formation rules: A ∈ Type B ∈ Type A + B ∈ Type Introduction rules: a ∈ A b ∈ B inl(a) ∈ A + B inr(b) ∈ A + B Nicola Gambino Dependent Type Theory Deduction rules for sum types (II) Elimination rule: c ∈ A + B (x ∈ A) d(x) ∈ C(inl(x)) (y ∈ B) e(y) ∈ C(inr(y)) case(c, d, e) ∈ C(c) Computation rules: a ∈ A (x ∈ A) d(x) ∈ C(inl(x)) (y ∈ B) e(y) ∈ C(inr(y)) case(inl(a), d, e) = d(a) ∈ C(inl(a)) b ∈ B (x ∈ A) d(x) ∈ C(inl(x)) (y ∈ B) e(y) ∈ C(inr(y)) case(inr(b), d, e) = e(b) ∈ C(inr(b)) Nicola Gambino Dependent Type Theory Deduction rules for identity types (I) Formation rule: A ∈ Type a ∈ A b ∈ A IdA(a, b) ∈ Type Introduction rule: a ∈ A r(a) ∈ IdA(a, a) Nicola Gambino Dependent Type Theory Deduction rules for identity types (II) Elimination rule: p ∈ IdA(a, b)(x ∈ A) d(x) ∈ C(x, x, r(x)) J(a, b, p, d) ∈ C(a, b, p) Computation rule: a ∈ A (x ∈ A) d(x) ∈ C(x, x, r(x)) J(a, a, r(a), d) = d(a) ∈ C(a, a, r(a)) Nicola Gambino Dependent Type Theory Deduction rules for Σ-types (I) Formation rule: (x ∈ A) B(x) ∈ Type (Σx ∈ A)B(x) ∈ Type Introduction rule: a ∈ A b ∈ B(a) pair(a, b) ∈ (Σx ∈ A)B(x) Nicola Gambino Dependent Type Theory Deduction rules for Σ-types (II) Elimination rule: c ∈ (Σx ∈ A)B(x)(x ∈ A, y ∈ B(x)) d(x, y) ∈ C(pair(x, y)) split(c, d) ∈ C(c) Computation rule: a ∈ A b ∈ B(a)(x ∈ A, y ∈ B(x)) d(x, y) ∈ C(pair(x, y)) split(pair(a, b), d) = d(a, b) ∈ C(pair(a, b)) Nicola Gambino Dependent Type Theory Deduction rules for Π-types (I) Formation rule: (x ∈ A) B(x) ∈ Type (Πx ∈ A)B(x) ∈ Type Introduction rule: (x ∈ A) b(x) ∈ B(x) (λx ∈ A)b(x) ∈ (Πx ∈ A)B(x) Nicola Gambino Dependent Type Theory Deduction rules for Π-types (II) Elimination rule: b ∈ (Πx ∈ A)B(x) ∈ Type a ∈ A app(b, a) ∈ B(a) Computation rule: (x ∈ A) b(x) ∈ B(x) a ∈ A app((λx ∈ A)b(x), a) = b(a) ∈ B(a) Nicola Gambino Dependent Type Theory Remarks We used ‘Type’ for what is called ‘Set’ in the Handbook paper. We did not use explicitly any logical framework. Nicola Gambino Dependent Type Theory.
Load more

Recommended publications
  • Types Are Internal Infinity-Groupoids Antoine Allioux, Eric Finster, Matthieu Sozeau
    Types are internal infinity-groupoids Antoine Allioux, Eric Finster, Matthieu Sozeau To cite this version: Antoine Allioux, Eric Finster, Matthieu Sozeau. Types are internal infinity-groupoids. 2021. hal- 03133144 HAL Id: hal-03133144 https://hal.inria.fr/hal-03133144 Preprint submitted on 5 Feb 2021 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. Types are Internal 1-groupoids Antoine Allioux∗, Eric Finstery, Matthieu Sozeauz ∗Inria & University of Paris, France [email protected] yUniversity of Birmingham, United Kingdom ericfi[email protected] zInria, France [email protected] Abstract—By extending type theory with a universe of defini- attempts to import these ideas into plain homotopy type theory tionally associative and unital polynomial monads, we show how have, so far, failed. This appears to be a result of a kind of to arrive at a definition of opetopic type which is able to encode circularity: all of the known classical techniques at some point a number of fully coherent algebraic structures. In particular, our approach leads to a definition of 1-groupoid internal to rely on set-level algebraic structures themselves (presheaves, type theory and we prove that the type of such 1-groupoids is operads, or something similar) as a means of presenting or equivalent to the universe of types.
    [Show full text]
  • Sequent Calculus and Equational Programming (Work in Progress)
    Sequent Calculus and Equational Programming (work in progress) Nicolas Guenot and Daniel Gustafsson IT University of Copenhagen {ngue,dagu}@itu.dk 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. 1 Programming with Equations Functional programming has proved extremely useful in making the task of writing correct software more abstract and thus less tied to the specific, and complex, architecture of modern computers. This, is in a large part, due to its extensive use of types as an abstraction mechanism, specifying in a crisp way the intended behaviour of a program, but it also relies on its declarative style, as a mathematical approach to functions and data structures. However, the vast gain in expressivity obtained through the development of dependent types makes the programming task more challenging, as it amounts to the question of proving complex theorems — as illustrated by the double nature of proof assistants such as Coq [11] and Agda [18]. Keeping this task as simple as possible is then of the highest importance, and it requires the use of a clear declarative style.
    [Show full text]
  • On Modeling Homotopy Type Theory in Higher Toposes
    Review: model categories for type theory Left exact localizations Injective fibrations On modeling homotopy type theory in higher toposes Mike Shulman1 1(University of San Diego) Midwest homotopy type theory seminar Indiana University Bloomington March 9, 2019 Review: model categories for type theory Left exact localizations Injective fibrations Here we go Theorem Every Grothendieck (1; 1)-topos can be presented by a model category that interprets \Book" Homotopy Type Theory with: • Σ-types, a unit type, Π-types with function extensionality, and identity types. • Strict universes, closed under all the above type formers, and satisfying univalence and the propositional resizing axiom. Review: model categories for type theory Left exact localizations Injective fibrations Here we go Theorem Every Grothendieck (1; 1)-topos can be presented by a model category that interprets \Book" Homotopy Type Theory with: • Σ-types, a unit type, Π-types with function extensionality, and identity types. • Strict universes, closed under all the above type formers, and satisfying univalence and the propositional resizing axiom. Review: model categories for type theory Left exact localizations Injective fibrations Some caveats 1 Classical metatheory: ZFC with inaccessible cardinals. 2 Classical homotopy theory: simplicial sets. (It's not clear which cubical sets can even model the (1; 1)-topos of 1-groupoids.) 3 Will not mention \elementary (1; 1)-toposes" (though we can deduce partial results about them by Yoneda embedding). 4 Not the full \internal language hypothesis" that some \homotopy theory of type theories" is equivalent to the homotopy theory of some kind of (1; 1)-category. Only a unidirectional interpretation | in the useful direction! 5 We assume the initiality hypothesis: a \model of type theory" means a CwF.
    [Show full text]
  • Indexed Induction-Recursion
    Indexed Induction-Recursion Peter Dybjer a;? aDepartment of Computer Science and Engineering, Chalmers University of Technology, 412 96 G¨oteborg, Sweden Email: [email protected], http://www.cs.chalmers.se/∼peterd/, Tel: +46 31 772 1035, Fax: +46 31 772 3663. Anton Setzer b;1 bDepartment of Computer Science, University of Wales Swansea, Singleton Park, Swansea SA2 8PP, UK, Email: [email protected], http://www.cs.swan.ac.uk/∼csetzer/, Tel: +44 1792 513368, Fax: +44 1792 295651. Abstract An indexed inductive definition (IID) is a simultaneous inductive definition of an indexed family of sets. An inductive-recursive definition (IRD) is a simultaneous inductive definition of a set and a recursive definition of a function from that set into another type. An indexed inductive-recursive definition (IIRD) is a combination of both. We present a closed theory which allows us to introduce all IIRDs in a natural way without much encoding. By specialising it we also get a closed theory of IID. Our theory of IIRDs includes essentially all definitions of sets which occur in Martin-L¨of type theory. We show in particular that Martin-L¨of's computability predicates for dependent types and Palmgren's higher order universes are special kinds of IIRD and thereby clarify why they are constructively acceptable notions. We give two axiomatisations. The first and more restricted one formalises a prin- ciple for introducing meaningful IIRD by using the data-construct in the original version of the proof assistant Agda for Martin-L¨of type theory. The second one admits a more general form of introduction rule, including the introduction rule for the intensional identity relation, which is not covered by the restricted one.
    [Show full text]
  • Proof-Assistants Using Dependent Type Systems
    CHAPTER 18 Proof-Assistants Using Dependent Type Systems Henk Barendregt Herman Geuvers Contents I Proof checking 1151 2 Type-theoretic notions for proof checking 1153 2.1 Proof checking mathematical statements 1153 2.2 Propositions as types 1156 2.3 Examples of proofs as terms 1157 2.4 Intermezzo: Logical frameworks. 1160 2.5 Functions: algorithms versus graphs 1164 2.6 Subject Reduction . 1166 2.7 Conversion and Computation 1166 2.8 Equality . 1168 2.9 Connection between logic and type theory 1175 3 Type systems for proof checking 1180 3. l Higher order predicate logic . 1181 3.2 Higher order typed A-calculus . 1185 3.3 Pure Type Systems 1196 3.4 Properties of P ure Type Systems . 1199 3.5 Extensions of Pure Type Systems 1202 3.6 Products and Sums 1202 3.7 E-typcs 1204 3.8 Inductive Types 1206 4 Proof-development in type systems 1211 4.1 Tactics 1212 4.2 Examples of Proof Development 1214 4.3 Autarkic Computations 1220 5 P roof assistants 1223 5.1 Comparing proof-assistants . 1224 5.2 Applications of proof-assistants 1228 Bibliography 1230 Index 1235 Name index 1238 HANDBOOK OF AUTOMAT8D REASONING Edited by Alan Robinson and Andrei Voronkov © 2001 Elsevier Science Publishers 8.V. All rights reserved PROOF-ASSISTANTS USING DEPENDENT TYPE SYSTEMS 1151 I. Proof checking Proof checking consists of the automated verification of mathematical theories by first fully formalizing the underlying primitive notions, the definitions, the axioms and the proofs. Then the definitions are checked for their well-formedness and the proofs for their correctness, all this within a given logic.
    [Show full text]
  • Formal Systems: Combinatory Logic and -Calculus
    INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION FORMAL SYSTEMS:COMBINATORY LOGIC AND λ-CALCULUS Andrew R. Plummer Department of Linguistics The Ohio State University 30 Sept., 2009 INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION OUTLINE 1 INTRODUCTION 2 APPLICATIVE SYSTEMS 3 USEFUL INFORMATION INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION COMBINATORY LOGIC We present the foundations of Combinatory Logic and the λ-calculus. We mean to precisely demonstrate their similarities and differences. CURRY AND FEYS (KOREAN FACE) The material discussed is drawn from: Combinatory Logic Vol. 1, (1958) Curry and Feys. Lambda-Calculus and Combinators, (2008) Hindley and Seldin. INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION FORMAL SYSTEMS We begin with some definitions. FORMAL SYSTEMS A formal system is composed of: A set of terms; A set of statements about terms; A set of statements, which are true, called theorems. INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION FORMAL SYSTEMS TERMS We are given a set of atomic terms, which are unanalyzed primitives. We are also given a set of operations, each of which is a mode for combining a finite sequence of terms to form a new term. Finally, we are given a set of term formation rules detailing how to use the operations to form terms. INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION FORMAL SYSTEMS STATEMENTS We are given a set of predicates, each of which is a mode for forming a statement from a finite sequence of terms. We are given a set of statement formation rules detailing how to use the predicates to form statements. INTRODUCTION APPLICATIVE SYSTEMS USEFUL INFORMATION FORMAL SYSTEMS THEOREMS We are given a set of axioms, each of which is a statement that is unconditionally true (and thus a theorem).
    [Show full text]
  • Wittgenstein, Turing and Gödel
    Wittgenstein, Turing and Gödel Juliet Floyd Boston University Lichtenberg-Kolleg, Georg August Universität Göttingen Japan Philosophy of Science Association Meeting, Tokyo, Japan 12 June 2010 Wittgenstein on Turing (1946) RPP I 1096. Turing's 'Machines'. These machines are humans who calculate. And one might express what he says also in the form of games. And the interesting games would be such as brought one via certain rules to nonsensical instructions. I am thinking of games like the “racing game”. One has received the order "Go on in the same way" when this makes no sense, say because one has got into a circle. For that order makes sense only in certain positions. (Watson.) Talk Outline: Wittgenstein’s remarks on mathematics and logic Turing and Wittgenstein Gödel on Turing compared Wittgenstein on Mathematics and Logic . The most dismissed part of his writings {although not by Felix Mülhölzer – BGM III} . Accounting for Wittgenstein’s obsession with the intuitive (e.g. pictures, models, aspect perception) . No principled finitism in Wittgenstein . Detail the development of Wittgenstein’s remarks against background of the mathematics of his day Machine metaphors in Wittgenstein Proof in logic is a “mechanical” expedient Logical symbolisms/mathematical theories are “calculi” with “proof machinery” Proofs in mathematics (e.g. by induction) exhibit or show algorithms PR, PG, BB: “Can a machine think?” Language (thought) as a mechanism Pianola Reading Machines, the Machine as Symbolizing its own actions, “Is the human body a thinking machine?” is not an empirical question Turing Machines Turing resolved Hilbert’s Entscheidungsproblem (posed in 1928): Find a definite method by which every statement of mathematics expressed formally in an axiomatic system can be determined to be true or false based on the axioms.
    [Show full text]
  • Proof Theory of Constructive Systems: Inductive Types and Univalence
    Proof Theory of Constructive Systems: Inductive Types and Univalence Michael Rathjen Department of Pure Mathematics University of Leeds Leeds LS2 9JT, England [email protected] Abstract In Feferman’s work, explicit mathematics and theories of generalized inductive definitions play a cen- tral role. One objective of this article is to describe the connections with Martin-L¨of type theory and constructive Zermelo-Fraenkel set theory. Proof theory has contributed to a deeper grasp of the rela- tionship between different frameworks for constructive mathematics. Some of the reductions are known only through ordinal-theoretic characterizations. The paper also addresses the strength of Voevodsky’s univalence axiom. A further goal is to investigate the strength of intuitionistic theories of generalized inductive definitions in the framework of intuitionistic explicit mathematics that lie beyond the reach of Martin-L¨of type theory. Key words: Explicit mathematics, constructive Zermelo-Fraenkel set theory, Martin-L¨of type theory, univalence axiom, proof-theoretic strength MSC 03F30 03F50 03C62 1 Introduction Intuitionistic systems of inductive definitions have figured prominently in Solomon Feferman’s program of reducing classical subsystems of analysis and theories of iterated inductive definitions to constructive theories of various kinds. In the special case of classical theories of finitely as well as transfinitely iterated inductive definitions, where the iteration occurs along a computable well-ordering, the program was mainly completed by Buchholz, Pohlers, and Sieg more than 30 years ago (see [13, 19]). For stronger theories of inductive 1 i definitions such as those based on Feferman’s intutitionic Explicit Mathematics (T0) some answers have been provided in the last 10 years while some questions are still open.
    [Show full text]
  • CS 6110 S18 Lecture 32 Dependent Types 1 Typing Lists with Lengths
    CS 6110 S18 Lecture 32 Dependent Types When we added kinding last time, part of the motivation was to complement the functions from types to terms that we had in System F with functions from types to types. Of course, all of these languages have plain functions from terms to terms. So it's natural to wonder what would happen if we added functions from values to types. The result is a language with \compile-time" types that can depend on \run-time" values. While this arrangement might seem paradoxical, it is a very powerful way to express the correctness of programs; and via the propositions-as-types principle, it also serves as the foundation for a modern crop of interactive theorem provers. The language feature is called dependent types (i.e., types depend on terms). Prominent dependently-typed languages include Coq, Nuprl, Agda, Lean, F*, and Idris. Some of these languages, like Coq and Nuprl, are more oriented toward proving things using propositions as types, and others, like F* and Idris, are more oriented toward writing \normal programs" with strong correctness guarantees. 1 Typing Lists with Lengths Dependent types can help avoid out-of-bounds errors by encoding the lengths of arrays as part of their type. Consider a plain recursive IList type that represents a list of any length. Using type operators, we might use a general type List that can be instantiated as List int, so its kind would be type ) type. But let's use a fixed element type for now. With dependent types, however, we can make IList a type constructor that takes a natural number as an argument, so IList n is a list of length n.
    [Show full text]
  • Reasoning in an ∞-Topos with Homotopy Type Theory
    Reasoning in an 1-topos with homotopy type theory Dan Christensen University of Western Ontario 1-Topos Institute, April 1, 2021 Outline: Introduction to homotopy type theory Examples of applications to 1-toposes 1 / 23 2 / 23 Motivation for Homotopy Type Theory People study type theory for many reasons. I'll highlight two: Its intrinsic homotopical/topological content. Things we prove in type theory are true in any 1-topos. Its suitability for computer formalization. This talk will focus on the first point. So, what is an 1-topos? 3 / 23 1-toposes An 1-category has objects, (1-)morphisms between objects, 2-morphisms between 1-morphisms, etc., with all k-morphisms invertible for k > 1. Alternatively: a category enriched over spaces. The prototypical example is the 1-category of spaces. An 1-topos is an 1-category C that shares many properties of the 1-category of spaces: C is presentable. In particular, C is cocomplete. C satisfies descent. In particular, C is locally cartesian closed. Examples include Spaces, slice categories such as Spaces/S1, and presheaves of Spaces, such as G-Spaces for a group G. If C is an 1-topos, so is every slice category C=X. 4 / 23 History of (Homotopy) Type Theory Dependent type theory was introduced in the 1970's by Per Martin-L¨of,building on work of Russell, Church and others. In 2006, Awodey, Warren, and Voevodsky discovered that dependent type theory has homotopical models, extending 1998 work of Hofmann and Streicher. At around this time, Voevodsky discovered his univalance axiom.
    [Show full text]
  • Dependent Types: Easy As PIE
    Dependent Types: Easy as PIE Work-In-Progress Project Description Dimitrios Vytiniotis and Stephanie Weirich University of Pennsylvania Abstract Dependent type systems allow for a rich set of program properties to be expressed and mechanically verified via type checking. However, despite their significant expres- sive power, dependent types have not yet advanced into mainstream programming languages. We believe the reason behind this omission is the large design space for dependently typed functional programming languages, and the consequent lack of ex- perience in dependently-typed programming and language implementations. In this newly-started project, we lay out the design considerations for a general-purpose, ef- fectful, functional, dependently-typed language, called PIE. The goal of this project is to promote dependently-typed programming to a mainstream practice. 1 INTRODUCTION The goal of static type systems is to identify programs that contain errors. The type systems of functional languages, such as ML and Haskell, have been very successful in this respect. However, these systems can ensure only relatively weak safety properties—there is a wide range of semantic errors that these systems can- not eliminate. As a result, there is growing consensus [13, 15, 28, 27, 26, 6, 7, 20, 21, 16, 11, 2, 25, 19, 1, 22] that the right way to make static type systems more expressive in this respect is to adopt ideas from dependent type theory [12]. Types in dependent type systems can carry significant information about program values. For example, a datatype for network packets may describe the internal byte align- ment of variable-length subfields. In such precise type systems, programmers can express many of complex properties about programs—e.g.
    [Show full text]
  • Warren Goldfarb, Notes on Metamathematics
    Notes on Metamathematics Warren Goldfarb W.B. Pearson Professor of Modern Mathematics and Mathematical Logic Department of Philosophy Harvard University DRAFT: January 1, 2018 In Memory of Burton Dreben (1927{1999), whose spirited teaching on G¨odeliantopics provided the original inspiration for these Notes. Contents 1 Axiomatics 1 1.1 Formal languages . 1 1.2 Axioms and rules of inference . 5 1.3 Natural numbers: the successor function . 9 1.4 General notions . 13 1.5 Peano Arithmetic. 15 1.6 Basic laws of arithmetic . 18 2 G¨odel'sProof 23 2.1 G¨odelnumbering . 23 2.2 Primitive recursive functions and relations . 25 2.3 Arithmetization of syntax . 30 2.4 Numeralwise representability . 35 2.5 Proof of incompleteness . 37 2.6 `I am not derivable' . 40 3 Formalized Metamathematics 43 3.1 The Fixed Point Lemma . 43 3.2 G¨odel'sSecond Incompleteness Theorem . 47 3.3 The First Incompleteness Theorem Sharpened . 52 3.4 L¨ob'sTheorem . 55 4 Formalizing Primitive Recursion 59 4.1 ∆0,Σ1, and Π1 formulas . 59 4.2 Σ1-completeness and Σ1-soundness . 61 4.3 Proof of Representability . 63 3 5 Formalized Semantics 69 5.1 Tarski's Theorem . 69 5.2 Defining truth for LPA .......................... 72 5.3 Uses of the truth-definition . 74 5.4 Second-order Arithmetic . 76 5.5 Partial truth predicates . 79 5.6 Truth for other languages . 81 6 Computability 85 6.1 Computability . 85 6.2 Recursive and partial recursive functions . 87 6.3 The Normal Form Theorem and the Halting Problem . 91 6.4 Turing Machines .
    [Show full text]