import Mathlib
import OAI.Probability.SKFluctuations.PotentialHeatTrace

namespace OAI

/-! Clock Derivative Continuous. -/

noncomputable section

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

 theorem clockDerivative_continuous {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)) (m : ℝ) :
    Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => clockDerivative m F G H p.1 p.2) := by
  have hGs (i) : BddSmooth 0 (fun y => (G i y)^2) := by simpa only [pow_two] using (hG i).mul (hG i)
  exact ((continuous_finsetSum _ fun i _ => clockTest_continuous hF (hH i) m).add
    ((continuous_finsetSum _ fun i _ => clockTest_continuous hF (hGs i) m).const_mul m)).const_mul (1/2:ℝ)

 theorem clockDerivative_absBounded {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)) (m : ℝ) :
    AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => clockDerivative m F G H p.1 p.2) := by
  have hGs (i) : BddSmooth 0 (fun y => (G i y)^2) := by simpa only [pow_two] using (hG i).mul (hG i)
  exact ((AbsBounded.sum fun i => clockTest_absBounded hF (hH i) m).add
    ((AbsBounded.sum fun i => clockTest_absBounded hF (hGs i) m).const_mul m)).const_mul (1/2:ℝ)

 theorem clockDerivative_eq_generator {n : ℕ} {F : (Fin (n+1) → ℝ) → ℝ}
    {G H : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ} (m t : ℝ) (x : Fin (n+1) → ℝ) :
    clockDerivative m F G H t x = (1/2:ℝ)*∑ i,
      (clockGradient m F (G i) (G i) (H i) t x+m*(clockTest m F (G i) t x)^2) := by
  unfold clockDerivative
  rw [Finset.mul_sum,← Finset.sum_add_distrib]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  dsimp only [clockGradient]
  simp only [pow_two]
  ring

 theorem hasDerivAt_clockContinuation {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)
    {m t : ℝ} (hm : 0 < m) (ht : 0 < t) (x : Fin (n+1) → ℝ) :
    HasDerivAt (fun s => clockContinuation m F s x) (clockDerivative m F G H t x) t := by
  obtain ⟨K,hK⟩ := parametric_clock hF hG hH hd hd₁ hm
  exact (hK (t+1)).derivative t ⟨ht,by linarith⟩ x

 theorem clockTest_bddSmooth {ι : Type*} [Fintype ι] {k : ℕ} {F A : (ι → ℝ) → ℝ}
    (hF : PotentialRegularity k F) (hA : BddSmooth k A) (m t : ℝ) : BddSmooth k (clockTest m F A t) := by
  obtain ⟨C,hC⟩ := hF.1
  exact hA.shiftedMean hF (fun x =>
    (exponentialIncrement_gaussian (fun _ : ι => Real.toNNReal t)).integrable_shift hC m x)

 theorem clockContinuation_regular {ι : Type*} [Fintype ι] {k : ℕ} {F : (ι → ℝ) → ℝ}
    (hF : PotentialRegularity k F) {m : ℝ} (hm : 0 < m) (t : ℝ) : PotentialRegularity k (clockContinuation m F t) := by
  obtain ⟨C,hC⟩ := hF.1
  exact hF.shiftedContinuation hm (fun x =>
    (exponentialIncrement_gaussian (fun _ : ι => Real.toNNReal t)).integrable_shift hC m x)

end SKFluctuations.Hierarchy

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

 

