lean/OAI/Probability/SKGap/Stability/HalfDiffField.lean

import Mathlib
import OAI.Probability.SKGap.Localization.PreparationGrowth

namespace OAI

section
open scoped BigOperators
open scoped BigOperators
open scoped BigOperators
open scoped BigOperators
open scoped BigOperators
open scoped BigOperators NNReal
open MeasureTheory ProbabilityTheory
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal
open MeasureTheory ProbabilityTheory
open scoped BigOperators NNReal ENNReal
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal ENNReal
open MeasureTheory ProbabilityTheory
open scoped BigOperators Matrix Matrix.Norms.Elementwise
open scoped BigOperators
open MeasureTheory ProbabilityTheory
open scoped BigOperators Matrix Matrix.Norms.Elementwise
open scoped BigOperators
open scoped BigOperators NNReal ENNReal
open MeasureTheory Metric Set
open scoped BigOperators NNReal ENNReal
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators NNReal ENNReal Matrix.Norms.L2Operator
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Matrix.Norms.L2Operator
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Set
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators ENNReal NNReal
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal ENNReal Matrix
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators ENNReal NNReal
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal ENNReal
open scoped BigOperators
open MeasureTheory ProbabilityTheory
open scoped BigOperators Matrix Matrix.Norms.Elementwise NNReal ENNReal
open scoped BigOperators
open Filter Topology
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal ENNReal Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal ENNReal Topology
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal Topology
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Set Matrix
open scoped BigOperators NNReal ENNReal Matrix.Norms.L2Operator
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open MeasureTheory ProbabilityTheory Filter Matrix
open scoped NNReal ENNReal BigOperators Topology Matrix Matrix.Norms.Elementwise
open Filter MeasureTheory ProbabilityTheory
open scoped Topology NNReal ENNReal
open Filter MeasureTheory ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter
open scoped Topology NNReal ENNReal
open MeasureTheory Filter ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter
open scoped Topology
open MeasureTheory Filter ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter ProbabilityTheory ContinuousLinearMap
open scoped Topology NNReal ENNReal
open Filter MeasureTheory ProbabilityTheory
open scoped Topology NNReal ENNReal
open MeasureTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter
open scoped BigOperators Topology
open MeasureTheory Filter
open scoped BigOperators Topology
open Filter Set Metric
open scoped Topology RealInnerProductSpace
open scoped BigOperators
open ContinuousLinearMap
open scoped BigOperators
open ContinuousLinearMap
namespace SKGapCutoff
open RandomMatrix

lemma halfDiff_field {n : ℕ} (J : Interaction n) (x : Spin n) (i j : Fin n) :
    halfDiff i (fun y => field J y j) x = J j i := by
  simp only [field, halfDiff_sum, halfDiff_mul, halfDiff_const, halfDiff_spin,
    add_zero, mul_ite, mul_one, mul_zero]
  simp

lemma halfDiff_field_add {n : ℕ} (J : Interaction n) (g : VectorFields n)
    (x : Spin n) (i j : Fin n) :
    halfDiff i (fun y => field J y j+g y j) x = J j i+halfDiff i (fun y => g y j) x := by
  rw [← halfDiff_field J x i j]
  simp only [halfDiff]
  ring

lemma refreshSemigroup_eq_preparationFlow {n : ℕ} (J : Interaction n)
    (g : VectorFields n) (t : ℝ) :
    refreshSemigroup (fun x i => Real.tanh (field J x i+g x i)) t = preparationFlow J g t := by
  rw [refreshSemigroup, refreshGeneratorCLM_eq, smul_smul, mul_comm t]
  rfl

