import Mathlib
import OAI.Probability.Perceptron.Variational.ShellBridge

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
namespace SphericalPerceptronFreeEnergy

def normalizedCoordinateSphereLog (n k : ℕ) (σ : ℕ → ℝ)
    (p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : ℝ :=
  coordinateAngularLog n k σ (Real.sqrt (n+1:ℕ)) ((fun i _ => p.1 i),p.2) / ((n+1:ℕ):ℝ)

def expectedCoordinateSphereLog (n k : ℕ) (σ : ℕ → ℝ) (z : Fin k → ℝ) (r : ℝ≥0) : ℝ :=
  ∫ p, normalizedCoordinateSphereLog n k σ p ∂coordinateCascadeLaw (n+1) k z r

lemma normalizedCoordinateSphereLog_measurable (n k : ℕ) (σ : ℕ → ℝ) :
    Measurable (normalizedCoordinateSphereLog n k σ) := by
  have hm := (coordinateAngularLog_measurable n k σ (Real.sqrt (n+1:ℕ))).comp
    (show Measurable (fun p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k =>
      ((fun (i : Fin (n+1)) (_ : ℕ) => p.1 i),p.2)) from by fun_prop)
  exact hm.div_const _

lemma normalizedCoordinateSphereLog_integrable (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ}
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0) :
    Integrable (normalizedCoordinateSphereLog n k σ) (coordinateCascadeLaw (n+1) k z r) :=
  (coordinateAngularLog_integrable n k σ (Real.sqrt (n+1:ℕ)) z hz hz0 hz1 hp r).div_const _

lemma normalizedCoordinateSphereLog_nonneg (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ}
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0) :
    0 ≤ᵐ[coordinateCascadeLaw (n+1) k z r] normalizedCoordinateSphereLog n k σ := by
  have hb : 0 < b := hp.trans_le (quadraticCascadePrecision_le σ b k z (fun i => (hz0 i).le))
  filter_upwards [canonicalCoordinateBase_pos (n+1) k σ z hz hz0 hz1 r,
    canonicalCoordinateTotal_pos (n+1) k σ b z hz hz0 hz1 hp r] with p h0 hc
  exact div_nonneg (coordinateAngularLog_regular n k σ _ hb _ h0 hc).2.1 (by positivity)

lemma expectedCoordinateSphereLog_upper (n k : ℕ) (σ : ℕ → ℝ) {b ε : ℝ}
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0)
    (hε : 0 ≤ ε) (hε1 : ε ≤ 1)
    (hm : 0 < (canonicalRadialMass n b).real (normSquareBand n ε)) :
    expectedCoordinateSphereLog n k σ z r ≤
      (1+ε)*canonicalGaussianFreeValue σ k z r b-
        Real.log ((canonicalRadialMass n b).real (normSquareBand n ε))/((n+1:ℕ):ℝ)+
          ε*(Real.log b/2+2*b) := by
  let μ := coordinateCascadeLaw (n+1) k z r
  let C := fun p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k =>
    canonicalCoordinateLog (n+1) k σ b ((fun i _ => p.1 i),p.2)
  let M := Real.log ((canonicalRadialMass n b).real (normSquareBand n ε))
  let d : ℝ := n+1
  have hd : 0 < d := by dsimp [d]; positivity
  have hb : 0 < b := hp.trans_le (quadraticCascadePrecision_le σ b k z (fun i => (hz0 i).le))
  have hi : Integrable C μ := (canonical_coordinate_joint_mean (n+1) σ b k z hz hz0 hz1 hp r).1
  have he : (∫ p, C p ∂μ) = d*canonicalGaussianFreeValue σ k z r b := by
    simpa [d,C,μ,coordinateCascadeLaw] using (canonical_coordinate_joint_mean (n+1) σ b k z hz hz0 hz1 hp r).2
  have hni := normalizedCoordinateSphereLog_integrable n k σ z hz hz0 hz1 hp r
  have hbi : Integrable (fun p => (1+ε)*C p/d-M/d+ε*(Real.log b/2+2*b)) μ :=
    (((hi.const_mul (1+ε)).div_const d).sub (integrable_const _)).add (integrable_const _)
  have hlo : ∀ᵐ p ∂μ, normalizedCoordinateSphereLog n k σ p ≤
      (1+ε)*C p/d-M/d+ε*(Real.log b/2+2*b) := by
    filter_upwards [canonicalCoordinateBase_pos (n+1) k σ z hz hz0 hz1 r,
      canonicalCoordinateTotal_pos (n+1) k σ b z hz hz0 hz1 hp r] with p h0 hc
    have hraw := canonicalCoordinate_unitSphere_upper n k σ hb hε hε1 _ h0 hc hm
    have hh := div_le_div_of_nonneg_right hraw hd.le
    have heq : ((1+ε)*C p-M+ε*((n+1:ℕ):ℝ)*(Real.log b/2+2*b))/d =
        (1+ε)*C p/d-M/d+ε*(Real.log b/2+2*b) := by
      dsimp only [d]
      push_cast
      field_simp
    change coordinateAngularLog n k σ (Real.sqrt (n+1:ℕ)) ((fun i _ => p.1 i),p.2)/d ≤
      ((1+ε)*C p-M+ε*((n+1:ℕ):ℝ)*(Real.log b/2+2*b))/d at hh
    rw [heq] at hh
    simpa only [normalizedCoordinateSphereLog,d,Nat.cast_add,Nat.cast_one] using hh
  have hh := integral_mono_ae hni hbi hlo
  have hcalc : (∫ p, (1+ε)*C p/d-M/d+ε*(Real.log b/2+2*b) ∂μ) =
      (1+ε)*canonicalGaussianFreeValue σ k z r b-M/d+ε*(Real.log b/2+2*b) := by
    rw [integral_add (f := fun p => (1+ε)*C p/d-M/d)
      (g := fun _ => ε*(Real.log b/2+2*b))
      (((hi.const_mul (1+ε)).div_const d).sub (integrable_const (M/d)))
      (integrable_const (ε*(Real.log b/2+2*b))),
      integral_sub (f := fun p => (1+ε)*C p/d) (g := fun _ => M/d)
        ((hi.const_mul (1+ε)).div_const d) (integrable_const (M/d)),
      integral_div,integral_const_mul,he]
    simp only [integral_const,probReal_univ,one_smul]
    field_simp
  rw [hcalc] at hh
  simpa [expectedCoordinateSphereLog,M,d] using hh

