File size: 8,819 Bytes
7d9f027 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | import Mathlib
import OAI.Probability.SKGap.Localization.CoefficientRow
import OAI.Probability.SKGap.Stability.ImplicitPerturb
import OAI.Probability.SKGap.Stability.ImplicitUniform
namespace OAI
section
noncomputable section
namespace SKGap.ImplicitSystem
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
[FiniteDimensional ℝ E] {ι : Type*} [Fintype ι]
def uniformControlBudget (j δ B : ℝ) : ℝ :=
let L:=B+|j| *B^2+2*|j| *B
let W:=(1+B^2*(δ/2)⁻¹*L)*B^2*(B+2*|j| *B)
let C:=B*W+B
let Y:=(B+|j| *B^2)*W+|j| *C
let F:=(1+B^2*(δ/2)⁻¹*L)*(B*(B+Y+|j| *C)+B^2*B+
|j| *B^2*W*B+|j| *B^2*C*B+|j| *B^2*2*(B*W+B))
let G:=B*W+B+B*F
let H:=(B+|j| *B^2)*F+|j| *W*B+|j| *C*B+|j| *G
W+C+Y+F+G+H
lemma uniformControlBudget_nonneg {j δ B : ℝ} (hδ : 0<δ) (hB : 0≤B) :
0≤uniformControlBudget j δ B := by unfold uniformControlBudget; positivity
theorem implicit_uniform_control (j χ b r p : ℝ) (X J : E→L[ℝ]E)
(u m t ell q w y : E) (c : ℝ)
(s χ' p' c' b' : ι→ℝ) (X' : ι→E→L[ℝ]E) (u' m' ell' w' y' q' : ι→E)
{δ d B : ℝ} (hδ : 0<δ) (hd : 0<d) (hr : 0≤r) (hscale : r*d^2=1) (hB : 0≤B)
(hX : ‖X‖≤B) (hX' : ∀i,‖X' i‖≤B) (hJ : ‖J‖≤B)
(hχ : |χ|≤B^2) (hχ' : ∀i,|χ' i|≤B^2)
(hu : ‖u‖≤B) (hm : ‖m‖≤d) (hm' : ∀i,‖m' i‖≤d) (ht : ‖t‖≤d)
(hell : ‖ell‖≤B*d) (hell' : ∀i,‖ell' i‖≤B*d) (hp : d*|p|≤B)
(hS : ∀v,δ*‖v‖^2≤ inner ℝ v (stableMatrix j b r X J q v))
(hS' : ∀i v,δ*‖v‖^2≤ inner ℝ v (stableMatrix j (b' i) r (X' i) J (q' i) v))
(hSmall : |j| *|χ-b| *‖X‖^2+|j*r| *‖X‖^2*
(‖m+t-(2:ℝ) • q‖*‖ell‖+2*‖q‖*‖ell+q‖)≤δ/2)
(hSmall' : ∀i,|j| *|χ' i-b' i| *‖X' i‖^2+|j*r| *‖X' i‖^2*
(‖m' i+t-(2:ℝ) • q' i‖*‖ell' i‖+2*‖q' i‖*‖ell' i+q' i‖)≤δ/2)
(h : Equations j χ r p (X*X) J u m t ell w y c)
(h' : ∀i,Equations j (χ' i) r (p' i) (X' i*X' i) J (u' i) (m' i) t (ell' i) (w' i) (y' i) (c' i))
(hDA : ∀V,columnNorm (fun i=>(s i • (X*X-X' i*X' i)) V)≤B*‖V‖)
(hDu : columnNorm (fun i=>s i • (u-u' i))≤B)
(hDχ : columnNorm (fun i=>s i*(χ-χ' i))≤B)
(hDm : columnNorm (fun i=>s i • (m-m' i))≤B*d)
(hDell : columnNorm (fun i=>s i • (ell-ell' i))≤B*d)
(hDp : d*columnNorm (fun i=>s i*(p-p' i))≤B) :
‖w‖+d*|c|+‖y‖+columnNorm (fun i=>s i • (w-w' i))+
d*columnNorm (fun i=>s i*(c-c' i))+columnNorm (fun i=>s i • (y-y' i))≤
uniformControlBudget j δ B := by
let L:=B+|j| *B^2+2*|j| *B
let W:=(1+B^2*(δ/2)⁻¹*L)*B^2*(B+2*|j| *B)
let C:=B*W+B
let Y:=(B+|j| *B^2)*W+|j| *C
let F:=(1+B^2*(δ/2)⁻¹*L)*(B*(B+Y+|j| *C)+B^2*B+
|j| *B^2*W*B+|j| *B^2*C*B+|j| *B^2*2*(B*W+B))
let G:=B*W+B+B*F
let H:=(B+|j| *B^2)*F+|j| *W*B+|j| *C*B+|j| *G
have hW0 : 0≤W := by dsimp [W,L]; positivity
have hC0 : 0≤C := by dsimp [C]; positivity
have hY0 : 0≤Y := by dsimp [Y]; positivity
have hL0 : 0≤L := by dsimp [L]; positivity
have hF0 : 0≤F := by dsimp [F]; positivity
obtain ⟨hw,hc,hy⟩:=implicit_uniform_size j χ b r p X J u m t ell q w y c
hδ hd hr hscale (sq_nonneg B) hB hB hB hB
(pow_le_pow_left₀ (norm_nonneg X) hX 2) hJ hχ hu hm ht hell hp hS hSmall h
change ‖w‖≤W at hw
change d*|c|≤C at hc
change ‖y‖≤Y at hy
have hl : ∀i,‖L₂ j (χ' i) r J (m' i+t) (ell' i)‖≤L := by
intro i
have hv : ‖m' i+t‖≤2*d := (norm_add_le _ _).trans (by linarith [hm' i])
convert L₂_normalized_bound j (χ' i) r J (m' i+t) (ell' i) hr hd.le hscale
(by norm_num : (0:ℝ)≤2) hB hv (hell' i) (hχ' i) hJ using 1; dsimp [L]; ring
have hb : ‖u+J w-(j*χ) • w-(j*c) • (m+t)‖≤B+Y+|j| *C := by
have he : u+J w-(j*χ) • w-(j*c) • (m+t)=u+y-(j*c) • t := by
rw [h.2.1]; module
rw [he]
apply (norm_sub_le _ _).trans
have hct : ‖(j*c) • t‖≤|j| *C := by
rw [norm_smul,Real.norm_eq_abs,abs_mul]
calc
_ ≤ |j| *|c| *d := mul_le_mul_of_nonneg_left ht (by positivity)
_ = |j| *(d*|c|) := by ring
_ ≤ _ := mul_le_mul_of_nonneg_left hc (abs_nonneg j)
exact add_le_add ((norm_add_le _ _).trans (add_le_add hu hy)) hct
have hf:=implicit_frobenius_estimate j χ r p X J u m t ell w y c
s χ' p' c' X' u' m' ell' w' y' q' b' h h' hδ hB hL0 hd hr hscale
hB hB hB hB hB hB hC0 (by norm_num : (0:ℝ)≤2) hX' hl hS' hSmall'
hDA hDu hDχ hDm hDell hDp hc (fun i=>(norm_add_le _ _).trans (by linarith [hm' i]))
have hf' : columnNorm (fun i=>s i • (w-w' i))≤F := by
apply hf.trans
apply mul_le_mul_of_nonneg_left _ (by positivity)
exact add_le_add (add_le_add (add_le_add (add_le_add
(mul_le_mul_of_nonneg_left hb hB) le_rfl)
(mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hw (by positivity)) hB)) le_rfl)
(mul_le_mul_of_nonneg_left (add_le_add (mul_le_mul_of_nonneg_left hw hB) le_rfl) (by positivity))
have hg : d*columnNorm (fun i=>s i*(c-c' i))≤G := by
exact (implicit_scalar_columns s r p ell w c p' c' ell' w' h.2.2 (fun i=>(h' i).2.2)
hr hd hscale hB hDell hDp hB hell').trans (add_le_add
(add_le_add (mul_le_mul_of_nonneg_left hw hB) le_rfl) (mul_le_mul_of_nonneg_left hf' hB))
have hh : columnNorm (fun i=>s i • (y-y' i))≤H := by
have hh:=implicit_field_columns s j χ r p (X*X) J u m t ell w y c χ' p' c'
(fun i=>X' i*X' i) u' m' ell' w' y' h h' hB (sq_nonneg B) hd hB hB hC0
(by norm_num : (0:ℝ)≤1) hJ hχ' hDχ hDm hc (by simpa only [one_mul] using hm') hg
apply hh.trans
simp only [mul_one]
exact add_le_add (add_le_add (add_le_add (mul_le_mul_of_nonneg_left hf' (by positivity))
(mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hw (abs_nonneg j)) hB)) le_rfl) le_rfl
change _≤W+C+Y+F+G+H
exact add_le_add (add_le_add (add_le_add (add_le_add (add_le_add hw hc) hy) hf') hg) hh
end SKGap.ImplicitSystem
end
end
section
noncomputable section
open scoped BigOperators Matrix.Norms.Frobenius
namespace SKGapCutoff.Recipe
open Primary SKGap.ImplicitSystem
variable {n : ℕ}
lemma halfDiff_column (U : VectorFields n) (x : Spin n) (k : Fin n) :
((spin x k/2) • ((WithLp.toLp 2 (U x) : Euclid n)-WithLp.toLp 2 (U (flip x k))))=
WithLp.toLp 2 (fun i=>derivativeMatrix U x i k) := by
ext i
change (spin x k/2)*(U x i-U (flip x k) i)=halfDiff k (fun y=>U y i) x
rw [halfDiff_as_flip]; ring
lemma columnNorm_halfDiff (U : VectorFields n) (x : Spin n) :
columnNorm (fun k=>(spin x k/2) •
((WithLp.toLp 2 (U x) : Euclid n)-WithLp.toLp 2 (U (flip x k))))=‖derivativeMatrix U x‖ := by
simp only [halfDiff_column]
exact columnNorm_matrix _
lemma columnNorm_scalar_halfDiff (f : Spin n→ℝ) (x : Spin n) :
columnNorm (fun k=>(spin x k/2)*(f x-f (flip x k)))=‖derivativeVector f x‖ := by
have he : (fun k=>(spin x k/2)*(f x-f (flip x k)))=fun k=>halfDiff k f x := by
ext k; rw [halfDiff_as_flip]; ring
rw [he]
rfl
lemma diagonal_halfDiff_columns (a : VectorFields n) (x : Spin n) {R : ℝ}
(hR : 0≤R) (ha : ∀i,∑k,(derivativeMatrix a x i k)^2≤R^2)
(V : Euclid n) :
columnNorm (fun k=>((spin x k/2) •
(Matrix.toEuclideanCLM (𝕜:=ℝ) (Matrix.diagonal (a x))-
Matrix.toEuclideanCLM (𝕜:=ℝ) (Matrix.diagonal (a (flip x k))))) V)≤R*‖V‖ := by
apply coefficient_diagonal_columns (fun _=>a x) (fun k=>a (flip x k)) (fun k=>spin x k/2) hR
intro i
convert ha i using 1
apply Finset.sum_congr rfl
intro k _
congr 1
rw [derivativeMatrix,halfDiff_as_flip]
ring
lemma implicit_tuple_small (w y : VectorFields n) (c : Spin n→ℝ) (x : Spin n)
{d C : ℝ} (hd : 0≤d) (hC : 0≤C)
(h : vectorNorm (w x)+d*|c x|+vectorNorm (y x)+‖derivativeMatrix w x‖+
d*‖derivativeVector c x‖+‖derivativeMatrix y x‖≤C) :
SmallBound w x C ∧ SmallBound y x C ∧
|d*c x|≤C ∧ ‖derivativeVector (fun z=>d*c z) x‖≤C := by
have hw0:=vectorNorm_nonneg (w x)
have hy0:=vectorNorm_nonneg (y x)
have hc0:=mul_nonneg hd (abs_nonneg (c x))
have hw1:=norm_nonneg (derivativeMatrix w x)
have hy1:=norm_nonneg (derivativeMatrix y x)
have hc1:=mul_nonneg hd (norm_nonneg (derivativeVector c x))
refine ⟨⟨hC,by linarith,by linarith⟩,⟨hC,by linarith,by linarith⟩,?_,?_⟩
· rw [abs_mul,abs_of_nonneg hd]; linarith
· have he : derivativeVector (fun z=>d*c z) x=d • derivativeVector c x := by
ext k
change halfDiff k (fun z=>d*c z) x=d*halfDiff k c x
simp [halfDiff]; ring
rw [he,norm_smul,Real.norm_eq_abs,abs_of_nonneg hd]
linarith
end SKGapCutoff.Recipe
end
end
end OAI
|