theorem preparation_poincare {n : ℕ} (J : Interaction n)
    (γ : ℝ) (hγ : 0 < γ) (hg : HasGap J γ)
    (g : VectorFields n) (C : ℝ) (hC : 0 ≤ C)
    (hJC : ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) J‖ ≤ C)
    (hgc : ∀ x, ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ)
      (fun j i => halfDiff i (fun y => g y j) x)‖ ≤ 1)
    (f : Observables n) (t : ℝ) (ht : 0 ≤ t) :
    gibbsExpectation J (preparationFlow J g t (fun y => f y^2)) -
      (gibbsExpectation J (preparationFlow J g t f))^2 ≤
      (γ⁻¹*Real.exp (preparationGrowth (C+1)*t)+
        4*((Real.exp (preparationGrowth (C+1)*t)-1)/preparationGrowth (C+1)))*
        gibbsExpectation J (preparationFlow J g t (fun y => ∑ i, (halfDiff i f y)^2)) := by
  have hHC (x : Spin n) : ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ)
      (fun j i => halfDiff i (fun y => field J y j+g y j) x)‖ ≤ C+1 := by
    have he : Matrix.of (fun j i => halfDiff i (fun y => field J y j+g y j) x) =
        J+Matrix.of (fun j i => halfDiff i (fun y => g y j) x) := by
      ext j i
      exact halfDiff_field_add J g x i j
    change ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ)
      (Matrix.of (fun j i => halfDiff i (fun y => field J y j+g y j) x))‖ ≤ C+1
    rw [he, map_add]
    exact (norm_add_le _ _).trans (add_le_add hJC (hgc x))
  have hh := preparation_poincare_field J γ hγ hg (fun x i => field J x i+g x i)
    (C+1) (by linarith) hHC f t ht
  simpa only [refreshSemigroup_eq_preparationFlow] using hh

end SKGapCutoff

open scoped Topology Interval
open MeasureTheory
namespace SKGapCutoff

