| import Mathlib |
| import OAI.Probability.Ballisticity.Model |
|
|
| namespace OAI |
|
|
| section |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal Topology BigOperators |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal Topology |
| namespace TailDecorrelation |
|
|
| noncomputable def entropyPlus (u : ℝ) : ℝ := u * Real.log (max 1 u) |
|
|
| lemma entropyPlus_nonneg {u : ℝ} (hu : 0 ≤ u) : 0 ≤ entropyPlus u := by |
| exact mul_nonneg hu (Real.log_nonneg (le_max_left _ _)) |
|
|
| lemma measurable_entropyPlus : Measurable entropyPlus := by |
| unfold entropyPlus |
| exact measurable_id.mul (Real.measurable_log.comp (measurable_const.max measurable_id)) |
|
|
| lemma entropy_young {u : ℝ} (hu : 0 ≤ u) (v : ℝ) : |
| u * v ≤ entropyPlus u + Real.exp v := by |
| by_cases h0 : u = 0 |
| · simp [h0, entropyPlus, Real.exp_nonneg] |
| have hp : 0 < u := lt_of_le_of_ne hu (Ne.symm h0) |
| have he := mul_le_mul_of_nonneg_left (Real.add_one_le_exp (v - Real.log u)) hu |
| have heq : u * Real.exp (v - Real.log u) = Real.exp v := by |
| rw [Real.exp_sub, Real.exp_log hp] |
| field_simp |
| rw [heq] at he |
| have hlog : Real.log u ≤ Real.log (max 1 u) := |
| Real.log_le_log hp (le_max_right _ _) |
| have hm := mul_le_mul_of_nonneg_left hlog hu |
| unfold entropyPlus |
| nlinarith |
|
|
| section Integrability |
|
|
| variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
|
|
| lemma integrable_density_mul_of_entropy {f z : Ω → ℝ} {c : ℝ} |
| (hc : 0 < c) (hf : Measurable f) (hz : Measurable z) |
| (hf0 : ∀ x, 0 ≤ f x) (hz0 : ∀ x, 0 ≤ z x) |
| (hH : Integrable (fun x => entropyPlus (f x)) μ) |
| (he : Integrable (fun x => Real.exp (c * z x)) μ) : |
| Integrable (fun x => f x * z x) μ := by |
| apply ((hH.add he).div_const c).mono' (hf.mul hz).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| change ‖f x * z x‖ ≤ (entropyPlus (f x) + Real.exp (c * z x)) / c |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (hf0 x) (hz0 x))] |
| apply (le_div_iff₀ hc).mpr |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using entropy_young (hf0 x) (c * z x) |
| |
| lemma exp_on_density_tail_pointwise {u z c L B : ℝ} |
| (hu : 0 ≤ u) (hc : 0 ≤ c) (hB : 0 < B) : |
| (if B < u then Real.exp (c * z) else 0) ≤ |
| (Real.exp (c * L) / B) * u + |
| Real.exp (-c * L) * Real.exp ((2 * c) * z) := by |
| by_cases ht : B < u |
| · rw [ite_eq_left ht] |
| by_cases hz : z ≤ L |
| · apply le_trans (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hz hc)) |
| have hb : 1 ≤ u / B := (le_div_iff₀ hB).mpr (by linarith) |
| have he := mul_le_mul_of_nonneg_left hb (Real.exp_nonneg (c * L)) |
| have hp : 0 ≤ Real.exp (-c * L) * Real.exp ((2 * c) * z) := by positivity |
| have heq : Real.exp (c * L) * (u / B) = Real.exp (c * L) / B * u := by ring |
| rw [mul_one, heq] at he |
| exact he.trans (le_add_of_nonneg_right hp) |
| · have hzl : L ≤ z := le_of_not_ge hz |
| have hle : c * z ≤ -c * L + (2 * c) * z := by |
| nlinarith [mul_nonneg hc (sub_nonneg.mpr hzl)] |
| calc |
| Real.exp (c * z) ≤ Real.exp (-c * L + (2 * c) * z) := Real.exp_le_exp.mpr hle |
| _ = Real.exp (-c * L) * Real.exp ((2 * c) * z) := Real.exp_add _ _ |
| _ ≤ _ := le_add_of_nonneg_left (by positivity) |
| · rw [ite_eq_right ht] |
| positivity |
| |
| lemma density_tail_pointwise {u z c L B : ℝ} |
| (hu : 0 ≤ u) (hz : 0 ≤ z) (hc : 0 < c) (hB : 0 < B) : |
| c * (if B < u then u * z else 0) ≤ |
| (if B < u then entropyPlus u else 0) + |
| (Real.exp (c * L) / B) * u + |
| Real.exp (-c * L) * Real.exp ((2 * c) * z) := by |
| rcases hz.eq_or_lt with rfl | _ |
| · have hEntropy := entropyPlus_nonneg hu |
| simp only [mul_zero, ite_self] |
| split_ifs <;> positivity |
| · have he := exp_on_density_tail_pointwise (u := u) (z := z) (L := L) hu hc.le hB |
| by_cases h : B < u |
| · simp only [ite_eq_left h] at * |
| have hy := entropy_young hu (c * z) |
| nlinarith |
| · simp only [ite_eq_right h, mul_zero, zero_add] |
| positivity |
| |
| lemma integrable_entropy_tail {f : Ω → ℝ} (hf : Measurable f) |
| (hH : Integrable (fun x => entropyPlus (f x)) μ) (B : ℝ) : |
| Integrable (fun x => if B < f x then entropyPlus (f x) else 0) μ := by |
| apply hH.norm.mono' |
| ((measurable_entropyPlus.comp hf).ite (measurableSet_lt measurable_const hf) measurable_const).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| change ‖if B < f x then entropyPlus (f x) else 0‖ ≤ ‖entropyPlus (f x)‖ |
| split_ifs <;> simp only [le_refl, norm_zero, norm_nonneg] |
|
|
| lemma entropy_tail_tendsto {f : Ω → ℝ} (hf : Measurable f) |
| (hf0 : ∀ x, 0 ≤ f x) (hH : Integrable (fun x => entropyPlus (f x)) μ) : |
| Tendsto (fun n : ℕ => ∫ x, if (n : ℝ) < f x then entropyPlus (f x) else 0 ∂μ) |
| atTop (𝓝 0) := by |
| have hm (n : ℕ) : AEStronglyMeasurable |
| (fun x => if (n : ℝ) < f x then entropyPlus (f x) else 0) μ := |
| (integrable_entropy_tail hf hH n).aestronglyMeasurable |
| have hb (n : ℕ) (x : Ω) : |
| ‖(if (n : ℝ) < f x then entropyPlus (f x) else 0)‖ ≤ entropyPlus (f x) := by |
| split_ifs |
| · rw [Real.norm_eq_abs, abs_of_nonneg (entropyPlus_nonneg (hf0 x))] |
| · simpa only [norm_zero] using entropyPlus_nonneg (hf0 x) |
| have ht : ∀ᵐ x ∂μ, Tendsto |
| (fun n : ℕ => if (n : ℝ) < f x then entropyPlus (f x) else 0) atTop (𝓝 0) := by |
| apply Eventually.of_forall |
| intro x |
| obtain ⟨N, hN⟩ := exists_nat_ge (f x) |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_ge_atTop N] with n hn |
| have hn' : f x ≤ (n : ℝ) := hN.trans (Nat.cast_le.mpr hn) |
| simp only [not_lt.mpr hn', ite_false] |
| simpa only [integral_zero] using tendsto_integral_of_dominated_convergence |
| (fun x => entropyPlus (f x)) hm hH |
| (fun n => Eventually.of_forall (hb n)) ht |
| |
| lemma density_tail_integral_le {f z : Ω → ℝ} {c B L : ℝ} |
| (hc : 0 < c) (hB : 0 < B) (hf : Measurable f) (hz : Measurable z) |
| (hf0 : ∀ x, 0 ≤ f x) (hz0 : ∀ x, 0 ≤ z x) |
| (hfi : Integrable f μ) (hH : Integrable (fun x => entropyPlus (f x)) μ) |
| (he : Integrable (fun x => Real.exp ((2 * c) * z x)) μ) : |
| (∫ x, if B < f x then f x * z x else 0 ∂μ) ≤ |
| ((∫ x, if B < f x then entropyPlus (f x) else 0 ∂μ) + |
| (Real.exp (c * L) / B) * (∫ x, f x ∂μ) + |
| Real.exp (-c * L) * (∫ x, Real.exp ((2 * c) * z x) ∂μ)) / c := by |
| have hei : Integrable (fun x => Real.exp (c * z x)) μ := by |
| apply he.mono' (Real.measurable_exp.comp (measurable_const.mul hz)).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| change ‖Real.exp (c * z x)‖ ≤ Real.exp ((2 * c) * z x) |
| rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _)] |
| exact Real.exp_le_exp.mpr (by nlinarith [hz0 x]) |
| have hprod := integrable_density_mul_of_entropy hc hf hz hf0 hz0 hH hei |
| have htail : Integrable (fun x => if B < f x then f x * z x else 0) μ := by |
| apply hprod.norm.mono' |
| ((hf.mul hz).ite (measurableSet_lt measurable_const hf) measurable_const).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| change ‖if B < f x then f x * z x else 0‖ ≤ ‖f x * z x‖ |
| split_ifs <;> simp only [le_refl, norm_zero, norm_nonneg] |
| have hEt := integrable_entropy_tail hf hH B |
| have hsum : Integrable (fun x => (if B < f x then entropyPlus (f x) else 0) + |
| (Real.exp (c * L) / B) * f x) μ := hEt.add (hfi.const_mul _) |
| have hi := integral_mono (htail.const_mul c) |
| (hsum.add (he.const_mul (Real.exp (-c * L)))) |
| (fun x => density_tail_pointwise (L := L) (hf0 x) (hz0 x) hc hB) |
| simp only [Pi.add_apply] at hi |
| rw [integral_const_mul, |
| integral_add hsum (he.const_mul _), |
| integral_add hEt (hfi.const_mul _), integral_const_mul, integral_const_mul] at hi |
| apply (le_div_iff₀ hc).mpr |
| simpa only [mul_comm] using hi |
| |
| lemma remainder_cap_pointwise {z c K : ℝ} (hz : 0 ≤ z) (hc : 0 < c) : |
| z - min K z ≤ (Real.exp (-c * K) / c) * Real.exp ((2 * c) * z) := by |
| by_cases h : z ≤ K |
| · rw [min_eq_right h, sub_self] |
| positivity |
| · have hK : K ≤ z := le_of_not_ge h |
| rw [min_eq_left hK] |
| have h0 : c * (z - K) ≤ Real.exp (c * (z - K)) := by |
| linarith [Real.add_one_le_exp (c * (z - K))] |
| have h1 : c * (z - K) ≤ -c * K + (2 * c) * z := by nlinarith |
| have h2 := Real.exp_le_exp.mpr h1 |
| rw [Real.exp_add] at h2 |
| rw [div_mul_eq_mul_div] |
| apply (le_div_iff₀ hc).mpr |
| simpa only [mul_comm] using h0.trans h2 |
| |
| lemma exp_neg_nat_tendsto {c : ℝ} (hc : 0 < c) : |
| Tendsto (fun n : ℕ => Real.exp (-c * (n : ℝ))) atTop (𝓝 0) := by |
| have ht : Tendsto (fun n : ℕ => c * (n : ℝ)) atTop atTop := |
| tendsto_natCast_atTop_atTop.const_mul_atTop hc |
| convert Real.tendsto_exp_neg_atTop_nhds_zero.comp ht using 1 |
| funext n |
| simp only [Function.comp_apply, neg_mul] |
| |
| lemma uniform_density_tail {f : Ω → ℝ} {Z : ℕ → Ω → ℝ} {c Q : ℝ} |
| (hc : 0 < c) (hf : Measurable f) (hf0 : ∀ x, 0 ≤ f x) |
| (hfi : Integrable f μ) (hH : Integrable (fun x => entropyPlus (f x)) μ) |
| (hZ : ∀ r, Measurable (Z r)) (hZ0 : ∀ r x, 0 ≤ Z r x) |
| (he : ∀ r, Integrable (fun x => Real.exp ((2 * c) * Z r x)) μ) |
| (heQ : ∀ r, (∫ x, Real.exp ((2 * c) * Z r x) ∂μ) ≤ Q) : |
| ∀ ε > 0, ∃ B > 1, ∀ r, |
| (∫ x, if B < f x then f x * Z r x else 0 ∂μ) < ε := by |
| let F := ∫ x, f x ∂μ |
| have hF : 0 ≤ F := integral_nonneg hf0 |
| have ht : Tendsto (fun n : ℕ => |
| ((∫ x, if (n : ℝ) < f x then entropyPlus (f x) else 0 ∂μ) + |
| Real.exp (-c * (n : ℝ)) * (F + Q)) / c) atTop (𝓝 0) := by |
| simpa only [zero_mul, zero_add, zero_div] using |
| ((entropy_tail_tendsto hf hf0 hH).add ((exp_neg_nat_tendsto hc).mul_const (F + Q))).div_const c |
| intro ε hε |
| obtain ⟨n, hn⟩ := (ht.eventually_lt_const hε).exists |
| let L : ℝ := n |
| let B : ℝ := Real.exp ((2 * c) * L) + L + 1 |
| have hL : 0 ≤ L := Nat.cast_nonneg n |
| have hB : 1 < B := by dsimp [B]; linarith [Real.exp_pos ((2 * c) * L)] |
| have hBn : (n : ℝ) ≤ B := by dsimp [B, L]; linarith [Real.exp_pos ((2 * c) * (n : ℝ))] |
| have hcoeff : Real.exp (c * L) / B ≤ Real.exp (-c * L) := by |
| apply (div_le_iff₀ (lt_trans zero_lt_one hB)).mpr |
| have hscale : Real.exp (-c * L) * Real.exp ((2 * c) * L) = Real.exp (c * L) := by |
| rw [← Real.exp_add] |
| congr 1 |
| ring |
| calc |
| Real.exp (c * L) = Real.exp (-c * L) * Real.exp ((2 * c) * L) := hscale.symm |
| _ ≤ Real.exp (-c * L) * B := by |
| apply mul_le_mul_of_nonneg_left _ (Real.exp_nonneg _) |
| dsimp [B] |
| linarith |
| have hHtail : (∫ x, if B < f x then entropyPlus (f x) else 0 ∂μ) ≤ |
| ∫ x, if (n : ℝ) < f x then entropyPlus (f x) else 0 ∂μ := by |
| apply integral_mono (integrable_entropy_tail hf hH B) (integrable_entropy_tail hf hH n) |
| intro x |
| change (if B < f x then entropyPlus (f x) else 0) ≤ |
| (if (n : ℝ) < f x then entropyPlus (f x) else 0) |
| by_cases h : B < f x |
| · rw [ite_eq_left h, ite_eq_left (lt_of_le_of_lt hBn h)] |
| · rw [ite_eq_right h] |
| split_ifs |
| · exact entropyPlus_nonneg (hf0 x) |
| · exact le_rfl |
| refine ⟨B, hB, ?_⟩ |
| intro r |
| apply lt_of_le_of_lt (density_tail_integral_le (c := c) (B := B) (L := L) |
| hc (lt_trans zero_lt_one hB) hf (hZ r) hf0 (hZ0 r) hfi hH (he r)) |
| apply lt_of_le_of_lt _ hn |
| apply div_le_div_of_nonneg_right _ hc.le |
| have h1 := mul_le_mul_of_nonneg_right hcoeff hF |
| have h2 := mul_le_mul_of_nonneg_left (heQ r) (Real.exp_nonneg (-c * L)) |
| dsimp [F, L] at * |
| nlinarith |
| |
| lemma cap_error_integrable {f z : Ω → ℝ} {c B K : ℝ} |
| (hc : 0 < c) (hB : 0 ≤ B) (hf : Measurable f) (hz : Measurable z) |
| (hf0 : ∀ x, 0 ≤ f x) (hfB : ∀ x, f x ≤ B) (hz0 : ∀ x, 0 ≤ z x) |
| (he : Integrable (fun x => Real.exp ((2 * c) * z x)) μ) : |
| Integrable (fun x => f x * (z x - min K (z x))) μ := by |
| apply (he.const_mul (B * (Real.exp (-c * K) / c))).mono' |
| (hf.mul (hz.sub (measurable_const.min hz))).aestronglyMeasurable |
| apply Eventually.of_forall |
| intro x |
| change ‖f x * (z x - min K (z x))‖ ≤ B * (Real.exp (-c * K) / c) * Real.exp ((2 * c) * z x) |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (hf0 x) (sub_nonneg.mpr (min_le_right _ _)))] |
| have hbound := mul_le_mul (hfB x) (remainder_cap_pointwise (K := K) (hz0 x) hc) |
| (sub_nonneg.mpr (min_le_right K (z x))) hB |
| simpa only [mul_assoc] using hbound |
|
|
| lemma cap_error_integral_le {f z : Ω → ℝ} {c B K : ℝ} |
| (hc : 0 < c) (hB : 0 ≤ B) (hf : Measurable f) (hz : Measurable z) |
| (hf0 : ∀ x, 0 ≤ f x) (hfB : ∀ x, f x ≤ B) (hz0 : ∀ x, 0 ≤ z x) |
| (he : Integrable (fun x => Real.exp ((2 * c) * z x)) μ) : |
| (∫ x, f x * (z x - min K (z x)) ∂μ) ≤ |
| (B * (Real.exp (-c * K) / c)) * (∫ x, Real.exp ((2 * c) * z x) ∂μ) := by |
| rw [← integral_const_mul] |
| apply integral_mono (cap_error_integrable hc hB hf hz hf0 hfB hz0 he) (he.const_mul _) |
| intro x |
| have hbound := mul_le_mul (hfB x) (remainder_cap_pointwise (K := K) (hz0 x) hc) |
| (sub_nonneg.mpr (min_le_right K (z x))) hB |
| simpa only [mul_assoc] using hbound |
|
|
| lemma uniform_remainder_cap {f : Ω → ℝ} {Z : ℕ → Ω → ℝ} {c B Q : ℝ} |
| (hc : 0 < c) (hB : 0 ≤ B) (hf : Measurable f) |
| (hf0 : ∀ x, 0 ≤ f x) (hfB : ∀ x, f x ≤ B) |
| (hZ : ∀ r, Measurable (Z r)) (hZ0 : ∀ r x, 0 ≤ Z r x) |
| (he : ∀ r, Integrable (fun x => Real.exp ((2 * c) * Z r x)) μ) |
| (heQ : ∀ r, (∫ x, Real.exp ((2 * c) * Z r x) ∂μ) ≤ Q) : |
| ∀ ε > 0, ∃ K > 0, ∀ r, |
| (∫ x, f x * (Z r x - min K (Z r x)) ∂μ) < ε := by |
| have ht : Tendsto (fun n : ℕ => B * (Real.exp (-c * (n : ℝ)) / c) * Q) |
| atTop (𝓝 0) := by |
| simpa only [zero_div, mul_zero, zero_mul] using |
| (((exp_neg_nat_tendsto hc).div_const c).const_mul B).mul_const Q |
| intro ε hε |
| obtain ⟨n, hn0, hn⟩ := ((eventually_gt_atTop 0).and (ht.eventually_lt_const hε)).exists |
| refine ⟨n, by exact_mod_cast hn0, ?_⟩ |
| intro r |
| apply lt_of_le_of_lt (cap_error_integral_le (K := n) hc hB hf (hZ r) hf0 hfB (hZ0 r) (he r)) |
| apply lt_of_le_of_lt _ hn |
| exact mul_le_mul_of_nonneg_left (heQ r) (by positivity) |
|
|
| end Integrability |
|
|
| end TailDecorrelation |
|
|
| end |
|
|
| end OAI |
|
|
