Iowa Type Theory Commute

Coercive subtyping and coherence

Wed, 01 Jul 2026 14:00:00 -0500

In this episode, I give further arguments in favor of coercive subtyping from a software-engineering perspective. I also explain the critical concept of coherence.

A Strange Deal, Explained

Thu, 07 May 2026 09:00:00 -0500

I explain the story from last episode.

A Strange Deal

Thu, 30 Apr 2026 22:00:00 -0500

The Curry-Howard isomorphism for the law of excluded middle, as a radio drama. I first saw a version of this story performed by Phil Wadler and Frank Pfenning (wearing fake horns!) at RTA in Nara, Japan in 2005. This is my take on it. In a subsequent episode, I will explain how the story illustrates the computational interpretation of the law of excluded middle.

Great paper: The Calculated Typer

Mon, 20 Apr 2026 10:00:00 -0500

I discuss a nice paper I quite enjoyed reading, called The Calculated Typer, by Garby, Bahr, and Hutton. The authors take a very nice general look at the specification of a type checker, for a very simple expression language. They then manually derive the actual code for the type checker by effectively trying to prove that this as yet unknown code satisfies its spec. (This is what is meant by calculating the type checker.)

Double-negation translations and CPS conversion, part 2

Thu, 02 Apr 2026 16:00:00 -0500

In this episode, I talk about the control operator callcc, and how it is implemented during compilation using continuation-passing style (CPS). I sketch how CPS conversion (transforming a program with callcc into one in CPS that does not need callcc any more) corresponds to double-negation translation from classical to intuitionistic logic. The paper I am referencing is here.

Double-negation translations and CPS conversion, part 1

Tue, 31 Mar 2026 10:00:00 -0500

In this episode, I talk about a somewhat more advanced case of the Curry-Howard isomorphism (the connection between logic and programming languages where formulas in logic are identified with types, and proofs with programs). This is the identification of double-negation translations in logic, which go back to a paper of Kolmogorov's in 1925, with conversion to continuation-passing style (CPS), a compilation technique. For this episode, we just discuss the idea of double-negation translation: classical theorems can be translated to intuitionistic ones, by adding some double negations. As an example, we talk through the intuitionistic proof of the double negation of the law of excluded middle: not not (p or not p).

What are commuting conversions in proof theory?

Tue, 03 Mar 2026 11:00:00 -0600

Commuting conversions are transformations on proofs in natural deduction, that move certain stuck inferences out of the way, so that the normal detour reductions (which correspond to beta-reduction under Curry-Howard) are enabled. The stuck inferences are uses of disjunction elimination. In programming terms, if you have an if-then-else (a simple case of or-elimination) where the then- and else-branches are lambda abstractions, and you apply that if-then-else to an argument, you need commuting conversions to move the argument into the branches, so you can call the functions (in the then- and else-branches) with it.

See Section 10.1 of Girard's Proofs and Types for more on the problem, and a nice paper by de Groote on strong normalization with commuting conversions.

What is Control Flow Analysis for Lambda Calculus?

Fri, 16 Jan 2026 10:00:00 -0600

I am currently on a frolic into the literature on Control Flow Analysis (CFA), and discuss what this is, for pure lambda calculus. A wonderful reference for this is this paper by Palsberg.

Measure Functions and Termination of STLC

Fri, 14 Nov 2025 17:00:00 -0600

In this episode, I talk about what we should consider to be a measure function. Such functions can be used to show termination of some process or program, by assigning a measure to each program, and showing that as the program computes, the measure decreases in some well-founded ordering. But what should count as a measure function? The context for this is RTA Open Problem 19, on showing termination for the simply typed lambda calculus using a measure function.

Let's call this the start of season 7, because it seems about time for that.

Schematic Affine Recursion, Oh My!

Fri, 22 Aug 2025 17:00:00 -0500

To solve the problem raised in the last episode, I propose schematic affine recursion. We saw that affine lambda calculus (where lambda-bound variables are used at most once) plus structural recursion does not enforce termination, even if you restrict the recursor so that the function to be iterated is closed when you reduce ("closed at reduction"). You have to restrict it so that recursion terms are disallowed entirely unless the function to be iterated is closed ("closed at construction"). But this prevents higher-order functions like map, which need to repeat a computation involving a variable f to be mapped over the elements of a list. The solution is to allow schematic definition of terms, using schema variables ranging over closed terms.

The Stunner: Linear System T is Diverging!

Tue, 19 Aug 2025 17:00:00 -0500

In this episode, I shoot down last episode's proposal -- at least in the version I discussed -- based on an amazing observation from an astonishing paper, "Gödel’s system T revisited", by Alves, Fernández, Florido, and Mackie. Linear System T is diverging, as they reveal through a short but clever example. It is even diverging if one requires that the iterator can only be reduced when the function to be iterated is closed (no free variables). This extraordinary observation does not sink Victor's idea of basing type theory on a terminating untyped core language, but it does sink the specific language he and I were thinking about, namely affine lambda calculus plus structural recursion.

My notes are here.

Terminating Computation First?

Fri, 01 Aug 2025 08:00:00 -0500

In this episode, I discuss an intriguing idea proposed by Victor Taelin, to base a logically sound type theory on an untyped but terminating language, upon which one may then erect as exotic a type system as one wishes. By enforcing termination already for the untyped language, we no longer have to make the type system do the heavy work of enforcing termination.

Correction: the Correct Author of the Proof from Last Episode, and an AI flop

Mon, 12 May 2025 15:00:00 -0500

I correct what I said in the last episode about the author of the proof of FD from last episode based on intersection types. I also describe AI flopping when I ask it a question about this.

Krivine's Proof of FD, Using Intersection Types

Mon, 05 May 2025 15:00:00 -0500

Krivine's book (Section 4.2) has a proof of the Finite Developments Theorem, based on intersection types. I discuss this proof in this episode.

A Measure-Based Proof of Finite Developments

Wed, 16 Apr 2025 16:00:00 -0500

I discuss the paper "A Direct Proof of the Finite Developments Theorem", by Roel de Vrijer. See also the write-up at my blog.

Introduction to the Finite Developments Theorem

Thu, 27 Mar 2025 12:00:00 -0500

The finite developments theorem in pure lambda calculus says that if you select as set of redexes in a lambda term and reduce only those and their residuals (redexes that can be traced back as existing in the original set), then this process will always terminate. In this episode, I discuss the theorem and why I got interested in it.

Nominal Isabelle/HOL

Fri, 31 Jan 2025 13:00:00 -0600

In this episode, I discuss the paper Nominal Techniques in Isabelle/HOL, by Christian Urban. This paper shows how to reason with terms modulo alpha-equivalence, using ideas from nominal logic. The basic idea is that instead of renamings, one works with permutations of names.

The Locally Nameless Representation

Thu, 02 Jan 2025 22:00:00 -0600

I discuss what is called the locally nameless representation of syntax with binders, following the first couple of sections of the very nicely written paper "The Locally Nameless Representation," by Charguéraud. I complain due to the statement in the paper that "the theory of λ-calculus identifies terms that are α-equivalent," which is simply not true if one is considering lambda calculus as defined by Church, where renaming is an explicit reduction step, on a par with beta-reduction. I also answer a listener's question about what "computational type theory" means.

Feel free to email me any time at aaron.stump@bc.edu, or join the Telegram group for the podcast.

POPLmark Reloaded, Part 2

Sun, 22 Dec 2024 19:00:00 -0600

I continue the discussion of POPLmark Reloaded , discussing the solutions proposed to the benchmark problem. The solutions are in the Beluga, Coq (recently renamed Rocq), and Agda provers.

POPLmark Reloaded, Part 1

Sun, 22 Dec 2024 19:00:00 -0600

I discuss the paper POPLmark Reloaded: Mechanizing Proofs by Logical Relations, which proposes a benchmark problem for mechanizing Programming Language theory.

Introduction to Formalizing Programming Languages Theory

Mon, 25 Nov 2024 11:00:00 -0600

In this episode, I begin discussing the question and history of formalizing results in Programming Languages Theory using interactive theorem provers like Rocq (formerly Coq) and Agda.

