work a bit on thesis

This commit is contained in:
Michael Zhang 2025-01-14 14:03:27 -06:00
parent 9bd7155777
commit afd32b8c67
13 changed files with 821 additions and 270 deletions

View file

@ -26,11 +26,11 @@ private
--
-- Similar to Cubical.Algebra.ChainComplex except it is indexed by a SuccStr
-- instead of , and uses Pointed types rather than groups.
record TypeChainComplex { ' : Level} (N : SuccStr ) : Type (-max (-suc ')) where
record TypeChainComplex ( : Level) {N : Level} (N : SuccStr N) : Type (-max N (-suc )) where
open SuccStr N
field
seq : (n : Index) Pointed '
fun : (n : Index) seq (succ n) seq n
chain : (n : Index) Pointed
boundary : (n : Index) chain (succ n) chain n
-- The primary chain complex property is that the composition of
-- consecutive maps is equivalent to the zero morphism, which in groups
@ -44,18 +44,18 @@ record TypeChainComplex { ' : Level} (N : SuccStr ) : Type (-max
-- that smaller part will map to the zero element in the next group. Thus,
-- d² ≡ 0
property : (n : Index)
let Tₙ₊₂ = seq (succ (succ n)) in let Tₙ₊₁ = seq (succ n) in let Tₙ = seq n in
let dₙ₊₁ = fun (succ n) in let dₙ = fun n in
let Tₙ₊₂ = chain (succ (succ n)) in let Tₙ₊₁ = chain (succ n) in let Tₙ = chain n in
let dₙ₊₁ = boundary (succ n) in let dₙ = boundary n in
dₙ ∘∙ dₙ₊₁ const∙ Tₙ₊₂ Tₙ
record TypeChainMap { A B : Level} {N : SuccStr }
(A : TypeChainComplex {} {A} N)
(B : TypeChainComplex {} {B} N)
: Type (-max (-max A B)) where
record TypeChainMap (A B : Level) {N : Level} {N : SuccStr N}
(A : TypeChainComplex A N)
(B : TypeChainComplex B N)
: Type (-max N (-max A B)) where
open SuccStr N
open TypeChainComplex
field
f : (n : Index) A .seq n B .seq n
f : (n : Index) A .chain n B .chain n
-- The boundary forms a commutative square
--
@ -64,7 +64,7 @@ record TypeChainMap { A B : Level} {N : SuccStr }
-- fₙ fₙ₋₁
-- ↓ ↓
-- Bₙ──dBₙ─→Bₙ₋₁
comm : (n : Index) B .fun n ∘∙ f (succ n) f n ∘∙ A .fun n
comm : (n : Index) B .boundary n ∘∙ f (succ n) f n ∘∙ A .boundary n
-- module _ {N : SuccStr } (CC : TypeChainComplex N) where
-- open SuccStr N

View file

@ -0,0 +1,78 @@
{-# OPTIONS --cubical #-}
module ThesisWork.ChainComplexGroup where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Algebra.AbGroup
open import Cubical.Algebra.Group.MorphismProperties
open import Cubical.Foundations.Function
open import Cubical.HITs.TypeQuotients
open import Cubical.Foundations.Structure
open import Cubical.Structures.Successor
open import ThesisWork.Exactness
private
variable
' '' : Level
-- In mathematics, a chain complex is an algebraic structure that consists of a
-- sequence of abelian groups (or modules) and a sequence of homomorphisms
-- between consecutive groups such that the image of each homomorphism is
-- contained in the kernel of the next.
--
-- "Type chain complexes" are chain complexes without the set requirement
-- a.k.a no set truncation
-- FVD Definition 4.1.2
--
-- Similar to Cubical.Algebra.ChainComplex except it is indexed by a SuccStr
-- instead of , and uses Pointed types rather than groups.
record TypeChainComplex ( : Level) {N : Level} (N : SuccStr N) : Type (-max N (-suc )) where
open SuccStr N
field
chain : (n : Index) AbGroup
boundary : (n : Index) AbGroupHom (chain (succ n)) (chain n)
-- The primary chain complex property is that the composition of
-- consecutive maps is equivalent to the zero morphism, which in groups
-- corresponds to the constant map to the zero element.
--
-- Relevant image: https://upload.wikimedia.org/wikipedia/commons/thumb/b/bc/Illustration_of_an_Exact_Sequence_of_Groups.svg/2880px-Illustration_of_an_Exact_Sequence_of_Groups.svg.png
-- ^Explanation: chain complex is only half of the property of an exact
-- sequence, so the crucial thing here is that the circle where the left
-- half of the cone meets the right is actually potentially smaller for the
-- left than the right side. (TODO: Draw this!) But this still means that
-- that smaller part will map to the zero element in the next group. Thus,
-- d² ≡ 0
property : (n : Index)
let dₙ₊₁ = boundary (succ n) in let dₙ = boundary n in
compGroupHom dₙ₊₁ dₙ trivGroupHom
record TypeChainMap (A B : Level) {N : Level} {N : SuccStr N}
(A : TypeChainComplex A N)
(B : TypeChainComplex B N)
: Type (-max N (-max A B)) where
open SuccStr N
open TypeChainComplex
field
f : (n : Index) AbGroupHom (A .chain n) (B .chain n)
-- The boundary forms a commutative square
--
-- Aₙ──dAₙ─→Aₙ₋₁
-- │ │
-- fₙ fₙ₋₁
-- ↓ ↓
-- Bₙ──dBₙ─→Bₙ₋₁
comm : (n : Index) compGroupHom (f (succ n)) (B .boundary n) compGroupHom (A .boundary n) (f n)
record TypeCoChainComplex ( : Level) {N : Level} (N : SuccStr N) : Type (-max N (-suc )) where
open SuccStr N
field
chain : (n : Index) AbGroup
boundary : (n : Index) AbGroupHom (chain n) (chain (succ n))
dₙdₙ₊₁≡0 : (n : Index)
let dₙ₊₁ = boundary (succ n) in let dₙ = boundary n in
compGroupHom dₙ dₙ₊₁ trivGroupHom

View file

@ -0,0 +1,58 @@
-- Definition of cohomology in terms of spectra
{-# OPTIONS --cubical #-}
module ThesisWork.CohomologySpectra where
open import Cubical.Foundations.Prelude
open import Cubical.Structures.Successor
open import Cubical.Data.Nat
open import Cubical.Algebra.Group
open import Cubical.Algebra.AbGroup
open import Cubical.Algebra.Group.MorphismProperties
open import Cubical.Algebra.Group.Morphisms
open import Cubical.Algebra.Group.QuotientGroup
open import Cubical.Algebra.Group.Subgroup
open import ThesisWork.ChainComplexGroup
private
variable
' '' : Level
{-
dₙ₊₁ dₙ
... <-- C*ₙ₊₂ <-- C*ₙ₊₁ <-- Cₙ <-- ...
-}
Cohomology : { N} {N : SuccStr N} (n : SuccStr.Index N) TypeCoChainComplex N Group
Cohomology { = } {N = N} n CC = ker[dₙ₊₁] / im[dₙ] where
-- TODO: Review how this works
-- Based on the homology version in Cubical.Algebra.ChainComplex.Homology
open SuccStr N
open TypeCoChainComplex CC
open AbGroupStr
open IsGroupHom
Cₙ = chain n
Cₙ₊₁ = chain (succ n)
Cₙ₊₂ = chain (succ (succ n))
dₙ = boundary n
dₙ₊₁ = boundary (succ n)
ker[dₙ₊₁] : Group
ker[dₙ₊₁] = kerGroup dₙ₊₁
Cₙ→Cₙ₊₁-ker : Cₙ .fst ker[dₙ₊₁] .fst
Cₙ→Cₙ₊₁-ker cₙ = dₙ .fst cₙ , p where
p : dₙ₊₁ .fst (dₙ .fst cₙ) Cₙ₊₂ .snd .0g
p = funExt⁻ (cong fst (dₙdₙ₊₁≡0 n)) cₙ
Cₙ→Cₙ₊₁-ker-Hom : GroupHom (AbGroup→Group Cₙ) ker[dₙ₊₁]
Cₙ→Cₙ₊₁-ker-Hom = Cₙ→Cₙ₊₁-ker , makeIsGroupHom (λ x y kerGroup≡ dₙ₊₁ (dₙ .snd .pres· x y))
im[dₙ] : NormalSubgroup ker[dₙ₊₁]
im[dₙ] = imSubgroup Cₙ→Cₙ₊₁-ker-Hom , isNormalIm Cₙ→Cₙ₊₁-ker-Hom (λ x y kerGroup≡ dₙ₊₁ (Cₙ₊₁ .snd .+Comm (x .fst) (y .fst)))
Cohomology : {} (n : ) TypeCoChainComplex + Group
Cohomology = Cohomology {N = +}

View file

@ -1,10 +0,0 @@
-- lean2/hott/homotopy/chain_complex.lean
{-# OPTIONS --cubical #-}
module ThesisWork.Pi3S2.ChainComplex where
open import Cubical.Foundations.Prelude
open import Agda.Primitive
data ChainComplex : Type where

View file

@ -1,99 +0,0 @@
{-# OPTIONS --cubical #-}
module ThesisWork.Pi3S2.LES where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Equiv
open import Data.Nat
open import Data.Fin
open import Data.Product
open import Cubical.Homotopy.Base
open import Cubical.Homotopy.Loopspace
open import Cubical.Homotopy.Group.Base
open import Cubical.Homotopy.Group.LES
open import Cubical.HITs.SetTruncation renaming (map to mapTrunc)
open import Cubical.HITs.SetTruncation.Fibers
private
variable
X Y : Type
LES-node : {l} {X Y : Pointed l} (f : X Y) × Fin 3 Type l
LES-node {Y = Y} f (n , zero) = π n Y
LES-node {X = X} f (n , suc zero) = π n X
LES-node {X = (X , x)} {Y = (Y , y)} (f , f-eq) (n , suc (suc zero)) =
let F = fiber f y in
π n (F , x , f-eq)
sucF : × Fin 3 × Fin 3
sucF (n , zero) = n , suc zero
sucF (n , suc zero) = n , suc (suc zero)
sucF (n , suc (suc zero)) = suc n , zero
LES-edge : {l} {X∙ Y∙ : Pointed l} (f∙ : X∙ Y∙) (n : × Fin 3)
LES-node f∙ (sucF n) LES-node f∙ n
LES-edge {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ @ (f , f-eq) (n , zero) = h n where
h1 : (n : ) (Ω^ n) X∙ (Ω^ n) Y∙
h1 zero = f∙
h1 (suc n) = (λ x refl) , helper where
helper : refl snd (Ω ((Ω^ n) Y∙))
helper i j = (Ω^ n) (Y , y) .snd
-- helper = λ i j →
-- let
-- top : (Ω^ n) (Y , y) .fst
-- top = {! refl !}
-- u = λ k → λ where
-- (i = i0) → {! !}
-- (i = i1) → {! !}
-- (j = i0) → {! !}
-- (j = i1) → {! !}
-- in hcomp u {! !}
h : (n : ) π n X∙ π n Y∙
h n = mapTrunc (fst (h1 n))
-- h zero a ∣₂ = f a ∣₂
-- h (suc n) a ∣₂ = let IH = h n a i0 ∣₂ in {! !} ∣₂
-- h zero (squash₂ a b p q i j) = squash₂ (h 0 a) (h 0 b) (cong (h 0) p) (cong (h 0) q) i j
-- h (suc n) (squash₂ a b p q i j) = {! !}
LES-edge {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ @ (f , f-eq) (n , suc zero) = h n where
F = fiber f y
h1 : (n : ) (Ω^ n) (F , x , f-eq) (Ω^ n) X∙
h1 zero = fst , refl
h1 (suc n) = (λ f i (Ω^ n) (X , x) .snd) , λ i j (Ω^ n) (X , x) .snd
h : (n : ) π n (F , x , f-eq) π n X∙
h n = mapTrunc (fst (h1 n))
LES-edge {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ @ (f , f-eq) (n , suc (suc zero)) = h n where
F = fiber f y
h1 : (n : ) (Ω^ (suc n)) Y∙ (Ω^ n) (F , x , f-eq)
h1 zero = (λ y x , f-eq) , refl
h1 (suc n) = (λ y i (Ω^ n) (F , x , f-eq) .snd) , λ i j (Ω^ n) (F , x , f-eq) .snd
h : (n : ) π (suc n) Y∙ π n (F , x , f-eq)
h n = mapTrunc (fst (h1 n))
-- LES-edge f n_ with mapN n_
-- LES-edge {X = X∙ @ (X , x)} {Y = Y∙ @ (Y , y)} f n_ | (n , zero) = {! h !} where
-- h : π n X∙ → π n Y∙
-- h x ∣₂ = {! !} ∣₂
-- h (squash₂ z z₁ p q i i₁) = {! !}
-- -- z : LES-node f (mapN (suc n_))
-- -- z : π n X
-- -- z : ∥ typ ((Ω^ 0) X) ∥₂
-- -- z : ∥ typ X ∥₂
-- -- z : ∥ typ X ∥₂
-- LES-edge f n_ | (n , suc zero) = λ z → {! !}
-- LES-edge f n_ | (n , suc (suc zero)) = λ z → {! !}
LES-is-exact : {l : Level} {X∙ Y∙ : Pointed l}
(f∙ : X∙ Y∙)
(n : × Fin 3)
{! !}
LES-is-exact f∙ (n , k) = {! !}

View file

@ -1,92 +0,0 @@
{-# OPTIONS --cubical #-}
module ThesisWork.Pi3S2.Lemma4-1-5 where
open import Cubical.Data.Sigma
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Equiv.Properties
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Prelude
open import Cubical.Homotopy.Loopspace
fiberF : {l : Level} {A∙ B∙ : Pointed l} (f : A∙ B∙) Pointed l
fiberF {A∙ = A∙ @ (A , a)} {B∙ = B∙ @ (B , b)} f = fiber (fst f) b , a , (snd f)
lemma : {l : Level} {A∙ @ (A , a) B∙ @ (B , b) : Pointed l}
(f : A∙ B∙)
let
p₁ : fiberF f A∙
p₁ = fst , refl
in fiberF p₁ ≃∙ (Ω B∙)
lemma {A∙ = A∙ @ (A , a0)} {B∙ = B∙ @ (B , b0)} f∙ @ (f , f-eq) = eqv , {! !} where
eqv : fst (fiberF ((λ r fst r) , refl)) fst (Ω B∙)
eqv =
fst (fiberF ((λ r fst r) , refl))
≃⟨ idEquiv (fst (fiberF (fst , refl)))
Σ (fst (fiberF f∙)) (λ fibf @ (a , p) a a0)
≃⟨ helper1
Σ A (λ a (a a0) × (f a b0))
≃⟨ helper2
f a0 b0
≃⟨ helper3
b0 b0
≃⟨ idEquiv (b0 b0)
fst (Ω B∙)
where
helper1 : Σ (fst (fiberF (f , f-eq))) (λ fibf fibf .fst a0) Σ A (λ a (a a0) × (f a b0))
helper1 = isoToEquiv (iso f' g' (λ _ refl) λ _ refl) where
f' : Σ (fst (fiberF (f , f-eq))) (λ fibf fibf .fst a0) Σ A (λ a (a a0) × (f a b0))
f' x @ ((x1 , x2) , x3) = x1 , x3 , x2
g' : Σ A (λ a (a a0) × (f a b0)) Σ (fst (fiberF (f , f-eq))) (λ fibf fibf .fst a0)
g' x @ (x1 , x2 , x3) = (x1 , x3) , x2
helper2 : Σ A (λ a (a a0) × (f a b0)) (f a0 b0)
helper2 = isoToEquiv (iso f' g' fg {! !}) where
f' : Σ A (λ a (a a0) × (f a b0)) f a0 b0
f' (x1 , x2 , x3) = cong f (sym x2) x3
g' : f a0 b0 Σ A (λ a (a a0) × (f a b0))
g' x = a0 , refl , x
fg : section f' g'
fg b =
f' (g' b) ≡⟨ refl
f' (a0 , refl , b) ≡⟨ refl
cong f (sym refl) b ≡⟨ refl
refl b ≡⟨ sym (lUnit b)
b
gf : retract f' g'
gf a @ (x1 , x2 , x3) =
g' (cong f (sym x2) x3) ≡⟨ refl
a0 , refl , (cong f (sym x2) x3) ≡⟨ cong (λ b {! !}) {! !}
a
helper3 : (f a0 b0) (b0 b0)
helper3 = isoToEquiv (iso f' g' fg gf) where
f' : f a0 b0 b0 b0
f' x = sym f-eq x
g' : b0 b0 f a0 b0
g' x = f-eq x
fg : section f' g'
fg b =
f' (g' b) ≡⟨ refl
f' (f-eq b) ≡⟨ refl
sym f-eq (f-eq b) ≡⟨ assoc (sym f-eq) f-eq b
(sym f-eq f-eq) b ≡⟨ cong (_∙ b) (lCancel f-eq)
refl b ≡⟨ sym (lUnit b)
b
gf : retract f' g'
gf a =
g' (f' a) ≡⟨ refl
g' (sym f-eq a) ≡⟨ refl
f-eq (sym f-eq a) ≡⟨ assoc f-eq (sym f-eq) a
(f-eq sym f-eq) a ≡⟨ cong (_∙ a) (rCancel f-eq)
refl a ≡⟨ sym (lUnit a)
a

View file

@ -1,44 +0,0 @@
{-# OPTIONS --cubical #-}
module ThesisWork.Pi3S2.Step1 where
open import Agda.Primitive
open import Cubical.Data.Sigma
open import Cubical.Data.Nat
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.Properties
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Prelude
open import Cubical.Homotopy.Loopspace
-- open import ThesisWork.Pi3S2.Lemma4-1-5 renaming (lemma to lemma4-1-5)
fiberF : {l : Level} {X∙ Y∙ : Pointed l} (f : X∙ Y∙) Pointed l
fiberF {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ @ (f , f-eq) =
fiber f y , x , f-eq
-- fiber f y , x , f-eq
arrow∙ : {l : Level} Type (lsuc l)
arrow∙ {l} = Σ (Pointed l) (λ X Σ (Pointed l) (λ Y X Y))
F : {l : Level} arrow∙ {l} arrow∙ {l}
F (X∙ @ (X , x) , Y∙ @ (Y , y) , f∙ @ (f , f-eq)) = fiberF f∙ , X∙ , fst , refl
F⁻ : {l : Level} (n : ) arrow∙ {l} arrow∙ {l}
F⁻ zero x = x
F⁻ (suc n) x = F (F⁻ n x)
-- Given a pointed map f∙ : X∙ →∙ Y∙, we define its fiber sequence
-- A : → Type by Aₙ :≡ p₂(Fⁿ(X , y , f))
A : {l : Level} {X∙ Y∙ : Pointed l} (f∙ : X∙ Y∙) Pointed l
A {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ @ (f , f-eq) n =
let it = F⁻ n (X∙ , Y∙ , f∙) in
fst (snd it)
f⁻ : {l : Level} {X∙ Y∙ : Pointed l} (f∙ : X∙ Y∙) (n : ) fst (A f∙ (suc n)) fst (A f∙ n)
f⁻ {X∙ = X∙ @ (X , x)} {Y∙ = Y∙ @ (Y , y)} f∙ n a =
let it = F⁻ n (X∙ , Y∙ , f∙) in
{! snd (snd it) !}

View file

@ -4,15 +4,20 @@ module ThesisWork.SpectralSequence where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Structure
open import Cubical.Foundations.Isomorphism
open import Cubical.Algebra.Ring
open import Cubical.Algebra.Group
open import Cubical.Algebra.Group.Morphisms
open import Cubical.Algebra.Group.DirProd
open import Cubical.Algebra.Group.Instances.Int
open import Cubical.Data.Nat using ()
open import Cubical.Data.Int using ()
open import Cubical.Data.Sigma
open import Cubical.Structures.Successor
open import ThesisWork.Graded
open import ThesisWork.CohomologySpectra
open import ThesisWork.ChainComplexGroup
private
variable
@ -26,19 +31,27 @@ module _ (R : Ring ) where
_-[gm]→_ : (M₁ M₂ : GradedModule R ×) Type (-max (-suc -zero))
_-[gm]→_ M₁ M₂ = GradedHom R ×Group M₁ M₂
-- Spectral sequence (definition 5.1.3 in FVD thesis)
-- Seems to be https://git.mzhang.io/michael/Spectral/src/commit/2913de520d4fb2c8177a8cbb7e64938291248d03/algebra/spectral_sequence.hlean#L14-L27
record SpectralSequence : Type (-suc ) where
field
-- A sequence Eᵣ of abelian groups graded over Z × Z for r ≥ 2.
-- Eᵣ is called the r-page of the spectral sequence
--
-- NOTE: Because starts at zero, I use s = r - 2.
E : (s : ) GradedModule R ( × )
open TypeCoChainComplex
-- differentials, are graded morphisms dᵣ : Eᵣ → Eᵣ such that dᵣ ◦ dᵣ = 0
d : (s : ) E s -[gm]→ E s
dᵣ∘dᵣ≡0 : (s : ) compGradedModuleHom (d s) (d s) idGradedModuleHom (E s)
ssCoChainComplex : TypeCoChainComplex +
ssCoChainComplex .chain n = {! !}
ssCoChainComplex .boundary = {! !}
ssCoChainComplex .dₙdₙ₊₁≡0 = {! !}
-- Isomorphisms
-- the cohomology of the cochain complex determined by dᵣ.
-- -- Spectral sequence (definition 5.1.3 in FVD thesis)
-- -- Seems to be https://git.mzhang.io/michael/Spectral/src/commit/2913de520d4fb2c8177a8cbb7e64938291248d03/algebra/spectral_sequence.hlean#L14-L27
-- record SpectralSequence : Type (-suc ) where
-- field
-- -- A sequence Eᵣ of abelian groups graded over Z × Z for r ≥ 2.
-- -- Eᵣ is called the r-page of the spectral sequence
-- --
-- -- NOTE: Because starts at zero, I use s = r - 2.
-- E : (s : ) → GradedModule R ( × )
-- -- differentials, are graded morphisms dᵣ : Eᵣ → Eᵣ such that dᵣ ◦ dᵣ = 0
-- d : (s : ) → E s -[gm]→ E s
-- dᵣ∘dᵣ≡0 : (s : ) → compGradedModuleHom (d s) (d s) ≡ idGradedModuleHom (E s)
-- -- Isomorphisms
-- -- the cohomology of the cochain complex determined by dᵣ.
-- α : (p q : ) (r : ) → GroupIso (Cohomology ? {! !}) {! !}

3
thesis/.gitignore vendored
View file

@ -1 +1,4 @@
_build
main.aux
main.log
*.pdf

323
thesis/main.bib Normal file
View file

@ -0,0 +1,323 @@
@incollection{hatcher_spectral_2004,
title = {Spectral Sequences},
url = {https://pi.math.cornell.edu/~hatcher/AT/SSpage.html},
booktitle = {Algebraic Topology},
author = {Hatcher, Allen},
urldate = {2024-09-25},
date = {2004},
file = {ATch5.pdf:/Users/michael/Zotero/storage/EGAC34WS/ATch5.pdf:application/pdf},
}
@book{hatcher_algebraic_2001,
title = {Algebraic Topology},
url = {https://pi.math.cornell.edu/~hatcher/AT/ATpage.html},
author = {Hatcher, Allen},
urldate = {2024-09-25},
date = {2001},
file = {AT+.pdf:/Users/michael/Zotero/storage/89RKS7DH/AT+.pdf:application/pdf},
}
@misc{van_doorn_formalization_2018,
title = {On the Formalization of Higher Inductive Types and Synthetic Homotopy Theory},
url = {http://arxiv.org/abs/1808.10690},
doi = {10.48550/arXiv.1808.10690},
abstract = {The goal of this dissertation is to present synthetic homotopy theory in the setting of homotopy type theory. We will present various results in this framework, most notably the construction of the Atiyah-Hirzebruch and Serre spectral sequences for cohomology, which have been fully formalized in the Lean proof assistant.},
number = {{arXiv}:1808.10690},
publisher = {{arXiv}},
author = {van Doorn, Floris},
urldate = {2024-09-25},
date = {2018-08-31},
eprinttype = {arxiv},
eprint = {1808.10690 [cs, math]},
keywords = {55T05 (Primary) 55T10, 55T25, 55P20, 03B15, 55U35 (Secondary), Computer Science - Logic in Computer Science, F.4.1, Mathematics - Algebraic Topology, Mathematics - Logic},
file = {arXiv Fulltext PDF:/Users/michael/Zotero/storage/3NZN52L9/van Doorn - 2018 - On the Formalization of Higher Inductive Types and.pdf:application/pdf;arXiv.org Snapshot:/Users/michael/Zotero/storage/G3XTTNC6/1808.html:text/html},
}
@misc{cohen_cubical_2016,
title = {Cubical Type Theory: a constructive interpretation of the univalence axiom},
url = {http://arxiv.org/abs/1611.02108},
doi = {10.48550/arXiv.1611.02108},
shorttitle = {Cubical Type Theory},
abstract = {This paper presents a type theory in which it is possible to directly manipulate \$n\$-dimensional cubes (points, lines, squares, cubes, etc.) based on an interpretation of dependent type theory in a cubical set model. This enables new ways to reason about identity types, for instance, function extensionality is directly provable in the system. Further, Voevodsky's univalence axiom is provable in this system. We also explain an extension with some higher inductive types like the circle and propositional truncation. Finally we provide semantics for this cubical type theory in a constructive meta-theory.},
number = {{arXiv}:1611.02108},
publisher = {{arXiv}},
author = {Cohen, Cyril and Coquand, Thierry and Huber, Simon and Mörtberg, Anders},
urldate = {2024-09-25},
date = {2016-11-07},
eprinttype = {arxiv},
eprint = {1611.02108 [cs, math]},
keywords = {Computer Science - Logic in Computer Science, F.4.1, Mathematics - Logic, F.3.2},
file = {arXiv Fulltext PDF:/Users/michael/Zotero/storage/PIFTAIIS/Cohen et al. - 2016 - Cubical Type Theory a constructive interpretation.pdf:application/pdf;arXiv.org Snapshot:/Users/michael/Zotero/storage/6JNE6NJS/1611.html:text/html},
}
@online{noauthor_cubical_nodate,
title = {Cubical — Agda 2.8.0 documentation},
url = {https://agda.readthedocs.io/en/latest/language/cubical.html},
urldate = {2024-09-25},
file = {Cubical — Agda 2.8.0 documentation:/Users/michael/Zotero/storage/R7TGJ3L9/cubical.html:text/html},
}
@article{vezzosi_cubical_2021,
title = {Cubical Agda: A dependently typed programming language with univalence and higher inductive types},
volume = {31},
issn = {0956-7968, 1469-7653},
url = {https://www.cambridge.org/core/product/identifier/S0956796821000034/type/journal_article},
doi = {10.1017/S0956796821000034},
shorttitle = {Cubical Agda},
abstract = {Abstract
Proof assistants based on dependent type theory provide expressive languages for both programming and proving within the same system. However, all of the major implementations lack powerful extensionality principles for reasoning about equality, such as function and propositional extensionality. These principles are typically added axiomatically which disrupts the constructive properties of these systems. Cubical type theory provides a solution by giving computational meaning to Homotopy Type Theory and Univalent Foundations, in particular to the univalence axiom and higher inductive types ({HITs}). This paper describes an extension of the dependently typed functional programming language Agda with cubical primitives, making it into a full-blown proof assistant with native support for univalence and a general schema of {HITs}. These new primitives allow the direct definition of function and propositional extensionality as well as quotient types, all with computational content. Additionally, thanks also to copatterns, bisimilarity is equivalent to equality for coinductive types. The adoption of cubical type theory extends Agda with support for a wide range of extensionality principles, without sacrificing type checking and constructivity.},
pages = {e8},
journaltitle = {Journal of Functional Programming},
shortjournal = {J. Funct. Prog.},
author = {Vezzosi, Andrea and Mörtberg, Anders and Abel, Andreas},
urldate = {2024-09-25},
date = {2021},
langid = {english},
file = {Full Text:/Users/michael/Zotero/storage/7MTLCPWG/Vezzosi et al. - 2021 - Cubical Agda A dependently typed programming lang.pdf:application/pdf},
}
@book{the_univalent_foundations_program_homotopy_2013,
title = {Homotopy Type Theory: Univalent Foundations of Mathematics},
url = {https://homotopytypetheory.org/book},
author = {{The \{Univalent Foundations Program\}}},
date = {2013},
}
@video{hottest_floris_2018,
title = {Floris van Doorn, Towards spectral sequences for homology},
url = {https://www.youtube.com/watch?v=Q3zaqeKhUKg},
abstract = {Homotopy Type Theory Electronic Seminar Talks, 2018-11-22
Spectral sequences form a powerful tool which can be used to compute homotopy, homology and cohomology groups of a wide variety of spaces. We have constructed two important spectral sequences in homotopy type theory, the Atiyah-Hirzebruch and Serre spectral sequences for cohomology. These spectral sequences have analogues for homology, but they have not been constructed in {HoTT} yet. However, many parts of our construction could be reused to construct the corresponding spectral sequences for homology.
In this talk I will introduce spectral sequences and review the spectral sequences we have constructed and some of their applications. Furthermore, I will describe what parts are still missing to construct the Atiyah-Hirzebruch and Serre spectral sequences for homology.
The construction of the spectral sequences for cohomology is joint work with Jeremy Avigad, Steve Awodey, Ulrik Buchholtz, Egbert Rijke and Mike Shulman.},
author = {{HoTTEST}},
urldate = {2024-10-03},
date = {2018-11-23},
}
@article{lyons_elementary_nodate,
title = {An Elementary Introduction to the Hopf Fibration},
author = {Lyons, David W},
langid = {english},
file = {PDF:/Users/michael/Zotero/storage/MKUPPFCK/Lyons - An Elementary Introduction to the Hopf Fibration.pdf:application/pdf},
}
@misc{buchholtz_cayley-dickson_2016,
title = {The Cayley-Dickson Construction in Homotopy Type Theory},
url = {http://arxiv.org/abs/1610.01134},
abstract = {We define in the setting of homotopy type theory an H-space structure on \${\textbackslash}mathbb S{\textasciicircum}3\$. Hence we obtain a description of the quaternionic Hopf fibration \${\textbackslash}mathbb S{\textasciicircum}3{\textbackslash}hookrightarrow{\textbackslash}mathbb S{\textasciicircum}7{\textbackslash}twoheadrightarrow{\textbackslash}mathbb S{\textasciicircum}4\$, using only homotopy invariant tools.},
number = {{arXiv}:1610.01134},
publisher = {{arXiv}},
author = {Buchholtz, Ulrik and Rijke, Egbert},
urldate = {2024-10-17},
date = {2016-10-04},
eprinttype = {arxiv},
eprint = {1610.01134},
keywords = {Computer Science - Logic in Computer Science, Mathematics - Algebraic Topology, Mathematics - Logic, Mathematics - Category Theory},
file = {Preprint PDF:/Users/michael/Zotero/storage/Y39DL75F/Buchholtz and Rijke - 2016 - The Cayley-Dickson Construction in Homotopy Type T.pdf:application/pdf;Snapshot:/Users/michael/Zotero/storage/Q9HVDU7R/1610.html:text/html},
}
@online{kovacs_answer_2023,
title = {Answer to "What are the complex induction patterns supported by Agda?"},
url = {https://proofassistants.stackexchange.com/a/2002},
shorttitle = {Answer to "What are the complex induction patterns supported by Agda?},
titleaddon = {Proof Assistants Stack Exchange},
author = {Kovács, András},
urldate = {2024-10-16},
date = {2023-02-20},
file = {Snapshot:/Users/michael/Zotero/storage/RC9J6FMA/what-are-the-complex-induction-patterns-supported-by-agda.html:text/html},
}
@online{wood_answer_2024,
title = {Answer to "What are the principal differences between Agda's core type theory and Coq's?"},
url = {https://proofassistants.stackexchange.com/a/2740},
shorttitle = {Answer to "What are the principal differences between Agda's core type theory and Coq's?},
titleaddon = {Proof Assistants Stack Exchange},
author = {Wood, James},
urldate = {2024-10-16},
date = {2024-02-14},
file = {Snapshot:/Users/michael/Zotero/storage/FXDZCGPH/what-are-the-principal-differences-between-agdas-core-type-theory-and-coqs.html:text/html},
}
@online{noauthor_calculus_nodate,
title = {Calculus of Inductive Constructions — Coq 8.9.1 documentation},
url = {https://coq.inria.fr/doc/v8.9/refman/language/cic.html},
urldate = {2024-10-16},
file = {Calculus of Inductive Constructions — Coq 8.9.1 documentation:/Users/michael/Zotero/storage/C6LMRM5W/cic.html:text/html},
}
@incollection{goos_polymorphism_1984,
location = {Berlin, Heidelberg},
title = {Polymorphism is not set-theoretic},
volume = {173},
isbn = {978-3-540-13346-9 978-3-540-38891-3},
url = {http://link.springer.com/10.1007/3-540-13346-1_7},
pages = {145--156},
booktitle = {Semantics of Data Types},
publisher = {Springer Berlin Heidelberg},
author = {Reynolds, John C.},
editor = {Kahn, Gilles and {MacQueen}, David B. and Plotkin, Gordon},
editorb = {Goos, G. and Hartmanis, J. and Barstow, D. and Brauer, W. and Brinch Hansen, P. and Gries, D. and Luckham, D. and Moler, C. and Pnueli, A. and Seegmüller, G. and Stoer, J. and Wirth, N.},
editorbtype = {redactor},
urldate = {2024-10-16},
date = {1984},
doi = {10.1007/3-540-13346-1_7},
note = {Series Title: Lecture Notes in Computer Science},
file = {Reynolds - 1984 - Polymorphism is not set-theoretic.pdf:/Users/michael/Zotero/storage/72S4JJZM/Reynolds - 1984 - Polymorphism is not set-theoretic.pdf:application/pdf},
}
@article{chow_you_2006,
title = {You Could Have Invented Spectral Sequences},
volume = {53},
number = {1},
author = {Chow, Timothy Y},
date = {2006},
langid = {english},
file = {Chow - 2006 - You Could Have Invented Spectral Sequences.pdf:/Users/michael/Zotero/storage/89SGKENP/Chow - 2006 - You Could Have Invented Spectral Sequences.pdf:application/pdf},
}
@article{strong_introduction_nodate,
title = {Introduction to Spectral Sequences},
author = {Strong, Kimball},
langid = {english},
file = {Strong - Introduction to Spectral Sequences.pdf:/Users/michael/Zotero/storage/VPL9V4UW/Strong - Introduction to Spectral Sequences.pdf:application/pdf},
}
@online{noauthor_penrose_nodate,
title = {Penrose},
url = {https://penrose.cs.cmu.edu/},
urldate = {2024-11-05},
file = {Penrose:/Users/michael/Zotero/storage/67ZBXZU7/penrose.cs.cmu.edu.html:text/html},
}
@article{buchsbaum_exact_nodate,
title = {{EXACT} {CATEGORIES} {AND} {DUALITY}},
author = {Buchsbaum, D A},
langid = {english},
file = {PDF:/Users/michael/Zotero/storage/BIADJWY4/Buchsbaum - EXACT CATEGORIES AND DUALITY.pdf:application/pdf},
}
@inproceedings{licata_eilenberg-maclane_2014,
location = {Vienna Austria},
title = {Eilenberg-{MacLane} spaces in homotopy type theory},
isbn = {978-1-4503-2886-9},
url = {https://dl.acm.org/doi/10.1145/2603088.2603153},
doi = {10.1145/2603088.2603153},
abstract = {Homotopy type theory is an extension of Martin-Löf type theory with principles inspired by category theory and homotopy theory. With these extensions, type theory can be used to construct proofs of homotopy-theoretic theorems, in a way that is very amenable to computer-checked proofs in proof assistants such as Coq and Agda. In this paper, we give a computer-checked construction of Eilenberg-{MacLane} spaces. For an abelian group G, an {EilenbergMacLane} space K(G, n) is a space (type) whose nth homotopy group is G, and whose homotopy groups are trivial otherwise. These spaces are a basic tool in algebraic topology; for example, they can be used to build spaces with specified homotopy groups, and to define the notion of cohomology with coefficients in G. Their construction in type theory is an illustrative example, which ties together many of the constructions and methods that have been used in homotopy type theory so far.},
eventtitle = {{CSL}-{LICS} '14: {JOINT} {MEETING} {OF} the Twenty-Third {EACSL} Annual Conference on {COMPUTER} {SCIENCE} {LOGIC}},
pages = {1--9},
booktitle = {Proceedings of the Joint Meeting of the Twenty-Third {EACSL} Annual Conference on Computer Science Logic ({CSL}) and the Twenty-Ninth Annual {ACM}/{IEEE} Symposium on Logic in Computer Science ({LICS})},
publisher = {{ACM}},
author = {Licata, Daniel R. and Finster, Eric},
urldate = {2024-11-20},
date = {2014-07-14},
langid = {english},
file = {PDF:/Users/michael/Zotero/storage/W3YYYBQW/Licata and Finster - 2014 - Eilenberg-MacLane spaces in homotopy type theory.pdf:application/pdf},
}
@software{licata_dlicata335hott-agda_2024,
title = {dlicata335/hott-agda},
url = {https://github.com/dlicata335/hott-agda},
author = {Licata, Dan},
urldate = {2024-11-20},
date = {2024-07-08},
note = {original-date: 2012-02-29T23:25:09Z},
}
@online{noauthor_spectral_nodate,
title = {spectral sequences in homotopy type theory in {nLab}},
url = {https://ncatlab.org/nlab/show/spectral+sequences+in+homotopy+type+theory},
urldate = {2024-11-26},
file = {spectral sequences in homotopy type theory in nLab:/Users/michael/Zotero/storage/EDEHNJYF/spectral+sequences+in+homotopy+type+theory.html:text/html},
}
@article{yang_homotopy_nodate,
title = {Homotopy Groups of Spheres in Homotopy Type Theory},
author = {Yang, Jinghui},
langid = {english},
file = {PDF:/Users/michael/Zotero/storage/TWWEY6E9/Yang - Homotopy Groups of Spheres in Homotopy Type Theory.pdf:application/pdf},
}
@misc{ljungstrom_computational_2024,
title = {Computational Synthetic Cohomology Theory in Homotopy Type Theory},
url = {http://arxiv.org/abs/2401.16336},
doi = {10.48550/arXiv.2401.16336},
abstract = {This paper discusses the development of synthetic cohomology in Homotopy Type Theory ({HoTT}), as well as its computer formalisation. The objectives of this paper are (1) to generalise previous work on integral cohomology in {HoTT} by the current authors and Brunerie (2022) to cohomology with arbitrary coefficients and (2) to provide the mathematical details of, as well as extend, results underpinning the computer formalisation of cohomology rings by the current authors and Lamiaux (2023). With respect to objective (1), we provide new direct definitions of the cohomology group operations and of the cup product, which, just as in (Brunerie et al., 2022), enable significant simplifications of many earlier proofs in synthetic cohomology theory. In particular, the new definition of the cup product allows us to give the first complete formalisation of the axioms needed to turn the cohomology groups into a graded commutative ring. We also establish that this cohomology theory satisfies the {HoTT} formulation of the Eilenberg-Steenrod axioms for cohomology and study the classical Mayer-Vietoris and Gysin sequences. With respect to objective (2), we characterise the cohomology groups and rings of various spaces, including the spheres, torus, Klein bottle, real/complex projective planes, and infinite real projective space. All results have been formalised in Cubical Agda and we obtain multiple new numbers, similar to the famous `Brunerie number', which can be used as benchmarks for computational implementations of {HoTT}. Some of these numbers are infeasible to compute in Cubical Agda and hence provide new computational challenges and open problems which are much easier to define than the original Brunerie number.},
number = {{arXiv}:2401.16336},
publisher = {{arXiv}},
author = {Ljungström, Axel and Mörtberg, Anders},
urldate = {2025-01-08},
date = {2024-03-25},
eprinttype = {arxiv},
eprint = {2401.16336 [math]},
keywords = {Computer Science - Logic in Computer Science, Mathematics - Algebraic Topology},
file = {Preprint PDF:/Users/michael/Zotero/storage/ITW5YQ7P/Ljungström and Mörtberg - 2024 - Computational Synthetic Cohomology Theory in Homotopy Type Theory.pdf:application/pdf;Snapshot:/Users/michael/Zotero/storage/QX3LMQPF/2401.html:text/html},
}
@misc{ljungstrom_formalising_2024,
title = {Formalising and Computing the Fourth Homotopy Group of the \$3\$-Sphere in Cubical Agda},
url = {http://arxiv.org/abs/2302.00151},
doi = {10.48550/arXiv.2302.00151},
abstract = {Brunerie's 2016 {PhD} thesis contains the first synthetic proof in Homotopy Type Theory ({HoTT}) of the classical result that the fourth homotopy group of the 3-sphere is \${\textbackslash}mathbb\{Z\}/2{\textbackslash}mathbb\{Z\}\$. The proof is one of the most impressive pieces of synthetic homotopy theory to date and uses a lot of advanced classical algebraic topology rephrased synthetically. Furthermore, the proof is fully constructive and the main result can be reduced to the question of whether a particular "Brunerie number" \${\textbackslash}beta\$ can be normalised to \${\textbackslash}pm 2\$. The question of whether Brunerie's proof could be formalised in a proof assistant, either by computing this number or by formalising the pen-and-paper proof, has since remained open. In this paper, we present a complete formalisation in Cubical Agda. We do this by modifying Brunerie's proof so that a key technical result, whose proof Brunerie only sketched in his thesis, can be avoided. We also present a formalisation of a new and much simpler proof that \${\textbackslash}beta\$ is \${\textbackslash}pm 2\$. This formalisation provides us with a sequence of simpler Brunerie numbers, one of which normalises very quickly to \$-2\$ in Cubical Agda, resulting in a fully formalised computer-assisted proof that \${\textbackslash}pi\_4({\textbackslash}mathbb\{S\}{\textasciicircum}3) {\textbackslash}cong {\textbackslash}mathbb\{Z\}/2{\textbackslash}mathbb\{Z\}\$.},
number = {{arXiv}:2302.00151},
publisher = {{arXiv}},
author = {Ljungström, Axel and Mörtberg, Anders},
urldate = {2025-01-08},
date = {2024-04-30},
eprinttype = {arxiv},
eprint = {2302.00151 [math]},
keywords = {Computer Science - Logic in Computer Science, Mathematics - Algebraic Topology},
file = {Preprint PDF:/Users/michael/Zotero/storage/VGLRRI2M/Ljungström and Mörtberg - 2024 - Formalising and Computing the Fourth Homotopy Group of the \$3\$-Sphere in Cubical Agda.pdf:application/pdf;Snapshot:/Users/michael/Zotero/storage/4ECF3ZJD/2302.html:text/html},
}
@inproceedings{ljungstrom_formalizing_2023,
title = {Formalizing π4(S3) ≅Z/2Z and Computing a Brunerie Number in Cubical Agda},
url = {https://ieeexplore.ieee.org/document/10175833/?arnumber=10175833},
doi = {10.1109/LICS56636.2023.10175833},
abstract = {Bruneries 2016 {PhD} thesis contains the first synthetic proof in Homotopy Type Theory ({HoTT}) of the classical result that the fourth homotopy group of the 3-sphere is /2. The proof is one of the most impressive pieces of synthetic homotopy theory to date and uses a lot of advanced classical algebraic topology rephrased synthetically. Furthermore, the proof is fully constructive and the main result can be reduced to the question of whether a particular "Brunerie number" β can be normalized to ±2. The question of whether Bruneries proof could be formalized in a proof assistant, either by computing this number or by formalizing the pen-and-paper proof, has since remained open. In this paper, we present a complete formalization in Cubical Agda. We do this by modifying Bruneries proof so that a key technical result, whose proof Brunerie only sketched in his thesis, can be avoided. We also present a formalization of a new and much simpler proof that β is ±2. This formalization provides us with a sequence of simpler Brunerie numbers, one of which normalizes very quickly to 2 in Cubical Agda, resulting in a fully formalized computer-assisted proof that {\textbackslash}pi \_4({\textbackslash}{mathbbS}{\textasciicircum}3) {\textbackslash}cong {\textbackslash}{mathbbZ}/2{\textbackslash}{mathbbZ}.},
eventtitle = {2023 38th Annual {ACM}/{IEEE} Symposium on Logic in Computer Science ({LICS})},
pages = {1--13},
booktitle = {2023 38th Annual {ACM}/{IEEE} Symposium on Logic in Computer Science ({LICS})},
author = {Ljungström, Axel and Mörtberg, Anders},
urldate = {2025-01-09},
date = {2023-06},
keywords = {Algebra, Codes, Computer science, Libraries, Machinery, Stress, Topology},
file = {Full Text PDF:/Users/michael/Zotero/storage/VU3UKR5E/Ljungström and Mörtberg - 2023 - Formalizing π4(S3) ≅Z2Z and Computing a Brunerie Number in Cubical Agda.pdf:application/pdf;IEEE Xplore Abstract Record:/Users/michael/Zotero/storage/TE6RX488/10175833.html:text/html},
}
@software{the_agda_community_cubical_2024,
title = {Cubical Agda Library},
url = {https://github.com/agda/cubical},
abstract = {An experimental library for Cubical Agda},
version = {0.7},
author = {{The Agda Community}},
urldate = {2025-01-09},
date = {2024-02},
note = {original-date: 2018-10-15T09:28:28Z},
}
@software{agda_developers_agda_2025,
title = {Agda},
url = {https://agda.readthedocs.io/},
abstract = {Agda is a dependently typed programming language / interactive theorem prover.},
version = {2.8.0},
author = {{Agda Developers}},
urldate = {2025-01-14},
date = {2025-01-13},
note = {original-date: 2015-08-08T17:51:48Z},
}
@incollection{martin-lof_intuitionistic_1975,
title = {An Intuitionistic Theory of Types: Predicative Part},
shorttitle = {An Intuitionistic Theory of Types},
booktitle = {? Iterose1975},
publisher = {North Holland},
author = {Martin-Löf, Per},
editor = {Martin-Löf, Per},
date = {1975},
file = {An-Intuitionistic-Theory-of-Types-1972.pdf:/Users/michael/Zotero/storage/ICVD458G/An-Intuitionistic-Theory-of-Types-1972.pdf:application/pdf;Snapshot:/Users/michael/Zotero/storage/JLETE5WU/MARAIT-27.html:text/html},
}

230
thesis/main.typ Normal file
View file

@ -0,0 +1,230 @@
#import "./style.typ": *
#import "@preview/prooftrees:0.1.0": *
#import "@preview/cetz:0.3.1" as cetz: canvas, draw
#show: doc => template(
title: "THESISge",
doc,
)
= Introduction
This work extends Floris van Doorn's PhD dissertation @van_doorn_formalization_2018.
In that work, the mechanization of the proof was done in Lean 2's HoTT mode.
This mode has been removed from Lean's later versions, and as of the time of writing, Lean has no support for doing full homotopy type theory.
== Computer formalization
One of the benefits of using a computationally-friendly system of proof is that we can use computer programs to verify the correctness of our proofs.
== Cubical Agda
The results in this paper have been formalized using Cubical Agda @vezzosi_cubical_2021, an extension to the Agda proof assistant that implements cubical type theory.
= Martin-Löf type theory
Martin-Löf type theory @martin-lof_intuitionistic_1975
== Types as propositions
=== Definitional vs. propositional equality <defVsProp>
Because of the computational nature of the theory, we distinguish these equalities:
- $a$ and $b$ are *definitionally* (or judgmentally) equal, denoted $defEq(a, b)$, if they reduce to exactly the same term through reduction rules
- $a$ and $b$ are *propositionally* equal, denoted $propEq(a, b)$, if there exists any term in the #link(<identityType>)[identity type] $propEq(a, b)$ (will be introduced in a later section).
== Basic types
=== Unit type ($unitType$) <unitType>
The unit type $unitType$ is the type with only a single inhabitant, $isTyp(tt, unitType)$.
=== Boolean type ($boolType$)
Similar to the unit type, the boolean type $boolType$ is the
=== Empty type ($emptyType$)
The empty type $emptyType$ is the type with no inhabitants.
Logically, this corresponds to falsehood.
A function $arro(A, emptyType)$ represents a proof of the negation of $A$, since as a consequence $A$ implies false.
The empty type eliminator is hence the principle of #link("https://en.wikipedia.org/wiki/Principle_of_explosion")[_ex falso quodlibet_]:
$ isTyp(ind_emptyType, #[$forall (isTyp(A, typ)), arro(emptyType, A)$]) $
== Functions ($Pi$)
== Pairs ($Sigma$)
== Identity type ($propEqSym$) <identityType>
= Homotopy type theory
== Equivalences
== Univalence axiom <univalence>
One of the key observations of homotopy type theory is that the equivalence type $eqv(A, B)$ internally reflects an underlying equality between $A$ and $B$.
The *univalence axiom* realizes this idea by giving a way to "upgrade" our equivalence into a propositional equality:
#axiom("Univalence")[
$ isTyp(ua, arro((eqv(A, B)), (propEq(A, B)))) $
] <univalenceAxiom>
#axiom("Univalence equivalence")[
$ isTyp(uaEqv, isEquiv(ua)) $
] <univalenceEqvAxiom>
This property is not expressible with book HoTT.
== Pointed types
== Higher inductive types
=== Circle ($S1$) <circle>
The circle is a simple yet rich space that demonstrates a lot of interesting properties.
Analytically, the circle could be defined as the set of points $isTyp((x, y), RR times RR)$ such that:
$ x^2 + y^2 = 1 $
#align(center, canvas({
import draw: *
grid((-3, -3), (3, 3), stroke: luma(90%))
circle((0, 0), radius: 2)
}))
In synthetic homotopy theory, we distill the circle to its only distinguishing property: that it cannot be contracted into a point, due to the hole in the middle.
We call this type $S1$, where the 1 indicates that it is a 1-dimensional sphere.
For some arbitrary choice of base point, denoted $isTyp(base, S1)$, we can imagine the circle as a path going from the base to itself.
We call this path $isTyp(loop, propEq(base, base))$.
#align(center, canvas({
import draw: *
circle((0, 2), radius: 2)
content((0, 4.5), $loop$)
circle((0, 0), radius: 0.05, stroke: (paint: red, thickness: 3pt))
content((0, 0.5), text($base$, stroke: red))
}))
=== Suspensions ($Sigma$)
== Homotopy levels <hlevels>
#footnote[
Homotopy levels are also known under a different name, homotopy $n$-types.
Although the name is the same, the numbers are offset by 2, such that sets are $0$-types, mere props are $(-1)$-types, and contractible types are $(-2)$-types.
This may introduce a lot of confusion, so for the purposes of this paper I will stick to homotopy levels since it makes more sense to begin induction on homotopy levels from 0.
]
= Cubical type theory <cubicaltt>
Cubical type theory @cohen_cubical_2016
== Cubical interval
== $sans(#[hcomp])$ and $sans(#[hfill])$
== $sans(#[Glue])$ and $sans(#[glue])$
= Algebra
== Groups
#definition("Group")[
A group ($G$, $dot$) is a type ($G$) equipped with a binary operation ($dot$) that satisfies a few axioms.
- Associativity: for any #isTyp($a, b, c$, $G$),
- Identity: #TODO[identity]
- Inverse: #TODO[inverse]
] <group>
The mechanized definition of this can be found in #agdaCubicalLink("Cubical.Algebra.Group.Base").
#definition("Abelian group")[] <abelianGroup>
== Images and kernels
For any function $isTyp(f, arro(A, B))$, we can define the image of $f$, denoted $imOf(f)$ to be all of the elements in $B$ such that are mapped to from $A$. This differs from the _codomain_ of $f$, which is the entire set $B$ including points that cannot be mapped to.
#definition("Image")[
For types $A$ and $B$, and a function $isTyp(f, arro(A, B))$, define:
$ defEq(imOf(f), sum_(isTyp(b, B)) (sum_(isTyp(a, A)) propEq(f(a), b))) $
#TODO[This needs to be mere existence, but I need to figure out how to write that]
] <image>
#align(center, canvas({
import draw: *
content((0, 2.5), $A$)
circle((0, 0), radius: (1, 2))
content((5, 2.5), $B$)
circle((5, 0), radius: (1, 2))
circle((5, 0), radius: (0.75, 1.25), stroke: none, fill: luma(80%))
circle((0, 1.5), stroke: 3pt, radius: 0.05)
circle((0, 0.75), stroke: 3pt, radius: 0.05)
circle((0, 0), stroke: 3pt, radius: 0.05)
circle((0, -0.75), stroke: 3pt, radius: 0.05)
circle((0, -1.5), stroke: 3pt, radius: 0.05)
circle((5, 1.5), stroke: 3pt, radius: 0.05)
circle((5, 0.75), stroke: 3pt, radius: 0.05)
circle((5, 0), stroke: 3pt, radius: 0.05)
circle((5, -0.75), stroke: 3pt, radius: 0.05)
circle((5, -1.5), stroke: 3pt, radius: 0.05)
bezier((0, 1.5), (5, 0.75), (3, 1.5), (2, 0.75), mark: (end: ">"))
line((0, 0), (5, 0), mark: (end: ">"))
line((0, 0.75), (5, 0.75), mark: (end: ">"))
bezier((0, -0.75), (5, 0), (3, -0.75), (2, 0), mark: (end: ">"))
bezier((0, -1.5), (5, -0.75), (3, -1.5), (2, -0.75), mark: (end: ">"))
line((6.25, 0), (5.5, 0), stroke: luma(80%))
content((7, 0), text($imOf(f)$, fill: luma(50%)))
}))
== Modules
== Grading
== Exactness <exactness>
= Algebraic topology
== Basic spaces
== Eilenberg-MacLane spaces
#agdaCubicalLink("Cubical.Homotopy.EilenbergMacLane.Base")
== Chain complexes
#definition("Chain complex")[
A *chain complex* is a sequence of #link(<abelianGroup>)[abelian groups] $isTyp(C_n, AbGroup)$ ("chains") along with homomorphisms between consecutive groups $isTyp(d_n, hom(C_n, C_(n-1)))$ ("boundaries"), such that for any $n$, the proposition $propEq(homComp(d_(n-1), d_n), 0_(C_(n-2)))$ is inhabited.
] <chainComplex>
Another way to word this is that for consecutive homomorphisms $d_n$ and $d_(n-1)$, the #link(<image>)[image] of $d_n$ is a subgroup of the kernel of $d_(n-1)$.
#definition("Exact sequence")[
An *exact sequence* is a chain complex where all consecutive homomorphisms are #link(<exactness>)[exact].
] <exactSequence>
== Homology and cohomology
== Long exact sequence of homotopy groups
= Spectral sequences
== Definition
== Exact couples
== Serre spectral sequence
= Applications
= Conclusion

87
thesis/style.typ Normal file
View file

@ -0,0 +1,87 @@
#import "@preview/ctheorems:1.1.3": *
#let template(title: "", content) = {
set text(
font: "New Computer Modern Math",
size: 12pt,
)
set page(
"us-letter",
margin: 1in,
)
set par(
// leading: 1.3em,
spacing: 2.4em,
first-line-indent: 1.8em,
justify: true,
)
set heading(
numbering: "1.1",
)
show: thmrules
show link: body => underline(text(fill: olive, body))
// show heading: set block(above: 1.4em, below: 1em)
heading(outlined: false, numbering: none)[#title]
outline(indent: true, depth: 2)
page(
numbering: "1", // TODO: Remove
content,
)
heading(outlined: false, numbering: none)[References]
bibliography("main.bib", title: none)
}
#let TODO(c) = [#text(fill: red)[*TODO:*] #c]
#let agdaCubicalLink(s) = link("https://github.com/agda/cubical/blob/2f085f5675066c0e1708752587ae788c036ade87/" + s.split(".").join("/") + ".agda", raw(s))
// ctheorems
#let theorem = thmbox("theorem", "Theorem", fill: rgb("#eeffee"))
#let corollary = thmplain(
"corollary",
"Corollary",
base: "theorem",
titlefmt: strong
)
#let definition = thmbox("definition", "Definition")
#let axiom = thmplain("axiom", "Axiom")
#let example = thmplain("example", "Example").with(numbering: none)
#let proof = thmproof("proof", "Proof")
// Notation
#let emptyType = $bot$
#let arro(a, b) = $#a op(arrow) #b$
#let judgCtx(a) = $#a sans("ctx")$
#let isTyp(a, b) = $#a op(:) #b$
#let judgTyp(G, a, A) = $#G tack.r isTyp(#a, #A)$
#let propEqSym = $equiv$
#let propEq(a, b) = $#a #propEqSym #b$
#let eqv(a, b) = $#a tilde.eq #b$
#let defEq(a, b) = $#a := #b$
#let judgEqTyp(G, a, b, A) = $#G tack.r isTyp(#a equiv #b, #A)$
#let imOf(f) = $sans("Im")(#f)$
#let ind = $sans("ind")$
#let ua = $sans("ua")$
#let uaEqv = $sans("uaEqv")$
#let isEquiv = $sans("isEquiv")$
#let typ = $sans("Type")$
#let abst(n, b) = $(#n) arrow.r.double #b$
#let typ0 = $typ_0$
#let unitType = link(<unitType>)[$bb(1)$]
#let tt = $sans("tt")$
#let boolType = $bb(2)$
#let S1 = $S^1$
#let base = $sans("base")$
#let loop = $sans("loop")$
#let AbGroup = $sans("AbGroup")$
#let hom(a, b) = $#a arrow.r.double #b$
#let homComp(a, b) = $#a op(circle.small) #b$

4
thesis/upload.sh Executable file
View file

@ -0,0 +1,4 @@
#!/usr/bin/env bash
typst compile main.typ
direnv exec ~/garage-data mc cp main.pdf garage/mzhang-io-website/msthesis.pdf