import OAI.Dynamics.EntropyCounterexample.Definitions

namespace OAI

noncomputable section

open Set Metric
open scoped unitInterval

namespace Problem340
namespace CoordinateGoodCover

section Cone

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

def sphereSlice (C : Set E) : Set (Metric.sphere (0 : E) 1) :=
  {x | (x : E) ∈ C}

theorem contractible_sphereSlice (C : Set E) (hconv : Convex ℝ C)
    (hscale : ∀ r : ℝ, 0 < r → ∀ x ∈ C, r • x ∈ C)
    (hzero : (0 : E) ∉ C) (hne : (sphereSlice C).Nonempty) :
    ContractibleSpace (sphereSlice C) := by
  obtain ⟨p, hp⟩ := hne
  let p' : sphereSlice C := ⟨p, hp⟩
  let blend : unitInterval × sphereSlice C → E :=
    fun z => (z.1 : ℝ) • (p : E) + (1 - (z.1 : ℝ)) • (z.2.1 : E)
  have hblend : Continuous blend := by
    dsimp [blend]
    fun_prop
  have hmem (z : unitInterval × sphereSlice C) : blend z ∈ C := by
    exact hconv hp z.2.property z.1.property.1
      (sub_nonneg.mpr z.1.property.2) (add_sub_cancel _ _)
  have hnezero (z : unitInterval × sphereSlice C) : blend z ≠ 0 := by
    intro hz
    exact hzero (hz ▸ hmem z)
  have hnorm (z : unitInterval × sphereSlice C) : ‖blend z‖ ≠ 0 :=
    norm_ne_zero_iff.mpr (hnezero z)
  let H : unitInterval × sphereSlice C → sphereSlice C := fun z =>
    ⟨⟨‖blend z‖⁻¹ • blend z, by
      simpa [mem_sphere_zero_iff_norm] using
        (norm_smul_inv_norm (𝕜 := ℝ) (hnezero z))⟩,
      hscale _ (inv_pos.mpr (norm_pos_iff.mpr (hnezero z))) _ (hmem z)⟩
  have hH : Continuous H := by
    apply Continuous.subtype_mk
    apply Continuous.subtype_mk
    exact (hblend.norm.inv₀ hnorm).smul hblend
  apply (contractible_iff_id_nullhomotopic (sphereSlice C)).mpr
  refine ⟨p', ⟨⟨⟨H, hH⟩, ?_, ?_⟩⟩⟩
  · intro x
    apply Subtype.ext
    apply Subtype.ext
    have hx : ‖(x.1 : E)‖ = 1 := by
      simpa only [mem_sphere_zero_iff_norm] using x.1.property
    simp [H, blend, hx]
  · intro x
    apply Subtype.ext
    apply Subtype.ext
    have hp' : ‖(p : E)‖ = 1 := by
      simpa only [mem_sphere_zero_iff_norm] using p.property
    simp [H, blend, hp', p']

def positiveCone {ι : Type*} (L : ι → E →L[ℝ] ℝ) (s : Set ι) : Set E :=
  {x | ∀ i ∈ s, 0 < L i x}

theorem convex_positiveCone {ι : Type*} (L : ι → E →L[ℝ] ℝ) (s : Set ι) :
    Convex ℝ (positiveCone L s) := by
  intro x hx y hy a b ha hb hab i hi
  exact ((convex_Ioi (𝕜 := ℝ) (0 : ℝ)).linear_preimage (L i).toLinearMap)
    (hx i hi) (hy i hi) ha hb hab

theorem positiveCone_smul {ι : Type*} (L : ι → E →L[ℝ] ℝ) (s : Set ι)
    {r : ℝ} (hr : 0 < r) {x : E} (hx : x ∈ positiveCone L s) :
    r • x ∈ positiveCone L s := by
  intro i hi
  simpa only [map_smul, smul_eq_mul] using mul_pos hr (hx i hi)

theorem zero_not_mem_positiveCone {ι : Type*} (L : ι → E →L[ℝ] ℝ)
    (s : Set ι) (hs : s.Nonempty) : (0 : E) ∉ positiveCone L s := by
  obtain ⟨i, hi⟩ := hs
  intro h
  simpa only [map_zero, lt_self_iff_false] using h i hi

theorem contractible_positiveSphere {ι : Type*} (L : ι → E →L[ℝ] ℝ)
    (s : Set ι) (hs : s.Nonempty)
    (hne : (sphereSlice (positiveCone L s)).Nonempty) :
    ContractibleSpace (sphereSlice (positiveCone L s)) :=
  contractible_sphereSlice _ (convex_positiveCone L s)
    (fun _ hr _ hx => positiveCone_smul L s hr hx)
    (zero_not_mem_positiveCone L s hs) hne

end Cone

theorem contractible_pi {ι : Type*} (X : ι → Type*)
    [∀ i, TopologicalSpace (X i)] [∀ i, ContractibleSpace (X i)] :
    ContractibleSpace (∀ i, X i) := by
  choose p hp using fun i => id_nullhomotopic (X i)
  apply (contractible_iff_id_nullhomotopic (∀ i, X i)).mpr
  refine ⟨p, ?_⟩
  exact ContinuousMap.Homotopic.piMap hp

