import Mathlib
import OAI.Probability.LogConcave.Numerics.Picard

namespace OAI

section
noncomputable section
namespace LogConcaveSampling
open Set MeasureTheory ProbabilityTheory
open scoped Classical BigOperators NNReal

def circuitD {d : ℕ} (F : Point d → ℝ) (x : Point d) : ℝ :=
  Real.sqrt d+‖gradient F x‖
lemma circuitD_nonneg {d : ℕ} (F : Point d → ℝ) (x : Point d) : 0 ≤ circuitD F x := by
  unfold circuitD; positivity
lemma sqrt_le_circuitD {d : ℕ} (F : Point d → ℝ) (x : Point d) : Real.sqrt d ≤ circuitD F x := by
  unfold circuitD; exact le_add_of_nonneg_right (norm_nonneg _)
lemma field_zero_eq_gradient {d : ℕ} (F : Point d → ℝ) (x : Point d) (r : ℝ) :
    primitiveField F x r 0=gradient F x := by simp [primitiveField]

def circuitGrowthConstant : ℝ := 8*(terminalTransportConstant+1)*(Real.pi+1)
lemma circuitGrowthConstant_pos : 0<circuitGrowthConstant := by
  unfold circuitGrowthConstant
  positivity [terminalTransportConstant_pos]

lemma probabilityInitialRms_growth {d : ℕ} (F : Point d → ℝ) (x : Point d)
    (lam : ℝ≥0) {r : ℝ} (hr : 0≤r) (hL : (lam:ℝ)*r≤1) :
    probabilityInitialRms F x lam r ≤ circuitGrowthConstant*r*circuitD F x := by
  let C := terminalTransportConstant
  let D := circuitD F x
  have hC : 0<C := terminalTransportConstant_pos
  have hD : 0≤D := circuitD_nonneg F x
  have hdc : ‖primitiveField F x r 0‖≤D := by
    rw [field_zero_eq_gradient]; exact le_add_of_nonneg_left (Real.sqrt_nonneg _)
  have hds : Real.sqrt d≤D := sqrt_le_circuitD F x
  have hL0 : 0≤(lam:ℝ)*r := by positivity
  have ha : r*‖primitiveField F x r 0‖+(lam:ℝ)*r^2*Real.pi*Real.sqrt d ≤ r*(Real.pi+1)*D := by
    have h₁ := mul_le_mul_of_nonneg_left hdc hr
    have h₂ := mul_le_mul_of_nonneg_right hL (show 0≤r*Real.pi*Real.sqrt d by positivity)
    have h₃ := mul_le_mul_of_nonneg_left hds (show 0≤r*Real.pi by positivity)
    nlinarith
  have hb : (lam:ℝ)*r^2*Real.sqrt d ≤ r*D := by
    have h₁ := mul_le_mul_of_nonneg_right hL (show 0≤r*Real.sqrt d by positivity)
    have h₂ := mul_le_mul_of_nonneg_left hds hr
    nlinarith
  have ha' := pow_le_pow_left₀ (show 0≤r*‖primitiveField F x r 0‖+(lam:ℝ)*r^2*Real.pi*Real.sqrt d by positivity) ha 2
  have hb' := pow_le_pow_left₀ (show 0≤(lam:ℝ)*r^2*Real.sqrt d by positivity) hb 2
  have hs := Real.sq_sqrt (show 0≤(d:ℝ) by positivity)
  have hm₁ := mul_le_mul_of_nonneg_left ha' (show 0≤2*C^2 by positivity)
  have hm₂ := mul_le_mul_of_nonneg_left hb' (show 0≤2*C^2 by positivity)
  apply (Real.sqrt_le_iff).mpr
  refine ⟨by exact mul_nonneg (mul_nonneg circuitGrowthConstant_pos.le hr) hD,?_⟩
  change 2*(C*(r*‖primitiveField F x r 0‖+(lam:ℝ)*r^2*Real.pi*Real.sqrt d))^2+
    2*(C*((lam:ℝ)*r^2))^2*d ≤ _
  have hn : 2*C^2*(r*(Real.pi+1)*D)^2+2*C^2*(r*D)^2 ≤
      (circuitGrowthConstant*r*D)^2 := by
    have hp : 1≤Real.pi+1 := by linarith [Real.pi_pos]
    have hmul : r*D ≤ (Real.pi+1)*(r*D) := by
      simpa only [one_mul] using mul_le_mul_of_nonneg_right hp (show 0≤r*D by positivity)
    have h := pow_le_pow_left₀ (by positivity : 0≤r*D) hmul 2
    have hc : 4*C^2 ≤ (8*(C+1))^2 := by nlinarith
    have hh := mul_le_mul_of_nonneg_right hc (sq_nonneg (r*(Real.pi+1)*D))
    dsimp only [circuitGrowthConstant]
    change _ ≤ (8*(C+1)*(Real.pi+1)*r*D)^2
    nlinarith [mul_nonneg (show 0≤2*C^2 by positivity) (sub_nonneg.mpr h)]
  nlinarith [hm₁,hm₂]

