{-# OPTIONS --without-K #-}

module CircleFundamentalGroup where

open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
  renaming (Set to Type) public
open import Agda.Builtin.Int

-- Path
data _≡_ {l : Level} {A : Type l} : A → A → Type l where
  refl : (x : A) → x ≡ x
path-ind : ∀ {ℓ : Level} {A : Type}
  -- Motive
  → (C : (x y : A) → x ≡ y → Type ℓ)
  -- What happens in the case of refl
  → (c : (x : A) → C x x (refl x))
  -- Actual path to eliminate
  → {x y : A} → (p : x ≡ y)
  -- Result
  → C x y p
path-ind C c {x} (refl x) = c x

-- Id
id : {ℓ : Level} {A : Set ℓ} → A → A
id x = x
 
-- Transport
transport : {X : Set} (P : X → Set) {x y : X}
  → x ≡ y
  → P x → P y
transport P (refl x) = id

-- apd
-- Lemma 2.3.4 of HoTT book
apd : {A : Type} {B : A → Type}
  -- The function that we want to apply
  → (f : (a : A) → B a)
  -- The path to apply it over
  → {x y : A} → (p : x ≡ y)
  -- Result
  → (transport B p) (f x) ≡ f y
apd {A} {B} f p = path-ind D d p
  where
    D : (x y : A) → (p : x ≡ y) → Type
    D x y p = (transport B p) (f x) ≡ f y

    d : (x : A) → D x x (refl x)
    d x = refl (f x)

-- Circle (S¹)
postulate
  S¹ : Set
  base : S¹
  loop : base ≡ base
  S¹-ind : (C : S¹ → Type)
    → (c-base : C base)
    → (c-loop : c-base ≡ c-base)
    → (s : S¹) → C s

-- Fundamental group of a circle

loop-space : {A : Type} → (a : A) → Set
loop-space a = a ≡ a

π₁ : {A : Type} → (a : A) → Type
π₁ a = ?

π₁[S¹]≡ℤ : π₁ base ≡ Int
π₁[S¹]≡ℤ = ?

-- References:
-- - https://homotopytypetheory.org/2011/04/29/a-formal-proof-that-pi1s1-is-z/
-- - HoTT book ch. 6.11
-- - https://en.wikipedia.org/wiki/Fundamental_group