import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.DimensionDrop.Separable

namespace OAI

noncomputable section
namespace JiangSuConstruction
open scoped CStarAlgebra ComplexOrder

local instance iteratedStagePNeZero (n : ℕ) : NeZero (stagePair n).p := ⟨(stagePair n).p_pos.ne'⟩
local instance iteratedStageQNeZero (n : ℕ) : NeZero (stagePair n).q := ⟨(stagePair n).q_pos.ne'⟩

abbrev stageMultiplicities (n : ℕ) :=
  canonicalMultiplicities (stagePair n).p_pos (stagePair n).q_pos

def IteratedIndex (n : ℕ) : ℕ → Type
  | 0 => PUnit
  | k+1 => IteratedIndex n k × SpectralIndex (stageMultiplicities (n+k))

instance iteratedIndexFintype (n k : ℕ) : Fintype (IteratedIndex n k) := by
  induction k with
  | zero => exact inferInstanceAs (Fintype PUnit)
  | succ k ih =>
    letI := ih
    exact inferInstanceAs (Fintype (IteratedIndex n k × SpectralIndex (stageMultiplicities (n+k))))

instance iteratedIndexNonempty (n k : ℕ) : Nonempty (IteratedIndex n k) := by
  induction k with
  | zero => exact ⟨PUnit.unit⟩
  | succ k ih =>
    let := ih
    have : Nonempty (SpectralIndex (stageMultiplicities (n+k))) := by
      apply Fintype.card_pos_iff.mp
      rw [spectralIndex_card]
      exact Nat.mul_pos (stageMultiplicities (n+k)).k_pos (stageMultiplicities (n+k)).l_pos
    exact inferInstanceAs (Nonempty (IteratedIndex n k × SpectralIndex (stageMultiplicities (n+k))))

def iteratedFamily (n : ℕ) : (k : ℕ) → IteratedIndex n k → C(Interval,Interval)
  | 0,_ => ContinuousMap.id Interval
  | k+1,i => (iteratedFamily n k i.1).comp (spectralFamily (stageMultiplicities (n+k)) i.2)

lemma spectralTransfer_sum {p q : ℕ} [NeZero p] [NeZero q] (m : Multiplicities p q)
    (z : C(Interval,ℂ)) (t : Interval) :
    spectralTransfer m z t=(Fintype.card (SpectralIndex m):ℂ)⁻¹ *
      ∑ i : SpectralIndex m,z (spectralFamily m i t) := by
  rw [spectralIndex_card]
  simp [spectralTransfer,Fintype.sum_sum_type,spectralFamily,
    ContinuousMap.id_apply,add_assoc]

theorem scalarIterates_sum (n k : ℕ) (z : C(Interval,ℂ)) (t : Interval) :
    scalarIterates n z k t=(Fintype.card (IteratedIndex n k):ℂ)⁻¹ *
      ∑ i : IteratedIndex n k,z (iteratedFamily n k i t) := by
  induction k generalizing t with
  | zero =>
    change z t=(Fintype.card PUnit:ℂ)⁻¹ * ∑ _i : PUnit,z t
    simp
  | succ k ih =>
    rw [scalarIterates,spectralTransfer_sum]
    simp_rw [ih]
    change ((Fintype.card (SpectralIndex (stageMultiplicities (n+k)))):ℂ)⁻¹ *
      (∑ j : SpectralIndex (stageMultiplicities (n+k)),
        (Fintype.card (IteratedIndex n k):ℂ)⁻¹ *
          ∑ i : IteratedIndex n k,z (iteratedFamily n k i (spectralFamily (stageMultiplicities (n+k)) j t))) =
      (Fintype.card (IteratedIndex n k × SpectralIndex (stageMultiplicities (n+k))):ℂ)⁻¹ *
        ∑ i : IteratedIndex n k × SpectralIndex (stageMultiplicities (n+k)),
          z (iteratedFamily n k i.1 (spectralFamily (stageMultiplicities (n+k)) i.2 t))
    rw [Fintype.card_prod,Nat.cast_mul,mul_inv_rev,Fintype.sum_prod_type,
      ←Finset.mul_sum,Finset.sum_comm,mul_assoc]

