import Mathlib
import OAI.Probability.SKFluctuations.MarkedAttachPreserves
import OAI.Probability.SKFluctuations.ScalarWeightedJet

namespace OAI

/-! Diagonal. -/

noncomputable section

open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter Set
open scoped Topology
open MeasureTheory ProbabilityTheory Filter Set
namespace SKFluctuations.GaussianCalculus
open MeasureTheory ProbabilityTheory Filter Set Hierarchy
open scoped Topology NNReal BigOperators
variable {ι : Type*} [Fintype ι]

theorem ExpNormBounded.diagonal {f : (ι → ℝ) → ℝ} (hf : ExpNormBounded f)
    (x a : ι → ℝ) : ExpNormBounded (fun z => f (x+a*z)) := by
  obtain ⟨C,c,hC,hc,hb⟩ := hf.2
  refine ⟨hf.1.comp (continuous_const.add (continuous_const.mul continuous_id)),
    C*Real.exp (c*‖x‖), c*‖a‖, by positivity, by positivity, fun z => ?_⟩
  calc
    _ ≤ C*Real.exp (c*‖x+a*z‖) := hb _
    _ ≤ C*Real.exp (c*(‖x‖+‖a‖*‖z‖)) := by
      gcongr
      exact (norm_add_le _ _).trans (add_le_add le_rfl (norm_mul_le a z))
    _ = _ := by rw [mul_add,Real.exp_add]; ring_nf

theorem ExpNormBounded.diagonal_integrable {f : (ι → ℝ) → ℝ} (hf : ExpNormBounded f)
    {ν : Measure (ι → ℝ)} (hν : ExponentialIncrement ν) (x a : ι → ℝ) :
    Integrable (fun z => f (x+a*z)) ν := by
  simpa only [one_smul,zero_add] using (hf.diagonal x a).affine_integrable hν 0 1

theorem ExpNormBounded.diagonal_coord_integrable {f : (ι → ℝ) → ℝ} (hf : ExpNormBounded f)
    (q : ι → ℝ≥0) (x a : ι → ℝ) (i : ι) :
    Integrable (fun z => z i*f (x+a*z)) (Measure.pi fun i => gaussianReal 0 (q i)) := by
  simpa only [one_smul,zero_add] using (hf.diagonal x a).affine_coord_integrable q 0 1 i

 

theorem standardGaussianVector_diagonal_stein {n : ℕ} (i : Fin (n+1))
    {f f₁ : (Fin (n+1) → ℝ) → ℝ} (hf : ExpNormBounded f) (hf₁ : ExpNormBounded f₁)
    (hd : ∀ x t, HasDerivAt (fun s : ℝ => f (x+s • Pi.single i 1))
      (f₁ (x+t • Pi.single i 1)) t) (x a : Fin (n+1) → ℝ) :
    (∫ z, z i*f (x+a*z) ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)) =
      a i * ∫ z, f₁ (x+a*z) ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1) := by
  have h := standardGaussianVector_stein i
    (f := fun z => f (x+a*z)) (f₁ := fun z => a i*f₁ (x+a*z))
    ?_ (hf.diagonal_integrable (exponentialIncrement_gaussian (fun _ => 1)) x a)
    ((hf₁.diagonal_integrable (exponentialIncrement_gaussian (fun _ => 1)) x a).const_mul (a i))
    (hf.diagonal_coord_integrable (fun _ => 1) x a i)
  · simpa only [integral_const_mul] using h
  · intro y t
    have he (s : ℝ) : x+a*i.insertNth s y =
        (x+a*i.insertNth 0 y)+(a i*s) • Pi.single i 1 := by
      ext j
      by_cases hj : j = i
      · subst j
        simp
      · obtain ⟨k,rfl⟩ := (Fin.eq_self_or_eq_succAbove i j).resolve_left hj
        simp
    have hd' := (hd (x+a*i.insertNth 0 y) (a i*t)).comp t
      ((hasDerivAt_id t).const_mul (a i))
    simpa only [Function.comp_def, ← he,mul_one] using hd'.congr_deriv (mul_comm _ _)

end SKFluctuations.GaussianCalculus

namespace SKFluctuations.GaussianCalculus
open MeasureTheory ProbabilityTheory Filter Set Hierarchy
open scoped Topology NNReal BigOperators

 

