| import Mathlib |
| import OAI.Probability.SKGap.Terminal.FiniteSpinCalculus |
| import OAI.Probability.SKGap.Brownian.ContinuousEnergy |
| import OAI.Probability.SKGap.Localization.UpperCoefficient |
|
|
| 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 |
| namespace SKGapCutoff |
|
|
| def CoordinateLipschitz {ι : Type*} [Fintype ι] (f : (ι → ℝ) → ℝ) : Prop := |
| ∀ x y, |f x - f y| ≤ ∑ i, |x i - y i| |
|
|
| lemma CoordinateLipschitz.lipschitz {ι : Type*} [Fintype ι] |
| {f : (ι → ℝ) → ℝ} (hf : CoordinateLipschitz f) : |
| LipschitzWith (Fintype.card ι) f := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| calc |
| dist (f x) (f y) = |f x - f y| := Real.dist_eq _ _ |
| _ ≤ ∑ i, |x i - y i| := hf x y |
| _ ≤ ∑ _ : ι, dist x y := Finset.sum_le_sum fun i _ => by |
| simpa only [Real.dist_eq] using dist_le_pi_dist x y i |
| _ = _ := by simp |
|
|
| lemma memLp_gaussian_pi_id {ι : Type*} [Fintype ι] (v : ℝ≥0) : |
| MemLp (id : (ι → ℝ) → (ι → ℝ)) 2 (Measure.pi (fun _ => gaussianReal 0 v)) := by |
| apply memLp_pi_iff.2 |
| intro i |
| exact (memLp_id_gaussianReal (μ := 0) (v := v) 2).comp_measurePreserving |
| (measurePreserving_eval _ i) |
|
|
| lemma memLp_gaussian_pi_of_lipschitz {ι : Type*} [Fintype ι] |
| {f : (ι → ℝ) → ℝ} {K : ℝ≥0} (hf : LipschitzWith K f) (v : ℝ≥0) : |
| MemLp f 2 (Measure.pi (fun _ => gaussianReal 0 v)) := by |
| have hsub : LipschitzWith K (fun x => f x - f 0) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| simpa only [dist_sub_right] using hf.dist_le_mul x y |
| have h := hsub.comp_memLp (by simp) (memLp_gaussian_pi_id (ι := ι) v) |
| convert h.add (memLp_const (f 0)) using 1 |
| · ext x; simp |
|
|
| lemma memLp_gaussian_real_of_lipschitz {f : ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (v : ℝ≥0) : MemLp f 2 (gaussianReal 0 v) := by |
| have hsub : LipschitzWith K (fun x => f x - f 0) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| simpa only [dist_sub_right] using hf.dist_le_mul x y |
| have h := hsub.comp_memLp (by simp) |
| (memLp_id_gaussianReal (μ := 0) (v := v) 2) |
| convert h.add (memLp_const (f 0)) using 1 <;> try norm_num |
| ext x |
| simp |
|
|
| lemma gaussian_lipschitz_variance {f : ℝ → ℝ} (hf : LipschitzWith 1 f) (v : ℝ≥0) : |
| variance f (gaussianReal 0 v) ≤ v := by |
| have hm := memLp_gaussian_real_of_lipschitz hf v |
| have hs : MemLp (fun z => f z - f 0) 2 (gaussianReal 0 v) := hm.sub (memLp_const (f 0)) |
| have hv : variance f (gaussianReal 0 v) = |
| (∫ z, (f z - f 0)^2 ∂gaussianReal 0 v) - |
| (∫ z, f z - f 0 ∂gaussianReal 0 v)^2 := by |
| rw [← variance_sub_const hm.aestronglyMeasurable (f 0)] |
| simpa only [Pi.pow_apply] using variance_eq_sub hs |
| rw [hv] |
| have hi : (∫ z, (f z - f 0)^2 ∂gaussianReal 0 v) ≤ |
| ∫ z, z^2 ∂gaussianReal 0 v := by |
| apply integral_mono hs.integrable_sq |
| (memLp_id_gaussianReal (μ := 0) (v := v) 2).integrable_sq |
| intro z |
| have h := hf.dist_le_mul z 0 |
| simp only [Real.dist_eq, NNReal.coe_one, one_mul, sub_zero] at h |
| exact sq_le_sq.mpr h |
| have hid : (∫ z : ℝ, z^2 ∂gaussianReal 0 v) = v := by |
| have hh := variance_eq_sub (memLp_id_gaussianReal (μ := 0) (v := v) 2) |
| simpa only [variance_id_gaussianReal, integral_id_gaussianReal, zero_pow (by decide : (2 : ℕ) ≠ 0), sub_zero, |
| id_eq, Pi.pow_apply] using hh.symm |
| rw [hid] at hi |
| linarith [sq_nonneg (∫ z, f z - f 0 ∂gaussianReal 0 v)] |
|
|
| lemma coordinateLipschitz_cons_real {n : ℕ} {f : (Fin (n+1) → ℝ) → ℝ} |
| (hf : CoordinateLipschitz f) (x : Fin n → ℝ) : |
| LipschitzWith 1 (fun z => f (Fin.cons z x)) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro z w |
| simpa [Real.dist_eq, Fin.sum_univ_succ] using hf (Fin.cons z x) (Fin.cons w x) |
|
|
| lemma coordinateLipschitz_integral_cons {n : ℕ} {f : (Fin (n+1) → ℝ) → ℝ} |
| (hf : CoordinateLipschitz f) (v : ℝ≥0) : |
| CoordinateLipschitz (fun x : Fin n → ℝ => |
| ∫ z, f (Fin.cons z x) ∂gaussianReal 0 v) := by |
| intro x y |
| rw [← integral_sub |
| ((memLp_gaussian_real_of_lipschitz (coordinateLipschitz_cons_real hf x) v).integrable one_le_two) |
| ((memLp_gaussian_real_of_lipschitz (coordinateLipschitz_cons_real hf y) v).integrable one_le_two)] |
| calc |
| _ ≤ ∫ z, |f (Fin.cons z x) - f (Fin.cons z y)| ∂gaussianReal 0 v := |
| abs_integral_le_integral_abs |
| _ ≤ ∫ _ : ℝ, (∑ i, |x i - y i|) ∂gaussianReal 0 v := by |
| apply integral_mono |
| (((memLp_gaussian_real_of_lipschitz (coordinateLipschitz_cons_real hf x) v).integrable one_le_two).sub |
| ((memLp_gaussian_real_of_lipschitz (coordinateLipschitz_cons_real hf y) v).integrable one_le_two)).abs |
| (integrable_const _) |
| intro z |
| simpa [Fin.sum_univ_succ] using hf (Fin.cons z x) (Fin.cons z y) |
| _ = _ := by simp |
|
|
| lemma integral_gaussian_fin_succ {n : ℕ} (v : ℝ≥0) |
| (f : (Fin (n+1) → ℝ) → ℝ) |
| (hf : Integrable f (Measure.pi (fun _ => gaussianReal 0 v))) : |
| (∫ x, f x ∂Measure.pi (fun _ => gaussianReal 0 v)) = |
| ∫ x : Fin n → ℝ, ∫ z : ℝ, f (Fin.cons z x) ∂gaussianReal 0 v |
| ∂Measure.pi (fun _ => gaussianReal 0 v) := by |
| let e := (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) => ℝ) 0).symm |
| have hm := (measurePreserving_piFinSuccAbove (fun _ : Fin (n+1) => gaussianReal 0 v) 0).symm |
| have he (p : ℝ × (Fin n → ℝ)) : e p = Fin.cons p.1 p.2 := by |
| simp [e, MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv] |
| rw [← hm.integral_comp'] |
| change (∫ p : ℝ × (Fin n → ℝ), f (e p) ∂(gaussianReal 0 v).prod |
| (Measure.pi (fun _ => gaussianReal 0 v))) = _ |
| simp_rw [he] |
| apply integral_prod_symm |
| have hi := (hm.integrable_comp hf.aestronglyMeasurable).mpr hf |
| change Integrable (fun p : ℝ × (Fin n → ℝ) => f (e p)) _ at hi |
| simpa only [he] using hi |
| |
| lemma gaussian_coordinate_variance_fin (v : ℝ≥0) (n : ℕ) |
| {f : (Fin n → ℝ) → ℝ} (hf : CoordinateLipschitz f) : |
| variance f (Measure.pi (fun _ => gaussianReal 0 v)) ≤ (n : ℝ) * v := by |
| induction n with |
| | zero => |
| have he : f = fun _ => f 0 := funext fun x => congrArg f (Subsingleton.elim x 0) |
| rw [he, variance_eq_sub (memLp_const _)] |
| simp |
| | succ n ih => |
| let g : (Fin n → ℝ) → ℝ := fun x => ∫ z, f (Fin.cons z x) ∂gaussianReal 0 v |
| have hg := coordinateLipschitz_integral_cons hf v |
| have hfm := memLp_gaussian_pi_of_lipschitz hf.lipschitz v |
| have hgm := memLp_gaussian_pi_of_lipschitz hg.lipschitz v |
| change MemLp g 2 _ at hgm |
| have hpoint (x : Fin n → ℝ) : |
| (∫ z, f (Fin.cons z x)^2 ∂gaussianReal 0 v) ≤ v + g x ^ 2 := by |
| have hv := gaussian_lipschitz_variance (coordinateLipschitz_cons_real hf x) v |
| rw [variance_eq_sub (memLp_gaussian_real_of_lipschitz |
| (coordinateLipschitz_cons_real hf x) v)] at hv |
| change (∫ z, f (Fin.cons z x)^2 ∂gaussianReal 0 v) - g x ^ 2 ≤ v at hv |
| linarith |
| have hsq := integral_mono_of_nonneg |
| (Filter.Eventually.of_forall (fun x => integral_nonneg (fun z => sq_nonneg _))) |
| ((integrable_const (v : ℝ)).add hgm.integrable_sq) (Filter.Eventually.of_forall hpoint) |
| simp only [Pi.add_apply] at hsq |
| rw [integral_add (f := fun _ => (v : ℝ)) (g := fun x => g x ^ 2) |
| (integrable_const _) hgm.integrable_sq, integral_const] at hsq |
| simp only [measureReal_def, measure_univ, ENNReal.toReal_one, one_smul] at hsq |
| rw [← integral_gaussian_fin_succ v (fun x => f x^2) hfm.integrable_sq] at hsq |
| have hih := ih hg |
| rw [variance_eq_sub hgm] at hih |
| rw [variance_eq_sub hfm, integral_gaussian_fin_succ v f (hfm.integrable one_le_two)] |
| change (∫ x, f x^2 ∂Measure.pi (fun _ => gaussianReal 0 v)) - |
| (∫ x, g x ∂Measure.pi (fun _ => gaussianReal 0 v))^2 ≤ ((n+1 : ℕ) : ℝ) * v |
| push_cast |
| change (∫ x, g x^2 ∂Measure.pi (fun _ => gaussianReal 0 v)) - |
| (∫ x, g x ∂Measure.pi (fun _ => gaussianReal 0 v))^2 ≤ (n : ℝ)*v at hih |
| linarith |
| |
| lemma gaussian_coordinate_variance {ι : Type*} [Fintype ι] (v : ℝ≥0) |
| {f : (ι → ℝ) → ℝ} (hf : CoordinateLipschitz f) : |
| variance f (Measure.pi (fun _ => gaussianReal 0 v)) ≤ (Fintype.card ι : ℝ) * v := by |
| let e : Fin (Fintype.card ι) ≃ ι := (Fintype.equivFin ι).symm |
| let T := MeasurableEquiv.piCongrLeft (fun _ : ι => ℝ) e |
| have hm := measurePreserving_piCongrLeft (fun _ : ι => gaussianReal 0 v) e |
| have hg : CoordinateLipschitz (fun x => f (T x)) := by |
| intro x y |
| calc |
| _ ≤ ∑ i : ι, |T x i - T y i| := hf _ _ |
| _ = ∑ i : Fin (Fintype.card ι), |x i - y i| := by |
| rw [← e.sum_comp] |
| simp [T, MeasurableEquiv.piCongrLeft_apply_apply] |
| rw [← hm.variance_fun_comp hf.lipschitz.continuous.measurable.aemeasurable] |
| exact gaussian_coordinate_variance_fin v _ hg |
| |
| lemma abs_upperCoefficient_le_one {n : ℕ} (x : Spin n) (p : Fin n × Fin n) : |
| |upperCoefficient x p| ≤ 1 := by |
| unfold upperCoefficient |
| split_ifs |
| · rw [abs_mul]; cases h₁ : x p.1 <;> cases h₂ : x p.2 <;> simp [spin, h₁, h₂] |
| · simp |
| |
| lemma energy_sampled_diff_le {n : ℕ} (x : Spin n) (g h : GaussianCoordinates n) : |
| |energy (sampledInteraction g) x - energy (sampledInteraction h) x| ≤ |
| ∑ p, |g p - h p| := by |
| simp only [energy_sampled, ← Finset.sum_sub_distrib, ← mul_sub] |
| calc |
| _ ≤ ∑ p, |upperCoefficient x p * (g p - h p)| := Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ _ := Finset.sum_le_sum fun p _ => by |
| rw [abs_mul] |
| exact mul_le_of_le_one_left (abs_nonneg _) (abs_upperCoefficient_le_one x p) |
| |
| lemma log_partition_sampled_le {n : ℕ} (g h : GaussianCoordinates n) : |
| Real.log (partition (sampledInteraction g)) ≤ |
| (∑ p, |g p - h p|) + Real.log (partition (sampledInteraction h)) := by |
| have hp : partition (sampledInteraction g) ≤ |
| Real.exp (∑ p, |g p - h p|) * partition (sampledInteraction h) := by |
| unfold partition |
| rw [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro x _ |
| rw [← Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| have hh := (le_abs_self _).trans (energy_sampled_diff_le x g h) |
| linarith |
| have hh := Real.log_le_log (partition_pos _) hp |
| rw [Real.log_mul (ne_of_gt (Real.exp_pos _)) (ne_of_gt (partition_pos _)), |
| Real.log_exp] at hh |
| exact hh |
| |
| lemma coordinateLipschitz_log_partition (n : ℕ) : |
| CoordinateLipschitz (fun g : GaussianCoordinates n => |
| Real.log (partition (sampledInteraction g))) := by |
| intro g h |
| apply abs_le.mpr |
| have hg := log_partition_sampled_le g h |
| have hh := log_partition_sampled_le h g |
| simp_rw [abs_sub_comm (h _) (g _)] at hh |
| constructor <;> linarith |
| |
| lemma memLp_log_partition (β : ℝ) (n : ℕ) : |
| MemLp (fun g => Real.log (partition (sampledInteraction g))) 2 (disorderLaw β n) := |
| memLp_gaussian_pi_of_lipschitz (coordinateLipschitz_log_partition n).lipschitz _ |
| |
| lemma variance_log_partition_le (β : ℝ) {n : ℕ} (hn : 0 < n) : |
| variance (fun g => Real.log (partition (sampledInteraction g))) (disorderLaw β n) ≤ |
| β ^ 2 * n := by |
| have h := gaussian_coordinate_variance (Real.toNNReal (β ^ 2 / n)) |
| (coordinateLipschitz_log_partition n) |
| simp only [Fintype.card_prod, Fintype.card_fin, Nat.cast_mul, |
| Real.coe_toNNReal _ (div_nonneg (sq_nonneg _) (Nat.cast_nonneg _))] at h |
| have hn0 : (n : ℝ) ≠ 0 := by exact_mod_cast ne_of_gt hn |
| have he : (n : ℝ) * n * (β ^ 2 / n) = β ^ 2 * n := by field_simp |
| rw [he] at h |
| exact h |
| |
| lemma integral_sq_cauchy {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsFiniteMeasure μ] {f : Ω → ℝ} (hf : Integrable f μ) |
| (hf2 : Integrable (fun x => f x ^ 2) μ) : |
| (∫ x, f x ∂μ) ^ 2 ≤ μ.real Set.univ * ∫ x, f x ^ 2 ∂μ := by |
| by_cases hμ : μ = 0 |
| · simp [hμ] |
| have hM : 0 < μ.real Set.univ := by |
| rw [measureReal_def, ENNReal.toReal_pos_iff] |
| exact ⟨pos_iff_ne_zero.mpr (Measure.measure_univ_ne_zero.mpr hμ), measure_lt_top _ _⟩ |
| let M := μ.real Set.univ |
| let I := ∫ x, f x ∂μ |
| have hp (x : Ω) : (M * f x - I) ^ 2 = |
| M ^ 2 * f x ^ 2 - (2 * M * I) * f x + I ^ 2 := by ring |
| have h := integral_nonneg (μ := μ) (f := fun x => (M * f x - I) ^ 2) |
| (fun x => sq_nonneg _) |
| simp_rw [hp] at h |
| rw [integral_add (f := fun x => M ^ 2 * f x ^ 2 - (2 * M * I) * f x) |
| (g := fun _ => I ^ 2) ((hf2.const_mul _).sub (hf.const_mul _)) (integrable_const _), |
| integral_sub (f := fun x => M ^ 2 * f x ^ 2) (g := fun x => (2 * M * I) * f x) |
| (hf2.const_mul _) (hf.const_mul _), integral_const_mul, |
| integral_const_mul, integral_const] at h |
| simp only [smul_eq_mul] at h |
| change 0 ≤ M ^ 2 * (∫ x, f x ^ 2 ∂μ) - 2 * M * I * I + M * I ^ 2 at h |
| change I ^ 2 ≤ M * ∫ x, f x ^ 2 ∂μ |
| have h' : 0 ≤ M * (M * (∫ x, f x ^ 2 ∂μ) - I ^ 2) := by nlinarith |
| exact sub_nonneg.mp ((mul_nonneg_iff_of_pos_left hM).mp h') |
| |
| lemma second_moment_lower_probability {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] {f : Ω → ℝ} |
| (hf : Integrable f μ) (hf2 : Integrable (fun x => f x ^ 2) μ) |
| (hm : Measurable f) (hfp : ∀ x, 0 ≤ f x) {a : ℝ} |
| (ha : 0 ≤ a) (ham : a ≤ ∫ x, f x ∂μ) : |
| ((∫ x, f x ∂μ) - a) ^ 2 ≤ μ.real {x | a ≤ f x} * ∫ x, f x ^ 2 ∂μ := by |
| let A := {x | a ≤ f x} |
| have hA : MeasurableSet A := measurableSet_le measurable_const hm |
| have hIc : (∫ x in Aᶜ, f x ∂μ) ≤ a := by |
| calc |
| _ ≤ ∫ _ in Aᶜ, a ∂μ := by |
| apply setIntegral_mono_on hf.integrableOn (integrable_const _).integrableOn hA.compl |
| intro x hx |
| exact le_of_lt (lt_of_not_ge hx) |
| _ = μ.real Aᶜ * a := by rw [setIntegral_const]; rfl |
| _ ≤ a := by |
| simpa only [one_mul] using mul_le_mul_of_nonneg_right |
| (measureReal_le_one (μ := μ) (s := Aᶜ)) ha |
| have hdecomp := integral_add_compl hA hf |
| have hI : (∫ x, f x ∂μ) - a ≤ ∫ x in A, f x ∂μ := by linarith |
| have hI0 : 0 ≤ ∫ x in A, f x ∂μ := integral_nonneg hfp |
| have hsq := integral_sq_cauchy (μ.restrict A) hf.integrableOn hf2.integrableOn |
| simp only [measureReal_restrict_apply_univ] at hsq |
| have hQ : (∫ x in A, f x ^ 2 ∂μ) ≤ ∫ x, f x ^ 2 ∂μ := |
| setIntegral_le_integral hf2 (Filter.Eventually.of_forall (fun x => sq_nonneg (f x))) |
| have hQ' := mul_le_mul_of_nonneg_left hQ (measureReal_nonneg (μ := μ) (s := A)) |
| have hab : 0 ≤ (∫ x, f x ∂μ) - a := sub_nonneg.mpr ham |
| nlinarith |
|
|
| open ProbabilityTheory |
| lemma partition_half_mean_probability (β : ℝ) (hβ : β ^ 2 < 1) |
| {n : ℕ} (hn : 0 < n) : |
| Real.sqrt (1 - β ^ 2) / 4 ≤ (disorderLaw β n).real |
| {g | (∫ h, partition (sampledInteraction h) ∂disorderLaw β n) / 2 ≤ |
| partition (sampledInteraction g)} := by |
| let : IsProbabilityMeasure (disorderLaw β n) := by unfold disorderLaw; infer_instance |
| let m := ∫ g, partition (sampledInteraction g) ∂disorderLaw β n |
| let q := ∫ g, partition (sampledInteraction g) ^ 2 ∂disorderLaw β n |
| let p := (disorderLaw β n).real {g | m / 2 ≤ partition (sampledInteraction g)} |
| have hm : 0 < m := by |
| dsimp [m] |
| rw [integral_partition_sampled β hn] |
| positivity |
| have hs : 0 < Real.sqrt (1 - β ^ 2) := Real.sqrt_pos.2 (by linarith) |
| have hz := second_moment_lower_probability (disorderLaw β n) |
| (integrable_partition_sampled β n) (integrable_partition_sq_sampled β n) |
| (((continuous_partition n).comp (continuous_sampledInteraction n)).measurable) |
| (fun g => le_of_lt (partition_pos _)) (a := m / 2) (by positivity) (by dsimp [m]; linarith) |
| change (m - m / 2) ^ 2 ≤ p * q at hz |
| have hu := partition_second_moment_bound β hβ hn |
| change q / m ^ 2 ≤ (Real.sqrt (1 - β ^ 2))⁻¹ at hu |
| have hu' : q * Real.sqrt (1 - β ^ 2) ≤ m ^ 2 := by |
| rw [div_le_iff₀ (sq_pos_of_pos hm)] at hu |
| have := mul_le_mul_of_nonneg_left hu (le_of_lt hs) |
| field_simp at this |
| nlinarith |
| have hp : 0 ≤ p := measureReal_nonneg |
| have hh := mul_le_mul_of_nonneg_right hz (le_of_lt hs) |
| have hh' := mul_le_mul_of_nonneg_left hu' hp |
| change Real.sqrt (1 - β ^ 2) / 4 ≤ p |
| nlinarith [sq_pos_of_pos hm] |
| |
| lemma mean_ge_of_upper_event {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {f : Ω → ℝ} (hf : MemLp f 2 μ) |
| {a p : ℝ} (hp : 0 < p) (hprob : p ≤ μ.real {x | a ≤ f x}) : |
| a - Real.sqrt (variance f μ / p) ≤ ∫ x, f x ∂μ := by |
| by_cases ha : a ≤ ∫ x, f x ∂μ |
| · linarith [Real.sqrt_nonneg (variance f μ / p)] |
| have hc : 0 < a - ∫ x, f x ∂μ := sub_pos.mpr (lt_of_not_ge ha) |
| have hsub : {x | a ≤ f x} ⊆ |
| {x | a - (∫ x, f x ∂μ) ≤ |f x - (∫ x, f x ∂μ)|} := by |
| intro x hx |
| change a ≤ f x at hx |
| exact (sub_le_sub_right hx _).trans (le_abs_self _) |
| have hm := meas_ge_le_variance_div_sq hf hc |
| have hr := ENNReal.toReal_mono ENNReal.ofReal_ne_top hm |
| rw [ENNReal.toReal_ofReal (div_nonneg (variance_nonneg _ _) (sq_nonneg _))] at hr |
| have hreal : p ≤ variance f μ / (a - (∫ x, f x ∂μ)) ^ 2 := |
| hprob.trans ((measureReal_mono hsub).trans hr) |
| rw [le_div_iff₀ (sq_pos_of_pos hc)] at hreal |
| have hs := Real.sq_sqrt (div_nonneg (variance_nonneg f μ) (le_of_lt hp)) |
| have he : p * Real.sqrt (variance f μ / p)^2 = variance f μ := by |
| rw [hs]; field_simp |
| have hle : a - (∫ x, f x ∂μ) ≤ Real.sqrt (variance f μ / p) := by |
| have hz := Real.sqrt_nonneg (variance f μ / p) |
| have hc2 := (mul_le_mul_iff_of_pos_left hp).mp (hreal.trans_eq he.symm) |
| nlinarith |
| linarith |
| |
| lemma integral_log_partition_le_log_mean (β : ℝ) {n : ℕ} (hn : 0 < n) : |
| (∫ g, Real.log (partition (sampledInteraction g)) ∂disorderLaw β n) ≤ |
| Real.log (∫ g, partition (sampledInteraction g) ∂disorderLaw β n) := by |
| let μ := disorderLaw β n |
| let : IsProbabilityMeasure μ := by dsimp [μ, disorderLaw]; infer_instance |
| let m := ∫ g, partition (sampledInteraction g) ∂μ |
| have hm : 0 < m := by dsimp [m, μ]; rw [integral_partition_sampled β hn]; positivity |
| have hi := integral_mono (memLp_log_partition β n |>.integrable one_le_two) |
| ((integrable_const (Real.log m)).add |
| ((integrable_partition_sampled β n).div_const m) |>.sub (integrable_const 1)) |
| (fun g => show Real.log (partition (sampledInteraction g)) ≤ |
| Real.log m + partition (sampledInteraction g) / m - 1 from by |
| have hl := Real.log_le_sub_one_of_pos (div_pos (partition_pos (sampledInteraction g)) hm) |
| rw [Real.log_div (ne_of_gt (partition_pos _)) (ne_of_gt hm)] at hl |
| linarith) |
| simp only [Pi.sub_apply, Pi.add_apply] at hi |
| rw [integral_sub (f := fun g => Real.log m + partition (sampledInteraction g) / m) |
| (g := fun _ => 1) ((integrable_const _).add ((integrable_partition_sampled β n).div_const _)) |
| (integrable_const _), integral_add (integrable_const _) |
| ((integrable_partition_sampled β n).div_const _), integral_const, integral_const, |
| integral_div] at hi |
| change (∫ g, Real.log (partition (sampledInteraction g)) ∂μ) ≤ |
| μ.real Set.univ • Real.log m + m / m - μ.real Set.univ • 1 at hi |
| simpa [ne_of_gt hm] using hi |
| |
| lemma integral_log_partition_ge_log_mean (β : ℝ) (hβ : β ^ 2 < 1) |
| {n : ℕ} (hn : 0 < n) : |
| Real.log (∫ g, partition (sampledInteraction g) ∂disorderLaw β n) - Real.log 2 - |
| Real.sqrt (β ^ 2 * n / (Real.sqrt (1 - β ^ 2) / 4)) ≤ |
| ∫ g, Real.log (partition (sampledInteraction g)) ∂disorderLaw β n := by |
| let μ := disorderLaw β n |
| let : IsProbabilityMeasure μ := by dsimp [μ, disorderLaw]; infer_instance |
| let m := ∫ g, partition (sampledInteraction g) ∂μ |
| have hm : 0 < m := by dsimp [m, μ]; rw [integral_partition_sampled β hn]; positivity |
| have hp : 0 < Real.sqrt (1 - β ^ 2) / 4 := by |
| exact div_pos (Real.sqrt_pos.2 (by linarith)) (by norm_num) |
| have hprob := partition_half_mean_probability β hβ hn |
| have he : {g : GaussianCoordinates n | m / 2 ≤ partition (sampledInteraction g)} = |
| {g : GaussianCoordinates n | Real.log m - Real.log 2 ≤ Real.log (partition (sampledInteraction g))} := by |
| ext g |
| rw [← Real.log_div (ne_of_gt hm) (by norm_num)] |
| exact (Real.log_le_log_iff (by positivity) (partition_pos _)).symm |
| change Real.sqrt (1 - β ^ 2) / 4 ≤ μ.real {g | m / 2 ≤ partition (sampledInteraction g)} at hprob |
| rw [he] at hprob |
| have hv := variance_log_partition_le β hn |
| have hs := Real.sqrt_le_sqrt (div_le_div_of_nonneg_right hv (le_of_lt hp)) |
| have hl := mean_ge_of_upper_event μ (memLp_log_partition β n) hp hprob |
| dsimp [m, μ] at hl hs ⊢ |
| linarith |
| |
| lemma square_integral_shift {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {f : Ω → ℝ} (hf : MemLp f 2 μ) (a : ℝ) : |
| (∫ x, (f x - a)^2 ∂μ) = variance f μ + ((∫ x, f x ∂μ) - a)^2 := by |
| have hs : MemLp (fun x => f x - a) 2 μ := hf.sub (memLp_const a) |
| have hv := variance_eq_sub hs |
| rw [variance_sub_const hf.aestronglyMeasurable] at hv |
| simp only [Pi.pow_apply] at hv |
| rw [integral_sub (hf.integrable one_le_two) (integrable_const _), integral_const] at hv |
| simp only [measureReal_def, measure_univ, ENNReal.toReal_one, one_smul] at hv |
| linarith |
| |
| lemma second_moment_log_partition_centered_le (β : ℝ) (hβ : β ^ 2 < 1) |
| {n : ℕ} (hn : 0 < n) : |
| (∫ g, (Real.log (partition (sampledInteraction g)) - |
| Real.log (∫ h, partition (sampledInteraction h) ∂disorderLaw β n)) ^ 2 |
| ∂disorderLaw β n) ≤ |
| (β ^ 2 + 2 * β ^ 2 / (Real.sqrt (1 - β ^ 2) / 4)) * n + 2 * (Real.log 2)^2 := by |
| let μ := disorderLaw β n |
| let : IsProbabilityMeasure μ := by dsimp [μ, disorderLaw]; infer_instance |
| let c := Real.log (∫ g, partition (sampledInteraction g) ∂μ) |
| let m := ∫ g, Real.log (partition (sampledInteraction g)) ∂μ |
| let p := Real.sqrt (1 - β ^ 2) / 4 |
| have hp : 0 < p := by dsimp [p]; positivity |
| have hs : Real.sqrt (β ^ 2 * n / p)^2 = β ^ 2 * n / p := |
| Real.sq_sqrt (by positivity) |
| have hmUpper := integral_log_partition_le_log_mean β hn |
| have hmLower := integral_log_partition_ge_log_mean β hβ hn |
| change m ≤ c at hmUpper |
| change c - Real.log 2 - Real.sqrt (β ^ 2 * n / p) ≤ m at hmLower |
| have hlog : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num) |
| have hsq : (m-c)^2 ≤ 2 * (Real.log 2)^2 + 2 * β ^ 2 * n / p := by |
| have hm0 : 0 ≤ c-m := sub_nonneg.mpr hmUpper |
| have hms : c-m ≤ Real.log 2 + Real.sqrt (β ^ 2 * n / p) := by linarith |
| have hmsq := sq_le_sq₀ hm0 (by positivity : 0 ≤ Real.log 2 + Real.sqrt (β^2*n/p)) |>.mpr hms |
| have hh : 2 * β ^ 2 * (n : ℝ) / p = 2 * (β ^ 2 * n / p) := by ring |
| rw [hh] |
| nlinarith [sq_nonneg (Real.log 2 - Real.sqrt (β^2*n/p))] |
| rw [square_integral_shift μ (memLp_log_partition β n) c] |
| have hv := variance_log_partition_le β hn |
| change variance (fun g => Real.log (partition (sampledInteraction g))) μ ≤ β^2*n at hv |
| change variance (fun g => Real.log (partition (sampledInteraction g))) μ + (m-c)^2 ≤ _ |
| calc |
| _ ≤ β^2*n + (2 * (Real.log 2)^2 + 2 * β^2*n/p) := add_le_add hv hsq |
| _ = _ := by dsimp [p]; ring |
| |
| end SKGapCutoff |
| end |
| |
| end OAI |
| |
