Lectures onType Theory
Chapter 76
Chapter 76Optional

Universe Paradoxes and Hurkens's Construction

Prerequisites. Direct starred prerequisites: none. No later core chapter depends on this route.

Suppose a small predicate code may quantify over every code in an enclosing large universe. Its classifier must then contain a product of the form 01X:U1.P(X):U0, not merely a product over one decoded small code. This mixed product is the point at which the familiar failed self-membership calculation becomes dangerous. Hurkens’s construction shows that four carefully separated product operations already suffice for collapse; literal self-membership is not required.

The axiom card

This chapter uses its own Tarski-style signature U. It is not an extension of the predicative hierarchy of chapter 29.

Definition 76.1 — Hurkens's U^- interface

The large universe consists of a type U1 and, for each A:U1, a type El1(A). It has codes for products over a decoded large code and over all large codes: Π1(A,B):U1(A:U1, B:El1(A)U1),Π2(F):U1(F:U1U1). For each product there are abstraction and application operations λ1,1 and λ2,2, with signatures λ1:(x:El1(A)El1(Bx))El1(Π1(A,B)),1:El1(Π1(A,B))x:El1(A)El1(Bx),λ2:(A:U1El1(FA))El1(Π2(F)),2:El1(Π2(F))A:U1El1(FA). We take the two large beta laws as judgmental computation equations: (λ1x.t)1at[a/x],(λ2A.t)2Bt[B/A]. Spiwack presents corresponding equality axioms and rewrites along them. The judgmental presentation used here exposes the same conversion sites without printing the transports; it is therefore a strengthened presentation of the source interface, not a claim that its equalities were judgmental.

There is a code u0:U1. Put U0:=El1(u0) and assume a type El0(a) for each a:U0. The small codes are closed under Π0(a,b):U0(a:U0, b:El0(a)U0),Π01(A,b):U0(A:U1, b:El1(A)U0), with abstraction and application λ0,0 and λ01,01, typed by λ0:(x:El0(a)El0(bx))El0(Π0(a,b)),0:El0(Π0(a,b))x:El0(a)El0(bx),λ01:(x:El1(A)El0(bx))El0(Π01(A,b)),01:El0(Π01(A,b))x:El1(A)El0(bx). No beta law for either small product is assumed. Finally fix an arbitrary code F:U0.

We use the following local notation, always at the code level: 1x:A.B:=Π1(A,λx.B),A1B:=1_:A.B,2A.B:=Π2(λA.B),0x:a.b:=Π0(a,λx.b),a0b:=0_:a.b,01x:A.b:=Π01(A,λx.b). Thus El1(A1u0) carries application into El1(A)U0 and abstraction back, with the displayed one-sided beta equation. We do not identify it with that function type. The code a0b:U0 has the corresponding small introduction and elimination operations but no assumed beta equation. The subscripts distinguish a code in U1 from one in U0.

The diagonal terms

The following definitions are Spiwack’s axiomatisation with names expanded and types kept beside the terms [Spi15].

Definition 76.2 — The Hurkens spine

Define the large codes V:=2A.((A1u0)1A1u0)1A1u0:U1,U:=V1u0:U1. Here U is a code in the universe U1, not a third universe; U0 is the small universe decoded from u0. For z:El1(V) define sb(z):=λ2A.λ1r.λ1a.r1(z2A1r)1a:El1(V). For i:El1(U1u0) and x:El1(U) put le(i,x):=x1(λ2A.λ1r.λ1a.i1(λ1v.sb(v)2A1r1a)):U0. Its curried large representative is le:=λ1i.λ1x.le(i,x):El1((U1u0)1U1u0). Now define the small code Ind(i):=01x:U.le(i,x)0(i1x):U0, the large term WF:=λ1z.Ind(z2U1le):El1(U), and, for x:El1(U), the large term D(x):=λ1v.sb(v)2U1le1x:El1(U). For i:El1(U1u0) put J(i):=λ1y.i1D(y):El1(U1u0). Finally, for x:El1(U) define the small code I(x):=(01i:(U1u0).le(i,x)0(i1D(x)))0F:U0.

Every displayed application is now checkable from the adjacent type. The critical one is z2U1le:El1(U1u0): since z:El1(V), instantiating its outer 2 at U expects exactly the large representative le. The result is precisely the domain of Ind, so WF is well formed.

