lean/OAI/Probability/SKGap/Localization/ComponentRefresh.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
open scoped Topology Interval
open MeasureTheory
open MeasureTheory
open scoped BigOperators Topology Interval
open MeasureTheory
open scoped BigOperators Topology Interval
open scoped Topology
open MeasureTheory
open scoped BigOperators Topology Interval
namespace SKGapCutoff

noncomputable def componentRefresh {n : ℕ} (m : VectorFields n) (t : ℝ)
    (p : VectorFields n) : VectorFields n :=
  fun x i => refreshSemigroup m t (fun y => p y i) x

noncomputable def componentGenerator {n : ℕ} (m p : VectorFields n) : VectorFields n :=
  fun x i => refreshGenerator m (fun y => p y i) x

noncomputable def vectorDerivativeSquare {n : ℕ} (p : VectorFields n) (x : Spin n) : ℝ :=
  ∑ i, ∑ j, (halfDiff j (fun y => p y i) x)^2

lemma refresh_jensen_square {n : ℕ} (m : VectorFields n) (hm : ∀ x i, |m x i|≤1)
    (t : ℝ) (ht : 0≤t) (f : Observables n) (x : Spin n) :
    (refreshSemigroup m t f x)^2 ≤ refreshSemigroup m t (fun y => f y^2) x := by
  let a := refreshSemigroup m t f x
  have hh := refreshSemigroup_nonneg m hm t ht (fun y => (f y-a)^2) (fun y => sq_nonneg (f y-a)) x
  have he : (fun y => (f y-a)^2) = (fun y => f y^2) - (2*a) • f + (fun _ => a^2) := by
    funext y; simp only [Pi.sub_apply, Pi.add_apply, Pi.smul_apply, smul_eq_mul]; ring
  rw [he, map_add, map_sub, map_smul] at hh
  simp only [Pi.add_apply, Pi.sub_apply, Pi.smul_apply, smul_eq_mul,
    refreshSemigroup_const] at hh
  dsimp only [a] at hh
  nlinarith only [hh]

lemma componentRefresh_vectorSquare {n : ℕ} (m : VectorFields n)
    (hm : ∀ x i, |m x i|≤1) (t : ℝ) (ht : 0≤t) (p : VectorFields n) (x : Spin n) :
    vectorSquare (componentRefresh m t p) x ≤ refreshSemigroup m t (vectorSquare p) x := by
  calc
    _ ≤ ∑ i, refreshSemigroup m t (fun y => p y i^2) x := by
      exact Finset.sum_le_sum (fun i _ => refresh_jensen_square m hm t ht _ x)
    _ = _ := by
      have he : vectorSquare p = ∑ i, fun y => p y i^2 := by
        funext y; simp [vectorSquare]
      rw [he, map_sum, Finset.sum_apply]

lemma componentRefresh_derivativeSquare {n : ℕ} (m : VectorFields n) (C : ℝ)
    (hrough : ∀ q : VectorFields n, ∀ t : ℝ, 0≤t → ∀ x,
      vectorSquare (refreshGradientSemigroup m t q) x ≤
        Real.exp (C*t)*refreshSemigroup m t (vectorSquare q) x)
    (t : ℝ) (ht : 0≤t) (p : VectorFields n) (x : Spin n) :
    vectorDerivativeSquare (componentRefresh m t p) x ≤
      Real.exp (C*t)*refreshSemigroup m t (vectorDerivativeSquare p) x := by
  unfold vectorDerivativeSquare
  calc
    _ ≤ ∑ i, Real.exp (C*t)*refreshSemigroup m t
        (fun y => ∑ j, (halfDiff j (fun z => p z i) y)^2) x := by
      apply Finset.sum_le_sum
      intro i _
      have hh := hrough (fun y j => halfDiff j (fun z => p z i) y) t ht x
      change (∑ j, (refreshGradientSemigroup m t (fun y j => halfDiff j (fun z => p z i) y) x j)^2) ≤ _ at hh
      have he : vectorSquare (fun y j => halfDiff j (fun z => p z i) y) =
          fun y => ∑ j, (halfDiff j (fun z => p z i) y)^2 := rfl
      rw [he] at hh
      simpa only [componentRefresh, refreshHalfDiff_semigroup] using hh
    _ = _ := by
      rw [← Finset.mul_sum]
      congr 1
      have he : (fun y => ∑ i, ∑ j, (halfDiff j (fun z => p z i) y)^2) =
          ∑ i, (fun y => ∑ j, (halfDiff j (fun z => p z i) y)^2) := by funext y; simp
      rw [he, map_sum, Finset.sum_apply]

