openAI-math-dataset / lean /OAI /Analysis /CoulombIonization /Localization /ObservationIntegral.lean
| import Mathlib | |
| import OAI.Analysis.CoulombIonization.Localization.SqrtMultiplier | |
| namespace OAI | |
| noncomputable section | |
| namespace CoulombObservation | |
| open MeasureTheory Filter | |
| open scoped Topology BigOperators ContDiff | |
| section Work_ObservationIntegral_scope | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal NNReal Topology | |
| lemma integrable_bounded_probability {Ω : Type*} [MeasurableSpace Ω] | |
| {μ : Measure Ω} [IsFiniteMeasure μ] {q : Ω → ℝ} (hq : Measurable q) | |
| (hn : ∀ x, 0 ≤ q x) (hb : ∀ x, q x ≤ 1) : Integrable q μ := by | |
| apply (integrable_const (1:ℝ)).mono' hq.aestronglyMeasurable | |
| exact ae_of_all _ (fun x => by simpa only [Real.norm_eq_abs, abs_of_nonneg (hn x)] using hb x) | |
| lemma bounded_probability_rpow_integrable {Ω : Type*} [MeasurableSpace Ω] | |
| {μ : Measure Ω} [IsFiniteMeasure μ] {q : Ω → ℝ} (hq : Measurable q) | |
| (hn : ∀ x, 0 ≤ q x) (hb : ∀ x, q x ≤ 1) {a : ℝ} (ha : 0 ≤ a) : | |
| Integrable (fun x => q x ^ a) μ := by | |
| apply integrable_bounded_probability (hq.pow_const a) | |
| · exact fun x => Real.rpow_nonneg (hn x) _ | |
| · exact fun x => Real.rpow_le_one (hn x) (hb x) ha | |
| lemma integral_bounded_probability_rpow {Ω : Type*} [MeasurableSpace Ω] | |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {q : Ω → ℝ} (hq : Measurable q) | |
| (hn : ∀ x, 0 ≤ q x) (hb : ∀ x, q x ≤ 1) {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) : | |
| (∫ x, q x ^ a ∂μ) ≤ (∫ x, q x ∂μ)^a := by | |
| apply (Real.concaveOn_rpow ha ha1).le_map_integral | |
| · exact (Real.continuous_rpow_const ha).continuousOn | |
| · exact isClosed_Ici | |
| · exact ae_of_all _ hn | |
| · exact integrable_bounded_probability hq hn hb | |
| · exact bounded_probability_rpow_integrable hq hn hb ha | |
| def eventMomentOrder (p : ℝ) : ℕ := ⌈-Real.log p⌉₊+1 | |
| lemma eventMomentOrder_pos (p : ℝ) : 0 < eventMomentOrder p := by | |
| unfold eventMomentOrder; omega | |
| lemma eventMomentOrder_bound {p : ℝ} (hp : 0 < p) (hp1 : p ≤ 1) : | |
| (eventMomentOrder p : ℝ) ≤ 2*(1-Real.log p) := by | |
| have hl := Real.log_nonpos hp.le hp1 | |
| have hc := Nat.ceil_lt_add_one (show 0 ≤ -Real.log p by linarith) | |
| dsimp [eventMomentOrder] | |
| push_cast | |
| linarith | |
| lemma eventMomentOrder_rpow_bound {p : ℝ} (hp : 0 < p) : | |
| p ^ (-((eventMomentOrder p : ℝ)⁻¹)) ≤ Real.exp 1 := by | |
| rw [Real.rpow_def_of_pos hp, Real.exp_le_exp] | |
| have hk : (0:ℝ) < eventMomentOrder p := by exact_mod_cast eventMomentOrder_pos p | |
| have hc := Nat.le_ceil (-Real.log p) | |
| have hle : -Real.log p ≤ (eventMomentOrder p : ℝ) := by | |
| dsimp [eventMomentOrder]; push_cast; linarith | |
| rw [mul_neg, ← neg_mul, ← div_eq_mul_inv, div_le_iff₀ hk] | |
| simpa using hle | |
| lemma eventMomentOrder_integral_bound {p : ℝ} (hp : 0 < p) (hp1 : p ≤ 1) : | |
| (eventMomentOrder p : ℝ)^5 * p^(1-(eventMomentOrder p:ℝ)⁻¹) ≤ | |
| (32*Real.exp 1)*(1-Real.log p)^5*p := by | |
| have hl : 0 ≤ 1-Real.log p := by linarith [Real.log_nonpos hp.le hp1] | |
| have hk : 0 ≤ (eventMomentOrder p : ℝ) := Nat.cast_nonneg _ | |
| have hpow := pow_le_pow_left₀ hk (eventMomentOrder_bound hp hp1) 5 | |
| have hprod := mul_le_mul hpow (eventMomentOrder_rpow_bound hp) | |
| (Real.rpow_nonneg hp.le _) (by positivity : 0 ≤ (2*(1-Real.log p))^5) | |
| rw [sub_eq_add_neg, Real.rpow_add hp, Real.rpow_one] | |
| calc | |
| _ = ((eventMomentOrder p : ℝ)^5 * p^(-((eventMomentOrder p:ℝ)⁻¹)))*p := by ring | |
| _ ≤ (2*(1-Real.log p))^5 * Real.exp 1 * p := mul_le_mul_of_nonneg_right hprod hp.le | |
| _ = _ := by ring | |
| lemma eventLog_eq {p : ℝ} (hp : 0 < p) : Real.log (Real.exp 1/p) = 1-Real.log p := by | |
| rw [Real.log_div (ne_of_gt (Real.exp_pos _)) (ne_of_gt hp), Real.log_exp] | |
| end Work_ObservationIntegral_scope | |
| open MeasureTheory Set Finset | |
| open scoped ENNReal NNReal BigOperators ContDiff | |
| def arrayFisher {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) (s : Set (J × I → ℝ)) (x : I → ℝ) : ℝ := | |
| ∑ i, (lineDeriv ℝ (fun y => Real.sqrt (arrayLikelihood b s y)) x (Pi.single i 1))^2 | |
| lemma arrayFisher_nonneg {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) (s : Set (J × I → ℝ)) (x : I → ℝ) : 0 ≤ arrayFisher b s x := | |
| sum_nonneg (fun _ _ => sq_nonneg _) | |
| lemma arrayFisher_measurable {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) {s : Set (J × I → ℝ)} (hs : MeasurableSet s) : | |
| Measurable (arrayFisher b s) := by | |
| apply Finset.measurable_sum | |
| intro i _ | |
| exact (measurable_lineDeriv (sqrtArrayLikelihood_lipschitz b hs).continuous).pow_const 2 | |
| lemma reciprocal_moment_sub_one_nonneg {k : ℕ} (hk : 0 < k) : 0 ≤ 1-(k:ℝ)⁻¹ := by | |
| have hh : (1:ℝ) ≤ k := by exact_mod_cast hk | |
| have hi : (k:ℝ)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hh | |
| linarith | |
| lemma arrayFisher_integrable {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) {s : Set (J × I → ℝ)} (hs : MeasurableSet s) | |
| (μ : Measure (I → ℝ)) [IsFiniteMeasure μ] : Integrable (arrayFisher b s) μ := by | |
| have hC := observationMomentConstant_pos | |
| have hbound (x : I → ℝ) : arrayFisher b s x ≤ | |
| (observationMomentConstant/4) * ∑ j, (b j)^2 := by | |
| simpa [arrayFisher] using sqrtArrayLikelihood_lineDeriv_sq b hs x (k := 1) (by decide) | |
| apply (integrable_const ((observationMomentConstant/4) * ∑ j, (b j)^2)).mono' | |
| (arrayFisher_measurable b hs).aestronglyMeasurable | |
| filter_upwards [] with x | |
| simpa only [Real.norm_eq_abs, abs_of_nonneg (arrayFisher_nonneg b s x)] using hbound x | |
| lemma arrayFisher_integral_moment {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) {s : Set (J × I → ℝ)} (hs : MeasurableSet s) | |
| (μ : Measure (I → ℝ)) [IsProbabilityMeasure μ] {k : ℕ} (hk : 0 < k) : | |
| (∫ x, arrayFisher b s x ∂μ) ≤ | |
| (observationMomentConstant/4) * (k:ℝ)^5 * (∑ j, (b j)^2) * | |
| (∫ x, arrayLikelihood b s x ∂μ)^(1-(k:ℝ)⁻¹) := by | |
| have ha := reciprocal_moment_sub_one_nonneg hk | |
| have ha1 : 1-(k:ℝ)⁻¹ ≤ 1 := sub_le_self _ (inv_nonneg.mpr (Nat.cast_nonneg _)) | |
| have hq := (arrayLikelihood_contDiff b hs (n := 1)).continuous.measurable | |
| have hC := observationMomentConstant_pos | |
| have hj := integral_bounded_probability_rpow (μ := μ) hq | |
| (arrayLikelihood_nonneg b hs) (arrayLikelihood_le_one b hs) ha ha1 | |
| calc | |
| _ ≤ ∫ x, (observationMomentConstant/4) * (k:ℝ)^5 * (∑ j, (b j)^2) * | |
| (arrayLikelihood b s x)^(1-(k:ℝ)⁻¹) ∂μ := by | |
| apply integral_mono (arrayFisher_integrable b hs μ) | |
| ((bounded_probability_rpow_integrable hq (arrayLikelihood_nonneg b hs) | |
| (arrayLikelihood_le_one b hs) ha).const_mul _) | |
| exact fun x => sqrtArrayLikelihood_lineDeriv_sq b hs x hk | |
| _ = ((observationMomentConstant/4) * (k:ℝ)^5 * (∑ j, (b j)^2)) * | |
| ∫ x, (arrayLikelihood b s x)^(1-(k:ℝ)⁻¹) ∂μ := integral_const_mul _ _ | |
| _ ≤ _ := mul_le_mul_of_nonneg_left hj (by positivity) | |
| def observationFisherConstant : ℝ := 8 * Real.exp 1 * observationMomentConstant | |
| lemma observationFisherConstant_pos : 0 < observationFisherConstant := by | |
| unfold observationFisherConstant | |
| exact mul_pos (mul_pos (by norm_num) (Real.exp_pos _)) observationMomentConstant_pos | |
| theorem arrayFisher_integral_log {J I : Type*} [Fintype J] [Fintype I] [DecidableEq I] | |
| (b : J → ℝ) {s : Set (J × I → ℝ)} (hs : MeasurableSet s) | |
| (μ : Measure (I → ℝ)) [IsProbabilityMeasure μ] | |
| (hp : 0 < ∫ x, arrayLikelihood b s x ∂μ) : | |
| (∫ x, arrayFisher b s x ∂μ) ≤ | |
| observationFisherConstant * (∑ j, (b j)^2) * | |
| (Real.log (Real.exp 1/(∫ x, arrayLikelihood b s x ∂μ)))^5 * | |
| (∫ x, arrayLikelihood b s x ∂μ) := by | |
| let p := ∫ x, arrayLikelihood b s x ∂μ | |
| have hp1 : p ≤ 1 := by | |
| have h := integral_mono | |
| (integrable_bounded_probability (μ := μ) ((arrayLikelihood_contDiff b hs (n:=1)).continuous.measurable) | |
| (arrayLikelihood_nonneg b hs) (arrayLikelihood_le_one b hs)) | |
| (integrable_const (1:ℝ)) (arrayLikelihood_le_one b hs) | |
| simpa [p] using h | |
| have hC := observationMomentConstant_pos | |
| have hb : 0 ≤ ∑ j, (b j)^2 := sum_nonneg (fun _ _ => sq_nonneg _) | |
| have hbound := arrayFisher_integral_moment b hs μ (eventMomentOrder_pos p) | |
| have hlog := mul_le_mul_of_nonneg_left (eventMomentOrder_integral_bound hp hp1) | |
| (show 0 ≤ observationMomentConstant/4 * ∑ j, (b j)^2 by positivity) | |
| change _ ≤ observationFisherConstant * (∑ j, (b j)^2) * Real.log (Real.exp 1/p)^5 * p | |
| rw [eventLog_eq hp] | |
| calc | |
| _ ≤ (observationMomentConstant/4) * (eventMomentOrder p:ℝ)^5 * (∑ j, (b j)^2) * | |
| p^(1-(eventMomentOrder p:ℝ)⁻¹) := hbound | |
| _ = (observationMomentConstant/4 * ∑ j, (b j)^2) * | |
| ((eventMomentOrder p:ℝ)^5 * p^(1-(eventMomentOrder p:ℝ)⁻¹)) := by ring | |
| _ ≤ (observationMomentConstant/4 * ∑ j, (b j)^2) * | |
| ((32*Real.exp 1)*(1-Real.log p)^5*p) := hlog | |
| _ = _ := by dsimp [observationFisherConstant]; ring | |
| end CoulombObservation | |
| end | |
| end OAI | |