import Mathlib

namespace OAI

/-! Loop-space homeomorphisms and the degree-shift equivalence. -/

noncomputable section
universe u v w


namespace NearbyLagrangian.BasedHomotopy
open ContinuousMap
open scoped Topology Topology.Homotopy
variable {N M X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
variable {x : X} {y : Y}

theorem genLoop_homotopic_iff_joined (f g : GenLoop N X x) :
    GenLoop.Homotopic f g ↔ Joined f g := by
  constructor
  · rintro ⟨H⟩
    refine ⟨{
      toFun := fun s => ⟨H.toContinuousMap.curry s,fun t ht =>
        (H.prop s t ht).trans (GenLoop.boundary f t ht)⟩
      continuous_toFun := H.toContinuousMap.curry.continuous.subtype_mk _
      source' := ?_
      target' := ?_ }⟩
    · ext t; exact H.apply_zero t
    · ext t; exact H.apply_one t
  · rintro ⟨P⟩
    refine ⟨{
      toFun := fun z => P z.1 z.2
      continuous_toFun := ?_
      map_zero_left := ?_
      map_one_left := ?_
      prop' := ?_ }⟩
    · exact (continuous_subtype_val.comp (P.continuous.comp continuous_fst)).eval continuous_snd
    · intro t; exact congrArg (fun z : GenLoop N X x => z t) P.source
    · intro t; exact congrArg (fun z : GenLoop N X x => z t) P.target
    · intro s t ht
      exact (GenLoop.boundary (P s) t ht).trans (GenLoop.boundary f t ht).symm

def piEquivOfLoopHomeomorph (e : GenLoop N X x ≃ₜ GenLoop M Y y) :
    HomotopyGroup N X x ≃ HomotopyGroup M Y y :=
  Quotient.congr e.toEquiv fun f g => by
    change GenLoop.Homotopic f g ↔ GenLoop.Homotopic (e f) (e g)
    rw [genLoop_homotopic_iff_joined,genLoop_homotopic_iff_joined]
    constructor
    · intro h; exact h.map e.continuous_toFun
    · intro h
      have hh : Joined (e.symm (e f)) (e.symm (e g)) := h.map e.symm.continuous_toFun
      simpa only [Homeomorph.symm_apply_apply] using hh

def piReindexEquiv (e : N ≃ M) (x : X) :
    HomotopyGroup N X x ≃ HomotopyGroup M X x :=
  piEquivOfLoopHomeomorph (GenLoop.congr x e)

def flattenPathLoop (f : GenLoop N (Path y y) (Path.refl y)) :
    GenLoop (N ⊕ Unit) Y y :=
  ⟨⟨fun a => f (a ∘ Sum.inl) (a (Sum.inr ())),by
    apply Continuous.eval
    · exact f.1.continuous.comp (by fun_prop)
    · fun_prop⟩,by
      rintro a ⟨i | i,hi⟩ <;> change f (a ∘ Sum.inl) (a (Sum.inr ())) = y
      · have h : a ∘ Sum.inl ∈ Cube.boundary N := ⟨i,hi⟩
        rw [GenLoop.boundary f _ h]
        rfl
      · cases i
        rcases hi with hi | hi
        · rw [hi]; exact (f _).source
        · rw [hi]; exact (f _).target⟩

def curryPathLoop (g : GenLoop (N ⊕ Unit) Y y) :
    GenLoop N (Path y y) (Path.refl y) :=
  ⟨⟨fun a => {
    toFun := fun r => g (Sum.elim a (fun _ => r))
    continuous_toFun := g.1.continuous.comp (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop)
    source' := GenLoop.boundary g _ ⟨Sum.inr (),Or.inl rfl⟩
    target' := GenLoop.boundary g _ ⟨Sum.inr (),Or.inr rfl⟩ },by
      apply Path.continuous_uncurry_iff.mp
      exact g.1.continuous.comp (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop)⟩,by
    rintro a ⟨i,hi⟩
    apply Path.ext
    funext r
    exact GenLoop.boundary g _ ⟨Sum.inl i,hi⟩⟩

@[simp] lemma curry_flatten (f : GenLoop N (Path y y) (Path.refl y)) :
    curryPathLoop (flattenPathLoop f) = f := by
  apply Subtype.ext
  ext a r
  rfl

@[simp] lemma flatten_curry (g : GenLoop (N ⊕ Unit) Y y) :
    flattenPathLoop (curryPathLoop g) = g := by
  apply Subtype.ext
  ext a
  change g (Sum.elim (a ∘ Sum.inl) (fun _ => a (Sum.inr ()))) = g a
  congr 1
  funext i
  cases i with
  | inl i => rfl
  | inr i => cases i; rfl

lemma continuous_flattenPathLoop : Continuous (@flattenPathLoop N Y _ y) := by
  apply Continuous.subtype_mk
  apply ContinuousMap.continuous_of_continuous_uncurry
  change Continuous (fun z : GenLoop N (Path y y) (Path.refl y) × ((N ⊕ Unit) → unitInterval) =>
    z.1 (z.2 ∘ Sum.inl) (z.2 (Sum.inr ())))
  have h : Continuous (fun z : GenLoop N (Path y y) (Path.refl y) × ((N ⊕ Unit) → unitInterval) =>
      z.1 (z.2 ∘ Sum.inl)) :=
    (continuous_subtype_val.comp continuous_fst).eval
      (continuous_pi (fun i => (continuous_apply (Sum.inl i)).comp continuous_snd))
  exact h.eval ((continuous_apply (Sum.inr ())).comp continuous_snd)

lemma continuous_curryPathLoop : Continuous (@curryPathLoop N Y _ y) := by
  apply Continuous.subtype_mk
  apply ContinuousMap.continuous_of_continuous_uncurry
  apply Path.continuous_uncurry_iff.mp
  exact (continuous_subtype_val.comp (continuous_fst.comp continuous_fst)).eval
    (by apply continuous_pi; intro i; cases i <;> dsimp only [Sum.elim] <;> fun_prop)

def loopSpaceCubeHomeomorph :
    GenLoop N (Path y y) (Path.refl y) ≃ₜ GenLoop (N ⊕ Unit) Y y where
  toFun := flattenPathLoop
  invFun := curryPathLoop
  left_inv := curry_flatten
  right_inv := flatten_curry
  continuous_toFun := continuous_flattenPathLoop
  continuous_invFun := continuous_curryPathLoop

def loopPiEquiv (y : Y) :
    HomotopyGroup N (Path y y) (Path.refl y) ≃ HomotopyGroup (N ⊕ Unit) Y y :=
  piEquivOfLoopHomeomorph loopSpaceCubeHomeomorph

def pi9LoopEquivPi10 (y : Y) :
    π_ 9 (Path y y) (Path.refl y) ≃ π_ 10 Y y :=
  (loopPiEquiv y).trans (piReindexEquiv
    ((Equiv.sumCongr (Equiv.refl (Fin 9)) (Equiv.ofUnique Unit (Fin 1))).trans finSumFinEquiv) y)

end NearbyLagrangian.BasedHomotopy

end

end OAI