import Mathlib
import OAI.Probability.BinarySweep.Mixing.ShapeDimension

namespace OAI

noncomputable section
open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young

def dimensionInv {n : ℕ} (p : n.Partition) : ℝ :=
  ((Module.finrank ℂ (PartitionHilbert p):ℝ)^8)⁻¹

def dimensionFiber (n k : ℕ) : ℝ := if k=0 then 0 else
  ∑p : {p : n.Partition // flatTail (diagram p)=k},dimensionInv p.val

def dimensionSeries (n : ℕ) : ℝ :=
  ∑p : n.Partition, if flatTail (diagram p)=0 then 0 else dimensionInv p

lemma dimensionInv_nonneg {n : ℕ} (p : n.Partition) : 0≤dimensionInv p := by
  unfold dimensionInv; positivity

lemma dimensionInv_exponential {n k : ℕ} (p : n.Partition) (hp : flatTail (diagram p)=k) :
    dimensionInv p≤(1/16:ℝ)^k := by
  have hD : (0:ℝ)<Module.finrank ℂ (PartitionHilbert p) := by exact_mod_cast partition_dimension_pos p
  have hl := partition_log_lower p hp
  have hh : (16:ℝ)^k≤(Module.finrank ℂ (PartitionHilbert p):ℝ)^8 := by
    apply (Real.log_le_log_iff (by positivity) (by positivity)).mp
    rw [Real.log_pow,Real.log_pow]
    have h16 : Real.log (16:ℝ)=4*Real.log 2 := by
      rw [show (16:ℝ)=2^4 by norm_num,Real.log_pow]
      norm_num
    rw [h16]
    norm_num only [Nat.cast_ofNat]
    nlinarith
  have hi := (inv_le_inv₀ (by positivity : (0:ℝ)<(Module.finrank ℂ (PartitionHilbert p):ℝ)^8)
    (by positivity : (0:ℝ)<16^k)).mpr hh
  simpa only [dimensionInv,one_div,inv_pow] using hi

lemma dimensionFiber_nonneg (n k : ℕ) : 0≤dimensionFiber n k := by
  unfold dimensionFiber
  split
  · rfl
  · exact Finset.sum_nonneg (fun _ _ => dimensionInv_nonneg _)

lemma dimensionFiber_bound (n k : ℕ) : dimensionFiber n k≤2*(1/8:ℝ)^k := by
  by_cases hk : k=0
  · simp [dimensionFiber,hk]
  rw [dimensionFiber,ite_eq_right hk]
  calc
    _ ≤ (Fintype.card {p : n.Partition // flatTail (diagram p)=k}:ℝ)*(1/16:ℝ)^k := by
      calc
        _ ≤ ∑p : {p : n.Partition // flatTail (diagram p)=k}, (1/16:ℝ)^k :=
          Finset.sum_le_sum (fun p _ => dimensionInv_exponential p.val p.property)
        _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
    _ ≤ (2*2^k:ℝ)*(1/16:ℝ)^k := by
      have hh : (Fintype.card {p : n.Partition // flatTail (diagram p)=k}:ℝ)≤2*2^k := by
        exact_mod_cast flatTail_card n k
      exact mul_le_mul_of_nonneg_right hh (by positivity)
    _ = _ := by rw [mul_assoc,←mul_pow]; norm_num

lemma dimensionFiber_grows_bound {n k : ℕ} (hk : 0<k) (hn : 2*k<n) :
    dimensionFiber n k≤(2*2^k:ℝ)*(((n-2*k:ℕ):ℝ)⁻¹)^8 := by
  rw [dimensionFiber,ite_eq_right (by omega : k≠0)]
  have hp : (0:ℝ)<(n-2*k:ℕ) := by exact_mod_cast (show 0<n-2*k by omega)
  calc
    _ ≤ (Fintype.card {p : n.Partition // flatTail (diagram p)=k}:ℝ)*(((n-2*k:ℕ):ℝ)⁻¹)^8 := by
      calc
        _ ≤ ∑p : {p : n.Partition // flatTail (diagram p)=k}, (((n-2*k:ℕ):ℝ)⁻¹)^8 := ?_
        _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
      apply Finset.sum_le_sum
      intro p _
      have hd : ((n-2*k:ℕ):ℝ)≤Module.finrank ℂ (PartitionHilbert p.val) := by
        exact_mod_cast partition_dimension_grows p.val p.property hk
      have hi := one_div_le_one_div_of_le hp hd
      simp only [dimensionInv,←inv_pow]
      apply pow_le_pow_left₀ (by positivity)
      simpa only [one_div] using hi
    _ ≤ _ := mul_le_mul_of_nonneg_right (by exact_mod_cast flatTail_card n k) (by positivity)

lemma dimensionFiber_tendsto (k : ℕ) :
    Filter.Tendsto (fun n => dimensionFiber n k) Filter.atTop (nhds 0) := by
  by_cases hk : k=0
  · subst k
    simpa only [dimensionFiber,ite_true] using
      (tendsto_const_nhds : Filter.Tendsto (fun _ : ℕ => (0:ℝ)) Filter.atTop (nhds 0))
  have ht : Filter.Tendsto (fun n : ℕ => n-2*k) Filter.atTop Filter.atTop := by
    apply Filter.tendsto_atTop.2
    intro b
    exact Filter.eventually_atTop.2 ⟨b+2*k,fun n hn => by omega⟩
  have hr : Filter.Tendsto (fun n : ℕ => ((n-2*k:ℕ):ℝ)) Filter.atTop Filter.atTop :=
    tendsto_natCast_atTop_atTop.comp ht
  have hlim : Filter.Tendsto (fun n : ℕ => (2*2^k:ℝ)*(((n-2*k:ℕ):ℝ)⁻¹)^8)
      Filter.atTop (nhds 0) := by
    simpa using (hr.inv_tendsto_atTop.pow 8).const_mul (2*2^k:ℝ)
  apply squeeze_zero' (Filter.Eventually.of_forall (fun n => dimensionFiber_nonneg n k)) _ hlim
  exact Filter.eventually_atTop.2 ⟨2*k+1,fun n hn => dimensionFiber_grows_bound (by omega) (by omega)⟩

lemma dimensionFiber_eq_filter (n k : ℕ) : dimensionFiber n k=
    ∑p ∈ Finset.univ.filter (fun p : n.Partition => flatTail (diagram p)=k),
      if flatTail (diagram p)=0 then 0 else dimensionInv p := by
  unfold dimensionFiber
  split
  · subst k
    symm
    apply Finset.sum_eq_zero
    intro p hp
    simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hp
    simp only [hp,ite_true]
  · rename_i hk
    rw [Finset.sum_subtype _ (by simp : ∀p : n.Partition,
      p ∈ Finset.univ.filter (fun p => flatTail (diagram p)=k) ↔ flatTail (diagram p)=k)]
    apply Finset.sum_congr rfl
    intro p _
    rw [ite_eq_right (by rw [p.property]; exact hk)]

lemma dimensionSeries_tsum (n : ℕ) : dimensionSeries n=∑'k,dimensionFiber n k := by
  rw [tsum_eq_sum (s:=Finset.range (n+1))]
  · simp_rw [dimensionFiber_eq_filter]
    symm
    apply Finset.sum_fiberwise_of_maps_to
    intro p _
    simp only [Finset.mem_range]
    have ht : flatTail (diagram p)≤n := by unfold flatTail; rw [diagram_card]; omega
    omega
  · intro k hk
    by_cases he : k=0
    · simp [dimensionFiber,he]
    rw [dimensionFiber,ite_eq_right he]
    apply Finset.sum_eq_zero
    intro p _
    have ht : flatTail (diagram p.val)≤n := by unfold flatTail; rw [diagram_card]; omega
    have hp := p.property
    simp only [Finset.mem_range,not_lt] at hk
    omega

theorem dimensionSeries_tendsto : Filter.Tendsto dimensionSeries Filter.atTop (nhds 0) := by
  have hs : Summable (fun k : ℕ => 2*(1/8:ℝ)^k) :=
    Summable.mul_left 2 (summable_geometric_of_norm_lt_one (by norm_num))
  have ht := tendsto_tsum_of_dominated_convergence hs dimensionFiber_tendsto
    (Filter.Eventually.of_forall (fun n k => by
      rw [Real.norm_eq_abs,abs_of_nonneg (dimensionFiber_nonneg n k)]
      exact dimensionFiber_bound n k))
  simpa only [←dimensionSeries_tsum,tsum_zero] using ht

end BinaryCoordinateSweeps.Young

end

end OAI