Homotopy Type Theory For Dummies

Homotopy Type Theory 

For Dummies 

Thorsten Altenkirch 

Functional Programming Laboratory 

School of Computer Science 

University of Nottingham 

October 30, 2013 

Thorsten Altenkirch (Nottingham) Edinburgh 13 October 30, 2013 1 / 29

Intro 

The HoTT book 

Outcome of the Special 

Year on Homotopy Type 

Theory at Princeton. 

Proposes an extension of 

Martin-Löf Type Theory 

as a new foundation of 

Mathematics. 

Informal use of Type 

Theory to appeal to 

Mathematicians (but not 

only). 

Additional principles 

inspired by Homotopy 

Theory. 


Basic Type Theory 

Type Theory 101 

Martin-Löf Type Theory: foundational system for 

constructive Mathematics 

Based on Curry-Howard equivalence 

proofs : proposition = programs : type 

E.g. as we recursively define the function (+) : N → N → N: 

0 + n :≡ n 

S(m) + n :≡ S(m + n) 

we recursively define the proof: 

assoc : Π i,j,k:N (i + j) + k = i + (j + k) 

assoc(0, j, k) :≡ refl(j + k) 

assoc(S(i), j, k) :≡ ap(S, assoc(i, j, k)) 

Theorem proving becomes functional programming! 

Basis of a number of proofs assistants / programming languages : 

NuPRL, LEGO, Coq, Agda, Idris, . . . 


Basic Type Theory 

Proof-relevant mathematics 

The axiom of choice (AC ∞ ) in Type Theory 

(given A, B : Type, R : A → B → Type): 

(Πa : A.Σb : B.R(a, b)) → (Σf : A → B.Πa : A.R(a, f (a))) 

AC ∞ is provable, the proof is given by 

