lean/OAI/Probability/LogConcave/Sampling/AnalyticBase.lean

import Mathlib
import OAI.Probability.LogConcave.JetEstimates.ReindexedMatrix

namespace OAI

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

lemma spatial_contract_allSplit {S T : Type} [Fintype S] [Fintype T]
    [Nonempty S] [Nonempty T] {d : ℕ}
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ)
    (G : (T ⊕ Unit → Fin d) → Point d → ℝ)
    (hF : ∀c,PolySmooth (F c)) (hG : ∀c,PolySmooth (G c)) (j : ℕ) (y : Point d) :
    TensorEnergy.AllSplitBound
      (spatialTensor (fun a x => TensorEnergy.singleContract (fun c => F c x) (fun c => G c x) a)
        (List.finRange j) y)
      (∑s∈(Finset.univ : Finset (Fin j)).powerset,
        spatialEnvelope F s.card y*spatialEnvelope G (j-s.card) y) := by
  have ht := spatialTensor_singleContract F G (fun c => (hF c).smooth) (fun c => (hG c).smooth)
    (List.finRange j) (List.nodup_finRange j) y
  have ht' : spatialTensor (fun a x => TensorEnergy.singleContract (fun c => F c x) (fun c => G c x) a)
      (List.finRange j) y=(fun c => ∑s∈(Finset.univ : Finset (Fin j)).powerset,
        spatialContractTerm (fun k => k∈s) F G (List.finRange j) y c) := by
    funext c
    convert ht c using 1
    · congr 1
      · ext s
        simp only [Finset.mem_powerset,Finset.subset_univ,true_iff]
        intro k _
        simp
      · funext s
        congr 1
  rw [ht']
  apply TensorEnergy.AllSplitBound.sum
  · intro s _; exact mul_nonneg (spatialEnvelope_nonneg _ _ _) (spatialEnvelope_nonneg _ _ _)
  · intro s _
    have hfs := spatialTensor_allSplit_envelope F (fun c => (hF c).smooth)
      (selectList (fun k => k∈s) (List.finRange j))
      (selectList_nodup _ (List.nodup_finRange _)) (selectList_full _ (by simp)) y
    have hgs := spatialTensor_allSplit_envelope G (fun c => (hG c).smooth)
      (selectList (fun k => k∉s) (List.finRange j))
      (selectList_nodup _ (List.nodup_finRange _)) (selectList_full _ (by simp)) y
    simpa only [Fintype.card_coe,Fintype.card_subtype_compl,Fintype.card_fin] using
      spatialContractTerm_allSplit (fun k => k∈s) hfs hgs

lemma spatialEnvelope_contract {S T : Type} [Fintype S] [Fintype T]
    [Nonempty S] [Nonempty T] {d : ℕ}
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ)
    (G : (T ⊕ Unit → Fin d) → Point d → ℝ)
    (hF : ∀c,PolySmooth (F c)) (hG : ∀c,PolySmooth (G c)) (j : ℕ) (y : Point d) :
    spatialEnvelope (fun a x => TensorEnergy.singleContract (fun c => F c x) (fun c => G c x) a) j y ≤
      (2:ℝ)^(j+Fintype.card S+Fintype.card T)*
        ∑s∈(Finset.univ : Finset (Fin j)).powerset,
          spatialEnvelope F s.card y*spatialEnvelope G (j-s.card) y := by
  have hh := TensorEnergy.splitEnvelope_le_pow
    (Finset.sum_nonneg (fun s _ => mul_nonneg (spatialEnvelope_nonneg _ _ _) (spatialEnvelope_nonneg _ _ _)))
    (spatial_contract_allSplit F G hF hG j y)
  simpa only [spatialEnvelope,Fintype.card_sum,Fintype.card_fin,Nat.add_assoc] using hh

theorem spatialEnvelope_contract_moment {S T : Type} [Fintype S] [Fintype T]
    [Nonempty S] [Nonempty T] {d : ℕ} (μ : Measure (Point d))
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ)
    (G : (T ⊕ Unit → Fin d) → Point d → ℝ)
    (hF : ∀c,PolySmooth (F c)) (hG : ∀c,PolySmooth (G c))
    (j n : ℕ) (hn : 0<n) (A B : ℕ → ℝ≥0∞)
    (hA : ∀e≤j,(∫⁻x,ENNReal.ofReal (spatialEnvelope F e x)^(2*n) ∂μ)≤(A e)^(2*n))
    (hB : ∀e≤j,(∫⁻x,ENNReal.ofReal (spatialEnvelope G e x)^(2*n) ∂μ)≤(B e)^(2*n)) :
    (∫⁻x,ENNReal.ofReal (spatialEnvelope
      (fun a y => TensorEnergy.singleContract (fun c => F c y) (fun c => G c y) a) j x)^n ∂μ)≤
      ((2:ℝ≥0∞)^(j+Fintype.card S+Fintype.card T)*
        ∑s∈(Finset.univ : Finset (Fin j)).powerset,A s.card*B (j-s.card))^n := by
  let U : Finset (Fin j) → Point d → ℝ := fun s x =>
    spatialEnvelope F s.card x*spatialEnvelope G (j-s.card) x
  let P := (Finset.univ : Finset (Fin j)).powerset
  have hu (s : Finset (Fin j)) (x : Point d) : 0≤U s x :=
    mul_nonneg (spatialEnvelope_nonneg _ _ _) (spatialEnvelope_nonneg _ _ _)
  have hm (s : Finset (Fin j)) : AEStronglyMeasurable (U s) μ :=
    ((spatialEnvelope_measurable F hF _).mul (spatialEnvelope_measurable G hG _)).aestronglyMeasurable
  have hp (s : Finset (Fin j)) (_ : s∈P) : (∫⁻x,ENNReal.ofReal (U s x)^n ∂μ)≤
      (A s.card*B (j-s.card))^n := by
    have hs : s.card≤j := (Finset.card_le_univ s).trans_eq (Fintype.card_fin j)
    exact natural_moment_mul (spatialEnvelope_measurable F hF _).aestronglyMeasurable
      (spatialEnvelope_measurable G hG _).aestronglyMeasurable
      (spatialEnvelope_nonneg F _) (spatialEnvelope_nonneg G _) n _ _
      (hA s.card hs) (hB (j-s.card) (Nat.sub_le _ _))
  have hh := natural_moment_const_mul
    (fun x => Finset.sum_nonneg (fun s _ => hu s x)) n
    (by positivity : (0:ℝ)≤2^(j+Fintype.card S+Fintype.card T)) _
    (natural_moment_sum_finset P U (fun s _ => hm s) (fun s _ => hu s) hn
      (fun s => A s.card*B (j-s.card)) hp)
  apply (lintegral_mono (fun x => pow_le_pow_left' (ENNReal.ofReal_le_ofReal
    (spatialEnvelope_contract F G hF hG j x)) n)).trans
  simpa only [ENNReal.ofReal_pow (by norm_num : (0:ℝ)≤2),ENNReal.ofReal_ofNat] using hh

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory
open scoped Classical BigOperators ENNReal