lemma conditionalMean_flow_growth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r T : ℝ} (hr : 0≤r) (hr1 : r≤1)
    (hl : (lam:ℝ)*r^2≤1/2) (hL : (lam:ℝ)*r≤1) (hT0 : 0≤T) (hT1 : T<1)
    (z : Point d) :
    ‖conditionalFieldMean F x r T (fullProbabilityFlow hF x hr hl T z)‖ ≤
      circuitGrowthConstant*(circuitD F x+‖z‖) := by
  let C := terminalTransportConstant
  let B := Real.pi*Real.sqrt d+‖z‖+‖primitiveField F x r 0‖
  have hC : 0<C := terminalTransportConstant_pos
  have hB : 0≤B := by dsimp [B]; positivity
  have hf := probabilityFlow_initial_displacement hF x hr hl z ⟨hT0,hT1.le⟩
  have hn := norm_le_norm_sub_add (fullProbabilityFlow hF x hr hl T z) z
  have h₁ := mul_le_mul_of_nonneg_right hr1 (norm_nonneg (primitiveField F x r 0))
  have h₂ := mul_le_mul_of_nonneg_right (show (lam:ℝ)*r^2≤1 by linarith)
    (show 0≤Real.pi*Real.sqrt d+‖z‖ by positivity)
  have hfb : ‖fullProbabilityFlow hF x hr hl T z‖ ≤ (C+1)*B := by
    have h := mul_le_mul_of_nonneg_left (add_le_add h₁ h₂) hC.le
    dsimp [C,B] at *
    nlinarith [norm_nonneg (primitiveField F x r 0),Real.sqrt_nonneg (d:ℝ),Real.pi_pos]
  have hm := conditionalFieldMean_center_zero_bound hF x hr hl hT0 hT1
    (fullProbabilityFlow hF x hr hl T z)
  have hmn := norm_le_norm_sub_add (conditionalFieldMean F x r T (fullProbabilityFlow hF x hr hl T z))
    (primitiveField F x r 0)
  have hinside : Real.pi*Real.sqrt d+‖fullProbabilityFlow hF x hr hl T z‖+
      r*‖primitiveField F x r 0‖ ≤ (C+2)*B := by
    dsimp [B] at *
    nlinarith [norm_nonneg z]
  have hmul := mul_le_mul hL hinside (by positivity : 0≤Real.pi*Real.sqrt d+
    ‖fullProbabilityFlow hF x hr hl T z‖+r*‖primitiveField F x r 0‖) (by norm_num : (0:ℝ)≤1)
  have hfin : ‖conditionalFieldMean F x r T (fullProbabilityFlow hF x hr hl T z)‖ ≤ (2*C+5)*B := by
    have hc : ‖primitiveField F x r 0‖≤B := by
      dsimp [B]; exact le_add_of_nonneg_left (by positivity)
    nlinarith
  have hB' : B≤(Real.pi+1)*(circuitD F x+‖z‖) := by
    dsimp [B,circuitD]
    rw [field_zero_eq_gradient]
    nlinarith [mul_nonneg Real.pi_pos.le (norm_nonneg z),
      mul_nonneg Real.pi_pos.le (norm_nonneg (gradient F x)), Real.sqrt_nonneg (d:ℝ)]
  have hc : 2*C+5≤8*(C+1) := by linarith
  exact hfin.trans ((mul_le_mul hc hB' hB (by positivity)).trans_eq (by
    dsimp only [circuitGrowthConstant]; change _=8*(C+1)*(Real.pi+1)*(circuitD F x+‖z‖); ring))

