lean/OAI/Probability/Ballisticity/Geometry/LatticeVector.lean

import Mathlib
import OAI.Probability.Ballisticity.Geometry.WordHeightGain

namespace OAI

section
section
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology
namespace DirectionalTransience

lemma stationary_initial_average_truncated_bound {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (T : Ω → Ω) (hT : MeasurePreserving T μ μ)
    (f : Ω → ℝ) (hf : Measurable f) (hfn : ∀ x, 0 ≤ f x)
    (K : ℕ) (a : ℝ) (ha : 0 < a) :
    a * μ.real {x | ∃ k, 0 < k ∧ k ≤ K ∧
      a * (k : ℝ) < ∑ j ∈ Finset.range k, f (T^[j] x)} ≤
      2 * truncatedMean μ f (a*K) := by
  let g : Ω → ℝ := fun x => min (f x) (a*K)
  have hg : Measurable g := hf.min measurable_const
  have hgn (x : Ω) : 0 ≤ g x := le_min (hfn x) (mul_nonneg ha.le (Nat.cast_nonneg _))
  have hgi : Integrable g μ := integrable_min_nonneg μ f hf hfn _
    (mul_nonneg ha.le (Nat.cast_nonneg _))
  have hsub : {x | ∃ k, 0 < k ∧ k ≤ K ∧
        a * (k : ℝ) < ∑ j ∈ Finset.range k, f (T^[j] x)} ⊆
      {x | ∃ k, 0 < k ∧ k ≤ K ∧
        (a/2) * (k : ℝ) < ∑ j ∈ Finset.range k, g (T^[j] x)} := by
    intro x hx
    obtain ⟨k,hk,hkK,hs⟩ := hx
    refine ⟨k,hk,hkK,?_⟩
    have hkpos : (0 : ℝ) < k := Nat.cast_pos.mpr hk
    by_cases ht : ∀ j ∈ Finset.range k, f (T^[j] x) ≤ a*K
    · have he : (∑ j ∈ Finset.range k, g (T^[j] x)) =
          ∑ j ∈ Finset.range k, f (T^[j] x) := by
        apply Finset.sum_congr rfl
        intro j hj
        exact min_eq_left (ht j hj)
      rw [he]
      nlinarith
    · obtain ⟨j,hj,hjt⟩ : ∃ j ∈ Finset.range k, a*K < f (T^[j] x) := by
        simpa only [not_forall, not_le, exists_prop] using ht
      have hle : a*(k : ℝ) ≤ ∑ j ∈ Finset.range k, g (T^[j] x) := by
        calc
          _ ≤ a*K := mul_le_mul_of_nonneg_left (Nat.cast_le.mpr hkK) ha.le
          _ = g (T^[j] x) := (min_eq_right hjt.le).symm
          _ ≤ _ := Finset.single_le_sum (fun i (_ : i ∈ Finset.range k) => hgn (T^[i] x)) hj
      nlinarith
  have hme := measureReal_mono (μ := μ) hsub
  have hb := stationary_initial_average_bound μ T hT g hg hgi hgn K (a/2) (by linarith)
  change (a/2) * _ ≤ truncatedMean μ f (a*K) at hb
  have hm := mul_le_mul_of_nonneg_left hme (show 0 ≤ a/2 by linarith)
  linarith

lemma truncatedMean_ratio_tendsto_zero {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) (c : ℝ) (hc : 0 ≤ c) :
    Tendsto (fun n : ℕ => truncatedMean μ f (c*(n+1)) / (n+1)) atTop (𝓝 0) := by
  have hpt (x : Ω) : Tendsto (fun n : ℕ => min (f x) (c*(n+1)) / (n+1)) atTop (𝓝 0) := by
    have hz : Tendsto (fun n : ℕ => f x / (n+1)) atTop (𝓝 0) :=
      tendsto_const_nhds.div_atTop (tendsto_atTop_mono (fun n : ℕ => show (n : ℝ) ≤ (n : ℝ)+1 by linarith)
        tendsto_natCast_atTop_atTop)
    apply squeeze_zero (fun n => div_nonneg (le_min (hfn x) (mul_nonneg hc (by positivity)))
      (by positivity)) (fun n => div_le_div_of_nonneg_right (min_le_left _ _) (by positivity)) hz
  have hdom := tendsto_integral_of_dominated_convergence (μ := μ)
    (F := fun n : ℕ => fun x : Ω => min (f x) (c*(n+1)) / (n+1))
    (f := fun _ : Ω => (0 : ℝ)) (fun _ : Ω => c)
    (fun n => ((hf.min measurable_const).div_const _).aestronglyMeasurable)
    (integrable_const c) (fun n => Filter.Eventually.of_forall fun x => by
      rw [Real.norm_eq_abs, abs_of_nonneg (div_nonneg
        (le_min (hfn x) (mul_nonneg hc (by positivity))) (by positivity))]
      exact (div_le_iff₀ (show (0 : ℝ) < n+1 by positivity)).mpr (min_le_right _ _))
    (Filter.Eventually.of_forall hpt)
  simpa only [integral_div, integral_zero, truncatedMean] using hdom

lemma real_integrable_of_scaled_truncation_bound {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) {c B : ℝ} (hc : 0 < c)
    (hB : ∀ K : ℕ, truncatedMean μ f (c*K) ≤ B) : Integrable f μ := by
  have hbound : (∫⁻ x, ENNReal.ofReal (f x) ∂μ) ≤ ENNReal.ofReal B := by
    have he (x : Ω) : ENNReal.ofReal (f x) =
        ⨆ K : ℕ, ENNReal.ofReal (min (f x) (c*K)) := by
      apply le_antisymm
      · obtain ⟨K,hK⟩ := exists_nat_ge (f x / c)
        have hle : f x ≤ c*K := by
          have := (div_le_iff₀ hc).mp hK
          linarith
        exact le_iSup_of_le K (by rw [min_eq_left hle])
      · exact iSup_le fun K => ENNReal.ofReal_le_ofReal (min_le_left _ _)
    simp_rw [he]
    rw [lintegral_iSup (f := fun K x => ENNReal.ofReal (min (f x) (c*K)))
      (fun K => (hf.min measurable_const).ennreal_ofReal)
      (fun i j hij x => ENNReal.ofReal_le_ofReal
        (min_le_min_left _ (mul_le_mul_of_nonneg_left (Nat.cast_le.mpr hij) hc.le)))]
    apply iSup_le
    intro K
    have hi := integrable_min_nonneg μ f hf hfn (c*K) (mul_nonneg hc.le (Nat.cast_nonneg _))
    rw [← ofReal_integral_eq_lintegral_ofReal hi
      (Filter.Eventually.of_forall fun x => le_min (hfn x) (mul_nonneg hc.le (Nat.cast_nonneg _)))]
    exact ENNReal.ofReal_le_ofReal (hB K)
  refine ⟨hf.aestronglyMeasurable, ?_⟩
  rw [hasFiniteIntegral_iff_ofReal (Filter.Eventually.of_forall hfn)]
  exact hbound.trans_lt ENNReal.ofReal_lt_top

lemma exists_minimal_truncation_scale {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) (hinf : ¬ Integrable f μ)
    (η a : ℝ) (hη : 0 < η) (ha : 0 < a) :
    ∃ N : ℕ, 0 < N ∧ η*a ≤ truncatedMean μ f (a*N) ∧
      ∀ k < N, truncatedMean μ f (a*k) < η*a := by
  have hex : ∃ N : ℕ, η*a ≤ truncatedMean μ f (a*N) := by
    by_contra h
    have hb : ∀ N : ℕ, truncatedMean μ f (a*N) ≤ η*a := by
      intro N
      have := not_exists.mp h N
      exact le_of_lt (lt_of_not_ge this)
    exact hinf (real_integrable_of_scaled_truncation_bound μ f hf hfn ha hb)
  refine ⟨Nat.find hex, ?_, Nat.find_spec hex, ?_⟩
  · by_contra h
    have he : Nat.find hex = 0 := by omega
    have hh := Nat.find_spec hex
    rw [he, Nat.cast_zero, mul_zero, truncatedMean] at hh
    have he' : (fun x => min (f x) 0) = fun _ => (0 : ℝ) :=
      funext fun x => min_eq_right (hfn x)
    rw [he', integral_zero] at hh
    exact (not_le_of_gt (mul_pos hη ha)) hh
  · intro k hk
    exact lt_of_not_ge (Nat.find_min hex hk)

lemma minimal_truncation_scale_upper {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) (η a : ℝ) (ha : 0 ≤ a) {N : ℕ} (hN : 2 ≤ N)
    (hmin : ∀ k < N, truncatedMean μ f (a*k) < η*a) :
    truncatedMean μ f (a*N) < 2*η*a := by
  have hlt := hmin (N-1) (by omega)
  calc
    _ ≤ truncatedMean μ f (2*(a*(N-1 : ℕ))) :=
      truncatedMean_mono μ f hf hfn (mul_nonneg ha (Nat.cast_nonneg _))
        (by have hn : (N : ℝ) ≤ 2*(N-1 : ℕ) := by exact_mod_cast (show N ≤ 2*(N-1) by omega)
            nlinarith)
    _ ≤ 2*truncatedMean μ f (a*(N-1 : ℕ)) :=
      truncatedMean_mul_le μ f hf hfn (mul_nonneg ha (Nat.cast_nonneg _)) (by norm_num)
    _ < 2*η*a := by linarith

noncomputable def latticeVector {d : ℕ} (x : Lattice d) : EuclideanSpace ℝ (Fin d) :=
  WithLp.toLp 2 (realPosition x)

@[simp] lemma latticeVector_zero {d : ℕ} : latticeVector (0 : Lattice d) = 0 := by
  ext i
  simp [latticeVector, realPosition]

lemma latticeVector_add {d : ℕ} (x y : Lattice d) :
    latticeVector (x+y) = latticeVector x + latticeVector y := by
  ext i
  simp [latticeVector, realPosition]

lemma latticeVector_sub {d : ℕ} (x y : Lattice d) :
    latticeVector (x-y) = latticeVector x - latticeVector y := by
  ext i
  simp [latticeVector, realPosition]

lemma latticeVector_step_norm {d : ℕ} (e : Direction d) : ‖latticeVector (step e)‖ = 1 := by
  have hs : ‖latticeVector (step e)‖ ^ 2 = 1 := by
    rw [EuclideanSpace.real_norm_sq_eq]
    simp only [latticeVector, realPosition, step,
      Int.cast_ite, Int.cast_one, Int.cast_neg, Int.cast_zero, ite_pow, zero_pow (by norm_num : 2 ≠ 0)]
    simp
  nlinarith [norm_nonneg (latticeVector (step e))]

noncomputable def wordRadius {d : ℕ} (w : List (Direction d)) : ℝ := by
  classical
  exact (Finset.range (w.length+1)).sup' (Finset.nonempty_range_iff.mpr (by omega))
    (fun j => ‖latticeVector (wordPath 0 w j)‖)

lemma wordRadius_bound {d : ℕ} (w : List (Direction d)) {j : ℕ} (hj : j ≤ w.length) :
    ‖latticeVector (wordPath 0 w j)‖ ≤ wordRadius w := by
  classical
  exact Finset.le_sup' (fun j => ‖latticeVector (wordPath 0 w j)‖)
    (Finset.mem_range.mpr (by omega))

lemma wordRadius_nonneg {d : ℕ} (w : List (Direction d)) : 0 ≤ wordRadius w := by
  have hh := wordRadius_bound w (j := 0) (by omega)
  simpa only [wordPath_zero, latticeVector_zero, norm_zero] using hh

lemma wordRadius_attained {d : ℕ} (w : List (Direction d)) :
    ∃ j ≤ w.length, wordRadius w = ‖latticeVector (wordPath 0 w j)‖ := by
  classical
  obtain ⟨j,hj,he⟩ := Finset.exists_mem_eq_sup' (Finset.nonempty_range_iff.mpr
    (show w.length+1 ≠ 0 by omega)) (fun j => ‖latticeVector (wordPath 0 w j)‖)
  exact ⟨j, by have := Finset.mem_range.mp hj; omega, he⟩

lemma wordRadius_le_length {d : ℕ} (w : List (Direction d)) : wordRadius w ≤ w.length := by
  classical
  have hb (j : ℕ) : ‖latticeVector (wordPath 0 w j)‖ ≤ j := by
    induction j with
    | zero => simp
    | succ j ih =>
      rcases wordPath_step_or_stay 0 w j with he | ⟨e,he⟩
      · rw [he, Nat.cast_add, Nat.cast_one]; linarith
      · rw [he, latticeVector_add, Nat.cast_add, Nat.cast_one]
        exact (norm_add_le _ _).trans (by rw [latticeVector_step_norm]; linarith)
  apply Finset.sup'_le
  intro j hj
  exact (hb j).trans (Nat.cast_le.mpr (by have := Finset.mem_range.mp hj; omega))

lemma measurable_wordRadius {d : ℕ} : Measurable (wordRadius (d := d)) := measurable_of_countable _

lemma conditioned_radius_initial_average_bound {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] (ℓ : Vector d) (htrans : DirectionallyTransient ν ℓ)
    (K : ℕ) (a : ℝ) (ha : 0 < a) :
    a * (conditionedLaw ν ℓ).real {X | ∃ k, 0 < k ∧ k ≤ K ∧
      a * (k : ℝ) < ∑ j ∈ Finset.range k, wordRadius (regenerationWords ℓ X j)} ≤
      2 * truncatedMean (conditionedLaw ν ℓ)
        (fun X => wordRadius (firstWord ℓ X)) (a*K) := by
  let : IsProbabilityMeasure (conditionedLaw ν ℓ) := conditionedLaw_probability ν ℓ
    (ne_of_gt (noDrop_positive_of_directionallyTransient ν ℓ htrans))
  exact stationary_initial_average_truncated_bound _ _
    (renewSuffix_preserves_conditioned ν ℓ htrans) _
    (measurable_wordRadius.comp (measurable_firstWord ℓ)) (fun X => wordRadius_nonneg _) K a ha

lemma affine_envelope_of_average_limit (H : ℕ → ℝ) (L : ℝ) (hL : 0 < L)
    (hlim : Tendsto (fun n : ℕ => H n / n) atTop (𝓝 L)) :
    ∃ C0 : ℕ, ∀ n : ℕ, (L/2)*n-C0 ≤ H n ∧ H n ≤ (2*L)*n+C0 := by
  have hevent : ∀ᶠ n : ℕ in atTop, L/2 < H n / n ∧ H n / n < 2*L :=
    hlim.eventually (Ioo_mem_nhds (by linarith) (by linarith))
  obtain ⟨N,hN⟩ := (eventually_atTop.1 hevent)
  let M := max N 1
  let B : ℝ := (∑ j ∈ Finset.range M, |H j|) + 2*L*M
  obtain ⟨C0,hC0⟩ := exists_nat_ge B
  refine ⟨C0, fun n => ?_⟩
  by_cases hn : M ≤ n
  · have hn0 : (0 : ℝ) < n := Nat.cast_pos.mpr (by dsimp [M] at hn; omega)
    obtain ⟨hl,hu⟩ := hN n (by dsimp [M] at hn; omega)
    have hl' := (lt_div_iff₀ hn0).mp hl
    have hu' := (div_lt_iff₀ hn0).mp hu
    constructor <;> nlinarith [Nat.cast_nonneg (α := ℝ) C0]
  · have hn' : n ∈ Finset.range M := Finset.mem_range.mpr (by omega)
    have hnM : (n : ℝ) ≤ M := Nat.cast_le.mpr (by omega)
    have hs : |H n| ≤ ∑ j ∈ Finset.range M, |H j| :=
      Finset.single_le_sum (fun j _ => abs_nonneg (H j)) hn'
    have hs0 : 0 ≤ ∑ j ∈ Finset.range M, |H j| :=
      Finset.sum_nonneg fun j _ => abs_nonneg (H j)
    dsimp only [B] at hC0
    constructor <;> nlinarith [le_abs_self (H n), neg_abs_le (H n),
      Nat.cast_nonneg (α := ℝ) n, Nat.cast_nonneg (α := ℝ) M]

lemma uniform_affine_envelope_probability {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (H : ℕ → Ω → ℝ) (L : ℝ) (hL : 0 < L)
    (hlim : ∀ᵐ x ∂μ, Tendsto (fun n : ℕ => H n x / n) atTop (𝓝 L))
    (ε : ℝ) (hε : 0 < ε) :
    ∃ C0 : ℕ, 1-ε < μ.real {x | ∀ n : ℕ, (L/2)*n-C0 ≤ H n x ∧
      H n x ≤ (2*L)*n+C0} := by
  let E : ℕ → Set Ω := fun C0 => {x | ∀ n : ℕ, (L/2)*n-C0 ≤ H n x ∧
    H n x ≤ (2*L)*n+C0}
  have hmono : Monotone E := by
    intro i j hij x hx n
    have hi := hx n
    have hij' : (i : ℝ) ≤ j := Nat.cast_le.mpr hij
    constructor <;> linarith
  have hae : ∀ᵐ x ∂μ, x ∈ ⋃ C0, E C0 := by
    filter_upwards [hlim] with x hx
    obtain ⟨C0,hC0⟩ := affine_envelope_of_average_limit (fun n => H n x) L hL hx
    exact Set.mem_iUnion.mpr ⟨C0,hC0⟩
  have hme : μ (⋃ C0, E C0) = 1 := by
    rw [← measure_univ (μ := μ)]
    apply measure_congr
    filter_upwards [hae] with x hx
    exact propext (iff_true_intro hx)
  have ht := (ENNReal.tendsto_toReal (measure_ne_top μ (⋃ C0, E C0))).comp
    (tendsto_measure_iUnion_atTop (μ := μ) hmono)
  rw [hme, ENNReal.toReal_one] at ht
  have he := ht.eventually (Ioi_mem_nhds (show 1-ε < 1 by linarith))
  obtain ⟨C0,hC0⟩ := he.exists
  exact ⟨C0,hC0⟩

lemma conditioned_height_template {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (ℓ : Vector d) (hℓ : ∀ i, |ℓ i| ≤ 1) (htrans : DirectionallyTransient ν ℓ)
    (ε : ℝ) (hε : 0 < ε) :
    ∃ c C : ℝ, 0 < c ∧ 0 < C ∧ ∃ C0 : ℕ,
      1-ε < (conditionedLaw ν ℓ).real {X | ∀ k : ℕ,
        c*k-C0 ≤ ∑ j ∈ Finset.range k, wordHeightGain ℓ (regenerationWords ℓ X j) ∧
        (∑ j ∈ Finset.range k, wordHeightGain ℓ (regenerationWords ℓ X j)) ≤ C*k+C0} := by
  let : IsProbabilityMeasure (conditionedLaw ν ℓ) := conditionedLaw_probability ν ℓ
    (ne_of_gt (noDrop_positive_of_directionallyTransient ν ℓ htrans))
  obtain ⟨hint,hpositive,_⟩ := conditioned_wordHeightGain_moments ν ℓ hℓ htrans
  let L := ∫ X, wordHeightGain ℓ (firstWord ℓ X) ∂conditionedLaw ν ℓ
  have hmeas : Measurable (wordHeightGain ℓ) := measurable_of_countable _
  have hlim : ∀ᵐ X ∂conditionedLaw ν ℓ, Tendsto
      (fun k : ℕ => (∑ j ∈ Finset.range k, wordHeightGain ℓ (regenerationWords ℓ X j)) / k)
      atTop (𝓝 L) := by
    exact strong_law_ae_real _ hint
      (fun i j hij => ((regenerationWords_independent ν ℓ htrans).indepFun hij).comp hmeas hmeas)
      (fun i => (regenerationWords_identDistrib ν ℓ htrans i).comp hmeas)
  obtain ⟨C0,hC0⟩ := uniform_affine_envelope_probability (conditionedLaw ν ℓ)
    (fun k X => ∑ j ∈ Finset.range k, wordHeightGain ℓ (regenerationWords ℓ X j))
    L hpositive hlim ε hε
  exact ⟨L/2,2*L,by linarith,by linarith,C0,hC0⟩

lemma truncation_threshold_eventually_large {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) (η : ℝ) (hη : 0 < η) (M : ℕ) :
    ∀ᶠ a : ℕ in atTop, ∀ N : ℕ,
      η*(a+1) ≤ truncatedMean μ f ((a+1)*N) → M < N := by
  have ht := truncatedMean_ratio_tendsto_zero μ f hf hfn (M : ℝ) (Nat.cast_nonneg _)
  have he := ht.eventually (Iio_mem_nhds hη)
  filter_upwards [he] with a ha N hN
  by_contra hNM
  have hNM' : (N : ℝ) ≤ M := Nat.cast_le.mpr (by omega)
  have hb := truncatedMean_mono μ f hf hfn
    (show 0 ≤ ((a : ℝ)+1)*N by positivity)
    (mul_le_mul_of_nonneg_left hNM' (by positivity : 0 ≤ (a : ℝ)+1))
  have ha' := (div_lt_iff₀ (show 0 < (a : ℝ)+1 by positivity)).mp ha
  rw [mul_comm ((a : ℝ)+1) (M : ℝ)] at hb
  linarith

lemma truncated_template_failure_bound {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (T : Ω → Ω)
    (hT : MeasurePreserving T μ μ) (f : Ω → ℝ) (hf : Measurable f)
    (hfn : ∀ x, 0 ≤ f x) (η a : ℝ) (ha : 0 < a) (C1 N : ℕ) (hC1 : 1 ≤ C1)
    (hI : truncatedMean μ f (a*N) < 2*η*a) :
    μ.real {x | ∃ k, 0 < k ∧ k ≤ C1*N ∧
      a*(k : ℝ) < ∑ j ∈ Finset.range k, f (T^[j] x)} < 4*C1*η := by
  have hb := stationary_initial_average_truncated_bound μ T hT f hf hfn (C1*N) a ha
  have hc : (1 : ℝ) ≤ C1 := by exact_mod_cast hC1
  have hs := truncatedMean_mul_le μ f hf hfn
    (mul_nonneg ha.le (Nat.cast_nonneg N)) hc
  have he : a*(C1*N : ℕ) = (C1 : ℝ)*(a*N) := by push_cast; ring
  rw [he] at hb
  have hC1pos : (0 : ℝ) < C1 := lt_of_lt_of_le zero_lt_one hc
  have hmul := mul_lt_mul_of_pos_left hI hC1pos
  have hh : a * μ.real {x | ∃ k, 0 < k ∧ k ≤ C1*N ∧
      a*(k : ℝ) < ∑ j ∈ Finset.range k, f (T^[j] x)} < a*(4*C1*η) := by
    nlinarith
  exact (mul_lt_mul_iff_right₀ ha).mp hh

lemma restricted_union_lower_bound {Ω ι : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (S : Finset ι) (E : ι → Set Ω)
    (hE : ∀ i, MeasurableSet (E i)) (p : ι → ℝ) (q : ℝ)
    (hfirst : ∀ i ∈ S, q*p i ≤ μ.real (E i))
    (hpair : ∀ i ∈ S, ∀ j ∈ S, i ≠ j → μ.real (E i ∩ E j) ≤ p i * p j) :
    q * (∑ i ∈ S, p i) - (∑ i ∈ S, p i)^2 / 2 ≤ μ.real (⋃ i ∈ S, E i) := by
  classical
  induction S using Finset.induction_on with
  | empty => simp
  | @insert a S ha ih =>
    have hfirstS : ∀ i ∈ S, q*p i ≤ μ.real (E i) := fun i hi => hfirst i (by simp [hi])
    have hpairS : ∀ i ∈ S, ∀ j ∈ S, i ≠ j → μ.real (E i ∩ E j) ≤ p i * p j :=
      fun i hi j hj hij => hpair i (by simp [hi]) j (by simp [hj]) hij
    have hold := ih hfirstS hpairS
    have hnew := hfirst a (Finset.mem_insert_self a S)
    have hcross : μ.real (E a ∩ ⋃ i ∈ S, E i) ≤ p a * (∑ i ∈ S, p i) := by
      rw [Set.inter_iUnion]
      simp_rw [Set.inter_iUnion]
      calc
        _ ≤ ∑ i ∈ S, μ.real (E a ∩ E i) := measureReal_biUnion_finset_le S _
        _ ≤ ∑ i ∈ S, p a * p i := by
          apply Finset.sum_le_sum
          intro i hi
          exact hpair a (by simp) i (by simp [hi]) (by intro he; subst i; contradiction)
        _ = _ := by rw [Finset.mul_sum]
    have hidentity := measureReal_union_add_inter₀' (μ := μ) (hE a).nullMeasurableSet
      (s := E a) (t := ⋃ i ∈ S, E i) (h₂ := measure_ne_top μ _)
    simp only [Finset.sum_insert ha, Finset.set_biUnion_insert]
    nlinarith [sq_nonneg (p a)]

lemma independent_rare_words_lower_bound {Ω ι : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (S : Finset ι) (A G : ι → Set Ω)
    (hA : ∀ i, MeasurableSet (A i)) (hG : ∀ i, MeasurableSet (G i)) (q : ℝ)
    (hprev : ∀ i ∈ S, q*μ.real (A i) ≤ μ.real (A i ∩ G i))
    (hpair : ∀ i ∈ S, ∀ j ∈ S, i ≠ j →
      μ.real (A i ∩ A j) = μ.real (A i) * μ.real (A j)) :
    q * (∑ i ∈ S, μ.real (A i)) - (∑ i ∈ S, μ.real (A i))^2 / 2 ≤
      μ.real {x | ∃ i ∈ S, x ∈ A i ∧ x ∈ G i} := by
  have hh := restricted_union_lower_bound μ S (fun i => A i ∩ G i)
    (fun i => (hA i).inter (hG i)) (fun i => μ.real (A i)) q hprev (by
      intro i hi j hj hij
      calc
        μ.real ((A i ∩ G i) ∩ (A j ∩ G j)) ≤ μ.real (A i ∩ A j) :=
          measureReal_mono (μ := μ) (fun _ hx => ⟨hx.1.1,hx.2.1⟩)
        _ = _ := hpair i hi j hj hij)
  have he : (⋃ i ∈ S, A i ∩ G i) = {x | ∃ i ∈ S, x ∈ A i ∧ x ∈ G i} := by
    ext x
    simp only [Set.mem_iUnion, Set.mem_inter_iff, Set.mem_ofPred_eq]
    aesop
  rwa [he] at hh

lemma annealed_avoiding_suffix {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (w : List (Direction d))
    (hnew : wordPath 0 w w.length ∉ wordDepartures 0 w)
    (A : Set (Path d)) (hA : MeasurableSet A)
    (havoid : ∀ X ∈ A, ∀ j, wordPath 0 w w.length + X j ∉ wordDepartures 0 w) :
    annealedLaw ν ((fun X : Path d => fun j => X (w.length + j) -
      wordPath 0 w w.length) ⁻¹' A ∩ wordCylinder 0 w) =
      annealedLaw ν (wordCylinder 0 w) * annealedLaw ν A := by
  let y := wordPath 0 w w.length
  let S : Set (Lattice d) := ↑(wordDepartures 0 w)
  let T : Set (Lattice d) := Sᶜ
  let B : Set (Path d) := (fun X : Path d => fun j => X j - y) ⁻¹' A
  have hB : MeasurableSet B := hA.preimage (by fun_prop)
  have hBT : B ⊆ Stay T := by
    intro X hX j
    have h := havoid (fun k => X k-y) hX j
    have he : wordPath 0 w w.length + (X j-y) = X j := by dsimp only [y]; abel
    rw [he] at h
    exact h
  have hST : Disjoint S T := disjoint_compl_right
  have hw (ω : Environment d) : quenchedKernel (ω, 0)
      ((fun X : Path d => fun j => X (w.length + j) - y) ⁻¹' A ∩ wordCylinder 0 w) =
      ENNReal.ofReal (wordWeight ω 0 w) * quenchedKernel (ω, y) B := by
    have hh := quenched_prefix_future ω 0 (wordPath 0 w) (by simp) w.length hB
    change quenchedKernel (ω, 0) (_ ∩ wordCylinder 0 w) =
      quenchedKernel (ω, 0) (wordCylinder 0 w) * quenchedKernel (ω, y) B at hh
    rwa [quenched_wordCylinder] at hh
  rw [annealed_apply ν ((hA.preimage (by fun_prop)).inter (measurableSet_wordCylinder 0 w))]
  change (∫⁻ ω, quenchedKernel (ω, 0)
    ((fun X : Path d => fun j => X (w.length + j) - y) ⁻¹' A ∩ wordCylinder 0 w)
    ∂environmentLaw ν) = _
  simp_rw [hw]
  rw [lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace
    (rowSigma_le S) (rowSigma_le T) (environment_indep_rows ν hST)
    ((measurable_wordWeight_on 0 w (fun _ hz => hz)).ennreal_ofReal)
    (measurable_quenched_stay_event_rows T y hnew B hB hBT)]
  rw [← annealed_wordCylinder, annealed_event_translation ν y A hA]

end DirectionalTransience
end
end

end OAI