| import Mathlib |
| import OAI.Probability.SKGap.Matrix.OpNormDiagonal |
| import OAI.Probability.SKGap.Matrix.MatrixSeminorm |
| import OAI.Probability.SKGap.Gaussian.SquaredGaussianFourth |
| import OAI.Probability.SKGap.Localization.PreparationGrowth |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators Matrix.Norms.Frobenius |
| namespace SKGapCutoff.Primary |
| open SKGap Matrix |
| variable {n : ℕ} |
| local instance : Fact (1≤(4:ENNReal)) := ⟨by norm_num⟩ |
|
|
| def derivativeMatrix (F : VectorFields n) (x : Spin n) : Interaction n := |
| fun i k => halfDiff k (fun y => F y i) x |
|
|
| def ShapeBound (M : Interaction n) (C : ℝ) : Prop := |
| SKGap.opNorm M ≤ C ∧ SKGap.diagonalSeminorm M ≤ C ∧ SKGap.offDiagonalSeminorm M ≤ C |
|
|
| lemma opNorm_eq (M : Interaction n) : |
| SKGap.opNorm M = ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) M‖ := rfl |
|
|
| lemma opNorm_le_frobenius (M : Interaction n) : SKGap.opNorm M ≤ ‖M‖ := by |
| apply nonneg_le_nonneg_of_sq_le_sq (norm_nonneg M) |
| simp only [← sq] |
| rw [SKGap.frobenius_sq,opNorm_eq] |
| exact RandomMatrix.matrix_opNorm_sq_le_frobenius M |
|
|
| lemma opNorm_add (M N : Interaction n) : SKGap.opNorm (M+N) ≤ SKGap.opNorm M+SKGap.opNorm N := by |
| simp only [opNorm_eq,map_add] |
| exact norm_add_le _ _ |
|
|
| lemma opNorm_smul (c : ℝ) (M : Interaction n) : SKGap.opNorm (c • M) = |c| * SKGap.opNorm M := by |
| simp only [opNorm_eq,map_smul,norm_smul,Real.norm_eq_abs] |
|
|
| lemma ShapeBound.mono {M : Interaction n} {C D : ℝ} (h : ShapeBound M C) (hCD : C≤D) : |
| ShapeBound M D := ⟨h.1.trans hCD,h.2.1.trans hCD,h.2.2.trans hCD⟩ |
|
|
| lemma ShapeBound.add {M N : Interaction n} {C D : ℝ} |
| (hM : ShapeBound M C) (hN : ShapeBound N D) : ShapeBound (M+N) (C+D) := by |
| exact ⟨(opNorm_add M N).trans (add_le_add hM.1 hN.1), |
| (SKGap.diagonalSeminorm_add M N).trans (add_le_add hM.2.1 hN.2.1), |
| (SKGap.offDiagonalSeminorm_add M N).trans (add_le_add hM.2.2 hN.2.2)⟩ |
|
|
| lemma shapeBound_of_frobenius {M : Interaction n} {C : ℝ} (h : ‖M‖≤C) : ShapeBound M C := |
| ⟨(opNorm_le_frobenius M).trans h,(SKGap.diagonalSeminorm_le M).trans h, |
| (SKGap.offDiagonalSeminorm_le M).trans h⟩ |
|
|
| lemma ShapeBound.perturb {M H : Interaction n} {C E : ℝ} |
| (hH : ShapeBound H C) (hE : ‖M-H‖≤E) : ShapeBound M (C+E) := by |
| simpa only [add_sub_cancel] using hH.add (shapeBound_of_frobenius hE) |
|
|
| lemma fourth_sum (M : Interaction n) : |
| (∑ i,∑ k,(M i k)^4) = (∑ i,(M i i)^4)+SKGap.offDiagonalSeminorm M^4 := by |
| rw [SKGap.offDiagonalSeminorm_fourth,Fintype.sum_prod_type,← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hs : (M i i)^4 = ∑ k : Fin n, if i=k then (M i k)^4 else 0 := by simp |
| rw [hs,← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro k _ |
| by_cases h : i=k <;> simp [h] |
|
|
| lemma fourth_sum_le {M : Interaction n} {C : ℝ} (hC : 0≤C) (hM : ShapeBound M C) : |
| (∑ i,∑ k,(M i k)^4) ≤ 2*C^4 := by |
| rw [fourth_sum] |
| have hd : (∑ i,(M i i)^4) ≤ SKGap.diagonalSeminorm M^4 := by |
| rw [show (4:ℕ)=2*2 by rfl,pow_mul,SKGap.diagonalSeminorm_sq] |
| simpa only [pow_mul] using |
| (Finset.sum_sq_le_sq_sum_of_nonneg (s:=Finset.univ) (f:=fun i => (M i i)^2) |
| (fun i _ => sq_nonneg _)) |
| have hdC := (pow_le_pow_iff_left₀ (norm_nonneg (SKGap.diagonalVector M)) hC |
| (by decide : 4 ≠ 0)).2 hM.2.1 |
| have hoC := pow_le_pow_left₀ (norm_nonneg (SKGap.offDiagonalVector M)) hM.2.2 4 |
| dsimp only [SKGap.diagonalSeminorm,SKGap.offDiagonalSeminorm] at hd ⊢ |
| nlinarith |
|
|
| lemma quadratic_entry_error {D R : Interaction n} {C A : ℝ} (hC : 0≤C) (hA : 0≤A) |
| (hD : ShapeBound D C) (he : ∀ i k, |R i k|≤A*(D i k)^2) : |
| ‖R‖ ≤ 2*A*C^2 := by |
| have hs : ‖R‖^2 ≤ A^2*(2*C^4) := by |
| rw [SKGap.frobenius_sq] |
| calc |
| _ ≤ ∑ i,∑ k,A^2*(D i k)^4 := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply Finset.sum_le_sum |
| intro k _ |
| have h := pow_le_pow_left₀ (abs_nonneg (R i k)) (he i k) 2 |
| nlinarith only [h,sq_abs (R i k)] |
| _ = A^2*(∑ i,∑ k,(D i k)^4) := by simp_rw [← Finset.mul_sum] |
| _ ≤ A^2*(2*C^4) := mul_le_mul_of_nonneg_left (fourth_sum_le hC hD) (sq_nonneg _) |
| have hp : 0≤2*A*C^2 := by positivity |
| nlinarith [sq_nonneg (A*C^2)] |
|
|
| lemma diagonal_mul_shape {M : Interaction n} {C : ℝ} {a : Fin n→ℝ} |
| (ha : ∀ i,|a i|≤1) (hM : ShapeBound M C) : |
| ShapeBound (Matrix.diagonal a*M) C := by |
| have haN : SKGap.opNorm (Matrix.diagonal a)≤1 := SKGap.opNorm_diagonal_le (by norm_num) ha |
| refine ⟨(SKGap.opNorm_mul _ _).trans ?_,?_,?_⟩ |
| · calc |
| _ ≤ 1*SKGap.opNorm M := mul_le_mul_of_nonneg_right haN (norm_nonneg _) |
| _ = SKGap.opNorm M := one_mul _ |
| _ ≤ C := hM.1 |
| · apply le_trans ?_ hM.2.1 |
| apply le_of_pow_le_pow_left₀ (by decide : 2≠0) (norm_nonneg _) |
| change SKGap.diagonalSeminorm _ ^2 ≤ SKGap.diagonalSeminorm M ^2 |
| simp only [SKGap.diagonalSeminorm_sq,Matrix.diagonal_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| have hi := pow_le_pow_left₀ (abs_nonneg (a i)) (ha i) 2 |
| simp only [sq_abs,one_pow] at hi |
| simpa only [mul_pow,one_mul] using mul_le_mul_of_nonneg_right hi (sq_nonneg (M i i)) |
| · apply le_trans ?_ hM.2.2 |
| apply le_of_pow_le_pow_left₀ (by decide : 4≠0) (norm_nonneg _) |
| change SKGap.offDiagonalSeminorm _ ^4 ≤ SKGap.offDiagonalSeminorm M ^4 |
| simp only [SKGap.offDiagonalSeminorm_fourth] |
| apply Finset.sum_le_sum |
| intro p _ |
| split_ifs |
| · exact le_rfl |
| · simp only [Matrix.diagonal_mul,mul_pow] |
| have hi := pow_le_pow_left₀ (abs_nonneg (a p.1)) (ha p.1) 4 |
| rw [← abs_pow,abs_of_nonneg (by positivity : 0≤a p.1^4)] at hi |
| simpa only [one_pow,one_mul] using mul_le_mul_of_nonneg_right hi |
| (by positivity : 0≤(M p.1 p.2)^4) |
|
|
| lemma tanh_derivative_error {F : VectorFields n} {x : Spin n} {C : ℝ} |
| (hC : 0≤C) (hD : ShapeBound (derivativeMatrix F x) C) : |
| ‖derivativeMatrix (fun y i => Real.tanh (F y i)) x- |
| Matrix.diagonal (fun i => scalarVariance (F x i))*derivativeMatrix F x‖ ≤ 8*C^2 := by |
| convert quadratic_entry_error hC (by norm_num : (0:ℝ)≤4) hD ?_ using 1 <;> try norm_num |
| intro i k |
| simpa only [derivativeMatrix,Matrix.sub_apply,Matrix.diagonal_mul,mul_comm, |
| refreshInfluence] using refreshInfluence_error_le F x k i |
|
|
| lemma tanh_derivative_shape {F : VectorFields n} {x : Spin n} {C : ℝ} |
| (hC : 0≤C) (hD : ShapeBound (derivativeMatrix F x) C) : |
| ShapeBound (derivativeMatrix (fun y i => Real.tanh (F y i)) x) (C+8*C^2) := by |
| apply ShapeBound.perturb _ (tanh_derivative_error hC hD) |
| apply diagonal_mul_shape ?_ hD |
| intro i |
| rw [abs_of_pos (scalarVariance_pos _)] |
| exact scalarVariance_le_one _ |
|
|
| def derivativeVector (f : Spin n→ℝ) (x : Spin n) : EuclideanSpace ℝ (Fin n) := |
| WithLp.toLp 2 (fun k => halfDiff k f x) |
|
|
| def siteMean (F : VectorFields n) (x : Spin n) : ℝ := (∑ i,F x i)/(n:ℝ) |
|
|
| lemma siteMean_derivative (F : VectorFields n) (x : Spin n) : |
| derivativeVector (siteMean F) x = (n:ℝ)⁻¹ • |
| (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) ((derivativeMatrix F x)ᵀ)) |
| (WithLp.toLp 2 (fun _ => 1)) := by |
| ext k |
| change halfDiff k (siteMean F) x = (n:ℝ)⁻¹*(∑ i,halfDiff k (fun y => F y i) x*1) |
| simp only [mul_one,halfDiff,siteMean] |
| rw [← Finset.sum_div,Finset.sum_sub_distrib] |
| ring |
|
|
| lemma euclidean_ones_norm_sq : |
| ‖(WithLp.toLp 2 (fun _ : Fin n => (1:ℝ)) : EuclideanSpace ℝ (Fin n))‖^2 = n := by |
| simp [EuclideanSpace.real_norm_sq_eq] |
|
|
| lemma siteMean_derivative_square (F : VectorFields n) (x : Spin n) (hn : 0<n) : |
| (n:ℝ)*‖derivativeVector (siteMean F) x‖^2 ≤ SKGap.opNorm (derivativeMatrix F x)^2 := by |
| have hnR : (0:ℝ)<n := Nat.cast_pos.mpr hn |
| have h := (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) ((derivativeMatrix F x)ᵀ)).le_opNorm |
| (WithLp.toLp 2 (fun _ : Fin n => (1:ℝ))) |
| change ‖(Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) ((derivativeMatrix F x)ᵀ)) |
| (WithLp.toLp 2 (fun _ : Fin n => (1:ℝ)))‖ ≤ |
| SKGap.opNorm ((derivativeMatrix F x)ᵀ) * ‖(WithLp.toLp 2 (fun _ : Fin n => (1:ℝ)) : EuclideanSpace ℝ (Fin n))‖ at h |
| rw [SKGap.opNorm_transpose] at h |
| have hs := pow_le_pow_left₀ (norm_nonneg _) h 2 |
| rw [mul_pow,euclidean_ones_norm_sq] at hs |
| rw [siteMean_derivative,norm_smul,Real.norm_eq_abs,abs_inv,abs_of_pos hnR,mul_pow] |
| field_simp |
| nlinarith |
|
|
| lemma siteMean_derivative_square_bound {F : VectorFields n} {x : Spin n} {B : ℝ} |
| (hn : 0<n) (hB : SKGap.opNorm (derivativeMatrix F x)≤B) : |
| (n:ℝ)*‖derivativeVector (siteMean F) x‖^2 ≤ B^2 := |
| (siteMean_derivative_square F x hn).trans |
| (pow_le_pow_left₀ (norm_nonneg _) hB 2) |
|
|
| lemma derivative_norm_of_mean_square {f : Spin n→ℝ} {x : Spin n} {B : ℝ} |
| (hn : 0<n) (hB : 0≤B) (h : (n:ℝ)*‖derivativeVector f x‖^2≤B^2) : |
| ‖derivativeVector f x‖≤B := by |
| have hn1 : (1:ℝ)≤n := by exact_mod_cast hn |
| nlinarith [sq_nonneg ‖derivativeVector f x‖,norm_nonneg (derivativeVector f x)] |
|
|
| lemma outer_frobenius_bound {v : Fin n→ℝ} {f : Spin n→ℝ} {x : Spin n} {B : ℝ} |
| (hv : ∀ i,|v i|≤1) (hB : 0≤B) |
| (h : (n:ℝ)*‖derivativeVector f x‖^2≤B^2) : |
| ‖Matrix.of (fun i k => v i*halfDiff k f x)‖≤B := by |
| apply nonneg_le_nonneg_of_sq_le_sq hB |
| simp only [← sq] |
| rw [SKGap.frobenius_sq] |
| calc |
| _ ≤ ∑ _i : Fin n,∑ k,(halfDiff k f x)^2 := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply Finset.sum_le_sum |
| intro k _ |
| have hi := pow_le_pow_left₀ (abs_nonneg (v i)) (hv i) 2 |
| simp only [sq_abs,one_pow] at hi |
| change (v i*halfDiff k f x)^2 ≤ _ |
| rw [mul_pow] |
| nlinarith [sq_nonneg (halfDiff k f x)] |
| _ = (n:ℝ)*‖derivativeVector f x‖^2 := by |
| simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul, |
| EuclideanSpace.real_norm_sq_eq,derivativeVector] |
| _ ≤ B^2 := h |
|
|
| lemma spin_diagonal_frobenius (f : Spin n→ℝ) (x : Spin n) : |
| ‖Matrix.diagonal (fun k => spin x k*halfDiff k f x)‖ = ‖derivativeVector f x‖ := by |
| apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp |
| rw [SKGap.frobenius_sq,EuclideanSpace.real_norm_sq_eq] |
| simp [Matrix.diagonal_apply,derivativeVector,mul_pow,spin_sq] |
|
|
| lemma derivativeMatrix_product (f : Spin n→ℝ) (F : VectorFields n) (x : Spin n) : |
| derivativeMatrix (fun y i => f y*F y i) x = f x • derivativeMatrix F x + |
| Matrix.of (fun i k => F x i*halfDiff k f x) - |
| (2:ℝ) • (derivativeMatrix F x*Matrix.diagonal (fun k => spin x k*halfDiff k f x)) := by |
| ext i k |
| simp only [derivativeMatrix,Matrix.sub_apply,Matrix.add_apply,Matrix.smul_apply, |
| smul_eq_mul,Matrix.mul_diagonal,halfDiff_mul,Matrix.of_apply] |
| ring |
|
|
| lemma product_derivative_error {f : Spin n→ℝ} {F : VectorFields n} {x : Spin n} {B C : ℝ} |
| (hn : 0<n) (hB : 0≤B) (hC : SKGap.opNorm (derivativeMatrix F x)≤C) |
| (hF : ∀ i,|F x i|≤1) (hf : (n:ℝ)*‖derivativeVector f x‖^2≤B^2) : |
| ‖derivativeMatrix (fun y i => f y*F y i) x-f x • derivativeMatrix F x‖ ≤ B+2*C*B := by |
| have hdb := derivative_norm_of_mean_square hn hB hf |
| have hC0 : 0≤C := (norm_nonneg _).trans hC |
| rw [derivativeMatrix_product] |
| have he (A R T : Interaction n) : A+R-T-A=R-T := by abel |
| rw [he] |
| calc |
| _ ≤ ‖Matrix.of (fun i k => F x i*halfDiff k f x)‖+ |
| ‖(2:ℝ) • (derivativeMatrix F x*Matrix.diagonal (fun k => spin x k*halfDiff k f x))‖ := norm_sub_le _ _ |
| _ ≤ B+2*C*B := by |
| apply add_le_add (outer_frobenius_bound hF hB hf) |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos (by norm_num : (0:ℝ)<2)] |
| calc |
| _ ≤ 2*(SKGap.opNorm (derivativeMatrix F x)*‖Matrix.diagonal (fun k => spin x k*halfDiff k f x)‖) := |
| mul_le_mul_of_nonneg_left (SKGap.frobenius_mul_le_opNorm _ _) (by norm_num) |
| _ ≤ 2*(C*B) := by |
| rw [spin_diagonal_frobenius] |
| exact mul_le_mul_of_nonneg_left (mul_le_mul hC hdb (norm_nonneg _) hC0) (by norm_num) |
| _ = _ := by ring |
|
|
| lemma derivativeMatrix_linear (J : Interaction n) (F : VectorFields n) (h : Fin n→ℝ) |
| (x : Spin n) : |
| derivativeMatrix (fun y i => h i+∑ k,J i k*F y k) x = J*derivativeMatrix F x := by |
| ext i l |
| simp only [derivativeMatrix,Matrix.mul_apply,halfDiff] |
| simp_rw [← mul_div_assoc,mul_sub] |
| rw [← Finset.sum_div,Finset.sum_sub_distrib] |
| ring |
|
|
| lemma derivativeMatrix_sub (F G : VectorFields n) (x : Spin n) : |
| derivativeMatrix (fun y i => F y i-G y i) x=derivativeMatrix F x-derivativeMatrix G x := by |
| ext i k |
| exact halfDiff_sub k (fun y => F y i) (fun y => G y i) x |
|
|
| lemma derivativeMatrix_smul (c : ℝ) (F : VectorFields n) (x : Spin n) : |
| derivativeMatrix (fun y i => c*F y i) x=c • derivativeMatrix F x := by |
| ext i k |
| simp only [derivativeMatrix,halfDiff,Matrix.smul_apply,smul_eq_mul] |
| ring |
|
|
| lemma derivativeMatrix_spin (x : Spin n) : derivativeMatrix spin x=1 := by |
| ext i k |
| simp [derivativeMatrix,Matrix.one_apply,eq_comm] |
|
|
| lemma variance_derivative_error {F : VectorFields n} {x : Spin n} {C : ℝ} |
| (hC : 0≤C) (hD : ShapeBound (derivativeMatrix F x) C) : |
| ‖derivativeMatrix (fun y i => 1-(F y i)^2) x- |
| (-2:ℝ) • (Matrix.diagonal (F x)*derivativeMatrix F x)‖ ≤ 4*C^2 := by |
| convert quadratic_entry_error hC (by norm_num : (0:ℝ)≤2) hD ?_ using 1 <;> try norm_num |
| intro i k |
| have hs : halfDiff k (fun y => 1-(F y i)^2) x = |
| -2*F x i*halfDiff k (fun y => F y i) x+ |
| 2*spin x k*(halfDiff k (fun y => F y i) x)^2 := by |
| have hh := halfDiff_mul k (fun y => F y i) (fun y => F y i) x |
| rw [halfDiff_sub,halfDiff_const] |
| simpa only [pow_two,zero_sub] using (show -(halfDiff k (fun y => F y i*F y i) x) = |
| -2*F x i*halfDiff k (fun y => F y i) x+ |
| 2*spin x k*(halfDiff k (fun y => F y i) x)^2 by rw [hh]; ring) |
| simp only [derivativeMatrix,hs] |
| have he (a b c : ℝ) : -2*a*b+2*c*b^2+2*(a*b)=2*c*b^2 := by ring |
| rw [he,abs_mul,abs_mul,abs_spin_eq_one,mul_one] |
| norm_num [abs_of_nonneg (sq_nonneg (halfDiff k (fun y => F y i) x))] |
|
|
| lemma variance_derivative_opNorm {F : VectorFields n} {x : Spin n} {C : ℝ} |
| (hC : 0≤C) (hF : ∀ i,|F x i|≤1) (hD : ShapeBound (derivativeMatrix F x) C) : |
| SKGap.opNorm (derivativeMatrix (fun y i => 1-(F y i)^2) x) ≤ 2*C+4*C^2 := by |
| let A := (-2:ℝ) • (Matrix.diagonal (F x)*derivativeMatrix F x) |
| have hA : SKGap.opNorm A≤2*C := by |
| dsimp only [A] |
| rw [opNorm_smul] |
| norm_num only [abs_neg,abs_of_nonneg (by norm_num : (0:ℝ)≤2)] |
| exact mul_le_mul_of_nonneg_left (diagonal_mul_shape hF hD).1 (by norm_num) |
| have hE := (opNorm_le_frobenius |
| (derivativeMatrix (fun y i => 1-(F y i)^2) x-A)).trans (variance_derivative_error hC hD) |
| have he : derivativeMatrix (fun y i => 1-(F y i)^2) x = |
| A+(derivativeMatrix (fun y i => 1-(F y i)^2) x-A) := by abel |
| rw [he] |
| exact (opNorm_add _ _).trans (add_le_add hA hE) |
|
|
| lemma tanh_derivative_formal_error {F : VectorFields n} {x : Spin n} |
| {H : Interaction n} {C E : ℝ} (hC : 0≤C) (hD : ShapeBound (derivativeMatrix F x) C) |
| (hE : ‖derivativeMatrix F x-H‖≤E) : |
| ‖derivativeMatrix (fun y i => Real.tanh (F y i)) x- |
| Matrix.diagonal (fun i => scalarVariance (F x i))*H‖ ≤ 8*C^2+E := by |
| let V := Matrix.diagonal (fun i => scalarVariance (F x i)) |
| have hV : SKGap.opNorm V≤1 := by |
| apply SKGap.opNorm_diagonal_le (by norm_num) |
| intro i |
| rw [abs_of_pos (scalarVariance_pos _)] |
| exact scalarVariance_le_one _ |
| have he : derivativeMatrix (fun y i => Real.tanh (F y i)) x-V*H = |
| (derivativeMatrix (fun y i => Real.tanh (F y i)) x-V*derivativeMatrix F x)+ |
| V*(derivativeMatrix F x-H) := by noncomm_ring |
| change ‖derivativeMatrix (fun y i => Real.tanh (F y i)) x-V*H‖≤_ |
| rw [he] |
| apply (norm_add_le _ _).trans |
| apply add_le_add (tanh_derivative_error hC hD) |
| exact (SKGap.frobenius_mul_le_opNorm _ _).trans |
| ((mul_le_mul_of_nonneg_right hV (norm_nonneg _)).trans (by simpa using hE)) |
|
|
| end SKGapCutoff.Primary |
| end |
| end |
|
|
| end OAI |
|
|