structure GoodCover (ι X : Type*) [TopologicalSpace X] where
  carrier : ι → Set X
  isOpen : ∀ i, IsOpen (carrier i)
  covers : ∀ x, ∃ i, x ∈ carrier i
  contractible : ∀ s : Finset ι, s.Nonempty →
    (⋂ i ∈ s, carrier i).Nonempty → ContractibleSpace (⋂ i ∈ s, carrier i)

theorem GoodCover.iUnion_eq_univ {ι X : Type*} [TopologicalSpace X]
    (U : GoodCover ι X) : (⋃ i, U.carrier i) = Set.univ := by
  ext x
  simp only [Set.mem_iUnion, Set.mem_univ, iff_true]
  exact U.covers x

def GoodCover.comap {ι X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    (U : GoodCover ι Y) (e : X ≃ₜ Y) : GoodCover ι X where
  carrier i := e ⁻¹' U.carrier i
  isOpen i := (U.isOpen i).preimage e.continuous
  covers x := U.covers (e x)
  contractible s hs hne := by
    let A := ⋂ i ∈ s, U.carrier i
    let B := ⋂ i ∈ s, e ⁻¹' U.carrier i
    have hset : B = e ⁻¹' A := by
      simp only [A, B, Set.preimage_iInter]
    have hA : A.Nonempty := by
      obtain ⟨x, hx⟩ := hne
      refine ⟨e x, ?_⟩
      change x ∈ e ⁻¹' A
      rw [← hset]
      exact hx
    let := U.contractible s hs hA
    exact (e.sets hset).contractibleSpace

section Products

variable {ι κ X Y : Type*} [topologyX : TopologicalSpace X] [topologyY : TopologicalSpace Y]

omit topologyX topologyY in
theorem inter_prod_eq [TopologicalSpace X] [TopologicalSpace Y]
    (U : ι → Set X) (V : κ → Set Y) (s : Finset (ι × κ))
    [DecidableEq ι] [DecidableEq κ] :
    (⋂ i ∈ s, U i.1 ×ˢ V i.2) =
      (⋂ i ∈ s.image Prod.fst, U i) ×ˢ (⋂ j ∈ s.image Prod.snd, V j) := by
  ext x
  simp only [mem_iInter, mem_prod, Finset.mem_image]
  constructor
  · intro h
    constructor
    · rintro i ⟨j, hj, rfl⟩
      exact (h j hj).1
    · rintro i ⟨j, hj, rfl⟩
      exact (h j hj).2
  · rintro ⟨hU, hV⟩ i hi
    exact ⟨hU i.1 ⟨i, hi, rfl⟩, hV i.2 ⟨i, hi, rfl⟩⟩

def GoodCover.prod (U : GoodCover ι X) (V : GoodCover κ Y) :
    GoodCover (ι × κ) (X × Y) where
  carrier i := U.carrier i.1 ×ˢ V.carrier i.2
  isOpen i := (U.isOpen i.1).prod (V.isOpen i.2)
  covers x := by
    obtain ⟨i, hi⟩ := U.covers x.1
    obtain ⟨j, hj⟩ := V.covers x.2
    exact ⟨(i, j), hi, hj⟩
  contractible s hs hne := by
    classical
    rw [inter_prod_eq] at hne ⊢
    let A := ⋂ i ∈ s.image Prod.fst, U.carrier i
    let B := ⋂ j ∈ s.image Prod.snd, V.carrier j
    have hA : A.Nonempty := by
      obtain ⟨x, hx⟩ := hne
      exact ⟨x.1, hx.1⟩
    have hB : B.Nonempty := by
      obtain ⟨x, hx⟩ := hne
      exact ⟨x.2, hx.2⟩
    let := U.contractible _ (hs.image _) hA
    let := V.contractible _ (hs.image _) hB
    exact (Homeomorph.Set.prod A B).contractibleSpace

def piSubsetHomeomorph {α : Type*} {Z : α → Type*}
    [∀ i, TopologicalSpace (Z i)] (A : ∀ i, Set (Z i)) :
    (Set.pi Set.univ A) ≃ₜ (∀ i, A i) where
  toFun x i := ⟨x.1 i, x.2 i (Set.mem_univ i)⟩
  invFun x := ⟨fun i => (x i).1, fun i _ => (x i).2⟩
  left_inv x := rfl
  right_inv x := rfl
  continuous_toFun := by
    apply continuous_pi
    intro i
    exact ((continuous_apply i).comp continuous_subtype_val).subtype_mk _
  continuous_invFun := by
    apply Continuous.subtype_mk
    exact continuous_pi fun i => continuous_subtype_val.comp (continuous_apply i)

def GoodCover.pi {α : Type*} [Finite α] {J Z : α → Type*}
    [∀ i, TopologicalSpace (Z i)] (U : ∀ i, GoodCover (J i) (Z i)) :
    GoodCover (∀ i, J i) (∀ i, Z i) where
  carrier j := Set.pi Set.univ (fun i => (U i).carrier (j i))
  isOpen j := isOpen_set_pi Set.finite_univ fun i _ => (U i).isOpen (j i)
  covers x := by
    choose j hj using fun i => (U i).covers (x i)
    exact ⟨j, fun i _ => hj i⟩
  contractible s hs hne := by
    classical
    let A : ∀ i, Set (Z i) := fun i =>
      ⋂ j ∈ s.image (fun f => f i), (U i).carrier j
    have hset : (⋂ j ∈ s, Set.pi Set.univ (fun i => (U i).carrier (j i))) =
        Set.pi Set.univ A := by
      ext x
      simp only [mem_iInter, Set.mem_pi, Set.mem_univ, true_implies]
      constructor
      · intro h i
        apply Set.mem_iInter₂.mpr
        intro j hj
        obtain ⟨f, hf, rfl⟩ := Finset.mem_image.mp hj
        exact h f hf i
      · intro h j hj i
        exact Set.mem_iInter₂.mp (h i) (j i) (Finset.mem_image.mpr ⟨j, hj, rfl⟩)
    rw [hset] at hne ⊢
    have hA (i : α) : (A i).Nonempty := by
      obtain ⟨x, hx⟩ := hne
      exact ⟨x i, hx i (Set.mem_univ i)⟩
    let (i : α) : ContractibleSpace (A i) :=
      (U i).contractible _ (hs.image _) (hA i)
    let : ContractibleSpace (∀ i, A i) := contractible_pi (fun i => A i)
    exact (piSubsetHomeomorph A).contractibleSpace

end Products

section Coordinates

variable (n : ℕ)

def signedCoordinate (i : Bool × Fin n) : EuclideanSpace ℝ (Fin n) →L[ℝ] ℝ :=
  if i.1 then EuclideanSpace.proj i.2 else -EuclideanSpace.proj i.2

def hemisphere (i : Bool × Fin n) : Set (Metric.sphere (0 : EuclideanSpace ℝ (Fin n)) 1) :=
  {x | 0 < signedCoordinate n i (x : EuclideanSpace ℝ (Fin n))}

theorem isOpen_hemisphere (i : Bool × Fin n) : IsOpen (hemisphere n i) :=
  isOpen_lt continuous_const ((signedCoordinate n i).continuous.comp continuous_subtype_val)

theorem hemisphere_covers (x : Metric.sphere (0 : EuclideanSpace ℝ (Fin n)) 1) :
    ∃ i, x ∈ hemisphere n i := by
  have hx : (x : EuclideanSpace ℝ (Fin n)) ≠ 0 := by
    intro h
    have hxnorm : ‖(x : EuclideanSpace ℝ (Fin n))‖ = 1 := by
      simpa only [mem_sphere_zero_iff_norm] using x.property
    rw [h, norm_zero] at hxnorm
    exact zero_ne_one hxnorm
  have hi : ∃ i : Fin n, (x : EuclideanSpace ℝ (Fin n)) i ≠ 0 := by
    by_contra h
    push Not at h
    exact hx (PiLp.ext h)
  obtain ⟨i, hi⟩ := hi
  rcases lt_or_gt_of_ne hi with h | h
  · exact ⟨(false, i), by simpa [hemisphere, signedCoordinate] using neg_pos.mpr h⟩
  · exact ⟨(true, i), by simpa [hemisphere, signedCoordinate] using h⟩

theorem hemisphere_inter_eq_slice (s : Finset (Bool × Fin n)) :
    (⋂ i ∈ s, hemisphere n i) =
      sphereSlice (positiveCone (signedCoordinate n) (s : Set (Bool × Fin n))) := by
  ext x
  simp [sphereSlice, positiveCone, hemisphere]

def sphereGoodCover : GoodCover (Bool × Fin n)
    (Metric.sphere (0 : EuclideanSpace ℝ (Fin n)) 1) where
  carrier := hemisphere n
  isOpen := isOpen_hemisphere n
  covers := hemisphere_covers n
  contractible s hs hne := by
    rw [hemisphere_inter_eq_slice] at hne ⊢
    exact contractible_positiveSphere _ _ hs hne

end Coordinates

def clockSphereGoodCover : GoodCover ((Bool × Fin 2) × (Bool × Fin 3))
    (StandardClock × StandardSphere2) :=
  (sphereGoodCover 2).prod (sphereGoodCover 3)

def counterexampleGoodCover (q : ℕ) :
    GoodCover ((Bool × Fin 2) × (Fin (q + 1) → Bool × Fin 3))
      (CounterexampleManifold q) :=
  (sphereGoodCover 2).prod (GoodCover.pi fun _ : Fin (q + 1) => sphereGoodCover 3)

theorem card_counterexampleGoodCover_index (q : ℕ) :
    Fintype.card ((Bool × Fin 2) × (Fin (q + 1) → Bool × Fin 3)) =
      4 * 6 ^ (q + 1) := by
  simp [Fintype.card_prod]

end CoordinateGoodCover
end Problem340

end

end OAI