structure HeatJet (n : ℕ) where
  F : (Fin (n+1) → ℝ) → ℝ
  A : (Fin (n+1) → ℝ) → ℝ
  G : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ
  H : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ
  A₁ : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ
  A₂ : Fin (n+1) → (Fin (n+1) → ℝ) → ℝ
  C : ℝ≥0
  lipschitz : LipschitzWith C F
  smoothA : BddSmooth 0 A
  smoothG : ∀ i, BddSmooth 0 (G i)
  smoothH : ∀ i, BddSmooth 0 (H i)
  smoothA₁ : ∀ i, BddSmooth 0 (A₁ i)
  smoothA₂ : ∀ i, BddSmooth 0 (A₂ i)
  derivF : ∀ x v t, HasDerivAt (fun s : ℝ => F (x+s • v)) (∑ i, v i*G i (x+t • v)) t
  derivG : ∀ i x t, HasDerivAt (fun s : ℝ => G i (x+s • Pi.single i 1)) (H i (x+t • Pi.single i 1)) t
  derivA : ∀ x v t, HasDerivAt (fun s : ℝ => A (x+s • v)) (∑ i, v i*A₁ i (x+t • v)) t
  derivA₁ : ∀ i x t, HasDerivAt (fun s : ℝ => A₁ i (x+s • Pi.single i 1)) (A₂ i (x+t • Pi.single i 1)) t

 theorem HeatJet.regular {n : ℕ} (J : HeatJet n) : PotentialRegularity 0 J.F := by
  refine ⟨⟨J.C,J.lipschitz⟩,fun v => ?_⟩
  exact ⟨fun y => ∑ i, v i*J.G i y,BddSmooth.sum Finset.univ (fun i _ => (J.smoothG i).const_mul (v i)),fun x t => J.derivF x v t⟩

 theorem hasDerivAt_clockContinuation_source_vector {n : ℕ} (J : HeatJet n) {m : ℝ} (hm : m ≠ 0)
    (t : ℝ) (x v : Fin (n+1) → ℝ) (s : ℝ) :
    HasDerivAt (fun r => clockContinuation m J.F t (x+r • v))
      (∑ i, v i*clockTest m J.F (J.G i) t (x+s • v)) s := by
  have hb : ∀ i, BddSmooth 0 (fun y => v i*J.G i y) := fun i => (J.smoothG i).const_mul (v i)
  have h := hasDerivAt_clockContinuation_source J.lipschitz
    (BddSmooth.sum Finset.univ fun i _ => hb i) (fun y r => J.derivF y v r) hm t x s
  rw [clockTest_sum J.lipschitz hb] at h
  simpa only [clockTest_const_mul] using h

 theorem HeatJet.derivF_coord {n : ℕ} (J : HeatJet n) (i : Fin (n+1)) (x : Fin (n+1) → ℝ) (t : ℝ) :
    HasDerivAt (fun s : ℝ => J.F (x+s • Pi.single i 1)) (J.G i (x+t • Pi.single i 1)) t := by
  simpa only [Pi.single_apply,ite_mul,one_mul,zero_mul,Finset.sum_ite_eq',Finset.mem_univ,ite_true] using
    J.derivF x (Pi.single i 1) t

 theorem HeatJet.derivA_coord {n : ℕ} (J : HeatJet n) (i : Fin (n+1)) (x : Fin (n+1) → ℝ) (t : ℝ) :
    HasDerivAt (fun s : ℝ => J.A (x+s • Pi.single i 1)) (J.A₁ i (x+t • Pi.single i 1)) t := by
  simpa only [Pi.single_apply,ite_mul,one_mul,zero_mul,Finset.sum_ite_eq',Finset.mem_univ,ite_true] using
    J.derivA x (Pi.single i 1) t

 
def HeatJet.evolve {n : ℕ} (J : HeatJet n) {m : ℝ} (hm : 0 < m) (t : ℝ) : HeatJet n where
  F := clockContinuation m J.F t
  A := clockTest m J.F J.A t
  G i := clockTest m J.F (J.G i) t
  H i := clockGradient m J.F (J.G i) (J.G i) (J.H i) t
  A₁ i := clockGradient m J.F (J.G i) J.A (J.A₁ i) t
  A₂ i := clockSecond m J.F (J.G i) (J.H i) J.A (J.A₁ i) (J.A₂ i) t
  C := J.C
  lipschitz := lipschitzWith_shiftedContinuation J.lipschitz hm (fun x =>
    (exponentialIncrement_gaussian (fun _ => Real.toNNReal t)).integrable_shift J.lipschitz m x)
  smoothA := clockTest_bddSmooth J.regular J.smoothA m t
  smoothG i := clockTest_bddSmooth J.regular (J.smoothG i) m t
  smoothH i := clockGradient_bddSmooth J.regular (J.smoothG i) (J.smoothG i) (J.smoothH i) m t
  smoothA₁ i := clockGradient_bddSmooth J.regular (J.smoothG i) J.smoothA (J.smoothA₁ i) m t
  smoothA₂ i := clockSecond_bddSmooth J.regular (J.smoothG i) (J.smoothH i) J.smoothA (J.smoothA₁ i) (J.smoothA₂ i) m t
  derivF := hasDerivAt_clockContinuation_source_vector J hm.ne' t
  derivG i := hasDerivAt_clockTest_source J.lipschitz (J.smoothG i) (J.smoothG i) (J.smoothH i)
    (J.derivF_coord i) (J.derivG i) m t
  derivA := hasDerivAt_clockTest_source_vector J.lipschitz J.smoothA J.smoothG J.smoothA₁
    J.derivF J.derivA m t
  derivA₁ i := hasDerivAt_clockGradient_source J.lipschitz (J.smoothG i) (J.smoothH i) J.smoothA
    (J.smoothA₁ i) (J.smoothA₂ i) (J.derivF_coord i) (J.derivG i) (J.derivA_coord i) (J.derivA₁ i) m t

 theorem HeatJet.evolve_time_F {n : ℕ} (J : HeatJet n) {m : ℝ} (hm : 0 < m)
    {t : ℝ} (ht : 0 < t) (x : Fin (n+1) → ℝ) :
    HasDerivAt (fun s => (J.evolve hm s).F x)
      ((1/2:ℝ)*∑ i, ((J.evolve hm t).H i x+m*((J.evolve hm t).G i x)^2)) t := by
  dsimp only [HeatJet.evolve]
  rw [← clockDerivative_eq_generator]
  exact hasDerivAt_clockContinuation J.lipschitz J.smoothG J.smoothH J.derivF J.derivG hm ht x

 theorem HeatJet.evolve_time_A {n : ℕ} (J : HeatJet n) {m : ℝ} (hm : 0 < m)
    {t : ℝ} (ht : 0 < t) (x : Fin (n+1) → ℝ) :
    HasDerivAt (fun s => (J.evolve hm s).A x)
      ((1/2:ℝ)*∑ i, ((J.evolve hm t).A₂ i x+2*m*(J.evolve hm t).A₁ i x*(J.evolve hm t).G i x)) t := by
  dsimp only [HeatJet.evolve]
  rw [← clockTestDerivative_eq_generator J.lipschitz J.smoothA J.smoothG J.smoothH J.smoothA₁ J.smoothA₂]
  exact (hasDerivWithinAt_clockTest J.lipschitz J.smoothA J.smoothG J.smoothH J.smoothA₁ J.smoothA₂
    J.derivF J.derivG J.derivA J.derivA₁ m x ht.le).hasDerivAt (Ici_mem_nhds ht)

end SKFluctuations.Hierarchy

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

 
def HeatJet.square {n : ℕ} (J : HeatJet n) : HeatJet n where
  F := J.F
  A := fun y => (J.A y)^2
  G := J.G
  H := J.H
  A₁ i y := 2*(J.A y*J.A₁ i y)
  A₂ i y := 2*((J.A₁ i y)^2+J.A y*J.A₂ i y)
  C := J.C
  lipschitz := J.lipschitz
  smoothA := by simpa only [pow_two] using J.smoothA.mul J.smoothA
  smoothG := J.smoothG
  smoothH := J.smoothH
  smoothA₁ i := (J.smoothA.mul (J.smoothA₁ i)).const_mul 2
  smoothA₂ i := by simpa only [pow_two] using
    (((J.smoothA₁ i).mul (J.smoothA₁ i)).add (J.smoothA.mul (J.smoothA₂ i))).const_mul 2
  derivF := J.derivF
  derivG := J.derivG
  derivA x v t := by
    apply ((J.derivA x v t).pow 2).congr_deriv
    simp only [Nat.cast_ofNat,pow_one,Nat.reduceSub,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    ring
  derivA₁ i x t := by
    apply (((J.derivA_coord i x t).mul (J.derivA₁ i x t)).const_mul 2).congr_deriv
    ring

structure HeatJetFamily (n : ℕ) where
  J : ℝ → HeatJet n
  C : ℝ≥0
  lipschitz : ∀ t, LipschitzWith C (J t).F
  continuousF : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).F p.2)
  continuousA : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A p.2)
  continuousG : ∀ i, Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).G i p.2)
  continuousH : ∀ i, Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).H i p.2)
  continuousA₁ : ∀ i, Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A₁ i p.2)
  continuousA₂ : ∀ i, Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A₂ i p.2)
  boundedA : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A p.2)
  boundedG : ∀ i, AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).G i p.2)
  boundedH : ∀ i, AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).H i p.2)
  boundedA₁ : ∀ i, AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A₁ i p.2)
  boundedA₂ : ∀ i, AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A₂ i p.2)

 def HeatJet.family {n : ℕ} (J : HeatJet n) {m : ℝ} (hm : 0 < m) : HeatJetFamily n where
  J := J.evolve hm
  C := J.C
  lipschitz t := (J.evolve hm t).lipschitz
  continuousF := clockContinuation_continuous J.lipschitz m
  continuousA := clockTest_continuous J.lipschitz J.smoothA m
  continuousG i := clockTest_continuous J.lipschitz (J.smoothG i) m
  continuousH i := clockGradient_continuous J.lipschitz (J.smoothG i) (J.smoothG i) (J.smoothH i) m
  continuousA₁ i := clockGradient_continuous J.lipschitz (J.smoothG i) J.smoothA (J.smoothA₁ i) m
  continuousA₂ i := clockSecond_continuous J.lipschitz (J.smoothG i) (J.smoothH i) J.smoothA (J.smoothA₁ i) (J.smoothA₂ i) m
  boundedA := clockTest_absBounded J.lipschitz J.smoothA m
  boundedG i := clockTest_absBounded J.lipschitz (J.smoothG i) m
  boundedH i := clockGradient_absBounded J.lipschitz (J.smoothG i) (J.smoothG i) (J.smoothH i) m
  boundedA₁ i := clockGradient_absBounded J.lipschitz (J.smoothG i) J.smoothA (J.smoothA₁ i) m
  boundedA₂ i := clockSecond_absBounded J.lipschitz (J.smoothG i) (J.smoothH i) J.smoothA (J.smoothA₁ i) (J.smoothA₂ i) m

 def HeatJetFamily.square {n : ℕ} (V : HeatJetFamily n) : HeatJetFamily n where
  J t := (V.J t).square
  C := V.C
  lipschitz := V.lipschitz
  continuousF := V.continuousF
  continuousA := V.continuousA.pow 2
  continuousG := V.continuousG
  continuousH := V.continuousH
  continuousA₁ i := (V.continuousA.mul (V.continuousA₁ i)).const_mul 2
  continuousA₂ i := (((V.continuousA₁ i).pow 2).add (V.continuousA.mul (V.continuousA₂ i))).const_mul 2
  boundedA := by simpa only [HeatJet.square,pow_two] using V.boundedA.mul V.boundedA
  boundedG := V.boundedG
  boundedH := V.boundedH
  boundedA₁ i := (V.boundedA.mul (V.boundedA₁ i)).const_mul 2
  boundedA₂ i := by simpa only [HeatJet.square,pow_two] using
    (((V.boundedA₁ i).mul (V.boundedA₁ i)).add (V.boundedA.mul (V.boundedA₂ i))).const_mul 2

 theorem HeatJetFamily.continuousP {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => potentialHeatTrace m (V.J p.1).G (V.J p.1).H p.2) := by
  exact continuous_finsetSum _ fun i _ =>
    ((V.continuousH i).const_mul m).add (((V.continuousG i).pow 2).const_mul (m^2))

 theorem HeatJetFamily.continuousW {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => testedHeatTrace m (V.J p.1).G (V.J p.1).H
      (V.J p.1).A (V.J p.1).A₁ (V.J p.1).A₂ p.2) := by
  exact continuous_finsetSum _ fun i _ =>
    ((V.continuousA₂ i).add (((V.continuousA₁ i).const_mul (2*m)).mul (V.continuousG i))).add
      (V.continuousA.mul (((V.continuousH i).const_mul m).add (((V.continuousG i).pow 2).const_mul (m^2))))

 theorem HeatJetFamily.boundedP {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => potentialHeatTrace m (V.J p.1).G (V.J p.1).H p.2) := by
  apply AbsBounded.sum
  intro i
  simpa only [pow_two] using ((V.boundedH i).const_mul m).add
    (((V.boundedG i).mul (V.boundedG i)).const_mul (m*m))

 theorem HeatJetFamily.boundedW {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => testedHeatTrace m (V.J p.1).G (V.J p.1).H
      (V.J p.1).A (V.J p.1).A₁ (V.J p.1).A₂ p.2) := by
  apply AbsBounded.sum
  intro i
  have hP : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => m*(V.J p.1).H i p.2+m^2*((V.J p.1).G i p.2)^2) := by
    simpa only [pow_two] using ((V.boundedH i).const_mul m).add
      (((V.boundedG i).mul (V.boundedG i)).const_mul (m*m))
  exact ((V.boundedA₂ i).add (((V.boundedA₁ i).const_mul (2*m)).mul (V.boundedG i))).add (V.boundedA.mul hP)

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory Filter Set
open scoped Topology
variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}

