import Mathlib
import OAI.Probability.LogConcave.Numerics.ReanchorWeight
import OAI.Probability.LogConcave.Sampling.HarmonicPositionDeriv

namespace OAI

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

local instance : DecidableEq Unit := Classical.decEq _

def kernelTransportAction {d : ℕ} (f : Point d → Point d) (p : Point (d+d)) : Point d :=
  (fderiv ℝ f (productPointEquiv d d p).1) (productPointEquiv d d p).2-
    (productPointEquiv d d p).2

lemma kernel_action_between_derivative {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r T : ℝ} (hr : 0<r)
    (hl : (lam:ℝ)*r^2≤1/2) (hT0 : 0≤T) (hT1 : T<1)
    (s e : Icc (0:ℝ) T) (p : Point (d+d))
    (Ξ : Point (d+d) → ℝ → Point (d+d)) (hinit : ∀p,Ξ p 0=p)
    (hder : ∀p v,v∈Icc (0:ℝ) 1 → HasDerivWithinAt (Ξ p)
      (skewLieField (centeringPotential F x r s) (harmonicSkew d) (Ξ p v)) (Icc (0:ℝ) 1) v) :
    let fw := probabilityTransport hF x hr.le hl hT0 hT1 s e
    let W := fun v => (productPointEquiv d d (Ξ p v)).1
    HasDerivWithinAt (fun v => fw (W v)-W v) (kernelTransportAction fw p) (Icc (0:ℝ) 1) 0 := by
  intro fw W
  have hH := (interpolationPotential_smooth hF x hr.le hl s.2.1 (s.2.2.trans_lt hT1)).differentiable
    (by norm_cast)
  have hw := harmonic_position_deriv hH Ξ hder p (by norm_num : (0:ℝ)∈Icc (0:ℝ) 1)
  rw [hinit] at hw
  have hw0 : W 0=(productPointEquiv d d p).1 := by dsimp [W]; rw [hinit]
  have hf := (probabilityTransport_smooth hF x hr.le hl hT0 hT1 s e).differentiable (by norm_cast)
  have he := ((hf (W 0)).hasFDerivAt.comp_hasDerivWithinAt 0 hw).sub hw
  rw [hw0] at he
  exact he

lemma kernel_between_lie_projection {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r R T : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hR : 0<R) (hRT : R^2≤1-T^2)
    (hT0 : 0≤T) (hT1 : T<1) (s e : Icc (0:ℝ) T)
    (Ξ : Point (d+d) → ℝ → Point (d+d)) (hinit : ∀p,Ξ p 0=p)
    (hder : ∀p v,v∈Icc (0:ℝ) 1 → HasDerivWithinAt (Ξ p)
      (skewLieField (centeringPotential F x r s) (harmonicSkew d) (Ξ p v)) (Icc (0:ℝ) 1) v)
    (p : Point (d+d)) :
    let fw := probabilityTransport hF x hr.le hl hT0 hT1 s e
    let A := jointCorrectionArray (fun z => fw z-z)
    meanOutputProjection d (tensorVector (iterTensorLie (centeringPotential F x r s)
      (harmonicSkew d) A 1) p)=kernelTransportAction fw p := by
  intro fw A
  have hH : PolySmooth (centeringPotential F x r s) := productPotential_polySmooth
    (interpolationPotential_polySmooth hF x hr hlam hl s.2.1 (s.2.2.trans_lt hT1))
      (gaussianPotential_polySmooth d)
  have hp := lie_vector_chain hH (harmonicSkew d) A (harmonicSkew_polySmooth d)
    (jointCorrectionArray_polySmooth hF x hr hlam hl hR hRT hT0 hT1 s e)
    (jointSkew_skew _ 1) (Ξ p) (hder p) 0 (by norm_num : (0:ℝ)∈Icc (0:ℝ) 1)
  have hproj := (meanOutputProjection d).hasFDerivAt.comp_hasDerivWithinAt 0 hp
  change HasDerivWithinAt (fun v => meanOutputProjection d
    (tensorVector A (Ξ p v))) (meanOutputProjection d (tensorVector
      (iterTensorLie (centeringPotential F x r s) (harmonicSkew d) A 1) (Ξ p 0)))
      (Icc (0:ℝ) 1) 0 at hproj
  simp only [A,meanOutputProjection_correction,hinit] at hproj
  have hd := kernel_action_between_derivative hF x hr hl hT0 hT1 s e p Ξ hinit hder
  have hu := uniqueDiffOn_Icc (by norm_num : (0:ℝ)<1) 0 (by norm_num)
  exact (hproj.derivWithin hu).symm.trans (hd.derivWithin hu)