theorem hasDerivAt_diagonal_heat_continuation {n : ℕ}
    {F : (Fin (n+1) → ℝ) → ℝ} {G H : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ} {C : ℝ≥0}
    (hF : LipschitzWith C F) (hG : ∀ i, BddSmooth 0 (G i)) (hH : ∀ i, BddSmooth 0 (H i))
    (hd : ∀ x v t, HasDerivAt (fun s : ℝ => F (x+s • v))
      (∑ i, v i*G i (x+t • v)) t)
    (hd₁ : ∀ i x t, HasDerivAt (fun s : ℝ => G i (x+s • Pi.single i 1))
      (H i (x+t • Pi.single i 1)) t)
    {a a' : ℝ → (Fin (n+1) → ℝ)} {l r A B t m : ℝ} (ht : t ∈ Ioo l r)
    (ha : ∀ s ∈ Ioo l r, HasDerivAt a (a' s) s)
    (hA : ∀ s ∈ Ioo l r, ‖a s‖ ≤ A) (hB : ∀ s ∈ Ioo l r, ‖a' s‖ ≤ B)
    (hm : m ≠ 0) (x : Fin (n+1) → ℝ) :
    HasDerivAt (fun s => Real.log (∫ z, Real.exp (m*F (x+a s*z))
        ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1))/m)
      (∑ i, a t i*a' t i *
        (tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+a t*z)) (fun z => H i (x+a t*z)) + m *
         tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+a t*z)) (fun z => (G i (x+a t*z))^2))) t := by
  let P := fun y => Real.exp (m*F y)
  let P₁ := fun i y => m*G i y*P y
  let P₂ := fun i y => (m*H i y + m^2*(G i y)^2)*P y
  let ν := Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1)
  have hν : ExponentialIncrement ν := exponentialIncrement_gaussian (fun _ => 1)
  have hP : ExpNormBounded P := ExpNormBounded.exp_lipschitz hF m
  have hB₁ (i) : BddSmooth 0 (fun y => m*G i y) := (hG i).const_mul m
  have hB₂ (i) : BddSmooth 0 (fun y => m*H i y + m^2*(G i y)^2) := by
    simpa only [pow_two] using ((hH i).const_mul m).add (((hG i).mul (hG i)).const_mul (m*m))
  have hdP (y v : Fin (n+1) → ℝ) (s : ℝ) :
      HasDerivAt (fun r : ℝ => P (y+r • v)) (∑ i, v i*P₁ i (y+s • v)) s := by
    apply (((hd y v s).const_mul m).exp).congr_deriv
    dsimp [P₁,P]
    rw [Finset.mul_sum, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    ring
  have hdP₁ (i) (y : Fin (n+1) → ℝ) (s : ℝ) :
      HasDerivAt (fun r : ℝ => P₁ i (y+r • Pi.single i 1))
        (P₂ i (y+s • Pi.single i 1)) s := by
    have hp := hdP y (Pi.single i 1) s
    simp only [Pi.single_apply, ite_mul, one_mul, zero_mul, Finset.sum_ite_eq', Finset.mem_univ, ite_true] at hp
    apply (((hd₁ i y s).const_mul m).mul hp).congr_deriv
    dsimp [P₂,P₁]
    ring
  have hs (i) : (∫ z, z i*P₁ i (x+a t*z) ∂ν) =
      a t i*∫ z, P₂ i (x+a t*z) ∂ν :=
    standardGaussianVector_diagonal_stein i (hP.bdd_mul (hB₁ i))
      (hP.bdd_mul (hB₂ i)) (hdP₁ i) x (a t)
  have h := hasDerivAt_integral_exp_scaledSource hν hF (fun i => (hG i).continuous)
    hd ht ha hA hB m x
  have hp : 0 < ∫ z, P (x+a t*z) ∂ν := partition_pos m (hP.diagonal_integrable hν x _)
  have hGs (i) : BddSmooth 0 (fun y => (G i y)^2) := by
    simpa only [pow_two] using (hG i).mul (hG i)
  have hiH (i) : Integrable (fun z => H i (x+a t*z)*P (x+a t*z)) ν :=
    (hP.bdd_mul (hH i)).diagonal_integrable hν x _
  have hiGs (i) : Integrable (fun z => (G i (x+a t*z))^2*P (x+a t*z)) ν :=
    (hP.bdd_mul (hGs i)).diagonal_integrable hν x _
  have he (i) : (∫ z, P₂ i (x+a t*z) ∂ν) =
      m*(∫ z, H i (x+a t*z)*P (x+a t*z) ∂ν) +
      m^2*(∫ z, (G i (x+a t*z))^2*P (x+a t*z) ∂ν) := by
    rw [← integral_const_mul, ← integral_const_mul,
      ← integral_add ((hiH i).const_mul m) ((hiGs i).const_mul (m^2))]
    apply integral_congr_ae
    exact Eventually.of_forall fun z => by dsimp [P₂]; ring
  have he' : (∫ z, m*(∑ i, (a' t*z) i*G i (x+a t*z))*P (x+a t*z) ∂ν) =
      ∑ i, a' t i*(∫ z, z i*P₁ i (x+a t*z) ∂ν) := by
    simp_rw [← integral_const_mul]
    rw [← integral_finsetSum _ (fun i _ =>
      ((hP.bdd_mul (hB₁ i)).diagonal_coord_integrable (fun _ => 1) x (a t) i).const_mul (a' t i))]
    apply integral_congr_ae
    exact Eventually.of_forall fun z => by
      dsimp only
      rw [Finset.mul_sum,Finset.sum_mul]
      apply Finset.sum_congr rfl
      intro i _
      dsimp [P₁]
      ring
  apply ((h.log hp.ne').div_const m).congr_deriv
  change ((∫ z, m*(∑ i, (a' t*z) i*G i (x+a t*z))*P (x+a t*z) ∂ν)/
    (∫ z, P (x+a t*z) ∂ν))/m = _
  rw [he',Finset.sum_div,Finset.sum_div]
  apply Finset.sum_congr rfl
  intro i _
  rw [hs,he]
  simp only [tiltedMean]
  dsimp [P,ν] at *
  field_simp

end SKFluctuations.GaussianCalculus

namespace SKFluctuations.GaussianCalculus
open MeasureTheory ProbabilityTheory Filter Set Hierarchy
open scoped Topology NNReal BigOperators

 

theorem hasDerivAt_signed_variance_continuation {n : ℕ}
    {F : (Fin (n+1) → ℝ) → ℝ} {G H : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ} {C : ℝ≥0}
    (hF : LipschitzWith C F) (hG : ∀ i, BddSmooth 0 (G i)) (hH : ∀ i, BddSmooth 0 (H i))
    (hd : ∀ x v t, HasDerivAt (fun s : ℝ => F (x+s • v))
      (∑ i, v i*G i (x+t • v)) t)
    (hd₁ : ∀ i x t, HasDerivAt (fun s : ℝ => G i (x+s • Pi.single i 1))
      (H i (x+t • Pi.single i 1)) t)
    (q d : Fin (n+1) → ℝ) {t m : ℝ} (ht : ∀ i, 0 < q i+t*d i) (hm : m ≠ 0)
    (x : Fin (n+1) → ℝ) :
    HasDerivAt (fun s => Real.log (∫ z, Real.exp (m*F (x+(fun i => Real.sqrt (q i+s*d i))*z))
        ∂Measure.pi (fun _ : Fin (n+1) => gaussianReal 0 1))/m)
      (∑ i, (d i/2) *
        (tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+(fun i => Real.sqrt (q i+t*d i))*z))
          (fun z => H i (x+(fun i => Real.sqrt (q i+t*d i))*z)) + m *
         tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+(fun i => Real.sqrt (q i+t*d i))*z))
          (fun z => (G i (x+(fun i => Real.sqrt (q i+t*d i))*z))^2))) t := by
  let a := fun s i => Real.sqrt (q i+s*d i)
  let a' := fun s i => d i/(2*Real.sqrt (q i+s*d i))
  have ha : Continuous a := continuous_pi fun i => (continuous_const.add (continuous_id.mul continuous_const)).sqrt
  have ha' : ContinuousAt a' t := continuousAt_pi.mpr fun i =>
    continuousAt_const.div (continuousAt_const.mul
      (continuousAt_const.add (continuousAt_id.mul continuousAt_const)).sqrt)
      (mul_ne_zero (by norm_num) (Real.sqrt_ne_zero'.mpr (ht i)))
  have hp : ∀ᶠ s in 𝓝 t, ∀ i, 0 < q i+s*d i := by
    rw [eventually_all]
    intro i
    exact (continuousAt_const.add (continuousAt_id.mul continuousAt_const)).eventually
      (eventually_gt_nhds (ht i))
  have hA : ∀ᶠ s in 𝓝 t, ‖a s‖ ≤ ‖a t‖+1 :=
    (ha.continuousAt.norm.eventually (eventually_lt_nhds (lt_add_one _))).mono fun _ h => h.le
  have hB : ∀ᶠ s in 𝓝 t, ‖a' s‖ ≤ ‖a' t‖+1 :=
    (ha'.norm.eventually (eventually_lt_nhds (lt_add_one _))).mono fun _ h => h.le
  obtain ⟨l,r,htr,hlr⟩ := (hp.and (hA.and hB)).exists_Ioo_subset
  have haD (s) (hs : s ∈ Ioo l r) : HasDerivAt a (a' s) s := by
    apply hasDerivAt_pi.mpr
    intro i
    simpa only [a, a', id_eq, one_mul] using
      (((hasDerivAt_id s).mul_const (d i)).const_add (q i)).sqrt ((hlr hs).1 i).ne'
  have hh := hasDerivAt_diagonal_heat_continuation hF hG hH hd hd₁ htr haD
    (fun s hs => (hlr hs).2.1) (fun s hs => (hlr hs).2.2) hm x
  apply hh.congr_deriv
  apply Finset.sum_congr rfl
  intro i _
  dsimp [a,a']
  rw [show Real.sqrt (q i+t*d i)*(d i/(2*Real.sqrt (q i+t*d i))) = d i/2 by
    field_simp [Real.sqrt_ne_zero'.mpr (ht i)]]

end SKFluctuations.GaussianCalculus

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι : Type*} [Fintype ι]

theorem integral_diagonalGaussian (q : ι → ℝ≥0) {f : (ι → ℝ) → ℝ} (hf : Continuous f) :
    (∫ z, f (fun i => Real.sqrt (q i)*z i) ∂Measure.pi fun _ : ι => gaussianReal 0 1) =
      ∫ z, f z ∂Measure.pi fun i => gaussianReal 0 (q i) := by
  have hh := integral_map_of_stronglyMeasurable (μ := Measure.pi fun _ : ι => gaussianReal 0 1)
    (diagonalDriver q).measurable hf.stronglyMeasurable
  change (∫ z, f z ∂linearGaussian (diagonalDriver q) 1) = _ at hh
  rw [linearGaussian_diagonal] at hh
  exact hh.symm

noncomputable def varianceContinuation (m : ℝ) (F : (ι → ℝ) → ℝ) (q : ι → ℝ) : (ι → ℝ) → ℝ :=
  shiftedContinuation (Measure.pi fun i => gaussianReal 0 (Real.toNNReal (q i))) m F

noncomputable def varianceTest (m : ℝ) (F A : (ι → ℝ) → ℝ) (q : ι → ℝ) : (ι → ℝ) → ℝ :=
  shiftedMean (Measure.pi fun i => gaussianReal 0 (Real.toNNReal (q i))) m F A

theorem varianceContinuation_eq {F : (ι → ℝ) → ℝ} (hF : Continuous F)
    (m : ℝ) {q : ι → ℝ} (hq : ∀ i, 0 ≤ q i) (x : ι → ℝ) :
    varianceContinuation m F q x = Real.log (∫ z, Real.exp (m*F (x+(fun i => Real.sqrt (q i))*z))
      ∂Measure.pi fun _ : ι => gaussianReal 0 1)/m := by
  have hi := integral_diagonalGaussian (fun i => Real.toNNReal (q i))
    (f := fun z => Real.exp (m*F (x+z))) (by fun_prop)
  simp only [Real.coe_toNNReal _ (hq _)] at hi
  exact congrArg (fun z => Real.log z/m) hi.symm

theorem varianceTest_eq {F A : (ι → ℝ) → ℝ} (hF : Continuous F) (hA : Continuous A)
    (m : ℝ) {q : ι → ℝ} (hq : ∀ i, 0 ≤ q i) (x : ι → ℝ) :
    varianceTest m F A q x = tiltedMean (Measure.pi fun _ : ι => gaussianReal 0 1) m
      (fun z => F (x+(fun i => Real.sqrt (q i))*z)) (fun z => A (x+(fun i => Real.sqrt (q i))*z)) := by
  have hn := integral_diagonalGaussian (fun i => Real.toNNReal (q i))
    (f := fun z => A (x+z)*Real.exp (m*F (x+z))) (by fun_prop)
  have hd := integral_diagonalGaussian (fun i => Real.toNNReal (q i))
    (f := fun z => Real.exp (m*F (x+z))) (by fun_prop)
  simp only [Real.coe_toNNReal _ (hq _)] at hn hd
  exact congrArg₂ (· / ·) hn.symm hd.symm

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι : Type*} [Fintype ι]

noncomputable def signedVarianceDerivative (m : ℝ) (F : (ι → ℝ) → ℝ)
    (G H : ι → (ι → ℝ) → ℝ) (d q : ι → ℝ) (x : ι → ℝ) : ℝ :=
  ∑ i, (d i/2)*(varianceTest m F (H i) q x + m*varianceTest m F (fun y => (G i y)^2) q x)

 

theorem parametric_signed_variance {n : ℕ}
    {F : (Fin (n+1) → ℝ) → ℝ} {G H : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ} {C : ℝ≥0}
    (hF : LipschitzWith C F) (hG : ∀ i, BddSmooth 0 (G i)) (hH : ∀ i, BddSmooth 0 (H i))
    (hd : ∀ x v t, HasDerivAt (fun s : ℝ => F (x+s • v))
      (∑ i, v i*G i (x+t • v)) t)
    (hd₁ : ∀ i x t, HasDerivAt (fun s : ℝ => G i (x+s • Pi.single i 1))
      (H i (x+t • Pi.single i 1)) t)
    (q d : Fin (n+1) → ℝ) {m : ℝ} (hm : 0 < m) :
    ∃ K, ∀ l r, (∀ t ∈ Ioo l r, ∀ i, 0 < q i+t*d i) →
      ParametricRegular l r K
        (fun t => varianceContinuation m F (fun i => q i+t*d i))
        (fun t => signedVarianceDerivative m F G H d (fun i => q i+t*d i)) := by
  have hGs (i) : BddSmooth 0 (fun y => (G i y)^2) := by
    simpa only [pow_two] using (hG i).mul (hG i)
  choose BH hBH bH using fun i => (hH i).bound
  choose BG hBG bG using fun i => (hGs i).bound
  let K : ℝ := ∑ i, (|d i|/2)*(BH i+m*BG i)
  have hK : 0 ≤ K := Finset.sum_nonneg fun i _ =>
    mul_nonneg (div_nonneg (abs_nonneg _) (by norm_num))
      (add_nonneg (hBH i) (mul_nonneg hm.le (hBG i)))
  have hi (t : ℝ) (x : Fin (n+1) → ℝ) :
      Integrable (fun z => Real.exp (m*F (x+z)))
        (Measure.pi fun i => gaussianReal 0 (Real.toNNReal (q i+t*d i))) :=
    (exponentialIncrement_gaussian _).integrable_shift hF m x
  refine ⟨K, fun l r hq => ⟨hK, ?_, ?_, ?_, ?_⟩⟩
  · intro t _
    exact ⟨C,lipschitzWith_shiftedContinuation hF hm (hi t)⟩
  · intro t _
    exact continuous_finsetSum _ fun i _ =>
      ((continuous_shiftedMean hF (hH i).continuous (hBH i) (bH i) (hi t)).add
        ((continuous_shiftedMean hF (hGs i).continuous (hBG i) (bG i) (hi t)).const_mul m)).const_mul (d i/2)
  · intro t _ x
    have hBH' (i) : |varianceTest m F (H i) (fun i => q i+t*d i) x| ≤ BH i :=
      abs_tiltedMean_le ((hH i).continuous.comp (continuous_const.add continuous_id)).measurable
        (hi t x) (fun z => bH i (x+z))
    have hBG' (i) : |varianceTest m F (fun y => (G i y)^2) (fun i => q i+t*d i) x| ≤ BG i :=
      abs_tiltedMean_le ((hGs i).continuous.comp (continuous_const.add continuous_id)).measurable
        (hi t x) (fun z => bG i (x+z))
    apply (Finset.abs_sum_le_sum_abs _ _).trans
    apply Finset.sum_le_sum
    intro i _
    rw [abs_mul,abs_div,abs_of_pos (by norm_num : (0:ℝ) < 2)]
    apply mul_le_mul_of_nonneg_left _ (by positivity)
    apply (abs_add_le _ _).trans
    rw [abs_mul,abs_of_pos hm]
    exact add_le_add (hBH' i) (mul_le_mul_of_nonneg_left (hBG' i) hm.le)
  · intro t ht x
    have hh := GaussianCalculus.hasDerivAt_signed_variance_continuation hF hG hH hd hd₁ q d
      (hq t ht) hm.ne' x
    have he : (fun s => varianceContinuation m F (fun i => q i+s*d i) x) =ᶠ[𝓝 t]
        (fun s => Real.log (∫ z, Real.exp (m*F (x+(fun i => Real.sqrt (q i+s*d i))*z))
          ∂Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1)/m) := by
      filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs
      exact varianceContinuation_eq hF.continuous m (fun i => (hq s hs i).le) x
    have hde : signedVarianceDerivative m F G H d (fun i => q i+t*d i) x =
        (∑ i, (d i/2)*(tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+(fun i => Real.sqrt (q i+t*d i))*z))
          (fun z => H i (x+(fun i => Real.sqrt (q i+t*d i))*z)) + m*
          tiltedMean (Measure.pi fun _ : Fin (n+1) => gaussianReal 0 1) m
          (fun z => F (x+(fun i => Real.sqrt (q i+t*d i))*z))
          (fun z => (G i (x+(fun i => Real.sqrt (q i+t*d i))*z))^2))) := by
      simp only [signedVarianceDerivative,varianceTest_eq hF.continuous (hH _).continuous m
        (fun i => (hq t ht i).le),varianceTest_eq hF.continuous (hGs _).continuous m
        (fun i => (hq t ht i).le)]
    rw [hde]
    exact hh.congr_of_eventuallyEq he

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι S : Type*} [Fintype ι] [Fintype S] [Nonempty S]

 
noncomputable def hierarchyAtom (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (steps : List (GaussianStep ι)) (σ : S) (x : ι → ℝ) : ℝ := by
  classical
  exact gaussianHierarchyMean w φ (fun τ => if τ = σ then 1 else 0) steps x

theorem hierarchyAtom_nonneg {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (σ : S) (x : ι → ℝ) :
    0 ≤ hierarchyAtom w φ steps σ x := by
  classical
  exact gaussianHierarchyMean_nonneg hw φ (fun τ => by split_ifs <;> norm_num) steps ha x

theorem hierarchyAtom_smooth {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (σ : S) (r : ℕ) :
    BddSmooth r (hierarchyAtom w φ steps σ) :=
  gaussianHierarchyMean_smooth hw φ _ steps ha r

theorem gaussianHierarchyMean_atoms {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (A : S → ℝ) (x : ι → ℝ) :
    gaussianHierarchyMean w φ A steps x = ∑ σ, A σ*hierarchyAtom w φ steps σ x := by
  classical
  have he : A = fun τ => ∑ σ, A σ*(if τ = σ then 1 else 0) := by
    funext τ
    simp
  conv_lhs => rw [he]
  rw [gaussianHierarchyMean_sum hw φ steps ha]
  apply Finset.sum_congr rfl
  intro σ _
  exact congrFun (gaussianHierarchyMean_const_mul_ordered hw φ _ steps ha (A σ)) x

theorem hierarchyAtom_sum {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    ∑ σ, hierarchyAtom w φ steps σ x = 1 := by
  have h := gaussianHierarchyMean_atoms hw φ steps ha (fun _ => 1) x
  rw [gaussianHierarchyMean_const hw φ steps ha] at h
  simpa only [one_mul] using h.symm

 

noncomputable def hierarchyPairMean (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (K : S → S → ℝ) (steps : List (GaussianStep ι)) (x : ι → ℝ) : ℝ :=
  ∑ σ, ∑ τ, (hierarchyAtom w φ steps σ x*hierarchyAtom w φ steps τ x)*K σ τ

theorem hierarchyPairMean_smooth {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K : S → S → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (r : ℕ) :
    BddSmooth r (hierarchyPairMean w φ K steps) := by
  apply BddSmooth.sum Finset.univ
  intro σ _
  apply BddSmooth.sum Finset.univ
  intro τ _
  simpa only [mul_comm (K σ τ)] using
    ((hierarchyAtom_smooth hw φ steps ha σ r).mul
      (hierarchyAtom_smooth hw φ steps ha τ r)).const_mul (K σ τ)

theorem hierarchyPairMean_const {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (c : ℝ) (x : ι → ℝ) :
    hierarchyPairMean w φ (fun _ _ => c) steps x = c := by
  unfold hierarchyPairMean
  simp_rw [← Finset.sum_mul,← Finset.mul_sum,hierarchyAtom_sum hw φ steps ha]
  simp only [mul_one,hierarchyAtom_sum hw φ steps ha]
  ring

theorem hierarchyPairMean_mono {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) {K L : S → S → ℝ} (hKL : ∀ σ τ, K σ τ ≤ L σ τ)
    (steps : List (GaussianStep ι)) {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    hierarchyPairMean w φ K steps x ≤ hierarchyPairMean w φ L steps x := by
  apply Finset.sum_le_sum
  intro σ _
  apply Finset.sum_le_sum
  intro τ _
  exact mul_le_mul_of_nonneg_left (hKL σ τ) (mul_nonneg
    (hierarchyAtom_nonneg hw φ steps ha σ x) (hierarchyAtom_nonneg hw φ steps ha τ x))

omit [Nonempty S] in
theorem hierarchyPairMean_linear (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (K L : S → S → ℝ) (steps : List (GaussianStep ι)) (c d : ℝ) (x : ι → ℝ) :
    hierarchyPairMean w φ (fun σ τ => c*K σ τ+d*L σ τ) steps x =
      c*hierarchyPairMean w φ K steps x+d*hierarchyPairMean w φ L steps x := by
  unfold hierarchyPairMean
  simp_rw [mul_add,Finset.sum_add_distrib,← mul_assoc]
  simp_rw [mul_comm _ c,mul_comm _ d,mul_assoc,← Finset.mul_sum]

theorem hierarchyPairMean_product {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (A B : S → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    hierarchyPairMean w φ (fun σ τ => A σ*B τ) steps x =
      gaussianHierarchyMean w φ A steps x*gaussianHierarchyMean w φ B steps x := by
  rw [gaussianHierarchyMean_atoms hw φ steps ha,gaussianHierarchyMean_atoms hw φ steps ha,
    Finset.sum_mul]
  simp_rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro σ _
  apply Finset.sum_congr rfl
  intro τ _
  ring

 

noncomputable def kernelPenalty (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (K : S → S → ℝ) : ℝ → List (GaussianStep ι) → (ι → ℝ) → ℝ
  | a, [] => fun x => (1-a)*hierarchyPairMean w φ K [] x
  | a, (m,q)::tail => fun x => (m-a)*hierarchyPairMean w φ K ((m,q)::tail) x+
      shiftedMean (Measure.pi fun i => gaussianReal 0 (q i)) m (gaussianHierarchy w φ tail)
        (kernelPenalty w φ K m tail) x

theorem kernelPenalty_smooth {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K : S → S → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (r : ℕ) :
    BddSmooth r (kernelPenalty w φ K a steps) := by
  induction steps generalizing a with
  | nil => exact (hierarchyPairMean_smooth hw φ K [] ha r).const_mul (1-a)
  | cons st tail ih =>
    rcases st with ⟨m,q⟩
    exact ((hierarchyPairMean_smooth hw φ K ((m,q)::tail) ha r).const_mul (m-a)).add
      ((ih ha.2.2.2).shiftedMean (gaussianHierarchy_regular hw φ tail ha.2.2.2 r)
        (gaussianHierarchy_integrable hw φ tail ha.2.2.2 m q))

theorem kernelPenalty_const {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (c : ℝ) (x : ι → ℝ) :
    kernelPenalty w φ (fun _ _ => c) a steps x = (1-a)*c := by
  induction steps generalizing a x with
  | nil => simp only [kernelPenalty,hierarchyPairMean_const hw φ [] ha]
  | cons st tail ih =>
    rcases st with ⟨m,q⟩
    simp only [kernelPenalty,hierarchyPairMean_const hw φ ((m,q)::tail) ha]
    rw [funext (ih ha.2.2.2)]
    rw [shiftedMean_const _ (gaussianHierarchy_integrable hw φ tail ha.2.2.2 m q x)]
    ring

theorem kernelPenalty_mono {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) {K L : S → S → ℝ} (hKL : ∀ σ τ, K σ τ ≤ L σ τ)
    (steps : List (GaussianStep ι)) {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    kernelPenalty w φ K a steps x ≤ kernelPenalty w φ L a steps x := by
  induction steps generalizing a x with
  | nil =>
    exact mul_le_mul_of_nonneg_left (hierarchyPairMean_mono hw φ hKL [] ha x)
      (sub_nonneg.mpr ha.2)
  | cons st tail ih =>
    rcases st with ⟨m,q⟩
    exact add_le_add (mul_le_mul_of_nonneg_left (hierarchyPairMean_mono hw φ hKL _ ha x)
      (sub_nonneg.mpr ha.2.1))
      (shiftedMean_mono (kernelPenalty_smooth hw φ K tail ha.2.2.2 0)
        (kernelPenalty_smooth hw φ L tail ha.2.2.2 0) (fun y => ih ha.2.2.2 y)
        (gaussianHierarchy_integrable hw φ tail ha.2.2.2 m q x))

theorem kernelPenalty_linear {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K L : S → S → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (c d : ℝ) (x : ι → ℝ) :
    kernelPenalty w φ (fun σ τ => c*K σ τ+d*L σ τ) a steps x =
      c*kernelPenalty w φ K a steps x+d*kernelPenalty w φ L a steps x := by
  induction steps generalizing a x with
  | nil => simp only [kernelPenalty,hierarchyPairMean_linear]; ring
  | cons st tail ih =>
    rcases st with ⟨m,q⟩
    simp only [kernelPenalty,hierarchyPairMean_linear]
    rw [funext (ih ha.2.2.2)]
    rw [shiftedMean_add ((kernelPenalty_smooth hw φ K tail ha.2.2.2 0).const_mul c)
      ((kernelPenalty_smooth hw φ L tail ha.2.2.2 0).const_mul d)
      (gaussianHierarchy_integrable hw φ tail ha.2.2.2 m q x),shiftedMean_const_mul,
      shiftedMean_const_mul]
    ring

theorem kernelPenalty_rankOne {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (v : ι → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    kernelPenalty w φ (fun σ τ => φ σ v*φ τ v) a steps x = hierarchyPenalty w φ v a steps x := by
  induction steps generalizing a x with
  | nil => simp only [kernelPenalty,hierarchyPenalty,hierarchyPairMean_product hw φ _ _ [] ha,pow_two]
  | cons st tail ih =>
    rcases st with ⟨m,q⟩
    simp only [kernelPenalty,hierarchyPenalty,hierarchyPairMean_product hw φ _ _ _ ha,pow_two]
    rw [funext (ih ha.2.2.2)]

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology NNReal BigOperators
variable {ι S : Type*} [Fintype ι] [Fintype S] [Nonempty S]

theorem kernelPenalty_const_mul {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K : S → S → ℝ) (steps : List (GaussianStep ι))
    {a : ℝ} (ha : OrderedSteps a steps) (c : ℝ) (x : ι → ℝ) :
    kernelPenalty w φ (fun σ τ => c*K σ τ) a steps x = c*kernelPenalty w φ K a steps x := by
  simpa only [zero_mul,add_zero] using kernelPenalty_linear hw φ K (fun _ _ => 0) steps ha c 0 x

theorem kernelPenalty_sum {κ : Type*} {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K : κ → S → S → ℝ) (is : Finset κ)
    (steps : List (GaussianStep ι)) {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    kernelPenalty w φ (fun σ τ => ∑ i ∈ is, K i σ τ) a steps x =
      ∑ i ∈ is, kernelPenalty w φ (K i) a steps x := by
  classical
  induction is using Finset.induction_on with
  | empty => simp only [Finset.sum_empty,kernelPenalty_const hw φ steps ha,mul_zero]
  | @insert i is hi ih =>
    simp only [Finset.sum_insert hi]
    have he := kernelPenalty_linear hw φ (K i) (fun σ τ => ∑ j ∈ is, K j σ τ) steps ha 1 1 x
    simp only [one_mul] at he
    rw [he,ih]

 

theorem kernelPenalty_weighted_features {κ : Type*} [Fintype κ] {w : S → ℝ}
    (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) (v : κ → ι → ℝ)
    (d : κ → ℝ) (steps : List (GaussianStep ι)) {a : ℝ} (ha : OrderedSteps a steps) (x : ι → ℝ) :
    kernelPenalty w φ (fun σ τ => ∑ i, d i*φ σ (v i)*φ τ (v i)) a steps x =
      ∑ i, d i*hierarchyPenalty w φ (v i) a steps x := by
  have he : (fun σ τ => ∑ i, d i*φ σ (v i)*φ τ (v i)) =
      fun σ τ => ∑ i, d i*(φ σ (v i)*φ τ (v i)) := by
    funext σ τ
    simp only [mul_assoc]
  rw [he,kernelPenalty_sum hw φ _ Finset.univ steps ha]
  apply Finset.sum_congr rfl
  intro i _
  rw [kernelPenalty_const_mul hw φ _ steps ha,kernelPenalty_rankOne hw φ _ steps ha]

theorem kernelPenalty_lower_bound {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (K : S → S → ℝ) (steps : List (GaussianStep ι))
    {a C : ℝ} (ha : OrderedSteps a steps) (hK : ∀ σ τ, -C ≤ K σ τ) (x : ι → ℝ) :
    -(1/2:ℝ)*kernelPenalty w φ K a steps x ≤ (1-a)*C/2 := by
  have hh := kernelPenalty_mono hw φ hK steps ha x
  rw [kernelPenalty_const hw φ steps ha] at hh
  linarith

 

theorem kernelPenalty_chord {w : S → ℝ} (hw : ∀ σ, 0 < w σ)
    (φ : S → (ι → ℝ) →L[ℝ] ℝ) (R : S → S → ℝ) (steps : List (GaussianStep ι))
    {m a : ℝ} (hm : OrderedSteps m steps) (ha : 0 < a) (c : ℝ) (x : ι → ℝ) :
    -(1/2:ℝ)*kernelPenalty w φ (fun σ τ => a/2*(R σ τ)^2-c*R σ τ) m steps x ≤
      (1-m)*c^2/(4*a) := by
  have hK (σ τ) : -(c^2/(2*a)) ≤ a/2*(R σ τ)^2-c*R σ τ := by
    rw [← neg_div,div_le_iff₀ (show 0 < 2*a by positivity)]
    nlinarith [sq_nonneg (a*R σ τ-c)]
  have hh := kernelPenalty_lower_bound hw φ _ steps hm hK x
  convert hh using 1; ring

 
theorem prefixTest_le_const {F A : (ι → ℝ) → ℝ} {C : ℝ≥0}
    (hF : LipschitzWith C F) (hA : BddSmooth 0 A) (front : List (GaussianStep ι))
    (ho : ∀ st ∈ front, 0 < st.1) {B : ℝ} (hb : ∀ y, A y ≤ B) (x : ι → ℝ) :
    prefixTest front F A x ≤ B := by
  have hn : ∀ y, 0 ≤ B+(-1)*A y := fun y => by linarith [hb y]
  have hh := prefixTest_nonneg hF hn front ho x
  rw [prefixTest_affine hF hA front ho B (-1) x] at hh
  linarith

theorem rootedPrefixTest_le_const {F A : (ι → ℝ) → ℝ} {C : ℝ≥0}
    (hF : LipschitzWith C F) (hA : BddSmooth 0 A) (front : List (GaussianStep ι))
    (ho : ∀ st ∈ front, 0 < st.1) {B : ℝ} (hb : ∀ y, A y ≤ B)
    (q₀ : ι → ℝ≥0) (x : ι → ℝ) :
    zeroContinuation (Measure.pi fun i => gaussianReal 0 (q₀ i)) (prefixTest front F A) x ≤ B := by
  have hP := prefixTest_smooth0 hF hA front ho
  have hi : Integrable (fun z => prefixTest front F A (x+z))
      (Measure.pi fun i => gaussianReal 0 (q₀ i)) := by
    obtain ⟨D,hD,hbD⟩ := hP.bound
    exact Integrable.of_bound (hP.continuous.comp (continuous_const.add continuous_id)).aestronglyMeasurable
      D (Filter.Eventually.of_forall fun z => by simpa only [Real.norm_eq_abs] using hbD (x+z))
  have hh := integral_mono hi (integrable_const B) (fun z => prefixTest_le_const hF hA front ho hb (x+z))
  simpa [zeroContinuation] using hh

end SKFluctuations.Hierarchy

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped Topology NNReal BigOperators

 

theorem orderedSK_kernel_chord (n : ℕ) (hn : 0 < n) {w : Spin n → ℝ}
    (hw : ∀ σ, 0 < w σ) (steps : List (GaussianStep (OrderedFeatureIndex n)))
    {m a : ℝ} (hm : OrderedSteps m steps) (ha : 0 < a) (c : ℝ) (x : OrderedFeatureIndex n → ℝ) :
    -(1/2:ℝ)*(∑ i : OrderedFeatureIndex n, Sum.elim (fun _ => -c) (fun _ => a) i*
      hierarchyPenalty w (orderedFeature n) (Pi.single i 1) m steps x) ≤
      (n:ℝ)*(1-m)*c^2/(4*a) := by
  have he : (fun σ τ => ∑ i : OrderedFeatureIndex n, Sum.elim (fun _ => -c) (fun _ => a) i*
      orderedFeature n σ (Pi.single i 1)*orderedFeature n τ (Pi.single i 1)) =
      fun σ τ => (n:ℝ)*(a/2*(orderedOverlap n σ τ)^2-c*orderedOverlap n σ τ) := by
    funext σ τ
    simp only [orderedFeature_single]
    rw [orderedCovariance n hn]
    ring
  rw [← kernelPenalty_weighted_features hw (orderedFeature n) (fun i => Pi.single i 1) _ steps hm,he,
    kernelPenalty_const_mul hw (orderedFeature n) _ steps hm]
  have hh := mul_le_mul_of_nonneg_left (kernelPenalty_chord hw (orderedFeature n)
    (orderedOverlap n) steps hm ha c x) (Nat.cast_nonneg n)
  convert hh using 1 <;> first | rfl | ring

end SKFluctuations

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped Topology NNReal BigOperators

 

theorem orderedSK_kernel_chord_observed (n : ℕ) (hn : 0 < n) {w : Spin n → ℝ}
    (hw : ∀ σ, 0 < w σ) (steps front : List (GaussianStep (OrderedFeatureIndex n)))
    {m a : ℝ} (hm : OrderedSteps m steps) (ha : 0 < a) (c : ℝ)
    (hf : ∀ st ∈ front, 0 < st.1) (q₀ : OrderedFeatureIndex n → ℝ≥0)
    (x : OrderedFeatureIndex n → ℝ) :
    zeroContinuation (Measure.pi fun i => gaussianReal 0 (q₀ i))
      (prefixTest front (gaussianHierarchy w (orderedFeature n) steps)
        (fun y => -(1/2:ℝ)*(∑ i : OrderedFeatureIndex n,
          Sum.elim (fun _ => -c) (fun _ => a) i*
          hierarchyPenalty w (orderedFeature n) (Pi.single i 1) m steps y))) x ≤
      (n:ℝ)*(1-m)*c^2/(4*a) := by
  apply rootedPrefixTest_le_const (gaussianHierarchy_regular hw (orderedFeature n) steps hm 0).1.choose_spec
    ((BddSmooth.sum Finset.univ (fun i _ =>
      (hierarchyPenalty_smooth hw (orderedFeature n) (Pi.single i 1) steps hm 0).const_mul
        (Sum.elim (fun _ => -c) (fun _ => a) i))).const_mul (-(1/2:ℝ))) front hf
  exact fun y => orderedSK_kernel_chord n hn hw steps hm ha c y

end SKFluctuations

end

end OAI