omit [MeasurableSpace Ω] in
 

theorem local_exponential_domination {F D : ℝ → Ω → ℝ} {l r t C : ℝ}
    (ht : t ∈ Ioo l r) (hC : 0 ≤ C)
    (hd : ∀ s ∈ Ioo l r, ∀ z, HasDerivAt (fun q => F q z) (D s z) s)
    (hb : ∀ s ∈ Ioo l r, ∀ z, |D s z| ≤ C) (m : ℝ) :
    ∃ ρ > 0, Metric.ball t ρ ⊆ Ioo l r ∧ ∀ s ∈ Metric.ball t ρ, ∀ z,
      Real.exp (m*F s z) ≤ Real.exp (|m| *C)*Real.exp (m*F t z) := by
  let ρ := min 1 (min (t-l) (r-t)) / 2
  have hρ : 0 < ρ := by
    have hl : 0 < t-l := sub_pos.mpr ht.1
    have hr : 0 < r-t := sub_pos.mpr ht.2
    dsimp [ρ]; positivity
  have hρ1 : ρ ≤ 1 := by dsimp [ρ]; have := min_le_left (1:ℝ) (min (t-l) (r-t)); linarith
  have hball : Metric.ball t ρ ⊆ Ioo l r := by
    intro s hs
    have hs' : |s-t| < ρ := Metric.mem_ball.mp hs
    have hρl : ρ ≤ t-l := by dsimp [ρ]; have := (min_le_right (1:ℝ) (min (t-l) (r-t))).trans (min_le_left _ _); linarith [ht.1]
    have hρr : ρ ≤ r-t := by dsimp [ρ]; have := (min_le_right (1:ℝ) (min (t-l) (r-t))).trans (min_le_right _ _); linarith [ht.2]
    have hs'' := abs_lt.mp hs'
    constructor <;> linarith
  refine ⟨ρ,hρ,hball,?_⟩
  intro s hs z
  have hL : LipschitzOnWith ⟨C,hC⟩ (fun q => F q z) (Ioo l r) :=
    (convex_Ioo l r).lipschitzOnWith_of_nnnorm_deriv_le
      (fun q hq => (hd q hq z).differentiableAt)
      (fun q hq => by
        change ‖deriv (fun q => F q z) q‖ ≤ C
        rw [(hd q hq z).deriv, Real.norm_eq_abs]
        exact hb q hq z)
  have hh := hL.dist_le_mul s (hball hs) t ht
  change |F s z-F t z| ≤ C*|s-t| at hh
  have hst : |s-t| ≤ 1 := (Metric.mem_ball.mp hs).le.trans hρ1
  have hLip : |F s z-F t z| ≤ C := hh.trans (by simpa using mul_le_mul_of_nonneg_left hst hC)
  rw [← Real.exp_add, Real.exp_le_exp]
  have h := mul_le_mul_of_nonneg_left hLip (abs_nonneg m)
  have h' := le_abs_self (m*(F s z-F t z))
  rw [abs_mul] at h'
  nlinarith

 theorem hasDerivAt_tested_integral_local {F D A B : ℝ → Ω → ℝ} {l r t C K : ℝ}
    (ht : t ∈ Ioo l r) (hC : 0 ≤ C) (hK : 0 ≤ K)
    (hF : ∀ s ∈ Ioo l r, Measurable (F s)) (hD : Measurable (D t))
    (hA : ∀ s ∈ Ioo l r, Measurable (A s)) (hB : Measurable (B t))
    (hdF : ∀ s ∈ Ioo l r, ∀ z, HasDerivAt (fun q => F q z) (D s z) s)
    (hdA : ∀ s ∈ Ioo l r, ∀ z, HasDerivAt (fun q => A q z) (B s z) s)
    (hbF : ∀ s ∈ Ioo l r, ∀ z, |D s z| ≤ C)
    (hbA : ∀ s ∈ Ioo l r, ∀ z, |A s z| ≤ K)
    (hbB : ∀ s ∈ Ioo l r, ∀ z, |B s z| ≤ K) (m : ℝ)
    (hi : Integrable (fun z => Real.exp (m*F t z)) μ) :
    HasDerivAt (fun s => ∫ z, A s z*Real.exp (m*F s z) ∂μ)
      (∫ z, (B t z+m*A t z*D t z)*Real.exp (m*F t z) ∂μ) t := by
  obtain ⟨ρ,hρ,hball,he⟩ := local_exponential_domination ht hC hdF hbF m
  apply (hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (s := Metric.ball t ρ) (bound := fun z => ((K+|m| *K*C)*Real.exp (|m| *C))*Real.exp (m*F t z)))
    (Metric.ball_mem_nhds t hρ) _ (integrable_weighted hi (hA t ht) (hbA t ht)) _ _ (hi.const_mul _) _ |>.2
  · filter_upwards [Metric.ball_mem_nhds t hρ] with s hs
    exact ((hA s (hball hs)).mul (((hF s (hball hs)).const_mul m).exp)).aestronglyMeasurable
  · exact ((hB.add (((hA t ht).const_mul m).mul hD)).mul (((hF t ht).const_mul m).exp)).aestronglyMeasurable
  · exact Eventually.of_forall fun z s hs => by
      have hcoef : |B s z+m*A s z*D s z| ≤ K+|m| *K*C := by
        apply (abs_add_le _ _).trans
        rw [abs_mul,abs_mul]
        exact add_le_add (hbB s (hball hs) z)
          (mul_le_mul (mul_le_mul_of_nonneg_left (hbA s (hball hs) z) (abs_nonneg m))
            (hbF s (hball hs) z) (abs_nonneg _) (mul_nonneg (abs_nonneg m) hK))
      rw [Real.norm_eq_abs,abs_mul,abs_of_pos (Real.exp_pos _)]
      calc
        _ ≤ (K+|m| *K*C)*(Real.exp (|m| *C)*Real.exp (m*F t z)) :=
          mul_le_mul hcoef (he s hs z) (Real.exp_nonneg _) (by positivity)
        _ = _ := by ring
  · exact Eventually.of_forall fun z s hs => ((hdA s (hball hs) z).mul
      (((hdF s (hball hs) z).const_mul m).exp)).congr_deriv (by ring)

 theorem hasDerivAt_tiltedMean_local [IsProbabilityMeasure μ]
    {F D A B : ℝ → Ω → ℝ} {l r t C K : ℝ}
    (ht : t ∈ Ioo l r) (hC : 0 ≤ C) (hK : 0 ≤ K)
    (hF : ∀ s ∈ Ioo l r, Measurable (F s)) (hD : Measurable (D t))
    (hA : ∀ s ∈ Ioo l r, Measurable (A s)) (hB : Measurable (B t))
    (hdF : ∀ s ∈ Ioo l r, ∀ z, HasDerivAt (fun q => F q z) (D s z) s)
    (hdA : ∀ s ∈ Ioo l r, ∀ z, HasDerivAt (fun q => A q z) (B s z) s)
    (hbF : ∀ s ∈ Ioo l r, ∀ z, |D s z| ≤ C)
    (hbA : ∀ s ∈ Ioo l r, ∀ z, |A s z| ≤ K)
    (hbB : ∀ s ∈ Ioo l r, ∀ z, |B s z| ≤ K) (m : ℝ)
    (hi : Integrable (fun z => Real.exp (m*F t z)) μ) :
    HasDerivAt (fun s => tiltedMean μ m (F s) (A s))
      (tiltedMean μ m (F t) (B t)+m*(tiltedMean μ m (F t) (fun z => A t z*D t z)-
        tiltedMean μ m (F t) (A t)*tiltedMean μ m (F t) (D t))) t := by
  have hP := hasDerivAt_tested_integral_local ht hC (K := 1) (by norm_num) hF hD
    (fun _ _ => measurable_const) measurable_const hdF (fun s _ _ => hasDerivAt_const s (1:ℝ))
    hbF (fun _ _ _ => by norm_num) (fun _ _ _ => by norm_num) m hi
  simp only [one_mul,mul_one,zero_add,mul_assoc,integral_const_mul] at hP
  have hd := (hasDerivAt_tested_integral_local ht hC hK hF hD hA hB hdF hdA hbF hbA hbB m hi).div hP
    (partition_pos m hi).ne'
  have h1 := integrable_weighted hi hB (hbB t ht)
  have h2 : Integrable (fun z => (A t z*D t z)*Real.exp (m*F t z)) μ :=
    integrable_weighted hi ((hA t ht).mul hD) (fun z => show |A t z*D t z| ≤ K*C by
    rw [abs_mul]; exact mul_le_mul (hbA t ht z) (hbF t ht z) (abs_nonneg _) hK)
  have he : (∫ z, (B t z+m*A t z*D t z)*Real.exp (m*F t z) ∂μ) =
      (∫ z, B t z*Real.exp (m*F t z) ∂μ)+m*(∫ z, (A t z*D t z)*Real.exp (m*F t z) ∂μ) := by
    rw [← integral_const_mul,← integral_add h1 (h2.const_mul m)]
    congr 1; funext z; ring
  apply hd.congr_deriv
  rw [he]
  dsimp [tiltedMean]
  field_simp
  ring