noncomputable def refreshCorrection {n : ℕ} (m p : VectorFields n) : VectorFields n :=
  componentGenerator m p-refreshGradientGenerator m p

lemma refreshCorrection_square {n : ℕ} (m p : VectorFields n)
    (x : Spin n) (M D : ℝ)
    (hrow : ∀ i, ∑ j, refreshInfluence m x i j^2 ≤ D)
    (hop : ∀ q : Fin n → ℝ, ∑ i, (∑ j, refreshInfluence m x i j*q j)^2 ≤
      M^2*∑ i, q i^2) :
    vectorSquare (refreshCorrection m p) x ≤
      3*(1+M^2)*vectorSquare p x+12*D*vectorDerivativeSquare p x := by
  have hc (i : Fin n) : (∑ j, refreshInfluence m x i j*halfDiff j (fun y => p y i) x)^2 ≤
      D*∑ j, (halfDiff j (fun y => p y i) x)^2 :=
    (Finset.sum_mul_sq_le_sq_mul_sq _ _ _).trans
      (mul_le_mul_of_nonneg_right (hrow i) (Finset.sum_nonneg (fun j _ => sq_nonneg _)))
  have he (i : Fin n) : (refreshCorrection m p x i)^2 ≤
      3*(p x i)^2 + 12*D*(∑ j, (halfDiff j (fun y => p y i) x)^2) +
        3*(∑ j, refreshInfluence m x i j*p x j)^2 := by
    have hrepr : refreshCorrection m p x i = p x i +
        2*spin x i*(∑ j, refreshInfluence m x i j*halfDiff j (fun y => p y i) x) -
        ∑ j, refreshInfluence m x i j*p x j := by
      simp only [refreshCorrection, Pi.sub_apply, componentGenerator, refreshGradientGenerator,
        refreshInfluence]
      ring
    rw [hrepr]
    have hs : (2*spin x i*(∑ j, refreshInfluence m x i j*halfDiff j (fun y => p y i) x))^2 =
        4*(∑ j, refreshInfluence m x i j*halfDiff j (fun y => p y i) x)^2 := by
      rw [mul_pow, mul_pow, spin_sq]; ring
    have hsum (a b c : ℝ) : (a+b-c)^2 ≤ 3*a^2+3*b^2+3*c^2 := by
      nlinarith only [sq_nonneg (a-b),sq_nonneg (a+c),sq_nonneg (b+c)]
    have hh := hsum (p x i) (2*spin x i*(∑ j, refreshInfluence m x i j*halfDiff j (fun y => p y i) x))
      (∑ j, refreshInfluence m x i j*p x j)
    rw [hs] at hh
    nlinarith only [hh,hc i]
  have hh := Finset.sum_le_sum (fun i (_ : i ∈ Finset.univ) => he i)
  simp only [Finset.sum_add_distrib, ← Finset.mul_sum] at hh
  have ho := hop (p x)
  dsimp only [vectorSquare, vectorDerivativeSquare]
  nlinarith only [hh,ho]

