Added templates and some code done

1FundamentalGroup/Preambles/P0.agda

@@ -0,0 +1,12 @@
+module 1FundamentalGroup.Preambles.P0 where
+
+open import Cubical.Data.Empty using (⊥) public
+open import Cubical.Data.Unit renaming ( Unit to ⊤ ) public
+open import Cubical.Data.Bool renaming ( elim to Bool-elim ) public
+open import Cubical.Foundations.Prelude
+     renaming ( subst to endPt
+              ; transport to pathToFun
+              ) public
+open import Cubical.Foundations.Isomorphism renaming ( Iso to _≅_ ) public
+open import Cubical.Foundations.Path public
+open import Cubical.HITs.S1 renaming ( elim to S¹-elim ) public

1FundamentalGroup/Preambles/P1.agda

@@ -0,0 +1,12 @@
+module 1FundamentalGroup.Preambles.P1 where
+
+open import Cubical.HITs.S1 using (S¹ ; base ; loop) public
+open import Cubical.Data.Nat using (ℕ ; suc ; zero) public
+open import Cubical.Data.Int using (ℤ ; pos ; negsuc ; -_) public
+open import Cubical.Data.Empty public
+open import Cubical.Foundations.Prelude
+     renaming ( subst to endPt
+              ; transport to pathToFun
+              ) public
+open import Cubical.Foundations.Isomorphism renaming (Iso to _≅_) public
+open import 1FundamentalGroup.Quest0Solutions using ( Refl ; Refl≢loop ) public

1FundamentalGroup/Preambles/P2.agda

@@ -0,0 +1,19 @@
+module 1FundamentalGroup.Preambles.P2 where
+
+open import Cubical.Data.Nat public
+open import Cubical.Data.Int using (ℤ ; pos ; negsuc ; -_) public
+open import Cubical.Foundations.Isomorphism renaming (Iso to _≅_) public
+open import Cubical.Data.Empty using (⊥) public
+open import Cubical.Data.Unit renaming (Unit to ⊤) public
+open import Cubical.Foundations.Prelude
+     renaming ( subst to endPt
+              ; transport to pathToFun
+              ) public
+open import Cubical.HITs.S1 using (S¹ ; base ; loop) public
+open import 1FundamentalGroup.Quest1Solutions public
+
+refl∙refl : {A : Type} {a : A} → refl ∙ refl ≡ refl {x = a}
+refl∙refl {a = a} = sym (λ i j → compPath-filler (refl {x = a}) refl i j)
+
+symRefl : {A : Type} {a : A} → sym refl ≡ refl {x = a}
+symRefl = refl

1FundamentalGroup/Preambles/P3.agda

@@ -0,0 +1,33 @@
+module 1FundamentalGroup.Preambles.P3 where
+
+open import Cubical.Foundations.Prelude public
+  renaming (transport to pathToFun ;
+            transportRefl to pathToFunRefl ;
+            subst to endPt) public
+open import Cubical.Foundations.Isomorphism renaming (Iso to _≅_) public
+open import Cubical.Foundations.GroupoidLaws
+  renaming (lCancel to sym∙ ; rCancel to ∙sym ; lUnit to Refl∙ ; rUnit to ∙Refl) public
+open import Cubical.Foundations.Path public
+open import Cubical.Data.Int using (ℤ ; isSetℤ) public
+open import Cubical.Data.Nat public
+open import Cubical.HITs.S1 using ( S¹ ; base ; loop ) public
+open import 1FundamentalGroup.Quest1Solutions public
+
+open ℤ public
+
+PathD : {A0 A1 : Type} (A : A0 ≡ A1) (x : A0) (y : A1) → Type
+PathD A x y = pathToFun A x ≡ y
+
+endPtRefl : {A : Type} {x : A} (B : A → Type) → endPt B (refl {x = x}) ≡ λ b → b
+endPtRefl {x = x} B = funExt (λ b → substRefl {B = B} b)
+
+outOfS¹P : (B : S¹ → Type) (b : B base) → PathP (λ i → B (loop i)) b b → (x : S¹) → B x
+outOfS¹P B b p base = b
+outOfS¹P B b p (loop i) = p i
+
+outOfS¹D : (B : S¹ → Type) (b : B base) → PathD (λ i → B (loop i)) b b → (x : S¹) → B x
+outOfS¹D B b p x = outOfS¹P B b (_≅_.inv (PathPIsoPath (λ i → B (loop i)) b b) p) x
+
+outOfS¹DBase : (B : S¹ → Type) (b : B base)
+  (p : PathD (λ i → B (loop i)) b b) → outOfS¹D B b p base ≡ b
+outOfS¹DBase B b p = refl

1FundamentalGroup/Quest0.agda