Turing's proof of normalization for STLC

Mon, 20 May 2024 22:00:00 -0500

In this episode, I describe the first proof of normalization for STLC, written by Alan Turing in the 1940s. See this short note for Turing's original proof and some historical comments.

Introduction to normalization for STLC

Mon, 13 May 2024 23:00:00 -0500

In this episode, after a quick review of the preceding couple, I discuss the property of normalization for STLC, and talk a bit about proof methods. We will look at proofs in more detail in the coming episodes. Feel free to join the Telegram group for the podcast if you want to discuss anything (or just email me at aaron.stump@gmail.com).

The curious case of exponentiation in simply typed lambda calculus

Sat, 04 May 2024 09:00:00 -0500

Like addition and multiplication on Church-encoded numbers, exponentiation can be assigned a type in simply typed lambda calculus (STLC). But surprisingly, the type is non-uniform. If we abbreviate (A -> A) -> A -> A as Nat_A, then exponentiation, which is defined as \ x . \ y . y x, can be assigned type Nat_A -> Nat_(A -> A) -> Nat_A. The second argument needs to have type at strictly higher order than the first argument. This has the fascinating consequence that we cannot define self-exponentiation, \ x . exp x x. That term would reduce to \ x . x x, which is provably not typable in STLC.

Arithmetic operations in simply typed lambda calculus

Sat, 04 May 2024 09:00:00 -0500

It is maybe not so well known that arithmetic operations -- at least some of them -- can be implemented in simply typed lambda calculus (STLC). Church-encoded numbers can be given the simple type (A -> A) -> A -> A, for any simple type A. If we abbreviate that type as Nat_A, then addition and multiplication can both be typed in STLC, at type Nat_A -> Nat_A -> Nat_A. Interestingly, things change with exponentiation, which we will consider in the next episode.

More on basics of simple types

Mon, 29 Apr 2024 10:00:00 -0500

I review the typing rules and some basic examples for STLC. I also remind listeners of the Curry-Howard isomorphism for STLC.

Begin Chapter on Simple Type Theory

Fri, 19 Apr 2024 11:00:00 -0500

In this episode, after a pretty long hiatus, I start a new chapter on simply typed lambda calculus. I present the typing rules and give some basic examples. Subsequent episodes will discuss various interesting nuances...

Some advanced examples in DCS

Sun, 24 Sep 2023 22:00:00 -0500

This episode presents two somewhat more advanced examples in DCS. They are Harper's continuation-based regular-expression matcher, and Bird's quickmin, which finds the least natural number not in a given list of distinct natural numbers, in linear time. I explain these examples in detail and then discuss how they are implemented in DCS, which ensures that they are terminating on all inputs.

DCS compared to termination checkers for type theories

Mon, 18 Sep 2023 22:00:00 -0500

In this episode, I continue introducing DCS by comparing it to termination checkers in constructive type theories like Coq, Agda, and Lean. I warmly invite ITTC listeners to experiment with the tool themselves. The repo is here.

Getting started with DCS

Sat, 09 Sep 2023 23:00:00 -0500

In this episode, I talk more about the DCS tool, and invite listeners to check it out and possibly contribute! The repo is here.

Introduction to DCS

Sun, 03 Sep 2023 23:00:00 -0500

DCS is a new functional programming language I am designing and implementing with Stefan Monnier. DCS has a pure, terminating core, around which monads will be layered for possibly diverging, impure computation. In this episode, I talk about this basic design, and its rationale.

Semantics of subtyping

Sun, 23 Jul 2023 22:00:00 -0500

I answer a listener's question about the semantics of subtyping, by discussing two different semantics: coercive subtyping and subsumptive subtyping. The terminology I found in this paper by Zhaohui Luo; see Section 4 of the paper for a comparison of the two kinds of subtyping. With coercive subtyping, we have subtyping axioms "A <: B by c", where c is a function from A to B. The idea is that the compiler should automatically insert calls to c whenever an expression of type A needs to be converted to one of type B. Subsumptive subtyping says that A <: B means that the meaning of A is a subset of the meaning of B. So this kind of subtyping depends on a semantics for types. A simple choice is to interpret a type A as (as least roughly) the set of its inhabitants. So a type like Integer might be interpreted as the set of all integers, etc. Luo argues that subsumptive subtyping does not work for Martin-Loef type theory, where type annotations are inherent parts of terms. For in that situation, A <: B does not imply List A <: List B, because Nil A is an inhabitant of List A but not of List B (which requires instead Nil B).

Join the telegram group here.

More on type inference for simple subtypes

Sat, 15 Jul 2023 21:00:00 -0500

I continue the discussion of Mitchell's paper Type Inference with Simple Subtypes. Coming soon: a discussion of semantics of subtyping.

Subtyping, the golden key

Sat, 08 Jul 2023 22:00:00 -0500

In this episode, I wax rhapsodic for the potential of subtyping to improve the practice of pure functional programming, in particular by allowing functional programmers to drop various irritating function calls that are needed just to make types work out. Examples are lifting functions with monad transformers, or even just the pure/return functions for applicative functors/monads.

Type inference with simple subtypes

Thu, 29 Jun 2023 23:00:00 -0500

In this episode, I begin discussing a paper titled "Type Inference with Simple Subtypes," by John C. Mitchell. The paper presents algorithms for computing a type and set of subtype constraints for any term of the pure lambda calculus. I mostly focus here on how subtype constraints allow typing any term (which seems surprising).

You can join the telegram group for discussion related to the podcast.

Basics of subtyping

Wed, 21 Jun 2023 16:00:00 -0500

In this episode, I discuss a few of the basics for what we expect from a subtyping relation on types: reflexivity, transitivity, and the variances for arrow types.

Begin chapter on subtyping

Tue, 20 Jun 2023 22:00:00 -0500

We begin a discussion of subtyping in functional programming. In this episode, I talk about how subtyping is a neglected feature in implemented functional programming languages (for example, not found in Haskell), and how it could be very useful for writing lighter, more elegant code. I also talk about how subtyping could help realize a new vision for practical strong functional programming, where the language has a pure, terminating core language, then a monad for pure but possibly diverging computation, and finally a monad for impurity and divergence.

Last episode discussing Observational Equality Now for Good

Thu, 13 Apr 2023 00:00:00 -0500

In this episode, I conclude my discussion of some (but hardly all!) points from Pujet and Tabareau's POPL 2022 paper, "Observational Equality -- Now for Good!". I talk a bit about the structure of the normalization proof in the paper, which uses induction recursion. See this paper by Peter Dybjer for more about that feature. Also, feel free to join the new Telegram group for the podcast if you want to discuss episodes.

More on observational type theory

Thu, 23 Mar 2023 00:00:00 -0500

I continue discussing the Puject and Tabareau paper, "Observational Equality -- Now for Good", in particular discussing more about how the equality type simplifies based on its index (which is the type of the terms being equated by the equality type), and how proofs of equalities can be used to cast terms from one type to another.

Also, in exciting news, I created a Telegram group that you can join if you want to discuss topics related to the podcast or particularly podcast episodes. I will be monitoring the group. I believe you have to request to join, and then I approve (it might take me until later in the day to do that, just fyi). The invitation link is here.

Introduction to Observational Type Theory

Sun, 05 Mar 2023 23:00:00 -0600

In this episode, I introduce an important paper by Pujet and Tabareau, titled "Observational Equality: Now for Good", that develops earlier work of McBride, Swierstra, and Altenkirch (which I will cover in a later episode) on a new approach to making a type theory extensional. The idea is to have equality types reduce, within the theory, to statements of extensional equality for the type of the values being equated.

Interjection: The Liquid Tensor Experiment

Thu, 02 Mar 2023 00:00:00 -0600

I pause the chapter on extensionality in type theory to talk about something very exciting that I just learned about (though the project was completed Summer 2022): the so-called Liquid Tensor Experiment, to formalize a recent very difficult proof by a mathematician named Peter Scholze, in Lean. This is the first time in history, that I know of, when a theorem was formalized in a theorem prover, in order to resolve doubts of the mathematician who proved it. An amazing achievement. This episode tells the story, as I have understood it on line. The result apparently sparked this recent workshop.