lemma componentRefresh_hasDerivAt {n : ℕ} (m p : VectorFields n) (t : ℝ) :
    HasDerivAt (fun s => componentRefresh m s p)
      (componentGenerator m (componentRefresh m t p)) t := by
  apply hasDerivAt_pi.mpr
  intro x
  apply hasDerivAt_pi.mpr
  intro i
  exact hasDerivAt_pi.mp (refreshSemigroup_apply_hasDerivAt' m (fun y => p y i) t) x

lemma gradientComponent_interpolate_hasDerivAt {n : ℕ} (m p : VectorFields n) (t s : ℝ) :
    HasDerivAt (fun r : ℝ => refreshGradientSemigroup m (t-r) (componentRefresh m r p))
      (refreshGradientSemigroup m (t-s) (refreshCorrection m (componentRefresh m s p))) s := by
  have hk := (hasDerivAt_exp_smul_const (refreshGradientGeneratorCLM m) (t-s)).scomp s
    ((hasDerivAt_id s).const_sub t)
  have hh := hk.clm_apply (componentRefresh_hasDerivAt m p s)
  apply hh.congr_deriv
  simp only [one_smul, neg_smul, Function.comp_def]
  change -refreshGradientSemigroup m (t-s) (refreshGradientGenerator m (componentRefresh m s p)) +
    refreshGradientSemigroup m (t-s) (componentGenerator m (componentRefresh m s p)) = _
  rw [refreshCorrection, map_sub]
  abel

noncomputable def vectorEvalEuclideanLM {n : ℕ} (x : Spin n) :
    VectorFields n →ₗ[ℝ] EuclideanSpace ℝ (Fin n) where
  toFun p := WithLp.toLp 2 (p x)
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

noncomputable def vectorEvalEuclidean {n : ℕ} (x : Spin n) :
    VectorFields n →L[ℝ] EuclideanSpace ℝ (Fin n) :=
  (vectorEvalEuclideanLM x).toContinuousLinearMap

lemma vectorEvalEuclidean_norm_sq {n : ℕ} (x : Spin n) (p : VectorFields n) :
    ‖vectorEvalEuclidean x p‖^2 = vectorSquare p x := by
  rw [EuclideanSpace.real_norm_sq_eq]
  rfl

lemma gradient_component_difference {n : ℕ} (m p : VectorFields n)
    (hm : ∀ x i, |m x i|≤1) (C B t : ℝ) (hC : 0≤C) (hB : 0≤B) (ht : 0≤t)
    (hrough : ∀ q : VectorFields n, ∀ s : ℝ, 0 ≤ s → ∀ x,
      vectorSquare (refreshGradientSemigroup m s q) x ≤
        Real.exp (C*s)*refreshSemigroup m s (vectorSquare q) x)
    (hcorr : ∀ s ∈ Set.Icc 0 t, ∀ x,
      vectorSquare (refreshCorrection m (componentRefresh m s p)) x ≤ B)
    (x : Spin n) :
    vectorSquare (refreshGradientSemigroup m t p-componentRefresh m t p) x ≤
      t^2*Real.exp (C*t)*B := by
  let f (s : ℝ) := vectorEvalEuclidean x
    (refreshGradientSemigroup m (t-s) (componentRefresh m s p))
  let f' (s : ℝ) := vectorEvalEuclidean x
    (refreshGradientSemigroup m (t-s) (refreshCorrection m (componentRefresh m s p)))
  have hd (s : ℝ) : HasDerivAt f (f' s) s :=
    (vectorEvalEuclidean x).hasFDerivAt.comp_hasDerivAt s
      (gradientComponent_interpolate_hasDerivAt m p t s)
  have hb (s : ℝ) (hs : s ∈ Set.Icc 0 t) : ‖f' s‖ ≤ Real.sqrt (Real.exp (C*t)*B) := by
    apply Real.le_sqrt_of_sq_le
    rw [show ‖f' s‖^2 = vectorSquare
      (refreshGradientSemigroup m (t-s) (refreshCorrection m (componentRefresh m s p))) x
        from vectorEvalEuclidean_norm_sq _ _]
    calc
      _ ≤ Real.exp (C*(t-s))*refreshSemigroup m (t-s)
          (vectorSquare (refreshCorrection m (componentRefresh m s p))) x :=
        hrough _ _ (sub_nonneg.mpr hs.2) _
      _ ≤ Real.exp (C*(t-s))*B := mul_le_mul_of_nonneg_left
        ((refreshSemigroup_mono m hm (t-s) (sub_nonneg.mpr hs.2) (hcorr s hs) x).trans_eq
          (by simp)) (Real.exp_pos _).le
      _ ≤ _ := mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr (by nlinarith [hs.1])) hB
  have hh := norm_image_sub_le_of_norm_deriv_le_segment'
    (fun s (_ : s ∈ Set.Icc 0 t) => (hd s).hasDerivWithinAt)
    (fun s hs => hb s ⟨hs.1,hs.2.le⟩) t ⟨ht,le_rfl⟩
  have hzero : componentRefresh m 0 p = p := by ext y i; simp [componentRefresh]
  have hend : f t-f 0 = vectorEvalEuclidean x
      (componentRefresh m t p-refreshGradientSemigroup m t p) := by
    simp only [f, sub_self, sub_zero, refreshGradientSemigroup, zero_smul,
      NormedSpace.exp_zero, one_apply_eq_self, hzero, map_sub]
  rw [hend, sub_zero] at hh
  have hh' := pow_le_pow_left₀ (norm_nonneg _) hh 2
  rw [mul_pow, Real.sq_sqrt (mul_nonneg (Real.exp_pos _).le hB),
    vectorEvalEuclidean_norm_sq] at hh'
  have he : vectorSquare (componentRefresh m t p-refreshGradientSemigroup m t p) x =
      vectorSquare (refreshGradientSemigroup m t p-componentRefresh m t p) x := by
    unfold vectorSquare
    apply Finset.sum_congr rfl
    intro i _
    simp only [Pi.sub_apply]
    ring
  rw [he] at hh'
  nlinarith only [hh']

lemma component_correction_bound {n : ℕ} (m p : VectorFields n)
    (hm : ∀ x i, |m x i|≤1) (C U H M D t s : ℝ)
    (hC : 0≤C) (hU0 : 0≤U) (hH0 : 0≤H) (hD : 0≤D)
    (hs : s ∈ Set.Icc 0 t)
    (hrough : ∀ q : VectorFields n, ∀ u : ℝ, 0≤u → ∀ x,
      vectorSquare (refreshGradientSemigroup m u q) x ≤
        Real.exp (C*u)*refreshSemigroup m u (vectorSquare q) x)
    (hU : ∀ x, vectorSquare p x ≤ U) (hH : ∀ x, vectorDerivativeSquare p x ≤ H)
    (hrow : ∀ x i, ∑ j, refreshInfluence m x i j^2 ≤ D)
    (hop : ∀ x (q : Fin n → ℝ), ∑ i, (∑ j, refreshInfluence m x i j*q j)^2 ≤
      M^2*∑ i, q i^2) (x : Spin n) :
    vectorSquare (refreshCorrection m (componentRefresh m s p)) x ≤
      Real.exp (C*t)*(3*(1+M^2)*U+12*D*H) := by
  have hu : vectorSquare (componentRefresh m s p) x ≤ U :=
    (componentRefresh_vectorSquare m hm s hs.1 p x).trans
      ((refreshSemigroup_mono m hm s hs.1 hU x).trans_eq (by simp))
  have hh : vectorDerivativeSquare (componentRefresh m s p) x ≤ Real.exp (C*t)*H := by
    calc
      _ ≤ Real.exp (C*s)*refreshSemigroup m s (vectorDerivativeSquare p) x :=
        componentRefresh_derivativeSquare m C hrough s hs.1 p x
      _ ≤ Real.exp (C*s)*H := mul_le_mul_of_nonneg_left
        ((refreshSemigroup_mono m hm s hs.1 hH x).trans_eq (by simp)) (Real.exp_pos _).le
      _ ≤ _ := mul_le_mul_of_nonneg_right
        (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hs.2 hC)) hH0
  have he : 1 ≤ Real.exp (C*t) := Real.one_le_exp_iff.mpr (mul_nonneg hC (hs.1.trans hs.2))
  have hu' : vectorSquare (componentRefresh m s p) x ≤ Real.exp (C*t)*U :=
    hu.trans (by nlinarith only [mul_le_mul_of_nonneg_right he hU0])
  calc
    _ ≤ 3*(1+M^2)*vectorSquare (componentRefresh m s p) x+
        12*D*vectorDerivativeSquare (componentRefresh m s p) x :=
      refreshCorrection_square m _ x M D (hrow x) (hop x)
    _ ≤ 3*(1+M^2)*(Real.exp (C*t)*U)+12*D*(Real.exp (C*t)*H) :=
      add_le_add (mul_le_mul_of_nonneg_left hu' (by positivity))
        (mul_le_mul_of_nonneg_left hh (by positivity))
    _ = _ := by ring

lemma vectorSquare_sub_triangle {n : ℕ} (p q r : VectorFields n) (x : Spin n) :
    vectorSquare (p-r) x ≤ 2*vectorSquare (p-q) x+2*vectorSquare (q-r) x := by
  simp only [vectorSquare, Pi.sub_apply, Finset.mul_sum, ← Finset.sum_add_distrib]
  exact Finset.sum_le_sum (fun i _ => by
    nlinarith only [sq_nonneg (p x i-2*q x i+r x i)])

lemma componentRefresh_difference {n : ℕ} (m p : VectorFields n)
    (hm : ∀ x i, |m x i|≤1) (t : ℝ) (ht : 0≤t) (x : Spin n) :
    vectorSquare (componentRefresh m t p-p) x ≤
      refreshSemigroup m t (fun y => ∑ i, (p y i-p x i)^2) x := by
  have hi (i : Fin n) : (componentRefresh m t p x i-p x i)^2 ≤
      refreshSemigroup m t (fun y => (p y i-p x i)^2) x := by
    have hh := refresh_jensen_square m hm t ht (fun y => p y i-p x i) x
    have he : (fun y => p y i-p x i) = (fun y => p y i)-(fun _ => p x i) := rfl
    rw [he, map_sub] at hh
    simpa only [Pi.sub_apply, refreshSemigroup_const, componentRefresh] using hh
  have he : (fun y => ∑ i, (p y i-p x i)^2) = ∑ i, fun y => (p y i-p x i)^2 := by
    funext y; simp
  rw [he, map_sum, Finset.sum_apply]
  exact Finset.sum_le_sum (fun i _ => hi i)

theorem refreshGradient_short_time {n : ℕ} (m p : VectorFields n)
    (hm : ∀ x i, |m x i|≤1) (C U H M D t : ℝ)
    (hC : 0≤C) (hU0 : 0≤U) (hH0 : 0≤H) (hD : 0≤D) (ht : 0≤t)
    (hrough : ∀ q : VectorFields n, ∀ u : ℝ, 0≤u → ∀ x,
      vectorSquare (refreshGradientSemigroup m u q) x ≤
        Real.exp (C*u)*refreshSemigroup m u (vectorSquare q) x)
    (hU : ∀ x, vectorSquare p x ≤ U) (hH : ∀ x, vectorDerivativeSquare p x ≤ H)
    (hrow : ∀ x i, ∑ j, refreshInfluence m x i j^2 ≤ D)
    (hop : ∀ x (q : Fin n → ℝ), ∑ i, (∑ j, refreshInfluence m x i j*q j)^2 ≤
      M^2*∑ i, q i^2) (x : Spin n) :
    vectorSquare (refreshGradientSemigroup m t p-p) x ≤
      2*t^2*Real.exp (2*C*t)*(3*(1+M^2)*U+12*D*H)+
        2*refreshSemigroup m t (fun y => ∑ i, (p y i-p x i)^2) x := by
  have hB : 0 ≤ Real.exp (C*t)*(3*(1+M^2)*U+12*D*H) := by positivity
  have hh := gradient_component_difference m p hm C _ t hC hB ht hrough
    (fun s hs x => component_correction_bound m p hm C U H M D t s hC hU0 hH0 hD hs
      hrough hU hH hrow hop x) x
  have hr := vectorSquare_sub_triangle (refreshGradientSemigroup m t p) (componentRefresh m t p) p x
  have ho := componentRefresh_difference m p hm t ht x
  have he : Real.exp (2*C*t) = Real.exp (C*t)*Real.exp (C*t) := by
    rw [← Real.exp_add]; congr 1; ring
  rw [he]
  nlinarith only [hh,hr,ho]

end SKGapCutoff

open scoped BigOperators Topology

end

end OAI