import Mathlib
import OAI.Probability.LogConcave.Sampling.TransportMajorant
import OAI.Probability.LogConcave.JetEstimates.ArrayRelabel

namespace OAI

section
section
noncomputable section
namespace LogConcaveSampling
open Set Function
open scoped Classical NNReal BigOperators
open TensorEnergy

def composedJetMajorant (n : ℕ) : ℝ :=
  ∑c : OrderedFinpartition n,normalizedTensorMajorant (c.length+2) 1*∏i,transportMajorant (c.partSize i)
lemma composedJetMajorant_nonneg (n : ℕ) : 0≤composedJetMajorant n :=
  Finset.sum_nonneg (fun _ _ => mul_nonneg (normalizedTensorMajorant_nonneg _ _)
    (Finset.prod_nonneg (fun _ _ => transportMajorant_nonneg _)))

lemma backwardFirstJet_iterated_split {d n : ℕ} {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) (t : Icc (0:ℝ) T) (y : Point d) :
    AllSplitBound (arrayTensor (iteratedFDeriv ℝ n
      (fun z => matrixArray d (conditionalFirstJet F x r ((lam:ℝ)*r)
        (t,terminalBackward hF x hr.le hl hT0 hT1 (t,z)))) y))
      (((lam:ℝ)*r)*composedJetMajorant n/R^n) := by
  let f := probabilityTransport hF x hr.le hl hT0 hT1 ⟨T,hT0,le_rfl⟩ t
  let g := fun z => matrixArray d (conditionalFirstJet F x r ((lam:ℝ)*r) (t,z))
  have hf : ContDiff ℝ (⊤:ℕ∞) f := probabilityTransport_smooth hF x hr.le hl hT0 hT1 _ _
  have ht2 : (t:ℝ)^2<1 := by nlinarith [t.2.1,t.2.2]
  have hg0 : ContDiff ℝ (⊤:ℕ∞) (fun z => conditionalFirstJet F x r ((lam:ℝ)*r) (t,z)) := by
    apply contDiff_iff_contDiffAt.mpr
    intro z
    exact (conditionalFirstJet_smooth hF x hr hlam hl ((t:ℝ),z) ht2).comp z
      (contDiffAt_const.prodMk contDiffAt_id)
  have hg : ContDiff ℝ (⊤:ℕ∞) g := (matrixArray d).contDiff.comp hg0
  have htR : R^2≤1-(t:ℝ)^2 := by nlinarith [t.2.1,t.2.2]
  have hh := array_composition_scale (n:=n) y hf hg
    (fun k => ((lam:ℝ)*r)*normalizedTensorMajorant (k+2) 1) transportMajorant
    (fun k => mul_nonneg (mul_nonneg lam.2 hr.le) (normalizedTensorMajorant_nonneg _ _))
    transportMajorant_nonneg R hR 0
    (fun order _ => by simpa only [Nat.add_zero] using
      conditionalFirstJet_iterated_split (n:=order) hF x hr hlam hl t.2.1 (t.2.2.trans_lt hT1) hR htR (f y))
    (fun _ _ => transportMajorant_bound hF x hr hlam hl hR hRT hT0 hT1 _ _ y)
  have he : (fun z => matrixArray d (conditionalFirstJet F x r ((lam:ℝ)*r)
        (t,terminalBackward hF x hr.le hl hT0 hT1 (t,z))))=g ∘ f := by
    funext z
    rw [terminalBackward_eq]
    rfl
  rw [he]
  simpa only [Nat.add_zero,composedJetMajorant,Finset.mul_sum,mul_assoc] using hh

def kernelMajorant (n : ℕ) : ℝ :=
  ∑s∈(Finset.univ : Finset (Fin n)).powerset,jacobianMajorant s.card*composedJetMajorant (n-s.card)
lemma kernelMajorant_nonneg (n : ℕ) : 0≤kernelMajorant n :=
  Finset.sum_nonneg (fun _ _ =>
    mul_nonneg (jacobianMajorant_nonneg _) (composedJetMajorant_nonneg _))

lemma steinIntegrand_iterated_split {d n : ℕ} {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) (t : Icc (0:ℝ) T) (y : Point d) :
    AllSplitBound (arrayTensor (iteratedFDeriv ℝ n
      (fun z => matrixArray d (steinIntegrand hF x hr hl hT0 hT1 (t,z))) y))
      (((lam:ℝ)*r)*kernelMajorant n/R^n) := by
  have hf : ContDiff ℝ (⊤:ℕ∞) (fun z => terminalJacobian hF x hr hl hT0 hT1 (t,z)) :=
    (terminalJacobian_smooth hF x hr hl hT0 hT1).comp
    (contDiff_const.prodMk (contDiff_id (E:=Point d)))
  have hg : ContDiff ℝ (⊤:ℕ∞) (fun z => conditionalFirstJet F x r ((lam:ℝ)*r)
      (t,terminalBackward hF x hr.le hl hT0 hT1 (t,z))) := by
    apply contDiff_iff_contDiffAt.mpr
    intro z
    apply (conditionalFirstJet_smooth hF x hr hlam hl _ (by nlinarith [t.2.1,t.2.2])).comp z
    exact contDiffAt_const.prodMk
      (((terminalBackward_smooth hF x hr.le hl hT0 hT1).comp (contDiff_const.prodMk contDiff_id)).contDiffAt)
  have hh := matrixComposition_split (n:=n) hf hg
    (fun k => jacobianMajorant k/R^k) (fun k => ((lam:ℝ)*r)*composedJetMajorant k/R^k)
    (fun k => div_nonneg (jacobianMajorant_nonneg _) (pow_nonneg hR.le _))
    (fun k => div_nonneg (mul_nonneg (mul_nonneg lam.2 hr.le) (composedJetMajorant_nonneg _)) (pow_nonneg hR.le _)) y
    (fun _ _ => terminalJacobian_iterated_split hF x hr hlam hl hR hRT hT0 hT1 t y)
    (fun _ _ => backwardFirstJet_iterated_split hF x hr hlam hl hR hRT hT0 hT1 t y)
  have he (s : Finset (Fin n)) :
      (jacobianMajorant s.card/R^s.card)*(((lam:ℝ)*r)*composedJetMajorant (n-s.card)/R^(n-s.card))=
        ((lam:ℝ)*r)*(jacobianMajorant s.card*composedJetMajorant (n-s.card))/R^n := by
    rw [div_mul_div_comm,←pow_add,Nat.add_sub_of_le ((Finset.card_le_univ s).trans_eq (Fintype.card_fin n))]
    ring
  simp_rw [he] at hh
  simpa only [steinIntegrand,smoothTimeClip_eq hT0 hT1 t.2,kernelMajorant,
    ←Finset.sum_div,←Finset.mul_sum] using hh
end LogConcaveSampling

end

end

end

end OAI