lean/OAI/LinearAlgebra/MatrixMultiplication/Entropy/ComplexAnalyticValue.lean

import Mathlib.Analysis.Convex.Function
import Mathlib.Analysis.Convex.Topology
import Mathlib.Algebra.BigOperators.Field
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Topology.Order.Monotone
import Mathlib.Topology.Semicontinuity.Basic
import Mathlib.Topology.Instances.Real.Lemmas
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring

namespace OAI

/-! Finite entropy, rate estimates and ordered asymptotic limits. -/

noncomputable section

open Set Filter
open scoped Topology BigOperators

namespace MatrixMultiplication.Foundation

theorem unitInterval_subset_closure_rat :
    Icc (0 : ℝ) 1 ⊆ closure (((↑) : ℚ → ℝ) '' Icc 0 1) := by
  have hinterior : Ioo (0 : ℝ) 1 ⊆ closure (((↑) : ℚ → ℝ) '' Icc 0 1) := by
    intro x hx
    rw [mem_closure_iff]
    intro U hU hxU
    obtain ⟨z, hz, hzrat⟩ := Rat.denseRange_cast.inter_open_nonempty
      (U ∩ Ioo (0 : ℝ) 1) (hU.inter isOpen_Ioo) ⟨x, hxU, hx⟩
    obtain ⟨q, rfl⟩ := hzrat
    refine ⟨(q : ℝ), hz.1, q, ?_, rfl⟩
    constructor
    · exact Rat.cast_nonneg.mp hz.2.1.le
    · exact Rat.cast_le.mp (by simpa using hz.2.2.le)
  have hclosed := closure_minimal hinterior isClosed_closure
  simpa only [closure_Ioo (show (0 : ℝ) ≠ 1 by norm_num)] using hclosed

structure FiniteConstructionRates where
  occurrences : ℕ
  multiplicity : ℕ
  auxiliaryRank : ℕ
  volume : ℕ
  occurrences_pos : 0 < occurrences
  multiplicity_pos : 0 < multiplicity
  auxiliaryRank_pos : 0 < auxiliaryRank
  volume_pos : 0 < volume

def FiniteConstructionRates.score (r : FiniteConstructionRates) (β : ℝ) : ℝ :=
  (Real.log r.multiplicity - Real.log r.auxiliaryRank +
    (β / 3) * Real.log r.volume) / r.occurrences

structure AttainableFamily (C X : Type*) where
  law : C → X
  score : C → ℝ

def finiteConstructionFamily {C X : Type*} (β : ℝ) (law : C → X)
    (rates : C → FiniteConstructionRates) : AttainableFamily C X :=
  ⟨law, fun c => (rates c).score β⟩

namespace AttainableFamily

variable {C X : Type*} [TopologicalSpace X] (A : AttainableFamily C X)

def pairs : Set (X × ℝ) :=
  {p | ∃ c, A.law c = p.1 ∧ p.2 ≤ A.score c}

def closedPairs : Set (X × ℝ) := closure A.pairs

def fiber (x : X) : Set ℝ := {t | (x, t) ∈ A.closedPairs}

def value (x : X) : ℝ := sSup (A.fiber x)

theorem finite_mem_closedPairs (c : C) : (A.law c, A.score c) ∈ A.closedPairs :=
  subset_closure ⟨c, rfl, le_rfl⟩

theorem closedPairs_law_mem_of_isClosed {s : Set X} (hs : IsClosed s)
    (hlaw : ∀ c, A.law c ∈ s) : ∀ p ∈ A.closedPairs, p.1 ∈ s := by
  apply closure_minimal
  · rintro p ⟨c, hc, _⟩
    change p.1 ∈ s
    rw [← hc]
    exact hlaw c
  · exact hs.preimage continuous_fst

theorem closedPairs_downward {x : X} {u v : ℝ}
    (hu : (x, u) ∈ A.closedPairs) (hvu : v ≤ u) :
    (x, v) ∈ A.closedPairs := by
  let T : X × ℝ → X × ℝ := fun p => (p.1, p.2 - (u - v))
  have hT : Continuous T :=
    continuous_fst.prodMk (continuous_snd.sub continuous_const)
  have himage : T '' A.pairs ⊆ A.pairs := by
    rintro _ ⟨p, ⟨c, hc, hscore⟩, rfl⟩
    exact ⟨c, hc, by dsimp [T]; linarith⟩
  have hmem : T (x, u) ∈ closure (T '' A.pairs) :=
    image_closure_subset_closure_image hT ⟨(x, u), hu, rfl⟩
  have := closure_mono himage hmem
  simpa [T, closedPairs] using this