lemma harmonicStationaryMoment_growth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r T : ℝ} (hr : 0≤r) (hr1 : r≤1)
    (hl : (lam:ℝ)*r^2≤1/2) (hL : (lam:ℝ)*r≤1) (hT0 : 0≤T) (hT1 : T<1) :
    harmonicStationaryMoment F x r T ≤ 4*circuitGrowthConstant^2*(circuitD F x)^2 := by
  have hm := (conditionalFieldMean_lipschitz hF x hr hl hT0 hT1).continuous
  have hg := gaussian_growth_sq_moment (hm.comp (fullProbabilityFlow_lipschitz hF x hr hl ⟨hT0,hT1.le⟩).continuous)
    circuitGrowthConstant_pos.le (circuitD_nonneg F x)
    (conditionalMean_flow_growth hF x hr hr1 hl hL hT0 hT1)
  have he : harmonicStationaryMoment F x r T =
      ∫z,‖conditionalFieldMean F x r T (fullProbabilityFlow hF x hr hl T z)‖^2 ∂stdGaussian (Point d) := by
    have hm' : AEStronglyMeasurable (fun y => ‖conditionalFieldMean F x r T y‖^2)
        ((gibbs (centeringPotential F x r T)).map (fun y => (productPointEquiv d d y).1)) :=
      (hm.norm.pow 2).aestronglyMeasurable
    have e₁ := integral_map ((productPointEquiv d d).continuous.fst.measurable.aemeasurable) hm'
    change (∫y,‖conditionalFieldMean F x r T y‖^2
      ∂(gibbs (centeringPotential F x r T)).map (fun y => (productPointEquiv d d y).1))=_ at e₁
    rw [centering_position_law hF x hr hl hT0 hT1] at e₁
    have e₂ := integral_map
      ((fullProbabilityFlow_lipschitz hF x hr hl ⟨hT0,hT1.le⟩).continuous.measurable.aemeasurable)
      (show AEStronglyMeasurable (fun y => ‖conditionalFieldMean F x r T y‖^2)
        ((stdGaussian (Point d)).map (fullProbabilityFlow hF x hr hl T)) from
        (hm.norm.pow 2).aestronglyMeasurable)
    rw [fullProbabilityFlow_interpolation_closed hF x hr hl hT0 hT1] at e₂
    exact e₁.symm.trans e₂
  rw [he]
  apply hg.2.trans
  have hs := pow_le_pow_left₀ (Real.sqrt_nonneg (d:ℝ)) (sqrt_le_circuitD F x) 2
  rw [Real.sq_sqrt (Nat.cast_nonneg d)] at hs
  nlinarith [mul_le_mul_of_nonneg_left hs (sq_nonneg circuitGrowthConstant)]
end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory Set
open scoped Classical BigOperators NNReal

variable {d : ℕ}