lemma scalarIterates_sum_re (n k : ℕ) (z : C(Interval,ℂ)) (t : Interval) :
    (scalarIterates n z k t).re=(Fintype.card (IteratedIndex n k):ℝ)⁻¹ *
      ∑ i : IteratedIndex n k,(z (iteratedFamily n k i t)).re := by
  rw [scalarIterates_sum]
  simp [Complex.mul_re,Complex.inv_re,Complex.normSq_natCast]

end JiangSuConstruction

namespace JiangSuCounting
open scoped Topology

abbrev I := Set.Icc (0:ℝ) 1

def falling (a b : ℝ) : C(I,ℝ) :=
  ⟨fun x => max 0 (min 1 ((b-(x:ℝ))/(b-a))),by fun_prop⟩

lemma falling_nonneg (a b : ℝ) (x : I) : 0≤falling a b x := le_max_left _ _
lemma falling_le_one (a b : ℝ) (x : I) : falling a b x≤1 :=
  max_le (by norm_num) (min_le_left _ _)
lemma falling_eq_one {a b : ℝ} (hab : a<b) {x : I} (hx : (x:ℝ)≤a) :
    falling a b x=1 := by
  change max 0 (min 1 ((b-(x:ℝ))/(b-a)))=1
  have hq : 1≤(b-(x:ℝ))/(b-a) := (le_div_iff₀ (sub_pos.mpr hab)).mpr (by linarith)
  rw [min_eq_left hq,max_eq_right (by norm_num : (0:ℝ)≤1)]
lemma falling_eq_zero {a b : ℝ} (hab : a<b) {x : I} (hx : b≤(x:ℝ)) :
    falling a b x=0 := by
  change max 0 (min 1 ((b-(x:ℝ))/(b-a)))=0
  apply max_eq_left
  exact (min_le_right _ _).trans (div_nonpos_of_nonpos_of_nonneg (by linarith) (by linarith))

def bump (b c d : ℝ) : C(I,ℝ) :=
  ⟨fun x => (1-falling b c x)*falling c d x,by fun_prop⟩
lemma bump_nonneg (b c d : ℝ) (x : I) : 0≤bump b c d x :=
  mul_nonneg (sub_nonneg.mpr (falling_le_one b c x)) (falling_nonneg c d x)
lemma bump_le_one (b c d : ℝ) (x : I) : bump b c d x≤1 := by
  change (1-falling b c x)*falling c d x≤1
  calc
    (1-falling b c x)*falling c d x ≤ 1*falling c d x :=
      mul_le_mul_of_nonneg_right (sub_le_self _ (falling_nonneg b c x))
        (falling_nonneg c d x)
    _ ≤ 1 := by simpa only [one_mul] using falling_le_one c d x
lemma bump_zero_left {b c d : ℝ} (hbc : b<c) {x : I} (hx : (x:ℝ)≤b) :
    bump b c d x=0 := by simp [bump,falling_eq_one hbc hx]
lemma bump_zero_right {b c d : ℝ} (hcd : c<d) {x : I} (hx : d≤(x:ℝ)) :
    bump b c d x=0 := by simp [bump,falling_eq_zero hcd hx]
lemma bump_one {b c d : ℝ} (hbc : b<c) (hcd : c<d) (hc : c∈Set.Icc (0:ℝ) 1) :
    bump b c d ⟨c,hc⟩=1 := by
  change (1-falling b c ⟨c,hc⟩)*falling c d ⟨c,hc⟩=1
  rw [falling_eq_zero hbc le_rfl,falling_eq_one hcd le_rfl]
  norm_num

lemma falling_add_bump_le_one {a b c d : ℝ} (hab : a<b) (hbc : b<c) (x : I) :
    falling a b x+bump b c d x≤1 := by
  by_cases hx : (x:ℝ)≤b
  · rw [bump_zero_left hbc hx,add_zero]
    exact falling_le_one _ _ _
  · rw [falling_eq_zero hab (le_of_not_ge hx),zero_add]
    exact bump_le_one _ _ _ _

def complexify (f : C(I,ℝ)) : C(I,ℂ) := ⟨fun x => (f x:ℂ),by fun_prop⟩
@[simp] lemma complexify_re (f : C(I,ℝ)) (x : I) : (complexify f x).re=f x := rfl

