| import OAI.Analysis.IntegralMeans.InverseDensity |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set MeasureTheory Filter Function InnerProductSpace |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical |
| open MeasureTheory Function |
| open Set Filter |
| open Set MeasureTheory Filter Function |
| open Set MeasureTheory Filter Function InnerProductSpace |
| open TopologicalSpace |
| open scoped CompactlySupported |
| open scoped ENNReal |
| open scoped Manifold |
| open scoped Topology CompactlySupported ComplexConjugate |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical |
| open scoped Topology ENNReal NNReal |
| namespace Brennan |
|
|
| attribute [local irreducible] classWeight |
| attribute [local irreducible] classFun |
| attribute [local irreducible] rerootClass |
| attribute [local irreducible] inverseDensity inverseJacDensity |
|
|
| lemma lintegral_Icc_inv {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) : |
| (∫⁻ y in Icc a b, ENNReal.ofReal y⁻¹) = ENNReal.ofReal (Real.log (b/a)) := by |
| have hc : ContinuousOn (fun y : ℝ => y⁻¹) (Icc a b) := |
| continuousOn_id.inv₀ (fun y hy => ne_of_gt (ha.trans_le hy.1)) |
| have hi : IntegrableOn (fun y : ℝ => y⁻¹) (Icc a b) volume := hc.integrableOn_Icc |
| rw [← ofReal_integral_eq_lintegral_ofReal hi] |
| · rw [integral_Icc_eq_integral_Ioc,← intervalIntegral.integral_of_le hab,integral_inv_of_pos ha (ha.trans_le hab)] |
| · filter_upwards [ae_restrict_mem measurableSet_Icc] with y hy |
| exact inv_nonneg.mpr (ha.le.trans hy.1) |
|
|
| lemma lintegral_transportBox_inv {R a b : ℝ} (hR : 0 ≤ R) (ha : 0 < a) (hab : a ≤ b) : |
| (∫⁻ z in transportBox R a b, ENNReal.ofReal z.im⁻¹) = |
| ENNReal.ofReal (2*R*Real.log (b/a)) := by |
| have he : Complex.measurableEquivRealProd ⁻¹' (Icc (-R) R ×ˢ Icc a b) = transportBox R a b := by |
| ext z |
| simp only [Complex.measurableEquivRealProd_apply,mem_preimage,mem_prod,mem_Icc,transportBox,mem_ofPred_eq,abs_le] |
| have hprod := Complex.volume_preserving_equiv_real_prod.setLIntegral_comp_preimage_emb |
| Complex.measurableEquivRealProd.measurableEmbedding (fun p : ℝ × ℝ => ENNReal.ofReal p.2⁻¹) |
| (Icc (-R) R ×ˢ Icc a b) |
| rw [he] at hprod |
| change (∫⁻ z in transportBox R a b, ENNReal.ofReal z.im⁻¹) = _ at hprod |
| rw [hprod,show (volume : Measure (ℝ × ℝ)) = volume.prod volume from rfl, |
| setLIntegral_prod _ (by fun_prop)] |
| dsimp only |
| rw [lintegral_Icc_inv ha hab, |
| lintegral_const,Measure.restrict_apply_univ,Real.volume_Icc] |
| rw [show R - -R = 2*R from by ring,mul_comm,← ENNReal.ofReal_mul (by positivity : 0 ≤ 2*R)] |
| |
| def rootJac (k σ : ℝ) (g : DiskClass) : ℝ≥0∞ := |
| ENNReal.ofReal (σ * normalizedJacobian (classFun g) k Complex.I) |
| |
| lemma measurable_rootJac (k σ : ℝ) : Measurable (rootJac k σ) := by |
| exact (measurable_const.mul ((continuous_class_normalizedJacobian k).comp |
| (continuous_id.prodMk (continuous_const (y := halfOne)))).measurable).ennreal_ofReal |
| |
| lemma rootJac_reroot (g : DiskClass) {k : ℝ} (hk : 0 < k) (σ : ℝ) (z : halfPlane) : |
| rootJac k σ (rerootClass g z) = ENNReal.ofReal (σ * normalizedJacobian (classFun g) k z) := by |
| rw [rootJac,class_normalizedJacobian_root g hk z] |
| |
| def rootWindow (k N : ℝ) : Set DiskClass := {g | (g,halfOne) ∈ transportWindow k N} |
| |
| def windowTest (k N : ℝ) : DiskClass → ℝ≥0∞ := (rootWindow k N).indicator (rootJac k 1) |
| |
| lemma measurableSet_rootWindow {k : ℝ} (hk : 0 < k) (N : ℝ) : MeasurableSet (rootWindow k N) := |
| (measurableSet_transportWindow hk N).preimage (measurable_id.prodMk measurable_const) |
| |
| lemma measurable_windowTest {k : ℝ} (hk : 0 < k) (N : ℝ) : Measurable (windowTest k N) := |
| (measurable_rootJac k 1).indicator (measurableSet_rootWindow hk N) |
| |
| lemma averagedDensity_window (g : DiskClass) (β : ℝ) {k : ℝ} (hk : 0 < k) (N : ℝ) (z : halfPlane) : |
| averagedDensity β (windowTest k N) (g,z) = |
| transportDensity g β z * ENNReal.ofReal (normalizedJacobian (classFun g) k z) * |
| (transportSlice g k N).indicator 1 z := by |
| rw [averagedDensity_of_mem,windowTest] |
| have he : rerootClass g z ∈ rootWindow k N ↔ z.val ∈ transportSlice g k N := |
| (transportWindow_root g hk N z).trans (transportSlice_iff g k N z).symm |
| by_cases hz : z.val ∈ transportSlice g k N |
| · rw [indicator_of_mem (he.mpr hz),rootJac_reroot g hk 1 z,one_mul,indicator_of_mem hz] |
| simp |
| · rw [indicator_of_notMem (fun h => hz (he.mp h)),indicator_of_notMem hz] |
| simp |
| |
| def rootException (k : ℝ) : Set DiskClass := |
| {g | ¬GoodPair (classFun g) k (criticalMap (classFun g) k Complex.I)} |
| |
| def exceptionTest (k : ℝ) : DiskClass → ℝ≥0∞ := (rootException k).indicator (rootJac k 1) |
| |
| lemma measurableSet_rootException {k : ℝ} (hk : 0 < k) : MeasurableSet (rootException k) := by |
| have hm : Measurable (fun g : DiskClass => (g,criticalMap (classFun g) k Complex.I)) := |
| continuous_id.measurable.prodMk (((continuous_class_criticalMap k).comp |
| (continuous_id.prodMk (continuous_const (y := halfOne)))).measurable) |
| exact ((measurableSet_class_goodPairs hk.le).preimage hm).compl |
| |
| lemma measurable_exceptionTest {k : ℝ} (hk : 0 < k) : Measurable (exceptionTest k) := |
| (measurable_rootJac k 1).indicator (measurableSet_rootException hk) |
| |
| lemma averagedDensity_exception (g : DiskClass) (β : ℝ) {k : ℝ} (hk : 0 < k) (z : halfPlane) : |
| averagedDensity β (exceptionTest k) (g,z) = |
| transportDensity g β z * ENNReal.ofReal (normalizedJacobian (classFun g) k z) * |
| {z : ℂ | z ∈ halfPlane ∧ ¬GoodPair (classFun g) k (criticalMap (classFun g) k z)}.indicator 1 z := by |
| rw [averagedDensity_of_mem,exceptionTest] |
| have he := class_goodPair_root g hk z |
| by_cases hg : GoodPair (classFun g) k (criticalMap (classFun g) k z) |
| · rw [indicator_of_notMem (show rerootClass g z ∉ rootException k from fun h => h (he.mpr hg)), |
| indicator_of_notMem (show z.val ∉ {z : ℂ | z ∈ halfPlane ∧ ¬GoodPair (classFun g) k (criticalMap (classFun g) k z)} from fun h => h.2 hg)] |
| simp |
| · rw [indicator_of_mem (show rerootClass g z ∈ rootException k from fun h => hg (he.mp h)), |
| rootJac_reroot g hk 1 z,one_mul,indicator_of_mem (show z.val ∈ {z : ℂ | z ∈ halfPlane ∧ ¬GoodPair (classFun g) k (criticalMap (classFun g) k z)} from ⟨z.property,hg⟩)] |
| simp |
| |
| lemma exceptionTest_integral_zero (P : ProbabilityMeasure DiskClass) (β : ℝ) |
| (hP : HasWeightedLaw P β) {k : ℝ} (hk : 0 < k) |
| (hg : ∀ᵐ g ∂(P : Measure DiskClass), ∀ᵐ ξ : ℂ, GoodPair (classFun g) k ξ) : |
| (∫⁻ g, exceptionTest k g ∂(P : Measure DiskClass)) = 0 := by |
| apply root_test_zero_of_averaging P β hP (measurable_exceptionTest hk) |
| filter_upwards [hg] with g hg |
| refine Eq.trans ?_ (exceptional_transport_zero g (β := β) hk hg) |
| apply setLIntegral_congr_fun isOpen_halfPlane.measurableSet |
| intro z hz |
| exact averagedDensity_exception g β hk ⟨z,hz⟩ |
| |
| lemma averagedDensity_box (P : ProbabilityMeasure DiskClass) (β : ℝ) |
| (hP : HasWeightedLaw P β) {Φ : DiskClass → ℝ≥0∞} (hΦ : Measurable Φ) |
| {R a b : ℝ} (hR : 0 ≤ R) (ha : 0 < a) (hab : a ≤ b) : |
| (∫⁻ g, ∫⁻ z in transportBox R a b, averagedDensity β Φ (g,z) ∂volume ∂(P : Measure DiskClass)) = |
| ENNReal.ofReal (2*R*Real.log (b/a)) * ∫⁻ g, Φ g ∂(P : Measure DiskClass) := by |
| rw [lintegral_lintegral_swap (f := fun g z => averagedDensity β Φ (g,z)) (μ := (P : Measure DiskClass)) (ν := volume.restrict (transportBox R a b)) (measurable_averagedDensity β hΦ).aemeasurable] |
| have he : (∫⁻ z in transportBox R a b, ∫⁻ g, averagedDensity β Φ (g,z) ∂(P : Measure DiskClass)) = |
| ∫⁻ z in transportBox R a b, ENNReal.ofReal z.im⁻¹ * ∫⁻ g, Φ g ∂(P : Measure DiskClass) := by |
| apply setLIntegral_congr_fun (measurableSet_transportBox R a b) |
| intro z hz |
| exact weighted_averagedDensity P β hP hΦ ⟨z,ha.trans_le hz.2.1⟩ |
| rw [he,lintegral_mul_const _ (by fun_prop),lintegral_transportBox_inv hR ha hab] |
| |
| lemma setLIntegral_mul_indicator_one {S T : Set ℂ} (hS : MeasurableSet S) (hST : S ⊆ T) |
| (f : ℂ → ℝ≥0∞) : |
| (∫⁻ z in T, f z * S.indicator 1 z) = ∫⁻ z in S, f z := by |
| have he : (fun z => f z * S.indicator 1 z) = S.indicator f := by |
| funext z |
| by_cases hz : z ∈ S <;> simp [hz] |
| rw [he,setLIntegral_indicator hS,inter_eq_left.mpr hST] |
| |
| lemma transport_box_averaged (g : DiskClass) {β k N R Y : ℝ} (hk : 0 < k) |
| (hb : β-1 = 4*(k-1)) (hN : 1 ≤ N) : |
| (∫⁻ z in transportBox R 1 Y, averagedDensity β (windowTest k N) (g,z)) ≤ |
| ∫⁻ z in transportBox (R+N*Y) (1/N) (N*Y), averagedDensity β (rootJac k (-1)) (g,z) := by |
| have hn : 0 < N := lt_of_lt_of_le zero_lt_one hN |
| have hB : transportBox R 1 Y ⊆ halfPlane := fun z hz => lt_of_lt_of_le zero_lt_one hz.2.1 |
| have hB' : transportBox (R+N*Y) (1/N) (N*Y) ⊆ halfPlane := fun z hz => |
| lt_of_lt_of_le (one_div_pos.mpr hn) hz.2.1 |
| have he := transport_box g hk hb hN (R := R) (Y := Y) |
| have hp : (∫⁻ z in halfPlane, transportDensity g β z*ENNReal.ofReal (normalizedJacobian (classFun g) k z)* |
| (transportSlice g k N ∩ transportBox R 1 Y).indicator 1 z) = |
| ∫⁻ z in transportBox R 1 Y, averagedDensity β (windowTest k N) (g,z) := by |
| have hid : (fun z => transportDensity g β z*ENNReal.ofReal (normalizedJacobian (classFun g) k z)* |
| (transportSlice g k N ∩ transportBox R 1 Y).indicator 1 z) = |
| fun z => (transportDensity g β z*ENNReal.ofReal (normalizedJacobian (classFun g) k z)* |
| (transportSlice g k N).indicator 1 z)*(transportBox R 1 Y).indicator 1 z := by |
| funext z |
| rw [inter_indicator_one] |
| simp only [Pi.mul_apply,mul_assoc] |
| rw [hid,setLIntegral_mul_indicator_one (measurableSet_transportBox _ _ _) hB] |
| apply setLIntegral_congr_fun (measurableSet_transportBox _ _ _) |
| intro z hz |
| exact (averagedDensity_window g β hk N ⟨z,hB hz⟩).symm |
| have hm : (∫⁻ z in halfPlane, transportDensity g β z*ENNReal.ofReal (-normalizedJacobian (classFun g) k z)* |
| (transportBox (R+N*Y) (1/N) (N*Y)).indicator 1 z) = |
| ∫⁻ z in transportBox (R+N*Y) (1/N) (N*Y), averagedDensity β (rootJac k (-1)) (g,z) := by |
| rw [setLIntegral_mul_indicator_one (measurableSet_transportBox _ _ _) hB'] |
| apply setLIntegral_congr_fun (measurableSet_transportBox _ _ _) |
| intro z hz |
| symm |
| exact (averagedDensity_of_mem β (rootJac k (-1)) g ⟨z,hB' hz⟩).trans |
| (congrArg (transportDensity g β z * ·) (by simpa only [neg_one_mul] using rootJac_reroot g hk (-1) ⟨z,hB' hz⟩)) |
| exact hp.symm.trans_le (he.trans_eq hm) |
| |
| lemma expected_transport_box (P : ProbabilityMeasure DiskClass) (β : ℝ) |
| (hP : HasWeightedLaw P β) {k N R Y : ℝ} (hk : 0 < k) |
| (hb : β-1 = 4*(k-1)) (hN : 1 ≤ N) (hR : 0 ≤ R) (hY : 1 ≤ Y) : |
| ENNReal.ofReal (2*R*Real.log Y) * (∫⁻ g, windowTest k N g ∂(P : Measure DiskClass)) ≤ |
| ENNReal.ofReal (2*(R+N*Y)*Real.log (N^2*Y)) * (∫⁻ g, rootJac k (-1) g ∂(P : Measure DiskClass)) := by |
| have hn : 0 < N := lt_of_lt_of_le zero_lt_one hN |
| have hny : 1 / N ≤ N*Y := by |
| rw [div_le_iff₀ hn] |
| have hc := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hY hn.le) hn.le |
| nlinarith [sq_nonneg (N-1)] |
| have hp := averagedDensity_box P β hP (measurable_windowTest hk N) hR zero_lt_one hY |
| have hm := averagedDensity_box P β hP (measurable_rootJac k (-1)) |
| (add_nonneg hR (mul_nonneg hn.le (zero_le_one.trans hY))) (one_div_pos.mpr hn) hny |
| simp only [div_one] at hp |
| rw [show N*Y/(1/N) = N^2*Y from by field_simp] at hm |
| rw [← hp,← hm] |
| exact lintegral_mono (fun g => transport_box_averaged g hk hb hN) |
| |
| lemma transport_ratio_tendsto (N : ℝ) : |
| Tendsto (fun Y : ℝ => (1+N/Y)*(1+2*Real.log N/Real.log Y)) atTop (𝓝 1) := by |
| have h1 : Tendsto (fun Y : ℝ => N/Y) atTop (𝓝 0) := tendsto_const_nhds.div_atTop tendsto_id |
| have h2 : Tendsto (fun Y : ℝ => 2*Real.log N/Real.log Y) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop Real.tendsto_log_atTop |
| simpa using ((tendsto_const_nhds (x := (1 : ℝ))).add h1).mul ((tendsto_const_nhds (x := (1 : ℝ))).add h2) |
| |
| lemma transport_box_limit {A B : ℝ≥0∞} (hA : A ≠ ∞) (hB : B ≠ ∞) |
| {N : ℝ} (hN : 1 ≤ N) |
| (h : ∀ Y : ℝ, 1 < Y → |
| ENNReal.ofReal (2*Y^2*Real.log Y)*A ≤ |
| ENNReal.ofReal (2*(Y^2+N*Y)*Real.log (N^2*Y))*B) : A ≤ B := by |
| have hn : 0 < N := zero_lt_one.trans_le hN |
| have hineq : ∀ Y : ℝ, 1 < Y → A.toReal ≤ (1+N/Y)*(1+2*Real.log N/Real.log Y)*B.toReal := by |
| intro Y hY |
| have hy : 0 < Y := zero_lt_one.trans hY |
| have hl : 0 < Real.log Y := Real.log_pos hY |
| have hny : 1 < N^2*Y := by nlinarith [sq_nonneg (N-1)] |
| have hlny : 0 ≤ Real.log (N^2*Y) := Real.log_nonneg hny.le |
| have hb := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hB) (h Y hY) |
| rw [ENNReal.toReal_mul,ENNReal.toReal_mul,ENNReal.toReal_ofReal (by positivity : 0 ≤ 2*Y^2*Real.log Y), |
| ENNReal.toReal_ofReal (by positivity : 0 ≤ 2*(Y^2+N*Y)*Real.log (N^2*Y))] at hb |
| have hlog : Real.log (N^2*Y) = 2*Real.log N + Real.log Y := by |
| rw [Real.log_mul (by positivity) (ne_of_gt hy),Real.log_pow] |
| norm_num |
| rw [hlog] at hb |
| apply (mul_le_mul_iff_right₀ (show 0 < 2*Y^2*Real.log Y by positivity)).mp |
| calc |
| _ ≤ 2*(Y^2+N*Y)*(2*Real.log N+Real.log Y)*B.toReal := hb |
| _ = _ := by field_simp; ring |
| apply (ENNReal.toReal_le_toReal hA hB).mp |
| have ht := (transport_ratio_tendsto N).mul_const B.toReal |
| simp only [one_mul] at ht |
| apply ge_of_tendsto ht |
| filter_upwards [eventually_gt_atTop (1 : ℝ)] with Y hY |
| exact hineq Y hY |
| |
| lemma rootJac_integral_lt_top (P : ProbabilityMeasure DiskClass) (k σ : ℝ) : |
| (∫⁻ g, rootJac k σ g ∂(P : Measure DiskClass)) < ∞ := by |
| have hc : Continuous (fun g : DiskClass => σ*normalizedJacobian (classFun g) k Complex.I) := |
| continuous_const.mul ((continuous_class_normalizedJacobian k).comp |
| (continuous_id.prodMk (continuous_const (y := halfOne)))) |
| have hi : Integrable (fun g : DiskClass => σ*normalizedJacobian (classFun g) k Complex.I) (P : Measure DiskClass) := |
| hc.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| apply lt_of_le_of_lt (lintegral_mono (fun g => ENNReal.ofReal_le_ofReal (le_abs_self _))) |
| exact (hasFiniteIntegral_iff_norm _).mp hi.2 |
| |
| lemma windowTest_le (k N : ℝ) (g : DiskClass) : windowTest k N g ≤ rootJac k 1 g := by |
| by_cases hg : g ∈ rootWindow k N <;> simp [windowTest,indicator_of_mem,indicator_of_notMem,hg] |
| |
| lemma windowTest_integral_lt_top (P : ProbabilityMeasure DiskClass) (k N : ℝ) : |
| (∫⁻ g, windowTest k N g ∂(P : Measure DiskClass)) < ∞ := |
| (lintegral_mono (windowTest_le k N)).trans_lt (rootJac_integral_lt_top P k 1) |
| |
| lemma windowTest_mono {k : ℝ} (hk : 0 < k) : |
| Monotone (fun n : ℕ => windowTest k (n+1)) := by |
| intro n m hnm g |
| have hs : rootWindow k (n+1) ⊆ rootWindow k (m+1) := |
| fun g hg => transportWindow_mono hk (by exact_mod_cast Nat.add_le_add_right hnm 1) hg |
| by_cases hg : g ∈ rootWindow k (n+1) |
| · simp only [windowTest,indicator_of_mem hg,indicator_of_mem (hs hg),le_refl] |
| · simp only [windowTest,indicator_of_notMem hg] |
| exact bot_le |
| |
| lemma iSup_windowTest {k : ℝ} (hk : 0 < k) (g : DiskClass) : |
| (⨆ n : ℕ, windowTest k (n+1) g) = |
| {g : DiskClass | (g,halfOne) ∈ pairingDomain k}.indicator (rootJac k 1) g := by |
| by_cases hg : (g,halfOne) ∈ pairingDomain k |
| · rw [indicator_of_mem (show g ∈ {g : DiskClass | (g,halfOne) ∈ pairingDomain k} from hg)] |
| apply le_antisymm (iSup_le (fun n : ℕ => windowTest_le k (n+1) g)) |
| have hu : (g,halfOne) ∈ ⋃ n : ℕ, transportWindow k (n+1) := (iUnion_transportWindow hk).symm ▸ hg |
| obtain ⟨n,hn⟩ := mem_iUnion.mp hu |
| have he : windowTest k (n+1) g = rootJac k 1 g := indicator_of_mem (show g ∈ rootWindow k (n+1) from hn) _ |
| exact he ▸ le_iSup (fun n : ℕ => windowTest k (n+1) g) n |
| · rw [indicator_of_notMem (show g ∉ {g : DiskClass | (g,halfOne) ∈ pairingDomain k} from hg)] |
| apply le_antisymm _ bot_le |
| apply iSup_le |
| intro n |
| apply le_of_eq |
| apply indicator_of_notMem |
| intro hn |
| exact hg hn.1 |
| |
| lemma rootJac_eq_window_exception {k : ℝ} (hk : 0 < k) (g : DiskClass) : |
| rootJac k 1 g = (⨆ n : ℕ, windowTest k (n+1) g) + exceptionTest k g := by |
| rw [iSup_windowTest hk g,exceptionTest] |
| by_cases hG : GoodPair (classFun g) k (criticalMap (classFun g) k Complex.I) |
| · rw [indicator_of_notMem (show g ∉ rootException k from fun h => h hG),add_zero] |
| by_cases hJ : 0 < normalizedJacobian (classFun g) k Complex.I |
| · exact (indicator_of_mem (show g ∈ {g : DiskClass | (g,halfOne) ∈ pairingDomain k} from ⟨hJ,hG⟩) _).symm |
| · rw [indicator_of_notMem (show g ∉ {g : DiskClass | (g,halfOne) ∈ pairingDomain k} from fun h => hJ h.1)] |
| exact ENNReal.ofReal_eq_zero.mpr (by simpa only [one_mul] using le_of_not_gt hJ) |
| · rw [indicator_of_mem (show g ∈ rootException k from hG),indicator_of_notMem (show g ∉ {g : DiskClass | (g,halfOne) ∈ pairingDomain k} from fun h => hG h.2),zero_add] |
| |
| lemma jacobian_positive_le_negative (P : ProbabilityMeasure DiskClass) (β : ℝ) |
| (hP : HasWeightedLaw P β) {k : ℝ} (hk : 0 < k) |
| (hb : β-1 = 4*(k-1)) |
| (hg : ∀ᵐ g ∂(P : Measure DiskClass), ∀ᵐ ξ : ℂ, GoodPair (classFun g) k ξ) : |
| (∫⁻ g, rootJac k 1 g ∂(P : Measure DiskClass)) ≤ ∫⁻ g, rootJac k (-1) g ∂(P : Measure DiskClass) := by |
| have hw (n : ℕ) : (∫⁻ g, windowTest k (n+1) g ∂(P : Measure DiskClass)) ≤ ∫⁻ g, rootJac k (-1) g ∂(P : Measure DiskClass) := by |
| apply transport_box_limit (N := (n:ℝ)+1) (windowTest_integral_lt_top P k (n+1)).ne (rootJac_integral_lt_top P k (-1)).ne |
| (by have h := Nat.cast_nonneg (α := ℝ) n; linarith : (1 : ℝ) ≤ n+1) |
| intro Y hY |
| exact expected_transport_box P β hP hk hb (by have h := Nat.cast_nonneg (α := ℝ) n; linarith) (sq_nonneg Y) hY.le |
| have he (g : DiskClass) := rootJac_eq_window_exception hk g |
| simp_rw [he] |
| rw [lintegral_add_left (Measurable.iSup (fun n : ℕ => measurable_windowTest hk (n+1))), |
| exceptionTest_integral_zero P β hP hk hg,add_zero,lintegral_iSup (fun n : ℕ => measurable_windowTest hk (n+1)) (windowTest_mono hk)] |
| exact iSup_le hw |
| |
| end Brennan |
| |
| end |
| |
| end OAI |
| |