ac f = (λa.fst(f (a)), λa.snd(f (a)) 

where fst,snd are the projections associated with Σ. 

Proofs in Type Theory can contain information. 

We call a type A propositional (A : Prop), if it contains no 

information. 

A propositional version of the axiom AC −1 is not provable and 

implies excluded middle. 


Identity types 


Given A : Type and a, b : A we can form 

a = A b : Type 

the type of proofs that a is equal to b. 

The canonical inhabitant is 

refl(a) : a = A a 

given a : A. 

The eliminator for equality types is 

J(a) : Π P:Πb:A.a=b→Type P(a, refl(a)) → Π x:A,α:a=x P(x, α) 

for a : A, with the definitional equality J(P, p, refl(a)) ≡ p. 



Groupoid structure 

Using the non-dependent version of J 

transport : Π a,b:A Π P:A→Type a = b → P(a) → P(b) 

we can show that = is an equivalence relation: 

α −1 : b = a 

for α : a = b 

α; β : a = c for α : a = b, β : b = c 

Using J we can also show: 

α, refl = α 

refl; α = α 

(α; β); γ = α; (β; γ) 

α; α −1 = refl 

α −1 ; α = refl 

That is = forms a groupoid. 



Should equality be propositional? 

Should equality be propositional ? I.e. can we prove Uniqueness of 

equality proofs (UIP): 

Using J this is can be reduced to: 

Π a,b:A Π p,q:a=b q = p 

Π a:A Π p:a=a p = refl 

Hofmann and Streicher showed that UIP cannot be derrived from J 

using a groupoid model of Type Theory. 

More recently, Voevodsky observed that UIP is also refuted by a 

homotopy model of Type Theory. 

Basic idea: 

Types topological spaces 

a : A points in the space 

a = A b paths between the points 


Homotopic interpretation 

Homotopic Model 

A : Type 

a, b : A 

p, q : a = b 

H : p = q 



Uniqueness of Identity proofs ? 

Π p:a=a p = refl ? 



Uniqueness of Identity proofs ? 

Okay, but what now? 



While we cannot show UIP 

We can show: 

Π p:a=a p = refl(a) 

Π p:a=a (a, p) = Σx:A x=a (a, refl(a)) 

This follows from SCTR (singletons are contractible): 

assuming a : A. 

On the other hand 

Π (b,p):Σb:A,a=b (a, refl(a)) = (b, p) 

J(a) : Π P:Πb:A.a=b→Type P(a, refl(a)) → Π x:A,α:a=x P(x, α) 

can be derived from transport 

and SCTR. 

transport : Π a,b:A Π P:A→Type a = b → P(a) → P(b) 



J in the Homotopy interpretation 

To show 

Π p:a=a (a, p) = Σx:A x=a (a, refl(a)) 

we use 

Π (b,p):Σb:A,a=b (a, refl(a)) = (b, p) 


The univalence axiom 

Univalence 

Rejection of UIP is not the only thing the Homotopy interpretation is 

good for. 

It also suggests an additional principle: the univalence axiom. 

This axiom can also be justified from a purely logical perspective. 

And it is inconsistent with UIP! 



What is equality of functions ? 

Given f , g : A → B we define extensional equality : 

f ∼ g :≡ Π a:A f (a) = g(a) 

We can show 

app : f = g → f ∼ g 

Extensionality corresponds to requiring app to be an isomorphism. 

It’s inverse is functional extensionality. 

This can be justified by the black box view of functions. 



What is the equality of types? 

Given A, B : Type we define isomorphism A ∼ B as 

f : A → B 

g : B → A 

η : Π a:A a = g(f (a)) 

ɛ : Π b:B b = f (g(b)) 

In the absence of UIP we can require coherence properties which 

correspond to the triangle equalities of an adjunction: 

δ : Π a:A ap(f , η(a)) = ɛ(f (b)) 

δ ′ : Π b:B η(g(b)) = ap(g, ɛ(n)) 

where ap(f ) : Π a,a ′ :Aa = a ′ → f (a) = f (a ′ ) 

We can derive δ from δ ′ and vice versa, because equality is a groupoid. 

We define equivalence A ≈ B as given by isomorphism and δ. 



What is the equality of types? 

We can show: 

coe : A = B → A ≈ B 

The univalence axiom sates that coe is an equivalence. 

This is justified by a black box view of types. 

Note that the univalence axiom implies functional extensionality. 


Truncation levels 


In the absence of UIP we classify types according to the complexity of 

their equality types. 

We say a type A : Type is contractible or a -2-type, if 

is inhabited. 

Σ a:A Π x:A x = a 

A type A : Type is a n + 1-type, if all its equality types a = A a ′ for 

a, a ′ : A an n-types. 

To show that any n-Type is also a n + 1-type we need to show that if 

a type is contractible, then its equalities are contractible too. 



A contractible → a = A a ′ contractible 

Assume that A is contractible, that means we have 

a 0 : A 

h : Π x:A x = a 0 

Now for any a, a ′ : A we have 

α 0 (a, a ′ ) : a = a ′ 

α 0 (a, a ′ ) :≡ h(a); h(a ′ ) −1 

We need to show that 

Π a,a ′ :AΠ p:a=a ′p = α 0 (a, a ′ ) 

Using J it is sufficient to show 

Π a:A refl(a) = α(a, a) ≡ h(a); h(a) −1 

Which is just one of the groupoid laws. 



The Truncation Hierarchy 

level 

-2 contractible types 

-1 propositions The theorem we just proved 

implies that it is enough that 

Π a,a ′ :Aa = a ′ . 

0 sets UIP corresponds to the assumption 

that every type is a 

set. 

1 groupoids 

. 

. 



Higher types 

How do we get types at higher levels? 

The 1st universe Type 0 cannot be a set. 

Consider Bool = Bool, using univalence there are two equivalences: 

id, and negation. 

However, id and negation cannot be equal. 

My student Nicolai Kraus proved that the nth universe is an cannot 

be an n-type. 


HITs 

Higher inductive types 

There are other ways to obtain higher types in HoTT. 

A higher inductive type has not only constructors for elements but 

also for equalities. 

A simple example is S 1 : Type 

base : S 1 

loop : base = base 

S 1 homotopically behaves like the circle. 

Indeed we can embedd i : Z into φ(i) : base = base: 

i 

↦→loop n 

0 ↦→refl 

− n 

↦→(loop −1 ) n 


HITs 


S 1 also comes with eliminators: just consider the non-dependent 

eliminator: 

satisfying the equalities 

Elim S1 : Π M:Type Π b:M (b = b) → S 1 → M 

Elim S1 (M, b, q, base) ≡ b 

ap(Elim S1 (M, b, q), loop) ≡ q 

Using univalence we can prove α : Z = Z using the equivalence 

(λn.n + 1, λn.n − 1, . . . ). 

We define a family: 

F : S 1 → Type 

F = Elim S1 (Type, Z, α) 


HITs 


This allows us to define an inverse to φ: Given p : base = base we 

can construct 

transport(F , p) 

: F (base) → F (base) 

Note that F (base) ≡ Z. Hence we define: 

φ −1 (p) :≡ transport(F , p, 0) : Z 

Dan Licata showed how we can use the dependent eliminator to 

derive that φ, φ −1 are inverse and hence: 

(base = base) = Z 


HITs 

The sphere 

The circle S 1 is 1-type (groupoid), all higher equalities are 

propositional. 

However, the situation is different for the sphere S 2 : Type which can 

be defined as a HIT: 

base : S 2 

loop : refl(base) = refl(base) 

None of the higher equalities of S 2 are propositional. 

Hence S 2 has no finite truncation level. 


HITs 

Truncations 

We can use HITs to define truncations, which is the adjoint to the 

embedding. 

E.g. given A : Type the -1-truncation ||A|| −1 : Type (also called 

bracket types, squash types) is given by 

Clearly, ||A|| −1 : Prop and 

for P : Prop. 

We can use this to define AC −1 : 

η : A → ||A|| −1 

uip : Π a,a ′ :||A|| −1 

a = a ′ 

A → P = ||A|| −1 → P 

(Πa : A.||Σb : B.R(a, b)|| −1 ) → (||Σf : A → B.Πa : A.R(a, f (a))|| −1 ) 

AC −1 implies excluded middle for Prop, i.e. P + ¬P for P : Prop 

(Diaconescu’s construction). 

We can generalize this to arbitrary levels ||A|| n is an n-type. 


Metatheory 

Canonicity 

We have introduced additional constants proving equalities: 

◮ functional extensionality 

◮ univalence 

◮ equality constructors for HITs 

While we have introduced some definitional equality, they are 

insufficient to guarantuee canonicity: 

All closed terms of type N are definitionally equal (indeed reducible) 

to a numeral. 

While we (with Conor McBride and Wouter Swierstra) have developed 

an approach to solve the problem for functional extensionality 

(Observational Type Theory), this relies on a strong form of UIP. 


Metatheory 

Constructive models 

The homotopy interpretation of type theory uses Kan Fibrations in 

simplicial sets (the simplicial set model). 

This construction relies essentially on classical principles. 

Thierry Coquand has suggested a modification of this construction 

using semi-simplicial sets. 

This models only weak Type Theory (i.e. no conversion under λ). 

An alternative would be to directly use weak ω-groupoids. 

It seems likely that an answer to this question would also provide a 

solution to the canonicity problem. 


Computer Science ? 

Why should we care? 

Structures can be 1st class citizens. 

(equality is isomorphism) 

HITs provide better ways to define the Cauchy Reals and the 

constructible hierarchy (avoiding choice). 

Quotient containers (like multisets) become ordinary containers. 


Computer Science ? 

The HoTT people

Homotopy Type Theory For Dummies

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?