theorem kernel_action_between_stencil_rms {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r R T : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hR : 0<R) (hRT : R^2≤1-T^2)
    (hT0 : 0≤T) (hT1 : T<1) (s e : Icc (0:ℝ) T)
    (Ξ : Point (d+d) → ℝ → Point (d+d)) (hinit : ∀p,Ξ p 0=p)
    (hder : ∀p v,v∈Icc (0:ℝ) 1 → HasDerivWithinAt (Ξ p)
      (skewLieField (centeringPotential F x r s) (harmonicSkew d) (Ξ p v)) (Icc (0:ℝ) 1) v)
    (hm : Measurable (fun p : ℝ × Point (d+d) => Ξ p.2 p.1))
    (hlaw : ∀v∈Icc (0:ℝ) 1,(gibbs (centeringPotential F x r s)).map (fun y => Ξ y v)=
      gibbs (centeringPotential F x r s))
    (m : ℕ) (hm1 : 1 ≤ m) (ψ : ℝ) (hψ : 0<ψ) (hψm : ψ*m≤1) :
    let fw := probabilityTransport hF x hr.le hl hT0 hT1 s e
    let W := fun v p => (productPointEquiv d d (Ξ p v)).1
    let K := kernelTransportAction fw
    Measurable K ∧
    Integrable (fun p => ‖derivativeStencil (angleNodes m) ψ
      (fun i => fw (W (ψ*angleNodes m i) p)-W (ψ*angleNodes m i) p)-K p‖^2)
        (gibbs (centeringPotential F x r s)) ∧
    (∫p,‖derivativeStencil (angleNodes m) ψ
      (fun i => fw (W (ψ*angleNodes m i) p)-W (ψ*angleNodes m i) p)-K p‖^2
        ∂gibbs (centeringPotential F x r s))≤
      ((∑i,|derivativeWeight (angleNodes m) i|)/ψ)^2*
        (((ψ*m)^(m+1)/(m.factorial:ℝ))^2*
          ((d*((lam:ℝ)*r^2)^2)*(R⁻¹)^(4*(m+1))*harmonicCorrectionBudget (m+1))) := by
  intro fw W K
  let A := jointCorrectionArray (fun z => fw z-z)
  let J := fun k v p => tensorVector (iterTensorLie (centeringPotential F x r s)
    (harmonicSkew d) A k) (Ξ p v)
  let E := fun p => derivativeStencil (angleNodes m) ψ (fun i => J 0 (ψ*angleNodes m i) p)-J 1 0 p
  have hH : PolySmooth (centeringPotential F x r s) := productPotential_polySmooth
    (interpolationPotential_polySmooth hF x hr hlam hl s.2.1 (s.2.2.trans_lt hT1))
      (gaussianPotential_polySmooth d)
  have hA := jointCorrectionArray_polySmooth hF x hr hlam hl hR hRT hT0 hT1 s e
  have hJ (k : ℕ) (v : ℝ) : Measurable (J k v) := liePathJet_measurable hH
    (harmonicSkew d) A (harmonicSkew_polySmooth d) hA Ξ hm k v
  have hj0 (v : ℝ) (p : Point (d+d)) : meanOutputProjection d (J 0 v p)=fw (W v p)-W v p :=
    meanOutputProjection_correction _ (Ξ p v)
  have hj1 (p : Point (d+d)) : meanOutputProjection d (J 1 0 p)=K p := by
    dsimp only [J]
    rw [hinit]
    exact kernel_between_lie_projection hF x hr hlam hl hR hRT hT0 hT1 s e Ξ hinit hder p
  have hK : Measurable K := by
    have hh := (meanOutputProjection d).continuous.measurable.comp (hJ 1 0)
    simpa only [Function.comp_def,hj1] using hh
  refine ⟨hK,?_⟩
  have he (p : Point (d+d)) : derivativeStencil (angleNodes m) ψ
      (fun i => fw (W (ψ*angleNodes m i) p)-W (ψ*angleNodes m i) p)-K p=
        meanOutputProjection d (E p) := by
    dsimp only [E]
    rw [map_sub,projection_derivativeStencil]
    simp only [hj0,hj1]
  have hb := harmonic_correction_stencil_rms hF x hr hlam hl hR hRT hT0 hT1
    s e s Ξ hder hm hlaw m hm1 ψ hψ hψm
  have hE : Measurable E := (Finset.measurable_sum _ (fun i _ =>
    (hJ 0 (ψ*angleNodes m i)).const_smul (derivativeWeight (angleNodes m) i/ψ))).sub (hJ 1 0)
  have hab (p : Point (d+d)) : ‖meanOutputProjection d (E p)‖^2≤‖E p‖^2 :=
    pow_le_pow_left₀ (norm_nonneg _) (finiteCoordinateProjection_norm_le _ _) 2
  simp_rw [he]
  have hi := hb.1.mono' (((meanOutputProjection d).continuous.measurable.comp hE).norm.pow_const 2).aestronglyMeasurable
    (Filter.Eventually.of_forall (fun p => by simpa only [Real.norm_eq_abs,abs_sq,Function.comp_def,E,J,A,fw] using hab p))
  exact ⟨hi,(integral_mono hi hb.1 hab).trans hb.2⟩