Extensional Martin-Loef Type Theory

Fri, 03 Feb 2023 23:00:00 -0600

In this episode, I discuss the basic distinguishing rule of Extensional Martin-Loef Type Theory, namely equality reflection. This rule says that propositional equality implies definitional equality. Algorithmically, it would imply that the type checker should do arbitrary proof search during type checking, to see if two expressions are definitionally equal. This immediately gives us undecidability of type checking for the theory, at least as usually realized.

Begin chapter on extensionality

Tue, 24 Jan 2023 23:00:00 -0600

This episode begins a new chapter on extensionality in type theory, where we seek to equate terms in different ways based on their types. The basic example is function extensionality, where we would like to equate functions from A to B if given equal inputs at type A, they produce equal outputs at type B. With this definition, quicksort and mergesort are equal, even though their codes are not syntactically equivalent. The episode begins by reviewing the distinction between definitional and propositional equality.

Also, I am still seeking your small donations ($5 or $10 would be awesome) to pay my podcast-hosting fees at Buzzsprout. To donate, click here, and then under "Gift details" select "Search for additional options" and then search for Computer Science. Select the Computer Science Development Fund, College of Liberal Arts and Sciences. Then add gift instructions saying that this is to support the Iowa Type Theory Commute podcast of Aaron Stump. Sorry it's that complicated.

Papers from Formal Methods for Blockchains 2021

Sun, 01 Jan 2023 14:00:00 -0600

In this episode, I talk about two papers from the 3rd International Workshop on Formal Methods for Blockchains, 2021. Also, I am continuing my request for your small donations ($5 or $10 would be awesome) to pay my podcast-hosting fees at Buzzsprout. To donate, click here, and then under "Gift details" select "Search for additional options" and then search for Computer Science. Select the Computer Science Development Fund, College of Liberal Arts and Sciences. Then add gift instructions saying that this is to support the Iowa Type Theory Commute podcast of Aaron Stump. Sorry it's that complicated.

Mi-Cho-Coq: Michelson formalized and applied, in Coq

Fri, 02 Dec 2022 00:00:00 -0600

In this episode, I discuss this paper, "Mi-Cho-Coq, a Framework for Certifying
Tezos Smart Contracts", by Bernardo et al. The paper gives a nice and very clear introduction to the Michelson language, and a formalization of it in Coq. This is used to prove a correctness property about a Multisig contract.

I also kindly solicit your small donations ($5 or $10 would be awesome) to pay my podcast-hosting fees at Buzzsprout. To donate, click here, and then under "Gift details" select "Search for additional options" and then search for Computer Science. Select the Computer Science Development Fund, College of Liberal Arts and Sciences. Then add gift instructions saying that this is to support the Iowa Type Theory Commute podcast of Aaron Stump. Sorry it's that complicated.

Verification of Tezos smart contracts with K-Michelson

Thu, 10 Nov 2022 23:00:00 -0600

In this episode (proudly wearing my "I am not an expert" hat), I discuss efforts by Runtime Verification to verify the Dexter2 defi smart contract, using their K-Michelson tool, which provides an executable description of the operational semantics of the Michelson language used for smart contracts on the Tezos blockchain.

Start of Season 4: Formal Methods for Blockchain

Mon, 07 Nov 2022 00:00:00 -0600

I start off a new chapter (seventeen!) of the podcast, to talk about formal methods for blockchain systems. In the next few episodes, we will look at some verification efforts related to the Tezos blockchain.

Separation Logic II: recursive predicates

Thu, 15 Sep 2022 23:00:00 -0500

I discuss separation logic basics some more, as presented in the seminal paper by John C. Reynolds. An important idea is describing data structure using separating conjunction and recursive predicates.

Separation Logic 1

Sun, 24 Jul 2022 22:00:00 -0500

I discuss separation logic, as presented in this seminal paper by the great John C. Reynolds. I did not go very far into the topic, so please expect a follow-up episode.

Let's talk about Rust

Sat, 09 Jul 2022 22:00:00 -0500

In this episode, I talk briefly about Rust, which uses compile-time analysis to ensure that code is memory-safe (and also free of data races in concurrent code) without using a garbage collector. Fantastic! The language draws on but richly develops ideas on ownership that originated in academic research.

Region-Based Memory Management

Tue, 21 Jun 2022 22:00:00 -0500

I discuss the idea of statically typed region-based memory management, proposed by Tofte and Talpin. The idea is to allow programmers to declare explicitly the region from which to satisfy individual allocation requests. Regions are created in a statically scoped way, so that after execution leaves the body of the region-creation construct, the entire region may be deallocated. Type inference is used to make sure that no dangling pointers are dereferenced (after the associated region is deallocated). This journal paper about the idea is not easy reading, but has a lot of good explanations in and around all the technicalities. Even better, I found, is this paper about region-based memory management in Cyclone. There are lots of intuitive explanations of the ideas, and not so much gory technicality.

Introduction to verified memory management

Sat, 04 Jun 2022 23:00:00 -0500

In this episode, I start a new chapter (we are up to Chapter 16, here), about verifying safe manual management of memory. I have personally gotten pretty interested in this topic, having seen through some simple experiments with Haskell how much time can go into garbage collection for seemingly simple benchmarks. I also talk about why verifying memory-usage properties of programs is challenging in proof assistants.

More on Metamath

Fri, 20 May 2022 22:00:00 -0500

I laud the Metamath proof checker and its excellent book. I am also looking for suggestions on what to discuss next, as I am ready to wrap up this chapter on proof assistants.

Metamath

Sat, 23 Apr 2022 16:00:00 -0500

In this episode I share my initial impressions -- very positive! -- of the Metamath system. Metamath allows one to develop theorems from axioms which you state. Typing or other syntactic requirements of axioms or theorems are also expressed axiomatically. The system exhibits an elegant coherent vision for how such a tool should work, and was super easy to download and try out.

The Seventeen Provers of the World

Sat, 09 Apr 2022 23:00:00 -0500

I discuss a book edited by Freek Wiedijk (pronounced "Frake Weedike"), which describes the solutions he received in response to a call for formalized proofs of the irrationality of the square root of 2. The book was published in 2006, and made an impression on me then. The provers we have discussed so far all have a solution in the book, except for Lean, which was created after that year. Happily, you can find a PDF of the book here, on Wiedijk's web site.

More on Lean

Sat, 12 Mar 2022 22:00:00 -0600

I talk about my positive experience trying out the tools for Lean, specifically the 'lean' executable and lean-mode in emacs.

The Lean Prover

Sun, 27 Feb 2022 22:00:00 -0600

In this episode, I talk about what I have learned so far about the Lean prover, especially from an excellent (if somewhat advanced) Master's thesis, "The Type Theory of Lean" by Marco Garneiro.

More on Isabelle, and the Complexity of ITPs

Wed, 16 Feb 2022 22:00:00 -0600

I talk about my attempts to use Isabelle as a newbie, and reflect a little on the complexity of both Isabelle and Coq.

Isabelle/HOL

Thu, 27 Jan 2022 23:00:00 -0600

The Isabelle theorem prover supports different logics, but its most developed seems to be Higher-Order Logic (HOL). In this episode, I talk about the logic and approach of Isabelle/HOL, as far as I have understood them.

More on Agda

Wed, 12 Jan 2022 19:00:00 -0600

I talk a bit more about the Agda proof assistant.

A look at Agda

Sun, 09 Jan 2022 23:00:00 -0600

In this episode I talk a bit about the Agda proof assistant.

More reflections on Coq

Fri, 31 Dec 2021 17:00:00 -0600

I talk about a couple good resources for learning Coq, the problem of too many ways to do things in type theory, and issues trying to explain and document a very complex language.

The Coq Proof Assistant

Tue, 28 Dec 2021 22:00:00 -0600

I discuss Coq, a widely used proof assistant based on a constructive type theory. One episode definitely cannot do justice to the complexity of a tool like this -- but I take a first try at covering its features at a high level.

Introduction to Interactive Theorem Provers

Thu, 16 Dec 2021 22:00:00 -0600

