Iowa Type Theory Commute

50 episodes listed below

Listen to the show on

Lambda calculus from the driver’s seat.

The gist

Iowa Type Theory Commute is a compact technical monologue series about type theory and computational logic. Aaron Stump works through lambda calculus proofs, termination questions, closure analysis, and papers with the patience of someone thinking aloud in real time.

PRESS PLAY

Find your next episode

All episodes

About Iowa Type Theory Commute

Iowa Type Theory Commute is a technical listening room for people who like computation before the slogans get simplified. Aaron Stump uses the commute format to work through type theory, computational logic, and pure lambda calculus in a direct, reflective register. The episodes are short in setup but dense in substance. A question such as “what is control flow analysis?” quickly becomes a discussion of lambda abstractions, program points, sound approximations, closure analysis, and the correctness property behind the analysis. The show is at its best when it pauses over distinctions that are easy to skip. In episodes on terminating computation, Stump considers the possibility of starting with an untyped language where every program terminates, then letting types describe other properties instead of carrying the whole burden of logical soundness. That leads into affine lambda calculus, structural recursion, closed construction, closed reduction, and the cost of restricting a language strongly enough to prevent divergence. The mood is curious rather than declarative. He is willing to say when an idea seems original, when it may be too restrictive, and when a paper finally states the property he had been looking for. Several episodes also return to the finite developments theorem in untyped lambda calculus. There, the show walks through marked redexes, residuals, beta reduction, multiplicity measures, and the elegance of using intersection types to get termination as a corollary. Names and papers matter because the arguments matter. Jens Paulsberg, Jean-Louis Cravin, Krivine, Royald de Vrier, and Victor Talon appear as reference points in a larger conversation about how proofs are shaped. The show does not aim for broad tech commentary. It rewards listeners who already care about formal systems, programming language theory, and the small proof moves that make a theorem suddenly feel clean.

Made for: For listeners with a serious interest in type theory, lambda calculus, programming language theory, computational logic, or formal systems. It best suits people who enjoy informal research-level explanation more than beginner-friendly survey material.

What sets it apart: The show pairs commute-length informality with unusually close attention to formal detail. Instead of summarizing results from a distance, it lingers on definitions, proof obligations, restrictions, and why a paper’s exact formulation can feel clarifying.

In their own words

Aaron Stump talks about type theory, computational logic, and related topics in Computer Science on his short commute.

Why you'd press play

Aaron Stump turns lambda-calculus proofs into passenger-seat chalk talks, if your idea of fun includes marked redexes.

Press play if you want

  • a proof explained from redexes and residuals all the way to the decreasing measure
  • intersection types served with enough enthusiasm to make termination feel like a plot twist
Read the full recommendation in PlayNext →
lambda calculustype theoryterminationcontrol flow analysisfinite developments theoremintersection typesaffine recursion

Talks about

Best episodes of Iowa Type Theory Commute

Short reviews from the PlayNext desk, based on the episodes we processed.

What is Control Flow Analysis for Lambda Calculus?Jan 16, 2026

A careful, patient guide to tracking lambda abstractions through pure, untyped terms.

Aaron Stump makes control flow analysis feel unusually tangible by asking which lambda abstractions might arrive at a given point in a pure lambda-calculus term.

Schematic Affine Recursion, Oh My!Aug 22, 2025

A careful look at how affine use and closed recursion reshape an untyped language.

Aaron Stump takes up Victor Talon's proposal to begin type theory from a terminating untyped programming language. The frame is affine lambda calculus with structural recursion: lambda-bound variables can be used at most once, and recursion ranges over constructed values such as…

Podcasts like Iowa Type Theory Commute