theorem isClosed_fiber (x : X) : IsClosed (A.fiber x) :=
  isClosed_closure.preimage (continuous_const.prodMk continuous_id)

theorem value_mem_closedPairs (x : X) (hne : (A.fiber x).Nonempty)
    (hbound : BddAbove (A.fiber x)) : (x, A.value x) ∈ A.closedPairs :=
  (A.isClosed_fiber x).csSup_mem hne hbound

theorem mem_closedPairs_iff_le_value (x : X) (hne : (A.fiber x).Nonempty)
    (hbound : BddAbove (A.fiber x)) (t : ℝ) :
    (x, t) ∈ A.closedPairs ↔ t ≤ A.value x := by
  constructor
  · exact fun ht => le_csSup hbound ht
  · exact fun ht => A.closedPairs_downward (A.value_mem_closedPairs x hne hbound) ht

theorem closedPairs_le_continuous_cap (H : X → ℝ) (hH : Continuous H)
    (hcap : ∀ c, A.score c ≤ H (A.law c)) :
    ∀ p ∈ A.closedPairs, p.2 ≤ H p.1 := by
  apply closure_minimal
  · rintro p ⟨c, hc, ht⟩
    exact ht.trans (hc ▸ hcap c)
  · exact isClosed_le continuous_snd (hH.comp continuous_fst)

theorem value_le_continuous_cap (H : X → ℝ) (hH : Continuous H)
    (hcap : ∀ c, A.score c ≤ H (A.law c)) (x : X)
    (hne : (A.fiber x).Nonempty) : A.value x ≤ H x :=
  csSup_le hne (fun _ ht => A.closedPairs_le_continuous_cap H hH hcap _ ht)

theorem value_nonneg (x : X) (hzero : (x, 0) ∈ A.closedPairs)
    (hbound : BddAbove (A.fiber x)) : 0 ≤ A.value x :=
  le_csSup hbound hzero

theorem upperSemicontinuous_value
    (hne : ∀ x, (A.fiber x).Nonempty) (hbound : ∀ x, BddAbove (A.fiber x)) :
    UpperSemicontinuous A.value := by
  intro x b hb
  have hnot : (x, b) ∉ A.closedPairs := by
    intro hmem
    exact (not_le_of_gt hb)
      ((A.mem_closedPairs_iff_le_value x (hne x) (hbound x) b).mp hmem)
  have hclosed : IsClosed {y : X | (y, b) ∈ A.closedPairs} :=
    isClosed_closure.preimage (continuous_id.prodMk continuous_const)
  have hnear : ∀ᶠ y in 𝓝 x, (y, b) ∉ A.closedPairs :=
    hclosed.isOpen_compl.mem_nhds hnot
  filter_upwards [hnear] with y hy
  exact lt_of_not_ge (fun hle =>
    hy ((A.mem_closedPairs_iff_le_value y (hne y) (hbound y) b).mpr hle))

theorem upperSemicontinuous_value_comp {Y : Type*} [TopologicalSpace Y]
    (α : Y → X) (hα : Continuous α)
    (hne : ∀ y, (A.fiber (α y)).Nonempty)
    (hbound : ∀ y, BddAbove (A.fiber (α y))) :
    UpperSemicontinuous (fun y => A.value (α y)) := by
  intro y b hb
  have hnot : (α y, b) ∉ A.closedPairs := by
    intro hmem
    exact (not_le_of_gt hb)
      ((A.mem_closedPairs_iff_le_value (α y) (hne y) (hbound y) b).mp hmem)
  have hclosed : IsClosed {z : Y | (α z, b) ∈ A.closedPairs} :=
    isClosed_closure.preimage (hα.prodMk continuous_const)
  have hnear : ∀ᶠ z in 𝓝 y, (α z, b) ∉ A.closedPairs :=
    hclosed.isOpen_compl.mem_nhds hnot
  filter_upwards [hnear] with z hz
  exact lt_of_not_ge (fun hle =>
    hz ((A.mem_closedPairs_iff_le_value (α z) (hne z) (hbound z) b).mpr hle))

