timescale.info
Sign inSign up

Type theory · foundations, languages, proof assistants and program logics

A connected history of type theory, programming languages, proof assistants and program logics, from Frege, Russell and Church to dependent types, homotopy type theory, cubical computation and recent higher-dimensional research. Gregorian calendar, UTC. Sources checked 3 November 2026.

Explore the families

Use Separate by tags to compare overlapping strands. Events are tagged for their theories, systems and application areas: foundations, polymorphism, dependent types, logical frameworks, proof assistants, program refinement, refinement types, separation logic, linear types, homotopy type theory, cubical type theory, programming languages and verified applications. Individual tags identify Coq/Rocq, Lean, Agda, Nuprl, HOL, Isabelle, F*, Idris, and other projects. The tracks share a calendar; they are not alternative histories or a single project ancestry tree.

Follow the theory into tools. Simple types and classical higher-order logic lead to the HOL family; LCF supplies a trusted-inference architecture. Constructive dependent foundations support Nuprl, constructions-based Coq/Rocq and other dependent programming systems. LF, Twelf, Beluga and Dedukti illustrate logical frameworks. Polymorphism, System F, ML inference, existential abstraction, System FC, gradual typing and DOT connect foundational research to programming-language implementation. Mizar, ACL2 and TLA are neighboring formal-methods traditions, included for comparison rather than incorrectly classed as HoTT descendants.

Program verification has several meanings of refinement. The timeline separates value-refinement types from specification-to-implementation refinement calculus and from interactive proof-goal refinement. Hoare logic, weakest preconditions, B, separation logic and Iris describe different correctness methods. Boogie, Z3, Dafny, Why3, Viper, F*, LiquidHaskell, Prusti, Creusot and Verus show different automation and language integrations. SMT solving, interactive proof checking and verified compilation have distinct trust boundaries.

HoTT, Coq and computational equality

The groupoid and homotopy interpretations of identity lead into univalent foundations and the HoTT Book. The HoTT Library in Coq and UniMath are separate libraries with related goals. Axiomatizing univalence in a configured Coq development does not make its kernel computationally cubical. Cubical models, CCHM, Cartesian computational higher type theory, RedPRL, cubical Agda, Arend and cooltt appear as distinct research or implementation milestones. Two-level, directed, modal, displayed and higher observational work extend the map further.

The lambda-cube cover compares typed calculi; it is not a diagram of cubical identity cells. Attached concept cards explain dependent Pi/Sigma types, judgmental equality versus identity proofs, universes, univalence, higher inductive types, canonicity versus normalization, usage quantities and verification boundaries. These notes explain concepts without adding fictitious dated events.

Dates, status and evidence

Each event states whether it is a manuscript, circulated note, publication, presentation, project milestone, compiler release or status snapshot. Publication dates do not automatically date invention. Howard’s 1969 circulation and 1980 publication, the 1973 colloquium and 1975 predicative paper, and the CCHM preprint and later TYPES 2015 proceedings publication are deliberately separated. The 2010 Voevodsky talk is not dated by its later arXiv deposit. Recent arXiv events are explicitly preprints, not claims of peer-reviewed acceptance. The cooltt marker records the repository as observed on 3 November 2026, not an inferred first-release year.

Year-only and month-only evidence uses January 1 or the first day solely as a plotting anchor. Midnight UTC does not assert a historical time of day. Coarse dates have presumptive outlines. Editorial coverage bands organize selected entries; they do not measure project lifetimes or claim that a line of research ended. The selection is extensive but cannot enumerate every calculus, language, proof library or implementation release.

Sources prioritize original papers, authors’ manuscripts, official histories, project repositories, release announcements and institutional records. Later author/project retrospectives are identified where needed. Each event has its own source list. Relationships carry explanations and supporting references in historyLinks metadata: arrows indicate specified theoretical or implementation relationships; comparison arcs distinguish related ideas without asserting descent. A relationship never implies that every feature of the target is derived from the source, or that the implementations are compatible.

Projects as evidence of use

Formalized mathematics includes the four-colour theorem, odd-order theorem, Flyspeck and mathlib. CompCert, seL4, CakeML, HACL*, EverCrypt and RustBelt demonstrate different verified-system or semantic-correctness achievements. MetaCoq/MetaRocq and Coq Coq Correct examine the checking and erasure machinery itself. Read the stated specification and assumptions: a theorem about one modeled component is not a blanket theorem about an entire deployed system.

Media credits

Individually checked Wikimedia Commons files use public-domain or Creative Commons attribution/share-alike licenses. Later portraits illustrate people rather than the historical date of the event. The modern HoTT Book cover illustrates the book. The lambda cube is an explanatory diagram, not a historical photograph or a cubical-theory logo.

147 moments · 1879-01-01T00:00:00Z CE – 2026-11-03T00:00:00Z CE · by @athan · @athan

Moments

  1. Frege’s Begriffsschrift formalizes quantified reasoning
  2. The Principles of Mathematics includes a doctrine of types
  3. Russell presents ramified type theory
  4. Principia Mathematica begins publication
  5. Ramsey’s simplification is part of the route to simple types
  6. Kolmogorov interprets intuitionistic logic through problems
  7. Gentzen introduces natural deduction and sequent calculi
  8. Church combines simple types with lambda notation
  9. Heyting’s Intuitionism explains constructive logical operations
  10. Strachey distinguishes forms of polymorphism
  11. Howard’s formulae-as-types notes circulate
  12. Scott develops a type-theoretical alternative for computable functions
  13. Hoare gives an axiomatic basis for program correctness
  14. Hindley proves a principal type-scheme result
  15. Automath’s mathematical language is published
  16. Lawvere treats equality and comprehension categorically
  17. Martin-Löf’s early type theory uses a type of all types
  18. A universe paradox exposes a boundary of early type theory
  19. Milner’s original LCF proof checker
  20. Girard’s thesis develops polymorphic type theory
  21. Mizar’s formal-mathematics vision is presented
  22. Reynolds independently develops polymorphic type structure
  23. Guarded commands and weakest preconditions
  24. Martin-Löf’s Predicative Part is published
  25. Back’s thesis initiates refinement-calculus development
  26. Milner gives a theory of polymorphic inference for ML
  27. Edinburgh LCF documents ML-based proof management
  28. The Cornell PRL project begins
  29. The formulae-as-types notes are published
  30. Damas and Milner establish principal type schemes for functional programs
  31. Reynolds develops relational parametricity
  32. Intuitionistic Type Theory consolidates a constructive foundation
  33. Nuprl systems develop proof-refinement logic
  34. An early Constructive Engine version is frozen
  35. Coquand defends the Calculus of Constructions thesis
  36. HOL formulates higher-order logic for machine reasoning
  37. Isabelle presents a generic theorem-proving framework
  38. LF encodes judgments and proofs using dependent types
  39. Girard introduces linear logic
  40. Abstract types are explained with existential types
  41. HOL88 packages a mature LCF descendant
  42. Constructions-system code feeds the later LEGO development
  43. Moggi models computational effects with monads
  44. Version 4.10 is a mature distributed constructions system
  45. The ACL2 project begins
  46. Inductively defined types extend the calculus of constructions
  47. Programming in Martin-Löf’s Type Theory presents a working methodology
  48. Programming from Specifications develops calculational refinement
  49. The Definition of Standard ML specifies the language
  50. Haskell 1.0 combines polymorphism with type classes