Formal Logic & Type Theory — Proofs as Programs, Types as Theorems

The Curry-Howard correspondence says every type annotation is a mathematical proof. Every type error is a theorem violation.

In 1934, Haskell Curry noticed something strange: the types of combinators in combinatory logic corresponded exactly to axioms in propositional logic. In 1969, William Alvin Howard proved this was not a coincidence — it was an isomorphism. Programs and proofs are the same thing. Types and propositions are the same thing. A well-typed program is a constructive proof that the proposition (expressed by its type) is true. A type error is a failed proof — a theorem that the program claims but cannot demonstrate.

This is the Curry-Howard correspondence, and it is the deepest result in the philosophy of programming. It means that the TypeScript compiler is a theorem prover. It means that Rust's borrow checker is a linear logic engine. It means that every time you write function add(a: number, b: number): number, you are stating a theorem: "there exists a computation that, given two numbers, produces a number." The compiler verifies your proof. If it fails, your theorem is wrong.

The flaw this axiom exposes: most software is written in languages that cannot state theorems, or that allow programmers to lie about their theorems, or that have escape hatches (any, void*, Object) that make every theorem trivially true — and therefore meaningless. The history of programming language design is the history of slowly, painfully rediscovering that Curry and Howard were right: more precise types mean more correct programs, because more precise types are stronger theorems.