The diagonal proof uses four conversions, all generated by the two large beta equations: (β1)J(i)1xi1D(x),(β1,β2)le(J(i),x)le(i,D(x)),(β1,β2)le(i,WF)Ind(J(i)),(β1)(λ1u.I(u))1xI(x). For the second equation, unfold le and contract the outer λ1 in J(i) and the λ2 and λ1 redexes in sb. The third unfolds WF and Ind before the same contractions. No small beta equation is used.

Lemma 76.3 — The three inhabitants

Under definition 76.1, definition 76.2, there are terms Ω:El0(01i:(U1u0).Ind(i)0(i1WF)),L1:El0(Ind(λ1u.I(u))),L2:El0((01i:(U1u0).Ind(i)0(i1WF))0F). Their construction uses only the two large beta laws.

Proof of Lemma 76.3 — The three inhabitants

Proof. Write Q:=01i:(U1u0).Ind(i)0(i1WF)andk:=λ1u.I(u). The three inhabitants are the following terms: Ω:=λ01i.λ0y.y01WF0(λ01x.λ0h.y01D(x)0h),L1:=λ01x.λ0p.λ0q.(q01k0p)0(λ01i.λ0h.q01J(i)0h),L2:=λ0q.(q01k0L1)0(λ01i.λ0h.q01J(i)0h).

We check the terms from the outside inward. For Ω, let i:El1(U1u0) and y:El0(Ind(i)). Application at WF asks for El0(le(i,WF)). By (β _1,β _2), this is El0(Ind(J(i))). Its displayed inhabitant sends x and h:El0(le(J(i),x)) to y01D(x)0h: equation (β _1,β _2) converts the premise, and (β _1) converts the result. Thus Ω:Q.

For L1, the outer two abstractions construct Ind(k). By (β _1), their result must inhabit I(x). After introducing p:El0(le(k,x))andq:El0(01i.le(i,x)0i1D(x)), the term q01k0p inhabits I(D(x)) by (β _1). Its remaining argument is constructed by sending i,h to q01J(i)0h; equations (β _1,β _2) and (β _1) give exactly the required premise and conclusion. This establishes L1.

Finally let q:El0(Q). The term q01k0L1 inhabits I(WF) by (β _1). Its displayed final argument sends i and h:El0(le(i,WF)) to q01J(i)0h; equation (β _1,β _2) converts h to the required induction premise, and (β _1) converts the result. Hence L2:Q0F.

These terms are the transport-free, judgmental-beta presentation of Spiwack’s Omega, lemma1, and lemma2 [Spi15]. The four code formers correspond to the source’s Forall1, ForallU1, Forall0, and ForallU0, respectively. Every conversion above is one of the four displayed β1/β2 equations; no small beta law occurs. ◻

Proof of Theorem 76.4 — Hurkens collapse

Proof. By lemma 76.3, application L20Ω has type El0(F). Application is an operation supplied by the interface; no small beta equation is used. ◻

Corollary 76.5 — The exact inconsistency boundary

If some F:U0 decodes to an empty type, the interface is inconsistent. Removing either large product closure, either small product closure, the embedding u0, or the relevant introduction/elimination operation blocks the displayed derivation. The derivation does not require beta for either small product.

Proof of Corollary 76.5 — The exact inconsistency boundary

Proof. If El0(F) is empty, theorem 76.4 supplies an inhabitant of an empty type. The dependency boundary is read from the written terms:

Π1.

It first forms U=V1u0 and is then used by sb, le, le, D, and J.

Π2.

It forms the head of V and permits each z2A and sb(v)2U application.

Π0.

It forms the small implications in Ind and I, including the final implication to F.

Π01.

It forms the quantifiers over x:U and over i:U1u0 in Ind, I, Q, and the three proof terms.

u0.

It supplies the small-universe code used in every A1u0 classifier and in the definition of U0.

The displayed proof terms also use the corresponding abstraction and application operations. Their only reductions are the four large-beta conversions in (β _1), (β _1,β _2), (β _1,β _2), and (β _1); neither small beta law is present. Removing one listed operation makes the first named construction that uses it ill formed. This proves a dependency claim about this derivation, not consistency of any weakened interface. ◻

It does not follow that every weakening of one assumption is consistent. In particular, ordinary predicative hierarchies avoid the interface because a small impredicative product may not quantify over the enclosing large universe.

A Reynolds–Hurkens variation