This is the start of Chapter 15, about interactive theorem provers (ITPs). In this episode, I talk about the difference between fully automatic and interactive provers, and my plan to discuss and compare several different ITPs, in future episodes of this chapter.

The proof-theoretic ordinal of Peano Arithmetic is Epsilon-0

Fri, 10 Dec 2021 22:00:00 -0600

In this episode, I outline the argument for why the proof-theoretic ordinal (in the sense of Rathjen, as presented last episode) is epsilon-0. My explanation has something of a hole, in explaining how one would go about deriving induction for ordinals strictly less than epsilon-0 in Peano Arithmetic. To help paper over this hole a little, I discuss a really nice recent exposition of encoding ordinals in Agda.

The proof-theoretic ordinal of a logical theory

Sat, 20 Nov 2021 23:00:00 -0600

Ordinal analysis seeks to determine the strength of a logical theory by assigning an ordinal to it. Which one? In this episode I describe a definition of the proof-theoretic ordinal of a logical theory from a paper by proof theorist Michael Rathjen. It is basically a measure of how strong an induction principle is derivable in the theory. (The first parts of the paper are pretty accessible, but the rest gets hard, at least for me.)

Introduction to Ordinal Analysis

Tue, 16 Nov 2021 21:00:00 -0600

Ordinal analysis is an important branch of proof theory, which seeks to compare, quantitatively, the strengths of different proof systems. The quantities in question are ordinals, which extend the ordering character of natural numbers into the infinite. In this episode, I discuss these ideas a bit further, and also review a little the ordinals up to epsilon 0.

An analogy for multiplicative disjunction

Wed, 03 Nov 2021 00:00:00 -0500

Listen in while I have an actual insight on air! After a week of head scratching, I figure out -- while chattering! -- what I hope is both a correct and intuitive example of multiplicative disjunction.

Linear conjunctions and disjunctions

Thu, 28 Oct 2021 22:00:00 -0500

I explain the basic idea of multiplicative versus additive proof rules, and consider multiplicative conjunction (tensor), addition conjunction (&, "with"), additive disjunction -- but leaving multiplicative disjunction (par) for next time!

A taste of linear logic

Thu, 21 Oct 2021 23:00:00 -0500

We discuss briefly the central ideas of linear logic, where by default assumptions must be used exactly once.

Structural rules, or the Curse of the Bound Variable

Tue, 12 Oct 2021 23:00:00 -0500

In this episode I discuss the basic structural rules of weakening, contraction, and exchange, and speculate on their dark origin.

Why Cut Elimination is More Complicated than Normalization

Tue, 05 Oct 2021 00:00:00 -0500

Cut elimination for sequent calculus is more involved that normalization of detours for natural deduction. There are more cases of cuts that must be transformed than correspond to detours (introductions followed by eliminations). In this episode, I explain why that is.

Introduction to Cut Elimination

Wed, 29 Sep 2021 00:00:00 -0500

We saw in the last few episodes that proofs in natural deduction can be simplified by removing detours, which occur when an introduction inference is immediately followed by an elimination inference on the introduced formula. What corresponds to this for sequent calculus proofs? The answer is cut elimination. This episode describes the cut rule and what is meant by a cut-elimination procedure. We will talk more about such a procedure in the next episode.

Normalization of detours for implication inferences

Sun, 19 Sep 2021 16:00:00 -0500

We talk about normalizing detours -- which are when an introduction inference is immediately followed by an elimination inference -- for the implication rules. Under Curry-Howard, this actually corresponds to beta-reduction, and could make the proof bigger (though less complex in a certain sense).

Normalization in natural deduction

Sat, 18 Sep 2021 00:00:00 -0500

This episode explains the idea of normalization of proofs in natural deduction. We want to eliminate so-called detours in proofs, which occur when an introduction is immediately followed by an elimination.

A Brief Look at Sequent Calculus

Wed, 15 Sep 2021 23:00:00 -0500

Sequent calculus is a different style in which proof systems can be formulated, where for each connective, we have a left rule for introducing it (in the conclusion of the rule) in the left part of a sequent G => D (i.e., in G), and similarly a right rule for introducing it in the right part (D). The beauty of sequent calculus is disjunction is handled without any departure from the general form for sequent calculus rules (unlike disjunction in natural deduction, as we discussed last time).

Natural deduction: or, the bad news!

Tue, 14 Sep 2021 00:00:00 -0500

We discuss the problem of the or-elimination rule in natural deduction, which does not have the correct form for natural deduction inferences. It is a research problem to fix this!

Don't forget to get in touch with me if you want to do the mini-course over Zoom next month, on normalization.

Implication rules for natural deduction

Tue, 14 Sep 2021 00:00:00 -0500

We discuss further inferences in natural deduction, in particular implication introduction and elimination.

Natural Deduction

Sat, 11 Sep 2021 23:00:00 -0500