end LogConcaveSampling

end

end

section

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

lemma finite_weighted_lipschitz {I X E : Type*} [Fintype I]
    [PseudoMetricSpace X] [NormedAddCommGroup E] [NormedSpace ℝ E]
    (w : I → ℝ) (f : I → X → E) {K : ℝ≥0} (hf : ∀i,LipschitzWith K (f i)) :
    LipschitzWith ((∑i,‖w i‖₊)*K) (fun x => ∑i,w i • f i x) := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  rw [dist_eq_norm,←Finset.sum_sub_distrib]
  simp_rw [←smul_sub]
  calc
    _ ≤ ∑i,‖w i • (f i x-f i y)‖ := norm_sum_le _ _
    _ = ∑i,|w i| *dist (f i x) (f i y) := by simp only [norm_smul,Real.norm_eq_abs,dist_eq_norm]
    _ ≤ ∑i,|w i| *((K:ℝ)*dist x y) := Finset.sum_le_sum (fun i _ =>
      mul_le_mul_of_nonneg_left ((hf i).dist_le_mul x y) (abs_nonneg _))
    _ = _ := by simp only [←Finset.sum_mul,NNReal.coe_mul,NNReal.coe_sum,coe_nnnorm,Real.norm_eq_abs,mul_assoc]

def kernelActionPicard {d : ℕ} (F : Point d → ℝ) (x : Point d)
    (r T h ψ : ℝ) (n m N : ℕ) (s e : ProbabilityNode T h n)
    (p : Point d × Point d) : Point d :=
  derivativeStencil (angleNodes m) ψ (fun i =>
    let b := probabilityAnchoredPicard F x r T h n N e p.1 s
    let w := harmonicPicard F x r (probabilityNodeTime T h n s)
      (ψ*angleNodes m i) n N (b,p.2) (Fin.last n)
    probabilityAnchoredPicard F x r T h n (N+1) s w e-w)

theorem kernelActionPicard_lipschitz (n : ℕ) (hn : 0<n) :
    ∃A B : ℝ≥0,∀{d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0},
      Primitive F lam → ∀(x : Point d) {r T h ψ : ℝ},0≤r →
        (lam:ℝ)*r^2≤1/2 → 0<T → T<1 → 0<h → 0<ψ →
        ∀m : ℕ,ψ*m≤1 →
        A*probabilityMeanLipschitz lam r≤1/2 →
        B*probabilityMeanLipschitz lam r≤1/2 →
        ∀N : ℕ,∀s e : ProbabilityNode T h n,
      LipschitzWith ((∑i : Fin (m+1),‖derivativeWeight (angleNodes m) i/ψ‖₊)*
        (16*(A*probabilityMeanLipschitz lam r)))
        (kernelActionPicard F x r T h ψ n m N s e) := by
  obtain ⟨A,hA⟩ := probabilityAnchored_lipschitz n hn
  obtain ⟨B,hB⟩ := harmonicPicard_lipschitz n hn
  refine ⟨A,B,?_⟩
  intro d F lam hF x r T h ψ hr hl hT0 hT1 hh hψ m hψm hq hq' N s e
  have htime := probabilityNodeTime_mem hT0 hT1 hh hn s
  have hb : LipschitzWith 2 (fun p : Point d × Point d =>
      (probabilityAnchoredPicard F x r T h n N e p.1 s,p.2)) := by
    have h := (((LipschitzWith.eval s).comp (hA hF x hr hl hT0 hT1 hh hq N e).1).comp
      (LipschitzWith.prod_fst (α:=Point d) (β:=Point d))).prodMk
      (LipschitzWith.prod_snd (α:=Point d) (β:=Point d))
    convert h using 1 <;> first | rfl | norm_num
  have hc : LipschitzWith (2*(A*probabilityMeanLipschitz lam r))
      (fun w => probabilityAnchoredPicard F x r T h n (N+1) s w e-w) := by
    have h := (LipschitzWith.eval e).comp (hA hF x hr hl hT0 hT1 hh hq N s).2
    convert h using 1 <;> first | rfl | simp only [one_mul]
  apply finite_weighted_lipschitz
  intro i
  have hz0 : 0≤ψ*angleNodes m i := mul_nonneg hψ.le (Nat.cast_nonneg _)
  have hz1 : ψ*angleNodes m i≤1 := by
    apply le_trans _ hψm
    apply mul_le_mul_of_nonneg_left _ hψ.le
    change (i:ℝ)≤(m:ℝ)
    exact_mod_cast (Nat.le_of_lt_succ i.2)
  have hw := ((LipschitzWith.eval (Fin.last n)).comp
    (hB hF x hr hl htime.1 (htime.2.trans_lt hT1) hz0 hz1 hq' N).1).comp hb
  have h := hc.comp hw
  convert h using 1 <;> first | rfl | ring

end LogConcaveSampling

end

end

end

end OAI