def cutoff (r δ : ℝ) : C(I,ℂ) := complexify (falling (r+δ/8) (r+δ/4))
def reserve (r δ : ℝ) : C(I,ℂ) :=
  complexify (bump (r+δ/4) (r+3*δ/8) (r+δ/2))

lemma reserve_nonneg (r δ : ℝ) (x : I) : 0≤(reserve r δ x).re := bump_nonneg _ _ _ _
lemma reserve_positive {r δ : ℝ} (hδ : 0<δ) (hr : r∈Set.Icc 0 (1-δ)) :
    ∃ x : I,0<(reserve r δ x).re := by
  have hc : r+3*δ/8∈Set.Icc (0:ℝ) 1 := by constructor <;> linarith [hr.1,hr.2]
  refine ⟨⟨r+3*δ/8,hc⟩,?_⟩
  change 0<bump _ _ _ _
  rw [bump_one (by linarith) (by linarith) hc]
  norm_num

lemma cutoff_source {r δ v : ℝ} (hδ : 0<δ) (hv : |v-r|<δ/8) (x : I) :
    (if (x:ℝ)≤v then (1:ℝ) else 0)≤(cutoff r δ x).re := by
  change _≤falling _ _ x
  split_ifs with hx
  · rw [falling_eq_one (by linarith : r+δ/8<r+δ/4) (by
      have hh := (abs_lt.mp hv).2
      linarith)]
  · exact falling_nonneg _ _ _

lemma cutoff_reserve_target {r δ v : ℝ} (hδ : 0<δ) (hv : |v-r|<δ/8) (x : I) :
    (cutoff r δ x).re+(reserve r δ x).re≤(if (x:ℝ)≤v+δ then (1:ℝ) else 0) := by
  change falling _ _ x+bump _ _ _ x≤_
  split_ifs with hx
  · apply falling_add_bump_le_one <;> linarith
  · have hv' := (abs_lt.mp hv).1
    have hx' : v+δ<(x:ℝ) := lt_of_not_ge hx
    rw [falling_eq_zero (by linarith : r+δ/8<r+δ/4) (by linarith),
      bump_zero_right (by linarith : r+3*δ/8<r+δ/2) (by linarith)]
    norm_num

lemma card_filter_le_of_sums {J : Type*} [Fintype J] [DecidableEq J]
    (x y : J → I) (f g : I → ℝ) (v w : ℝ)
    (hx : ∀ z : I,(if (z:ℝ)≤v then (1:ℝ) else 0)≤f z)
    (hy : ∀ z : I,f z+g z≤(if (z:ℝ)≤w then (1:ℝ) else 0))
    (hm : (∑ j,f (x j))≤(∑ j,f (y j))+(∑ j,g (y j))) :
    (Finset.univ.filter fun j => (x j:ℝ)≤v).card≤
      (Finset.univ.filter fun j => (y j:ℝ)≤w).card := by
  have h₁ := Finset.sum_le_sum (s := Finset.univ) (fun j _ => hx (x j))
  have h₂ := Finset.sum_le_sum (s := Finset.univ) (fun j _ => hy (y j))
  rw [Finset.sum_add_distrib] at h₂
  have hh := h₁.trans (hm.trans h₂)
  exact_mod_cast (show ((Finset.univ.filter fun j => (x j:ℝ)≤v).card:ℝ) ≤
    (Finset.univ.filter fun j => (y j:ℝ)≤w).card from by simpa only [Finset.sum_boole] using hh)

end JiangSuCounting

namespace JiangSuConstruction
open Filter JiangSuCounting
open scoped Topology