lemma circuitD_change {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    (x y : Point d) : circuitD F y≤circuitD F x+(lam:ℝ)*‖y-x‖ := by
  have he := hF.gradient_lipschitz.dist_le_mul y x
  rw [dist_eq_norm,dist_eq_norm] at he
  have hn := norm_le_norm_add_norm_sub (gradient F x) (gradient F y)
  rw [norm_sub_rev] at hn
  dsimp [circuitD]
  linarith

lemma primitiveExpectedField_growth {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r : ℝ} (hr : 0≤r)
    (hl : (lam:ℝ)*r^2≤1/2) (hL : (lam:ℝ)*r≤1) :
    ‖primitiveExpectedField F x r‖≤(2*Real.pi+2)*circuitD F x := by
  have he := terminal_mean_error hF x hr hl (0:Point d)
  rw [norm_zero,add_zero,field_zero_eq_gradient] at he
  have hn := norm_le_norm_add_norm_sub (gradient F x) (primitiveExpectedField F x r)
  have h₁ := mul_le_mul_of_nonneg_right hL (show 0≤2*Real.pi*Real.sqrt d by positivity)
  have h₂ := mul_le_mul_of_nonneg_right hl (show 0≤2*‖gradient F x‖ by positivity)
  have h₃ := mul_nonneg (show 0≤2*Real.pi by positivity) (norm_nonneg (gradient F x))
  dsimp [circuitD]
  nlinarith [Real.sqrt_nonneg (d:ℝ)]

namespace MeanTree
variable {X : Type*} [MeasurableSpace X]

theorem eval_circuitD_bound {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam)
    (x : Point d) (z : X) {A B : ℝ} (hB : 0≤B)
    (hsmall : (lam:ℝ)*A*(2*Real.pi+2)≤1)
    (E : MeanTree X d) (hw : weight E≤A) (hweights : centersBound A E)
    (hb : circuitD F x+(lam:ℝ)*‖base E z-x‖≤B)
    (hc : centers (fun r b => 0≤r ∧ (lam:ℝ)*r^2≤1/2 ∧ (lam:ℝ)*r≤1 ∧
      circuitD F x+(lam:ℝ)*‖b z-x‖≤B) E) :
    circuitD F (E.eval F z)≤((depth E:ℝ)+1)*B := by
  induction E with | node k b hm a r C ih =>
    have hchild (i : Fin k) := ih i (hweights i).1 (hweights i).2 (hc i).1.2.2.2 (hc i).2
    have hd (i : Fin k) : (depth (C i):ℝ)+1≤(depth (node k b hm a r C):ℝ) := by
      exact_mod_cast (Finset.le_sup (f:=fun j => depth (C j)+1) (Finset.mem_univ i))
    have hmean (i : Fin k) : ‖primitiveExpectedField F ((C i).eval F z) (r i)‖≤
        (2*Real.pi+2)*(depth (node k b hm a r C):ℝ)*B := by
      apply (primitiveExpectedField_growth hF _ (hc i).1.1 (hc i).1.2.1 (hc i).1.2.2.1).trans
      exact (mul_le_mul_of_nonneg_left
        ((hchild i).trans (mul_le_mul_of_nonneg_right (hd i) hB)) (by positivity)).trans_eq (by ring)
    have hs : ‖∑i,a i • primitiveExpectedField F ((C i).eval F z) (r i)‖≤
        (∑i,|a i|)*((2*Real.pi+2)*(depth (node k b hm a r C):ℝ)*B) := by
      apply (norm_sum_le _ _).trans
      rw [Finset.sum_mul]
      exact Finset.sum_le_sum (fun i _ => by
        rw [norm_smul,Real.norm_eq_abs]
        exact mul_le_mul_of_nonneg_left (hmean i) (abs_nonneg _))
    have hn : ‖(node k b hm a r C).eval F z-x‖≤‖b z-x‖+
        (∑i,|a i|)*((2*Real.pi+2)*(depth (node k b hm a r C):ℝ)*B) := by
      change ‖b z+(∑i,a i • primitiveExpectedField F ((C i).eval F z) (r i))-x‖≤_
      rw [add_sub_right_comm]
      exact (norm_add_le _ _).trans (add_le_add le_rfl hs)
    have hD := (circuitD_change hF x ((node k b hm a r C).eval F z)).trans
      (add_le_add le_rfl (mul_le_mul_of_nonneg_left hn lam.coe_nonneg))
    change (∑i,|a i|)≤A at hw
    have hmcoef := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hw lam.coe_nonneg)
      (show 0≤2*Real.pi+2 by positivity)
    have hcoef : (lam:ℝ)*(∑i,|a i|)*(2*Real.pi+2)≤1 := hmcoef.trans hsmall
    have hh := mul_le_mul_of_nonneg_right hcoef
      (show 0≤(depth (node k b hm a r C):ℝ)*B by positivity)
    change circuitD F x+(lam:ℝ)*‖b z-x‖≤B at hb
    nlinarith
end MeanTree
end LogConcaveSampling

end

end

end OAI