Download data/lean/OAI/Probability/SKGap/Localization/ComponentRefresh.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 21.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKGap/Localization/ComponentRefresh.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SKGap/Localization/ComponentRefresh.lean
-
curl -L -o ComponentRefresh.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKGap/Localization/ComponentRefresh.lean
21.4 kB
| 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 | |