def analyticBase (d j n : ℕ) : ℝ := (n:ℝ)+j+Real.log ((d:ℝ)+1)+1

lemma analyticBase_one_le (d j n : ℕ) : 1≤analyticBase d j n := by
  have := Real.log_nonneg (show (1:ℝ)≤(d:ℝ)+1 by linarith [Nat.cast_nonneg (α:=ℝ) d])
  dsimp [analyticBase]; linarith [Nat.cast_nonneg (α:=ℝ) j,Nat.cast_nonneg (α:=ℝ) n]

lemma analyticBase_nat_le (d j n : ℕ) : (n:ℝ)≤analyticBase d j n ∧ (j:ℝ)+1≤analyticBase d j n := by
  have := Real.log_nonneg (show (1:ℝ)≤(d:ℝ)+1 by linarith [Nat.cast_nonneg (α:=ℝ) d])
  dsimp [analyticBase]; constructor <;> linarith [Nat.cast_nonneg (α:=ℝ) j,Nat.cast_nonneg (α:=ℝ) n]

lemma analyticBase_double {d j n e : ℕ} (he : e≤j) :
    analyticBase d e (2*n)≤2*analyticBase d j n := by
  have := Real.log_nonneg (show (1:ℝ)≤(d:ℝ)+1 by linarith [Nat.cast_nonneg (α:=ℝ) d])
  have he' : (e:ℝ)≤j := by exact_mod_cast he
  simp only [analyticBase,Nat.cast_mul,Nat.cast_ofNat]
  nlinarith [Nat.cast_nonneg (α:=ℝ) n,Nat.cast_nonneg (α:=ℝ) j]

lemma analyticBase_mono {d j n e m : ℕ} (he : e≤j) (hm : m≤n) :
    analyticBase d e m≤analyticBase d j n := by
  have he' : (e:ℝ)≤j := by exact_mod_cast he
  have hm' : (m:ℝ)≤n := by exact_mod_cast hm
  dsimp [analyticBase]; linarith

lemma traceMomentOrder_budget {d j c n : ℕ} (hc : 1≤c) (hn : 2≤n) :
    (traceMomentOrder d j c n:ℝ)≤(c:ℝ)*(analyticBase d j n)^2 := by
  have ht := traceMomentOrder_polynomial (d:=d) (j:=j)
    (by exact_mod_cast hc : (1:ℝ)≤c) (by exact_mod_cast hn : (2:ℝ)≤n)
  apply ht.trans
  apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg c)
  apply pow_le_pow_left₀
  · have := Real.log_nonneg (show (1:ℝ)≤(d:ℝ)+1 by linarith [Nat.cast_nonneg (α:=ℝ) d])
    positivity
  · dsimp [analyticBase]; linarith

def TameAt {S : Type} [Fintype S] {d : ℕ} (μ : Measure (Point d))
    (F : (S → Fin d) → Point d → ℝ) (k C : ℕ) (R : ℝ≥0∞) : Prop :=
  ∀j n,2≤n → (∫⁻x,ENNReal.ofReal (spatialEnvelope F j x)^n ∂μ)≤
    (((C:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n))^(C*(j+1))*R^(k+j))^n