theorem exists_finite_in_open_gt {x : X} {b : ℝ} (hne : (A.fiber x).Nonempty)
    (hb : b < A.value x) {U : Set X} (hU : IsOpen U) (hx : x ∈ U) :
    ∃ c, A.law c ∈ U ∧ b < A.score c := by
  obtain ⟨t, ht, hbt⟩ := exists_lt_of_lt_csSup hne hb
  have hopen : IsOpen (U ×ˢ Ioi b) := hU.prod isOpen_Ioi
  obtain ⟨p, hpU, hpA⟩ := mem_closure_iff.mp ht (U ×ˢ Ioi b) hopen ⟨hx, hbt⟩
  obtain ⟨c, hc, hscore⟩ := hpA
  refine ⟨c, hc.symm ▸ hpU.1, lt_of_lt_of_le hpU.2 hscore⟩

theorem exists_finite_gt {x : X} {b : ℝ} (hne : (A.fiber x).Nonempty)
    (hb : b < A.value x) : ∃ c, b < A.score c := by
  obtain ⟨c, _, hc⟩ := A.exists_finite_in_open_gt hne hb isOpen_univ (mem_univ x)
  exact ⟨c, hc⟩

section Concavity

variable [AddCommGroup X] [Module ℝ X]

theorem concaveOn_value (s : Set X) (hs : Convex ℝ s)
    (hne : ∀ x ∈ s, (A.fiber x).Nonempty)
    (hbound : ∀ x ∈ s, BddAbove (A.fiber x))
    (hmix : Convex ℝ A.closedPairs) : ConcaveOn ℝ s A.value := by
  refine ⟨hs, ?_⟩
  intro x hx y hy a b ha hb hab
  have hpair := hmix (A.value_mem_closedPairs x (hne x hx) (hbound x hx))
    (A.value_mem_closedPairs y (hne y hy) (hbound y hy)) ha hb hab
  exact le_csSup (hbound _ (hs hx hy ha hb hab)) hpair

end Concavity

section RationalMixtures

variable [AddCommGroup X] [Module ℝ X] [ContinuousAdd X] [ContinuousSMul ℝ X]

theorem closedPairs_convex_of_rational_mixing
    (hmix : ∀ c d : C, ∀ q : ℚ, q ∈ Icc 0 1 →
      (q : ℝ) • (A.law c, A.score c) +
        (1 - (q : ℝ)) • (A.law d, A.score d) ∈ A.pairs) :
    Convex ℝ A.closedPairs := by
  have hfull : ∀ c d : C, ∀ t : ℝ, t ∈ Icc 0 1 →
      t • (A.law c, A.score c) + (1 - t) • (A.law d, A.score d) ∈
        A.closedPairs := by
    intro c d t ht
    let T : ℝ → X × ℝ := fun u =>
      u • (A.law c, A.score c) + (1 - u) • (A.law d, A.score d)
    have hT : Continuous T :=
      (continuous_id.smul continuous_const).add
        ((continuous_const.sub continuous_id).smul continuous_const)
    have himage : T '' (((↑) : ℚ → ℝ) '' Icc 0 1) ⊆ A.pairs := by
      rintro _ ⟨_, ⟨q, hq, rfl⟩, rfl⟩
      exact hmix c d q hq
    exact closure_mono himage
      (image_closure_subset_closure_image hT ⟨t, unitInterval_subset_closure_rat ht, rfl⟩)
  intro x hx y hy a b ha hb hab
  have hb_eq : b = 1 - a := by linarith
  subst b
  have ha1 : a ≤ 1 := by linarith
  let T : (X × ℝ) → (X × ℝ) → X × ℝ := fun p q => a • p + (1 - a) • q
  have hT : Continuous (Function.uncurry T) := by
    change Continuous (fun p : (X × ℝ) × (X × ℝ) => a • p.1 + (1 - a) • p.2)
    have hfst : Continuous (fun p : (X × ℝ) × (X × ℝ) => a • p.1) :=
      continuous_fst.const_smul a
    have hsnd : Continuous (fun p : (X × ℝ) × (X × ℝ) => (1 - a) • p.2) :=
      continuous_snd.const_smul (1 - a)
    exact hfst.add hsnd
  have hseed : ∀ p ∈ A.pairs, ∀ q ∈ A.pairs, T p q ∈ A.closedPairs := by
    rintro p ⟨c, hc, hp⟩ q ⟨d, hd, hq⟩
    have h := hfull c d a ⟨ha, ha1⟩
    have hlaw : a • A.law c + (1 - a) • A.law d =
        a • p.1 + (1 - a) • q.1 := by rw [hc, hd]
    have hscore : a * p.2 + (1 - a) * q.2 ≤
        a * A.score c + (1 - a) * A.score d :=
      add_le_add (mul_le_mul_of_nonneg_left hp ha)
        (mul_le_mul_of_nonneg_left hq hb)
    change (a • A.law c + (1 - a) • A.law d,
      a * A.score c + (1 - a) * A.score d) ∈ A.closedPairs at h
    rw [hlaw] at h
    exact A.closedPairs_downward h hscore
  have hresult : T x y ∈ closure A.closedPairs := map_mem_closure₂ hT hx hy hseed
  simpa only [closedPairs, closure_closure] using hresult

