1FundamentalGroup/Quest1 edits

1FundamentalGroup/Quest0Part0.md

@@ -66,7 +66,7 @@ We will fill the hole `{ }0`.
   ...
   ```
   
-  This says you have some unfilled __holes_.
+  This says you have some unfilled _holes_.
 - navigate to the hole `{ }0` using `C-c C-f` (forward) or `C-c C-b` (backward)
 - enter `C-c C-r`. The `r` stands for _refine_.
   Whenever you do this whilst having your cursor in a hole,

1FundamentalGroup/Quest0Part1.md

@@ -41,7 +41,12 @@ you can hover over `Bool` in `agda` and use `M-SPC c d`.)
 We will create a map `doubleCover : S¹ → Type` that sends
 `base` to `Bool` and the path `loop` to a non-trivial path `flipPath : Bool ≡ Bool`
 in the space of spaces.
-(Insert gif of double cover.)
+
+<img src="images/doubleCover.png" 
+     alt="doubleCover" 
+     width="500"
+     class="center"/>
+
 Viewing the picture vertically,
 for each point `x : S¹`, 
 we call `doubleCover x` the _fiber of `doubleCover` over `x`_.
@@ -52,7 +57,11 @@ in the fiber of `doubleCover` over `base`
 by 'lifting the homotopy' `h : Refl ≡ loop` and considering the end points of 
 the 'lifted paths'.
 `Refl` will 'lift' to a 'constant path' and `loop` will 'lift' to 
-(Insert picture of 'lift' of `loop`)
+
+<img src="images/lifted_loops.png" 
+     alt="lifted_loops" 
+     width="500"
+     class="center"/>
 
 Let's assume for the moment that we have `flipPath` already and
 define `doubleCover`.

1FundamentalGroup/Quest0Part2.md

@@ -2,7 +2,11 @@
 
 In this part, we will define the path `flipPath : Bool ≡ Bool`.
 Recall the picture of `doubleCover`.
-(Insert gif.)
+
+<img src="images/doubleCover.png" 
+     alt="doubleCover" 
+     width="500"
+     class="center"/>
 
 This means we need `flipPath` to correspond to 
 the unique non-identity permutation of `Bool`

1FundamentalGroup/Quest0Part3.md

@@ -32,26 +32,29 @@ drawn as a dot `true`.
 When we 'lift' `loop` - starting at the point `true : doubleCover base` -
 it will look like
 
- <!-- [insert picture] -->
+<img src="images/lifted_loops.png" 
+     alt="lifted_loops" 
+     width="500"
+     class="center"/>
 
 The homotopy `h : Refl ≡ loop` is 'lifted'
 (starting at 'lifted `Refl`')
 to some kind of surface 
 
-<!-- [insert picture] -->
+<img src="images/lifted_homotopy.png" 
+     alt="lifted_homotopy" 
+     width="500"
+     class="center"/>
 
 According to the pictures the end point of the 'lifted' 
 `Refl` is `true` and the end point of the 'lifted' `loop` is `false`.
 We are interested in the end points of each 
 'lifted paths' in the 'lifted homotopy',
 since this forms a path in the endpoint fiber `doubleCover base`
-from `true` to `false`
-
-<!-- [insert picture] -->
+from `true` to `false`.
 
 We can evaluate the end points of both 'lifted paths' by using 
-something in the cubical library called `endPt` 
-(originally called `subst`).
+something in the cubical library (called `subst`) which we call `endPt`.
 
 ```agda
 endPt : (B : A → Type) (p : x ≡ y) (bx : B x) → B y
@@ -93,6 +96,6 @@ from `f x` to `f y`.
 cong : (f : A → B) → (p : x ≡ y) → f x ≡ f y
 ```
 
-Using `cong` and `endPtOfTrue` you should be able to complete Quest0.
+Using `cong` and `endPtOfTrue` you should be able to complete `Quest0`.
 If you have done everything correctly you can reload `agda` and see that
 you have no remaining goals.

1FundamentalGroup/Quest1.agda

@@ -0,0 +1,16 @@
+module 1FundamentalGroup.Quest1 where
+
+open import Cubical.Core.Everything
+open import Cubical.HITs.S1
+open import Cubical.Data.Nat
+open import Cubical.Data.Int
+open import Cubical.Foundations.Prelude
+
+Ω : (A : Type) (a : A) → Type
+Ω A a = a ≡ a 
+
+loop_times : ℤ → Ω S¹ base
+loop pos zero times = refl
+loop pos (suc n) times = loop pos n times ∙ loop
+loop negsuc zero times = sym loop
+loop negsuc (suc n) times = loop negsuc n times ∙ sym loop

1FundamentalGroup/Quest1Part0.md

@@ -19,6 +19,81 @@ In general the _loop space_ of a space `A` at a point `a` is defined as follows
 Ω A a = a ≡ a 
 ```
 
