| import Mathlib |
| import OAI.Probability.SKGap.Terminal.TerminalMatrixTransfer |
| import OAI.Probability.SKGap.Terminal.SpinLocalField |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace SKGap |
| open Matrix Real |
| open scoped BigOperators Matrix.Norms.L2Operator |
| variable {n : ℕ} |
|
|
| lemma cardinal_small_sum {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (h z : ι→ℝ) {t a b : ℝ} (ht : 0 < t) |
| (hh : ((Finset.univ.filter (fun i=>|h i| < 2*t)).card:ℝ) ≤ a) |
| (hz : (∑ i,z i^2) ≤ t^2*b) : |
| ((Finset.univ.filter (fun i=>|h i+z i| < t)).card:ℝ) ≤ a+b := by |
| let S := Finset.univ.filter (fun i=>|h i+z i| < t) |
| let B := Finset.univ.filter (fun i=>|h i| < 2*t) |
| let L := Finset.univ.filter (fun i=>t < |z i|) |
| have hsub : S ⊆ B ∪ L := by |
| intro i hi |
| have hfield : |h i+z i| < t := (Finset.mem_filter.mp hi).2 |
| by_cases hb : |h i| < 2*t |
| · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb⟩) |
| · apply Finset.mem_union_right |
| apply Finset.mem_filter.mpr |
| refine ⟨Finset.mem_univ _,?_⟩ |
| have he : h i=(h i+z i)+(-z i) := by ring |
| have habs := abs_add_le (h i+z i) (-z i) |
| rw [← he,abs_neg] at habs |
| linarith only [hfield,le_of_not_gt hb,habs] |
| have hL : t^2*(L.card:ℝ) ≤ ∑ i,z i^2 := by |
| calc |
| _ = ∑ _i ∈ L,t^2 := by simp [mul_comm] |
| _ ≤ ∑ i ∈ L,z i^2 := by |
| apply Finset.sum_le_sum |
| intro i hi |
| have hh := ((Finset.mem_filter.mp hi).2 : t < |z i|) |
| have hs := (sq_le_sq₀ ht.le (abs_nonneg (z i))).mpr hh.le |
| simpa only [sq_abs] using hs |
| _ ≤ ∑ i,z i^2 := Finset.sum_le_univ_sum_of_nonneg (fun i=>sq_nonneg (z i)) |
| have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le B L) |
| have hcard' : (S.card:ℝ) ≤ (B.card:ℝ)+(L.card:ℝ) := by exact_mod_cast hcard |
| have hLb : (L.card:ℝ) ≤ b := by |
| exact (mul_le_mul_iff_right₀ (sq_pos_of_pos ht)).mp (hL.trans hz) |
| exact hcard'.trans (add_le_add hh hLb) |
|
|
| lemma coupling_spin_norm_square (g : Disorder n) {M : ℝ} (hM : 0 ≤ M) |
| (hJ : ‖Matrix.of (coupling g)‖ ≤ M) (x : Spin n) : |
| (∑ i,(∑ j,coupling g i j*spinValue (x j))^2) ≤ M^2*(n:ℝ) := by |
| let v : EuclideanSpace ℝ (Fin n) := WithLp.toLp 2 (fun i=>spinValue (x i)) |
| let w := Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) (Matrix.of (coupling g)) v |
| have hv : ‖v‖^2=(n:ℝ) := by |
| rw [EuclideanSpace.real_norm_sq_eq] |
| change (∑ i,spinValue (x i)^2)=(n:ℝ) |
| simp |
| have hw : ‖w‖ ≤ M*‖v‖ := (ContinuousLinearMap.le_opNorm _ _).trans |
| (mul_le_mul_of_nonneg_right (by simpa only [Matrix.l2_opNorm_toEuclideanCLM] using hJ) (norm_nonneg v)) |
| have hw2 := (sq_le_sq₀ (norm_nonneg w) (mul_nonneg hM (norm_nonneg v))).mpr hw |
| rw [mul_pow,hv,EuclideanSpace.real_norm_sq_eq] at hw2 |
| exact hw2 |
|
|
| lemma all_configurations_small_fields (g : Disorder n) (h : Fin n→ℝ) {M t α : ℝ} |
| (hM : 0 ≤ M) (ht : 0 < t) (hJ : ‖Matrix.of (coupling g)‖ ≤ M) |
| (hB : ((Finset.univ.filter (fun i=>|h i| < 2*t)).card:ℝ) ≤ α*(n:ℝ)/2) |
| (hsmall : M^2 ≤ t^2*α/2) : |
| ∀ x : Spin n,((Finset.univ.filter (fun i=>|localField g h i x| < t)).card:ℝ) ≤ α*(n:ℝ) := by |
| intro x |
| have hnorm := coupling_spin_norm_square g hM hJ x |
| have hnorm' : (∑ i,(∑ j,coupling g i j*spinValue (x j))^2) ≤ t^2*(α*(n:ℝ)/2) := by |
| apply hnorm.trans |
| have hh := mul_le_mul_of_nonneg_right hsmall (Nat.cast_nonneg n) |
| nlinarith only [hh] |
| have hc := cardinal_small_sum h (fun i=>∑ j,coupling g i j*spinValue (x j)) ht hB hnorm' |
| have he : α*(n:ℝ)/2+α*(n:ℝ)/2=α*(n:ℝ) := by ring |
| rw [he] at hc |
| exact hc |
| end SKGap |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace SKGap |
| open scoped RealInnerProductSpace |
|
|
| lemma positive_form_cauchy {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| (H : E →ₗ[ℝ] E) (hH : H.IsSymmetric) (hpos : ∀ v,0 ≤ ⟪v,H v⟫) (u v : E) : |
| ⟪u,H v⟫^2 ≤ ⟪u,H u⟫*⟪v,H v⟫ := by |
| have hh : ∀ t : ℝ,0 ≤ ⟪v,H v⟫*(t*t)+(2*⟪u,H v⟫)*t+⟪u,H u⟫ := by |
| intro t |
| have hp := hpos (u+t • v) |
| simp only [map_add,map_smul,inner_add_left,inner_add_right,real_inner_smul_left, |
| real_inner_smul_right] at hp |
| have he : ⟪v,H u⟫=⟪u,H v⟫ := (real_inner_comm (H u) v).trans (hH u v) |
| rw [he] at hp |
| nlinarith only [hp] |
| have hd := discrim_le_zero hh |
| unfold discrim at hd |
| nlinarith only [hd] |
|
|
| lemma curvature_poincare_on_kernel_orthogonal {E : Type*} |
| [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] |
| (H : E →ₗ[ℝ] E) (hH : H.IsSymmetric) (hpos : ∀ v,0 ≤ ⟪v,H v⟫) |
| {ρ : ℝ} (hρ : 0 < ρ) (hcurv : ∀ v,ρ*⟪v,H v⟫ ≤ ⟪H v,H v⟫) |
| (f : E) (hf : f ∈ (LinearMap.ker H)ᗮ) : |
| ρ*⟪f,f⟫ ≤ ⟪f,H f⟫ := by |
| have hrange : f ∈ LinearMap.range H := by |
| rwa [← hH.orthogonal_range,Submodule.orthogonal_orthogonal] at hf |
| obtain ⟨g,rfl⟩ := hrange |
| have hc := positive_form_cauchy H hH hpos (H g) g |
| have hg := hcurv g |
| have hp := hpos (H g) |
| have hn : 0 ≤ ⟪H g,H g⟫ := real_inner_self_nonneg |
| have hh : ρ*⟪H g,H g⟫^2 ≤ ⟪H g,H (H g)⟫*⟪H g,H g⟫ := by |
| calc |
| _ ≤ ρ*(⟪H g,H (H g)⟫*⟪g,H g⟫) := mul_le_mul_of_nonneg_left hc hρ.le |
| _ = ⟪H g,H (H g)⟫*(ρ*⟪g,H g⟫) := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left hg hp |
| by_cases hz : ⟪H g,H g⟫=0 |
| · rw [hz,mul_zero];exact hp |
| · have hpos' : 0 < ⟪H g,H g⟫ := lt_of_le_of_ne hn (Ne.symm hz) |
| nlinarith only [hh,hpos'] |
| end SKGap |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace SKGap |
| open Real |
| open scoped BigOperators RealInnerProductSpace |
| variable {n : ℕ} |
|
|
| lemma conditionalExpectation_add (g : Disorder n) (h : Fin n→ℝ) (i : Fin n) |
| (f k : Spin n→ℝ) (x : Spin n) : |
| conditionalExpectation g h i (f+k) x=conditionalExpectation g h i f x+conditionalExpectation g h i k x := by |
| unfold conditionalExpectation |
| simp only [Pi.add_apply] |
| ring |
| lemma conditionalExpectation_smul (g : Disorder n) (h : Fin n→ℝ) (i : Fin n) |
| (c : ℝ) (f : Spin n→ℝ) (x : Spin n) : |
| conditionalExpectation g h i (c • f) x=c*conditionalExpectation g h i f x := by |
| unfold conditionalExpectation |
| simp only [Pi.smul_apply,smul_eq_mul] |
| ring |
|
|
| def heatBathLinear (g : Disorder n) (h : Fin n→ℝ) : (Spin n→ℝ) →ₗ[ℝ] (Spin n→ℝ) where |
| toFun := heatBathGenerator g h |
| map_add' f k := by |
| funext x |
| simp only [heatBathGenerator,conditionalExpectation_add,Pi.add_apply] |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro i _;ring |
| map_smul' c f := by |
| funext x |
| simp only [heatBathGenerator,conditionalExpectation_smul,Pi.smul_apply,smul_eq_mul, |
| RingHom.id_apply] |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro i _;ring |
|
|
| def gibbsScale (g : Disorder n) (h : Fin n→ℝ) : (Spin n→ℝ) ≃ₗ[ℝ] EuclideanSpace ℝ (Spin n) where |
| toFun f := WithLp.toLp 2 (fun x=>sqrt (mass g h x)*f x) |
| invFun v := fun x=>v x/sqrt (mass g h x) |
| left_inv f := by |
| funext x |
| change sqrt (mass g h x)*f x/sqrt (mass g h x)=f x |
| exact mul_div_cancel_left₀ (f x) (sqrt_pos.mpr (mass_pos g h x)).ne' |
| right_inv v := by |
| ext x |
| exact mul_div_cancel₀ (v x) (sqrt_pos.mpr (mass_pos g h x)).ne' |
| map_add' f k := by ext x;simp [mul_add] |
| map_smul' c f := by ext x;simp [mul_left_comm] |
|
|
| lemma gibbsScale_inner (g : Disorder n) (h : Fin n→ℝ) (f k : Spin n→ℝ) : |
| ⟪gibbsScale g h f,gibbsScale g h k⟫=expectation g h (fun x=>f x*k x) := by |
| simp only [EuclideanSpace.inner_eq_star_dotProduct,star_trivial] |
| unfold dotProduct expectation |
| apply Finset.sum_congr rfl |
| intro x _ |
| change sqrt (mass g h x)*k x*(sqrt (mass g h x)*f x)=mass g h x*(f x*k x) |
| calc |
| _ = sqrt (mass g h x)^2*(f x*k x) := by ring |
| _ = _ := by rw [sq_sqrt (mass_nonneg g h x)] |
|
|
| lemma heatBathLinear_const (g : Disorder n) (h : Fin n→ℝ) (c : ℝ) : |
| heatBathLinear g h (fun _=>c)=0 := by |
| funext x |
| simp only [heatBathLinear,heatBathGenerator,LinearMap.coe_mk,AddHom.coe_mk, |
| conditionalExpectation_const,sub_self,Finset.sum_const_zero,Pi.zero_apply] |
|
|
| lemma heatBathLinear_kernel (g : Disorder n) (h : Fin n→ℝ) (f : Spin n→ℝ) : |
| heatBathLinear g h f=0 ↔ ∀ x y,f x=f y := by |
| constructor |
| · intro hf |
| apply (dirichlet_eq_zero_iff g h f).mp |
| rw [← heatBathGenerator_form] |
| change expectation g h (fun x=>f x*(heatBathLinear g h f) x)=0 |
| rw [hf] |
| simp only [Pi.zero_apply,mul_zero,expectation_const] |
| · intro hf |
| have he : f=(fun _=>f (fun _=>false)) := funext (fun x=>hf x (fun _=>false)) |
| rw [he,heatBathLinear_const] |
|
|
| lemma heatBath_curvature_poincare (g : Disorder n) (h : Fin n→ℝ) |
| {ρ : ℝ} (hρ : 0 < ρ) |
| (hc : ∀ f : Spin n→ℝ,ρ*dirichlet g h f ≤ |
| expectation g h (fun x=>heatBathGenerator g h f x^2)) (f : Spin n→ℝ) : |
| ρ*variance g h f ≤ dirichlet g h f := by |
| let S := gibbsScale g h |
| let H : EuclideanSpace ℝ (Spin n) →ₗ[ℝ] EuclideanSpace ℝ (Spin n) := |
| S.toLinearMap ∘ₗ heatBathLinear g h ∘ₗ S.symm.toLinearMap |
| have hHS (k : Spin n→ℝ) : H (S k)=S (heatBathLinear g h k) := by simp [H] |
| have hH : H.IsSymmetric := by |
| intro u v |
| obtain ⟨u,rfl⟩ := S.surjective u |
| obtain ⟨v,rfl⟩ := S.surjective v |
| rw [hHS,hHS] |
| exact (gibbsScale_inner g h _ _).trans ((heatBathGenerator_adjoint g h u v).trans |
| (gibbsScale_inner g h _ _).symm) |
| have hform (k : Spin n→ℝ) : ⟪S k,H (S k)⟫=dirichlet g h k := by |
| rw [hHS,gibbsScale_inner] |
| exact heatBathGenerator_form g h k |
| have hpos : ∀ v,0 ≤ ⟪v,H v⟫ := by |
| intro v |
| obtain ⟨k,rfl⟩ := S.surjective v |
| rw [hform] |
| exact dirichlet_nonneg g h k |
| have hcurv : ∀ v,ρ*⟪v,H v⟫ ≤ ⟪H v,H v⟫ := by |
| intro v |
| obtain ⟨k,rfl⟩ := S.surjective v |
| rw [hform,hHS,gibbsScale_inner] |
| simpa only [sq,heatBathLinear,LinearMap.coe_mk,AddHom.coe_mk] using hc k |
| let f₀ := f-(fun _=>expectation g h f) |
| have hm : expectation g h f₀=0 := by |
| change expectation g h (fun x=>f x-expectation g h f)=0 |
| rw [expectation_sub,expectation_const,sub_self] |
| have hker : S f₀ ∈ (LinearMap.ker H)ᗮ := by |
| rw [Submodule.mem_orthogonal] |
| intro v hv |
| obtain ⟨k,rfl⟩ := S.surjective v |
| have hk : heatBathLinear g h k=0 := by |
| have hh := LinearMap.mem_ker.mp hv |
| rw [hHS] at hh |
| exact S.injective (by simpa using hh) |
| have hk' := (heatBathLinear_kernel g h k).mp hk |
| have he : k=(fun _=>k (fun _=>false)) := funext (fun x=>hk' x (fun _=>false)) |
| rw [gibbsScale_inner,he,expectation_const_mul,hm,mul_zero] |
| have hh := curvature_poincare_on_kernel_orthogonal H hH hpos hρ hcurv (S f₀) hker |
| rw [gibbsScale_inner,hform] at hh |
| have hd : dirichlet g h f₀=dirichlet g h f := by |
| rw [← heatBathGenerator_form,← heatBathGenerator_form] |
| have he : heatBathLinear g h f₀=heatBathLinear g h f := by |
| simp only [f₀,map_sub,heatBathLinear_const,sub_zero] |
| change expectation g h (fun x=>f₀ x*(heatBathLinear g h f₀) x)=_ |
| rw [he] |
| have hz : expectation g h (heatBathLinear g h f)=0 := by |
| change expectation g h (fun x=>∑ i,(f x-conditionalExpectation g h i f x))=0 |
| rw [expectation_sum] |
| apply Finset.sum_eq_zero |
| intro i _ |
| rw [expectation_sub,expectation_conditionalExpectation,sub_self] |
| simp only [f₀,Pi.sub_apply,sub_mul] |
| rw [expectation_sub,expectation_const_mul,hz,mul_zero,sub_zero] |
| rfl |
| rw [hd] at hh |
| simpa only [variance,f₀,Pi.sub_apply,sq] using hh |
| end SKGap |
|
|
| end |
| end |
|
|
| end OAI |
|
|