Coquand’s variation is a separate higher-order-logic calculation, not a renaming of theorem 76.4. Its λHOL card has sorts ,,, axioms :, :, and product rules (,), (,), and (,). Fix A:, put :=p:.p and ¬p:=p, and let Pow(X)=X and T(X)=Pow(Pow(X)). The rule (,) is spent when a proposition quantifies over p:Pow(A). For f:XY, Q:T(X), and p:Pow(Y), functorial action is T(f)(Q):=λp.Q(λx.p(fx)).

Theorem 76.6 — Reynolds–Hurkens retraction boundary

In minimal higher-order logic, suppose A is a type with maps intro:T(A)A,match:AT(A), and the judgmental equality (RH)matchintroT(intromatch). Then falsity is inhabited.

Proof of Theorem 76.6 — Reynolds–Hurkens retraction boundary

Proof. Put δ=intromatch and define p0(x):=p:Pow(A). p(δx)¬match(x)(p),X0(p):=x:A. p(x)¬match(x)(p),x0:=intro(X0). Equation (RH) gives match(δx)(p)match(x)(pδ). Let x:A, p:Pow(A), h1:p0(x), and h0:X0(p). The auxiliary terms are s1(x,h1):=λp.h1(pδ):p0(δx),s2(p,h0):=λx.h0(δx):X0(pδ),l0:=λp.λh.λh0.h0(x0)(h)(s2(p,h0)),l1:=λx.λh1.h1(p0)(s1(x,h1)):X0(p0). Here l0:p:Pow(A)p(x0)¬X0(p). Its typing uses (RH) to convert match(x0)(p) to X0(pδ). For arbitrary p:Pow(A) and h:p(δx0), put l2(p,h):=l0(pδ,h):¬match(x0)(p). The classifier is converted using (RH), since match(x0)(p)X0(pδ). Thus l2:p0(x0). The final term l0(p0,l2,l1) has type . This is the calculation of Coquand’s Theorem 1.2 [Coq23]; its only conversion beyond beta is (RH), used in the typings of s1, s2, l0, and l2. The source prints l0(x0,l2,l1) at the final step; its declared type requires the first argument p0, as displayed here. ◻

The weak impredicative encoding A:=ΠX:(TXX)X supplies such maps and equation in λU, which extends the displayed λHOL card by the product rule (,) [Coq23]. That observation is scoped to the stated sort and product rules. It neither adds those rules to the book’s predicative hierarchy nor turns Reynolds’s semantic non-definability theorem into this syntactic contradiction.

Exercise 76.1

★★☆ Starting from z:El1(V), type every application in sb(z). Record which occurrence uses Π2 rather than Π1.

Exercise 29.17

★☆☆ Work in the inductive theory of chapter 28 extended by the U interface, and assume F:U0 with El0(F)0 type. Use theorem 76.4 and empty elimination to inhabit any given closed type.

Suggested first pass.

Begin with exercise 76.3, exercise 76.4; then run exercise 76.5 and compare each rejected certificate with the mathematical dependency ledger in corollary 76.5.

Exercise 76.3

★★★ For each conversion in (β _1), (β _1,β _2), (β _1,β _2), and (β _1), mark the contracted β1 and β2 redexes. Then check each use of those equations in the proof of lemma 76.3. Verify that no line appeals to β0 or β01.

Exercise 76.4

★★☆ Derive match(δx)(p)match(x)(pδ) from (RH) by expanding T. Identify the exact type of s2(p,h) and the four points at which the proof uses (RH).

Exercise 76.5

★★★ Practical project.hurkens-assumption-ledger Run this chapter’s Kappa assumption ledger. Remove Π1, Π2, Π0, Π01, and u0 in turn and require the corresponding named rejection. Then enable the two small-beta flags: the accepted certificate must remain accepted. Explain why this finite Boolean dependency check is not a term checker and does not mechanize theorem 76.4.

Bibliographic notes

Hurkens gave the compact paradox in 1995 [Hur95]. Spiwack’s axiomatisation records exactly which beta laws the proof uses [Spi15]; those pages were the primary rule and proof source for definition 76.1, lemma 76.3. Coquand’s Reynolds–Hurkens variation states the separate retraction equation and its λU encoding [Coq23]. The Rocq library and an Agda file compiled with --type-in-type are useful replays of stronger inconsistent settings. Neither is evidence that the predicative hierarchy of chapter 29 admits the displayed interface.

Search the book

Type to search the local edition.