lemma expectedCoordinateSphereLog_upper_eventually (k : ℕ) (σ : ℕ → ℝ) {b ε : ℝ}
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0) (hε : 0 < ε) (hε1 : ε < 1) :
    ∀ᶠ n : ℕ in atTop, expectedCoordinateSphereLog n k σ z r ≤
      canonicalGaussianFreeValue σ k z r b+(b-1)/2+
        ε*(canonicalGaussianFreeValue σ k z r b+Real.log b/2+2*b+|1-b|/2)+
          Real.log 2/((n+1:ℕ):ℝ) := by
  have hb : 0 < b := hp.trans_le (quadraticCascadePrecision_le σ b k z (fun i => (hz0 i).le))
  filter_upwards [canonicalRadial_band_eventually_half hε hε1] with n hn
  have hm := (canonicalRadial_band_mass_bounds n hb hn).1
  have hmp : 0 < (canonicalRadialMass n b).real (normSquareBand n ε) :=
    (by positivity : 0 < Real.exp (((n+1:ℕ):ℝ)*((1-b)/2-|1-b| * ε/2))/2).trans_le hm
  have hu := expectedCoordinateSphereLog_upper n k σ z hz hz0 hz1 hp r hε.le hε1.le hmp
  have hl := (canonicalRadial_band_log_bounds n hb hn).1
  linarith