lemma interval_hasFDerivAt_of_continuous
    {H E : Type*} [NormedAddCommGroup H] [NormedSpace ℝ H] [ProperSpace H]
    [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
    (F : H → ℝ → E) (F' : H → ℝ → H →L[ℝ] E)
    (hF : Continuous (Function.uncurry F)) (hF' : Continuous (Function.uncurry F'))
    (hd : ∀ x t, HasFDerivAt (fun y => F y t) (F' x t) x)
    (a b : ℝ) (x : H) :
    HasFDerivAt (fun y => ∫ t in a..b, F y t) (∫ t in a..b, F' x t) x := by
  obtain ⟨C,hC⟩ := ((isCompact_closedBall x 1).prod isCompact_uIcc).exists_bound_of_continuousOn
    hF'.continuousOn
  apply intervalIntegral.hasFDerivAt_integral_of_dominated_of_fderiv_le
    (s := Metric.closedBall x 1) (bound := fun _ => C) (Metric.closedBall_mem_nhds x (by norm_num))
  · filter_upwards [] with y
    exact (hF.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  · exact (hF.comp (continuous_const.prodMk continuous_id)).intervalIntegrable _ _
  · exact (hF'.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  · filter_upwards [] with t ht y hy
    exact hC (y,t) ⟨hy, Set.uIoc_subset_uIcc ht⟩
  · exact intervalIntegrable_const
  · filter_upwards [] with t _ y _
    exact hd y t

lemma algebra_exp_contDiff {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] : ContDiff ℝ ⊤ (NormedSpace.exp : A → A) := by
  exact contDiff_iff_contDiffAt.mpr (fun x => (NormedSpace.exp_analytic (𝕂 := ℝ) x).contDiffAt)

lemma algebra_duhamel {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] (X Y : A) (t : ℝ) :
    NormedSpace.exp (t • Y)-NormedSpace.exp (t • X) =
      ∫ s in 0..t, NormedSpace.exp (s • X)*(Y-X)*NormedSpace.exp ((t-s) • Y) := by
  let : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℝ A
  have hc : Continuous (fun s : ℝ => NormedSpace.exp (s • X)*(Y-X)*NormedSpace.exp ((t-s) • Y)) := by
    fun_prop
  have hd (s : ℝ) : HasDerivAt
      (fun u : ℝ => NormedSpace.exp (u • X)*NormedSpace.exp ((t-u) • Y))
      (-(NormedSpace.exp (s • X)*(Y-X)*NormedSpace.exp ((t-s) • Y))) s := by
    have h1 := hasDerivAt_exp_smul_const X s
    have h2 := (hasDerivAt_exp_smul_const' Y (t-s)).scomp s
      ((hasDerivAt_id s).const_sub t)
    convert! h1.mul h2 using 1
    simp only [one_smul, neg_smul]
    noncomm_ring
  have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt (fun s _ => hd s)
    (hc.neg.intervalIntegrable 0 t)
  simp only [intervalIntegral.integral_neg, sub_self, zero_smul, NormedSpace.exp_zero,
    mul_one, one_mul, sub_zero] at hi
  simpa only [neg_sub, neg_neg] using (congrArg Neg.neg hi).symm

lemma algebra_exp_smul_hasFDerivAt {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] [ProperSpace A] (X : A) (t : ℝ) :
    HasFDerivAt (fun Y : A => NormedSpace.exp (t • Y))
      (∫ s in 0..t, ContinuousLinearMap.mulLeftRight ℝ A
        (NormedSpace.exp (s • X)) (NormedSpace.exp ((t-s) • X))) X := by
  let F : A → ℝ → A := fun Y s =>
    NormedSpace.exp (s • X)*(Y-X)*NormedSpace.exp ((t-s) • Y)
  have ce : ContDiff ℝ ⊤ (NormedSpace.exp : A → A) := algebra_exp_contDiff
  have hF : ContDiff ℝ ⊤ (Function.uncurry F) := by
    exact ((ce.comp (contDiff_snd.smul_const X)).mul (contDiff_fst.sub contDiff_const)).mul
      (ce.comp ((contDiff_const.sub contDiff_snd).smul contDiff_fst))
  have hd (Y : A) (s : ℝ) : DifferentiableAt ℝ (fun Z => F Z s) Y := by
    exact (hF.comp (contDiff_id.prodMk contDiff_const)).differentiable (by simp) |>.differentiableAt
  have hc' : Continuous (fun p : A × ℝ => fderiv ℝ (fun Y => F Y p.2) p.1) := by
    have hFF : ContDiff ℝ ⊤ (fun p : (A × ℝ) × A => F p.2 p.1.2) :=
      hF.comp (contDiff_snd.prodMk contDiff_fst.snd)
    exact Continuous.fderiv (f := fun p : A × ℝ => fun Y => F Y p.2)
      (g := fun p => p.1) hFF continuous_fst le_top
  have hint := interval_hasFDerivAt_of_continuous F
    (fun Y s => fderiv ℝ (fun Z => F Z s) Y) hF.continuous hc'
    (fun Y s => (hd Y s).hasFDerivAt) 0 t X
  have he (s : ℝ) : fderiv ℝ (fun Y => F Y s) X =
      ContinuousLinearMap.mulLeftRight ℝ A (NormedSpace.exp (s • X))
        (NormedSpace.exp ((t-s) • X)) := by
    have hdR : DifferentiableAt ℝ (fun Y : A => NormedSpace.exp ((t-s) • Y)) X :=
      (ce.comp (contDiff_id.const_smul (t-s))).differentiable (by simp) |>.differentiableAt
    have hh := (((hasFDerivAt_id X).sub_const X).mul' hdR.hasFDerivAt).const_mul
      (NormedSpace.exp (s • X))
    have hfun : (fun Y => NormedSpace.exp (s • X)*((Y-X)*NormedSpace.exp ((t-s) • Y))) =
        (fun Y => F Y s) := by funext Y; exact (mul_assoc _ _ _).symm
    simp only [Pi.mul_apply, id_eq] at hh
    rw [hfun] at hh
    rw [hh.fderiv]
    ext Z
    simp [ContinuousLinearMap.mulLeftRight_apply, mul_assoc]
  simp_rw [he] at hint
  have hfinal := hint.add_const (NormedSpace.exp (t • X))
  convert! hfinal using 1
  funext Y
  rw [← algebra_duhamel X Y t]
  exact (sub_add_cancel _ _).symm

lemma algebra_exp_curve_hasDerivAt {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] [ProperSpace A] {L : ℝ → A} {L' : A} {θ : ℝ}
    (hL : HasDerivAt L L' θ) (t : ℝ) :
    HasDerivAt (fun u => NormedSpace.exp (t • L u))
      (∫ s in 0..t, NormedSpace.exp (s • L θ)*L'*NormedSpace.exp ((t-s) • L θ)) θ := by
  have hc : Continuous (fun s : ℝ => ContinuousLinearMap.mulLeftRight ℝ A
      (NormedSpace.exp (s • L θ)) (NormedSpace.exp ((t-s) • L θ))) := by
    have ce : Continuous (NormedSpace.exp : A → A) := algebra_exp_contDiff.continuous
    exact ((ContinuousLinearMap.mulLeftRight ℝ A).continuous.comp
      (ce.comp (continuous_id.smul continuous_const))).clm_apply
        (ce.comp ((continuous_const.sub continuous_id).smul continuous_const))
  have hh := (algebra_exp_smul_hasFDerivAt (L θ) t).comp_hasDerivAt θ hL
  rw [ContinuousLinearMap.intervalIntegral_apply (hc.intervalIntegrable _ _) L'] at hh
  exact hh

noncomputable def meanGeneratorCLM {n : ℕ} (m : VectorFields n) :
    Observables n →L[ℝ] Observables n := refreshGeneratorCLM m-refreshGeneratorCLM 0

lemma meanGeneratorCLM_apply {n : ℕ} (m : VectorFields n) (f : Observables n) (x : Spin n) :
    meanGeneratorCLM m f x = ∑ i, m x i*halfDiff i f x := by
  change (∑ i, (m x i-spin x i)*halfDiff i f x)-
    (∑ i, (0-spin x i)*halfDiff i f x) = _
  rw [← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro i _
  ring

noncomputable def meanGeneratorMapLM (n : ℕ) :
    VectorFields n →ₗ[ℝ] (Observables n →L[ℝ] Observables n) where
  toFun := meanGeneratorCLM
  map_add' p q := by
    ext f x
    simp [meanGeneratorCLM_apply, add_mul, Finset.sum_add_distrib]
  map_smul' a p := by
    ext f x
    simp [meanGeneratorCLM_apply, mul_assoc, Finset.mul_sum]

noncomputable def meanGeneratorMap (n : ℕ) :
    VectorFields n →L[ℝ] (Observables n →L[ℝ] Observables n) :=
  (meanGeneratorMapLM n).toContinuousLinearMap

lemma meanGeneratorMap_apply {n : ℕ} (m : VectorFields n) :
    meanGeneratorMap n m = meanGeneratorCLM m := rfl

lemma refreshGeneratorCLM_eq_mean {n : ℕ} (m : VectorFields n) :
    refreshGeneratorCLM m = meanGeneratorMap n m + refreshGeneratorCLM 0 := by
  simp [meanGeneratorMap_apply, meanGeneratorCLM]

lemma preparation_mean_hasDerivAt {n : ℕ} (H v : VectorFields n) (θ : ℝ) :
    HasDerivAt (fun u : ℝ => (fun x i => Real.tanh (H x i+u*v x i) : VectorFields n))
      (fun x i => scalarVariance (H x i+θ*v x i)*v x i) θ := by
  apply hasDerivAt_pi.mpr
  intro x
  apply hasDerivAt_pi.mpr
  intro i
  convert! (tanh_hasDerivAt (H x i+θ*v x i)).comp θ
    (((hasDerivAt_id θ).mul_const (v x i)).const_add (H x i)) using 1
  simp

lemma preparation_generator_hasDerivAt {n : ℕ} (H v : VectorFields n) (θ : ℝ) :
    HasDerivAt (fun u : ℝ => refreshGeneratorCLM (fun x i => Real.tanh (H x i+u*v x i)))
      (meanGeneratorCLM (fun x i => scalarVariance (H x i+θ*v x i)*v x i)) θ := by
  have hh := ((meanGeneratorMap n).hasFDerivAt.comp_hasDerivAt θ
    (preparation_mean_hasDerivAt H v θ)).add_const (refreshGeneratorCLM 0)
  simp only [meanGeneratorMap_apply] at hh
  convert! hh using 1
  funext u
  exact refreshGeneratorCLM_eq_mean _

lemma preparation_semigroup_hasDerivAt {n : ℕ} (H v : VectorFields n) (θ h : ℝ) :
    HasDerivAt (fun u : ℝ => refreshSemigroup (fun x i => Real.tanh (H x i+u*v x i)) h)
      (∫ s in 0..h,
        refreshSemigroup (fun x i => Real.tanh (H x i+θ*v x i)) s *
        meanGeneratorCLM (fun x i => scalarVariance (H x i+θ*v x i)*v x i) *
        refreshSemigroup (fun x i => Real.tanh (H x i+θ*v x i)) (h-s)) θ := by
  exact algebra_exp_curve_hasDerivAt (preparation_generator_hasDerivAt H v θ) h

theorem preparation_expectation_hasDerivAt {n : ℕ} (J : Interaction n)
    (g v : VectorFields n) (θ h : ℝ) (f : Observables n) :
    HasDerivAt (fun u : ℝ => gibbsExpectation J
      (preparationFlow J (fun x i => g x i+u*v x i) h f))
      (∫ s in 0..h, gibbsExpectation J
        (preparationFlow J (fun x i => g x i+θ*v x i) s
          (fun x => ∑ i, scalarVariance (field J x i+g x i+θ*v x i)*v x i*
            halfDiff i (preparationFlow J (fun x i => g x i+θ*v x i) (h-s) f) x))) θ := by
  let m : VectorFields n := fun x i => Real.tanh (field J x i+g x i+θ*v x i)
  let B := meanGeneratorCLM (fun x i => scalarVariance (field J x i+g x i+θ*v x i)*v x i)
  have hc : Continuous (fun s : ℝ => refreshSemigroup m s*B*refreshSemigroup m (h-s)) := by
    exact ((refreshSemigroup_continuous m).mul continuous_const).mul
      ((refreshSemigroup_continuous m).comp (continuous_const.sub continuous_id))
  have hd := (preparation_semigroup_hasDerivAt (fun x i => field J x i+g x i) v θ h).clm_apply
    (hasDerivAt_const θ f)
  have hh := (expectationCLM J).hasFDerivAt.comp_hasDerivAt θ hd
  simp only [map_zero, add_zero] at hh
  change HasDerivAt _ (expectationCLM J ((∫ s in 0..h,
    refreshSemigroup m s*B*refreshSemigroup m (h-s)) f)) θ at hh
  rw [ContinuousLinearMap.intervalIntegral_apply (hc.intervalIntegrable _ _) f,
    ← (expectationCLM J).intervalIntegral_comp_comm
      ((hc.clm_apply continuous_const).intervalIntegrable _ _)] at hh
  have he (u k : ℝ) : refreshSemigroup
      (fun x i => Real.tanh (field J x i+g x i+u*v x i)) k =
      preparationFlow J (fun x i => g x i+u*v x i) k := by
    convert! refreshSemigroup_eq_preparationFlow J (fun x i => g x i+u*v x i) k using 1
    congr 1
    funext x i
    congr 1
    ring
  simp only [mul_apply_eq_comp, m, B, he] at hh
  have hB (q : Observables n) :
      meanGeneratorCLM (fun x i => scalarVariance (field J x i+g x i+θ*v x i)*v x i) q =
        fun x => ∑ i, scalarVariance (field J x i+g x i+θ*v x i)*v x i*halfDiff i q x := by
    funext x
    exact meanGeneratorCLM_apply _ q x
  simp_rw [hB] at hh
  exact hh

end SKGapCutoff

end

end OAI