lean/OAI/Probability/DirectionalWalk/RadiusMoment.lean

import OAI.Probability.DirectionalWalk.RadiusLaunch

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

def finiteHighMaximum {d : ℕ} (v : Fin d → ℝ) (L : ℝ) : Set (Path d) :=
  {X | (∃ b : ℕ, ∀ n, height v (X n) ≤ b) ∧ ∃ j, L ≤ height v (X j)}

lemma measurableSet_finiteHighMaximum {d : ℕ} (v : Fin d → ℝ) (L : ℝ) :
    MeasurableSet (finiteHighMaximum v L) := by
  simp only [finiteHighMaximum,Set.ofPred_and,Set.ofPred_exists]
  exact (MeasurableSet.iUnion fun b : ℕ => measurableSet_alwaysBelow v b).inter
    (MeasurableSet.iUnion fun j => measurableSet_le measurable_const
      ((measurable_of_countable (height v)).comp (measurable_pi_apply j)))

lemma finiteHighMaximum_mono {d : ℕ} (v : Fin d → ℝ) {L U : ℝ} (h : L ≤ U) :
    finiteHighMaximum v U ⊆ finiteHighMaximum v L := by
  rintro X ⟨hb,j,hj⟩
  exact ⟨hb,j,h.trans hj⟩

lemma tendsto_measure_finiteHighMaximum {d : ℕ} (P : Measure (Path d)) [IsFiniteMeasure P]
    (v : Fin d → ℝ) : Tendsto (fun n : ℕ => P (finiteHighMaximum v n)) atTop (𝓝 0) := by
  have hh : (⋂ n : ℕ, finiteHighMaximum v n) = ∅ := by
    apply Set.eq_empty_iff_forall_notMem.mpr
    intro X hX
    have h := Set.mem_iInter.mp hX
    obtain ⟨b,hb⟩ := (h 0).1
    obtain ⟨j,hj⟩ := (h (b+1)).2
    have hb' := hb j
    have : (b:ℝ)+1 ≤ b := by simpa only [Nat.cast_add,Nat.cast_one] using hj.trans hb'
    linarith
  have hm := tendsto_measure_iInter_atTop
    (fun n : ℕ => (measurableSet_finiteHighMaximum v n).nullMeasurableSet (μ := P))
    (fun m n hmn => finiteHighMaximum_mono v (by exact_mod_cast hmn))
    (show ∃ i : ℕ, P (finiteHighMaximum v i) ≠ ⊤ from ⟨0,measure_ne_top _ _⟩)
  simpa only [hh,measure_empty,Function.comp_def] using hm

lemma measurableSet_goodSlabPath {d : ℕ} (v : Fin d → ℝ) :
    MeasurableSet {X : Path d | GoodSlabPath v X} := by
  simp only [GoodSlabPath,Set.ofPred_and,Set.ofPred_forall]
  exact (measurableSet_eq_fun (measurable_pi_apply 0) measurable_const).inter
    (MeasurableSet.iInter fun k => (Set.to_countable {γ | RegenerationWord v γ}).measurableSet.preimage
      ((measurable_pi_apply k).comp (measurable_slabs v)))

def radiusTemplate {d : ℕ} (v : Fin d → ℝ) (a c C b : ℝ) (q : ℕ) : Set (Path d) :=
  {Z | GoodSlabPath v Z} ∩ goodRadiusPrefix v a c C b q

lemma measurableSet_radiusTemplate {d : ℕ} (v : Fin d → ℝ) (a c C b : ℝ) (q : ℕ) :
    MeasurableSet (radiusTemplate v a c C b q) :=
  (measurableSet_goodSlabPath v).inter (measurableSet_goodRadiusPrefix v a c C b q)

lemma annealed_radiusTemplate {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v)) (a c C b : ℝ) (q : ℕ) :
    annealed μ 0 (radiusTemplate v a c C b q) = annealed μ 0 (nonBacktracking v) *
      conditioned μ v (goodRadiusPrefix v a c C b q) := by
  have hsub : radiusTemplate v a c C b q ⊆ nonBacktracking v :=
    fun Z hZ t => goodSlabPath_height_nonneg v Z hZ.1 t
  have he : conditioned μ v (radiusTemplate v a c C b q) =
      conditioned μ v (goodRadiusPrefix v a c C b q) := by
    apply measure_congr
    filter_upwards [ae_goodSlabPath μ hell v hv hp] with Z hZ
    exact propext ⟨fun h => h.2, fun h => ⟨hZ, h⟩⟩
  have hh := cond_mul_eq_inter (measurableSet_nonBacktracking v) (radiusTemplate v a c C b q) (annealed μ 0)
  rw [Set.inter_eq_right.mpr hsub] at hh
  change conditioned μ v (radiusTemplate v a c C b q) * _ = _ at hh
  rw [he,mul_comm] at hh
  exact hh.symm

lemma shiftPath_add_neg_cancel {d : ℕ} (x : Site d) (Z : Path d) :
    shiftPath (-x) (shiftPath x Z) = Z := by
  funext t
  simp [shiftPath]

lemma shiftPath_neg_add_cancel {d : ℕ} (x : Site d) (Z : Path d) :
    shiftPath x (shiftPath (-x) Z) = Z := by
  funext t
  simp [shiftPath]