@@ -0,0 +1,64 @@
+-- ignore
+module 1FundamentalGroup.Quest0 where
+open import 1FundamentalGroup.Preambles.P0
+
+Refl : base ≡ base
+Refl = {!!}
+
+Flip : Bool → Bool
+Flip x = {!!}
+
+flipIso : Bool ≅ Bool
+flipIso = {!!}
+
+flipPath : Bool ≡ Bool
+flipPath = {!!}
+
+doubleCover : S¹ → Type
+doubleCover x = {!!}
+
+endPtOfTrue : base ≡ base → doubleCover base
+endPtOfTrue p = {!!}
+
+Refl≢loop : Refl ≡ loop → ⊥
+Refl≢loop p = {!!}
+
+------------------- Side Quest - Empty -------------------------
+
+{-
+-- This is a comment box,
+-- remove the {- and -} to do the side quests
+
+toEmpty : (A : Type) → Type
+toEmpty A = {!!}
+
+pathEmpty : (A : Type) → Type₁
+pathEmpty A = {!!}
+
+isoEmpty : (A : Type) → Type
+isoEmpty A = {!!}
+
+outOf⊥ : (A : Type) → ⊥ → A
+outOf⊥ A ()
+
+toEmpty→isoEmpty : (A : Type) → toEmpty A → isoEmpty A
+toEmpty→isoEmpty A = {!!}
+
+isoEmpty→pathEmpty : (A : Type) → isoEmpty A → pathEmpty A
+isoEmpty→pathEmpty A = {!!}
+
+pathEmpty→toEmpty : (A : Type) → pathEmpty A → toEmpty A
+pathEmpty→toEmpty A = {!!}
+-}
+
+------------------- Side Quests - true≢false --------------------
+
+{-
+-- This is a comment box,
+-- remove the {- and -} to do the side quests
+
+true≢false' : true ≡ false → ⊥
+true≢false' = {!!}
+
+-}
+

1FundamentalGroup/Quest1.agda

@@ -0,0 +1,35 @@
+-- ignore
+module 1FundamentalGroup.Quest1 where
+open import 1FundamentalGroup.Preambles.P1
+
+
+loopSpace : (A : Type) (a : A) → Type
+loopSpace A a = a ≡ a
+
+loop_times : ℤ → loopSpace S¹ base
+loop n times = {!!}
+
+{-
+The definition of sucℤ goes here.
+-}
+
+{-
+The definition of predℤ goes here.
+-}
+
+{-
+The definition of sucℤIso goes here.
+-}
+
+{-
+The definition of sucℤPath goes here.
+-}
+
+helix : S¹ → Type
+helix = {!!}
+
+windingNumberBase : base ≡ base → ℤ
+windingNumberBase = {!!}
+
+windingNumber : (x : S¹) → base ≡ x → helix x
+windingNumber = {!!}

1FundamentalGroup/Quest1SideQuests/Sn.agda

@@ -0,0 +1,23 @@
+module 1FundamentalGroup.Quest1SideQuests.Sn where
+
+open import Cubical.Data.Nat
+open import Cubical.Data.Empty
+open import Cubical.Data.Unit renaming (Unit to ⊤)
+open import Cubical.Data.Bool
+open import Cubical.Foundations.Prelude
+
+
+data susp (X : Type) : Type where
+  north : {!!}
+  south : {!!}
+  merid : {!!}
+
+Sphere : ℕ → Type
+Sphere = {!!}
+
+Disk : (n : ℕ) → Type
+Disk zero = {!!}
+Disk (suc n) = {!!}
+
+SphereToDisk : {n : ℕ} → Sphere n → Disk n
+SphereToDisk {n} s = {!!}

1FundamentalGroup/Quest2.agda

@@ -0,0 +1,27 @@
+-- ignore
+module 1FundamentalGroup.Quest2 where
+open import 1FundamentalGroup.Preambles.P2
+
+isSet→LoopSpace≡⊤ : {A : Type} (x : A) → isSet A → (x ≡ x) ≡ ⊤
+isSet→LoopSpace≡⊤ = {!!}
+
+data _⊔_ (A B : Type) : Type where
+
+     inl : A → A ⊔ B
+     inr : B → A ⊔ B
+
+{-
+
+Your definition of ℤ≡ℕ⊔ℕ goes here.
+
+Your definition of ⊔NoConfusion goes here.
+
+Your definition of Path≡⊔NoConfusion goes here.
+
+Your definition of isSet⊔NoConfusion goes here.
+
+Your definition of isSet⊔ goes here.
+
+Your definition of isSetℤ goes here.
+
+-}

1FundamentalGroup/Quest3.agda

@@ -0,0 +1,3 @@
+module 1FundamentalGroup.Quest3 where
+
+open import 1FundamentalGroup.Preambles.P3