lemma TameAt.with_base {S : Type} [Fintype S] {d : ℕ} {μ : Measure (Point d)}
    {F : (S → Fin d) → Point d → ℝ} {k C : ℕ} {R : ℝ≥0∞}
    (h : TameAt μ F k C R) (j n : ℕ) (hn : 2≤n) (D : ℝ≥0∞)
    (hD : (C:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n)≤D) :
    (∫⁻x,ENNReal.ofReal (spatialEnvelope F j x)^n ∂μ)≤(D^(C*(j+1))*R^(k+j))^n :=
  (h j n hn).trans (pow_le_pow_left' (mul_le_mul' (pow_le_pow_left' hD _) le_rfl) _)

lemma TameAt.constant_mono {S : Type} [Fintype S] {d : ℕ} {μ : Measure (Point d)}
    {F : (S → Fin d) → Point d → ℝ} {k C D : ℕ} {R : ℝ≥0∞}
    (h : TameAt μ F k C R) (hC : 1≤C) (hCD : C≤D) : TameAt μ F k D R := by
  intro j n hn
  have hp : (1:ℝ≥0∞)≤(D:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n) :=
    one_le_mul (by exact_mod_cast hC.trans hCD) (by simpa only [ENNReal.ofReal_one] using ENNReal.ofReal_le_ofReal (analyticBase_one_le d j n))
  apply (h.with_base j n hn ((D:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n)) (mul_le_mul' (by exact_mod_cast hCD) le_rfl)).trans
  exact pow_le_pow_left' (mul_le_mul' (pow_le_pow_right₀ hp (Nat.mul_le_mul_right _ hCD)) le_rfl) _

lemma ofReal_base_one_le (d j n : ℕ) : (1:ℝ≥0∞)≤ENNReal.ofReal (analyticBase d j n) := by
  simpa only [ENNReal.ofReal_one] using ENNReal.ofReal_le_ofReal (analyticBase_one_le d j n)

structure TameScore {d : ℕ} (H : Point d → ℝ) (R : ℝ≥0∞) where
  bound : ℕ → ℝ
  nonneg : ∀e,0≤bound e
  hessian : ∀e y,TensorEnergy.AllSplitBound
    (CycleTrace.scorePosition H (EuclideanSpace.basisFun (Fin d) ℝ) e y) (bound e)
  spatial : ∀e,0<e → ∀y,TensorEnergy.AllSplitBound
    (spatialTensor (scoreField H) (List.finRange e) y) (bound e)
  budget : ∀e,ENNReal.ofReal (bound e)≤(40*((e:ℝ≥0∞)+3))^(16*(e+1))*R^e

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory
open scoped Classical BigOperators ENNReal

lemma subset_sum_le_common {j : ℕ} {f : Finset (Fin j) → ℝ≥0∞} {B : ℝ≥0∞}
    (h : ∀s : Finset (Fin j),f s≤B) :
    (∑s∈(Finset.univ : Finset (Fin j)).powerset,f s)≤(2:ℝ≥0∞)^j*B := by
  have hh := Finset.sum_le_sum (s:=(Finset.univ : Finset (Fin j)).powerset) (fun s _ => h s)
  simpa only [Finset.sum_const,Finset.card_powerset,Finset.card_univ,Fintype.card_fin,
    nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] using hh

lemma profile_base_double {d j n e C D : ℕ} (he : e≤j) (hC : 2*C≤D) :
    (C:ℝ≥0∞)*ENNReal.ofReal (analyticBase d e (2*n))≤
      (D:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n) := by
  have hh := ENNReal.ofReal_le_ofReal (analyticBase_double (d:=d) (n:=n) he)
  rw [ENNReal.ofReal_mul (by norm_num),ENNReal.ofReal_ofNat] at hh
  calc
    _ ≤ (C:ℝ≥0∞)*(2*ENNReal.ofReal (analyticBase d j n)) := mul_le_mul' le_rfl hh
    _ = (2*(C:ℝ≥0∞))*ENNReal.ofReal (analyticBase d j n) := by ring
    _ ≤ _ := mul_le_mul' (by exact_mod_cast hC) le_rfl

theorem TameAt.contract {S T : Type} [Fintype S] [Fintype T] [Nonempty S] [Nonempty T]
    {d : ℕ} (μ : Measure (Point d))
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ)
    (G : (T ⊕ Unit → Fin d) → Point d → ℝ)
    (hF : ∀c,PolySmooth (F c)) (hG : ∀c,PolySmooth (G c))
    {k l C E : ℕ} {R : ℝ≥0∞} (hC : 20≤C) (hE : 20≤E)
    (hf : TameAt μ F k C R) (hg : TameAt μ G l E R) :
    TameAt μ (fun a y => TensorEnergy.singleContract (fun c => F c y) (fun c => G c y) a)
      (k+l) (4*(C+E+Fintype.card S+Fintype.card T+1)) R := by
  intro j n hn
  let q := 4*(C+E+Fintype.card S+Fintype.card T+1)
  let D : ℝ≥0∞ := (q:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n)
  have hq : C+E+Fintype.card S+Fintype.card T+2≤q := by dsimp [q]; omega
  have hD2 : 2≤D := by
    have hq2 : 2≤q := by omega
    simpa only [mul_one] using mul_le_mul' (show (2:ℝ≥0∞)≤q by exact_mod_cast hq2) (ofReal_base_one_le d j n)
  have hD : 1≤D := (by norm_num : (1:ℝ≥0∞)≤2).trans hD2
  let A : ℕ → ℝ≥0∞ := fun e => D^(C*(e+1))*R^(k+e)
  let B : ℕ → ℝ≥0∞ := fun e => D^(E*(e+1))*R^(l+e)
  have ha (e : ℕ) (he : e≤j) :
      (∫⁻x,ENNReal.ofReal (spatialEnvelope F e x)^(2*n) ∂μ)≤(A e)^(2*n) :=
    hf.with_base e (2*n) (by omega) D (profile_base_double he (by dsimp [q]; omega))
  have hb (e : ℕ) (he : e≤j) :
      (∫⁻x,ENNReal.ofReal (spatialEnvelope G e x)^(2*n) ∂μ)≤(B e)^(2*n) :=
    hg.with_base e (2*n) (by omega) D (profile_base_double he (by dsimp [q]; omega))
  have hsum : (∑s∈(Finset.univ : Finset (Fin j)).powerset,A s.card*B (j-s.card))≤
      (2:ℝ≥0∞)^j*(D^((C+E)*(j+1))*R^(k+l+j)) := by
    apply subset_sum_le_common
    intro s
    have hs : s.card≤j := (Finset.card_le_univ s).trans_eq (Fintype.card_fin j)
    have he : C*(s.card+1)+E*(j-s.card+1)≤(C+E)*(j+1) := by
      simpa only [Nat.add_mul] using Nat.add_le_add
        (Nat.mul_le_mul_left C (by omega : s.card+1≤j+1))
        (Nat.mul_le_mul_left E (by omega : j-s.card+1≤j+1))
    dsimp [A,B]
    rw [mul_mul_mul_comm,←pow_add,←pow_add,show k+s.card+(l+(j-s.card))=k+l+j from by omega]
    exact mul_le_mul' (pow_le_pow_right₀ hD he) le_rfl
  have htotal : (2:ℝ≥0∞)^(j+Fintype.card S+Fintype.card T)*
      ∑s∈(Finset.univ : Finset (Fin j)).powerset,A s.card*B (j-s.card)≤
      D^(q*(j+1))*R^(k+l+j) := by
    calc
      _ ≤ D^(j+Fintype.card S+Fintype.card T)*
          (D^j*(D^((C+E)*(j+1))*R^(k+l+j))) :=
        mul_le_mul' (pow_le_pow_left' hD2 _) (hsum.trans (mul_le_mul' (pow_le_pow_left' hD2 _) le_rfl))
      _ = D^(j+Fintype.card S+Fintype.card T+j+(C+E)*(j+1))*R^(k+l+j) := by rw [pow_add,pow_add]; ring
      _ ≤ _ := by
        apply mul_le_mul' _ le_rfl
        apply pow_le_pow_right₀ hD
        have he : j+Fintype.card S+Fintype.card T+j≤(Fintype.card S+Fintype.card T+2)*(j+1) := by nlinarith
        have hh := Nat.mul_le_mul_right (j+1) hq
        nlinarith
  exact (spatialEnvelope_contract_moment μ F G hF hG j n (by omega) A B ha hb).trans
    (pow_le_pow_left' htotal n)

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory
open scoped Classical BigOperators ENNReal

def adjointConstant (C s : ℕ) : ℕ := 100*C*(s+2)

lemma adjointConstant_bounds {C s : ℕ} (hC : 20≤C) :
    C*(4*(s+1)+1)≤adjointConstant C s ∧
    80*(s+1)+120≤adjointConstant C s ∧
    18*(s+1)+3≤adjointConstant C s ∧
    4*C+2*s+5≤adjointConstant C s ∧ 120≤adjointConstant C s := by
  have hCs := Nat.mul_le_mul_right s hC
  dsimp [adjointConstant]
  constructor
  · nlinarith
  constructor
  · nlinarith
  constructor
  · nlinarith
  constructor <;> nlinarith

lemma adjoint_base_budget {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n)
    (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) :
    (C:ℝ)*analyticBase d (j+e) (2*traceMomentOrder d j (s+1) n)≤
      ((adjointConstant C s:ℝ)*analyticBase d j n)^2 := by
  let b := analyticBase d j n
  let t := traceMomentOrder d j (s+1) n
  let q := adjointConstant C s
  have hb : 1≤b := analyticBase_one_le _ _ _
  have hb2 : b≤b^2 := by nlinarith
  have ht : (t:ℝ)≤((s:ℝ)+1)*b^2 := by
    simpa only [Nat.cast_add,Nat.cast_one] using traceMomentOrder_budget (d:=d) (j:=j)
      (c:=s+1) (n:=n) (by omega) hn
  have he' : (e:ℝ)≤2*(t:ℝ) := by
    have he0 : e≤2*t := he
    exact_mod_cast he0
  have hj : (j:ℝ)+Real.log ((d:ℝ)+1)+1≤b := by
    dsimp [b,analyticBase]; linarith [Nat.cast_nonneg (α:=ℝ) n]
  have hp : analyticBase d (j+e) (2*t)≤(4*((s:ℝ)+1)+1)*b^2 := by
    simp only [analyticBase,Nat.cast_mul,Nat.cast_ofNat,Nat.cast_add]
    nlinarith
  have hq1 : (1:ℝ)≤q := by
    have := (adjointConstant_bounds (s:=s) hC).2.2.2.2
    dsimp [q]; exact_mod_cast (by omega : 1≤adjointConstant C s)
  have hcoef : (C:ℝ)*(4*((s:ℝ)+1)+1)≤q := by
    exact_mod_cast (adjointConstant_bounds (s:=s) hC).1
  calc
    _ ≤ (C:ℝ)*((4*((s:ℝ)+1)+1)*b^2) := mul_le_mul_of_nonneg_left hp (Nat.cast_nonneg C)
    _ = ((C:ℝ)*(4*((s:ℝ)+1)+1))*b^2 := by ring
    _ ≤ (q:ℝ)*b^2 := mul_le_mul_of_nonneg_right hcoef (sq_nonneg b)
    _ ≤ (q:ℝ)^2*b^2 := mul_le_mul_of_nonneg_right (by nlinarith) (sq_nonneg b)
    _ = _ := by ring

lemma adjoint_score_budget {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n)
    (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) :
    40*((e:ℝ)+3)≤((adjointConstant C s:ℝ)*analyticBase d j n)^2 := by
  let b := analyticBase d j n
  let t := traceMomentOrder d j (s+1) n
  let q := adjointConstant C s
  have hb : 1≤b := analyticBase_one_le _ _ _
  have hb2 : 1≤b^2 := by nlinarith
  have ht : (t:ℝ)≤((s:ℝ)+1)*b^2 := by
    simpa only [Nat.cast_add,Nat.cast_one] using traceMomentOrder_budget (d:=d) (j:=j)
      (c:=s+1) (n:=n) (by omega) hn
  have he' : (e:ℝ)≤2*(t:ℝ) := by
    have he0 : e≤2*t := he
    exact_mod_cast he0
  have hcoef : 80*((s:ℝ)+1)+120≤q := by exact_mod_cast (adjointConstant_bounds (s:=s) hC).2.1
  have hq1 : (1:ℝ)≤q := by nlinarith [Nat.cast_nonneg (α:=ℝ) s]
  calc
    _ ≤ (80*((s:ℝ)+1)+120)*b^2 := by nlinarith
    _ ≤ (q:ℝ)*b^2 := mul_le_mul_of_nonneg_right hcoef (sq_nonneg b)
    _ ≤ (q:ℝ)^2*b^2 := mul_le_mul_of_nonneg_right (by nlinarith) (sq_nonneg b)
    _ = _ := by ring

lemma adjoint_trace_prefactor {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n) :
    (6*(traceMomentOrder d j (s+1) n:ℝ)+1)*Real.exp (1/2)≤
      ((adjointConstant C s:ℝ)*analyticBase d j n)^2 := by
  let b := analyticBase d j n
  let t := traceMomentOrder d j (s+1) n
  let q := adjointConstant C s
  have hb : 1≤b := analyticBase_one_le _ _ _
  have hb2 : 1≤b^2 := by nlinarith
  have ht : (t:ℝ)≤((s:ℝ)+1)*b^2 := by
    simpa only [Nat.cast_add,Nat.cast_one] using traceMomentOrder_budget (d:=d) (j:=j)
      (c:=s+1) (n:=n) (by omega) hn
  have hcoef : 18*((s:ℝ)+1)+3≤q := by exact_mod_cast (adjointConstant_bounds (s:=s) hC).2.2.1
  have hq1 : (1:ℝ)≤q := by nlinarith [Nat.cast_nonneg (α:=ℝ) s]
  have he : Real.exp (1/2)≤3 := (Real.exp_le_exp.mpr (by norm_num : (1:ℝ)/2≤1)).trans Real.exp_one_lt_three.le
  calc
    _ ≤ (6*(t:ℝ)+1)*3 := mul_le_mul_of_nonneg_left he (by positivity)
    _ ≤ (18*((s:ℝ)+1)+3)*b^2 := by nlinarith
    _ ≤ (q:ℝ)*b^2 := mul_le_mul_of_nonneg_right hcoef (sq_nonneg b)
    _ ≤ (q:ℝ)^2*b^2 := mul_le_mul_of_nonneg_right (by nlinarith) (sq_nonneg b)
    _ = _ := by ring

lemma natural_moment_add {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} {f g : Ω → ℝ}
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ)
    (hf0 : ∀x,0≤f x) (hg0 : ∀x,0≤g x) {n : ℕ} (hn : 0<n) (A B : ℝ≥0∞)
    (hA : (∫⁻x,ENNReal.ofReal (f x)^n ∂μ)≤A^n)
    (hB : (∫⁻x,ENNReal.ofReal (g x)^n ∂μ)≤B^n) :
    (∫⁻x,ENNReal.ofReal (f x+g x)^n ∂μ)≤(A+B)^n := by
  apply (norm_le_iff_natural_moment (fun x => add_nonneg (hf0 x) (hg0 x)) hn _).mp
  exact (eLpNorm'_add_le hf hg (by exact_mod_cast hn : (1:ℝ)≤n)).trans
    (add_le_add ((norm_le_iff_natural_moment hf0 hn _).mpr hA)
      ((norm_le_iff_natural_moment hg0 hn _).mpr hB))

end LogConcaveSampling

end

end

section

noncomputable section
namespace LogConcaveSampling
open MeasureTheory
open scoped Classical BigOperators

lemma scoreField_arbitrary_allSplit {d : ℕ} {H : Point d → ℝ}
    (hH : ContDiff ℝ (⊤:ℕ∞) H)
    {K : Type} [Fintype K] (l : List K) (hl : l.Nodup) (hall : ∀k,k∈l) (y : Point d)
    (M : ℝ) (hM : TensorEnergy.AllSplitBound
      (spatialTensor (scoreField H) (List.finRange (Fintype.card K)) y) M) :
    TensorEnergy.AllSplitBound (spatialTensor (scoreField H) l y) M := by
  let e := (Fintype.equivFin K).symm
  have hp : ((List.finRange (Fintype.card K)).map e).Perm l :=
    fullList_perm ((List.nodup_finRange _).map e.injective) hl
      (fun k => by simp only [List.mem_map]; exact ⟨e.symm k,by simp,e.apply_symm_apply k⟩) hall
  have hh := spatialTensor_allSplit_relabel (scoreField H) (fun _ => directional_smooth hH _)
    (Equiv.refl _) e (List.finRange (Fintype.card K)) l hp y M hM
  simpa only [Function.comp_def,Equiv.refl_apply] using hh

def scoreContractSlots (K S : Type) : K ⊕ (Empty ⊕ S) ≃ K ⊕ S :=
  (Equiv.refl K).sumCongr (Equiv.emptySum Empty S)

def adjointCommutator {K S : Type} {d : ℕ}
    (H : Point d → ℝ) (F : (S ⊕ Unit → Fin d) → Point d → ℝ) (l : List K)
    (y : Point d) (c : K ⊕ S → Fin d) : ℝ :=
  ∑s∈l.toFinset.powerset.erase ∅,
    spatialContractTerm (fun k => k∈s) (scoreField H) F l y (c ∘ scoreContractSlots K S)

lemma spatialTensor_adjoint_sum {K S : Type} {d : ℕ}
    {H : Point d → ℝ} (hH : PolySmooth H)
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ) (hF : ∀c,PolySmooth (F c))
    (l : List K) (hl : l.Nodup) (y : Point d) :
    spatialTensor (fun a => tensorAdjoint H (EuclideanSpace.basisFun (Fin d) ℝ)
      (fun z => F (Sum.elim a (fun _ => z)))) l y =
      fun c => spatialAdjointLeading H F l y c+adjointCommutator H F l y c := by
  funext c
  rw [spatialTensor_adjoint hH F hF l hl y c]
  congr 1
  unfold adjointCommutator
  apply Finset.sum_congr rfl
  intro s _
  rw [spatialContractTerm_eq]
  apply Finset.sum_congr rfl
  intro z _
  congr 1