end RationalMixtures
end AttainableFamily

private abbrev realSimplex (ι : Type*) [Fintype ι] : Set (ι → ℝ) :=
  {weights | (∀ index, 0 ≤ weights index) ∧ ∑ index, weights index = 1}

private theorem convex_realSimplex (ι : Type*) [Fintype ι] :
    Convex ℝ (realSimplex ι) := by
  intro left hleft right hright leftWeight rightWeight hleftWeight hrightWeight hsum
  refine ⟨fun index => add_nonneg (mul_nonneg hleftWeight (hleft.1 index))
    (mul_nonneg hrightWeight (hright.1 index)), ?_⟩
  simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Finset.sum_add_distrib,
    ← Finset.mul_sum, hleft.2, hright.2, mul_one, hsum]

theorem simplex_residual {ι : Type*} [Fintype ι] {x y : ι → ℝ}
    (hx : x ∈ realSimplex ι) (hy : y ∈ realSimplex ι)
    {ε : ℝ} (hε : 0 < ε) (hdom : ∀ i, (1 - ε) * x i ≤ y i) :
    (fun i => (y i - (1 - ε) * x i) / ε) ∈ realSimplex ι := by
  refine ⟨fun i => div_nonneg (sub_nonneg.mpr (hdom i)) hε.le, ?_⟩
  rw [← Finset.sum_div, Finset.sum_sub_distrib, ← Finset.mul_sum, hx.2, hy.2]
  field_simp [ne_of_gt hε]
  ring

theorem concave_simplex_domination {ι : Type*} [Fintype ι] {F : (ι → ℝ) → ℝ}
    (hF : ConcaveOn ℝ (realSimplex ι) F)
    (hzero : ∀ x ∈ realSimplex ι, 0 ≤ F x)
    {x y : ι → ℝ} (hx : x ∈ realSimplex ι) (hy : y ∈ realSimplex ι)
    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1)
    (hdom : ∀ i, (1 - ε) * x i ≤ y i) : (1 - ε) * F x ≤ F y := by
  let r : ι → ℝ := fun i => (y i - (1 - ε) * x i) / ε
  have hr : r ∈ realSimplex ι := simplex_residual hx hy hε hdom
  have hmix : (1 - ε) • x + ε • r = y := by
    funext i
    dsimp [r]
    field_simp [ne_of_gt hε]
    ring
  have hconc := hF.2 hx hr (sub_nonneg.mpr hε1) hε.le (by ring)
  rw [hmix] at hconc
  change (1 - ε) * F x + ε * F r ≤ F y at hconc
  exact le_trans (le_add_of_nonneg_right (mul_nonneg hε.le (hzero r hr))) hconc