Episodes

  1. 1

    Double-negation translations and CPS conversion, part 2

    Apr 2, 2026·14m
  2. 2

    Double-negation translations and CPS conversion, part 1

    Mar 31, 2026·14m
  3. 3

    What are commuting conversions in proof theory?

    Mar 3, 2026·22m
  4. 4

    What is Control Flow Analysis for Lambda Calculus?

    Hidden gem

    Aaron Stump uses Type Theory Commute to define control flow analysis as a static approximation of what lambda abstractions can flow to each program point in lambda calculus.

    Jan 16, 2026·19m·1 clip
  5. 5

    Measure Functions and Termination of STLC

    Nov 14, 2025·22m
  6. 6

    Schematic Affine Recursion, Oh My!

    Hidden gem

    Aaron Stump uses `Type Theory Commute` to revisit Victor Talon's affine lambda calculus plus structural recursion proposal.

    Aug 22, 2025·19m·1 clip
  7. 7

    The Stunner: Linear System T is Diverging!

    Aaron Stump discusses Victor Talon's idea of building a type theory starting from a terminating untyped programming language.

    Aug 19, 2025·21m
  8. 8

    Terminating Computation First?

    Aug 1, 2025·11m
  9. 9

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

    May 12, 2025·7m
  10. 10

    Krivine's Proof of FD, Using Intersection Types

    Hidden gem

    Aaron Stump explains Jean-Louis Krivine's proof of the finite developments theorem for pure untyped lambda calculus.

    May 5, 2025·22m·1 clip
  11. 11

    A Measure-Based Proof of Finite Developments

    Hidden gem

    Iowa Type Theory Commute host Aaron Stump explains Royald de Vrier’s measure-based proof of the Finite Development Theorem for untyped lambda calculus.

    Apr 16, 2025·23m·1 clip
  12. 12

    Introduction to the Finite Developments Theorem

    Mar 27, 2025·16m
  13. 13

    Nominal Isabelle/HOL

    Jan 31, 2025·16m
  14. 14

    The Locally Nameless Representation

    Hidden gem

    Iowa Type Theory Commute examines the locally nameless representation for syntax with binders in theorem provers.

    Jan 3, 2025·20m·1 clip
  15. 15

    POPLmark Reloaded, Part 2

    Dec 23, 2024·14m
  16. 16

    POPLmark Reloaded, Part 1

    Dec 23, 2024·15m
  17. 17

    Introduction to Formalizing Programming Languages Theory

    Nov 25, 2024·12m
  18. 18

    Turing's proof of normalization for STLC

    May 21, 2024·18m
  19. 19

    Introduction to normalization for STLC

    May 14, 2024·10m
  20. 20

    Arithmetic operations in simply typed lambda calculus

    May 4, 2024·10m
  21. 21

    The curious case of exponentiation in simply typed lambda calculus

    May 4, 2024·7m
  22. 22

    More on basics of simple types

    Apr 29, 2024·16m
  23. 23

    Begin Chapter on Simple Type Theory

    Apr 19, 2024·16m
  24. 24

    Some advanced examples in DCS

    Sep 25, 2023·23m
  25. 25

    DCS compared to termination checkers for type theories

    Sep 19, 2023·20m
  26. 26

    Getting started with DCS

    Sep 10, 2023·17m
  27. 27

    Introduction to DCS

    Sep 4, 2023·12m
  28. 28

    Semantics of subtyping

    Jul 24, 2023·15m
  29. 29

    More on type inference for simple subtypes

    Jul 16, 2023·9m
  30. 30

    Subtyping, the golden key

    Jul 9, 2023·9m
  31. 31

    Type inference with simple subtypes

    Jun 30, 2023·13m
  32. 32

    Basics of subtyping

    Jun 21, 2023·8m
  33. 33

    Begin chapter on subtyping

    Jun 21, 2023·16m
  34. 34

    Last episode discussing Observational Equality Now for Good

    Apr 13, 2023·12m
  35. 35

    More on observational type theory

    Mar 23, 2023·14m
  36. 36

    Introduction to Observational Type Theory

    Mar 6, 2023·10m
  37. 37

    Interjection: The Liquid Tensor Experiment

    Mar 2, 2023·12m
  38. 38

    Extensional Martin-Loef Type Theory

    Feb 4, 2023·11m
  39. 39

    Begin chapter on extensionality

    Jan 25, 2023·10m
  40. 40

    Papers from Formal Methods for Blockchains 2021

    Jan 1, 2023·17m
  41. 41

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

    Dec 2, 2022·16m
  42. 42

    Verification of Tezos smart contracts with K-Michelson

    Nov 11, 2022·14m
  43. 43

    Start of Season 4: Formal Methods for Blockchain

    Nov 7, 2022·11m
  44. 44

    Separation Logic II: recursive predicates

    Sep 16, 2022·12m
  45. 45

    Separation Logic 1

    Jul 25, 2022·13m
  46. 46

    Let's talk about Rust

    Jul 10, 2022·14m
  47. 47

    Region-Based Memory Management

    Jun 22, 2022·17m
  48. 48

    Introduction to verified memory management

    Jun 5, 2022·17m
  49. 49

    More on Metamath

    May 21, 2022·17m
  50. 50

    Metamath

    Apr 23, 2022·15m