Simply Typed Lambda Calculus: Termination and Types

The Curry-Howard Isomorphism establishes a direct correspondence between logical proofs and computer programs, where propositions correspond to types, proofs correspond to programs, and proof verification corresponds to program compilation; this connection means that any valid program in typed lambda calculus can be interpreted as a proof in intuitionistic logic, and vice versa, with modus ponens corresponding to function application and axioms K and S corresponding to the K and S combinators in lambda calculus.

The Curry-Howard-Lambek isomorphism reveals that logic, type theory (programming), and category theory are three different notations for describing the same underlying mathematical structure. These three independently developed fields converge because they share fundamental principles. Category theory serves as the unifying framework, describing how to compose things from smaller things - a principle intrinsic to programming where programs must be composable to solve large problems by breaking them into smaller pieces. A category consists of objects (abstract entities with no internal structure) and morphisms (arrows connecting objects). The fundamental operations are composition (combining arrows from A to B and B to C into an arrow from A to C) and identity (each object has a special arrow that loops back to itself). Initial and terminal objects are universal constructions that define objects by their relationships to all other objects. An initial object has exactly one arrow to every other object (in Set, this is the empty set), while a terminal object has exactly one incoming arrow from every other object (in Set, this is a singleton set).

The Curry-Howard isomorphism establishes a profound correspondence between logic and computing, revealing that propositions correspond to types and proofs correspond to programs. This correspondence was independently discovered by multiple researchers including Curry, Howard, de Bruijn, and others, with William Howard publishing the key insight in 1980. Category theory serves as the foundational framework underlying this correspondence, providing the mathematical structure that explains why functional programming concepts like monads and functors work the way they do. Category theory studies the composition of functions through abstract structures called categories, where objects represent types and arrows represent functions between types. Categories satisfy identity laws (composing with identity arrows yields the original arrow) and associativity laws (composition order doesn't matter). This foundational framework provides the mathematical language for understanding how programming language constructs relate to logical principles.

Intuitionistic mathematics, developed by L.E.J. Brouwer, rejects the classical notion of truth as correspondence with an objective reality. Instead, truth is identified with the ability to construct a proof. The BHK (Brouwer-Heyting-Kolmogorov) interpretation provides constructive meanings: conjunction requires proofs of both conjuncts; disjunction requires a proof of one disjunct; implication requires a method transforming proofs of the antecedent into proofs of the consequent; universal quantification requires a method producing proofs for each instance. Negation (¬A) is interpreted as A → ⊥, where ⊥ represents absurdity. The law of excluded middle (A ∨ ¬A) is rejected because it does not provide a constructive method for determining which disjunct holds. Intuitionistic propositional logic (IPC) accepts all classical propositional logic axioms except the law of excluded middle. Natural deduction provides a more intuitive presentation with introduction and elimination rules for each connective. The Curry-Howard isomorphism establishes a correspondence between intuitionistic logic and simply typed lambda calculus: propositions correspond to types, proofs correspond to terms (programs), and proof construction corresponds to program execution. A proof of A → B corresponds to a program of type A → B that takes an input of type A and produces an output of type B.

Propositions as types is a fundamental principle where logical propositions correspond to types and proofs correspond to programs/values. The equality type (x ≡ y) represents the proposition that x equals y. The only inhabitant of this type is 'refl', which proves that a value equals itself. When you write a proof in Agda, you're constructing a value of a certain type, which serves as evidence that the proposition is true. For example, proving 11 + 4 = 15 means constructing a value of the type representing that equality.

Type safety in System F is proven via progress and preservation. Progress states that for a closed term e with type a in empty contexts, either e is a value or e steps to e'. Preservation states that if e has type a and e steps to e', then e' also has type a. Progress is proven by induction on typing derivations, with new cases for big lambdas and type applications. The canonical forms property states that values are either little lambda x dot e or big lambda alpha dot e. For type applications, if e is a value of type for all alpha dot b, it must be big lambda alpha dot e', and the for all evaluation rule substitutes a for alpha in e'. Preservation is proven by induction on evaluation steps, with the new case being the for all evaluation rule. System F is extremely expressive: from polymorphism and functions alone, all data types can be defined.

Type safety aims to exclude certain errors from programs through static analysis. The core principle is that well-typed programs guarantee certain errors cannot occur. The type preservation property ensures that if a well-typed program reduces to a value, the resulting value has the expected type. A type environment (gamma) maps variables to types, and for correctness, gamma must agree with the memory store (sigma) on all variable types. Type correctness proofs use structural induction on expressions: base cases include constants and variables, while compound expressions like addition apply the induction hypothesis to subexpressions. The Mini-While type system includes rules for constants (int, bool), variables (gamma(x)), addition (both operands int), sequences (both statements well-typed), assignments (variable type matches expression type), conditionals (condition bool, both branches well-typed), and while loops (condition bool, body well-typed). Expressions produce types while statements are simply well-typed or not. A configuration consists of a statement and store. A configuration is well-typed if the statement is well-typed in gamma and all variables in sigma match gamma's types. Type safety requires two properties: Progress (well-typed configurations can reduce or reach final state) and Preservation (reduction preserves well-typedness). These are proven by structural induction on statements. For assignments, the proof uses the type correctness theorem for expressions. For sequences, the proof applies the induction hypothesis to each statement. For conditionals, the proof shows that regardless of which branch executes, the resulting configuration is well-typed. For while loops, the proof shows the loop body reduces and the resulting configuration is well-typed. For type safety to work, the initial store must be compatible with the type environment, requiring either initialization of all variables in declarations or default values for all types.

Type safety requires that every closed expression evaluates to a value of its type. Proving this requires strengthening induction hypotheses with type-indexed predicates. Logical relations, developed by Martin-Löf and Tait, provide the technique: define relations P(τ, v) inductively on types, requiring termination for base types and preservation for functions. This method underlies all serious PL research. The approach was revolutionary in connecting constructive mathematics with computer programming, transforming theoretical computer science.

This comprehensive section covers the complete theory and practice of proving type soundness. It begins with a minimal language featuring natural numbers, booleans, and if statements, establishing small step semantics with deterministic evaluation order. The type system rules ensure expressions of different types cannot be combined improperly. Type safety means well-typed programs never get stuck, proven through an invariant-based approach: define initial states (well-typed programs), bad states (stuck states), and prove an invariant containing initial states, disjoint from bad states, and closed under steps. The section demonstrates complete proofs of progress (well-typed expressions are either values or can take a step) and preservation (types are preserved under execution) using Coq automation. Key techniques include induction on typing derivations, case analysis on which operands can step, inversion of typing hypotheses, and managing proof search depth to avoid infinite loops.

This video presents a method for structuring type soundness proofs in Dafny to improve proof stability by making the safety property and type checker functions opaque, thereby reducing the complexity that verification solvers must handle during proof construction. The approach involves proving safety lemmas for each language construct separately and inserting them directly after recursive calls in the main proof, which significantly improves resource usage metrics and makes large-scale type soundness proofs more tractable.

Despite common misconceptions, dependent type systems can achieve excellent type inference through unification-based approaches. The video demonstrates that Idris can infer complex type parameters including computational costs when sufficient information is available. Using question marks and proof search (auto), the system can automatically find appropriate evidence for type constraints. This makes dependent types practical for everyday programming despite their theoretical complexity.

Dependent types represent an evolution in type system capabilities, building upon existing dependency patterns. In standard programming, terms depend on other terms. In polymorphic languages, terms depend on types. In Haskell type families, types depend on types. Dependent types extend this by allowing types to depend on values/programs, enabling unprecedented expressiveness. This first-class treatment of types allows programs to compute types based on runtime values. The implementation demonstrates this through heterogeneous lists where each element can have a different type, with the compiler knowing the exact type at each position. This eliminates manual index checking and ad-hoc workarounds, showing how type-level computation enables safe, verified data manipulation impossible in conventional languages.

Dependent types extend type theory by allowing types to depend on values, enabling families of types indexed by types. The framework includes judgmental apparatus with definitional equivalences and typing judgments. A key structural property is that typing respects definitional equivalence, distinguishing it from simply typed lambda calculus where types are static syntax. This allows types to vary based on runtime values, enabling more precise type checking and computation at the type level.

Dependent type systems allow types to depend on values—for example, R^n is a type whose members are n-dimensional vectors, where n is a natural number. These systems were originally developed for proof verification but gained popularity in industry for software verification rather than mathematical proof checking.

Dependent types are types that depend on values, not just other types. Unlike ordinary functional programming where types like lists depend on element types (list of integers vs. list of strings), dependent types allow types to depend on specific values. For example, you can define an index type for a list where the type contains exactly the valid indices (0 to length-1) for that particular list. This enables safe operations like list indexing without runtime errors, as the compiler verifies validity at compile time.

The Lambda Cube is a three-dimensional framework that organizes different type systems for the lambda calculus, starting from the simply typed lambda calculus and extending it along three orthogonal axes—dependent types (lambda 2), polymorphism (lambda weak omega), and type operators (lambda p)—to demonstrate how type systems can be systematically combined to model computation, programming, and logic; this framework reveals the deep connections between computation, programming languages, and mathematical logic through the Curry-Howard isomorphism, which shows that propositions correspond to types and proofs correspond to programs.

The hypercube functor is a mathematical construction that generalizes Barendregt's lambda cube to arbitrary graph-structured lambda theories, enabling the systematic addition of types and kinds to untyped computational systems. This framework creates a hypercube of calculi where each dimension corresponds to different choices of whether types or kinds appear in specific positions, allowing for the derivation of dependent types, polymorphism, and structural types. From an AI perspective, this is significant because programs with holes (modal types) represent hypotheses about their environment, and the hypercube functor provides the minimal apparatus needed to build a scientist that can reason about its own reasoning methodology through computation over these hypotheses.

Pure type systems generalize the lambda cube by allowing arbitrary sets of sorts with flexible relations, enabling abstraction over any combination of sorts. However, this flexibility causes loss of metatheoretic properties like type unicity. Barendregt's conjecture proposes that weak normalization implies strong normalization for all pure type systems—a simple statement representing a major open question. Tiered pure type systems provide a constrained subclass generalizing the lambda cube while maintaining useful metatheoretic properties like the classification lemma. They feature hierarchical sorts with restricted rules ensuring quantification yields the source sort. Girard's paradox demonstrates that lambda minus (a tiered system) is not weakly normalizing—it contains a proof of false via Burali-Forti encoding. Remarkably, no other non-normalizing pure type systems have been discovered, making this question exceptionally challenging.

The Lambda Cube illustrates three different dimensions of a type system according to a subset of category theory. It shows how type systems can be extended through different dimensions, with the Calculus of Constructions being as close as we can get to solving these different constraints.

LambdaCube 3D is implemented as a Haskell-like language with its own compiler that transforms declarative descriptions into intermediate representations executed by backends for desktop, web, and mobile platforms. The system supports live coding where changes to code immediately update the preview window. For animation, time becomes a parameter for rendering functions. The framework uses 'slots' as named interfaces between the pipeline and application, with typed data structures for streams, framebuffers, and uniform data. This enables real-time experimentation with algorithms and effects while maintaining type safety throughout the graphics pipeline.