This episode begins the discussion of the style of proof known as Natural Deduction, invented by Gerhard Gentzen, a student of Hermann Weyl, himself a student of David Hilbert (sorry, I said incorrectly that Gentzen was Hilbert's own student). Each logical connective (like OR, AND, IMPLIES, etc.) has introduction rules that let you prove formulas built with that connective; and elimination rules that let you deduce consequences from a proven formula built with that connective.

Rules of proof, standard proof systems

Wed, 08 Sep 2021 23:00:00 -0500

We continue our gradual entry into proof theory by talking about reflecting meta-logical reasoning into logical rules, and naming the three basic proof systems (Hilbert-style, natural deduction, and sequent calculus).

Advertising for the October 3-session Zoom mini-course on normalization continues. Email me if you are interested! This is just for ITTC listeners.

Finally, if you like the podcast and want to support it, would you consider a small ($5 or $10 is great) donation? This is not so much to cover the $12/month hosting fee at Buzzsprout but to get some kudos here at my institution, so people here know that I have a podcast [grin] and that listeners like it. To donate, go here, then choose "Colleges", then "College of Liberal Arts and Sciences", and then tick "Computer Science Development Fund". For "gift details", please leave "gift instructions" that say the gift is for Aaron Stump for the Iowa Type Theory Commute podcast. Then the money will get to the right place for me to use it for this. Thanks a lot in advance!

Different proof systems, distinguishing logical rules from domain axioms

Wed, 01 Sep 2021 22:00:00 -0500

I highlight two basic points in this continuing warm-up to proof theory: there are different proof systems for the same logics, and it is customary to separate purely logical rules (dealing with propositional connectives and quantifiers, for example) from rules or axioms for some particular domain (like axioms about arithmetic, or whatever domain is of interest).

Introduction to Proof Theory (Start of Season 3)

Tue, 31 Aug 2021 00:00:00 -0500

This is the start of Season 3 of the podcast. We are beginning with a new chapter (Chapter 14) on Proof Theory. This episode gives some basic introduction to the history and broad concerns of proof theory. There is even music, composed and played by yours truly, chez nous...

Modula-2

Tue, 27 Jul 2021 23:00:00 -0500

In this episode I discuss the paper "Modula-2 and Oberon" by Niklaus Wirth. Modula-2 introduced (it seems from the paper) the idea of having modules with explicit import and import lists -- something we saw at the start of our look at module systems with Haskell's module system. I note some interesting historical points raised by the paper.

Decomposing recursions using algebras

Mon, 12 Jul 2021 22:00:00 -0500

Analogously to the decomposition of a datatype into a functor (which can be built from other functors to assemble a bigger language from smaller pieces of languages) and a single expression datatype with a sole constructor that builds an Expr from an F Expr (where F is the functor) -- analogously, a recursion can be decomposed into algebras and a fold function that applies the algebra throughout the datatype.

Reassembling datatypes from functors using a fixed-point

Sat, 10 Jul 2021 22:00:00 -0500

Last episode we discussed how functors can describe a single level of a datatype. In this episode, we discuss how to put these functors back together into a datatype, using disjoint unions of functors and a fixed-point datatype. The latter expresses the idea that inductive data is built in any finite number of layers, where each layer is described by the functor for the datatype.

Decomposing datatypes into functors

Sat, 03 Jul 2021 12:00:00 -0500

This episode continues the discussion of Swierstra's paper "Datatypes à la Carte", explaining how we can decompose a datatype into the application of a fixed-point type constructor and then a functor. The functor itself can be assembled from other functors for pieces of the datatype. This makes modular datatypes possible.

Modular datatypes: introducing Swierstra's paper "Datatypes à la Carte"

Thu, 24 Jun 2021 17:00:00 -0500

In a really wonderful paper of some few years back, Swierstra introduced the idea of modular datatypes using ideas from universal algebra. Modular datatypes allow one to assemble a bigger datatype from component datatypes, and combine functions written on the component datatypes in a modular way. In this episode I introduce the paper and the problem (dubbed the expression problem by Phil Wadler) it is trying to solve. Modular datatypes are a different form of modularity that I would like to consider in the context of the discussion of module systems we have been engaged in now for a while in Chapter 13 of the podcast.

Modules for Mathematical Theories (MMT)

Tue, 08 Jun 2021 22:00:00 -0500

In a 2013 journal article titled "A Scalable Module System", Florian Rabe and Michael Kohlhase propose a module system called MMT (Modules for Mathematical Theories) for structuring mathematical knowledge. The paper has a very interesting general discussion of module systems, from programming languages but also other areas like algebraic specification and theorem proving. The system is based on a rather small set of concepts which subsume those of, for example, Standard ML's module system. Thought-provoking!

Some thoughts on module systems so far

Tue, 18 May 2021 23:00:00 -0500

I look back at the module systems we considered so far (Haskell's, Standard ML's, and Agda's), and consider a few points that are on my mind about these. I also mention a few other languages' module systems (Clojure, Java 9). I also ponder names and namespace management.

A look at Agda's module system

Wed, 12 May 2021 05:00:00 -0500

Agda's module system (beautifully described here) could be seen as intermediate between Haskell's and Standard ML's. It supports nested parametrized modules with information hiding, but does not go all the way to higher-order functors (as in Standard ML).

Standard ML: the Newmar King-Aire of module systems

Mon, 10 May 2021 00:00:00 -0500

SML has arguably the most complicated/powerful module system of any existing programming language. It is a luxury RV to Haskell's camper van. I take a high-level look, following a very nice paper by Xavier Leroy, titled "A modular module system".

A look at Haskell's module system

Mon, 26 Apr 2021 20:00:00 -0500

I briefly survey the main features of Haskell's module system, and reflect a bit on its design.

Let's talk about modules!

Tue, 20 Apr 2021 00:00:00 -0500

I start Chapter 13 (in Season 2) of the podcast, on module systems. Almost all programming languages I know include some kind of scheme for modules, packages, namespaces, or something like this. I discuss the high-level ideas of namespace management and type abstraction, two main use cases for module systems. Subsequent episodes will discuss module systems (from papers or documentation) of various languages.

Church-style Typing and Intersection Types: Glimpses of Benjamin Pierce's Dissertation

Mon, 12 Apr 2021 00:00:00 -0500

I was reading Benjamin Pierce's dissertation, and learning some intriguing things about intersection types in the context of Church-style typing. I summarize the parts of this I comprehended so far.

Intersections and Unions in Practice; Failure of Type Preservation with Unions

Mon, 22 Mar 2021 00:00:00 -0500

I discuss the perhaps surprising fact that union and intersection types are quite actively used and promoted for languages like TypeScript, also OO languages like Scala. I also try to explain briefly a counterexample to type preservation with union types, which you can find at the start of Section 2 of Barbanera and Dezani-Ciancaglini's paper "Intersection and Union Types: Syntax and Semantics", where it is attributed to Benjamin Pierce.

Normal terms are typable with intersection types

Fri, 05 Mar 2021 00:00:00 -0600

I sketch the argument that pure lambda terms in normal form are typable using intersection types. This completes the argument started in the previous episode, that intersection types are complete for normalizing terms: normal forms are typable, and typing is preserved by beta-expansion. Hence any normalizing term is typable (since it reduces to a normal form by definition, and from this normal form we can walk typing back to the term).

Intersection Types Preserved Under Beta-Expansion

Mon, 15 Feb 2021 00:00:00 -0600

Type systems usually have the type preservation property: if a typable term beta-reduces, then the resulting term is still typable. So typing is closed under beta-reduction. With intersection typing, typing is also closed under beta-expansion, which is a critical step in showing that intersection typing is complete for normalizing terms: any normalizing term can be typed with intersection types (and simple function types).

Introduction to Intersection Types

Mon, 08 Feb 2021 23:00:00 -0600

In a type system with intersection types, a term t that has type A and also has type B can be assigned the type 'A intersect B'. This episode begins Chapter 12 of the podcast on intersection types.

Deriving disjointness of constructor ranges in RelTT

Tue, 02 Feb 2021 00:00:00 -0600

Responding to an email question from a listener, I explain how to derive a form of inconsistency from the assumption that True is related to False at type Bool.

Software Design and Intrinsic Identity

Wed, 20 Jan 2021 22:00:00 -0600

I muse about the hopeless prospect of a single intrinsic conceptual decomposition of a problem domain in software engineering, and relate this to the idea of intrinsic identity we discussed recently for Relational Type Theory.

Identity Inclusion in Relational Type Theory

Mon, 18 Jan 2021 12:00:00 -0600

Where relational semantics for parametric polymorphism often includes a lemma called Identity Extension (discussed in Episode 10, on the paper "Types, Abstraction, and Parametric Polymorphism"), RelTT instead has a refinement of this called Identity Inclusion. Instead of saying that the interpretation of every closed type is the identity relation (Identity Extension), the Identity Inclusion lemma identifies certain types whose relational meaning is included in the identity relation, and certain types which include the identity relation. So there are two subset relations, going in opposite directions. The two classes of types are first, the ones where all quantifiers occur only positively, and second, where they occur only negatively. Using Identity Inclusion, we can derive transitivity for forall-positive types, which is needed to derive induction following the natural generalization of the scheme in Wadler's paper (last episode).

On the paper "The Girard-Reynolds Isomorphism" by Philip Wadler

Mon, 18 Jan 2021 00:00:00 -0600

I give a brief glimpse at Phil Wadler's important paper "The Girard-Reynolds Isomorphism", which is quite relevant for Relational Type Theory as it shows that relational semantics for the usual type for Church-encoded natural numbers implies induction. RelTT uses a generalization of these ideas to derive induction for any positive type family.

Equivalence of inductive and parametric naturals in RelTT

Mon, 28 Dec 2020 00:00:00 -0600

I talk through a proof I just completed that the type of relationally inductive naturals and the type of parametric naturals are equivalent. This is similar to proofs one can find in a paper of Philip Wadler's titled "The Girard-Reynolds Isomorphism", which I plan to discuss in the next episode.

Examples in Relational Type Theory

Wed, 23 Dec 2020 16:00:00 -0600

I discuss how to define internalized relational typings, implicit products, and two forms of natural number types, in RelTT.

The Semantics of Relational Types

Tue, 22 Dec 2020 23:00:00 -0600

In this episode, I discuss the semantics of the proposed six type constructors of RelTT.

The Types of Relational Type Theory

Mon, 14 Dec 2020 23:00:00 -0600

This episode continues the introduction of RelTT by presenting the types of the language. Because the system is based on binary relational semantics, we can include binary relational operators like composition and converse as type constructs! Strange. The language also promotes terms to relations, by viewing them as functions and then taking their graphs as the relational meaning.

Introducing Relational Type Theory

Mon, 14 Dec 2020 23:00:00 -0600

This episode begins Chapter 11 of the podcast, on Relational Type Theory. This is a new approach to type theory that I am developing. The idea is to design a type system based on the binary relational semantics for types, which we considered in Chapter 10. This episode recalls some of that semantics.

On the paper "Types, Abstraction, and Parametric Polymorphism"

Wed, 25 Nov 2020 23:00:00 -0600

In this episode I discuss one of the greatest papers in the history of Programming Language's research, namely "Types, Abstraction, and Parametric Polymorphism" by the great John C. Reynolds. I summarize the two interconnected semantics for polymorphic types proposed by Reynolds: one which interprets types as sets and programs as members of those sets, and another which interprets types as relations on the sets from the first interpretation. Listen and you will get to hear my aha moment as I understand live on air what the Identity Extension Lemma really means. See also this blog post on the same topic.

Parametric models and representation independence

Mon, 09 Nov 2020 00:00:00 -0600

Today I discuss the construction of relational models of typed lambda calculus (say, System F), that support the idea of representation independence. This is a feature of a type theory where different implementations of the same interface can be proved equivalent, and used interchangeably in the theory. Only in the past couple years have researchers proposed theories like this, but the semantic ideas underlying such theories have been around since Reynolds's seminal paper "Types, Abstraction, and Parametric Polymorphism".

Explaining my encoding of a HOAS datatype, part 2

Mon, 09 Nov 2020 00:00:00 -0600

I continue discussing the approach to HOAS from my paper "A Weakly Initial Algebra for Higher-Order Abstract Syntax in Cedille", 2019, available from my web page.

Explaining my encoding of a HOAS datatype, part 1

Mon, 19 Oct 2020 17:00:00 -0500

I start explaining an idea from my paper "A Weakly Initial Algebra for Higher-Order Abstract Syntax in Cedille", 2019, available from my web page. The goal is to encode a datatype (including its constructors, which we saw were troublesome for higher-order signatures generally in the previous episode) for application-free lambda terms, which I submit is the simplest higher-order datatype possible. I just explain some of the setup, and will attempt wading through the details next time.

Term models for higher-order signatures

Mon, 19 Oct 2020 00:00:00 -0500

I discuss the problem of term models for higher-order signatures, following a prelude about the Edinburgh Logical Framework (LF) and higher-order datatypes.

Lambda applicative structures and interpretations of lambda abstractions

Wed, 07 Oct 2020 23:00:00 -0500

Discussion of definitions in "Pre-logical relations" by Honsell and Sannella, particularly the notion of a lambda applicative structure (similar to a definition in John C. Mitchell's book "Foundations for Programming Languages'). In short, lambda abstractions get interpreted in combinatory algebras by compiling away the lambda abstractions in favor of S and K combinators, which are then interpreted by the combinatory algebra. I complain about the fact that the definition of a lambda applicative structure is required to come with an interpretation function for terms (hence tying the semantics to the syntax).

The Basic Lemma

Wed, 30 Sep 2020 16:00:00 -0500

Also known as the Fundamental Property, this is a theorem stating that for every well-typed term t : T, and every logical relation R between algebraic structures A and B, the meaning of t in A is related by R to the meaning of t in B. I view it as a straightforward semantic soundness property, but where the semantics of types is this somewhat interesting one that interprets types as binary relations on structures A and B. I muse on these matters a bit in the episode.

Logical relations are not closed under composition

Mon, 31 Aug 2020 16:00:00 -0500

In this episode, I talk through a small (but intricate) example from a paper titled "Pre-logical relations" by Honsell and Sannella, showing that the set of logical relations is not closed under composition. That is, you can have a logical relation between structure A and structure B, and one between B and C, but the composition (while a relation) is not a logical relation between A and C. This took me three takes to get to where I wasn't tripping over my tongue, so enjoy.

The definition of a logical relation

Tue, 18 Aug 2020 23:00:00 -0500

Logical relations are the relational generalization of the algebraic concept of a homomorphism -- but they go further in extending the notion of structure-preservation to higher-order structures. We discuss the basic definition in this episode.

Introduction to Logical Relations

Sun, 16 Aug 2020 23:00:00 -0500

Start of Chapter 10, on logical relations and parametricity. Basic idea of logical relation as the relational generalization of the algebraic idea of homomorphism. This is also the start of Season 2, as the fall academic year is just beginning here in Iowa.

Lamping's abstract algorithm

Sat, 25 Jul 2020 15:00:00 -0500

The simplified version of Lamping's algorithm for optimal beta-reduction is discussed. We have duplicators which eat their way through lambda graphs. When copying a lambda abstraction, we send one duplicator down the variable port, and another down the body port. When they meet, they cancel each other and the duplication is done. But duplication can get paused waiting for a value to come in on a wire from outside the lambda abstraction. This can lead to a situation where some other duplication needs to duplicate a lambda graph containing frozen duplicators. Then we have to decide, when two duplicators meet, should they cancel each other (signalling the end of a duplication on one level), or should one duplicate the duplicators (for an outer duplication of some lambda graph containing frozen duplicators). The abstract algorithm leaves this choice undetermined. The hairy versions of the algorithm add complex additional machinery to keep track of these levels of duplication to resolve that nondeterminism.

Examples showing non-optimality of Haskell

Tue, 14 Jul 2020 23:00:00 -0500

I discuss some examples posted on my blog, QA9, which show that executables produced by ghc (the main implementation of Haskell) can exhibit non-optimal beta-reduction. Thanks to Victor Maia for major help with these.

Lambda graphs with duplicators and start of Lamping's abstract algorithm

Fri, 03 Jul 2020 15:00:00 -0500

In this episode I talk about how to represent lambda terms as graphs with duplicator nodes for splitting edges corresponding to bound variables. I also start discussing the beginning of Lampings' abstract algorithm for optimal beta-reduction, in particular how we need to push duplicators inside lambda abstractions to initiate a lazy duplication.

Duplicating redexes as the central problem of optimal reduction

Sat, 20 Jun 2020 22:00:00 -0500

We discussed last time how with a graph-sharing implementation of untyped lambda calculus, it can happen that you are forced to break sharing and copy a lambda abstraction. We discuss in this episode the central issue with doing that, namely copying redexes and copying applications which could turn into redexes following other beta reductions. The high-level idea of the proposed solution is also discussed, namely lazy graph duplication.

Introduction to optimal beta reduction

Tue, 16 Jun 2020 00:00:00 -0500

Some background on optimal beta reduction: Levy, Lamping. The main problem to overcome is duplicating a lambda abstraction that is used in two different places in your term. The solution is to try to duplicate it incrementally.

Lexicographic termination

Tue, 02 Jun 2020 23:00:00 -0500

Many termination checkers support lexicographic (structural) recursion. The lexicographic combination of orderings on sets A and B is an ordering on A x B where a pair decreases if the A component does (and then the B component can increase unboundedly) or else the A component stays the same and the B component decreases. Connections with nested recursion and ordinals discussed.

Mendler-style iteration

Mon, 18 May 2020 23:00:00 -0500

Another type-based approach to termination-checking for recursive functions over inductive datatypes is to use so-called Mendler-style iteration. On this approach, we write recursive functions by coding against a certain interface that features an abstract type R, which abstracts the datatype over which we are recursing; and a function from R to the result type of the recursion. Subdata of the input data are available at type R only, not at the original datatype. This allows us to make explicit recursive calls, but only on subdata.

Well-founded recursion

Mon, 18 May 2020 23:00:00 -0500

Well-founded recursion is a technique to turn recursion which decreases along a well-founded ordering into a structural recursion.

Compositional termination checking with sized types

Mon, 30 Mar 2020 14:00:00 -0500

Discussion of a compositional method of termination checking using so-called sized types. Datatypes are indexed by sizes, and recursive calls can only be made on data of strictly smaller size than the data as input to the recursion. Since the method is type-based, it is compositional: we can break out helper functions from a recursive function and not upset the termination checker. A readable and interesting tutorial on the subject is here.

Noncompositionality of syntactic structural-recursion checks

Thu, 19 Mar 2020 23:00:00 -0500

Review of need for termination analysis for recursive functions on inductive datatypes. Discussion of a serious problem with syntactic termination checks, namely noncompositionality. A function may pass the syntactic termination check, but abstracting part of it out into a helper function may result in code which no longer passes the check. So we need a compositional termination check, which will be discussed in subsequent episodes.

Structural termination

Tue, 17 Mar 2020 00:00:00 -0500

Start of Chapter 8 of the podcast, on termination checking in type theory, and strong functional programming. Discussion of a little history of adding datatypes to the original pure type theory of Coq (called the Calculus of Constructions). Considering the most basic form of termination checking, which is checking syntactically that recursive calls are only made on subdata of the data input to the recursive function.

Proving Confluence for Untyped Lambda Calculus II

Fri, 13 Mar 2020 17:00:00 -0500

Discussion of the basic idea of the Tait--Martin-Loef proof of confluence for untyped lambda calculus. Let me know any requests for what to discuss in Chapter 8!

Proving Confluence for Untyped Lambda Calculus I

Fri, 13 Mar 2020 14:00:00 -0500

Start of discussion on how to prove confluence for untyped lambda calculus. Also some discussion about the research community interested in confluence.

Confluence, and its use for conversion checking

Wed, 11 Mar 2020 15:00:00 -0500

The basic property of confluence of a nondeterministic reduction semantics: if from starting term t you can reach t1 and also t2 (by two finite reduction sequences), then there is some t3 to which t1 and t2 both reduce in a finite number of steps. The use of confluence for ensuring completeness of the conversion-checking algorithm that tests conversion of t1 and t2 by normalizing both terms and checking for alpha-equivalence (or maybe alpha,eta-equivalence).

Normalization and logical consistency

Mon, 09 Mar 2020 14:00:00 -0500

Discussion of the connection between normalization and logical consistency. One approach is to prove normalization and type preservation, to show (in proof-theoretic terms) that all detours can be eliminated from proofs (this is normalization) and that the resulting proof still proves the same theorem (this is type preservation). I mention an alternative I use for Cedille, which is to use a realizability semantics (often used for normalization proofs) directly to prove consistency.

Normalization in type theory: where it is needed, and where not

Fri, 06 Mar 2020 15:00:00 -0600

Normalization (every term reaches a normal form via some reduction sequence) is needed essentially in type theory due to the Curry-Howard isomorphism: diverging programs become unsound proofs. Traditionally, type theorists have also desired normalization or even termination (every term reaches a normal form no matter what reduction sequence is explored in a nondeterministic operational semantics) for conversion checking. This is the process of confirming that types are equivalent during type checking, which, due to dependent types, can require checking program equivalence. The latter is usually restricted to just beta-equivalence (where beta-reduction is substitution of argument for input variable when applying a function), because richer notions of program equivalence are usually undecidable. I have a mini-rant in this episode explaining why this usual requirement of normalization for conversion checking is not sensible.

Also I note that you can find the episodes of the podcast organized by chapter on my web page.

Introduction to normalization

Thu, 05 Mar 2020 22:00:00 -0600

Discussion of normalization (there is some way to reach a normal form) versus termination (no matter how you execute the term you reach a normal form). A little more discussion of strong FP. For type theory, the need for normalization due to Curry-Howard and due to conversion checking.

Proving type safety; upcoming metatheoretic properties

Wed, 04 Mar 2020 15:00:00 -0600

Type safety proofs are big confirmations requiring consideration of all your operational and typing rules. So they rarely contain much deep insight, but are needed to confirm your language's type system is correct. Looking ahead, this episode also talks about the different between normalization and termination when your language is nondeterministic, and the property of confluence.

The progress property and the problem of axioms in type theory

Tue, 03 Mar 2020 23:00:00 -0600

We review the metatheoretic property of type safety, decomposed into two properties called type preservation and progress. Discussion of progress in the context of type theory, where adding axioms can lead to a failure of progress.

Introduction to type safety

Mon, 02 Mar 2020 17:00:00 -0600

Type safety is a basic property of both statically typed programming languages and type theories. It has traditionally (past few decades) been decomposed into type preservation and progress. Type preservation says that if a program expression e has some type T, then running e a bit will give a result that still has type T (and type preservation would apply again to that result, to preserve the type T indefinitely along the execution of e). Progress says that well-typed expressions cannot get stuck computationally: they cannot reduce to a form where the operational semantics is then undefined. This is how we model the idea that the type system is preventing certain kinds of failures: make those failures correspond to undefined behavior.

Introduction to metatheory

Fri, 28 Feb 2020 16:00:00 -0600

Metatheory is concerned with proving properties about theories, in this case type theories or programming languages.

Definition of the Mendler encoding

Wed, 26 Feb 2020 15:00:00 -0600

We consider using Mendler's technique of abstracting out problematic types with new type variables, and how this can yield a lambda encoding where the programmer is in charge of when to make recursive calls (rather than in the Church encoding, where the data present the programmer's combining function with the results of all possible recursive calls on immediate subdata).

The Mendler encoding and the problem of explicit recursion

Tue, 25 Feb 2020 15:00:00 -0600

The Church encoding allows definition of certain recursive functions, but all the recursive calls are implicit. The encoding simply presents you with the results of recursion for all immediate subdata. Using a technique due to Mendler, an encoding is possible where recursions are explicitly made by the combining functions given to the data.

The Scott encoding

Mon, 24 Feb 2020 14:00:00 -0600

In this episode we briefly review the Church and Parigot encodings (discussed previously in Chapter 6 of this podcast) and then consider the Scott encoding, where combining functions receive only the immediate subdata of the data.

More on the Parigot encoding

Fri, 21 Feb 2020 22:00:00 -0600

The Parigot encoding has exponential-size normal forms: but don't panic! With a decent graph-sharing implementation of lambda calculus, they take linear space in memory.

Introduction to the Parigot encoding

Tue, 18 Feb 2020 17:00:00 -0600

The Parigot encoding solves the Church encoding's problem of inefficient predecessor. It can be typed using positive-recursive types, which preserve normalization of the type theory.

Church-encoding natural numbers

Mon, 17 Feb 2020 17:00:00 -0600

What is fold-right for a natural number? How do we define addition with this? The problem of inefficient predecessor.

Church encoding of lists

Fri, 14 Feb 2020 22:00:00 -0600

We consider fold-right for lists, and its static type. The Church encoding for lists makes them into their own fold-right functions

Church encoding of the booleans

Fri, 14 Feb 2020 21:00:00 -0600

The Church encoding represents data as their own fold-right functions. For booleans, this means they become their own if-then-else expressions. We consider the polymorphic type for these, which is forall X. X -> X -> X.

Introduction to Church encoding

Tue, 11 Feb 2020 19:00:00 -0600

The Church encoding represents data as their own fold-right functions

Functional encodings turning the world inside out

Tue, 11 Feb 2020 17:00:00 -0600

Functional encodings take programming language features like pattern-matching and recursion and move them from outside of data to inside of data.

More benefits of lambda encodings

Fri, 07 Feb 2020 17:00:00 -0600

The idea that without lambda encodings, the current state of the art forces you to commit to a class of datatypes in the design of your type theory.

Introduction to lambda encodings

Fri, 07 Feb 2020 15:00:00 -0600

A lambda encoding is some way of representing data as functions (lambda abstractions). Some motivations for this for computer-checked proofs and type theory.

Adding a top type and allowing non-normalizing terms

Tue, 04 Feb 2020 19:00:00 -0600

Curry-style typing and realizability make it sensible to allow a top type to type every term, even non-normalizing ones.

Intersection types using Curry-style typing

Tue, 04 Feb 2020 17:00:00 -0600

Intersection types internalize the idea that a term has two types. Curry-style typing is generally needed for this to be nontrivial.

Curry-style versus Church-style, and the nature of type annotations

Thu, 30 Jan 2020 17:00:00 -0600

In Curry-style typing annotations -- for example, the types of bound variables -- are erased, and not truly (semantically) part of the term. In Church-style, they are intrinsic to the term and are truly there. Discussion of some of the practicalities of Curry-style typing, in particular type annotations versus proving typings.

More on Computation First, and Basic Idea of Realizability

Wed, 29 Jan 2020 16:00:00 -0600

Types are specifications whose semantics is explained in terms of computation, which is thus conceptually prior. Realizability is a way of explaining the semantics of types.

Types should be erased for executing and reasoning about programs

Wed, 29 Jan 2020 14:00:00 -0600

In which I argue that type information should be erased from programs by the compiler both for final execution and also for reasoning (in a language with dependent types, for example, where we can reason about program execution statically).

Why go beyond GADTs?

Fri, 24 Jan 2020 14:00:00 -0600

GADTs are quite powerful. Why go all the way to true dependent types? And should you use the Curry-Howard isomorphism (see Chapter 3 of the podcast) or not?

GADTs for programming with representations of types

Wed, 22 Jan 2020 14:00:00 -0600

This episode reviews some of the applications of GADTs we have discussed so far, and discusses an example where we want to write a function that consumes a number of inputs that is controlled by an argument to the function.

Using GADTs for typed subsetting of your language

Mon, 20 Jan 2020 13:00:00 -0600

One use case for GADTs (as a special case of dependent types) is to form a typed subset of your host language. One creates an EDSL called Expr a, where a is a type of the language (say this language is Haskell). Values of types Expr a are the abstract syntax trees of expressions of type a from your host language. This is just a special case of embedding a typed language into your host language: in this case the typed language is a subset of your host language.

Example of programming with indexed types: binary search trees

Thu, 16 Jan 2020 17:00:00 -0600

Using indexed types, we can restrict the form of legal values in some datatype. A nice example is binary search trees, where we can statically enforce the binary search tree property using an indexed type bst l u, where l is a lower bound and u an upper bound on the data stored in the tree.

Programming with indexed types using singletons

Thu, 16 Jan 2020 16:00:00 -0600

Basic idea of using singleton types like Nat n where n is a value from the index domain, to connect program expressions and index expressions. The data value of type Nat n is a copy of n, but living in the syntactic category of program expressions. This allows programs to operate on a proxy for n. Singletons library in Haskell mentioned.

Limitations of indexed types that are not truly dependent

Tue, 14 Jan 2020 06:00:00 -0600

If indices to types come from a different syntactic category than programs, there are a few things you cannot do. Some initial thoughts on how to work around these.

Programming with Indexed Types

Mon, 13 Jan 2020 17:00:00 -0600

Indexed datatypes like vectors, where the indices come from a different syntactic category than program expressions.

Program Termination and the Curry-Howard Isomorphism

Fri, 10 Jan 2020 14:00:00 -0600

For programs to make sense as proofs, they need to be terminating (cannot run forever), since otherwise you can write infinite loops that have any type. Under Curry-Howard this means any formula is provable, which is one way to define inconsistency. (And logics have to be consistent to be useful.)

Why Curry-Howard for classical proofs is a bad idea for programming

Mon, 06 Jan 2020 19:00:00 -0600

If you have dependent types, classical reasoning, and the Curry-Howard isomorphism, you can write programs that look like they are invoking oracles for undecidable problems -- but they are not, and this is confusing.

Curry-Howard for classical logic

Mon, 06 Jan 2020 15:00:00 -0600

CH can be applied to classical logic, too. The seminal paper is A Formulae-as-Types Notion of Control by Timothy Griffin. I discuss how backtracking implements the law of excluded middle.

Dependent types and design by contract

Fri, 03 Jan 2020 20:00:00 -0600

Dependent types are discussed, particularly as used for expressing pre- and post-conditions of functions.

Indexed types and Curry-Howard for first-order quantifiers

Fri, 03 Jan 2020 14:00:00 -0600

I follow up on some comments I made about Curry-Howard for first-order quantifiers in the previous episode. Sheard's Omega language also mentioned (see links on his web page). First-order quantifications turn into indexed types where the indices are not program expressions but come from another syntactic domain.

The Curry-Howard Isomorphism for Propositional Logic

Thu, 02 Jan 2020 15:00:00 -0600

Discussion of the Curry-Howard isomorphism for the connectives of propositional logic (AND, OR, NOT, FALSE, IMPLIES). Initial consideration of Curry-Howard for first-order and higher-order logic. Dependent types.

The Curry-Howard Isomorphism for Induction

Tue, 31 Dec 2019 17:00:00 -0600

In which I discover why the domino analogy for explaining induction always bothered me!

Constructive proofs as programs

Sat, 21 Dec 2019 23:00:00 -0600

We consider the basic idea of the Curry-Howard isomorphism, that constructive proofs are essentially programs, and vice versa. Several simple examples. Why the law of excluded middle is not a legal constructive proof.

Introduction to the Curry-Howard Isomorphism

Fri, 20 Dec 2019 14:00:00 -0600

The basic idea of the Curry-Howard isomorphism, and its connection to the contents of Chapters 1 and 2. Constructive proof. A famous nonconstructive proof.

Functors and catamorphisms

Fri, 20 Dec 2019 14:00:00 -0600

More about the structured recusion scheme known as the catamorphism. Basic idea of functors.

Structured Recursion Schemes for Point-Free Recursion

Wed, 18 Dec 2019 23:00:00 -0600

Review of basic application of category theory for functional programming. Recursion schemes are combinators that let you write point-free recursions.

More on point-free programming and category theory

Tue, 17 Dec 2019 12:00:00 -0600

A few very basic ideas of categories and combinators. Also, the problem of understanding very concise code.

Point-free programming and category theory

Tue, 17 Dec 2019 00:00:00 -0600

Relation of point-free functional programming to category theory.

Concise code through point-free programming

Fri, 13 Dec 2019 06:00:00 -0600

Higher-order functions help make it possible to program in a point-free style, where we use combinators to connect functions, rather than calling the functions on inputs explicitly.

More on FP and concise code

Thu, 12 Dec 2019 17:00:00 -0600

Discussion of datatypes for tree-like data structures in functional languages. Usefulness of these for processing structured linguistic artifacts, where the structure is represented by the tree structure.

Functional Programming and Concise Code: Type Inference

Thu, 12 Dec 2019 14:00:00 -0600

Start of discussion of some of technology and culture that lead to more concise code in functional programming languages. Type inference to avoid writing types for local and input variables. Some basics of static and dynamic typing.

Introduction to Functional Programming

Wed, 11 Dec 2019 14:00:00 -0600

Introduction to the basic idea of functional programming. Three kinds are discussed: functional programming with mutable state, pure functional programming (where there is no implicit state), and strong functional programming (which is pure functional programming where every function is statically required to terminate).

Software Engineering Considerations for Formal Methods

Sun, 01 Dec 2019 22:00:00 -0600

Discussion of some practicalities of applying formal methods to software. Ideally we are seeking techniques that can be applied with increasing effort to yield increasingly strong results. Also, introduction to functional programming.

Power of Computer-Checked Proofs for Software

Sat, 30 Nov 2019 18:00:00 -0600

Continuing pessimistic discussion about the purpose of formal methods for Computer Science. But then counter arguments about the value of absolutely correct software.

Technical reasons for lack of adoption of computer-checked proofs

Thu, 28 Nov 2019 12:00:00 -0600

Discussion of a technical reason for lack of adoption of computer-checked proofs for mathematics, namely the level of detail in the proof. Proof assistants require too much detail in proofs to allow mathematicians to carry over their elegant art of expressing just the right amount of information to convey the idea of the proof to a mathematically competent reader. For Computer Science, a problem of adoption is that proofs are computationally useless (generally).

Why Computer-Checked Proofs are Not Used More in Mathematics

Wed, 27 Nov 2019 14:00:00 -0600

Some discussion of why computer-checked proofs have not been adopted more in mathematics. The psychology of telling mathematicians their time-honored method of investigation is inadequate and they need computer-checked proofs. Computer-checked proofs and certainty.

Computer-Checked Proofs in American Research

Tue, 26 Nov 2019 15:00:00 -0600

Some pockets of interest in computer-checked proofs in the US in the 1980s and 1990s. Several important research projects and initiatives in the US in the late 1990s and early 2000s that helped raise awareness in the US of computer-checked proofs: proof-carrying code, the POPLmark challenge.

Computer-checked proofs about software

Sat, 23 Nov 2019 23:00:00 -0600

Computer-checked proofs can ensure properties of software. Discussion of several aspects of this idea.

More on Computer-Checked Proofs

Fri, 22 Nov 2019 13:00:00 -0600

Further discussion of computer-checked proofs, including the example of the proof by Hales and his collaborators of the Kepler Conjecture. Automath also mentioned. DAO hack on Ethereum and the interest in cryptocurrency community in computer-checked proofs.

Computer-checked proofs

Thu, 21 Nov 2019 14:00:00 -0600

First episode of the Iowa Type Theory Commute. The basic idea of computer-checked proofs. The example of the original proof of the Four Color Theorem.