theorem lowerSemicontinuousOn_nonneg_concave_simplex {ι : Type*} [Fintype ι]
    {F : (ι → ℝ) → ℝ} (hF : ConcaveOn ℝ (realSimplex ι) F)
    (hzero : ∀ x ∈ realSimplex ι, 0 ≤ F x) :
    LowerSemicontinuousOn F (realSimplex ι) := by
  intro x hx b hb
  by_cases hb0 : b < 0
  · filter_upwards [self_mem_nhdsWithin] with y hy
    exact lt_of_lt_of_le hb0 (hzero y hy)
  have hbnonneg : 0 ≤ b := le_of_not_gt hb0
  have hxpos : 0 < F x := lt_of_le_of_lt hbnonneg hb
  let ε : ℝ := (F x - b) / (2 * F x)
  have hden : 0 < 2 * F x := mul_pos (by norm_num) hxpos
  have hε : 0 < ε := div_pos (sub_pos.mpr hb) hden
  have hε1 : ε ≤ 1 := by
    apply (div_le_iff₀ hden).2
    linarith
  have hεeq : ε * (2 * F x) = F x - b := div_mul_cancel₀ _ (ne_of_gt hden)
  have hgap : b < (1 - ε) * F x := by nlinarith
  have hdom : ∀ᶠ y in 𝓝[realSimplex ι] x, ∀ i, (1 - ε) * x i ≤ y i := by
    apply Filter.eventually_all.2
    intro i
    by_cases hxi : x i = 0
    · filter_upwards [self_mem_nhdsWithin] with y hy
      simpa [hxi] using hy.1 i
    have hxipos : 0 < x i := lt_of_le_of_ne (hx.1 i) (Ne.symm hxi)
    have hlt : (1 - ε) * x i < x i := by nlinarith
    have hev : ∀ᶠ y : ι → ℝ in 𝓝 x, (1 - ε) * x i < y i :=
      (continuous_apply i).continuousAt.eventually (lt_mem_nhds hlt)
    exact (hev.filter_mono nhdsWithin_le_nhds).mono (fun _ h => h.le)
  filter_upwards [self_mem_nhdsWithin, hdom] with y hy hdomy
  exact lt_of_lt_of_le hgap (concave_simplex_domination hF hzero hx hy hε hε1 hdomy)

theorem lowerSemicontinuous_comp_of_mem {X Y : Type*} [TopologicalSpace X]
    [TopologicalSpace Y] {s : Set X} {F : X → ℝ}
    (hF : LowerSemicontinuousOn F s) (α : Y → X) (hα : Continuous α)
    (hmem : ∀ y, α y ∈ s) : LowerSemicontinuous (fun y => F (α y)) := by
  intro y b hb
  have ht : Tendsto α (𝓝 y) (𝓝[s] α y) :=
    tendsto_nhdsWithin_iff.mpr ⟨hα.continuousAt, Eventually.of_forall hmem⟩
  exact ht.eventually (hF (α y) (hmem y) b hb)

theorem AttainableFamily.continuous_value_on_simplex_chart {C Y ι : Type*}
    [TopologicalSpace Y] [Fintype ι] (A : AttainableFamily C (ι → ℝ))
    (hzero : ∀ x ∈ realSimplex ι, (x, 0) ∈ A.closedPairs)
    (hbound : ∀ x ∈ realSimplex ι, BddAbove (A.fiber x))
    (hmix : Convex ℝ A.closedPairs)
    (α : Y → (ι → ℝ)) (hα : Continuous α)
    (hmem : ∀ y, α y ∈ realSimplex ι) :
    Continuous (fun y => A.value (α y)) := by
  have hne : ∀ x ∈ realSimplex ι, (A.fiber x).Nonempty :=
    fun x hx => ⟨0, hzero x hx⟩
  have hconc := A.concaveOn_value _ (convex_realSimplex ι) hne hbound hmix
  have hnonneg : ∀ x ∈ realSimplex ι, 0 ≤ A.value x :=
    fun x hx => A.value_nonneg x (hzero x hx) (hbound x hx)
  exact continuous_iff_lower_upperSemicontinuous.mpr
    ⟨lowerSemicontinuous_comp_of_mem
      (lowerSemicontinuousOn_nonneg_concave_simplex hconc hnonneg) α hα hmem,
      A.upperSemicontinuous_value_comp α hα
        (fun y => hne _ (hmem y)) (fun y => hbound _ (hmem y))⟩

end MatrixMultiplication.Foundation

end

end OAI