import Mathlib
import OAI.Probability.LogConcave.Complexity.VelocityNormalizedBudgetCalibrated

namespace OAI

section
noncomputable section
namespace LogConcaveSampling
open Filter
open scoped Topology

lemma centerScaleRate {α : ℕ → ℝ} {u a : ℝ} (hα : LogPowerRate α u) :
    LogPowerRate (fun d => (α d)^2*(((d:ℝ)^(-a))⁻¹)^4) (2*u-4*a) := by
  convert! (hα.pow 2).mul ((LogPowerRate.inv_power a).pow 4) using 1
  first | rfl | (norm_num; ring)

lemma centerStateQuadratureEnvelope_rate (n : ℕ) {α : ℕ → ℝ} {u a : ℝ}
    (hα : LogPowerRate α u) :
    LogPowerRate (fun d => centerStateQuadratureEnvelope n (α d) ((d:ℝ)^(-a)))
      ((n+2)*(2*u-4*a)) := by
  have he := (((centerScaleRate (a:=a) hα).pow (n+2)).const_mul (8*(singleCellBasisBudget n)^2)).mul_const
    (centeringStateBudget (n+2))
  simpa only [centerStateQuadratureEnvelope,Nat.cast_add,Nat.cast_ofNat] using he

lemma centerInitialEnvelope_rate {α : ℕ → ℝ} {u a : ℝ} (hα : LogPowerRate α u) :
    LogPowerRate (fun d => centerInitialEnvelope (α d) ((d:ℝ)^(-a))) (2*u-4*a) :=
  ((centerScaleRate hα).const_mul 2).mul_const (centeringStateBudget 1)

