| import Mathlib |
| import OAI.Probability.SKGap.Entropy.ProdFst |
| import OAI.Probability.SKGap.Entropy.BoundGood |
| import OAI.Probability.SKGap.Terminal.GibbsEventProbabilityReal |
|
|
| 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 |
| open scoped BigOperators Topology |
| open MeasureTheory |
| open scoped BigOperators Topology Interval RealInnerProductSpace |
| open MeasureTheory Filter |
| open scoped BigOperators Topology Interval |
| open MeasureTheory Filter |
| open scoped Topology |
| open MeasureTheory Filter |
| open scoped Topology |
| open MeasureTheory Filter |
| open scoped Topology |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators NNReal ENNReal Matrix.Norms.L2Operator |
| open MeasureTheory ProbabilityTheory Filter Matrix |
| open scoped BigOperators ENNReal NNReal Topology Matrix.Norms.L2Operator |
| namespace SKGapCutoff.Regression |
|
|
| noncomputable def plantedFieldArray (β : ℝ) (n : ℕ) (g : Option (Fin n) → ℝ) : Fin n → ℝ := |
| sharedGaussianField (β^2*((n:ℝ)-1)/(n:ℝ)) |
| (β*Real.sqrt (((n:ℝ)-2)/(n:ℝ))) (β/Real.sqrt (n:ℝ)) g |
|
|
| lemma plantedFieldArray_measurable (β : ℝ) (n : ℕ) : Measurable (plantedFieldArray β n) := by |
| unfold plantedFieldArray sharedGaussianField |
| fun_prop |
|
|
| lemma planted_field_event_eq (β : ℝ) {n : ℕ} (hn : 2≤n) (x : Spin n) |
| (E : Set (Fin n → ℝ)) (hE : MeasurableSet E) : |
| singleSpinPlantedLaw β x ((gaugedField x) ⁻¹' E) = |
| standardArrayLaw (Option (Fin n)) ((plantedFieldArray β n) ⁻¹' E) := by |
| have hh := congrArg (fun μ : Measure (Fin n → ℝ) => μ E) (planted_field_representation β hn x) |
| change (singleSpinPlantedLaw β x).map (gaugedField x) E = |
| (standardArrayLaw (Option (Fin n))).map (plantedFieldArray β n) E at hh |
| rw [Measure.map_apply (continuous_gaugedField x).measurable hE, |
| Measure.map_apply (plantedFieldArray_measurable β n) hE] at hh |
| exact hh |
|
|
| lemma plantedField_common_convergence (β : ℝ) (hβ : 0<β) : |
| ExponentialConvergence (fun n => standardArrayLaw (Option (Fin n))) |
| (fun n g => (β/Real.sqrt (n:ℝ))*g none) 0 := by |
| intro ε hε |
| refine ⟨2,ε^2/(2*β^2),by norm_num,by positivity,?_⟩ |
| filter_upwards [eventually_gt_atTop 0] with n hn |
| have hnR : (0:ℝ)<n := Nat.cast_pos.mpr hn |
| have ht := subgaussian_abs_tail |
| (gaussian_hasSubgaussianMGF (coordinate_hasLaw (none : Option (Fin n)))) |
| (ε*Real.sqrt (n:ℝ)/β) (by positivity) |
| simp only [Real.dist_eq,sub_zero] |
| apply (measure_mono (show {g : Option (Fin n) → ℝ | ε ≤ |β/Real.sqrt (n:ℝ)*g none|} ⊆ |
| {g | ε*Real.sqrt (n:ℝ)/β ≤ |g none|} from ?_)).trans |
| · apply ht.trans_eq |
| rw [ENNReal.ofReal_mul (by norm_num : (0:ℝ)≤2)] |
| norm_num only [ENNReal.ofReal_ofNat,NNReal.coe_one,mul_one] |
| congr 2 |
| rw [div_pow,mul_pow,Real.sq_sqrt hnR.le] |
| ring_nf |
| · intro g hg |
| change ε ≤ |β/Real.sqrt (n:ℝ)*g none| at hg |
| rw [abs_mul,abs_of_pos (by positivity : 0<β/Real.sqrt (n:ℝ))] at hg |
| apply (div_le_iff₀ hβ).mpr |
| have hh := (le_div_iff₀ (Real.sqrt_pos.mpr hnR)).mp |
| (show ε ≤ β*|g none|/Real.sqrt (n:ℝ) by simpa only [div_mul_eq_mul_div] using hg) |
| nlinarith |
|
|
| lemma plantedField_mean_bound (β : ℝ) (n : ℕ) : |
| |β^2*((n:ℝ)-1)/(n:ℝ)| ≤ β^2 := by |
| by_cases hn : n=0 |
| · simp [hn, sq_nonneg] |
| have hn1 : (1:ℝ)≤n := by exact_mod_cast (Nat.one_le_iff_ne_zero.mpr hn) |
| rw [abs_of_nonneg (by positivity)] |
| apply (div_le_iff₀ (by positivity : (0:ℝ)<n)).mpr |
| nlinarith [sq_nonneg β] |
|
|
| lemma plantedField_scale_bound (β : ℝ) (n : ℕ) : |
| |β*Real.sqrt (((n:ℝ)-2)/(n:ℝ))| ≤ |β| := by |
| have hs : Real.sqrt (((n:ℝ)-2)/(n:ℝ)) ≤ 1 := by |
| apply Real.sqrt_le_one.mpr |
| by_cases hn : n=0 |
| · simp [hn] |
| · apply (div_le_iff₀ (Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn))).mpr |
| linarith |
| rw [abs_mul,abs_of_nonneg (Real.sqrt_nonneg _)] |
| nlinarith [abs_nonneg β] |
|
|
| lemma plantedFieldArray_squareTails (β : ℝ) (hβ : 0<β) : |
| ExponentialSquareTails (fun n => standardArrayLaw (Option (Fin n))) |
| (plantedFieldArray β) := by |
| let ρ := fun n => standardArrayLaw (Option (Fin n)) |
| have hi : ExponentialSquareTails ρ (fun _ g i => g (some i)) := by |
| exact iid_exponential_squareTails ρ _ (fun _ _ => measurable_pi_apply _) |
| (fun _ => coordinates_independent.precomp (Option.some_injective _)) |
| (gaussianReal 0 1) (fun _ _ => coordinate_hasLaw _) gaussian_integrable_exp_quarter_sq |
| have ha := hi.bounded_mul |
| (fun n _ _ => β*Real.sqrt (((n:ℝ)-2)/(n:ℝ))) |β| (abs_nonneg β) |
| (fun n _ _ => plantedField_scale_bound β n) |
| have hm := exponentialSquareTails_of_bounded ρ |
| (fun n _ _ => β^2*((n:ℝ)-1)/(n:ℝ)) (β^2) (fun n _ _ => plantedField_mean_bound β n) |
| have hb := hm.add ha |
| apply hb.l2_stability |
| have hz := (plantedField_common_convergence β hβ).continuous_map |
| (f := fun x : ℝ => x^2) (by fun_prop) |
| simp only [zero_pow (by norm_num : (2:ℕ)≠0)] at hz |
| intro ε hε |
| apply (hz ε hε).mono |
| filter_upwards [eventually_gt_atTop 0] with n hn |
| intro g hg |
| have he : (∑ i : Fin n, |
| (β^2*((n:ℝ)-1)/(n:ℝ)+β*Real.sqrt (((n:ℝ)-2)/(n:ℝ))*g (some i) - |
| plantedFieldArray β n g i)^2)/(n:ℝ) = ((β/Real.sqrt (n:ℝ))*g none)^2 := by |
| simp only [plantedFieldArray,sharedGaussianField,sub_add_cancel_left, |
| neg_sq,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] |
| field_simp |
| change ε ≤ dist _ 0 at hg ⊢ |
| rwa [he] at hg |
|
|
| noncomputable def plantedFieldLimitLaw (β : ℝ) : Measure ℝ := |
| (gaussianReal 0 1).map (fun z => β^2+β*z) |
|
|
| instance plantedFieldLimitLaw_probability (β : ℝ) : IsProbabilityMeasure (plantedFieldLimitLaw β) := by |
| unfold plantedFieldLimitLaw |
| infer_instance |
|
|
| lemma plantedFieldArray_empirical (β : ℝ) (hβ : 0<β) : |
| ExponentialEmpiricalConcentration (fun n => standardArrayLaw (Option (Fin n))) |
| (plantedFieldArray β) (plantedFieldLimitLaw β) := by |
| intro f K hf B hB ε hε |
| have hf' : LipschitzWith (K+1) f := hf.weaken (by simp) |
| obtain ⟨c,hc,ht⟩ := planted_field_average_exponential β hβ f (by positivity) hf' |
| (|B|+1) (by positivity) (fun z => (hB z).trans (by linarith [le_abs_self B])) ε hε |
| refine ⟨1,c,by norm_num,hc,?_⟩ |
| filter_upwards [ht,eventually_ge_atTop 2] with n hn hn2 |
| have hm : (∫ z, f z ∂plantedFieldLimitLaw β) = ∫ z, f (β^2+β*z) ∂gaussianReal 0 1 := by |
| exact integral_map (by fun_prop) hf.continuous.aestronglyMeasurable |
| rw [hm] |
| have hh := hn (fun _ => false) |
| have hE : MeasurableSet {v : Fin n → ℝ | ε ≤ |(∑ i, f (v i))/(n:ℝ) - |
| ∫ z, f (β^2+β*z) ∂gaussianReal 0 1|} := by |
| apply measurableSet_le measurable_const |
| exact (((Finset.measurable_sum _ (fun i _ => hf.continuous.measurable.comp |
| (measurable_pi_apply i))).div_const _).sub_const _).abs |
| rw [show singleSpinPlantedLaw β (fun _ : Fin n => false) {g | ε ≤ |
| |(∑ i, f (gaugedField (fun _ => false) g i))/(n:ℝ) - |
| ∫ z, f (β^2+β*z) ∂gaussianReal 0 1|} = _ from |
| planted_field_event_eq β hn2 (fun _ => false) _ hE] at hh |
| simpa only [one_mul,Set.preimage_ofPred_eq] using hh |
|
|
| lemma plantedFieldLimitLaw_secondMoment (β : ℝ) : |
| Integrable (fun z : ℝ => z^2) (plantedFieldLimitLaw β) ∧ |
| (∫ z, z^2 ∂plantedFieldLimitLaw β)=β^2+β^4 := by |
| have hl : HasLaw (fun z : ℝ => β^2+β*z) (plantedFieldLimitLaw β) (gaussianReal 0 1) := |
| ⟨by fun_prop,rfl⟩ |
| have hi2 : MemLp (id : ℝ → ℝ) 2 (plantedFieldLimitLaw β) := by |
| apply (memLp_map_measure_iff (by fun_prop) (by fun_prop)).mpr |
| exact (memLp_const (β^2)).add |
| (((IsGaussian.hasGaussianLaw_id (μ := gaussianReal 0 1)).memLp_two).const_mul β) |
| have hi := hi2.integrable_sq |
| refine ⟨hi,?_⟩ |
| have hmean : (∫ z, z ∂plantedFieldLimitLaw β)=β^2 := by |
| rw [← hl.integral_eq] |
| have hm : Integrable (fun z : ℝ => β*z) (gaussianReal 0 1) := |
| (IsGaussian.hasGaussianLaw_id (μ := gaussianReal 0 1)).integrable.const_mul β |
| rw [integral_add (integrable_const _) hm,integral_const,integral_const_mul] |
| simp [integral_id_gaussianReal] |
| have hv : Var[id |
| rw [← hl.variance_eq,variance_const_add (by fun_prop),variance_const_mul] |
| simp |
| have hh := variance_eq_sub (X := id) hi2 |
| simp only [Pi.pow_apply,id_eq,hmean] at hh |
| rw [hv] at hh |
| nlinarith |
|
|
| lemma plantedFieldArray_secondMoment (β : ℝ) (hβ : 0<β) : |
| ExponentialConvergence (fun n => standardArrayLaw (Option (Fin n))) |
| (fun n g => (∑ i, plantedFieldArray β n g i^2)/(n:ℝ)) (β^2+β^4) := by |
| have hh := (plantedFieldArray_empirical β hβ).secondMoment |
| (plantedFieldArray_squareTails β hβ) (plantedFieldLimitLaw_secondMoment β).1 |
| rwa [(plantedFieldLimitLaw_secondMoment β).2] at hh |
|
|
| lemma ExponentiallyRare.without_prefactor {H : ℕ → Type*} [∀ n, MeasurableSpace (H n)] |
| {ρ : ∀ n, Measure (H n)} {A : ∀ n, Set (H n)} (hA : ExponentiallyRare ρ A) : |
| ∃ c : ℝ, 0<c ∧ ∀ᶠ n in atTop, ρ n (A n) ≤ ENNReal.ofReal (Real.exp (-c*n)) := by |
| obtain ⟨C,c,hC,hc,he⟩ := hA |
| refine ⟨c/2,by positivity,?_⟩ |
| have hnc := (tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n:ℝ)) atTop atTop) |
| filter_upwards [he,hnc.eventually (eventually_ge_atTop (2*Real.log C/c))] with n hn hsize |
| apply hn.trans |
| apply ENNReal.ofReal_le_ofReal |
| rw [show C*Real.exp (-c*n)=Real.exp (Real.log C-c*n) by |
| rw [Real.exp_sub,Real.exp_log hC,neg_mul,Real.exp_neg,div_eq_mul_inv] ] |
| apply Real.exp_le_exp.mpr |
| have hh := (div_le_iff₀ hc).mp hsize |
| nlinarith |
|
|
| noncomputable def spinFieldSquareAverage {n : ℕ} (x : Spin n) |
| (g : GaussianCoordinates n) : ℝ := (∑ i, gaugedField x g i^2)/(n:ℝ) |
|
|
| lemma continuous_spinFieldSquareAverage {n : ℕ} (x : Spin n) : |
| Continuous (spinFieldSquareAverage x) := by |
| change Continuous (fun g => (∑ i, gaugedField x g i^2)/(n:ℝ)) |
| exact (continuous_finsetSum _ (fun i _ => |
| ((continuous_apply i).comp (continuous_gaugedField x)).pow 2)).div_const _ |
|
|
| lemma spinFieldSquareAverage_planted_exponential (β : ℝ) (hβ : 0<β) |
| (ε : ℝ) (hε : 0<ε) : ∃ c : ℝ, 0<c ∧ ∀ᶠ n : ℕ in atTop, |
| ∀ x : Spin n, singleSpinPlantedLaw β x {g | ε ≤ |spinFieldSquareAverage x g-(β^2+β^4)|} ≤ |
| ENNReal.ofReal (Real.exp (-c*n)) := by |
| obtain ⟨c,hc,ht⟩ := ((plantedFieldArray_secondMoment β hβ) ε hε).without_prefactor |
| refine ⟨c,hc,?_⟩ |
| filter_upwards [ht,eventually_ge_atTop 2] with n hn hn2 |
| intro x |
| have hE : MeasurableSet {v : Fin n → ℝ | ε ≤ |(∑ i, v i^2)/(n:ℝ)-(β^2+β^4)|} := by |
| apply measurableSet_le measurable_const |
| exact (((Finset.measurable_sum _ (fun i _ => (measurable_pi_apply i).pow_const 2)).div_const _).sub_const _).abs |
| have he := planted_field_event_eq β hn2 x _ hE |
| change singleSpinPlantedLaw β x {g | ε ≤ |spinFieldSquareAverage x g-(β^2+β^4)|} = _ at he |
| rw [he] |
| simpa only [Real.dist_eq,Set.preimage_ofPred_eq] using hn |
| |
| theorem quenched_spinFieldSquareAverage_exponential (β : ℝ) (hβ : 0<β) (hβ1 : β<1) |
| (ε : ℝ) (hε : 0<ε) : ∃ c : ℝ, 0<c ∧ Tendsto (fun n => disorderLaw β n {g | |
| ENNReal.ofReal (Real.exp (-c*n)) ≤ gibbsEventProbability |
| (fun x : Spin n => {h | ε ≤ |spinFieldSquareAverage x h-(β^2+β^4)|}) g}) |
| atTop (nhds 0) := by |
| obtain ⟨c,hc,hs⟩ := spinFieldSquareAverage_planted_exponential β hβ ε hε |
| refine ⟨c/2,by positivity,?_⟩ |
| apply quenched_gibbs_events_exponential β (by nlinarith) c hc _ _ hs |
| intro n x |
| exact measurableSet_le measurable_const ((continuous_spinFieldSquareAverage x).measurable.sub_const _).abs |
| |
| lemma spinFieldSquareAverage_abs_le_opNorm_sq {n : ℕ} (hn : 0<n) (x : Spin n) |
| (g : GaussianCoordinates n) : |spinFieldSquareAverage x g| ≤ |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (sampledInteraction g)‖^2 := by |
| have hh := matrix_mulVec_sq_bound (sampledInteraction g) (spin x) le_rfl |
| have he : (∑ i, gaugedField x g i^2) = ∑ i, (sampledInteraction g *ᵥ spin x) i^2 := by |
| simp only [gaugedField,mul_pow,spin_sq,one_mul,field,Matrix.mulVec,dotProduct] |
| have hsum : (∑ i : Fin n, spin x i^2)=(n:ℝ) := by simp [spin_sq] |
| rw [hsum] at hh |
| rw [spinFieldSquareAverage,abs_of_nonneg (by positivity),he] |
| exact (div_le_iff₀ (Nat.cast_pos.mpr hn)).mpr hh |
| |
| noncomputable def gibbsSpinFieldSquareAverage {n : ℕ} (g : GaussianCoordinates n) : ℝ := |
| gibbsExpectation (sampledInteraction g) (fun x => spinFieldSquareAverage x g) |
| |
| theorem gibbsSpinFieldSquareAverage_limit (β : ℝ) (hβ : 0<β) (hβ1 : β<1) |
| (ε : ℝ) (hε : 0<ε) : |
| Tendsto (fun n => disorderLaw β n {g | ε ≤ |gibbsSpinFieldSquareAverage g-(β^2+β^4)|}) |
| atTop (nhds 0) := by |
| obtain ⟨c,hc,hevent⟩ := quenched_spinFieldSquareAverage_exponential β hβ hβ1 (ε/2) (by positivity) |
| let C := 2*(β^2+10) |
| let K := C^2+(β^2+β^4) |
| have hK : 0 ≤ K := by dsimp [K,C] |
| have hnorm := RandomMatrix.sampled_opNorm_tendsto β |
| have ht : Tendsto (fun n : ℕ => K*Real.exp (-c*n)) atTop (nhds 0) := by |
| have hh := Real.tendsto_exp_neg_atTop_nhds_zero.comp |
| ((tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n:ℝ)) atTop atTop).const_mul_atTop hc) |
| simpa only [Function.comp_apply,neg_mul,mul_zero] using hh.const_mul K |
| have hsum := hnorm.add hevent |
| simp only [add_zero] at hsum |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hsum |
| (Eventually.of_forall (fun _ => bot_le)) |
| filter_upwards [eventually_gt_atTop 0,ht.eventually (gt_mem_nhds (by positivity : (0:ℝ)<ε/2))] |
| with n hn hsmall |
| apply (measure_mono (show {g | ε ≤ |gibbsSpinFieldSquareAverage g-(β^2+β^4)|} ⊆ |
| {g | C < ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (sampledInteraction g)‖} ∪ |
| {g | ENNReal.ofReal (Real.exp (-c*n)) ≤ |
| gibbsEventProbability (fun x : Spin n => {h | ε/2 ≤ |spinFieldSquareAverage x h-(β^2+β^4)|}) g} from ?_)).trans |
| (measure_union_le _ _) |
| intro g hg |
| by_cases ha : C < ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (sampledInteraction g)‖ |
| · exact Or.inl ha |
| by_cases hb : ENNReal.ofReal (Real.exp (-c*n)) ≤ |
| gibbsEventProbability (fun x : Spin n => {h | ε/2 ≤ |spinFieldSquareAverage x h-(β^2+β^4)|}) g |
| · exact Or.inr hb |
| exfalso |
| have hp : (gibbsEventProbability (fun x : Spin n => {h | ε/2 ≤ |spinFieldSquareAverage x h-(β^2+β^4)|}) g).toReal |
| ≤ Real.exp (-c*n) := by |
| have hh := ENNReal.toReal_mono (show ENNReal.ofReal (Real.exp (-c*n))≠⊤ from ENNReal.ofReal_ne_top) |
| (lt_of_not_ge hb).le |
| simpa only [ENNReal.toReal_ofReal (Real.exp_pos _).le] using hh |
| have hdev := gibbsExpectation_deviation_bound g |
| (fun x h => spinFieldSquareAverage x h) ((β^2+β^4)) (ε/2) K (by positivity) (fun x => by |
| calc |
| _ ≤ |spinFieldSquareAverage x g|+|(β^2+β^4)| := by simpa only [sub_zero,zero_sub,abs_neg] using abs_sub_le (spinFieldSquareAverage x g) (0:ℝ) ((β^2+β^4)) |
| _ ≤ C^2+(β^2+β^4) := by |
| rw [abs_of_nonneg (by positivity : 0≤β^2+β^4)] |
| exact add_le_add_left ((spinFieldSquareAverage_abs_le_opNorm_sq hn x g).trans |
| (pow_le_pow_left₀ (norm_nonneg _) (le_of_not_gt ha) 2)) _) |
| change ε ≤ |gibbsExpectation (sampledInteraction g) (fun x => spinFieldSquareAverage x g)-(β^2+β^4)| at hg |
| have he := mul_le_mul_of_nonneg_left hp hK |
| linarith |
| |
| end SKGapCutoff.Regression |
| |
| open MeasureTheory ProbabilityTheory Filter Matrix |
| open scoped BigOperators ENNReal Matrix.Norms.L2Operator |
| |
| end |
| |
| end OAI |
| |