lemma normalizedCoordinateSphereLog_lower_probability (k : ℕ) (σ : ℕ → ℝ)
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (r : ℝ≥0) (b : ℝ) (hp : 0 < quadraticCascadePrecision σ b k z)
    (hstat : -1/(2*b)+quadraticCascadeReciprocalSlope σ b k z-
      (r:ℝ)/(2*(quadraticCascadePrecision σ b k z)^2) = -1/2)
    {ε a : ℝ} (hε : 0 < ε) (hε1 : ε < 1)
    (ha : a < canonicalGaussianFreeValue σ k z r b+(b-1)/2-
      ε*(canonicalGaussianFreeValue σ k z r b+Real.log b/2+2*b+|1-b|/2)) :
    Tendsto (fun n : ℕ => (coordinateCascadeLaw (n+1) k z r).real
      {p | a ≤ normalizedCoordinateSphereLog n k σ p}) atTop (𝓝 1) := by
  let C := canonicalGaussianFreeValue σ k z r b
  let K := Real.log b/2+2*b
  let L := C+(b-1)/2-ε*(C+K+|1-b|/2)
  let δ := L-a
  have hδ : 0 < δ := by
    apply sub_pos.mpr
    simpa [L,C,K,add_assoc] using ha
  let μ := fun n => coordinateCascadeLaw (n+1) k z r
  let F := fun n (p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) =>
    canonicalCoordinateLog (n+1) k σ b ((fun i _ => p.1 i),p.2)
  let B := fun n => {p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k |
    (canonicalCoordinateBandTotalE n k σ b ε ((fun i _ => p.1 i),p.2)).toReal <
      decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ)
        (canonicalCoordinatePotential (n+1) b) k ((fun i _ => p.1 i),p.2)/2}
  let D := fun n => {p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k |
    (δ/2)*((n+1:ℕ):ℝ) ≤ |F n p-((n+1:ℕ):ℝ)*C|}
  have hB : Tendsto (fun n => μ n (B n)) atTop (𝓝 0) :=
    canonicalCoordinate_bad_half_band_tendsto_zero k σ z hz hz0 hz1 r b hp hstat hε
  have hD : Tendsto (fun n => μ n (D n)) atTop (𝓝 0) :=
    (canonical_coordinate_converges σ b k z hz hz0 hz1 hp r (half_pos hδ)).comp
      (tendsto_add_atTop_nat 1)
  have hsum := hB.add hD
  simp only [add_zero] at hsum
  have ht : Tendsto (fun n : ℕ => Real.log 2/((n+1:ℕ):ℝ)) atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1))
  have hev : ∀ᶠ n : ℕ in atTop, Real.log 2/((n+1:ℕ):ℝ) < δ/2 :=
    ht.eventually (gt_mem_nhds (half_pos hδ))
  have hb : 0 < b := hp.trans_le (quadraticCascadePrecision_le σ b k z (fun i => (hz0 i).le))
  have hbad : Tendsto (fun n => μ n {p | normalizedCoordinateSphereLog n k σ p < a}) atTop (𝓝 0) := by
    apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hsum
      (Eventually.of_forall (fun _ => bot_le))
    filter_upwards [hev,canonicalRadial_band_eventually_half hε hε1] with n hn hhalf
    apply le_trans (measure_mono_ae (t := B n ∪ D n) ?_) (measure_union_le _ _)
    filter_upwards [canonicalCoordinateBase_pos (n+1) k σ z hz hz0 hz1 r,
      canonicalCoordinateTotal_pos (n+1) k σ b z hz hz0 hz1 hp r] with p h0 hc
    intro hbad
    by_cases hpB : p ∈ B n
    · exact Or.inl hpB
    · right
      by_contra hpD
      have hm := (canonicalRadial_band_mass_bounds n hb hhalf).1
      have hmp : 0 < (canonicalRadialMass n b).real (normSquareBand n ε) :=
        (by positivity : 0 < Real.exp (((n+1:ℕ):ℝ)*((1-b)/2-|1-b| * ε/2))/2).trans_le hm
      have hu := (canonicalRadial_band_log_bounds n hb hhalf).2
      have hraw := canonicalCoordinate_unitSphere_lower n k σ hb hε.le hε1.le _ h0 hc hmp
        (le_of_not_gt hpB)
      have hd : 0 < ((n+1:ℕ):ℝ) := by positivity
      have hlow := (div_le_div_of_nonneg_right hraw hd.le)
      have herr : |F n p-((n+1:ℕ):ℝ)*C| < (δ/2)*((n+1:ℕ):ℝ) := not_le.mp hpD
      have herr' : C-δ/2 < F n p/((n+1:ℕ):ℝ) := by
        apply (lt_div_iff₀ hd).mpr
        have hh := (abs_lt.mp herr).1
        nlinarith
      have he : ((1-ε)*F n p-Real.log 2-
          Real.log ((canonicalRadialMass n b).real (normSquareBand n ε))-
          ε*((n+1:ℕ):ℝ)*K)/((n+1:ℕ):ℝ) =
          (1-ε)*(F n p/((n+1:ℕ):ℝ))-Real.log 2/((n+1:ℕ):ℝ)-
          Real.log ((canonicalRadialMass n b).real (normSquareBand n ε))/((n+1:ℕ):ℝ)-ε*K := by
        field_simp
      change ((1-ε)*F n p-Real.log 2-
          Real.log ((canonicalRadialMass n b).real (normSquareBand n ε))-
          ε*((n+1:ℕ):ℝ)*K)/((n+1:ℕ):ℝ) ≤ normalizedCoordinateSphereLog n k σ p at hlow
      rw [he] at hlow
      have hmule := mul_lt_mul_of_pos_left herr' (sub_pos.mpr hε1)
      have haeq : a = L-δ := by dsimp [δ]; ring
      change normalizedCoordinateSphereLog n k σ p < a at hbad
      dsimp only [L] at haeq
      nlinarith [mul_nonneg hε.le hδ.le]
  have hreal : Tendsto (fun n => (μ n).real {p | normalizedCoordinateSphereLog n k σ p < a}) atTop (𝓝 0) := by
    exact (ENNReal.tendsto_toReal (by simp : (0:ℝ≥0∞) ≠ ⊤)).comp hbad
  have hone : Tendsto (fun n => 1-(μ n).real {p | normalizedCoordinateSphereLog n k σ p < a}) atTop (𝓝 1) := by
    simpa using (tendsto_const_nhds (x := (1:ℝ))).sub hreal
  convert hone using 1
  ext n
  have hmeas : MeasurableSet {p | normalizedCoordinateSphereLog n k σ p < a} :=
    measurableSet_lt (normalizedCoordinateSphereLog_measurable n k σ) measurable_const
  rw [← probReal_compl_eq_one_sub hmeas]
  congr 1
  ext p
  simp only [mem_compl_iff,mem_ofPred_eq,not_lt]