lemma centerStateEnvelope_rate (n N : ℕ) {α q E : ℕ → ℝ} {u a v e z : ℝ}
    (hα : LogPowerRate α u) (hq : LogPowerRate q v) (hE : LogPowerRate E e)
    (hz₁ : z≤2*u+e) (hz₂ : z≤(n+2)*(2*u-4*a))
    (hz₃ : z≤(2*N)*v+(2*u-4*a)) :
    LogPowerRate (fun d => centerStateEnvelope n N (α d) ((d:ℝ)^(-a)) (q d) (E d)) z := by
  have hp := ((hα.pow 2).const_mul (2*(centeringRowBudget n:ℝ)^2)).mul hE
  have hp' : LogPowerRate (fun d => 2*(centeringRowBudget n:ℝ)^2*(α d)^2*E d) z := by
    apply hp.mono
    norm_num
    exact hz₁
  have hs := ((centerStateQuadratureEnvelope_rate n hα).const_mul 2).mono hz₂
  have hq' := ((hq.pow (2*N)).const_mul 2).mul (centerInitialEnvelope_rate (a:=a) hα)
  have hq'' : LogPowerRate (fun d => 2*(q d)^(2*N)*centerInitialEnvelope (α d) ((d:ℝ)^(-a))) z := by
    apply hq'.mono
    push_cast
    exact hz₃
  exact ((hp'.add hs).const_mul 8).add hq''

lemma centerMeanEnvelope_rate (n : ℕ) {α Z : ℕ → ℝ} {u a z e : ℝ}
    (hα : LogPowerRate α u) (hZ : LogPowerRate Z z)
    (he₁ : e≤2*u+z) (he₂ : e≤2*u+(n+1)*(2*u-4*a)) :
    LogPowerRate (fun d => centerMeanEnvelope n (α d) ((d:ℝ)^(-a)) (Z d)) e := by
  have hp := ((hα.pow 2).const_mul (2*(centeringRowBudget n:ℝ)^2*(Real.pi^2/2)^2)).mul hZ
  have hp' : LogPowerRate (fun d => 2*(centeringRowBudget n:ℝ)^2*(Real.pi^2/2)^2*(α d)^2*Z d) e := by
    apply hp.mono
    norm_num
    exact he₁
  have hq := (((hα.pow 2).const_mul (8*(singleCellBasisBudget n)^2)).mul
    ((centerScaleRate (a:=a) hα).pow (n+1))).mul_const (centeringMeanBudget (n+1))
  have hq' : LogPowerRate (fun d => 8*(singleCellBasisBudget n)^2*(α d)^2*
      ((α d)^2*(((d:ℝ)^(-a))⁻¹)^4)^(n+1)*centeringMeanBudget (n+1)) e := by
    apply hq.mono
    push_cast
    exact he₂
  exact hp'.add hq'

theorem centeringEnvelopes_calibrated {α q E : ℕ → ℝ} {κ J b t w : ℝ} {n N : ℕ}
    (hκ : 0<κ) (hJ : 1≤J) (hb : 1/2≤b) (ht : 0<t) (htsmall : t<1/100)
    (hw : 0<w) (hwt : w<t)
    (hnw : J+10<w*((n:ℝ)-3)) (hnt : J+10<t*((n:ℝ)-3))
    (hnn : 4*(J+10)<(n:ℝ)) (hN : 10*(J+2)≤(N:ℝ))
    (hα : LogPowerRate α (κ*b)) (hq : LogPowerRate q (κ/3))
    (hE : LogPowerRate E (2*κ*(J+8))) :
    let Z := fun d => centerStateEnvelope n N (α d) ((d:ℝ)^(-(κ*t))) (q d) (E d)
    LogPowerRate Z (2*κ*(J+8)) ∧
    LogPowerRate (fun d => centerMeanEnvelope n (α d) ((d:ℝ)^(-(κ*t))) (Z d)) (2*κ*(J+8)) := by
  intro Z
  obtain ⟨hp,hh,hiter,ha₁,ha₂,hv₁,hv₂,hlip,hbeta,hcq,hniter,hmq⟩ :=
    numerical_exponent_margins hJ hb ht htsmall hw hwt hnw hnt hnn hN
  have hκb : 0≤κ*b := mul_nonneg hκ.le (by linarith)
  have hκβ := mul_nonneg hκ.le hbeta
  have hZ : LogPowerRate Z (2*κ*(J+8)) := by
    apply centerStateEnvelope_rate n N hα hq hE
    · linarith
    · have he := mul_le_mul_of_nonneg_left hcq hκ.le
      nlinarith
    · have he := mul_le_mul_of_nonneg_left hniter hκ.le
      nlinarith
  refine ⟨hZ,?_⟩
  apply centerMeanEnvelope_rate n hα hZ
  · linarith
  · have he := mul_le_mul_of_nonneg_left hmq hκ.le
    nlinarith
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Filter Quadrature
open scoped Topology

def sourceCorrelation (a : ℝ) (d : ℕ) : ℝ := Real.sqrt (1-((d:ℝ)^(-a))^2)

lemma sourceCorrelation_eventually {a : ℝ} (ha : 0<a) :
    ∀ᶠ d : ℕ in atTop,0<sourceCorrelation a d ∧ sourceCorrelation a d<1 ∧
      ((d:ℝ)^(-a))^2=1-(sourceCorrelation a d)^2 := by
  have ht := (tendsto_rpow_neg_atTop ha).comp (tendsto_natCast_atTop_atTop (R:=ℝ))
  have he := ht.eventually (gt_mem_nhds (by norm_num : (0:ℝ)<1))
  filter_upwards [he,eventually_ge_atTop (1:ℕ)] with d hd hd1
  have hd0 : (0:ℝ)<d := by exact_mod_cast hd1
  change (d:ℝ)^(-a)<1 at hd
  have hp := Real.rpow_pos_of_pos hd0 (-a)
  have hs : 0<1-((d:ℝ)^(-a))^2 := by nlinarith
  have hsq := Real.sq_sqrt hs.le
  refine ⟨Real.sqrt_pos.mpr hs,?_,?_⟩
  · change Real.sqrt _<1
    nlinarith [Real.sqrt_nonneg (1-((d:ℝ)^(-a))^2)]
  · change ((d:ℝ)^(-a))^2=1-Real.sqrt (1-((d:ℝ)^(-a))^2)^2
    linarith

lemma sourceCorrelation_tendsto {a : ℝ} (ha : 0<a) :
    Tendsto (sourceCorrelation a) atTop (nhds 1) := by
  have ht := (tendsto_rpow_neg_atTop ha).comp (tendsto_natCast_atTop_atTop (R:=ℝ))
  change Tendsto (fun d : ℕ => Real.sqrt (1-((d:ℝ)^(-a))^2)) atTop (nhds 1)
  simpa only [Function.comp_def,zero_pow (by omega : (2:ℕ)≠0),sub_zero,Real.sqrt_one] using
    ((tendsto_const_nhds (x:=(1:ℝ))).sub (ht.pow 2)).sqrt

lemma sourceMesh_eventually {a b : ℝ} (ha : 0<a) (hb : 0<b) :
    ∀ᶠ d : ℕ in atTop,(d:ℝ)^(-b) ≤ Real.log 2 ∧
      (d:ℝ)^(-b) ≤ logMeshLength (sourceCorrelation a d) := by
  have ht := (tendsto_rpow_neg_atTop hb).comp (tendsto_natCast_atTop_atTop (R:=ℝ))
  have he := ht.eventually (gt_mem_nhds (Real.log_pos (by norm_num : (1:ℝ)<2)))
  have hc := (sourceCorrelation_tendsto ha).eventually (lt_mem_nhds (by norm_num : (1/2:ℝ)<1))
  filter_upwards [he,hc,sourceCorrelation_eventually ha] with d hd hcd hp
  refine ⟨hd.le,?_⟩
  apply hd.le.trans
  unfold logMeshLength
  rw [←Real.log_inv]
  apply Real.log_le_log (by norm_num)
  rw [inv_eq_one_div]
  apply (le_div_iff₀ (by linarith : 0<1-sourceCorrelation a d)).mpr
  linarith

lemma sourceAngle_eventually {a : ℝ} (ha : 0<a) (n : ℕ) :
    ∀ᶠ d : ℕ in atTop,(d:ℝ)^(-a)*(n:ℝ) ≤ 1 := by
  have ht := ((tendsto_rpow_neg_atTop ha).comp
    (tendsto_natCast_atTop_atTop (R:=ℝ))).mul_const (n:ℝ)
  have ht' : Tendsto (fun d : ℕ => (d:ℝ)^(-a)*(n:ℝ)) atTop (nhds 0) := by
    simpa only [Function.comp_def,zero_mul] using ht
  exact (ht'.eventually (gt_mem_nhds (by norm_num : (0:ℝ)<1))).mono (fun _ h => h.le)
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open Filter Quadrature
open scoped Topology Classical BigOperators NNReal

lemma probabilityMeanLipschitz_rate {lam : ℕ → ℝ≥0} {r : ℕ → ℝ} {u : ℝ}
    (hl : LogPowerRate (fun d => (lam d:ℝ)*(r d)^2) u) (A : ℝ≥0) :
    LogPowerRate (fun d => (A*probabilityMeanLipschitz (lam d) (r d):ℝ≥0)) u := by
  apply (hl.const_mul ((A:ℝ)*(Real.pi^2/2))).congr
  apply Eventually.of_forall
  intro d
  change (A:ℝ)*(Real.pi^2/2)*((lam d:ℝ)*(r d)^2) =
    (A:ℝ)*((Real.pi^2/2)*(lam d:ℝ)*(r d)^2)
  ring

theorem centeringScalarCalibration (k n N : ℕ) (A Ap Ah Lp contraction : ℝ≥0) (C J₀ D : ℝ)
    {lam : ℕ → ℝ≥0} {r s : ℕ → ℝ} {κ J b t w : ℝ}
    (hκ : 0<κ) (hJ : 1≤J) (hb : 1/2≤b) (ht : 0<t) (htsmall : t<1/100)
    (hw : 0<w) (hwt : w<t)
    (hnw : J+10<w*((n:ℝ)-3)) (hnt : J+10<t*((n:ℝ)-3))
    (hnn : 4*(J+10)<(n:ℝ)) (hN : 10*(J+2)≤(N:ℝ))
    (hl : LogPowerRate (fun d => (lam d:ℝ)*(r d)^2) (κ*b))
    (hα : LogPowerRate (fun d => (lam d:ℝ)*r d/s d) (κ*b))
    (hr : ∀ᶠ d : ℕ in atTop,0<r d) (hs : ∀ᶠ d : ℕ in atTop,0<s d) :
    let R := fun d : ℕ => (d:ℝ)^(-(κ*t))
    let T := sourceCorrelation (κ*t)
    let h := fun d : ℕ => (d:ℝ)^(-(κ*w))
    let ψ := fun d : ℕ => (d:ℝ)^(-(κ*(4*t)))
    let E := fun d => velocityNormalizedBudget d k n n N (lam d) Ap Ah Lp (r d) (R d) (T d) (h d) (ψ d) C J₀ D
    let q := fun d => centeringRowBudget n*velocityJointLip n n A (lam d) (r d) (T d) (h d) (ψ d) (s d)
    let Z := fun d => centerStateEnvelope n N ((lam d:ℝ)*r d/s d) (R d) (q d:ℝ) (E d)
    ∀ᶠ d : ℕ in atTop,
      (lam d:ℝ)*(r d)^2≤1/2 ∧ contraction*probabilityMeanLipschitz (lam d) (r d)≤1/2 ∧
      q d≤1/2 ∧ Z d≤(d:ℝ)^(-(2*κ*J)) ∧
      centerMeanEnvelope n ((lam d:ℝ)*r d/s d) (R d) (Z d)≤(d:ℝ)^(-(2*κ*J)) := by
  intro R T h ψ E q Z
  have hκt := mul_pos hκ ht
  have hκw := mul_pos hκ hw
  have hκb : 0<κ*b := mul_pos hκ (by linarith)
  have hT := sourceCorrelation_eventually hκt
  have hT0 : ∀ᶠ d : ℕ in atTop,0<T d := hT.mono (fun _ h => h.1)
  have hT1 : ∀ᶠ d : ℕ in atTop,T d<1 := hT.mono (fun _ h => h.2.1)
  have hRT : ∀ᶠ d : ℕ in atTop,(R d)^2≤1-(T d)^2 := hT.mono (fun _ h => h.2.2.le)
  have hmesh := sourceMesh_eventually hκt hκw
  have hsmall := hmesh.mono (fun _ hd => hd.1)
  have hlarge := hmesh.mono (fun _ hd => hd.2)
  have hE : LogPowerRate E (2*κ*(J+8)) := velocityNormalizedBudget_calibrated k n N Ap Ah Lp C J₀ D
    hκ hJ hb ht htsmall hw hwt hnw hnt hnn hN hl hT0 hT1 hRT hsmall hlarge
  obtain ⟨Dq,hDq,hDqu⟩ := exists_basisDerivative_budget (probabilityNodes (n+1))
  have hW := terminalQuadratureWeight_rate n Dq (by linarith) hDqu (κ*t) (κ*w) hT0 hT1 hRT hsmall hlarge
  have hlip := velocityJointLip_rate n n A (show 0≤κ*w+κ*(4*t) by positivity)
    hr hs hT0 hT1 hW hα
  have hmargin : κ/3≤κ*b-κ*w-κ*(4*t) := by
    have hex := (numerical_exponent_margins hJ hb ht htsmall hw hwt hnw hnt hnn hN).2.2.2.2.2.2.2.1
    have he := mul_le_mul_of_nonneg_left hex hκ.le
    nlinarith
  have hq : LogPowerRate (fun d => (q d:ℝ)) (κ/3) := by
    simpa only [q,NNReal.coe_mul] using (hlip.const_mul (centeringRowBudget n:ℝ)).mono hmargin
  have hz := centeringEnvelopes_calibrated hκ hJ hb ht htsmall hw hwt hnw hnt hnn hN hα hq hE
  have hze := hz.1.eventually_small (show 2*κ*J<2*κ*(J+8) by nlinarith)
  have hme := hz.2.eventually_small (show 2*κ*J<2*κ*(J+8) by nlinarith)
  have hle := hl.eventually_lt_const hκb (by norm_num : (0:ℝ)<1/2)
  have hc := (probabilityMeanLipschitz_rate hl contraction).eventually_lt_const hκb (by norm_num : (0:ℝ)<1/2)
  have hqe := hq.eventually_lt_const (by linarith) (by norm_num : (0:ℝ)<1/2)
  filter_upwards [hze,hme,hle,hc,hqe] with d hzd hmd hld hcd hqd
  refine ⟨(le_abs_self _).trans hld.le,?_,?_,(le_abs_self _).trans hzd, (le_abs_self _).trans hmd⟩
  · exact_mod_cast (le_abs_self _).trans hcd.le
  · exact_mod_cast (le_abs_self _).trans hqd.le
end LogConcaveSampling

end

end

end OAI