enetsee

The Monoid Laws, Proved in Lean

Michael Thomas — Sat, 30 May 2026 00:00:00 GMT

In an earlier post the monoid laws showed up as an OCaml fold. Here they are again as theorems in Lean 4 — and this time the proofs are interactive.

Each proof below is rendered with Alectryon driven by LeanInk. Hover over a tactic (or the goal markers in the gutter) to see the proof state at that point: the hypotheses in context and the goal that remains.

/-! # The monoid laws for `Nat`, proved in Lean

The proofs below are processed by LeanInk + Alectryon, so each tactic step
shows the intermediate proof state when you hover or step through it. -/

/- Associativity of addition. We go by induction on the last argument. -/
theorem nat_add_assoc (a b c : Nat) : (a + b) + c = a + (b + c) := byGoals accomplished! 🐙
  a, b, c: Nat
a + b + c = a + (b + c)induction c with
  a, b, c: Nat
a + b + c = a + (b + c)| zero =>Goals accomplished! 🐙 a, b, c: Nat
a + b + c = a + (b + c)rflGoals accomplished! 🐙
  a, b, c: Nat
a + b + c = a + (b + c)| succ c ih =>a, b, c: Nat
ih: a + b + c = a + (b + c)
succa + b + (c + 1) = a + (b + (c + 1)) a, b, c: Nat
a + b + c = a + (b + c)simp [Nat.add_succ, ih]Error: tactic 'simp' failed, nested error:
maximum recursion depth has been reached
use `set_option maxRecDepth <num>` to increase limit
use `set_option diagnostics true` to get diagnostic information
a, b, c: Nat
ih: a + b + c = a + (b + c)
succa + b + (c + 1) = a + (b + (c + 1))

/- `0` is a left identity. (It is a right identity definitionally.) -/
theorem nat_zero_add (a : Nat) : 0 + a = a := byGoals accomplished! 🐙
  a: Nat
0 + a = ainduction a with
  a: Nat
0 + a = a| zero =>Goals accomplished! 🐙 a: Nat
0 + a = arflGoals accomplished! 🐙
  a: Nat
0 + a = a| succ a ih =>a: Nat
ih: 0 + a = a
succ0 + (a + 1) = a + 1 a: Nat
0 + a = asimp [Nat.add_succ, ih]Error: tactic 'simp' failed, nested error:
maximum recursion depth has been reached
use `set_option maxRecDepth <num>` to increase limit
use `set_option diagnostics true` to get diagnostic information
a: Nat
ih: 0 + a = a
succ0 + (a + 1) = a + 1

The associativity proof goes by induction on c: the zero case closes by rfl, and the succ case rewrites with the inductive hypothesis. Step through it above to watch the goal shrink.

Hello, Quarto

Michael Thomas — Sat, 30 May 2026 00:00:00 GMT

After a decade of neglect, the old Jekyll site is gone and this blog now runs on Quarto.

The plan for what lives here: programming languages, type theory, and proof assistants — with code in OCaml and proofs in Lean, plenty of mathematics, and the occasional digression.

Posts render to HTML with live math, and can also be exported to PDF when a typeset version is useful.

Folds, Monoids, and a Little Algebra

Michael Thomas — Sat, 30 May 2026 00:00:00 GMT

Monoids

A monoid is a set with an associative binary operation and an identity element such that

for all . Inline math works too: the natural numbers form a monoid, as do lists under concatenation.

In OCaml

We can capture this directly with a module type, and fold over any container given a monoid instance:

module type Monoid = sig
  type t
  val empty : t
  val combine : t -> t -> t
end

(* Sum the elements of a list through any monoid. *)
let fold_monoid (type a) (module M : Monoid with type t = a) (xs : a list) : a =
  List.fold_left M.combine M.empty xs

module Sum : Monoid with type t = int = struct
  type t = int
  let empty = 0
  let combine = ( + )
end

let () =
  let total = fold_monoid (module Sum) [ 1; 2; 3; 4 ] in
  Printf.printf "sum = %d\n" total   (* sum = 10 *)

The associativity law is exactly what makes the fold’s grouping irrelevant:

What’s next

A follow-up post will show the same idea in Lean, with the monoid laws stated as theorems and the proof states rendered inline.