end SKFluctuations.Hierarchy

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

 

theorem dynamic_testedPartition_continuous {F A : ℝ → (ι → ℝ) → ℝ} {C : ℝ≥0} {K : ℝ}
    (hF : ∀ r, LipschitzWith C (F r))
    (hcF : Continuous (fun p : ℝ × (ι → ℝ) => F p.1 p.2))
    (hcA : Continuous (fun p : ℝ × (ι → ℝ) => A p.1 p.2))
    (hb : ∀ r y, |A r y| ≤ K) (m : ℝ) (x : ι → ℝ) :
    Continuous (fun p : ℝ × ℝ => ∫ z, A p.2 (x+Real.sqrt p.1 • z)*Real.exp (m*F p.2 (x+Real.sqrt p.1 • z))
      ∂Measure.pi fun _ : ι => gaussianReal 0 1) := by
  let ν := Measure.pi fun _ : ι => gaussianReal 0 1
  have hν : ExponentialIncrement ν := exponentialIncrement_gaussian (fun _ => 1)
  apply continuous_iff_continuousAt.mpr
  intro p
  let B := |F p.2 x|+1
  let Q := Real.sqrt p.1+1
  have hQ : 0 ≤ Q := by dsimp [Q]; positivity
  have hcbase : Continuous (fun q : ℝ × ℝ => F q.2 x) := hcF.comp (continuous_snd.prodMk continuous_const)
  have hbase : ∀ᶠ q in 𝓝 p, |F q.2 x| < B := hcbase.abs.continuousAt.eventually
    (eventually_lt_nhds (by dsimp [B]; linarith))
  have hscale : ∀ᶠ q in 𝓝 p, Real.sqrt q.1 < Q :=
    (Real.continuous_sqrt.comp continuous_fst).continuousAt.eventually
      (eventually_lt_nhds (by dsimp [Q]; linarith))
  apply continuousAt_of_dominated
    (bound := fun z => K*Real.exp (|m| *B)*Real.exp (|m| *C*Q*‖z‖))
  · exact Eventually.of_forall fun q => by
      have hmap : Continuous (fun z : ι → ℝ => (q.2,x+Real.sqrt q.1 • z)) := by fun_prop
      exact ((hcA.comp hmap).mul (((hcF.comp hmap).const_mul m).rexp)).aestronglyMeasurable
  · filter_upwards [hbase,hscale] with q hq hq'
    exact Eventually.of_forall fun z => by
      have hK : 0 ≤ K := (abs_nonneg (A q.2 x)).trans (hb q.2 x)
      have hdiff : |F q.2 (x+Real.sqrt q.1 • z)-F q.2 x| ≤ (C:ℝ)*Real.sqrt q.1*‖z‖ := by
        simpa only [dist_eq_norm,add_sub_cancel_left,norm_smul,Real.norm_eq_abs,
          abs_of_nonneg (Real.sqrt_nonneg _),mul_assoc] using (hF q.2).dist_le_mul (x+Real.sqrt q.1 • z) x
      have hale : |F q.2 (x+Real.sqrt q.1 • z)| ≤ B+(C:ℝ)*Q*‖z‖ := by
        have hh := abs_add_le (F q.2 (x+Real.sqrt q.1 • z)-F q.2 x) (F q.2 x)
        rw [sub_add_cancel] at hh
        have hcomp : (C:ℝ)*Real.sqrt q.1*‖z‖ ≤ (C:ℝ)*Q*‖z‖ := by gcongr
        linarith
      have hexp : Real.exp (m*F q.2 (x+Real.sqrt q.1 • z)) ≤
          Real.exp (|m| *B)*Real.exp (|m| *C*Q*‖z‖) := by
        rw [← Real.exp_add,Real.exp_le_exp]
        have h1 := (le_abs_self (m*F q.2 (x+Real.sqrt q.1 • z))).trans_eq (abs_mul m _)
        have h2 := mul_le_mul_of_nonneg_left hale (abs_nonneg m)
        nlinarith
      change |A q.2 (x+Real.sqrt q.1 • z)*Real.exp (m*F q.2 (x+Real.sqrt q.1 • z))| ≤ _
      rw [abs_mul,abs_of_pos (Real.exp_pos _)]
      exact (mul_le_mul (hb q.2 _) hexp (Real.exp_nonneg _) hK).trans_eq (by ring)
  · exact (hν (|m| *C*Q)).const_mul _
  · exact Eventually.of_forall fun z => by
      have hmap : Continuous (fun q : ℝ × ℝ => (q.2,x+Real.sqrt q.1 • z)) :=
        continuous_snd.prodMk (continuous_const.add ((Real.continuous_sqrt.comp continuous_fst).smul continuous_const))
      exact ((hcA.comp hmap).mul (((hcF.comp hmap).const_mul m).rexp)).continuousAt

 theorem dynamic_clockTest_continuous {F A : ℝ → (ι → ℝ) → ℝ} {C : ℝ≥0} {K : ℝ}
    (hF : ∀ r, LipschitzWith C (F r))
    (hcF : Continuous (fun p : ℝ × (ι → ℝ) => F p.1 p.2))
    (hcA : Continuous (fun p : ℝ × (ι → ℝ) => A p.1 p.2))
    (hb : ∀ r y, |A r y| ≤ K) (m : ℝ) (x : ι → ℝ) :
    Continuous (fun p : ℝ × ℝ => clockTest m (F p.2) (A p.2) p.1 x) := by
  have hn := dynamic_testedPartition_continuous hF hcF hcA hb m x
  have hd := dynamic_testedPartition_continuous (A := fun _ _ => 1) hF hcF continuous_const
    (fun _ _ => le_refl |(1:ℝ)|) m x
  simp only [one_mul] at hd
  have hh := hn.div hd (fun p => (partition_pos m
    ((ExpNormBounded.exp_lipschitz (hF p.2) m).affine_integrable (exponentialIncrement_gaussian (fun _ : ι => 1)) x _)).ne')
  exact hh.congr fun p => (clockTest_eq_all (hF p.2).continuous
    (hcA.comp (continuous_const.prodMk continuous_id)) m p.1 x).symm

end SKFluctuations.Hierarchy

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

 theorem dynamic_clockGradient_continuous {ι : Type*} [Fintype ι]
    {F G A B : ℝ → (ι → ℝ) → ℝ} {C : ℝ≥0}
    (hF : ∀ r, LipschitzWith C (F r))
    (hcF : Continuous (fun p : ℝ × (ι → ℝ) => F p.1 p.2))
    (hcG : Continuous (fun p : ℝ × (ι → ℝ) => G p.1 p.2))
    (hcA : Continuous (fun p : ℝ × (ι → ℝ) => A p.1 p.2))
    (hcB : Continuous (fun p : ℝ × (ι → ℝ) => B p.1 p.2))
    (hbG : AbsBounded (fun p : ℝ × (ι → ℝ) => G p.1 p.2))
    (hbA : AbsBounded (fun p : ℝ × (ι → ℝ) => A p.1 p.2))
    (hbB : AbsBounded (fun p : ℝ × (ι → ℝ) => B p.1 p.2)) (m : ℝ) (x : ι → ℝ) :
    Continuous (fun p : ℝ × ℝ => clockGradient m (F p.2) (G p.2) (A p.2) (B p.2) p.1 x) := by
  have hbM := hbA.mul hbG
  obtain ⟨KA,_,bA⟩ := hbA
  obtain ⟨KG,_,bG⟩ := hbG
  obtain ⟨KB,_,bB⟩ := hbB
  obtain ⟨KM,_,bM⟩ := hbM
  exact (dynamic_clockTest_continuous hF hcF hcB (fun r y => bB (r,y)) m x).add
    (((dynamic_clockTest_continuous hF hcF (hcA.mul hcG) (fun r y => bM (r,y)) m x).sub
      ((dynamic_clockTest_continuous hF hcF hcA (fun r y => bA (r,y)) m x).mul
        (dynamic_clockTest_continuous hF hcF hcG (fun r y => bG (r,y)) m x))).const_mul m)

 

theorem hasDerivAt_dynamic_clockTest {n : ℕ} (J : ℝ → HeatJet n)
    {D B : ℝ → (Fin (n+1) → ℝ) → ℝ} {l r : ℝ} {C : ℝ≥0} (m : ℝ)
    (hF : ∀ s, LipschitzWith C (J s).F)
    (hcF : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).F p.2))
    (hcA : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A p.2))
    (hcD : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => D p.1 p.2))
    (hcB : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => B p.1 p.2))
    (hbA : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (J p.1).A p.2))
    (hbD : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => D p.1 p.2))
    (hbB : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => B p.1 p.2))
    (hcP : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => potentialHeatTrace m (J p.1).G (J p.1).H p.2))
    (hcW : Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => testedHeatTrace m (J p.1).G (J p.1).H (J p.1).A (J p.1).A₁ (J p.1).A₂ p.2))
    (hbP : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => potentialHeatTrace m (J p.1).G (J p.1).H p.2))
    (hbW : AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => testedHeatTrace m (J p.1).G (J p.1).H (J p.1).A (J p.1).A₁ (J p.1).A₂ p.2))
    (hdF : ∀ s ∈ Ioo l r, ∀ y, HasDerivAt (fun q => (J q).F y) (D s y) s)
    (hdA : ∀ s ∈ Ioo l r, ∀ y, HasDerivAt (fun q => (J q).A y) (B s y) s)
    (x : Fin (n+1) → ℝ) {a b : ℝ → ℝ} {a' b' t : ℝ}
    (ha : HasDerivAt a a' t) (hb : HasDerivAt b b' t) (ha₀ : 0 < a t) (hbt : b t ∈ Ioo l r) :
    HasDerivAt (fun s => clockTest m (J (b s)).F (J (b s)).A (a s) x)
      (clockTestDerivative m (J (b t)).F (J (b t)).G (J (b t)).H (J (b t)).A (J (b t)).A₁ (J (b t)).A₂ (a t) x*a'+
       clockGradient m (J (b t)).F (D (b t)) (J (b t)).A (B (b t)) (a t) x*b') t := by
  have hcg := dynamic_clockGradient_continuous (F := fun s => (J s).F)
    (G := D) (A := fun s => (J s).A) (B := B) hF hcF hcD hcA hcB hbD hbA hbB m x
  obtain ⟨KA,hKA,bA⟩ := hbA
  obtain ⟨KD,hKD,bD⟩ := hbD
  obtain ⟨KB,hKB,bB⟩ := hbB
  obtain ⟨KP,_,bP⟩ := hbP
  obtain ⟨KW,_,bW⟩ := hbW
  have hct : Continuous (fun p : ℝ × ℝ =>
      clockTestDerivative m (J p.2).F (J p.2).G (J p.2).H (J p.2).A (J p.2).A₁ (J p.2).A₂ p.1 x) :=
    ((dynamic_clockTest_continuous hF hcF hcW (fun s y => bW (s,y)) m x).sub
      ((dynamic_clockTest_continuous hF hcF hcA (fun s y => bA (s,y)) m x).mul
        (dynamic_clockTest_continuous hF hcF hcP (fun s y => bP (s,y)) m x))).const_mul (1/2:ℝ)
  apply hasDerivAt_bivariate_chain
    (f := fun q s => clockTest m (J s).F (J s).A q x)
    (f₁ := fun q s => clockTestDerivative m (J s).F (J s).G (J s).H (J s).A (J s).A₁ (J s).A₂ q x)
    (f₂ := fun q s => clockGradient m (J s).F (D s) (J s).A (B s) q x)
    ?_ ?_ hct.continuousAt
    hcg.continuousAt ha hb
  · filter_upwards [continuous_fst.continuousAt.preimage_mem_nhds (Ioi_mem_nhds ha₀)] with p hp
    exact (hasDerivWithinAt_clockTest (J p.2).lipschitz (J p.2).smoothA (J p.2).smoothG (J p.2).smoothH
      (J p.2).smoothA₁ (J p.2).smoothA₂ (J p.2).derivF (J p.2).derivG (J p.2).derivA (J p.2).derivA₁ m x hp.le).hasDerivAt
        (Ici_mem_nhds hp)
  · filter_upwards [continuous_snd.continuousAt.preimage_mem_nhds (isOpen_Ioo.mem_nhds hbt)] with p hp
    apply hasDerivAt_tiltedMean_local hp hKD (K := max KA KB) (hKA.trans (le_max_left _ _))
      (fun s _ => ((J s).lipschitz.continuous.comp (continuous_const.add continuous_id)).measurable)
      ((hcD.comp (continuous_const.prodMk (continuous_const.add continuous_id))).measurable)
      (fun s _ => ((J s).smoothA.continuous.comp (continuous_const.add continuous_id)).measurable)
      ((hcB.comp (continuous_const.prodMk (continuous_const.add continuous_id))).measurable)
      (fun s hs z => hdF s hs (x+z)) (fun s hs z => hdA s hs (x+z))
      (fun s _ z => bD (s,x+z))
      (fun s _ z => (bA (s,x+z)).trans (le_max_left _ _))
      (fun s _ z => (bB (s,x+z)).trans (le_max_right _ _)) m
      ((exponentialIncrement_gaussian (fun _ : Fin (n+1) => Real.toNNReal p.1)).integrable_shift (J p.2).lipschitz m x)

end SKFluctuations.Hierarchy

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

 def HeatJet.potentialRate {n : ℕ} (J : HeatJet n) (m : ℝ) (y : Fin (n+1) → ℝ) : ℝ :=
  (1/2:ℝ)*∑ i, (J.H i y+m*(J.G i y)^2)
 def HeatJet.testRate {n : ℕ} (J : HeatJet n) (m : ℝ) (y : Fin (n+1) → ℝ) : ℝ :=
  (1/2:ℝ)*∑ i, (J.A₂ i y+2*m*J.A₁ i y*J.G i y)
 def HeatJet.energy {n : ℕ} (J : HeatJet n) (y : Fin (n+1) → ℝ) : ℝ :=
  ∑ i, (J.A₁ i y)^2

 theorem HeatJet.smoothPotentialRate {n : ℕ} (J : HeatJet n) (m : ℝ) : BddSmooth 0 (J.potentialRate m) := by
  apply (BddSmooth.sum Finset.univ fun i _ => ?_).const_mul
  simpa only [pow_two] using (J.smoothH i).add (((J.smoothG i).mul (J.smoothG i)).const_mul m)
 theorem HeatJet.smoothTestRate {n : ℕ} (J : HeatJet n) (m : ℝ) : BddSmooth 0 (J.testRate m) := by
  apply (BddSmooth.sum Finset.univ fun i _ => ?_).const_mul
  exact (J.smoothA₂ i).add (((J.smoothA₁ i).const_mul (2*m)).mul (J.smoothG i))
 theorem HeatJet.smoothEnergy {n : ℕ} (J : HeatJet n) : BddSmooth 0 J.energy := by
  apply BddSmooth.sum Finset.univ
  intro i _
  simpa only [pow_two] using (J.smoothA₁ i).mul (J.smoothA₁ i)
 theorem HeatJet.energy_nonneg {n : ℕ} (J : HeatJet n) (y : Fin (n+1) → ℝ) : 0 ≤ J.energy y :=
  Finset.sum_nonneg fun _ _ => sq_nonneg _

 theorem HeatJet.trace_eq_rate {n : ℕ} (J : HeatJet n) (m : ℝ) :
    potentialHeatTrace m J.G J.H = fun y => (2*m)*J.potentialRate m y := by
  funext y
  unfold potentialHeatTrace HeatJet.potentialRate
  simp only [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  ring
 theorem HeatJet.square_trace {n : ℕ} (J : HeatJet n) (m : ℝ) :
    testedHeatTrace m J.square.G J.square.H J.square.A J.square.A₁ J.square.A₂ =
      fun y => 2*J.energy y+2*(2*(J.A y*J.testRate m y))+(2*m)*((J.A y)^2*J.potentialRate m y) := by
  funext y
  unfold testedHeatTrace HeatJet.square HeatJet.energy HeatJet.testRate HeatJet.potentialRate
  simp only [Finset.mul_sum,← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro i _
  ring

 

 theorem HeatJet.square_cancellation {n : ℕ} (J : HeatJet n) (m t : ℝ) (x : Fin (n+1) → ℝ) :
    clockTestDerivative m J.square.F J.square.G J.square.H J.square.A J.square.A₁ J.square.A₂ t x-
      clockGradient m J.F (J.potentialRate m) J.square.A (fun y => 2*(J.A y*J.testRate m y)) t x =
        clockTest m J.F J.energy t x := by
  have hs := J.square.smoothA
  have hB := (J.smoothA.mul (J.smoothTestRate m)).const_mul 2
  have hAD := hs.mul (J.smoothPotentialRate m)
  unfold clockTestDerivative clockGradient
  rw [J.square_trace, J.square.trace_eq_rate]
  change (1/2:ℝ)*(clockTest m J.F
    (fun y => 2*J.energy y+2*(2*(J.A y*J.testRate m y))+(2*m)*((J.A y)^2*J.potentialRate m y)) t x-
      clockTest m J.F J.square.A t x*clockTest m J.F (fun y => (2*m)*J.potentialRate m y) t x)-
    (clockTest m J.F (fun y => 2*(J.A y*J.testRate m y)) t x+
      m*(clockTest m J.F (fun y => J.square.A y*J.potentialRate m y) t x-
        clockTest m J.F J.square.A t x*clockTest m J.F (J.potentialRate m) t x)) = _
  dsimp only [HeatJet.square] at hs hAD ⊢
  rw [clockTest_add_test J.lipschitz ((J.smoothEnergy.const_mul 2).add (hB.const_mul 2)) (hAD.const_mul (2*m)),
    clockTest_add_test J.lipschitz (J.smoothEnergy.const_mul 2) (hB.const_mul 2)]
  simp only [clockTest_const_mul]
  ring

 theorem HeatJetFamily.continuousPotentialRate {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (V.J p.1).potentialRate m p.2) := by
  exact (continuous_finsetSum _ fun i _ => (V.continuousH i).add (((V.continuousG i).pow 2).const_mul m)).const_mul (1/2:ℝ)
 theorem HeatJetFamily.continuousTestRate {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    Continuous (fun p : ℝ × (Fin (n+1) → ℝ) => (V.J p.1).testRate m p.2) := by
  exact (continuous_finsetSum _ fun i _ => (V.continuousA₂ i).add
    (((V.continuousA₁ i).const_mul (2*m)).mul (V.continuousG i))).const_mul (1/2:ℝ)
 theorem HeatJetFamily.boundedPotentialRate {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (V.J p.1).potentialRate m p.2) := by
  apply (AbsBounded.sum fun i => ?_).const_mul
  simpa only [pow_two] using (V.boundedH i).add (((V.boundedG i).mul (V.boundedG i)).const_mul m)
 theorem HeatJetFamily.boundedTestRate {n : ℕ} (V : HeatJetFamily n) (m : ℝ) :
    AbsBounded (fun p : ℝ × (Fin (n+1) → ℝ) => (V.J p.1).testRate m p.2) := by
  apply (AbsBounded.sum fun i => ?_).const_mul
  exact (V.boundedA₂ i).add (((V.boundedA₁ i).const_mul (2*m)).mul (V.boundedG i))

end SKFluctuations.Hierarchy

end

end OAI