Agda on emsenn.net

Dependent Types in Agda

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

¶Dependent function types (Pi-types)

In Agda, every function type can be dependent. The syntax:

f : (x : A) → B x

declares a function where the return type B x depends on the input value x. When the return type does not depend on the input, this reduces to the ordinary function type A → B.

Example. A function that returns a type based on a boolean:

T : Bool → Set
T true  = Nat
T false = String

A function using this:

Introduction to Agda

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

¶What Agda is

Agda is a dependently typed functional programming language based on Martin-Löf type theory. It is simultaneously a programming language and a proof assistant: every well-typed program is a proof, and every proof is a program.

Unlike Lean, which provides a tactic language for constructing proofs interactively, Agda proofs are written as ordinary function definitions using pattern matching. There is no tactic layer — the proof IS the code. This design choice makes proofs explicit and readable at the cost of less automation.

pattern matching

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

Pattern matching in Agda is dependent: when you match on a constructor, the type checker refines the types of all other variables in scope to reflect the information gained.

For example, matching a value of type Vec A (suc n) against the constructor x ∷ xs tells the checker that the length is suc n, and xs has type Vec A n. This refinement happens automatically and is checked for completeness — you must handle every constructor.

Proving in Agda

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

¶Propositions as types

In Agda, there is no separate Prop sort — propositions are ordinary types in Set. A proof of proposition P is a term of type P. The logical connectives are defined as data types:

-- Conjunction
record _×_ (A B : Set) : Set where
  constructor _,_
  field fst : A ; snd : B

-- Disjunction
data _⊎_ (A B : Set) : Set where
  inj₁ : A → A ⊎ B
  inj₂ : B → A ⊎ B

-- Negation
¬_ : Set → Set
¬ A = A → ⊥    -- where ⊥ is the empty type

-- Existential
-- Σ type (see previous lesson)

-- Universal: dependent function type (x : A) → P x

Because Agda is intuitionistic, excluded middle is not available by default. A proof of A ⊎ B must supply a proof of A or a proof of B — you cannot argue “suppose neither, derive a contradiction.”

standard library

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

The Agda standard library (agda-stdlib) provides formalized definitions and proofs for common mathematical and computational structures. It covers:

Data types: natural numbers, integers, lists, vectors, finite sets, strings.
Relations: binary relations, equivalence relations, partial orders, total orders, decidability.
Algebra: monoids, groups, rings, lattices, with an algebraic hierarchy using record types.
Logic: propositional logic, predicate logic, decidability, classical axioms (importable but not default).
Category theory: basic definitions of categories, functors, natural transformations.

The standard library is smaller and more manually curated than Lean’s Mathlib. Where Mathlib aims for broad coverage with automation, agda-stdlib emphasizes explicit, readable definitions that stay close to the underlying type theory.

universe level

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

In Agda, types are organized into a hierarchy of universes to avoid paradoxes. The base universe is Set (also written Set₀), which contains ordinary types like Nat, Bool, and List Nat. The type Set itself belongs to Set₁, which belongs to Set₂, and so on:

Nat : Set
Set : Set₁
Set₁ : Set₂
...

This stratification prevents Russell’s paradox: no universe contains itself.

Agda supports universe polymorphism — definitions can be parameterized over a universe level variable ℓ, allowing them to work at any level:

Write Agda Proof

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

¶Prerequisites

Read the write-formal-proof skill first. It contains the anti-slop checklist that must pass before any proof is considered complete.

¶Agda-specific workflow

State the proposition as an Agda type signature with explicit universe levels and parameters.
Identify standard library imports. Common ones:
- Relation.Binary.PropositionalEquality — _≡_, refl, cong, sym, trans, subst
- Data.Nat, Data.List — basic data types
- Data.Product — _×_, _,_, proj₁, proj₂
- Data.Sum — _⊎_, inj₁, inj₂
- Level — universe level management
- Function — id, _∘_, case_of_
Write the proof as a function definition. Agda has no tactic mode — proofs are terms. Use: