import Mathlib
import OAI.Probability.LogConcave.JetEstimates.PolySmooth
import OAI.Probability.LogConcave.Sampling.NormalizedTensor
import OAI.Probability.LogConcave.JetEstimates.ContractLeftSplit

namespace OAI

section
section
noncomputable section
namespace LogConcaveSampling
open MeasureTheory
open scoped Classical BigOperators RealInnerProductSpace

lemma directional_basis_sum {d : ℕ} (v : Point d) (f : Point d → ℝ) :
    directional v f=fun x => ∑i : Fin d,
      (EuclideanSpace.basisFun (Fin d) ℝ).repr v i *
        directional (EuclideanSpace.basisFun (Fin d) ℝ i) f x := by
  funext x
  unfold directional
  conv_lhs => arg 2; rw [←(EuclideanSpace.basisFun (Fin d) ℝ).sum_repr v]
  simp only [map_sum,map_smul,smul_eq_mul]

lemma basis_jet_growth_all {d : ℕ} {f : Point d → ℝ}
    (hf : ContDiff ℝ (⊤ : ℕ∞) f)
    (hg : ∀l : List (Fin d),HasPolynomialGrowth
      (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) ℝ) l f))
    (l : List (Point d)) : HasPolynomialGrowth (JetCalculus.jet id l f) := by
  induction l generalizing f with
  | nil => exact hg []
  | cons v l ih =>
    change HasPolynomialGrowth (directional v (JetCalculus.jet id l f))
    rw [←jet_directional hf,directional_basis_sum,
      JetCalculus.jet_sum Finset.univ (fun i _ =>
        contDiff_const.mul (directional_smooth hf _))]
    apply Appell.HasGrowth.sum
    intro i _
    rw [JetCalculus.jet_const_mul (directional_smooth hf _)]
    apply Appell.HasGrowth.mul (growth_const _)
    apply ih (directional_smooth hf _)
    intro k
    have hh := hg (k++[i])
    have he : JetCalculus.jet (EuclideanSpace.basisFun (Fin d) ℝ) [i] f=
        directional (EuclideanSpace.basisFun (Fin d) ℝ i) f := rfl
    rw [JetCalculus.jet_append,he] at hh
    exact hh

lemma PolySmooth.of_basis_growth {d : ℕ} {f : Point d → ℝ}
    (hf : ContDiff ℝ (⊤ : ℕ∞) f)
    (hg : ∀l : List (Fin d),HasPolynomialGrowth
      (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) ℝ) l f)) : PolySmooth f :=
  ⟨hf,basis_jet_growth_all hf hg⟩

lemma growth_of_bounded {d : ℕ} {f : Point d → ℝ} {B : ℝ}
    (hB : 0≤B) (h : ∀x,|f x|≤B) : HasPolynomialGrowth f := by
  refine ⟨B,hB,0,fun x => ?_⟩
  simp only [pow_zero,Real.norm_eq_abs]
  exact (h x).trans (by linarith)

end LogConcaveSampling

end

end

section

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

universe u

lemma normalizedTensor_spatial_allSplit {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    (y : Point d) {S K : Type u} [Fintype S] [Fintype K]
    (mask : S → Bool) (l : List S) (hlne : l≠[])
    (hlN : l.Nodup) (hlall : ∀s,s∈l) (k : List K) (hkN : k.Nodup) (hkall : ∀i,i∈k) :
    TensorEnergy.AllSplitBound (fun c : K ⊕ S → Fin d =>
      JetCalculus.jet (fun i => EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inl i))) k
        (fun y => normalizedTensor F x r ρ ((lam:ℝ)*r) y mask l (fun s => c (Sum.inr s))) y)
      (normalizedTensorMajorant (Fintype.card K+Fintype.card S) (1-ρ^2)) := by
  have hS : 0<Fintype.card S := by
    rw [←list_length_full l hlN hlall]
    exact List.length_pos_iff.mpr hlne
  have he := normalizedTensor_spatial_jet hF x hr hlam hl hρ0 hρ1 y mask l hlne hS
    k (list_length_full k hkN hkall)
  simp_rw [he]
  have hN : (k.map Sum.inl++l.map Sum.inr).Nodup := JetCalculus.nodup_sum_append hkN hlN
  have hall : ∀t : K ⊕ S,t∈k.map Sum.inl++l.map Sum.inr := by
    intro t
    cases t <;> simp [hkall,hlall]
  have hh := (normalizedTensor_allSplit hF x hr hlam hl hρ0 hρ1 y
    (Sum.elim (fun _ => false) mask) (k.map Sum.inl++l.map Sum.inr) hN hall).const_mul
    (ρ^(Fintype.card K))
  simp only [Fintype.card_sum] at hh
  apply hh.mono (mul_nonneg (pow_nonneg hρ0 _) (normalizedTensorMajorant_nonneg _ _))
  exact mul_le_of_le_one_left (normalizedTensorMajorant_nonneg _ _)
    (pow_le_one₀ hρ0 hρ1.le)

lemma normalizedTensor_polySmooth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    {S : Type} [Fintype S] (mask : S → Bool) (l : List S)
    (hlN : l.Nodup) (hlall : ∀s,s∈l) (hS : 2≤Fintype.card S) (c : S → Fin d) :
    PolySmooth (fun y => normalizedTensor F x r ρ ((lam:ℝ)*r) y mask l c) := by
  have hlne : l≠[] := by
    intro he
    have hh := list_length_full l hlN hlall
    simp [he] at hh
    omega
  apply PolySmooth.of_basis_growth (normalizedTensor_smooth hF x hr hlam hl hρ0 hρ1 mask l hlne c)
  intro k
  apply growth_of_bounded (normalizedTensorMajorant_nonneg (k.length+Fintype.card S) (1-ρ^2))
  intro y
  have hh := (normalizedTensor_spatial_allSplit hF x hr hlam hl hρ0 hρ1 y mask l hlne hlN hlall
    (List.finRange k.length) (List.nodup_finRange _) (by simp)).entry_le
      (normalizedTensorMajorant_nonneg _ _) (by simp only [Fintype.card_sum,Fintype.card_fin]; omega)
      (Sum.elim k.get c)
  simp only [Sum.elim_inl,Sum.elim_inr,Fintype.card_fin] at hh
  change |JetCalculus.jet ((EuclideanSpace.basisFun (Fin d) ℝ) ∘ k.get)
    (List.finRange k.length) (fun y => normalizedTensor F x r ρ ((lam:ℝ)*r) y mask l c) y|≤_ at hh
  rw [←JetCalculus.jet_map, List.map_get_finRange] at hh
  exact hh

end LogConcaveSampling

end

end

section

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

lemma conditionalFieldMean_jet_normalized {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    (y : Point d) {S : Type} [Fintype S] (l : List S) (hlen : l.length=Fintype.card S)
    (c : S ⊕ Unit → Fin d) :
    JetCalculus.jet (fun s => EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inl s))) l
      (fun y => inner ℝ (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr ())))
        (conditionalFieldMean F x r ρ y)) y=
      ρ^(Fintype.card S)*((lam:ℝ)*r)*normalizedTensor F x r ρ ((lam:ℝ)*r) y
        (Sum.elim (fun _ => false) (fun _ => true)) (l.map Sum.inl++[Sum.inr ()]) c := by
  have hi : (fun y => inner ℝ (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr ())))
      (conditionalFieldMean F x r ρ y))=
      conditionalMeanScalar F x r ρ (fun z => inner ℝ
        (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inr ()))) (primitiveField F x r z)) :=
    funext (conditionalFieldMean_inner hF x hr.le hl hρ0 hρ1 _)
  rw [hi,conditionalFieldMean_jet_U hF x hr hlam hl hρ0 hρ1]
  unfold conditionalU normalizedTensor
  rw [JetCalculus.jet_append,JetCalculus.jet_map]
  simp only [Fintype.card_sum,Fintype.card_unique,add_tsub_cancel_right,hlen,
    Function.comp_def]
  have hv : (fun s => jointPosition d (EuclideanSpace.basisFun (Fin d) ℝ (c (Sum.inl s))))=
      (fun s => EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ
        (conditionalSlotEmbedding d (Sum.elim (fun _ => false) (fun _ => true)) c (Sum.inl s))) := by
    funext s
    exact jointPosition_basis _
  rw [hv,jointField_basis]
  have he : conditionalSlotEmbedding d (Sum.elim (fun _ : S => false) (fun _ : Unit => true)) c
      (Sum.inr ())=Sum.inr (c (Sum.inr ())) := rfl
  simp only [JetCalculus.jet,he]
  ring

lemma conditionalFieldMean_component_polySmooth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
    (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r)
    (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1)
    (i : Fin d) : PolySmooth (fun y => inner ℝ (EuclideanSpace.basisFun (Fin d) ℝ i)
      (conditionalFieldMean F x r ρ y)) := by
  let v := EuclideanSpace.basisFun (Fin d) ℝ i
  have hs := (innerSL ℝ v).contDiff.comp (conditionalFieldMean_smooth hF x hr.le hl hρ0 hρ1)
  apply PolySmooth.of_basis_growth hs
  intro k
  by_cases hk : k=[]
  · subst k
    exact growth_of_lipschitz ((innerSL ℝ v).lipschitzWith.comp
      (conditionalFieldMean_lipschitz hF x hr.le hl hρ0 hρ1))
  · let c : Fin k.length ⊕ Unit → Fin d := Sum.elim k.get (fun _ => i)
    have he : JetCalculus.jet (EuclideanSpace.basisFun (Fin d) ℝ) k
        (fun y => inner ℝ v (conditionalFieldMean F x r ρ y))=
        fun y => ρ^k.length*((lam:ℝ)*r)*normalizedTensor F x r ρ ((lam:ℝ)*r) y
          (Sum.elim (fun _ => false) (fun _ => true))
          ((List.finRange k.length).map Sum.inl++[Sum.inr ()]) c := by
      funext y
      have hh := conditionalFieldMean_jet_normalized hF x hr hlam hl hρ0 hρ1 y
        (List.finRange k.length) (by simp) c
      simp only [c,Sum.elim_inl,Sum.elim_inr,Fintype.card_fin] at hh
      change JetCalculus.jet ((EuclideanSpace.basisFun (Fin d) ℝ) ∘ k.get)
        (List.finRange k.length) _ y=_ at hh
      rw [←JetCalculus.jet_map,List.map_get_finRange] at hh
      exact hh
    change HasPolynomialGrowth (JetCalculus.jet (EuclideanSpace.basisFun (Fin d) ℝ) k
      (fun y => inner ℝ v (conditionalFieldMean F x r ρ y)))
    rw [he]
    apply Appell.HasGrowth.mul (growth_const _)
    have hN : ((List.finRange k.length).map (Sum.inl : Fin k.length → Fin k.length ⊕ Unit)++
        [Sum.inr ()]).Nodup := by
      simpa using JetCalculus.nodup_sum_append (List.nodup_finRange k.length)
        (by simp : ([()] : List Unit).Nodup)
    have hall : ∀t : Fin k.length ⊕ Unit,t∈(List.finRange k.length).map Sum.inl++[Sum.inr ()] := by
      intro t; cases t <;> simp
    exact (normalizedTensor_polySmooth hF x hr hlam hl hρ0 hρ1 _ _ hN hall
      (by simp; exact List.length_pos_iff.mpr hk) c).growth []

end LogConcaveSampling

end

end

end

end OAI