lemma adjointCommutator_allSplit {K S : Type} [Fintype K] [Fintype S] [Nonempty S]
    {d : ℕ} {H : Point d → ℝ} (hH : ContDiff ℝ (⊤:ℕ∞) H)
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ) (hF : ∀c,ContDiff ℝ (⊤:ℕ∞) (F c))
    (l : List K) (hl : l.Nodup) (hall : ∀k,k∈l) (y : Point d)
    (M : ℕ → ℝ) (hM0 : ∀e,0≤M e)
    (hM : ∀e,0<e → TensorEnergy.AllSplitBound (spatialTensor (scoreField H) (List.finRange e) y) (M e)) :
    TensorEnergy.AllSplitBound (adjointCommutator H F l y)
      (∑s∈l.toFinset.powerset.erase ∅, M s.card*spatialEnvelope F (Fintype.card K-s.card) y) := by
  apply TensorEnergy.AllSplitBound.sum
  · intro s _; exact mul_nonneg (hM0 _) (spatialEnvelope_nonneg _ _ _)
  · intro s hs
    have hs0 : s.Nonempty := Finset.nonempty_iff_ne_empty.mpr (Finset.mem_erase.mp hs).1
    let : Nonempty {k // k∈s} := ⟨⟨hs0.choose,hs0.choose_spec⟩⟩
    have hh := scoreField_arbitrary_allSplit hH
      (selectList (fun k => k∈s) l) (selectList_nodup _ hl) (selectList_full _ hall) y _
      (hM (Fintype.card {k // k∈s}) Fintype.card_pos)
    have hf := spatialTensor_allSplit_envelope F hF
      (selectList (fun k => k∉s) l) (selectList_nodup _ hl) (selectList_full _ hall) y
    have hb := (spatialContractTerm_allSplit_nonempty (fun k => k∈s) hh hf).reindex
      (scoreContractSlots K S)
    simpa only [Fintype.card_coe,Fintype.card_subtype_compl] using hb

lemma spatialEnvelope_adjoint {S : Type} [Fintype S] [Nonempty S] {d : ℕ}
    {H : Point d → ℝ} (hH : PolySmooth H)
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ) (hF : ∀c,PolySmooth (F c)) (j : ℕ) (y : Point d)
    (M : ℕ → ℝ) (hM0 : ∀e,0≤M e)
    (hM : ∀e,0<e → TensorEnergy.AllSplitBound (spatialTensor (scoreField H) (List.finRange e) y) (M e)) :
    spatialEnvelope (fun a => tensorAdjoint H (EuclideanSpace.basisFun (Fin d) ℝ)
      (fun z => F (Sum.elim a (fun _ => z)))) j y≤
      (2:ℝ)^(j+Fintype.card S)*(TensorEnergy.splitEnvelope (spatialAdjointLeading H F (List.finRange j) y)+
        ∑s∈(Finset.univ : Finset (Fin j)).powerset,M s.card*spatialEnvelope F (j-s.card) y) := by
  have hh := (TensorEnergy.allSplitBound_envelope (spatialAdjointLeading H F (List.finRange j) y)).add
    (adjointCommutator_allSplit hH.smooth F (fun c => (hF c).smooth) (List.finRange j)
      (List.nodup_finRange _) (by simp) y M hM0 hM)
    (TensorEnergy.splitEnvelope_nonneg _)
    (Finset.sum_nonneg (fun s _ => mul_nonneg (hM0 _) (spatialEnvelope_nonneg _ _ _)))
  rw [←spatialTensor_adjoint_sum hH F hF _ (List.nodup_finRange _) y] at hh
  have hb := TensorEnergy.splitEnvelope_le_pow
    (add_nonneg (TensorEnergy.splitEnvelope_nonneg _) (Finset.sum_nonneg (fun s _ =>
      mul_nonneg (hM0 _) (spatialEnvelope_nonneg _ _ _)))) hh
  simp only [Fintype.card_sum,Fintype.card_fin] at hb
  apply hb.trans
  apply mul_le_mul_of_nonneg_left _ (by positivity)
  apply add_le_add le_rfl
  apply Finset.sum_le_sum_of_subset_of_nonneg
  · intro s _; exact Finset.mem_powerset.mpr (Finset.subset_univ _)
  · intro s _ _; exact mul_nonneg (hM0 _) (spatialEnvelope_nonneg _ _ _)

end LogConcaveSampling

end

end

section

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

lemma adjoint_base_enn {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n)
    (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) :
    (C:ℝ≥0∞)*ENNReal.ofReal (analyticBase d (j+e) (2*traceMomentOrder d j (s+1) n))≤
      ((adjointConstant C s:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n))^2 := by
  have hh := ENNReal.ofReal_le_ofReal (adjoint_base_budget hC hn e he)
  simpa only [ENNReal.ofReal_mul (Nat.cast_nonneg _),ENNReal.ofReal_natCast,
    ENNReal.ofReal_pow (mul_nonneg (Nat.cast_nonneg _) (le_trans zero_le_one (analyticBase_one_le _ _ _)))] using hh

lemma adjoint_score_enn {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n)
    (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) :
    40*((e:ℝ≥0∞)+3)≤((adjointConstant C s:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n))^2 := by
  have hh := ENNReal.ofReal_le_ofReal (adjoint_score_budget hC hn e he)
  simpa only [ENNReal.ofReal_mul (by norm_num : (0:ℝ)≤40),ENNReal.ofReal_ofNat,
    ENNReal.ofReal_add (Nat.cast_nonneg _) (by norm_num : (0:ℝ)≤3),ENNReal.ofReal_natCast,
    ENNReal.ofReal_pow (mul_nonneg (Nat.cast_nonneg _) (le_trans zero_le_one (analyticBase_one_le _ _ _))),
    ENNReal.ofReal_mul (Nat.cast_nonneg _)] using hh

lemma adjoint_trace_enn {d j n C s : ℕ} (hC : 20≤C) (hn : 2≤n) :
    (3*(2*traceMomentOrder d j (s+1) n)+1:ℝ≥0∞)*ENNReal.ofReal (Real.exp (1/2))≤
      ((adjointConstant C s:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n))^2 := by
  have hh := ENNReal.ofReal_le_ofReal (adjoint_trace_prefactor (d:=d) (j:=j) (s:=s) hC hn)
  simp only [ENNReal.ofReal_mul (by positivity : (0:ℝ)≤6*(traceMomentOrder d j (s+1) n:ℝ)+1),
    ENNReal.ofReal_add (by positivity : (0:ℝ)≤6*(traceMomentOrder d j (s+1) n:ℝ)) (by norm_num : (0:ℝ)≤1),
    ENNReal.ofReal_mul (by norm_num : (0:ℝ)≤6),ENNReal.ofReal_ofNat,ENNReal.ofReal_one,
    ENNReal.ofReal_natCast,
    ENNReal.ofReal_pow (mul_nonneg (Nat.cast_nonneg _) (le_trans zero_le_one (analyticBase_one_le _ _ _))),
    ENNReal.ofReal_mul (Nat.cast_nonneg _)] at hh
  convert hh using 1; ring

theorem TameAt.adjoint {S : Type} [Fintype S] [Nonempty S] {d : ℕ}
    {H : Point d → ℝ} {K : ℝ≥0} (hH : PolySmooth H)
    (ht : HasGaussianLowerTail H) (hK : LipschitzWith K (gradient H))
    [IsProbabilityMeasure (gibbs H)]
    (F : (S ⊕ Unit → Fin d) → Point d → ℝ) (hF : ∀c,PolySmooth (F c))
    {k C : ℕ} {R : ℝ≥0∞} (hd : 1≤d) (hC : 20≤C) (hR : 1≤R) (hRf : R≠⊤)
    (hscore : TameScore H R) (hf : TameAt (gibbs H) F k C R) :
    TameAt (gibbs H) (fun a => tensorAdjoint H (EuclideanSpace.basisFun (Fin d) ℝ)
      (fun z => F (Sum.elim a (fun _ => z)))) (k+1) (adjointConstant C (Fintype.card S)) R := by
  intro j n hn
  let s := Fintype.card S
  let q := adjointConstant C s
  let D : ℝ≥0∞ := (q:ℝ≥0∞)*ENNReal.ofReal (analyticBase d j n)
  let A : ℝ≥0∞ := D^(2*C)
  have hq120 : 120≤q := (adjointConstant_bounds (s:=s) hC).2.2.2.2
  have hCq : C≤q := by dsimp [q,adjointConstant]; nlinarith
  have hD2 : 2≤D := by
    simpa only [mul_one] using mul_le_mul' (show (2:ℝ≥0∞)≤q by exact_mod_cast (by omega : 2≤q)) (ofReal_base_one_le d j n)
  have hD : 1≤D := (by norm_num : (1:ℝ≥0∞)≤2).trans hD2
  have hDf : D≠⊤ := by dsimp [D]; finiteness
  have hA : 1≤A := one_le_pow₀ hD
  have hAf : A≠⊤ := ENNReal.pow_ne_top hDf
  let B : ℝ≥0∞ := D^((4*C+s+3)*(j+1))*R^(k+j+1)
  have hp (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) :
      (∫⁻x,ENNReal.ofReal (spatialEnvelope F (j+e) x)^(2*traceMomentOrder d j (s+1) n) ∂gibbs H)≤
      (A^(j+e+1)*R^(k+j+e))^(2*traceMomentOrder d j (s+1) n) := by
    have ht0 := (traceMomentOrder_bounds (d:=d) (j:=j)
      (by have := Nat.cast_nonneg (α:=ℝ) s; linarith : (1:ℝ)≤(s:ℝ)+1) (by exact_mod_cast hn : (2:ℝ)≤n)).1
    have hh := hf.with_base (j+e) _ (by omega) (D^2) (adjoint_base_enn hC hn e he)
    simpa only [A,←pow_mul,Nat.mul_assoc,Nat.mul_comm,Nat.mul_left_comm,Nat.add_assoc] using hh
  have hh (e : ℕ) (he : e≤2*traceMomentOrder d j (s+1) n) (x : Point d) :
      ENNReal.ofReal (hscore.bound e)≤A^(e+1)*R^e := by
    apply (hscore.budget e).trans
    apply mul_le_mul' _ le_rfl
    apply (pow_le_pow_left' (adjoint_score_enn hC hn e he) _).trans
    simp only [A,←pow_mul]
    apply pow_le_pow_right₀ hD
    have := Nat.mul_le_mul_right (e+1) (by omega : 32≤2*C)
    nlinarith
  have hl : (∫⁻x,ENNReal.ofReal (TensorEnergy.splitEnvelope (spatialAdjointLeading H F (List.finRange j) x))^n ∂gibbs H)≤B^n := by
    apply (spatialAdjoint_envelope_moment hH ht hK F hF (fun e _ => hscore.bound e)
      (fun e _ => hscore.nonneg e) hscore.hessian j k n hd hn A R hA hR hAf hRf hp hh).trans
    apply pow_le_pow_left'
    calc
      _ ≤ D^(j+s)*(D^2*A^(2*(j+1))*R^(k+j+1)) :=
        mul_le_mul' (pow_le_pow_left' hD2 _) (mul_le_mul' (mul_le_mul' (adjoint_trace_enn hC hn) le_rfl) le_rfl)
      _ = D^(j+s+2+4*C*(j+1))*R^(k+j+1) := by dsimp [A]; rw [←pow_mul]; ring_nf
      _ ≤ B := by
        apply mul_le_mul' _ le_rfl
        apply pow_le_pow_right₀ hD
        nlinarith
  let U : Finset (Fin j) → Point d → ℝ := fun a x => hscore.bound a.card*spatialEnvelope F (j-a.card) x
  let P := (Finset.univ : Finset (Fin j)).powerset
  let E : ℝ≥0∞ := D^(2*C*(j+1))*R^(k+j+1)
  have hu0 (a : Finset (Fin j)) (x : Point d) : 0≤U a x :=
    mul_nonneg (hscore.nonneg _) (spatialEnvelope_nonneg _ _ _)
  have hum (a : Finset (Fin j)) : AEStronglyMeasurable (U a) (gibbs H) :=
    ((spatialEnvelope_measurable F hF _).const_mul _).aestronglyMeasurable
  have hsbase (e : ℕ) (he : e≤j) : 40*((e:ℝ≥0∞)+3)≤D := by
    have he' : (e:ℝ)≤j := by exact_mod_cast he
    have hb := (analyticBase_nat_le d j n).2
    have hb0 : 0≤analyticBase d j n := (zero_le_one.trans (analyticBase_one_le _ _ _))
    have hq' : (120:ℝ)≤q := by exact_mod_cast hq120
    have hb' : 40*((e:ℝ)+3)≤(q:ℝ)*analyticBase d j n := by nlinarith
    have hb'' := ENNReal.ofReal_le_ofReal hb'
    simpa only [ENNReal.ofReal_mul (by norm_num : (0:ℝ)≤40),ENNReal.ofReal_ofNat,
      ENNReal.ofReal_add (Nat.cast_nonneg _) (by norm_num : (0:ℝ)≤3),ENNReal.ofReal_natCast,
      ENNReal.ofReal_mul (Nat.cast_nonneg _)] using hb''
  have hup (a : Finset (Fin j)) : (∫⁻x,ENNReal.ofReal (U a x)^n ∂gibbs H)≤E^n := by
    have ha : a.card≤j := (Finset.card_le_univ a).trans_eq (Fintype.card_fin j)
    have hm := hf.with_base (j-a.card) n hn D (mul_le_mul' (by exact_mod_cast hCq)
      (ENNReal.ofReal_le_ofReal (analyticBase_mono (Nat.sub_le _ _) le_rfl)))
    have hh := natural_moment_const_mul (spatialEnvelope_nonneg F _) n (hscore.nonneg a.card) _ hm
    apply hh.trans
    apply pow_le_pow_left'
    calc
      _ ≤ (D^(16*(a.card+1))*R^a.card)*(D^(C*(j-a.card+1))*R^(k+(j-a.card))) :=
        mul_le_mul' ((hscore.budget a.card).trans (mul_le_mul' (pow_le_pow_left' (hsbase a.card ha) _) le_rfl)) le_rfl
      _ = D^(16*(a.card+1)+C*(j-a.card+1))*R^(k+j) := by
        rw [mul_mul_mul_comm,←pow_add,←pow_add,show a.card+(k+(j-a.card))=k+j from by omega]
      _ ≤ E := by
        apply mul_le_mul' _ (pow_le_pow_right₀ hR (by omega))
        apply pow_le_pow_right₀ hD
        have h16 := Nat.mul_le_mul_right (a.card+1) (by omega : 16≤C)
        have he := Nat.sub_add_cancel ha
        nlinarith
  have hsum : (∫⁻x,ENNReal.ofReal (∑a∈P,U a x)^n ∂gibbs H)≤((2:ℝ≥0∞)^j*E)^n := by
    have hm := natural_moment_sum_finset P U (fun a _ => hum a) (fun a _ => hu0 a) (by omega) (fun _ => E) (fun a _ => hup a)
    apply hm.trans
    apply pow_le_pow_left'
    exact subset_sum_le_common (fun _ => le_rfl)
  have hsB : (2:ℝ≥0∞)^j*E≤B := by
    calc
      _ ≤ D^j*E := mul_le_mul' (pow_le_pow_left' hD2 _) le_rfl
      _ = D^(j+2*C*(j+1))*R^(k+j+1) := by dsimp [E]; rw [pow_add]; ring
      _ ≤ B := by
        apply mul_le_mul' _ le_rfl
        apply pow_le_pow_right₀ hD
        nlinarith
  have hlm : AEStronglyMeasurable (fun x => TensorEnergy.splitEnvelope (spatialAdjointLeading H F (List.finRange j) x)) (gibbs H) :=
    (TensorEnergy.measurable_splitEnvelope _ (fun c => (spatialAdjoint_polySmooth hH F hF _ c).smooth.continuous.measurable)).aestronglyMeasurable
  have hsm : AEStronglyMeasurable (fun x => ∑a∈P,U a x) (gibbs H) := by
    have he : (fun x => ∑a∈P,U a x)=∑a∈P,U a := by ext x; simp
    rw [he]
    exact Finset.aestronglyMeasurable_sum P (fun a _ => hum a)
  have hsum0 (x : Point d) : 0≤∑a∈P,U a x := Finset.sum_nonneg (fun a _ => hu0 a x)
  have hcomb := natural_moment_add hlm hsm (fun _ => TensorEnergy.splitEnvelope_nonneg _) hsum0
    (by omega : 0<n) B B hl (hsum.trans (pow_le_pow_left' hsB n))
  have hscale := natural_moment_const_mul (fun x => add_nonneg (TensorEnergy.splitEnvelope_nonneg _) (hsum0 x))
    n (by positivity : (0:ℝ)≤2^(j+s)) _ hcomb
  apply (lintegral_mono (fun x => pow_le_pow_left' (ENNReal.ofReal_le_ofReal
    (spatialEnvelope_adjoint hH F hF j x hscore.bound hscore.nonneg (fun e he => hscore.spatial e he x))) n)).trans
  apply hscale.trans
  apply pow_le_pow_left'
  simp only [ENNReal.ofReal_pow (by norm_num : (0:ℝ)≤2),ENNReal.ofReal_ofNat]
  calc
    _ = (2:ℝ≥0∞)^(j+s)*(2*B) := by rw [two_mul]
    _ ≤ D^(j+s)*(D*B) := mul_le_mul' (pow_le_pow_left' hD2 _) (mul_le_mul' hD2 le_rfl)
    _ = D^(j+s+1+(4*C+s+3)*(j+1))*R^(k+j+1) := by dsimp [B]; rw [pow_add,pow_add]; ring
    _ ≤ D^(q*(j+1))*R^((k+1)+j) := by
      rw [show k+1+j=k+j+1 by omega]
      apply mul_le_mul' _ le_rfl
      apply pow_le_pow_right₀ hD
      have hq := (adjointConstant_bounds (s:=s) hC).2.2.2.1
      have hh := Nat.mul_le_mul_right (j+1) hq
      dsimp [q] at *
      nlinarith

end LogConcaveSampling

end

end

end

end OAI