Type theory is often introduced as a catalogue of formalisms: simply typed \lambda calculus, dependent types, universes, inductive families. The fastest route to competence is different. Treat type theory as a discipline of proof engineering in which every statement is a judgment, every proof is a derivation tree, and the core lemmas are about how derivations behave under context change and substitution. Once that posture is stable, the sophisticated layers become variations on a small set of moves.
This guide builds that posture. It focuses on the proof habits that reliably work across systems: structural induction on derivations, explicit invariants for contexts, substitution as the central engine, and the progress and preservation template as a stress test for any design.
Value WiFi 7 RouterTri-Band Gaming RouterTP-Link Tri-Band BE11000 Wi-Fi 7 Gaming Router Archer GE650
TP-Link Tri-Band BE11000 Wi-Fi 7 Gaming Router Archer GE650
A gaming-router recommendation that fits comparison posts aimed at buyers who want WiFi 7, multi-gig ports, and dedicated gaming features at a lower price than flagship models.
- Tri-band BE11000 WiFi 7
- 320MHz support
- 2 x 5G plus 3 x 2.5G ports
- Dedicated gaming tools
- RGB gaming design
Why it stands out
- More approachable price tier
- Strong gaming-focused networking pitch
- Useful comparison option next to premium routers
Things to know
- Not as extreme as flagship router options
- Software preferences vary by buyer
The basic objects are judgments, not propositions
In many courses, propositions come first and judgments are treated as notation. In type theory, judgments are primary. A judgment is something like:
- A context is well formed: `Γ ⊢`
- A type is well formed in a context: `Γ ⊢ A : Type`
- A term has a type: `Γ ⊢ t : A`
- Two terms are definitionally equal: `Γ ⊢ t ≡ u : A`
The inference rules of the theory determine which judgments can be derived. Proofs are derivations, and derivations are trees built from rules. That viewpoint prevents a common mistake: arguing semantically when the goal is syntactic, or vice versa. When a claim is about derivations, the right tool is induction on the derivation tree.
A practical habit is to keep a clear boundary between:
- Derivable judgments, proved by rule applications
- Meta level statements about derivations, proved by induction and lemmas
- Semantic statements about models, proved by interpretation
Most of the day to day work in type theory lives in the second bullet.
Contexts are structured data, not sets of assumptions
A context is not merely a collection of assumptions. It is ordered, it carries variable bindings, and the rules constrain which extensions are legal. For the simply typed \lambda calculus, a context looks like `x:A, y:B, z:C`. For dependent types, later bindings may depend on earlier ones.
Because contexts are structured, the meta lemmas are structured too. You rarely prove an isolated theorem about typing without also proving companion facts about weakening, exchange, and substitution.
A compact way to keep the structure visible is to use a context discipline that makes dependencies explicit. For dependent types, one typically writes:
- `Γ, x:A ⊢` means `Γ ⊢ A : Type` and then `x` may be used later
- If a later type mentions `x`, that dependency is part of the well formedness proof
The payoff is that substitution becomes predictable rather than mysterious.
The substitution lemma is the central engine
Substitution is the theorem that makes type theory behave like a calculus rather than a collection of ad hoc rules. In its simplest form, it says:
If `Γ, x:A, Δ ⊢ t : B` and `Γ ⊢ s : A`, then `Γ, Δ[s/x] ⊢ t[s/x] : B[s/x]`.
The statement is a mouthful because it is accurate. It tracks both term substitution in terms and type substitution in types, and it tracks how substitution transforms the trailing context `Δ`.
The proof is also the template for many other proofs: induction on the derivation of `Γ, x:A, Δ ⊢ t : B`. Each rule case shows how to push substitution through that rule.
A reliable workflow is:
- Write the lemma with all dependencies visible, including how contexts are transformed
- Prove auxiliary lemmas you will need inside the induction, especially about well formedness
- In each rule case, decide whether substitution acts on the rule premises, the conclusion, or both
- Use the induction hypothesis to rewrite the premises after substitution
- Rebuild the derivation with the same rule
For many systems, substitution is the only proof that takes time. Once it is done, a large fraction of later theorems become corollaries.
Weakening is the second pillar
Weakening says that adding unused assumptions does not break derivability. In a simple statement:
If `Γ ⊢ t : A` and `Γ ⊆ Γ'` by well formed extension, then `Γ' ⊢ t : A`.
There are different formulations depending on how you represent contexts. The proof is usually induction on the typing derivation, with careful attention to the variable rule.
Weakening and substitution form a pair:
- Weakening lets you move to larger contexts
- Substitution lets you eliminate variables by replacing them with terms
Together they let you refactor derivations without changing the underlying term.
A worked example: typing and preservation in the simply typed \lambda calculus
To make these proof moves concrete, consider the simply typed \lambda calculus with:
- Types: `A, B ::= ι | A → B` where `ι` is a base type
- Terms: `t, u ::= x | λx:A. t | t u`
- Values: `v ::= λx:A. t`
Typing rules include:
- Variable: if `x:A ∈ Γ` then `Γ ⊢ x : A`
- Abstraction: if `Γ, x:A ⊢ t : B` then `Γ ⊢ λx:A. t : A → B`
- Application: if `Γ ⊢ t : A → B` and `Γ ⊢ u : A` then `Γ ⊢ t u : B`
Operational semantics includes \beta reduction:
- `(λx:A. t) v → t[v/x]` when `v` is a value
Preservation, the fact that reduction respects types, is:
If `Γ ⊢ t : A` and `t → t'`, then `Γ ⊢ t' : A`.
A clean preservation proof follows a stable shape:
- Induct on the derivation of `Γ ⊢ t : A`
- Analyze the reduction step `t → t'` by cases
- In the application case, the only interesting subcase is \beta reduction
- Beta reduction forces you to use substitution
In the \beta case, typing has the form:
- `Γ ⊢ (λx:A0. t0) v : B0`
- So `Γ ⊢ λx:A0. t0 : A0 → B0` and `Γ ⊢ v : A0`
- From typing of abstraction, `Γ, x:A0 ⊢ t0 : B0`
- Apply substitution to obtain `Γ ⊢ t0[v/x] : B0`
- This is the required type for the reduced term
The only nontrivial lemma used is substitution. Everything else is bookkeeping.
A similar pattern appears in far more expressive systems, where reduction may include unfolding definitions, evaluating eliminators, or computing on inductive data. Preservation remains a repeated test of whether substitution and definitional equality are correctly designed.
How to choose the right induction parameter
Many beginners attempt induction on term structure and get stuck. Induction on terms is sometimes appropriate, but typing derivations contain information that term structure alone does not capture. For example, a term `x` can have many different types in different contexts, and the typing derivation records the relevant type.
A practical rule is:
- If the claim is about typing, induct on the typing derivation
- If the claim is about reduction, induct on the reduction derivation
- If the claim is about normal forms or canonical forms, use induction on types, sometimes nested with induction on derivations
When multiple derivations are involved, pick the one with the most informative rule cases, and then use the other as a parameter within each case.
Canonical forms and progress
Progress says that a closed well typed term is either a value or can take a reduction step. In the simply typed \lambda calculus, it is:
If `∅ ⊢ t : A` then either `t` is a value or there exists `t'` with `t → t'`.
Progress requires a lemma about canonical forms:
- If `∅ ⊢ v : A → B` and `v` is a value, then `v` is an abstraction `λx:A. t`
The proof uses the fact that the only value form is abstraction. In richer systems, canonical forms become structural lemmas that say what values of a given type must look like. The proof strategy is typically induction on the typing derivation of the value, or on the type, depending on the system.
The progress and preservation pair is more than a safety theorem. It is a debugging tool. When designing a type system, if progress fails, you learn that your typing permits stuck terms. If preservation fails, you learn that your operational rules compute in a way not aligned with typing. The pair quickly exposes mismatches between syntax, computation, and typing.
Definitional equality is where many systems become subtle
In dependent type theory, definitional equality is part of typing. A term may type check because two types are definitionally equal after computation. This changes how proofs are structured:
- Many lemmas must be stated up to definitional equality
- Substitution must respect definitional equality
- Normalization or canonicity results become important for metatheory
A useful practice is to separate:
- Definitional equality, a built in judgment used by the type checker
- Propositional equality, a type whose inhabitants are explicit proofs
Once separated, you can reason about which equalities are computational and which are proof relevant.
When a proof unexpectedly grows, it often means you are using definitional equality where propositional equality would be more stable, or the other way around. The remedy is rarely to add more cleverness. It is usually to adjust which equalities are implicit and which are explicit.
A table of core lemmas and what they buy
| Lemma | Informal meaning | Typical proof method | What it enables |
|—|—|—|—|
| Weakening | you may extend a context | induction on derivation | reuse derivations under extra assumptions |
| Substitution | you may replace a variable by a term | induction on derivation | preservation, \beta soundness, dependent instantiation |
| Exchange | you may permute independent bindings | derivation transform | reordering contexts, structural rules |
| Strengthening | unused bindings can be removed | admissibility argument | minimal contexts, proof compression |
| Canonical forms | values of a type have a specific shape | derivation analysis | progress, canonicity |
| Subject reduction | types are preserved by computation | induction on typing | safety, definitional equality sanity |
In most systems, everything else is decoration on these ideas.
Proof ergonomics: make invariants visible early
Proof failures in type theory are usually failures of hidden invariants. The antidote is to state the invariant as part of the theorem statement.
Examples of invariants that should be explicit:
- The context is well formed and each type in it is well formed in the preceding context
- The term is well scoped with respect to the context
- Definitional equality respects substitution and weakening
When these are explicit, induction hypotheses become usable instead of fragile.
A practical style is to use short well formedness side conditions in the main lemmas and to keep separate lemmas that establish well formedness of derived types. This prevents proofs from bloating with repeated checks.
Extending the method: dependent types and inductive definitions
The same proof patterns scale. For dependent types, substitution becomes more involved because types depend on terms. For inductive definitions, one adds computation rules for eliminators and proves that the computation rules preserve typing.
A good litmus test is to attempt a progress and preservation argument for a small fragment of your theory. For example:
- A dependent function type with application
- A dependent pair type with projections
- A natural number type with primitive recursion
Each fragment forces you to prove exactly the lemmas you will need for the whole system, and it reveals whether definitional equality is aligned with computation.
If the fragment proof is smooth, the full metatheory will be manageable. If the fragment proof is painful, the system design likely needs adjustment.
Closing perspective
Type theory becomes far less intimidating when you see that most proofs are about moving derivations through structural transformations. The high level concepts matter, but the daily work is craft. Learn the craft first.
The most transferable habit is this: when you read a new type theory, hunt for its substitution lemma, its weakening lemma, and its definitional equality rules. Those three pieces determine the shape of everything that follows. Once you can prove them or at least understand their proof skeleton, you can handle the rest of the system with confidence.
Books by Drew Higgins
Prophecy and Its Meaning for Today
New Testament Prophecies and Their Meaning for Today
A focused study of New Testament prophecy and why it still matters for believers now.
Leave a Reply