lemma annealed_translated_event {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (x : Site d) {E : Set (Path d)} (hE : MeasurableSet E) :
    annealed μ x (shiftPath (-x) ⁻¹' E) = annealed μ 0 E := by
  have hh := congrArg (fun P : Measure (Path d) => P (shiftPath (-x) ⁻¹' E)) (annealed_shift μ 0 x)
  rw [zero_add,Measure.map_apply (measurable_shiftPath x) ((measurable_shiftPath (-x)) hE)] at hh
  have he : shiftPath x ⁻¹' (shiftPath (-x) ⁻¹' E) = E := by
    ext Z
    simp only [Set.mem_preimage,shiftPath_add_neg_cancel]
  rw [he] at hh
  exact hh.symm

lemma radius_launch_cylinder_lower {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (v : Fin d → ℝ) (u e : Step d) (a β c C b L U : ℝ)
    (ha : 0 ≤ a) (hβ : 0 ≤ β) (hbc : 1 ≤ β*c) (hta : 1 < β*a)
    (he : height v (stepVector e) = -1) (M q : ℕ)
    (hM : (M : ℝ) < a*(M*β-1-β*b)) (hq : U-M-c*q+b < 0)
    (γ : Path d) (n : ℕ) (hr : radiusLaunch v u (β*a) L U γ n) :
    (meanStep μ e ^ M * annealed μ 0 (radiusTemplate (-v) a c C b q)) *
      annealed μ 0 (pathCylinder n γ) ≤
      annealed μ 0 (pathCylinder n γ ∩ finiteHighMaximum v L) := by
  let δ := concatPath n γ (axialRay (γ n) e)
  let x := axialRay (γ n) e M
  let F := shiftPath (-x) ⁻¹' radiusTemplate (-v) a c C b q
  let K : Set (Site d) := {y | ∃ i < n+M, δ i = y}
  have hF : MeasurableSet F :=
    (measurable_shiftPath (-x)) (measurableSet_radiusTemplate (-v) a c C b q)
  have hx : δ (n+M) = x := concatPath_after _ _ _ _
  have hFK : F ⊆ avoids K := by
    intro W hW t
    rintro ⟨i,hi,hii⟩
    let Z := shiftPath (-x) W
    have hz : W = shiftPath x Z := (shiftPath_neg_add_cancel x W).symm
    have hZ : Z ∈ radiusTemplate (-v) a c C b q := hW
    have hsep := radius_template_avoids v u e a β c C b U ha hβ hbc he M q hM hq
      γ hr.1 hr.2.1 (hr.2.2.2 n le_rfl) Z hZ.1 hZ.2 i hi t
    apply hsep
    have hwt : W t = Z t+x := congr_fun hz t
    exact hwt.symm.trans hii.symm
  have hraw : annealed μ x F = annealed μ 0 (radiusTemplate (-v) a c C b q) :=
    annealed_translated_event μ x (measurableSet_radiusTemplate (-v) a c C b q)
  have hfac := annealed_fresh_prefix_tail μ K 0 (n+M) δ (fun i hi => ⟨i,hi,rfl⟩) hF
  rw [Set.inter_eq_left.mpr hFK,hx,hraw] at hfac
  have hscript : annealed μ 0 (pathCylinder (n+M) δ) =
      annealed μ 0 (pathCylinder n γ) * meanStep μ e ^ M := by
    have hh := annealed_disjoint_prefix_tail μ 0 n M γ (axialRay (γ n) e)
      (axialRay_zero _ _).symm (fun i hi j _ => radius_script_fresh v u e (β*a) hta he γ hr.1 i hi j)
    rw [prefix_tail_inter,ite_eq_left (axialRay_zero _ _).symm,annealed_axialRay] at hh
    exact hh
  have hsub : pathCylinder (n+M) δ ∩ tailPath (n+M) ⁻¹' F ⊆
      pathCylinder n γ ∩ finiteHighMaximum v L := by
    rintro Y ⟨hY,hT⟩
    let Z := shiftPath (-x) (tailPath (n+M) Y)
    have hZ : Z ∈ radiusTemplate (-v) a c C b q := hT
    have ht : tailPath (n+M) Y = shiftPath x Z :=
      (shiftPath_neg_add_cancel x (tailPath (n+M) Y)).symm
    have hy : Y ∈ pathCylinder n γ := by
      intro i hi
      rw [hY i (by omega)]
      exact concatPath_before _ _ _ (axialRay_zero _ _).symm hi
    refine ⟨hy,?_,?_⟩
    · obtain ⟨b',hb'⟩ := exists_nat_ge U
      exact ⟨b',fun i => (radius_continuation_maximum v e he γ Y Z n M hY ht hZ.1 U hr.2.2.2 i).trans hb'⟩
    · obtain ⟨j,hj,hjl⟩ := hr.2.2.1
      exact ⟨j,by rw [hy j hj];exact hjl⟩
  have hm := measure_mono (μ := annealed μ 0) hsub
  rw [hfac,hscript] at hm
  convert hm using 1; ac_rfl

lemma radius_launch_probability_lower {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (v : Fin d → ℝ) (u e : Step d) (a β c C b L U : ℝ)
    (ha : 0 ≤ a) (hβ : 0 ≤ β) (hbc : 1 ≤ β*c) (hta : 1 < β*a)
    (he : height v (stepVector e) = -1) (M q : ℕ)
    (hM : (M : ℝ) < a*(M*β-1-β*b)) (hq : U-M-c*q+b < 0) :
    (meanStep μ e ^ M * annealed μ 0 (radiusTemplate (-v) a c C b q)) *
      annealed μ 0 {X | ∃ n, radiusLaunch v u (β*a) L U X n} ≤
      annealed μ 0 (finiteHighMaximum v L) :=
  measure_first_prefix_lower (annealed μ 0) (radiusLaunch v u (β*a) L U)
    (measurableSet_radiusLaunch v u (β*a) L U)
    (fun _ _ h _ hY => radiusLaunch_prefix v u (β*a) L U h hY)
    (measurableSet_finiteHighMaximum v L) _
    (radius_launch_cylinder_lower μ v u e a β c C b L U ha hβ hbc hta he M q hM hq)

lemma controlledSlabOccurrence_launch {d : ℕ} (v : Fin d → ℝ) (X : Path d)
    (hX : GoodSlabPath v X) (a B β c C b L : ℝ) (ha : 0 < a) (hβ : 0 ≤ β)
    (hc : 0 ≤ c) (hC : 0 ≤ C) (hB : Real.sqrt d*(2+β*(C+2)) < B-1)
    (l N : ℕ) (hl : b ≤ l+1) (hL : L ≤ c*l-b)
    (hocc : X ∈ controlledSlabOccurrence v a c C b
      (largeRadiusWord slabRadius (slabWidth v) (B*a)) (Finset.Ico l N)) :
    ∃ e : Step d, ∃ n, radiusLaunch v e (β*a) L ((C+2)*N) X n := by
  obtain ⟨k,hk,hgp,hbig⟩ := Set.mem_iUnion₂.mp hocc
  have hki := Finset.mem_Ico.mp hk
  have hg := (goodRadiusPrefix_iff v a c C b k X).mp hgp k le_rfl
  have hwidth : slabWidth v (slabs v X k) ≤ k+1 := hbig.2
  apply largeRadius_launch v X hX a B β (C+2) L ((C+2)*N) ha hβ (by linarith) hB hbig.1 hg.2.2
  · have hb : b ≤ (k : ℝ)+1 := hl.trans (by exact_mod_cast Nat.add_le_add_right hki.1 1)
    rw [slabHeightSum,Finset.sum_range_succ]
    change slabHeightSum v X k + slabWidth v (slabs v X k) ≤ _
    nlinarith [hg.2.1]
  · exact hL.trans ((sub_le_sub_right (mul_le_mul_of_nonneg_left
      (Nat.cast_le.mpr hki.1) hc) b).trans hg.1)
  · exact mul_le_mul_of_nonneg_left (by exact_mod_cast (show k+1 ≤ N by omega)) (by linarith)

lemma annealed_goodSlabPath_event {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v)) (E : Set (Path d)) :
    annealed μ 0 ({X | GoodSlabPath v X} ∩ E) =
      annealed μ 0 (nonBacktracking v) * conditioned μ v E := by
  have hsub : {X | GoodSlabPath v X} ∩ E ⊆ nonBacktracking v :=
    fun X hX t => goodSlabPath_height_nonneg v X hX.1 t
  have he : conditioned μ v ({X | GoodSlabPath v X} ∩ E) = conditioned μ v E := by
    apply measure_congr
    filter_upwards [ae_goodSlabPath μ hell v hv hp] with X hX
    exact propext ⟨fun h => h.2,fun h => ⟨hX,h⟩⟩
  have hh := cond_mul_eq_inter (measurableSet_nonBacktracking v)
    ({X | GoodSlabPath v X} ∩ E) (annealed μ 0)
  rw [Set.inter_eq_right.mpr hsub] at hh
  change conditioned μ v ({X | GoodSlabPath v X} ∩ E) * _ = _ at hh
  rw [he,mul_comm] at hh
  exact hh.symm

lemma radius_occurrence_probability_upper {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v)) (e : Step d)
    (a B β c C b L : ℝ) (ha : 0 < a) (hβ : 0 ≤ β) (hc : 0 ≤ c) (hC : 0 ≤ C)
    (hB : Real.sqrt d*(2+β*(C+2)) < B-1)
    (hbc : 1 ≤ β*c) (hta : 1 < β*a) (he : height v (stepVector e) = -1)
    (M q l N : ℕ) (hM : (M : ℝ) < a*(M*β-1-β*b))
    (hq : (C+2)*N-M-c*q+b < 0) (hl : b ≤ l+1) (hL : L ≤ c*l-b) :
    ((meanStep μ e ^ M * annealed μ 0 (radiusTemplate (-v) a c C b q)).toReal *
      (annealed μ 0).real (nonBacktracking v)) *
      (conditioned μ v).real (controlledSlabOccurrence v a c C b
        (largeRadiusWord slabRadius (slabWidth v) (B*a)) (Finset.Ico l N)) ≤
      (Fintype.card (Step d) : ℝ) * (annealed μ 0).real (finiteHighMaximum v L) := by
  let A := controlledSlabOccurrence v a c C b
    (largeRadiusWord slabRadius (slabWidth v) (B*a)) (Finset.Ico l N)
  let E (u : Step d) : Set (Path d) := {X | ∃ n, radiusLaunch v u (β*a) L ((C+2)*N) X n}
  let κ := meanStep μ e ^ M * annealed μ 0 (radiusTemplate (-v) a c C b q)
  have hsub : {X | GoodSlabPath v X} ∩ A ⊆ ⋃ u : Step d, E u := by
    intro X hX
    obtain ⟨u,n,hn⟩ := controlledSlabOccurrence_launch v X hX.1 a B β c C b L ha hβ hc hC hB l N hl hL hX.2
    exact Set.mem_iUnion.mpr ⟨u,n,hn⟩
  have hmass := (measureReal_mono (μ := annealed μ 0) hsub (measure_ne_top _ _)).trans
    (measureReal_iUnion_fintype_le (μ := annealed μ 0) E)
  have heq : (annealed μ 0).real ({X | GoodSlabPath v X} ∩ A) =
      (annealed μ 0).real (nonBacktracking v) * (conditioned μ v).real A := by
    exact (congrArg ENNReal.toReal (annealed_goodSlabPath_event μ hell v hv hp A)).trans ENNReal.toReal_mul
  rw [heq] at hmass
  have hu (u : Step d) : κ.toReal * (annealed μ 0).real (E u) ≤
      (annealed μ 0).real (finiteHighMaximum v L) := by
    have hh := radius_launch_probability_lower μ v u e a β c C b L ((C+2)*N)
      ha.le hβ hbc hta he M q hM hq
    have hh' := ENNReal.toReal_mono (measure_ne_top (annealed μ 0) _) hh
    simpa only [κ,E,Measure.real,ENNReal.toReal_mul] using hh'
  calc
    _ = κ.toReal*((annealed μ 0).real (nonBacktracking v)*(conditioned μ v).real A) := by ring
    _ ≤ κ.toReal * ∑ u : Step d, (annealed μ 0).real (E u) := mul_le_mul_of_nonneg_left hmass ENNReal.toReal_nonneg
    _ = ∑ u : Step d, κ.toReal * (annealed μ 0).real (E u) := Finset.mul_sum _ _ _
    _ ≤ ∑ _u : Step d, (annealed μ 0).real (finiteHighMaximum v L) := Finset.sum_le_sum (fun u _ => hu u)
    _ = _ := by simp

lemma radius_occurrence_mass_le {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v))
    (hp' : 0 < annealed μ 0 (nonBacktracking (-v))) (e : Step d)
    (a B β c C b L : ℝ) (ha : 0 < a) (hβ : 0 ≤ β) (hc : 0 ≤ c) (hC : 0 ≤ C)
    (hB : Real.sqrt d*(2+β*(C+2)) < B-1)
    (hbc : 1 ≤ β*c) (hta : 1 < β*a) (he : height v (stepVector e) = -1)
    (M q l N : ℕ) (hM : (M : ℝ) < a*(M*β-1-β*b))
    (hq : (C+2)*N-M-c*q+b < 0) (hl : b ≤ l+1) (hL : L ≤ c*l-b)
    (hgp : ∀ i ∈ Finset.Ico l N, (3:ℝ)/4 ≤
      (conditioned μ v).real (goodRadiusPrefix v a c C b i))
    (htp : (3:ℝ)/4 ≤ (conditioned μ (-v)).real (goodRadiusPrefix (-v) a c C b q))
    (hs : (∑ i ∈ Finset.Ico l N, (slabLaw μ v).real
      (largeRadiusWord slabRadius (slabWidth v) (B*a) i)) ≤ 1/4) :
    ((meanStep μ e ^ M).toReal * (annealed μ 0).real (nonBacktracking v) *
      (annealed μ 0).real (nonBacktracking (-v)) * (3/8)) *
      (∑ i ∈ Finset.Ico l N, (slabLaw μ v).real
        (largeRadiusWord slabRadius (slabWidth v) (B*a) i)) ≤
      (Fintype.card (Step d) : ℝ) * (annealed μ 0).real (finiteHighMaximum v L) := by
  have hh := radius_occurrence_probability_upper μ hell v hv hp e a B β c C b L
    ha hβ hc hC hB hbc hta he M q l N hM hq hl hL
  have ht := congrArg ENNReal.toReal (annealed_radiusTemplate μ hell (-v) (neg_ne_zero.mpr hv) hp' a c C b q)
  rw [ENNReal.toReal_mul] at ht
  have ho := controlledSlabOccurrence_probability_half μ hell v hv hp a c C b
    (largeRadiusWord slabRadius (slabWidth v) (B*a)) (Finset.Ico l N) hgp hs
  rw [ENNReal.toReal_mul,ht] at hh
  have hn : 0 ≤ ∑ i ∈ Finset.Ico l N, (slabLaw μ v).real
      (largeRadiusWord slabRadius (slabWidth v) (B*a) i) :=
    Finset.sum_nonneg (fun _ _ => measureReal_nonneg)
  have hcoef : 0 ≤ (meanStep μ e ^ M).toReal * (annealed μ 0).real (nonBacktracking (-v)) *
      (annealed μ 0).real (nonBacktracking v) := by positivity
  have hmul := mul_le_mul_of_nonneg_left (mul_le_mul htp ho (by positivity) measureReal_nonneg) hcoef
  calc
    _ = ((meanStep μ e ^ M).toReal * (annealed μ 0).real (nonBacktracking (-v)) *
      (annealed μ 0).real (nonBacktracking v)) * ((3/4)*
      ((∑ i ∈ Finset.Ico l N, (slabLaw μ v).real
        (largeRadiusWord slabRadius (slabWidth v) (B*a) i))/2)) := by ring
    _ ≤ _ := hmul
    _ = _ := by unfold Measure.real; ring
    _ ≤ _ := hh

lemma goodRadiusPrefix_uniform_probability {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v)) (a c C b : ℝ) (ha : 0 < a)
    (n : ℕ) (hn : 0 < n)
    (hheight : (15:ℝ)/16 ≤ (conditioned μ v).real
      (heightEnvelope (fun k X => slabHeightSum v X k) c C b))
    (htrunc : truncatedMoment (slabLaw μ v) slabRadius (a*n) ≤ 3*a/32) :
    ∀ i ≤ n, (3:ℝ)/4 ≤ (conditioned μ v).real (goodRadiusPrefix v a c C b i) := by
  let := conditioned_probability μ v hp
  have hh := goodRadiusPrefix_probability μ hell v hv hp a c C b ha n hn
  have hb : 2*truncatedMoment (slabLaw μ v) slabRadius (a*n)/a ≤ 3/16 := by
    apply (div_le_iff₀ ha).mpr
    linarith
  intro i hi
  exact (show (3:ℝ)/4 ≤ (conditioned μ v).real (goodRadiusPrefix v a c C b n) by linarith).trans
    (measureReal_mono (goodRadiusPrefix_mono v a c C b hi) (measure_ne_top _ _))

lemma summable_real_upper_tail {Ω : Type*} [MeasurableSpace Ω]
    (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f)
    (hfi : Integrable f P) : Summable (fun n : ℕ => P.real {x | (n+1 : ℝ) < f x}) := by
  apply Summable.of_nonneg_of_le (fun _ => measureReal_nonneg) (fun n =>
    measureReal_mono (fun x hx => hx.trans_le (le_abs_self (f x))) (measure_ne_top _ _))
  exact summable_real_tail_of_integrable P (fun x => |f x|) hfm.abs (fun _ => abs_nonneg _) hfi.abs

lemma summable_small_Ico (f : ℕ → ℝ) (hf : Summable f) (hn : ∀ i, 0 ≤ f i)
    {ε : ℝ} (hε : 0 < ε) : ∀ᶠ l : ℕ in atTop, ∀ n, l ≤ n → ∑ i ∈ Finset.Ico l n, f i < ε := by
  have ht : Tendsto (fun l : ℕ => (∑' i, f i) - ∑ i ∈ Finset.range l, f i) atTop (𝓝 0) := by
    have hh : Tendsto (fun _ : ℕ => ∑' i, f i) atTop (𝓝 (∑' i, f i)) := tendsto_const_nhds
    simpa only [sub_self] using hh.sub hf.hasSum.tendsto_sum_nat
  filter_upwards [ht.eventually (gt_mem_nhds hε)] with l hl n hln
  rw [Finset.sum_Ico_eq_sub f hln]
  exact (sub_le_sub_right (hf.sum_le_tsum (Finset.range n) (fun _ _ => hn _)) _).trans_lt hl

lemma measurable_slabHeightSum {d : ℕ} (v : Fin d → ℝ) (k : ℕ) :
    Measurable (fun X : Path d => slabHeightSum v X k) := by
  apply Finset.measurable_sum
  intro i hi
  exact (measurable_of_countable (slabWidth v)).comp
    ((measurable_pi_apply i).comp (measurable_slabs v))

lemma exists_common_heightEnvelope {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hvnorm : ∀ i, |v i| ≤ 1) (hp : 0 < annealed μ 0 (nonBacktracking v))
    (hp' : 0 < annealed μ 0 (nonBacktracking (-v))) :
    ∃ c C b : ℝ, 0 < c ∧ 0 ≤ C ∧ 0 ≤ b ∧
      (15:ℝ)/16 ≤ (conditioned μ v).real
        (heightEnvelope (fun k X => slabHeightSum v X k) c C b) ∧
      (15:ℝ)/16 ≤ (conditioned μ (-v)).real
        (heightEnvelope (fun k X => slabHeightSum (-v) X k) c C b) := by
  let := conditioned_probability μ v hp
  let := conditioned_probability μ (-v) hp'
  have hv' : -v ≠ 0 := neg_ne_zero.mpr hv
  have hvnorm' : ∀ i, |(-v) i| ≤ 1 := by simpa only [Pi.neg_apply,abs_neg] using hvnorm
  let m := ∫ γ, slabWidth v γ ∂slabLaw μ v
  let m' := ∫ γ, slabWidth (-v) γ ∂slabLaw μ (-v)
  have hm : 0 < m := integral_slabWidth_pos μ hell v hv hvnorm hp
  have hm' : 0 < m' := integral_slabWidth_pos μ hell (-v) hv' hvnorm' hp'
  let c := min m m'/2
  let C := m+m'+1
  have hc : 0 < c := half_pos (lt_min hm hm')
  have hcm : c < m := (half_lt_self (lt_min hm hm')).trans_le (min_le_left _ _)
  have hcm' : c < m' := (half_lt_self (lt_min hm hm')).trans_le (min_le_right _ _)
  obtain ⟨b,hb,hbe⟩ := exists_heightEnvelope_probability (conditioned μ v)
    (fun k X => slabHeightSum v X k) (measurable_slabHeightSum v)
    (slabWidth_strongLaw μ hell v hv hvnorm hp) hcm (show m < C by dsimp [C]; linarith)
    (by norm_num : (15:ℝ)/16 < 1)
  obtain ⟨b',hb',hbe'⟩ := exists_heightEnvelope_probability (conditioned μ (-v))
    (fun k X => slabHeightSum (-v) X k) (measurable_slabHeightSum (-v))
    (slabWidth_strongLaw μ hell (-v) hv' hvnorm' hp') hcm' (show m' < C by dsimp [C]; linarith)
    (by norm_num : (15:ℝ)/16 < 1)
  refine ⟨c,C,max b b',hc,by dsimp [C]; linarith,hb.trans (le_max_left _ _),?_,?_⟩
  · exact hbe.le.trans (measureReal_mono (heightEnvelope_mono _ c C (le_max_left _ _)) (measure_ne_top _ _))
  · exact hbe'.le.trans (measureReal_mono (heightEnvelope_mono _ c C (le_max_right _ _)) (measure_ne_top _ _))

lemma truncatedMoment_component_scale {Ω : Type*} [MeasurableSpace Ω]
    (P Q : Measure Ω) [IsFiniteMeasure P] [IsFiniteMeasure Q]
    (f : Ω → ℝ) (hfm : Measurable f) (hf : ∀ x, 0 ≤ f x)
    {a : ℝ} (ha : 0 < a) (r n : ℕ) (hr : 1 ≤ r)
    (hs : truncatedMoment (P+Q) f (a*n) < a/(32*r)) :
    truncatedMoment P f (a*(r*n)) ≤ 3*a/32 := by
  have hnon := truncatedMoment_nonneg Q f (fun x => hf x) (t := a*(r*n)) (by positivity)
  have hadd := truncatedMoment_add_measure P Q f hfm hf (t := a*(r*n)) (by positivity)
  have ht := truncatedMoment_mul_le (P+Q) f hfm hf (t := a*n) (by positivity)
    (show (1:ℝ) ≤ r by exact_mod_cast hr)
  have hmul := mul_lt_mul_of_pos_left hs (show (0:ℝ) < r by exact_mod_cast (by omega : 0 < r))
  have he : (r : ℝ)*(a/(32*r)) = a/32 := by
    have hr0 : (r:ℝ) ≠ 0 := by exact_mod_cast (by omega : r ≠ 0)
    field_simp
  rw [he] at hmul
  have he' : (r:ℝ)*(a*n) = a*(r*n) := by ring
  rw [he'] at ht
  linarith

lemma tendsto_real_finiteHighMaximum {d : ℕ} (P : Measure (Path d)) [IsFiniteMeasure P]
    (v : Fin d → ℝ) : Tendsto (fun n : ℕ => P.real (finiteHighMaximum v n)) atTop (𝓝 0) := by
  simpa only [Function.comp_def,Measure.real,ENNReal.toReal_zero] using
    (ENNReal.tendsto_toReal ENNReal.zero_ne_top).comp (tendsto_measure_finiteHighMaximum P v)

lemma meanStep_power_real_pos {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d) (M : ℕ) : 0 < (meanStep μ e ^ M).toReal :=
  ENNReal.toReal_pos (pow_ne_zero _ (ne_of_gt (meanStep_pos μ hell e)))
    (ne_of_lt (lt_of_le_of_lt (pow_le_one₀ zero_le (meanStep_le_one μ e)) ENNReal.one_lt_top))

lemma integrable_radius_from_parameters {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hvnorm : ∀ i, |v i| ≤ 1) (hp : 0 < annealed μ 0 (nonBacktracking v))
    (hp' : 0 < annealed μ 0 (nonBacktracking (-v))) (e e' : Step d)
    (he : height v (stepVector e) = -1) (he' : height (-v) (stepVector e') = -1)
    (c C b β B : ℝ) (hc : 0 < c) (hC : 0 ≤ C) (hb : 0 ≤ b)
    (hβ : 0 < β) (hβc : 1 ≤ β*c) (hB : 1 ≤ B)
    (htilt : Real.sqrt d*(2+β*(C+2)) < B-1)
    (r : ℕ) (hr : 1 ≤ r) (hrc : C+3 < c*r)
    (hheight : (15:ℝ)/16 ≤ (conditioned μ v).real
      (heightEnvelope (fun k X => slabHeightSum v X k) c C b))
    (hheight' : (15:ℝ)/16 ≤ (conditioned μ (-v)).real
      (heightEnvelope (fun k X => slabHeightSum (-v) X k) c C b)) :
    Integrable slabRadius (slabLaw μ v + slabLaw μ (-v)) := by
  let := slabLaw_probability μ v hp
  let := slabLaw_probability μ (-v) hp'
  let := conditioned_probability μ v hp
  let := conditioned_probability μ (-v) hp'
  by_contra hnot
  have hv' : -v ≠ 0 := neg_ne_zero.mpr hv
  have hvnorm' : ∀ i, |(-v) i| ≤ 1 := by simpa only [Pi.neg_apply,abs_neg] using hvnorm
  have hr0 : (0:ℝ) < r := by exact_mod_cast (by omega : 0 < r)
  have hB0 : 0 < B := lt_of_lt_of_le zero_lt_one hB
  let η : ℝ := 1/(64*r)
  have hη : 0 < η := by dsimp [η]; positivity
  have hηsmall : 2*η ≤ 1/4 := by
    dsimp [η]
    rw [mul_one_div]
    have hr1 : (1:ℝ) ≤ r := by exact_mod_cast hr
    apply (div_le_iff₀ (by positivity : (0:ℝ) < 64*r)).mpr
    linarith
  obtain ⟨M,hM⟩ := exists_nat_gt ((2+β*b)/β)
  have hMcoef : 1 < (M:ℝ)*β-1-β*b := by
    have hm := (div_lt_iff₀ hβ).mp hM
    nlinarith only [hm]
  let p := (annealed μ 0).real (nonBacktracking v)
  let p' := (annealed μ 0).real (nonBacktracking (-v))
  have hp0 : 0 < p := ENNReal.toReal_pos hp.ne' (measure_ne_top _ _)
  have hp0' : 0 < p' := ENNReal.toReal_pos hp'.ne' (measure_ne_top _ _)
  let A := (meanStep μ e ^ M).toReal*p*p'*(3/8)
  let A' := (meanStep μ e' ^ M).toReal*p'*p*(3/8)
  have hA : 0 < A := by
    have := meanStep_power_real_pos μ hell e M
    dsimp [A]; positivity
  have hA' : 0 < A' := by
    have := meanStep_power_real_pos μ hell e' M
    dsimp [A']; positivity
  let Γ := min A A'
  have hΓ : 0 < Γ := lt_min hA hA'
  let K : ℝ := Fintype.card (Step d)
  have hlim : Tendsto (fun L : ℕ => K*((annealed μ 0).real (finiteHighMaximum v L)+
      (annealed μ 0).real (finiteHighMaximum (-v) L))) atTop (𝓝 0) := by
    simpa only [zero_add,mul_zero] using tendsto_const_nhds.mul
      ((tendsto_real_finiteHighMaximum (annealed μ 0) v).add
        (tendsto_real_finiteHighMaximum (annealed μ 0) (-v)))
  obtain ⟨L,hLsmall⟩ := (hlim.eventually (gt_mem_nhds (show (0:ℝ) < Γ*(η/(2*B)) by positivity))).exists
  have hsum := (summable_real_upper_tail (slabLaw μ v) (slabWidth v) (measurable_of_countable _)
    (integrable_slabWidth μ hell v hv hvnorm hp)).add
    (summable_real_upper_tail (slabLaw μ (-v)) (slabWidth (-v)) (measurable_of_countable _)
      (integrable_slabWidth μ hell (-v) hv' hvnorm' hp'))
  have hsmall := summable_small_Ico _ hsum (fun _ => add_nonneg measureReal_nonneg measureReal_nonneg)
    (show 0 < η/(4*B) by positivity)
  obtain ⟨l₁,hl₁⟩ := eventually_atTop.mp hsmall
  obtain ⟨l₀,hl₀⟩ := exists_nat_gt (max (b+1) (((L:ℝ)+b)/c))
  let l := max l₀ l₁
  have hlb : b+1 < (l:ℝ) := (lt_of_le_of_lt (le_max_left _ _) hl₀).trans_le
    (Nat.cast_le.mpr (le_max_left _ _))
  have hlL : (L:ℝ) ≤ c*l-b := by
    have hll : ((L:ℝ)+b)/c < (l:ℝ) := (lt_of_le_of_lt (le_max_right _ _) hl₀).trans_le
      (Nat.cast_le.mpr (le_max_left _ _))
    have hh := (div_lt_iff₀ hc).mp hll
    nlinarith only [hh]
  have hl0 : 0 < l := by
    have hh : (0:ℝ) < l := by linarith
    exact_mod_cast hh
  have hscales := radius_scales (slabLaw μ v + slabLaw μ (-v)) slabRadius
    (measurable_of_countable _) slabRadius_nonneg hnot hη l
    (show 0 < B*((l:ℝ)+1) by positivity)
  obtain ⟨a,ha,hlarge⟩ := ((eventually_gt_atTop (max ((M:ℝ)+1) (1/β+1))).and hscales).exists
  obtain ⟨ha0,N,hN,hsc,hscu,hscs,_⟩ := hlarge
  have hNl : l ≤ N := (le_max_right _ _).trans hN
  have hN0 : 0 < N := hl0.trans_le hNl
  have hβa : 1 < β*a := by
    have haa : 1/β+1 < a := lt_of_le_of_lt (le_max_right _ _) ha
    have hh := mul_lt_mul_of_pos_left haa hβ
    rw [mul_add,mul_one_div_cancel hβ.ne',mul_one] at hh
    linarith
  have hMa : (M:ℝ) < a*((M:ℝ)*β-1-β*b) := by
    have haa : (M:ℝ)+1 < a := lt_of_le_of_lt (le_max_left _ _) ha
    nlinarith only [mul_lt_mul_of_pos_left hMcoef ha0,haa]
  have hq : (C+2)*(N:ℝ)-(M:ℝ)-c*(r*N:ℕ)+b < 0 := by
    have hbn : b+1 < (N:ℝ) := hlb.trans_le (Nat.cast_le.mpr hNl)
    have hh := mul_lt_mul_of_pos_right hrc (Nat.cast_pos.mpr hN0)
    push_cast
    nlinarith only [hh,hbn,show (0:ℝ) ≤ M from Nat.cast_nonneg M]
  have hwidth := hl₁ l (le_max_right _ _) N hNl
  rw [Finset.sum_add_distrib] at hwidth
  have hsmallscale : truncatedMoment (slabLaw μ v + slabLaw μ (-v)) slabRadius
      (B*a*(l+1)) < η*a/4 := by
    convert hscs using 1; ring_nf
  have hlo := largeRadius_mass_pair_lower (slabLaw μ v) (slabLaw μ (-v))
    slabRadius (slabWidth v) (slabWidth (-v)) (measurable_of_countable _) slabRadius_nonneg
    ha0 hB hη hNl hsc hsmallscale hwidth
  have hup := largeRadius_mass_pair_upper (slabLaw μ v) (slabLaw μ (-v))
    slabRadius (slabWidth v) (slabWidth (-v)) (measurable_of_countable _) slabRadius_nonneg
    ha0 hB hNl hscu
  let lam := ∑ i ∈ Finset.Ico l N, (slabLaw μ v).real (largeRadiusWord slabRadius (slabWidth v) (B*a) i)
  let lam' := ∑ i ∈ Finset.Ico l N, (slabLaw μ (-v)).real (largeRadiusWord slabRadius (slabWidth (-v)) (B*a) i)
  have hlam : 0 ≤ lam := Finset.sum_nonneg (fun _ _ => measureReal_nonneg)
  have hlam' : 0 ≤ lam' := Finset.sum_nonneg (fun _ _ => measureReal_nonneg)
  change η/(2*B) ≤ lam+lam' at hlo
  change lam+lam' < 2*η at hup
  have hlams : lam ≤ 1/4 := by linarith
  have hlams' : lam' ≤ 1/4 := by linarith
  have hscsimple : truncatedMoment (slabLaw μ v + slabLaw μ (-v)) slabRadius (a*N) < a/(32*r) := by
    convert hscu using 1
    dsimp [η]
    field_simp [ne_of_gt hr0]
    ring
  have htr := truncatedMoment_component_scale (slabLaw μ v) (slabLaw μ (-v)) slabRadius
    (measurable_of_countable _) slabRadius_nonneg ha0 r N hr hscsimple
  have htr' := truncatedMoment_component_scale (slabLaw μ (-v)) (slabLaw μ v) slabRadius
    (measurable_of_countable _) slabRadius_nonneg ha0 r N hr (by simpa only [add_comm] using hscsimple)
  have hq0 : 0 < r*N := Nat.mul_pos (by omega) hN0
  have hNq : N ≤ r*N := Nat.le_mul_of_pos_left N (by omega)
  have hgood := goodRadiusPrefix_uniform_probability μ hell v hv hp a c C b ha0 (r*N) hq0 hheight (by simpa only [Nat.cast_mul] using htr)
  have hgood' := goodRadiusPrefix_uniform_probability μ hell (-v) hv' hp' a c C b ha0 (r*N) hq0 hheight' (by simpa only [Nat.cast_mul] using htr')
  have hpos := radius_occurrence_mass_le μ hell v hv hp hp' e a B β c C b L ha0 hβ.le hc.le hC
    htilt hβc hβa he M (r*N) l N hMa hq (by linarith) hlL
    (fun i hi => hgood i ((Finset.mem_Ico.mp hi).2.le.trans hNq)) (hgood' _ le_rfl) hlams
  have hneg := radius_occurrence_mass_le μ hell (-v) hv' hp' (by simpa only [neg_neg] using hp) e' a B β c C b L ha0 hβ.le hc.le hC
    htilt hβc hβa he' M (r*N) l N hMa hq (by linarith) hlL
    (fun i hi => hgood' i ((Finset.mem_Ico.mp hi).2.le.trans hNq)) (by simpa only [neg_neg] using hgood (r*N) le_rfl) hlams'
  change A*lam ≤ K*(annealed μ 0).real (finiteHighMaximum v L) at hpos
  simp only [neg_neg] at hneg
  change A'*lam' ≤ K*(annealed μ 0).real (finiteHighMaximum (-v) L) at hneg
  have hbound : Γ*(lam+lam') ≤ K*((annealed μ 0).real (finiteHighMaximum v L)+
      (annealed μ 0).real (finiteHighMaximum (-v) L)) := by
    have hh := add_le_add (mul_le_mul_of_nonneg_right (min_le_left A A') hlam)
      (mul_le_mul_of_nonneg_right (min_le_right A A') hlam')
    dsimp [Γ]
    nlinarith only [hh,hpos,hneg]
  have hh := mul_le_mul_of_nonneg_left hlo hΓ.le
  exact (not_lt_of_ge (hh.trans hbound)) hLsmall

lemma exists_down_unit_step {d : ℕ} (v : Fin d → ℝ) (hv : ∃ i, |v i| = 1) :
    ∃ e : Step d, height v (stepVector e) = -1 := by
  obtain ⟨i,hi⟩ := hv
  rcases le_total 0 (v i) with h | h
  · rw [abs_of_nonneg h] at hi
    exact ⟨(i,false),by simp [height_stepVector,hi]⟩
  · rw [abs_of_nonpos h] at hi
    exact ⟨(i,true),by simp [height_stepVector]; linarith⟩

lemma integrable_slabRadius_normalized {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hvnorm : ∀ i, |v i| ≤ 1) (hvunit : ∃ i, |v i| = 1)
    (hp : 0 < annealed μ 0 (nonBacktracking v))
    (hp' : 0 < annealed μ 0 (nonBacktracking (-v))) :
    Integrable slabRadius (slabLaw μ v) ∧ Integrable slabRadius (slabLaw μ (-v)) := by
  obtain ⟨c,C,b,hc,hC,hb,hh,hh'⟩ := exists_common_heightEnvelope μ hell v hv hvnorm hp hp'
  let β := 2/c
  have hβ : 0 < β := div_pos (by norm_num) hc
  have hβc : 1 ≤ β*c := by dsimp [β]; rw [div_mul_cancel₀ _ hc.ne']; norm_num
  let B := Real.sqrt d*(2+β*(C+2))+2
  have hB : 1 ≤ B := by
    have ht : 0 ≤ Real.sqrt d*(2+β*(C+2)) := by positivity
    dsimp [B]; linarith
  have htilt : Real.sqrt d*(2+β*(C+2)) < B-1 := by dsimp [B]; linarith
  obtain ⟨r,hr⟩ := exists_nat_gt (max 1 ((C+3)/c))
  have hr1 : 1 ≤ r := by
    have hh : (1:ℝ) < r := lt_of_le_of_lt (le_max_left _ _) hr
    have : 1 < r := by exact_mod_cast hh
    omega
  have hrc : C+3 < c*r := by
    have hh := (div_lt_iff₀ hc).mp (lt_of_le_of_lt (le_max_right _ _) hr)
    nlinarith only [hh]
  obtain ⟨e,he⟩ := exists_down_unit_step v hvunit
  obtain ⟨e',he'⟩ := exists_down_unit_step (-v) (by simpa only [Pi.neg_apply,abs_neg] using hvunit)
  exact integrable_add_measure.mp (integrable_radius_from_parameters μ hell v hv hvnorm hp hp'
    e e' he he' c C b β B hc hC hb hβ hβc hB htilt r hr1 hrc hh hh')

end DirectionalZeroOne

end OAI