lemma expectedCoordinateSphereLog_lower_eventually (k : ℕ) (σ : ℕ → ℝ)
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (r : ℝ≥0) (b : ℝ) (hp : 0 < quadraticCascadePrecision σ b k z)
    (hstat : -1/(2*b)+quadraticCascadeReciprocalSlope σ b k z-
      (r:ℝ)/(2*(quadraticCascadePrecision σ b k z)^2) = -1/2)
    {ε : ℝ} (hε : 0 < ε) (hε1 : ε < 1) :
    ∀ a : ℝ, a < canonicalGaussianFreeValue σ k z r b+(b-1)/2-
      ε*(canonicalGaussianFreeValue σ k z r b+Real.log b/2+2*b+|1-b|/2) →
    ∀ᶠ n : ℕ in atTop, a < expectedCoordinateSphereLog n k σ z r := by
  apply expected_eventually_gt_of_probability_lower
    (fun n => coordinateCascadeLaw (n+1) k z r) (fun n => normalizedCoordinateSphereLog n k σ)
    (fun n => normalizedCoordinateSphereLog_integrable n k σ z hz hz0 hz1 hp r)
    (fun n => normalizedCoordinateSphereLog_nonneg n k σ z hz hz0 hz1 hp r)
  exact fun a ha => normalizedCoordinateSphereLog_lower_probability k σ z hz hz0 hz1 r b hp hstat hε hε1 ha

theorem expectedCoordinateSphereLog_tendsto (k : ℕ) (σ : ℕ → ℝ)
    (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (r : ℝ≥0) (b : ℝ) (hp : 0 < quadraticCascadePrecision σ b k z)
    (hstat : -1/(2*b)+quadraticCascadeReciprocalSlope σ b k z-
      (r:ℝ)/(2*(quadraticCascadePrecision σ b k z)^2) = -1/2) :
    Tendsto (fun n : ℕ => expectedCoordinateSphereLog n k σ z r) atTop
      (𝓝 (canonicalGaussianFreeValue σ k z r b+(b-1)/2)) := by
  let T := canonicalGaussianFreeValue σ k z r b+(b-1)/2
  let A := canonicalGaussianFreeValue σ k z r b+Real.log b/2+2*b+|1-b|/2
  let e := fun j : ℕ => 1/((j+1:ℕ):ℝ)
  have he : Tendsto e atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1))
  have he0 : ∀ j, 0 < e j := by intro j; dsimp [e]; positivity
  have he1 : ∀ᶠ j in atTop, e j < 1 := he.eventually (gt_mem_nhds zero_lt_one)
  have hl : Tendsto (fun j => T-e j*A) atTop (𝓝 T) := by
    simpa using tendsto_const_nhds.sub (he.mul_const A)
  have hu : Tendsto (fun j => T+e j*A) atTop (𝓝 T) := by
    simpa using tendsto_const_nhds.add (he.mul_const A)
  apply tendsto_order.mpr
  constructor
  · intro a ha
    obtain ⟨j,hj1,hja⟩ := (he1.and (hl.eventually (lt_mem_nhds ha))).exists
    exact expectedCoordinateSphereLog_lower_eventually k σ z hz hz0 hz1 r b hp hstat (he0 j) hj1 a hja
  · intro a ha
    obtain ⟨j,hj1,hja⟩ := (he1.and (hu.eventually (gt_mem_nhds ha))).exists
    have ht : Tendsto (fun n : ℕ => T+e j*A+Real.log 2/((n+1:ℕ):ℝ)) atTop (𝓝 (T+e j*A)) := by
      have hh : Tendsto (fun n : ℕ => Real.log 2/((n+1:ℕ):ℝ)) atTop (𝓝 0) :=
        tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1))
      simpa using tendsto_const_nhds.add hh
    filter_upwards [expectedCoordinateSphereLog_upper_eventually k σ z hz hz0 hz1 hp r (he0 j) hj1,
      ht.eventually (gt_mem_nhds hja)] with n hn hn'
    exact hn.trans_lt hn'

end SphericalPerceptronFreeEnergy
end

end OAI