| 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 |
| 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 |
| 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 |
| 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] |
| 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 |
| 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 |
| 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] |
| rw [he] |
| nlinarith only [hh,hr,ho] |
|
|
| end SKGapCutoff |
|
|
| open scoped BigOperators Topology |
|
|
| end |
|
|
| end OAI |
|
|