lemma cumulative_counts_near (n : ℕ) {r δ : ℝ} (hδ : 0<δ)
    (hr : r∈Set.Icc 0 (1-δ)) :
    ∃ k : ℕ,∀ l, k≤l → ∀ s t : Interval,∀ v : ℝ, |v-r|<δ/8 →
      (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i s:ℝ)≤v).card≤
      (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i t:ℝ)≤v+δ).card := by
  classical
  let f := cutoff r δ
  let g := reserve r δ
  obtain ⟨x,hx⟩ := reserve_positive hδ hr
  obtain ⟨b,kb,hb,hkb⟩ := scalarIterates_eventually_positive n g (reserve_nonneg r δ) x hx
  obtain ⟨kf,hkf⟩ := scalarIterates_eventually_oscillation n f hb
  refine ⟨max kb kf,?_⟩
  intro l hl s t v hv
  have hlow := hkb l ((le_max_left kb kf).trans hl) t
  have hosc := hkf l ((le_max_right kb kf).trans hl) s t
  have hre := Complex.re_le_norm (scalarIterates n f l s-scalarIterates n f l t)
  rw [Complex.sub_re] at hre
  have hmean : (scalarIterates n f l s).re≤
      (scalarIterates n f l t).re+(scalarIterates n g l t).re := by linarith
  simp only [scalarIterates_sum_re] at hmean
  rw [←mul_add] at hmean
  have hI : (0:ℝ)<(Fintype.card (IteratedIndex n l):ℝ) := by
    exact_mod_cast Fintype.card_pos
  have hsum := le_of_mul_le_mul_left hmean (inv_pos.mpr hI)
  exact card_filter_le_of_sums (fun i => iteratedFamily n l i s)
    (fun i => iteratedFamily n l i t) (fun z => (f z).re) (fun z => (g z).re) v (v+δ)
    (cutoff_source hδ hv) (cutoff_reserve_target hδ hv) hsum

theorem iterated_spectrum_shifted_counts (n : ℕ) {δ : ℝ} (hδ : 0<δ) :
    ∃ k : ℕ,∀ l, k≤l → ∀ s t : Interval,∀ v : ℝ,
      (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i s:ℝ)≤v).card≤
      (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i t:ℝ)≤v+δ).card := by
  classical
  obtain ⟨T,hTK,hT,hcover⟩ := (isCompact_Icc : IsCompact (Set.Icc (0:ℝ) (1-δ))).finite_cover_balls
    (show 0<δ/8 by positivity : 0<δ/8)
  let R : Finset ℝ := hT.toFinset
  have he (r : ℝ) (hr : r∈R) : ∀ᶠ l : ℕ in atTop,
      ∀ s t : Interval,∀ v : ℝ, |v-r|<δ/8 →
        (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i s:ℝ)≤v).card≤
        (Finset.univ.filter fun i : IteratedIndex n l => (iteratedFamily n l i t:ℝ)≤v+δ).card := by
    have hrT : r∈T := (hT.mem_toFinset).mp hr
    obtain ⟨k,hk⟩ := cumulative_counts_near n hδ (hTK hrT)
    exact eventually_atTop.mpr ⟨k,hk⟩
  obtain ⟨k,hk⟩ := eventually_atTop.mp ((eventually_all_finset R).mpr he)
  refine ⟨k,?_⟩
  intro l hl s t v
  by_cases hv : v<0
  · have hzero : (Finset.univ.filter fun i : IteratedIndex n l =>
        (iteratedFamily n l i s:ℝ)≤v)=∅ := by
      apply Finset.eq_empty_iff_forall_notMem.mpr
      intro i hi
      have hh := (Finset.mem_filter.mp hi).2
      linarith [(iteratedFamily n l i s).property.1]
    rw [hzero,Finset.card_empty]
    exact Nat.zero_le _
  · by_cases hw : 1≤v+δ
    · have hall : (Finset.univ.filter fun i : IteratedIndex n l =>
          (iteratedFamily n l i t:ℝ)≤v+δ)=Finset.univ := by
        apply Finset.filter_eq_self.mpr
        intro i hi
        exact (iteratedFamily n l i t).property.2.trans hw
      rw [hall]
      exact Finset.card_le_card (Finset.filter_subset _ _)
    · have hvK : v∈Set.Icc 0 (1-δ) := ⟨le_of_not_gt hv,by linarith⟩
      obtain ⟨r,hrT,hvr⟩ := Set.mem_iUnion₂.mp (hcover hvK)
      have hrR : r∈R := hT.mem_toFinset.mpr hrT
      have hdist : |v-r|<δ/8 := hvr
      exact hk l hl r hrR s t v hdist

end JiangSuConstruction

end

end OAI