+Clearly for each integer `n : ℤ` we have a path 
+that is '`loop` around `n` times'.
+Locate `loop_times` in the `Quest1.agda`
+(note how `agda` treats underscores)
+
+```agda
+loop_times : ℤ → Ω S¹ base
+loop n times = {!!}
+```
+
+Try casing on `n`, you should see
+
+```agda
+loop_times : ℤ → Ω S¹ base
+loop pos n times = {!!}
+loop negsuc n times = {!!}
+```
+
+It says to map out of `ℤ` it suffices to 
+map the non-negative integers (`pos`) 
+and the negative integers (`negsuc`).
+
+```agda
+data ℤ : Type where
+  pos    : (n : ℕ) → ℤ
+  negsuc : (n : ℕ) → ℤ
+```
+
+This definition of `ℤ` uses the naturals, so try
+casing on `n` again, you should see
+
+```agda
+loop_times : ℤ → Ω S¹ base
+loop pos zero times = {!!}
+loop pos (suc n) times = {!!}
+loop negsuc n times = {!!}
+```
+
+It says to map out of `ℕ` it suffices to map `zero` and 
+map each succesive integer `suc n` inductively.
+When we loop `zero` (`pos zero`) times what should we get?
+Try filling it in.
+For looping `pos (suc n)` times we loop `n` times and 
+loop once more.
+For this we need composition of paths.
+
+```agda
+_∙_ : x ≡ y → y ≡ z → x ≡ z
+```
+
+Try typing `_∙_` or `? ∙ ?` in the hole (input `/.`)
+and refining.
+Checking the new holes you should see that now you need 
+to give two loops.
+Try giving it '`loop n times`' composed with `loop`.
+Then try to also define the map on the negative integers.
+You will need to invert paths using `sym`.
+
+<p>
+<details>
+<summary>Looking up definitions</summary>
+
+If you don't know the definition of something 
+you can look up the definition by sticking your cursor
+on it and pressing `M-SPC c d` in _insert mode_
+or `SPC c d` in _evil mode_.
+
+You can use it to find out the definition of `ℤ` and `ℕ`.
+
+</details>
+</p>
+
+<!-- Next level -->
+
+
 Warning : 
 the loop space can contain higher homotopical information that
 the fundamental group does not capture.
@@ -49,3 +124,67 @@ However, the 'composition' of the path `southHemisphere` with `northHemisphere`
 in `base ≡ base` gives the surface of `S²`,
 which intuitively is not homotopic to the constant point `base`.
 So `base ≡ base` has non-trivial path structure.
+
+<img src="images/S2.png" 
+     alt="S2" 
+     width="500"
+     class="center"/>
+
+Let's be more precise about homotopical data : 
+We can check that a space is 'homotopically trivial' (h-trivial) 
+from dimension `n`
+by checking if spheres of dimension `n` can be filled.
+To be h-trivial from `0` is for any two points
+to have a line in between; to fill `S⁰`. 
+This data is captured in 
+
+```agda
+isProp : Type → Type 
+isProp A = (x y : A) → x ≡ y
+```
+
+<p>
+<details>
+<summary>All maps are continuous in HoTT</summary>
+
+There is a subtlety in the definition `isProp`.
+This is _stronger_ than saying that the space `A` is path connected.
+Since `A` is equipped with a continuous map taking pairs `x y : A`
+to a path between them. 
+
+We will show that `isProp S¹` is _empty_ despite `S¹` being path connected. 
+
+</details>
+</p>
+
+Similarly, to be h-trivial from `1` is for any two points `x y : A`
+and any two paths `p q : x ≡ y` to have a homotopy from `p` to `q`;
+to fill `S¹`. This is captured in
+
+```agda
+isSet : Type → Type
+isSet A = (x y : A) → isProp (x ≡ y)
+```
+
+We may therefore want to remove homotopical data 
+beyond a certain dimension.
+We define the fundamental group to be 
+the homotopical data of `S¹` up to (and 
+including) dimension `1`, i.e. 
+the homotopical data of the loop space of `S¹`
+up to dimension `0`.
+
+We make the definitions for a space to 
+have homotopical data only up to dimension `0`
+and `1` respectively
+
+
+```agda
+isProp : Type → Type 
+isProp A = (x y : A) → x ≡ y
+
+isSet : Type → Type
+isSet A = (x y : A) → isProp (x ≡ y)
+
+isProp→isSet : (A : Type) → isProp A → isSet A
+```