Lean on emsenn.net

Introduction to Lean

Sun, 01 Mar 2026 00:00:00 +0000

What Lean is

Lean 4 is a dependently typed functional programming language and interactive theorem prover. It serves two purposes at once: you can write executable programs in it, and you can state and prove mathematical theorems in it. These are the same activity — a proof is a program whose type is the proposition it proves.

Lean’s architecture has two layers:

The kernel: a small, trusted type checker that verifies proof terms. The kernel implements the Calculus of Inductive Constructions. If the kernel accepts a term, the proof is correct — there is no appeal to external authority.
The elaborator: a front-end that translates human-readable Lean code into the kernel’s internal language. Tactics, implicit arguments, type inference, and metaprogramming all live in the elaborator. They make proofs easier to write without enlarging the trusted base.

Installation

Lean 4 is installed through elan, a toolchain manager (analogous to rustup for Rust):

Mathlib

Sun, 01 Mar 2026 00:00:00 +0000

Mathlib is Lean’s primary library of formalized mathematics. It contains Lean definitions for objects, theorems, and proofs in algebra, analysis, category theory, combinatorics, number theory, order theory, and topology. Mathlib serves as both a reference library for working mathematicians and a testbed for proof automation techniques. The library is community-maintained and grows through a structured contribution process that enforces style, documentation, and proof conventions. In the context of this vault, Mathlib is relevant for formalizing the Heyting algebra and closure operator structures that underlie the semiotic universe.

tactic

Sun, 01 Mar 2026 00:00:00 +0000

A tactic is a command that transforms a proof goal into simpler subgoals. Tactics build proof terms incrementally: each tactic takes the current goal state (a type to be inhabited) and produces zero or more new goals, constructing the proof term behind the scenes.

In Lean 4, tactic mode is entered with the by keyword. Common tactics include intro (introduce a hypothesis), apply (apply a lemma), exact (supply the exact proof term), simp (simplify using lemmas), rw (rewrite using an equation), and cases/induction (case-split or induct on a value).

Tactics in Lean

Sun, 01 Mar 2026 00:00:00 +0000

What tactics do

A tactic transforms a proof goal into simpler subgoals. The proof state consists of:

Context: named hypotheses and local definitions.
Goal: the type (proposition) that remains to be proved.

Each tactic inspects the goal and context, then either closes the goal (producing a proof term) or splits it into subgoals. When all goals are closed, the proof is complete and Lean’s kernel checks the assembled proof term.

Core tactics

Introducing hypotheses

intro moves a universally quantified variable or implication antecedent from the goal into the context:

theorem

Sun, 01 Mar 2026 00:00:00 +0000

A theorem in Lean is a named declaration consisting of a type (the proposition) and a term (the proof). The syntax is:

theorem name : proposition := proof_term

or equivalently in tactic mode:

theorem name : proposition := by
  tactic₁
  tactic₂
  ...

The kernel checks that the proof term has the declared type. If it does, the theorem is accepted; if not, Lean reports an error. A theorem declaration differs from a def only in that theorems are marked as irrelevant to computation — they contribute type information but are erased at runtime.

Types and Propositions in Lean

Sun, 01 Mar 2026 00:00:00 +0000

Prop and Type

Lean distinguishes two sorts:

Type (actually Type u for universe level u) — the sort of computational types. Nat : Type, String : Type, List Nat : Type.
Prop — the sort of propositions. 2 + 2 = 4 : Prop, ∀ n, n + 0 = n : Prop.

The distinction matters for erasure: values of type Prop are erased at runtime because they carry no computational content — a proof that 2 + 2 = 4 does not affect program execution. This separation lets Lean be both a programming language and a proof assistant without proofs slowing down compiled code.