| import Mathlib |
| import OAI.Probability.JammingConcavity.GaussianColeHopf |
|
|
| namespace OAI |
|
|
| /-! Cascade Normalization. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Set |
| open scoped NNReal ENNReal |
| open Set Filter |
| open scoped Topology |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
| open MeasureTheory Filter Set |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| def CascadeTree : ℕ → Type |
| | 0 => Unit |
| | k+1 => PointCloud (CascadeTree k) |
|
|
| instance cascadeTreeMeasurable : (k : ℕ) → MeasurableSpace (CascadeTree k) |
| | 0 => inferInstanceAs (MeasurableSpace Unit) |
| | k+1 => by |
| letI := cascadeTreeMeasurable k |
| exact inferInstanceAs (MeasurableSpace (PointCloud (CascadeTree k))) |
|
|
| def cascadeLaw : (ms : List ℝ) → Measure (CascadeTree ms.length) |
| | [] => Measure.dirac () |
| | _::ms => pointCloudLaw (cascadeLaw ms) |
|
|
| def cascadeTotal : (ms : List ℝ) → CascadeTree ms.length → ℝ≥0∞ |
| | [], _ => 1 |
| | m::ms, ω => pointCloudFunctional |
| (fun z => ENNReal.ofReal (z.1 ^ (-1/m)) * cascadeTotal ms z.2) ω |
|
|
| def CascadeNormalizationStatement : Prop := |
| ∀ ms : List ℝ, ms.Pairwise (· < ·) → (∀ m ∈ ms, 0 < m ∧ m < 1) → |
| (∀ᵐ ω ∂cascadeLaw ms, 0 < cascadeTotal ms ω ∧ cascadeTotal ms ω < ∞) ∧ |
| Integrable (fun ω => |Real.log (cascadeTotal ms ω).toReal|^2) (cascadeLaw ms) |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open MeasureTheory ProbabilityTheory Set |
| open scoped ENNReal NNReal BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| def mapPoissonBin {X Y : Type*} (f : X → Y) (z : PoissonBin X) : PoissonBin Y := |
| (z.1, fun j => f (z.2 j)) |
|
|
| lemma measurable_mapPoissonBin {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| {f : X → Y} (hf : Measurable f) : Measurable (mapPoissonBin f) := by |
| apply measurable_fst.prodMk |
| exact Measurable.of_eval fun index => hf.comp ((measurable_pi_apply index).comp measurable_snd) |
|
|
| lemma poissonBinLaw_map {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| (ν : Measure X) [IsProbabilityMeasure ν] {f : X → Y} (hf : Measurable f) : |
| (poissonBinLaw ν).map (mapPoissonBin f) = poissonBinLaw (ν.map f) := by |
| unfold poissonBinLaw mapPoissonBin |
| change Measure.map (Prod.map id (fun (z : ℕ → X) (j : ℕ) => f (z j))) _ = _ |
| rw [← Measure.map_prod_map _ _ measurable_id (by fun_prop), Measure.map_id, |
| Measure.infinitePi_map_pi (fun _ : ℕ => ν) (fun _ => hf)] |
|
|
| lemma poissonSeriesLaw_map {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| (ν : Measure X) [IsProbabilityMeasure ν] {f : X → Y} (hf : Measurable f) : |
| (poissonSeriesLaw ν).map (fun ω n => mapPoissonBin f (ω n)) = |
| poissonSeriesLaw (ν.map f) := by |
| unfold poissonSeriesLaw |
| rw [Measure.infinitePi_map_pi (fun _ : ℕ => poissonBinLaw ν) (fun _ => measurable_mapPoissonBin hf)] |
| simp_rw [poissonBinLaw_map ν hf] |
|
|
| def mapPointCloud {A B : Type*} (f : A → B) (ω : PointCloud A) : PointCloud B := |
| fun n => mapPoissonBin (Prod.map id f) (ω n) |
|
|
| lemma measurable_mapPointCloud {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| {f : A → B} (hf : Measurable f) : Measurable (mapPointCloud f) := by |
| apply Measurable.of_eval |
| intro n |
| exact (measurable_mapPoissonBin (measurable_id.prodMap hf)).comp (measurable_pi_apply n) |
|
|
| lemma pointCloudLaw_map {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (ν : Measure A) [IsProbabilityMeasure ν] {f : A → B} (hf : Measurable f) : |
| (pointCloudLaw ν).map (mapPointCloud f) = pointCloudLaw (ν.map f) := by |
| unfold pointCloudLaw mapPointCloud |
| rw [poissonSeriesLaw_map _ (measurable_id.prodMap hf), |
| ← Measure.map_prod_map _ _ measurable_id hf, Measure.map_id] |
| end MicroscopicJamming |
|
|
| |
| |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| lemma integrable_one_sub_expNeg {X : Type*} [MeasurableSpace X] (μ : Measure X) |
| [IsProbabilityMeasure μ] {F : X → ℝ≥0∞} (hF : Measurable F) : |
| Integrable (fun x => 1-expNeg (F x)) μ := |
| (integrable_const 1).sub (integrable_expNeg μ hF) |
|
|
| lemma poisson_series_laplace_general {X : Type*} [MeasurableSpace X] (μ : Measure X) |
| [IsProbabilityMeasure μ] (F : ℕ → X → ℝ≥0∞) (hF : ∀ n, Measurable (F n)) : |
| (∫ ω, expNeg (∑' n : ℕ, poissonBinSum (F n) (ω n)) ∂poissonSeriesLaw μ) = |
| expNeg (∑' n : ℕ, ∫⁻ x, ENNReal.ofReal (1-expNeg (F n x)) ∂μ) := by |
| have hnonneg : ∀ n : ℕ, 0 ≤ ∫ x, 1-expNeg (F n x) ∂μ := fun n => |
| integral_nonneg (fun x => sub_nonneg.mpr (expNeg_le_one _)) |
| have hfinite : ∀ k : ℕ, |
| (∫ ω, expNeg (∑ n ∈ Finset.range k, poissonBinSum (F n) (ω n)) ∂poissonSeriesLaw μ) = |
| expNeg (∑ n ∈ Finset.range k, ∫⁻ x, ENNReal.ofReal (1-expNeg (F n x)) ∂μ) := by |
| intro k |
| simp only [expNeg_sum, poissonSeriesLaw] |
| rw [iid_prefix_product_varying (poissonBinLaw μ) |
| (fun n z => expNeg (poissonBinSum (F n) z)) |
| (fun n => continuous_expNeg.measurable.comp (measurable_poissonBinSum (hF n)))] |
| apply Finset.prod_congr rfl |
| intro n hn |
| rw [poissonBin_laplace μ (hF n)] |
| rw [← ofReal_integral_eq_lintegral_ofReal (integrable_one_sub_expNeg μ (hF n)) |
| (Filter.Eventually.of_forall fun x => sub_nonneg.mpr (expNeg_le_one _)), |
| expNeg_ofReal (hnonneg n)] |
| have h₁ := integral_expNeg_tsum (poissonSeriesLaw μ) |
| (fun n ω => poissonBinSum (F n) (ω n)) |
| (fun n => (measurable_poissonBinSum (hF n)).comp (measurable_pi_apply n)) |
| have h₂ := continuous_expNeg.continuousAt.tendsto.comp |
| (ENNReal.tendsto_nat_tsum (fun n => ∫⁻ x, ENNReal.ofReal (1-expNeg (F n x)) ∂μ)) |
| exact tendsto_nhds_unique h₁ (h₂.congr (fun k => (hfinite k).symm)) |
| end MicroscopicJamming |
|
|
| |
| |
| open MeasureTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
| lemma lintegral_unit_shift {f : ℝ → ℝ≥0∞} (hf : Measurable f) (n : ℕ) : |
| (∫⁻ u in Ico (0:ℝ) 1, f ((n:ℝ)+u)) = ∫⁻ x in Ioc (n:ℝ) ((n:ℝ)+1), f x := by |
| rw [restrict_Ico_eq_restrict_Ioc] |
| have he : (fun u : ℝ => (n:ℝ)+u) ⁻¹' Ioc (n:ℝ) ((n:ℝ)+1) = Ioc 0 1 := by |
| ext u; simp only [mem_preimage, mem_Ioc]; constructor <;> intro h <;> constructor <;> linarith [h.1,h.2] |
| rw [← he, ← setLIntegral_map measurableSet_Ioc hf (by fun_prop), |
| MeasureTheory.Measure.IsAddLeftInvariant.map_add_left_eq_self] |
|
|
| lemma tsum_lintegral_unit_shifts {f : ℝ → ℝ≥0∞} (hf : Measurable f) : |
| (∑' n : ℕ, ∫⁻ u in Ico (0:ℝ) 1, f ((n:ℝ)+u)) = ∫⁻ x in Ioi 0, f x := by |
| simp_rw [lintegral_unit_shift hf] |
| rw [← lintegral_iUnion (fun n : ℕ => measurableSet_Ioc) unit_bins_disjoint, |
| unit_bins_union] |
|
|
| lemma lintegral_Ioi_div {f : ℝ → ℝ≥0∞} (hf : Measurable f) {c : ℝ} (hc : 0 < c) : |
| (∫⁻ x in Ioi (0:ℝ), f (x/c)) = ENNReal.ofReal c * ∫⁻ x in Ioi 0, f x := by |
| have he : (fun x : ℝ => x/c) ⁻¹' Ioi (0:ℝ) = Ioi 0 := by |
| ext x; simp [div_pos_iff_of_pos_right hc] |
| have hm : Measure.map (fun x : ℝ => x/c) volume = ENNReal.ofReal c • volume := by |
| simp only [div_eq_mul_inv] |
| rw [Real.map_volume_mul_right (inv_ne_zero hc.ne'), inv_inv, abs_of_pos hc] |
| conv_lhs => rw [← he, ← setLIntegral_map measurableSet_Ioi hf (by fun_prop), hm, |
| Measure.restrict_smul, lintegral_smul_measure] |
| rfl |
| end MicroscopicJamming |
|
|
| |
| |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
| instance pointCloudLaw_probability {A : Type*} [MeasurableSpace A] |
| (ν : Measure A) [IsProbabilityMeasure ν] : IsProbabilityMeasure (pointCloudLaw ν) := by |
| unfold pointCloudLaw; infer_instance |
|
|
| lemma measurable_pointCloudFunctional {A : Type*} [MeasurableSpace A] |
| {f : ℝ × A → ℝ≥0∞} (hf : Measurable f) : Measurable (pointCloudFunctional f) := by |
| unfold pointCloudFunctional |
| apply Measurable.tsum |
| intro n |
| exact (measurable_poissonBinSum (hf.comp (by fun_prop))).comp (measurable_pi_apply n) |
|
|
| lemma pointCloud_laplace {A : Type*} [MeasurableSpace A] (ν : Measure A) |
| [IsProbabilityMeasure ν] {f : ℝ × A → ℝ≥0∞} (hf : Measurable f) : |
| (∫ ω, expNeg (pointCloudFunctional f ω) ∂pointCloudLaw ν) = |
| expNeg (∫⁻ z, ENNReal.ofReal (1-expNeg (f z)) ∂(volume.restrict (Ioi 0)).prod ν) := by |
| change (∫ ω, expNeg (∑' n : ℕ, poissonBinSum |
| (fun z : ℝ × A => f ((n:ℝ)+z.1,z.2)) (ω n)) ∂poissonSeriesLaw (cloudUniform.prod ν)) = _ |
| rw [poisson_series_laplace_general] |
| · congr 1 |
| have hg : Measurable (fun z : ℝ × A => ENNReal.ofReal (1-expNeg (f z))) := by |
| exact (measurable_const.sub (continuous_expNeg.measurable.comp hf)).ennreal_ofReal |
| have hn (n : ℕ) : |
| (∫⁻ z, ENNReal.ofReal (1-expNeg (f ((n:ℝ)+z.1,z.2))) ∂cloudUniform.prod ν) = |
| ∫⁻ u in Ico (0:ℝ) 1, ∫⁻ a, ENNReal.ofReal (1-expNeg (f ((n:ℝ)+u,a))) ∂ν := |
| lintegral_prod _ ((hg.comp (measurable_fst.const_add (n:ℝ) |>.prodMk measurable_snd)).aemeasurable) |
| simp_rw [hn] |
| rw [lintegral_prod _ hg.aemeasurable] |
| exact tsum_lintegral_unit_shifts hg.lintegral_prod_right' |
| · intro n; exact hf.comp (by fun_prop) |
| end MicroscopicJamming |
|
|
| |
| |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| lemma laplace_ae_ne_top {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {S : Ω → ℝ≥0∞} (hS : Measurable S) |
| {c m : ℝ} (hm : 0 < m) |
| (hL : ∀ t : ℝ, 0 ≤ t → (∫ ω, expNeg (ENNReal.ofReal t*S ω) ∂μ) = |
| Real.exp (-c*t^m)) : ∀ᵐ ω ∂μ, S ω ≠ ∞ := by |
| let f : Ω → ℝ := fun ω => if S ω = ∞ then 0 else 1 |
| have hf : Measurable f := Measurable.ite (hS (measurableSet_singleton ∞)) measurable_const measurable_const |
| have hfi : Integrable f μ := Integrable.of_bound hf.aestronglyMeasurable 1 |
| (Filter.Eventually.of_forall fun ω => by unfold f; split_ifs <;> norm_num) |
| have hconv : Tendsto (fun n : ℕ => ∫ ω, |
| expNeg (ENNReal.ofReal (1/((n:ℝ)+1))*S ω) ∂μ) atTop (𝓝 (∫ ω, f ω ∂μ)) := by |
| apply tendsto_integral_of_dominated_convergence (fun _ => 1) |
| · intro n; exact (continuous_expNeg.measurable.comp (by fun_prop)).aestronglyMeasurable |
| · exact integrable_const 1 |
| · intro n; exact Filter.Eventually.of_forall fun _ => expNeg_norm_le _ |
| · apply Filter.Eventually.of_forall |
| intro ω |
| have ht : ∀ n : ℕ, 0 < 1/((n:ℝ)+1) := fun _ => by positivity |
| by_cases hs : S ω = ∞ |
| · have he : ∀ n : ℕ, expNeg (ENNReal.ofReal (1/((n:ℝ)+1))*S ω) = 0 := by |
| intro n |
| rw [hs, ENNReal.mul_top (ENNReal.ofReal_pos.mpr (ht n)).ne', expNeg_top] |
| have hfω : f ω = 0 := by simp [f, hs] |
| simpa only [he, hfω] using |
| (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℝ)) atTop (𝓝 0)) |
| · have he : ∀ n : ℕ, |
| expNeg (ENNReal.ofReal (1/((n:ℝ)+1))*S ω) = |
| Real.exp (-(1/((n:ℝ)+1))*(S ω).toReal) := by |
| intro n |
| rw [expNeg_eq_of_ne_top (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hs), |
| ENNReal.toReal_mul, ENNReal.toReal_ofReal (ht n).le] |
| congr 1; ring |
| simp_rw [he] |
| simpa [f, hs, Function.comp_def] using Real.continuous_exp.continuousAt.tendsto.comp |
| (tendsto_one_div_add_atTop_nhds_zero_nat.neg.mul_const (S ω).toReal) |
| have hval : Tendsto (fun n : ℕ => ∫ ω, |
| expNeg (ENNReal.ofReal (1/((n:ℝ)+1))*S ω) ∂μ) atTop (𝓝 (1:ℝ)) := by |
| have he : ∀ n : ℕ, (∫ ω, expNeg (ENNReal.ofReal (1/((n:ℝ)+1))*S ω) ∂μ) = |
| Real.exp (-c*(1/((n:ℝ)+1))^m) := fun n => hL _ (by positivity) |
| simp_rw [he] |
| have hpow := (Real.continuous_rpow_const hm.le).continuousAt.tendsto.comp |
| (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)) |
| simpa [Real.zero_rpow hm.ne', Function.comp_def] using |
| Real.continuous_exp.continuousAt.tendsto.comp (hpow.const_mul (-c)) |
| have heq : (∫ ω, f ω ∂μ) = 1 := tendsto_nhds_unique hconv hval |
| have hz : (∫ ω, 1-f ω ∂μ) = 0 := by rw [integral_sub (integrable_const 1) hfi, heq]; simp |
| have hae := (integral_eq_zero_iff_of_nonneg_ae |
| (Filter.Eventually.of_forall (fun ω => by change 0 ≤ 1-f ω; unfold f; split_ifs <;> norm_num)) |
| ((integrable_const 1).sub hfi)).mp hz |
| filter_upwards [hae] with ω hω |
| by_contra hs |
| simp [f, hs] at hω |
|
|
| lemma laplace_real_ae_pos {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : Measurable X) (h0 : ∀ ω, 0 ≤ X ω) |
| {c m : ℝ} (hc : 0 < c) (hm : 0 < m) |
| (hL : ∀ t : ℝ, 0 ≤ t → (∫ ω, Real.exp (-t*X ω) ∂μ) = |
| Real.exp (-c*t^m)) : ∀ᵐ ω ∂μ, 0 < X ω := by |
| let f : Ω → ℝ := fun ω => if X ω = 0 then 1 else 0 |
| have hf : Measurable f := Measurable.ite (hX (measurableSet_singleton 0)) measurable_const measurable_const |
| have hfi : Integrable f μ := Integrable.of_bound hf.aestronglyMeasurable 1 |
| (Filter.Eventually.of_forall fun ω => by unfold f; split_ifs <;> norm_num) |
| have hn : Tendsto (fun n : ℕ => (n:ℝ)+1) atTop atTop := |
| tendsto_atTop_add_const_right _ 1 tendsto_natCast_atTop_atTop |
| have hconv : Tendsto (fun n : ℕ => ∫ ω, |
| Real.exp (-((n:ℝ)+1)*X ω) ∂μ) atTop (𝓝 (∫ ω, f ω ∂μ)) := by |
| apply tendsto_integral_of_dominated_convergence (fun _ => 1) |
| · intro n; fun_prop |
| · exact integrable_const 1 |
| · intro n; apply Filter.Eventually.of_forall |
| intro ω |
| rw [Real.norm_of_nonneg (Real.exp_pos _).le] |
| exact Real.exp_le_one_iff.mpr (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (by positivity)) (h0 ω)) |
| · apply Filter.Eventually.of_forall |
| intro ω |
| by_cases hx : X ω = 0 |
| · simp only [hx, mul_zero, Real.exp_zero, f] |
| exact tendsto_const_nhds |
| · have hp : 0 < X ω := lt_of_le_of_ne (h0 ω) (Ne.symm hx) |
| have hh := Real.tendsto_exp_atBot.comp (hn.const_mul_atTop_of_neg (neg_lt_zero.mpr hp)) |
| rw [show f ω = 0 by simp [f, hx]] |
| convert hh using 1 |
| funext n; congr 1; ring |
| have hval : Tendsto (fun n : ℕ => ∫ ω, |
| Real.exp (-((n:ℝ)+1)*X ω) ∂μ) atTop (𝓝 (0:ℝ)) := by |
| have he : ∀ n : ℕ, (∫ ω, Real.exp (-((n:ℝ)+1)*X ω) ∂μ) = |
| Real.exp (-c*((n:ℝ)+1)^m) := fun n => hL _ (by positivity) |
| simp_rw [he] |
| exact Real.tendsto_exp_atBot.comp ((tendsto_rpow_atTop hm).comp hn |>.const_mul_atTop_of_neg |
| (neg_lt_zero.mpr hc)) |
| have heq : (∫ ω, f ω ∂μ) = 0 := tendsto_nhds_unique hconv hval |
| have hae := (integral_eq_zero_iff_of_nonneg_ae |
| (Filter.Eventually.of_forall (fun ω => by change 0 ≤ f ω; unfold f; split_ifs <;> norm_num)) hfi).mp heq |
| filter_upwards [hae] with ω hω |
| have hne : X ω ≠ 0 := by intro he; simp [f, he] at hω |
| exact lt_of_le_of_ne (h0 ω) (Ne.symm hne) |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| lemma integrable_exp_neg_mul {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : Measurable X) (h0 : ∀ ω, 0 ≤ X ω) |
| {t : ℝ} (ht : 0 ≤ t) : Integrable (fun ω => Real.exp (-t*X ω)) μ := by |
| apply Integrable.of_bound (by fun_prop) 1 |
| apply Filter.Eventually.of_forall |
| intro ω |
| rw [Real.norm_of_nonneg (Real.exp_pos _).le] |
| exact Real.exp_le_one_iff.mpr (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr ht) (h0 ω)) |
|
|
| lemma stable_positive_moment {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : Measurable X) (h0 : ∀ ω, 0 ≤ X ω) |
| {c m : ℝ} (hc : 0 ≤ c) (hm : 0 < m) (hm1 : m < 1) |
| (hL : ∀ t : ℝ, 0 ≤ t → (∫ ω, Real.exp (-t*X ω) ∂μ) = Real.exp (-c*t^m)) |
| {a : ℝ} (ha : 0 < a) (ham : a < m) : Integrable (fun ω => (X ω)^a) μ := by |
| let K : ℝ × Ω → ℝ := fun z => 1-Real.exp (-(z.1^(-1/a))*X z.2) |
| have hK : Measurable K := by unfold K; fun_prop |
| have hK0 : ∀ x : ℝ, 0 < x → ∀ ω, 0 ≤ K (x,ω) := by |
| intro x hx ω |
| exact sub_nonneg.mpr (Real.exp_le_one_iff.mpr |
| (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Real.rpow_nonneg hx.le _)) (h0 ω))) |
| have hKi : ∀ x : ℝ, 0 < x → Integrable (fun ω => K (x,ω)) μ := by |
| intro x hx |
| exact (integrable_const 1).sub (integrable_exp_neg_mul μ hX h0 (Real.rpow_nonneg hx.le _)) |
| have hKval : ∀ x : ℝ, 0 < x → (∫ ω, K (x,ω) ∂μ) = |
| 1-Real.exp (-c*x^(-1/(a/m))) := by |
| intro x hx |
| unfold K |
| rw [integral_sub (integrable_const 1) |
| (integrable_exp_neg_mul μ hX h0 (Real.rpow_nonneg hx.le _)), hL _ (Real.rpow_nonneg hx.le _)] |
| simp only [integral_const, probReal_univ, smul_eq_mul, one_mul] |
| rw [← Real.rpow_mul hx.le] |
| congr 3 |
| field_simp |
| have hip : Integrable K ((volume.restrict (Ioi 0)).prod μ) := by |
| apply (integrable_prod_iff hK.aestronglyMeasurable).mpr |
| refine ⟨?_, ?_⟩ |
| · filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx using hKi x hx |
| · apply (stable_integrable (div_pos ha hm) ((div_lt_one hm).mpr ham) hc).congr |
| filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx |
| rw [← hKval x hx] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun ω => (Real.norm_of_nonneg (hK0 x hx ω)).symm |
| have hinner : ∀ ω, (∫ x in Ioi (0:ℝ), K (x,ω)) = Real.Gamma (1-a)*(X ω)^a := by |
| intro ω |
| have he : (fun x : ℝ => K (x,ω)) = |
| (fun x : ℝ => 1-Real.exp (-(X ω)*x^(-1/a))) := by |
| funext x; unfold K; congr 2; ring |
| rw [he, stable_integral ha (ham.trans hm1) (h0 ω)] |
| have hi := hip.integral_prod_right |
| simp_rw [hinner] at hi |
| have hγ : Real.Gamma (1-a) ≠ 0 := (Real.Gamma_pos_of_pos (by linarith : 0 < 1-a)).ne' |
| convert hi.const_mul (Real.Gamma (1-a))⁻¹ using 1 |
| funext ω |
| simp [hγ] |
|
|
| lemma stable_negative_moment {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : Measurable X) (h0 : ∀ ω, 0 ≤ X ω) |
| (hpos : ∀ᵐ ω ∂μ, 0 < X ω) {c m : ℝ} (hc : 0 < c) (hm : 0 < m) |
| (hL : ∀ t : ℝ, 0 ≤ t → (∫ ω, Real.exp (-t*X ω) ∂μ) = Real.exp (-c*t^m)) |
| {a : ℝ} (ha : 0 < a) : Integrable (fun ω => (X ω)^(-a)) μ := by |
| let K : ℝ × Ω → ℝ := fun z => Real.exp (-(z.1^(1/a))*X z.2) |
| have hK : Measurable K := by unfold K; fun_prop |
| have hKi : ∀ x : ℝ, 0 < x → Integrable (fun ω => K (x,ω)) μ := by |
| intro x hx |
| exact integrable_exp_neg_mul μ hX h0 (Real.rpow_nonneg hx.le _) |
| have hKval : ∀ x : ℝ, 0 < x → (∫ ω, K (x,ω) ∂μ) = |
| Real.exp (-c*x^(m/a)) := by |
| intro x hx |
| unfold K |
| rw [hL _ (Real.rpow_nonneg hx.le _), ← Real.rpow_mul hx.le] |
| congr 2; ring_nf |
| have hiouter : IntegrableOn (fun x : ℝ => Real.exp (-c*x^(m/a))) (Ioi 0) := by |
| simpa using (integrableOn_rpow_mul_exp_neg_mul_rpow |
| (s := (0:ℝ)) (by norm_num) (div_pos hm ha) hc) |
| have hip : Integrable K ((volume.restrict (Ioi 0)).prod μ) := by |
| apply (integrable_prod_iff hK.aestronglyMeasurable).mpr |
| refine ⟨?_, ?_⟩ |
| · filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx using hKi x hx |
| · apply hiouter.congr |
| filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx |
| rw [← hKval x hx] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun ω => (Real.norm_of_nonneg (Real.exp_pos _).le).symm |
| have hinner : ∀ᵐ ω ∂μ, (∫ x in Ioi (0:ℝ), K (x,ω)) = |
| (X ω)^(-a)*Real.Gamma (a+1) := by |
| filter_upwards [hpos] with ω hω |
| have he : (fun x : ℝ => K (x,ω)) = |
| (fun x : ℝ => Real.exp (-(X ω)*x^(1/a))) := by |
| funext x; unfold K; congr 1; ring |
| rw [he, integral_exp_neg_mul_rpow (div_pos (by norm_num) ha) hω] |
| congr 2 <;> field_simp |
| have hi := hip.integral_prod_right.congr hinner |
| have hγ : Real.Gamma (a+1) ≠ 0 := (Real.Gamma_pos_of_pos (by linarith : 0 < a+1)).ne' |
| convert hi.mul_const (Real.Gamma (a+1))⁻¹ using 1 |
| funext ω |
| simp [hγ] |
| end MicroscopicJamming |
|
|
| |
| |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| lemma log_square_le_powers {x a : ℝ} (hx : 0 < x) (ha : 0 < a) : |
| |Real.log x|^2 ≤ ((a/2)^2)⁻¹*(x^a+x^(-a)) := by |
| let ε : ℝ := a/2 |
| have hε : 0 < ε := by dsimp [ε]; positivity |
| have h₁ : ε*Real.log x ≤ x^ε := by |
| have h := Real.log_le_rpow_div hx.le hε |
| simpa only [mul_comm] using (le_div_iff₀ hε).mp h |
| have h₂ : -(ε*Real.log x) ≤ x^(-ε) := by |
| have h := (le_div_iff₀ hε).mp (Real.log_le_rpow_div (inv_nonneg.mpr hx.le) hε) |
| rw [Real.log_inv, Real.inv_rpow hx.le, ← Real.rpow_neg hx.le] at h |
| nlinarith |
| have hp₁ : (x^ε)^2 = x^a := by |
| rw [← Real.rpow_natCast, ← Real.rpow_mul hx.le] |
| congr 1; dsimp [ε]; ring |
| have hp₂ : (x^(-ε))^2 = x^(-a) := by |
| rw [← Real.rpow_natCast, ← Real.rpow_mul hx.le] |
| congr 1; dsimp [ε]; ring |
| have hb : (ε*Real.log x)^2 ≤ x^a+x^(-a) := by |
| by_cases h : 0 ≤ ε*Real.log x |
| · have hh := pow_le_pow_left₀ h h₁ 2 |
| rw [hp₁] at hh |
| exact hh.trans (le_add_of_nonneg_right (Real.rpow_nonneg hx.le _)) |
| · have hh := pow_le_pow_left₀ (neg_nonneg.mpr (le_of_not_ge h)) h₂ 2 |
| rw [neg_sq, hp₂] at hh |
| exact hh.trans (le_add_of_nonneg_left (Real.rpow_nonneg hx.le _)) |
| rw [sq_abs, mul_comm ((a/2)^2)⁻¹, ← div_eq_mul_inv] |
| apply (le_div_iff₀ (sq_pos_of_pos hε)).mpr |
| change (Real.log x)^2 * ε^2 ≤ _ |
| nlinarith |
|
|
| lemma integrable_log_square {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| {X : Ω → ℝ} (hX : Measurable X) (hpos : ∀ᵐ ω ∂μ, 0 < X ω) |
| {a : ℝ} (ha : 0 < a) (hplus : Integrable (fun ω => (X ω)^a) μ) |
| (hminus : Integrable (fun ω => (X ω)^(-a)) μ) : |
| Integrable (fun ω => |Real.log (X ω)|^2) μ := by |
| apply ((hplus.add hminus).const_mul ((a/2)^2)⁻¹).mono' (hX.log.abs.pow_const 2).aestronglyMeasurable |
| filter_upwards [hpos] with ω hω |
| rw [Real.norm_of_nonneg (sq_nonneg _)] |
| exact log_square_le_powers hω ha |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| theorem stableCloud : StableCloudStatement := by |
| intro m hm hm1 ν hprob hν hmean |
| let : IsProbabilityMeasure ν := hprob |
| let c : ℝ := Real.Gamma (1-m)*(∫ y : ℝ≥0, (y:ℝ)^m ∂ν) |
| have hc : 0 < c := mul_pos (Real.Gamma_pos_of_pos (by linarith)) hmean |
| have hExt : ∀ t : ℝ, 0 ≤ t → (∫ ω, expNeg (ENNReal.ofReal t*stableCloudSum m ω) |
| ∂markedCloudLaw ν) = Real.exp (-c*t^m) := by |
| intro t ht |
| rw [cloud_laplace_extended hm hm1 ν hν ht] |
| congr 1; dsimp [c]; ring |
| have hfin := laplace_ae_ne_top (markedCloudLaw ν) (measurable_stableCloudSum m) hm hExt |
| have hX : Measurable (fun ω => (stableCloudSum m ω).toReal) := |
| (measurable_stableCloudSum m).ennreal_toReal |
| have hL : ∀ t : ℝ, 0 ≤ t → (∫ ω, Real.exp (-t*(stableCloudSum m ω).toReal) |
| ∂markedCloudLaw ν) = Real.exp (-c*t^m) := by |
| intro t ht |
| rw [← hExt t ht] |
| apply integral_congr_ae |
| filter_upwards [hfin] with ω hω |
| rw [expNeg_eq_of_ne_top (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hω), |
| ENNReal.toReal_mul, ENNReal.toReal_ofReal ht] |
| congr 1; ring |
| have hpos := laplace_real_ae_pos (markedCloudLaw ν) hX |
| (fun _ => ENNReal.toReal_nonneg) hc hm hL |
| have hplus : ∀ a : ℝ, 0 < a → a < m → |
| Integrable (fun ω => (stableCloudSum m ω).toReal^a) (markedCloudLaw ν) := by |
| intro a ha ham |
| exact stable_positive_moment (markedCloudLaw ν) hX (fun _ => ENNReal.toReal_nonneg) |
| hc.le hm hm1 hL ha ham |
| have hminus : ∀ a : ℝ, 0 < a → |
| Integrable (fun ω => (stableCloudSum m ω).toReal^(-a)) (markedCloudLaw ν) := by |
| intro a ha |
| exact stable_negative_moment (markedCloudLaw ν) hX (fun _ => ENNReal.toReal_nonneg) |
| hpos hc hm hL ha |
| refine ⟨?_, ?_, hplus, hminus, ?_⟩ |
| · filter_upwards [hpos] with ω hω |
| exact ENNReal.toReal_pos_iff.mp hω |
| · intro t ht |
| rw [hL t ht] |
| congr 1; dsimp [c]; ring |
| · exact integrable_log_square (markedCloudLaw ν) hX hpos (div_pos hm (by norm_num)) |
| (hplus (m/2) (by positivity) (by linarith)) (hminus (m/2) (by positivity)) |
|
|
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| lemma pointCloud_mark_preserving {A : Type*} [MeasurableSpace A] (ν : Measure A) |
| [IsProbabilityMeasure ν] (n j : ℕ) : |
| MeasurePreserving (fun ω : PointCloud A => ((ω n).2 j).2) (pointCloudLaw ν) ν := by |
| have h₁ := measurePreserving_eval_infinitePi (fun _ : ℕ => poissonBinLaw (cloudUniform.prod ν)) n |
| have h₂ : MeasurePreserving Prod.snd (poissonBinLaw (cloudUniform.prod ν)) |
| (Measure.infinitePi (fun _ : ℕ => cloudUniform.prod ν)) := measurePreserving_snd |
| have h₃ := measurePreserving_eval_infinitePi (fun _ : ℕ => cloudUniform.prod ν) j |
| have h₄ : MeasurePreserving Prod.snd (cloudUniform.prod ν) ν := measurePreserving_snd |
| exact h₄.comp (h₃.comp (h₂.comp h₁)) |
|
|
| lemma ae_pointCloud_marks {A : Type*} [MeasurableSpace A] (ν : Measure A) |
| [IsProbabilityMeasure ν] {p : A → Prop} (hp : ∀ᵐ a ∂ν, p a) : |
| ∀ᵐ ω ∂pointCloudLaw ν, ∀ n j, p ((ω n).2 j).2 := by |
| rw [ae_all_iff] |
| intro n |
| rw [ae_all_iff] |
| intro j |
| exact (pointCloud_mark_preserving ν n j).quasiMeasurePreserving.ae hp |
|
|
| def coloredStableSum {A : Type*} (m : ℝ) (Y : A → ℝ≥0) (ω : PointCloud A) : ℝ≥0∞ := |
| pointCloudFunctional (fun z => ENNReal.ofReal (z.1^(-1/m)*(Y z.2:ℝ))) ω |
|
|
| lemma stableCloudSum_mapPointCloud {A : Type*} (m : ℝ) (Y : A → ℝ≥0) (ω : PointCloud A) : |
| stableCloudSum m (mapPointCloud Y ω) = coloredStableSum m Y ω := by |
| rw [stableCloudSum_bins] |
| rfl |
|
|
| lemma coloredStable_properties {A : Type*} [MeasurableSpace A] |
| (ν : Measure A) [IsProbabilityMeasure ν] {m : ℝ} (hm : 0 < m) (hm1 : m < 1) |
| {Y : A → ℝ≥0} (hY : Measurable Y) |
| (hi : Integrable (fun a => (Y a:ℝ)^m) ν) (hp : 0 < ∫ a, (Y a:ℝ)^m ∂ν) : |
| (∀ᵐ ω ∂pointCloudLaw ν, 0 < coloredStableSum m Y ω ∧ coloredStableSum m Y ω < ∞) ∧ |
| (∀ a : ℝ, 0 < a → a < m → Integrable (fun ω => (coloredStableSum m Y ω).toReal^a) (pointCloudLaw ν)) ∧ |
| Integrable (fun ω => |Real.log (coloredStableSum m Y ω).toReal|^2) (pointCloudLaw ν) := by |
| let η := ν.map Y |
| have : IsProbabilityMeasure η := inferInstance |
| have hpow : Measurable (fun y : ℝ≥0 => (y:ℝ)^m) := by fun_prop |
| have hiη : Integrable (fun y : ℝ≥0 => (y:ℝ)^m) η := |
| (integrable_map_measure hpow.aestronglyMeasurable hY.aemeasurable).mpr hi |
| have hpη : 0 < ∫ y : ℝ≥0, (y:ℝ)^m ∂η := by |
| rwa [integral_map hY.aemeasurable hpow.aestronglyMeasurable] |
| have hs := stableCloud m hm hm1 η inferInstance hiη hpη |
| have hmap : MeasurePreserving (mapPointCloud Y) (pointCloudLaw ν) (markedCloudLaw η) := |
| ⟨measurable_mapPointCloud hY, pointCloudLaw_map ν hY⟩ |
| refine ⟨?_, ?_, ?_⟩ |
| · simpa only [stableCloudSum_mapPointCloud] using hmap.quasiMeasurePreserving.ae hs.1 |
| · intro a ha ham |
| simpa only [Function.comp_def, stableCloudSum_mapPointCloud] using |
| hmap.integrable_comp_of_integrable (hs.2.2.1 a ha ham) |
| · simpa only [Function.comp_def, stableCloudSum_mapPointCloud] using |
| hmap.integrable_comp_of_integrable hs.2.2.2.2 |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
|
|
| namespace MicroscopicJamming |
|
|
| instance cascadeLaw_probability (ms : List ℝ) : IsProbabilityMeasure (cascadeLaw ms) := by |
| induction ms with |
| | nil => exact inferInstanceAs (IsProbabilityMeasure (Measure.dirac ())) |
| | cons m ms ih => |
| have := ih |
| exact inferInstanceAs (IsProbabilityMeasure (pointCloudLaw (cascadeLaw ms))) |
|
|
| lemma measurable_cascadeTotal (ms : List ℝ) : Measurable (cascadeTotal ms) := by |
| induction ms with |
| | nil => exact measurable_const |
| | cons m ms ih => |
| exact measurable_pointCloudFunctional ((by fun_prop : Measurable |
| (fun z : ℝ × CascadeTree ms.length => ENNReal.ofReal (z.1^(-1/m)))).mul |
| (ih.comp measurable_snd)) |
|
|
| lemma pointCloudFunctional_mark_congr {A : Type*} [MeasurableSpace A] |
| (ν : Measure A) [IsProbabilityMeasure ν] {f g : ℝ × A → ℝ≥0∞} |
| (h : ∀ᵐ a ∂ν, ∀ x, f (x,a) = g (x,a)) : |
| pointCloudFunctional f =ᵐ[pointCloudLaw ν] pointCloudFunctional g := by |
| filter_upwards [ae_pointCloud_marks ν h] with ω hω |
| unfold pointCloudFunctional |
| apply tsum_congr |
| intro n |
| unfold poissonBinSum |
| apply Finset.sum_congr rfl |
| intro j hj |
| exact hω n j _ |
|
|
| lemma cascadeTotal_colored {ms : List ℝ} {m : ℝ} |
| (hf : ∀ᵐ ω ∂cascadeLaw ms, cascadeTotal ms ω < ∞) : |
| cascadeTotal (m::ms) =ᵐ[cascadeLaw (m::ms)] |
| coloredStableSum m (fun ω => (cascadeTotal ms ω).toNNReal) := by |
| apply pointCloudFunctional_mark_congr (cascadeLaw ms) |
| filter_upwards [hf] with ω hω |
| intro x |
| rw [ENNReal.ofReal_mul' (NNReal.coe_nonneg _), ENNReal.ofReal_coe_nnreal, |
| ENNReal.coe_toNNReal hω.ne] |
|
|
| lemma cascadeTotal_properties (ms : List ℝ) (hms : ms.Pairwise (· < ·)) |
| (h01 : ∀ m ∈ ms, 0 < m ∧ m < 1) : |
| (∀ᵐ ω ∂cascadeLaw ms, 0 < cascadeTotal ms ω ∧ cascadeTotal ms ω < ∞) ∧ |
| (∀ a : ℝ, 0 < a → (∀ m ∈ ms, a < m) → |
| Integrable (fun ω => (cascadeTotal ms ω).toReal^a) (cascadeLaw ms)) ∧ |
| Integrable (fun ω => |Real.log (cascadeTotal ms ω).toReal|^2) (cascadeLaw ms) := by |
| induction ms with |
| | nil => |
| refine ⟨Filter.Eventually.of_forall (by intro ω; simp [cascadeTotal]), ?_, ?_⟩ |
| · intro a ha ham |
| simpa [cascadeTotal] using integrable_const (μ := cascadeLaw ([] : List ℝ)) (1:ℝ) |
| · simp [cascadeTotal] |
| | cons m ms ih => |
| have hm := (h01 m (List.mem_cons_self)).1 |
| have hm1 := (h01 m (List.mem_cons_self)).2 |
| have hs := List.pairwise_cons.mp hms |
| have ht := ih hs.2 (fun x hx => h01 x (List.mem_cons_of_mem _ hx)) |
| let Y : CascadeTree ms.length → ℝ≥0 := fun ω => (cascadeTotal ms ω).toNNReal |
| have hY : Measurable Y := (measurable_cascadeTotal ms).ennreal_toNNReal |
| have hi : Integrable (fun ω => (Y ω:ℝ)^m) (cascadeLaw ms) := ht.2.1 m hm hs.1 |
| have hpos : ∀ᵐ ω ∂cascadeLaw ms, 0 < (Y ω:ℝ)^m := by |
| filter_upwards [ht.1] with ω hω |
| exact Real.rpow_pos_of_pos (ENNReal.toReal_pos hω.1.ne' hω.2.ne) _ |
| have hp : 0 < ∫ ω, (Y ω:ℝ)^m ∂cascadeLaw ms := by |
| have hn : 0 ≤ ∫ ω, (Y ω:ℝ)^m ∂cascadeLaw ms := |
| integral_nonneg (fun ω => Real.rpow_nonneg (NNReal.coe_nonneg _) _) |
| apply lt_of_le_of_ne hn |
| intro heq |
| have hz := (integral_eq_zero_iff_of_nonneg |
| (fun ω => Real.rpow_nonneg (NNReal.coe_nonneg _) _) hi).mp heq.symm |
| have hc := hpos.and hz |
| obtain ⟨ω, hω⟩ := hc.exists |
| exact (ne_of_gt hω.1) hω.2 |
| have hc := coloredStable_properties (cascadeLaw ms) hm hm1 hY hi hp |
| have heq := cascadeTotal_colored (m := m) (ht.1.mono (fun _ h => h.2)) |
| refine ⟨?_, ?_, ?_⟩ |
| · filter_upwards [heq, hc.1] with ω he hω |
| rwa [he] |
| · intro a ha ham |
| exact (hc.2.1 a ha (ham m (List.mem_cons_self))).congr |
| (heq.symm.mono (fun _ h => congrArg (fun x : ℝ≥0∞ => x.toReal^a) h)) |
| · exact hc.2.2.congr |
| (heq.symm.mono (fun _ h => congrArg (fun x : ℝ≥0∞ => |Real.log x.toReal|^2) h)) |
|
|
| theorem cascadeNormalization : CascadeNormalizationStatement := by |
| intro ms hms h01 |
| have h := cascadeTotal_properties ms hms h01 |
| exact ⟨h.1, h.2.2⟩ |
|
|
| end MicroscopicJamming |
|
|
| end |
|
|
| end OAI |
|
|
