lean/OAI/Geometry/Borsuk/Projectors/Basic.lean

import Mathlib
import OAI.Geometry.Borsuk.Model

namespace OAI

namespace BorsukNine

open scoped RealInnerProductSpace ContDiff

@[simp] theorem projector_apply (u : Vector4) (i j : Fin 4) :
    projector u (i, j) = u i * u j := rfl

@[simp] theorem projector_neg (u : Vector4) : projector (-u) = projector u := by
  ext ⟨i, j⟩
  simp [projector]

theorem continuous_projector : Continuous projector := by
  apply (PiLp.continuous_toLp 2 _).comp
  apply continuous_pi
  intro ij
  exact (PiLp.continuous_apply 2 _ ij.1).mul (PiLp.continuous_apply 2 _ ij.2)

theorem isCompact_projectorSet : IsCompact projectorSet := by
  have h : {u : Vector4 | ‖u‖ = 1} = Metric.sphere 0 1 := by
    ext u
    simp
  rw [projectorSet, h]
  exact (isCompact_sphere (0 : Vector4) 1).image continuous_projector

theorem projector_inner (u v : Vector4) :
    ⟪projector u, projector v⟫ = ⟪u, v⟫ ^ 2 := by
  simp only [PiLp.inner_apply, RCLike.inner_apply, conj_trivial, projector]
  change (∑ ij : Fin 4 × Fin 4, (v ij.1 * v ij.2) * (u ij.1 * u ij.2)) =
    (∑ i : Fin 4, v i * u i) ^ 2
  rw [Fintype.sum_prod_type]
  simp only [pow_two, Finset.sum_mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring

theorem projector_norm_sq (u : Vector4) : ‖projector u‖ ^ 2 = ‖u‖ ^ 4 := by
  rw [← real_inner_self_eq_norm_sq, projector_inner, real_inner_self_eq_norm_sq]
  ring

theorem projectorSet_subset_traceOneSymmetric : projectorSet ⊆ traceOneSymmetric := by
  rintro _ ⟨u, hu, rfl⟩
  constructor
  · intro i j
    simp [mul_comm]
  · have he : (∑ i : Fin 4, u i * u i) = ‖u‖ ^ 2 := by
      exact (EuclideanSpace.inner_eq_star_dotProduct u u).symm.trans
        (real_inner_self_eq_norm_sq u)
    change ‖u‖ = 1 at hu
    simp only [projector_apply, he, hu, one_pow]

theorem projector_dist_sq (u v : Vector4) (hu : ‖u‖ = 1) (hv : ‖v‖ = 1) :
    dist (projector u) (projector v) ^ 2 = 2 - 2 * ⟪u, v⟫ ^ 2 := by
  rw [dist_eq_norm, norm_sub_sq_real, projector_norm_sq, projector_norm_sq,
    projector_inner, hu, hv]
  ring

theorem projector_dist_le (u v : Vector4) (hu : ‖u‖ = 1) (hv : ‖v‖ = 1) :
    dist (projector u) (projector v) ≤ Real.sqrt 2 := by
  have hd := projector_dist_sq u v hu hv
  have hs := Real.sq_sqrt (show (0 : ℝ) ≤ 2 by norm_num)
  have hp := Real.sqrt_nonneg (2 : ℝ)
  nlinarith [sq_nonneg ⟪u, v⟫, dist_nonneg (x := projector u) (y := projector v)]

theorem projector_dist_eq_sqrt_two_iff (u v : Vector4)
    (hu : ‖u‖ = 1) (hv : ‖v‖ = 1) :
    dist (projector u) (projector v) = Real.sqrt 2 ↔ ⟪u, v⟫ = 0 := by
  have hd := projector_dist_sq u v hu hv
  have hs := Real.sq_sqrt (show (0 : ℝ) ≤ 2 by norm_num)
  constructor
  · intro h
    rw [h] at hd
    nlinarith [sq_nonneg ⟪u, v⟫]
  · intro h
    rw [h] at hd
    have hn := dist_nonneg (x := projector u) (y := projector v)
    have hp := Real.sqrt_nonneg (2 : ℝ)
    nlinarith

theorem diam_projectorSet : Metric.diam projectorSet = Real.sqrt 2 := by
  apply le_antisymm
  · apply Metric.diam_le_of_forall_dist_le (Real.sqrt_nonneg 2)
    rintro _ ⟨u, hu, rfl⟩ _ ⟨v, hv, rfl⟩
    exact projector_dist_le u v hu hv
  · let u : Vector4 := EuclideanSpace.single 0 1
    let v : Vector4 := EuclideanSpace.single 1 1
    have hu : ‖u‖ = 1 := by simp [u]
    have hv : ‖v‖ = 1 := by simp [v]
    have huv : ⟪u, v⟫ = 0 := by simp [u, v, EuclideanSpace.inner_single_left]
    have hd := (projector_dist_eq_sqrt_two_iff u v hu hv).mpr huv
    rw [← hd]
    exact Metric.dist_le_diam_of_mem isCompact_projectorSet.isBounded
      ⟨u, hu, rfl⟩ ⟨v, hv, rfl⟩

structure Admissible {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
    {ι : Type*} [Fintype ι] (f : V → ι → ℝ) : Prop where
  smooth : ∀ i, ContDiff ℝ ∞ (fun u => f u i)
  antipodal : ∀ u i, f (-u) i = f u i
  nonneg : ∀ u, ‖u‖ = 1 → ∀ i, 0 ≤ f u i
  sum_one : ∀ u, ‖u‖ = 1 → ∑ i, f u i = 1
  orthogonal : ∀ u v, ‖u‖ = 1 → ‖v‖ = 1 → ⟪u, v⟫ = 0 →
    ∀ i, ¬ (0 < f u i ∧ 0 < f v i)

theorem contDiff_projector : ContDiff ℝ ∞ projector := by
  apply (contDiff_piLp 2).mpr
  intro ij
  exact (contDiff_piLp_apply (p := 2) (i := ij.1)).mul (contDiff_piLp_apply (p := 2) (i := ij.2))

theorem dist_lt_of_mem_thickening_small {C : Set Matrix4}
    (hC : C ⊆ projectorSet) (hd : Metric.diam C < Real.sqrt 2)
    {P Q : Matrix4}
    (hP : P ∈ Metric.thickening ((Real.sqrt 2 - Metric.diam C) / 4) C)
    (hQ : Q ∈ Metric.thickening ((Real.sqrt 2 - Metric.diam C) / 4) C) :
    dist P Q < Real.sqrt 2 := by
  rcases Metric.mem_thickening_iff.mp hP with ⟨p, hp, hPp⟩
  rcases Metric.mem_thickening_iff.mp hQ with ⟨q, hq, hQq⟩
  have hb := isCompact_projectorSet.isBounded.subset hC
  have hpq := Metric.dist_le_diam_of_mem hb hp hq
  have ht : dist P Q ≤ dist P p + dist p q + dist Q q := by
    calc
      dist P Q ≤ dist P p + dist p Q := dist_triangle P p Q
      _ ≤ dist P p + (dist p q + dist q Q) :=
        add_le_add le_rfl (dist_triangle p q Q)
      _ = dist P p + dist p q + dist Q q := by rw [dist_comm q Q]; ring
  linarith

open scoped Manifold

theorem cover_to_admissible (h : HasTenSmallCover) :
    ∃ f : Vector4 → Fin 10 → ℝ, Admissible f := by
  classical
  rcases h with ⟨C, hCX, hcov, hdiam⟩
  let U : Fin 10 → Set Matrix4 := fun i =>
    Metric.thickening ((Real.sqrt 2 - Metric.diam (C i)) / 4) (C i)
  have hU : ∀ i, IsOpen (U i) := fun _ => Metric.isOpen_thickening
  have hCU : ∀ i, C i ⊆ U i := by
    intro i
    apply Metric.self_subset_thickening
    linarith [hdiam i]
  have hXU : projectorSet ⊆ ⋃ i, U i := by
    intro P hP
    rcases Set.mem_iUnion.mp (hcov hP) with ⟨i, hi⟩
    exact Set.mem_iUnion.mpr ⟨i, hCU i hi⟩
  obtain ⟨ρ, hρ⟩ := SmoothPartitionOfUnity.exists_isSubordinate
    (I := 𝓘(ℝ, Matrix4)) isCompact_projectorSet.isClosed U hU hXU
  refine ⟨fun u i => ρ i (projector u), ?_⟩
  constructor
  · intro i
    exact (contMDiff_iff_contDiff.mp (ρ i).contMDiff).comp contDiff_projector
  · intro u i
    simp
  · intro u _ i
    exact ρ.nonneg i (projector u)
  · intro u hu
    simpa only [finsum_eq_sum_of_fintype] using ρ.sum_eq_one (show projector u ∈ projectorSet
      from ⟨u, hu, rfl⟩)
  · intro u v hu hv huv i ⟨hui, hvi⟩
    have huU : projector u ∈ U i := hρ i (subset_tsupport _ (ne_of_gt hui))
    have hvU : projector v ∈ U i := hρ i (subset_tsupport _ (ne_of_gt hvi))
    have hd := dist_lt_of_mem_thickening_small (hCX i) (hdiam i) huU hvU
    rw [(projector_dist_eq_sqrt_two_iff u v hu hv).mpr huv] at hd
    exact lt_irrefl _ hd

theorem compact_diam_lt {C : Set Matrix4} (hC : IsCompact C) {d : ℝ}
    (hd : 0 < d) (hpair : ∀ x ∈ C, ∀ y ∈ C, dist x y < d) :
    Metric.diam C < d := by
  rcases C.eq_empty_or_nonempty with rfl | hne
  · simpa using hd
  · obtain ⟨⟨x, y⟩, hxy, hmax⟩ := (hC.prod hC).exists_isMaxOn (hne.prod hne)
      (continuous_fst.dist continuous_snd).continuousOn
    have hbound : Metric.diam C ≤ dist x y := by
      apply Metric.diam_le_of_forall_dist_le dist_nonneg
      intro a ha b hb
      exact (isMaxOn_iff.mp hmax) (a, b) ⟨ha, hb⟩
    exact hbound.trans_lt (hpair x hxy.1 y hxy.2)

theorem admissible_to_cover {f : Vector4 → Fin 10 → ℝ} (hf : Admissible f) :
    HasTenSmallCover := by
  classical
  let L : Fin 10 → Set Vector4 := fun i =>
    {u | ‖u‖ = 1} ∩ {u | (1 : ℝ) / 10 ≤ f u i}
  let C : Fin 10 → Set Matrix4 := fun i => projector '' L i
  have hLcompact : ∀ i, IsCompact (L i) := by
    intro i
    have hsphere : IsCompact {u : Vector4 | ‖u‖ = 1} := by
      have he : {u : Vector4 | ‖u‖ = 1} = Metric.sphere 0 1 := by
        ext u
        simp
      rw [he]
      exact isCompact_sphere (0 : Vector4) 1
    exact hsphere.inter_right (isClosed_le continuous_const (hf.smooth i).continuous)
  have hCcompact : ∀ i, IsCompact (C i) := fun i =>
    (hLcompact i).image continuous_projector
  refine ⟨C, ?_, ?_, ?_⟩
  · intro i P hP
    rcases hP with ⟨u, hu, rfl⟩
    exact ⟨u, hu.1, rfl⟩
  · rintro P ⟨u, hu, rfl⟩
    have hsum : (∑ _i : Fin 10, (1 : ℝ) / 10) ≤ ∑ i, f u i := by
      rw [hf.sum_one u hu]
      norm_num
    obtain ⟨i, _, hi⟩ := Finset.exists_le_of_sum_le Finset.univ_nonempty hsum
    exact Set.mem_iUnion.mpr ⟨i, u, ⟨hu, hi⟩, rfl⟩
  · intro i
    apply compact_diam_lt (hCcompact i) (Real.sqrt_pos.mpr (by norm_num))
    rintro _ ⟨u, hu, rfl⟩ _ ⟨v, hv, rfl⟩
    by_contra h
    have heq : dist (projector u) (projector v) = Real.sqrt 2 :=
      le_antisymm (projector_dist_le u v hu.1 hv.1) (le_of_not_gt h)
    have huv := (projector_dist_eq_sqrt_two_iff u v hu.1 hv.1).mp heq
    exact hf.orthogonal u v hu.1 hv.1 huv i
      ⟨lt_of_lt_of_le (by norm_num) hu.2, lt_of_lt_of_le (by norm_num) hv.2⟩

theorem cover_iff_admissible : HasTenSmallCover ↔
    ∃ f : Vector4 → Fin 10 → ℝ, Admissible f :=
  ⟨cover_to_admissible, fun ⟨_, hf⟩ => admissible_to_cover hf⟩

theorem exists_unit_orthogonal {n : ℕ} (hn : n < 4) (v : Fin n → Vector4) :
    ∃ w : Vector4, ‖w‖ = 1 ∧ ∀ i, ⟪v i, w⟫ = 0 := by
  classical
  let W : Submodule ℝ Vector4 := Submodule.span ℝ (Set.range v)
  have hW : W ≠ ⊤ := by
    intro he
    have hh := finrank_le_of_span_eq_top he
    have hd : Module.finrank ℝ Vector4 = 4 := by simp
    rw [hd, Fintype.card_fin] at hh
    omega
  have hO : Wᗮ ≠ ⊥ := by
    intro he
    exact hW (Submodule.orthogonal_eq_bot_iff.mp he)
  obtain ⟨w, hw, hwne⟩ := (Submodule.ne_bot_iff Wᗮ).mp hO
  refine ⟨(‖w‖⁻¹ : ℝ) • w, norm_smul_inv_norm hwne, ?_⟩
  intro i
  rw [inner_smul_right, Submodule.inner_right_of_mem_orthogonal
    (show v i ∈ W from Submodule.subset_span (Set.mem_range_self i)) hw, mul_zero]

noncomputable def positiveSupport {ι : Type*} [Fintype ι]
    {V : Type*} (f : V → ι → ℝ) (u : V) : Finset ι := by
  classical
  exact Finset.univ.filter (fun i => 0 < f u i)

@[simp] theorem mem_positiveSupport {ι : Type*} [Fintype ι]
    {V : Type*} (f : V → ι → ℝ) (u : V) (i : ι) :
    i ∈ positiveSupport f u ↔ 0 < f u i := by
  classical
  simp [positiveSupport]

lemma Admissible.support_nonempty {ι : Type*} [Fintype ι]
    {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
    {f : V → ι → ℝ} (hf : Admissible f) {u : V} (hu : ‖u‖ = 1) :
    (positiveSupport f u).Nonempty := by
  classical
  have hs : 0 < ∑ i, f u i := by rw [hf.sum_one u hu]; norm_num
  obtain ⟨i, _, hi⟩ := (Finset.sum_pos_iff_of_nonneg (fun i _ => hf.nonneg u hu i)).mp hs
  exact ⟨i, (mem_positiveSupport f u i).mpr hi⟩

lemma Admissible.disjoint_supports {ι : Type*} [Fintype ι]
    {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
    {f : V → ι → ℝ} (hf : Admissible f) {u v : V}
    (hu : ‖u‖ = 1) (hv : ‖v‖ = 1) (horth : ⟪u, v⟫ = 0) :
    Disjoint (positiveSupport f u) (positiveSupport f v) := by
  classical
  apply Finset.disjoint_left.mpr
  intro i hi hj
  exact hf.orthogonal u v hu hv horth i
    ⟨(mem_positiveSupport f u i).mp hi, (mem_positiveSupport f v i).mp hj⟩

theorem Admissible.exists_label_absent {ι : Type*} [Fintype ι]
    {f : Vector4 → ι → ℝ} (hf : Admissible f) {n : ℕ} (hn : n < 4)
    (v : Fin n → Vector4) (hv : ∀ j, ‖v j‖ = 1) :
    ∃ i, ∀ j, i ∉ positiveSupport f (v j) := by
  obtain ⟨w, hw, hvw⟩ := exists_unit_orthogonal hn v
  obtain ⟨i, hi⟩ := hf.support_nonempty hw
  refine ⟨i, ?_⟩
  intro j hj
  exact Finset.disjoint_left.mp (hf.disjoint_supports (hv j) hw (hvw j)) hj hi

end BorsukNine

end OAI