lean/OAI/Probability/Ballisticity/Geometry/HeightSlab.lean

import Mathlib
import OAI.Probability.Ballisticity.Estimates.ClippedInverse

namespace OAI

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

lemma convexOn_rpow_nonpos_Ici {δ p : ℝ} (hδ : 0 < δ) (hp : p ≤ 0) :
    ConvexOn ℝ (Set.Ici δ) (fun x : ℝ => x ^ p) := by
  refine ⟨convex_Ici δ, ?_⟩
  intro x hx y hy a b ha hb hab
  have hx0 := hδ.trans_le hx
  have hy0 := hδ.trans_le hy
  have hz : 0 < a • x + b • y :=
    hδ.trans_le ((convex_Ici δ) hx hy ha hb hab)
  have hl := (StrictConcaveOn.concaveOn strictConcaveOn_log_Ioi).2 hx0 hy0 ha hb hab
  have he := convexOn_exp.2 (Set.mem_univ (p * Real.log x))
    (Set.mem_univ (p * Real.log y)) ha hb hab
  simp only [smul_eq_mul] at hl he hz ⊢
  rw [Real.rpow_def_of_pos hz, Real.rpow_def_of_pos hx0, Real.rpow_def_of_pos hy0]
  calc
    Real.exp (Real.log (a * x + b * y) * p) ≤
      Real.exp (a * (p * Real.log x) + b * (p * Real.log y)) := by
        apply Real.exp_le_exp.mpr
        nlinarith [mul_le_mul_of_nonpos_right hl hp]
    _ ≤ a * Real.exp (Real.log x * p) + b * Real.exp (Real.log y * p) := by
      simpa only [mul_comm p] using he

lemma inverse_jensen_bounded {α : Type*} [MeasurableSpace α]
    (μ : Measure α) [IsProbabilityMeasure μ] {f : α → ℝ} (hf : Measurable f)
    {δ B lam : ℝ} (hδ : 0 < δ) (hlam : 0 ≤ lam) (hb : ∀ x, δ ≤ f x ∧ f x ≤ B) :
    (∫ x, f x ∂μ) ^ (-lam) ≤ ∫ x, (f x) ^ (-lam) ∂μ := by
  have hi : Integrable f μ :=
    (MemLp.of_bound (p := 1) hf.aestronglyMeasurable B
      (Filter.Eventually.of_forall fun x => by
        simpa only [Real.norm_eq_abs, abs_of_nonneg (hδ.le.trans (hb x).1)] using
          (hb x).2)).integrable le_rfl
  have hj : Integrable (fun x => (f x) ^ (-lam)) μ :=
    (MemLp.of_bound (p := 1) (hf.pow_const _).aestronglyMeasurable (δ ^ (-lam))
      (Filter.Eventually.of_forall fun x => by
        rw [Real.norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg (hδ.le.trans (hb x).1) _)]
        exact Real.rpow_le_rpow_of_nonpos hδ (hb x).1 (neg_nonpos.mpr hlam))).integrable le_rfl
  exact (convexOn_rpow_nonpos_Ici hδ (neg_nonpos.mpr hlam)).map_integral_le
    (continuousOn_id.rpow_const (fun x hx => Or.inl (ne_of_gt (hδ.trans_le hx))))
    isClosed_Ici (Filter.Eventually.of_forall fun x => (hb x).1) hi hj

lemma inverse_mixture_markov {Ω A : Type*} [MeasurableSpace Ω] [MeasurableSpace A]
    (μ : Measure Ω) (π : Measure A) [IsProbabilityMeasure μ] [IsProbabilityMeasure π]
    (F : Ω → A → ℝ) (hF : Measurable (Function.uncurry F)) (Q : Ω → ℝ)
    {δ₀ δ lam s K : ℝ} (hδ₀ : 0 < δ₀) (hlam : 0 ≤ lam) (hs : 0 < s) (hδs : δ ≤ s)
    (hb : ∀ ω a, δ₀ ≤ F ω a ∧ F ω a ≤ 1)
    (hQ : ∀ ω, (∫ a, F ω a ∂π) ≤ Q ω + δ)
    (hE : (∫ ω, ∫ a, (F ω a) ^ (-lam) ∂π ∂μ) ≤ K) :
    μ {ω | Q ω < 2 * s} ≤ ENNReal.ofReal ((3 * s) ^ lam * K) := by
  have hGi : Integrable (fun z : Ω × A => F z.1 z.2 ^ (-lam)) (μ.prod π) :=
    (MemLp.of_bound (p := 1) (hF.pow_const _).aestronglyMeasurable (δ₀ ^ (-lam))
      (Filter.Eventually.of_forall fun z => by
        change ‖F z.1 z.2 ^ (-lam)‖ ≤ _
        rw [Real.norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg (hδ₀.le.trans (hb z.1 z.2).1) _)]
        exact Real.rpow_le_rpow_of_nonpos hδ₀ (hb z.1 z.2).1
          (neg_nonpos.mpr hlam))).integrable le_rfl
  have hJi ω : Integrable (F ω) π :=
    (MemLp.of_bound (p := 1) (hF.comp (measurable_const.prodMk measurable_id)).aestronglyMeasurable 1
      (Filter.Eventually.of_forall fun a => by
        change ‖F ω a‖ ≤ 1
        rw [Real.norm_eq_abs, abs_of_nonneg (hδ₀.le.trans (hb ω a).1)]
        exact (hb ω a).2)).integrable le_rfl
  have hJpos ω : 0 < ∫ a, F ω a ∂π := by
    have hl := integral_mono (integrable_const δ₀) (hJi ω) (fun a => (hb ω a).1)
    have hl' : δ₀ ≤ ∫ a, F ω a ∂π := by simpa using hl
    exact hδ₀.trans_le hl'
  have hp : 0 < 3 * s := mul_pos (by norm_num) hs
  have hMeas := (hGi.integral_prod_left.const_mul ((3 * s) ^ lam)).measure_le_integral
    (Filter.Eventually.of_forall fun ω => mul_nonneg (Real.rpow_nonneg hp.le _)
      (integral_nonneg (fun a => Real.rpow_nonneg (hδ₀.le.trans (hb ω a).1) _)))
    (s := {ω | Q ω < 2 * s}) (fun ω hω => by
      have hJle : (∫ a, F ω a ∂π) ≤ 3 * s := by
        change Q ω < 2 * s at hω
        linarith [hQ ω]
      have hj := inverse_jensen_bounded π
        (hF.comp (measurable_const.prodMk measurable_id)) hδ₀ hlam (hb ω)
      have hr := Real.rpow_le_rpow_of_nonpos (hJpos ω) hJle (neg_nonpos.mpr hlam)
      calc
        1 = (3 * s) ^ lam * (3 * s) ^ (-lam) := by
          rw [← Real.rpow_add hp, add_neg_cancel, Real.rpow_zero]
        _ ≤ (3 * s) ^ lam * ∫ a, F ω a ^ (-lam) ∂π :=
          mul_le_mul_of_nonneg_left (hr.trans hj) (Real.rpow_nonneg hp.le _))
  rw [integral_const_mul] at hMeas
  exact hMeas.trans (ENNReal.ofReal_le_ofReal
    (mul_le_mul_of_nonneg_left hE (Real.rpow_nonneg hp.le _)))

theorem separated_initial_inverse_moment {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] (hue : UniformElliptic ν) (ℓ : Vector d)
    (hℓ : dot ℓ ℓ = 1) (htrans : DirectionallyTransient ν ℓ) (e : Fin d) :
    ∃ lam C : ℝ, 0 < lam ∧ lam ≤ 1 ∧ 0 < C ∧
      ∀ Bstar : ℝ, 0 < Bstar → ∀ k : ℕ, 1 ≤ k → ∃ G : ℕ,
      ∀ (π : Measure (Fin k → Lattice d)) [IsProbabilityMeasure π],
        (∀ᵐ x ∂π, Pairwise fun i j => (G : ℤ) ≤ |x i e - x j e|) →
        ∀ s : ℝ, Real.exp (-Bstar) ≤ s →
        (environmentLaw ν) {ω | (∫ x, noDropProduct ℓ x ω ∂π) < 2 * s} ≤
          ENNReal.ofReal (Real.exp (C * k) * s ^ lam) := by
  classical
  obtain ⟨lam, hlam, hlam1, hmom⟩ := noDrop_real_inverse_moment ν hue ℓ hℓ htrans
  let M := max 1 (∫ ω, (noDropQuenched ℓ 0 ω).toReal ^ (-lam) ∂environmentLaw ν)
  have hM : 1 ≤ M := le_max_left _ _
  have hM0 : 0 ≤ M := zero_le_one.trans hM
  let C := Real.log (6 * M)
  have hC : 0 < C := Real.log_pos (by linarith)
  refine ⟨lam, C, hlam, hlam1, hC, ?_⟩
  intro Bstar hBstar k hk
  let δ := Real.exp (-Bstar)
  have hδ : 0 < δ := Real.exp_pos _
  have hδ1 : δ ≤ 1 := Real.exp_le_one_iff.mpr (neg_nonpos.mpr hBstar.le)
  have hpos : ∀ᵐ ω ∂environmentLaw ν, 0 < noDropQuenched ℓ 0 ω := by
    filter_upwards [quenched_noDrop_positive_of_directionallyTransient ν hue ℓ hℓ htrans] with ω hω
    exact hω 0
  obtain ⟨n, hn⟩ := separated_noDropProduct_inverse_bound ν ℓ hδ hlam.le hpos hmom k
  refine ⟨2 * n + 1, ?_⟩
  intro π hπ hsep s hs
  have hs0 : 0 < s := hδ.trans_le hs
  let F : Environment d → (Fin k → Lattice d) → ℝ := fun ω x => clippedNoDropProduct ℓ δ x ω
  have hF : Measurable (Function.uncurry F) := clippedNoDropProduct_measurable ℓ δ
  have hb ω x : δ ^ k ≤ F ω x ∧ F ω x ≤ 1 :=
    clippedNoDropProduct_bounds ℓ hδ.le hδ1 x ω
  have hGi : Integrable (fun z : Environment d × (Fin k → Lattice d) =>
      F z.1 z.2 ^ (-lam)) ((environmentLaw ν).prod π) := by
    apply integrable_of_nonneg_bound _ (hF.pow_const _)
    intro z
    exact ⟨Real.rpow_nonneg ((pow_pos hδ k).le.trans (hb z.1 z.2).1) _,
      Real.rpow_le_rpow_of_nonpos (pow_pos hδ k) (hb z.1 z.2).1 (neg_nonpos.mpr hlam.le)⟩
  have hE : (∫ ω, ∫ x, F ω x ^ (-lam) ∂π ∂environmentLaw ν) ≤ 2 * M ^ k := by
    rw [integral_integral_swap hGi]
    have hh := integral_mono_ae hGi.integral_prod_right (integrable_const (2 * M ^ k))
      (hsep.mono fun x hx => hn x (fun i j hij => latticeBall_disjoint_of_coordinate_gap e
        (by have h := hx hij; omega)))
    simpa using hh
  have hQ ω : (∫ x, F ω x ∂π) ≤ (∫ x, noDropProduct ℓ x ω ∂π) + δ := by
    have hI : Integrable (noDropProduct ℓ · ω) π :=
      integrable_of_nonneg_bound π (measurable_of_countable _) (fun x => noDropProduct_bounds ℓ x ω)
    have hJ : Integrable (F ω) π :=
      integrable_of_nonneg_bound π (measurable_of_countable _) (fun x =>
        ⟨(pow_pos hδ k).le.trans (hb ω x).1, (hb ω x).2⟩)
    calc
      (∫ x, F ω x ∂π) ≤ ∫ x, noDropProduct ℓ x ω + δ ∂π :=
        integral_mono hJ (hI.add (integrable_const δ)) (clippedNoDropProduct_error ℓ hδ.le hδ1 · ω)
      _ = (∫ x, noDropProduct ℓ x ω ∂π) + δ := by simp [integral_add hI (integrable_const δ)]
  have hmark := inverse_mixture_markov (environmentLaw ν) π F hF
    (fun ω => ∫ x, noDropProduct ℓ x ω ∂π) (pow_pos hδ k) hlam.le hs0 hs hb hQ hE
  apply hmark.trans (ENNReal.ofReal_le_ofReal ?_)
  have h3 : (3 : ℝ) ^ lam ≤ 3 := by
    simpa only [Real.rpow_one] using Real.rpow_le_rpow_of_exponent_le (show (1 : ℝ) ≤ 3 by norm_num) hlam1
  have h6 : (6 : ℝ) ≤ 6 ^ k := by
    have h := pow_le_pow_right₀ (show (1 : ℝ) ≤ 6 by norm_num) hk
    simpa only [pow_one] using h
  have hexp : Real.exp (C * k) = (6 * M) ^ k := by
    rw [mul_comm, Real.exp_nat_mul, Real.exp_log (by positivity : 0 < 6 * M)]
  rw [hexp, Real.mul_rpow (by norm_num : (0 : ℝ) ≤ 3) hs0.le, mul_pow]
  have hsp : 0 ≤ s ^ lam := Real.rpow_nonneg hs0.le _
  calc
    3 ^ lam * s ^ lam * (2 * M ^ k) ≤ 6 * M ^ k * s ^ lam := by
      nlinarith [mul_le_mul_of_nonneg_right h3 (mul_nonneg hsp (pow_nonneg hM0 k))]
    _ ≤ 6 ^ k * M ^ k * s ^ lam := by gcongr

lemma hitKernel_apply_eq_hit {d : ℕ} {S T : Set (Lattice d)}
    (hST : Disjoint S T) (U : Set (Lattice d)) (z : State d) :
    hitKernel S T z U = quenchedKernel z (Hit S (T ∩ U)) := by
  rw [hitKernel_apply]
  exact (measure_iUnion (hitAt_pairwise_disjoint (hST.mono_right Set.inter_subset_left))
    (measurableSet_hitAt S (T ∩ U))).symm

lemma hit_concatenation {d : ℕ} {S₁ T₁ S₂ T₂ S : Set (Lattice d)}
    (h₁ : S₁ ⊆ S) (h₂ : S₂ ⊆ S) :
    (⋃ n, HitAt S₁ T₁ n ∩ FutureEvent (fun _ => Hit S₂ T₂) n) ⊆ Hit S T₂ := by
  rintro X hX
  obtain ⟨n, hn, hfuture⟩ := Set.mem_iUnion.mp hX
  obtain ⟨m, hm⟩ := Set.mem_iUnion.mp hfuture
  apply Set.mem_iUnion.mpr
  refine ⟨n + m, hm.1, ?_⟩
  intro j hj
  by_cases hjn : j < n
  · exact h₁ (hn.2 j hjn)
  · have hn : n ≤ j := by omega
    have hsub : j - n < m := by omega
    have := h₂ (hm.2 (j - n) hsub)
    simpa only [Nat.add_sub_of_le hn] using this

lemma hitKernel_comp_le {d : ℕ} (ω : Environment d) (x : Lattice d)
    {S₁ T₁ S₂ T₂ S : Set (Lattice d)}
    (hST₁ : Disjoint S₁ T₁) (hST₂ : Disjoint S₂ T₂) (hST : Disjoint S T₂)
    (h₁ : S₁ ⊆ S) (h₂ : S₂ ⊆ S) (U : Set (Lattice d)) :
    (∫⁻ y, hitKernel S₂ T₂ (ω, y) U ∂hitKernel S₁ T₁ (ω, x)) ≤
      hitKernel S T₂ (ω, x) U := by
  simp_rw [hitKernel_apply_eq_hit hST₂ U]
  rw [hitKernel_future ω x hST₁ (fun _ => Hit S₂ (T₂ ∩ U))
    (fun _ => measurableSet_hit _ _), hitKernel_apply_eq_hit hST U]
  exact measure_mono (hit_concatenation h₁ h₂)

def HeightSlab {d : ℕ} (i : Fin d) (a b : ℤ) : Set (Lattice d) :=
  {x | a ≤ x i ∧ x i < b}

def HeightLayer {d : ℕ} (i : Fin d) (b : ℤ) : Set (Lattice d) :=
  {x | x i = b}

lemma heightSlab_disjoint_layer {d : ℕ} (i : Fin d) (a b : ℤ) :
    Disjoint (HeightSlab i a b) (HeightLayer i b) := by
  apply Set.disjoint_left.mpr
  intro x hx hy
  exact (ne_of_lt hx.2) hy

noncomputable def heightKernel {d : ℕ} (i : Fin d) (a b : ℤ) :
    Kernel (State d) (Lattice d) :=
  hitKernel (HeightSlab i a b) (HeightLayer i b)

lemma heightKernel_total_le_one {d : ℕ} (i : Fin d) (a b : ℤ) (z : State d) :
    heightKernel i a b z Set.univ ≤ 1 :=
  hitKernel_total_le_one (heightSlab_disjoint_layer i a b) z

instance heightKernel_finite {d : ℕ} (i : Fin d) (a b : ℤ) :
    IsFiniteKernel (heightKernel i a b) where
  exists_univ_le := ⟨1, ENNReal.one_lt_top, heightKernel_total_le_one i a b⟩

lemma heightKernel_supported {d : ℕ} (i : Fin d) (a b : ℤ) (z : State d) :
    ∀ᵐ y ∂heightKernel i a b z, y i = b := by
  rw [ae_iff]
  change hitKernel (HeightSlab i a b) (HeightLayer i b) z (HeightLayer i b)ᶜ = 0
  rw [hitKernel_apply_eq_hit (heightSlab_disjoint_layer i a b), Set.inter_compl_self]
  have he : Hit (HeightSlab i a b) ∅ = ∅ := by
    ext X
    simp [Hit, HitAt]
  rw [he, measure_empty]

lemma heightKernel_rows {d : ℕ} (i : Fin d) {a b : ℤ} (hab : a < b)
    (x : Lattice d) (hx : x i = a) :
    @Measurable _ _ (rowSigma (HeightSlab i a b)) _
      (fun ω : Environment d => heightKernel i a b (ω, x)) := by
  exact measurable_hitKernel_rows _ _ x ⟨by simpa only [hx] using (le_refl a), by simpa only [hx]⟩

lemma heightKernel_comp_le {d : ℕ} (i : Fin d) {a b c : ℤ}
    (hab : a ≤ b) (hbc : b ≤ c) (ω : Environment d) (x : Lattice d)
    (U : Set (Lattice d)) :
    (∫⁻ y, heightKernel i b c (ω, y) U ∂heightKernel i a b (ω, x)) ≤
      heightKernel i a c (ω, x) U := by
  exact hitKernel_comp_le ω x (heightSlab_disjoint_layer i a b)
    (heightSlab_disjoint_layer i b c) (heightSlab_disjoint_layer i a c)
    (fun _ h => ⟨h.1, h.2.trans_le hbc⟩)
    (fun _ h => ⟨hab.trans h.1, h.2⟩) U

noncomputable def normalizedMeasure {α : Type*} [MeasurableSpace α]
    (μ : Measure α) : Measure α := (μ Set.univ)⁻¹ • μ

lemma normalizedMeasure_probability {α : Type*} [MeasurableSpace α]
    (μ : Measure α) [IsFiniteMeasure μ] (hμ : μ Set.univ ≠ 0) :
    IsProbabilityMeasure (normalizedMeasure μ) := by
  constructor
  simp only [normalizedMeasure, Measure.smul_apply, smul_eq_mul]
  exact ENNReal.inv_mul_cancel hμ (measure_ne_top μ Set.univ)

lemma mass_smul_normalizedMeasure {α : Type*} [MeasurableSpace α]
    (μ : Measure α) [IsFiniteMeasure μ] :
    μ Set.univ • normalizedMeasure μ = μ := by
  by_cases hμ : μ Set.univ = 0
  · have hzero : μ = 0 := Measure.measure_univ_eq_zero.mp hμ
    simp [hzero, normalizedMeasure]
  · rw [normalizedMeasure, smul_smul,
      ENNReal.mul_inv_cancel hμ (measure_ne_top μ Set.univ), one_smul]

lemma integral_normalized_comp {α : Type*} [MeasurableSpace α]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → ℝ≥0∞) :
    μ Set.univ * (∫⁻ x, f x ∂normalizedMeasure μ) = ∫⁻ x, f x ∂μ := by
  change μ Set.univ • (∫⁻ x, f x ∂normalizedMeasure μ) = _
  rw [← lintegral_smul_measure, mass_smul_normalizedMeasure]

lemma retained_kernel_comp_le {d : ℕ} (i : Fin d) {a b c : ℤ}
    (hab : a ≤ b) (hbc : b ≤ c) (ω : Environment d) (x : Lattice d)
    (ρ : Measure (Lattice d)) (hρ : ρ ≤ heightKernel i a b (ω, x))
    (U : Set (Lattice d)) :
    ρ Set.univ * (∫⁻ y, heightKernel i b c (ω, y) U ∂normalizedMeasure ρ) ≤
      heightKernel i a c (ω, x) U := by
  have : IsFiniteMeasure ρ := ⟨lt_of_le_of_lt (hρ Set.univ)
    (measure_lt_top (heightKernel i a b (ω, x)) Set.univ)⟩
  rw [integral_normalized_comp]
  exact (lintegral_mono' hρ le_rfl).trans (heightKernel_comp_le i hab hbc ω x U)

lemma pathCylinder_weight_locality {d : ℕ} (S : Set (Lattice d))
    (ω η : Environment d) (hωη : Set.EqOn ω η S) (x : Lattice d)
    (f : Path d) (n : ℕ) (hf : ∀ j < n, f j ∈ S) :
    quenchedKernel (ω, x) (pathCylinder f n) =
      quenchedKernel (η, x) (pathCylinder f n) := by
  by_cases hfx : f 0 = x
  · rw [quenched_pathCylinder ω x f hfx, quenched_pathCylinder η x f hfx]
    exact Finset.prod_congr rfl fun j hj => by
      simp only [edgeWeight, hωη (hf j (Finset.mem_range.mp hj))]
  · rw [quenched_pathCylinder_zero ω x f hfx, quenched_pathCylinder_zero η x f hfx]

lemma quenched_restrict_stay_congr {d : ℕ} (S : Set (Lattice d))
    (ω η : Environment d) (hωη : Set.EqOn ω η S) (x : Lattice d) :
    (quenchedKernel (ω, x)).restrict (Stay S) =
      (quenchedKernel (η, x)).restrict (Stay S) := by
  apply pathMeasure_ext
  intro f n
  rw [Measure.restrict_apply (measurableSet_pathCylinder f n),
    Measure.restrict_apply (measurableSet_pathCylinder f n)]
  by_cases hf : ∀ j ≤ n, f j ∈ S
  · have he : pathCylinder f n ∩ Stay S =
        (fun X : Path d => fun j => X (n + j)) ⁻¹' Stay S ∩ pathCylinder f n := by
      ext X
      constructor
      · rintro ⟨hX, hS⟩
        exact ⟨fun j => hS (n + j), hX⟩
      · rintro ⟨hS, hX⟩
        refine ⟨hX, fun j => ?_⟩
        by_cases hj : j ≤ n
        · simpa only [hX j hj] using hf j hj
        · have hnj : n ≤ j := by omega
          simpa only [Nat.add_sub_of_le hnj] using hS (j - n)
    rw [he]
    by_cases hfx : f 0 = x
    · rw [quenched_prefix_future ω x f hfx n (measurableSet_stay S),
        quenched_prefix_future η x f hfx n (measurableSet_stay S),
        pathCylinder_weight_locality S ω η hωη x f n (fun j hj => hf j hj.le),
        quenched_stay_congr S ω η hωη (f n)]
    · rw [measure_mono_null Set.inter_subset_right (quenched_pathCylinder_zero ω x f hfx n),
        measure_mono_null Set.inter_subset_right (quenched_pathCylinder_zero η x f hfx n)]
  · have he : pathCylinder f n ∩ Stay S = ∅ := by
      apply Set.eq_empty_iff_forall_notMem.mpr
      rintro X ⟨hX, hS⟩
      exact hf fun j hj => by simpa only [← hX j hj] using hS j
    rw [he]
    simp

lemma quenched_stay_event_congr {d : ℕ} (A : Set (Path d))
    (T : Set (Lattice d)) (hA : MeasurableSet A) (hAT : A ⊆ Stay T)
    (ω η : Environment d) (hωη : Set.EqOn ω η T) (x : Lattice d) :
    quenchedKernel (ω, x) A = quenchedKernel (η, x) A := by
  have := congrArg (fun μ : Measure (Path d) => μ A)
    (quenched_restrict_stay_congr T ω η hωη x)
  simpa only [Measure.restrict_apply hA, Set.inter_eq_left.mpr hAT] using this

lemma measurable_quenched_stay_event_rows {d : ℕ} (T : Set (Lattice d))
    (x : Lattice d) (hx : x ∈ T) (A : Set (Path d))
    (hA : MeasurableSet A) (hAT : A ⊆ Stay T) :
    @Measurable _ _ (rowSigma T) _ (fun ω : Environment d => quenchedKernel (ω, x) A) := by
  apply measurable_of_row_locality _
    ((Kernel.measurable_coe _ hA).comp (measurable_id.prodMk measurable_const)) T x hx
  intro ω η h
  exact quenched_stay_event_congr A T hA hAT ω η h x

lemma annealed_event_translation {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (x : Lattice d) (A : Set (Path d)) (hA : MeasurableSet A) :
    (∫⁻ ω, quenchedKernel (ω, x) ((fun X : Path d => fun n => X n - x) ⁻¹' A)
      ∂environmentLaw ν) = annealedLaw ν A := by
  have ht : Measurable (fun X : Path d => fun n => X n - x) := by fun_prop
  have he (ω : Environment d) :
      quenchedKernel (ω, x) ((fun X : Path d => fun n => X n - x) ⁻¹' A) =
        quenchedKernel ((fun a => ω (x + a)), 0) A := by
    have := congrArg (fun μ : Measure (Path d) => μ A) (quenched_translation ω x 0)
    rw [Measure.map_apply ht hA] at this
    simpa only [add_zero] using this
  simp_rw [he]
  have hm : Measurable (fun ω : Environment d => quenchedKernel (ω, 0) A) :=
    (Kernel.measurable_coe _ hA).comp (measurable_id.prodMk measurable_const)
  rw [← lintegral_map hm (show Measurable (fun ω : Environment d => fun a => ω (x + a)) by
    fun_prop), environment_translation, ← annealed_apply ν hA]

lemma annealed_record_suffix {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (ℓ : Vector d) (w : List (Direction d))
    (hrecord : ∀ y ∈ wordDepartures 0 w,
      dot (realPosition y) ℓ < dot (realPosition (wordPath 0 w w.length)) ℓ)
    (A : Set (Path d)) (hA : MeasurableSet A) (hAD : A ⊆ NoDrop ℓ 0) :
    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) := {z | dot (realPosition y) ℓ ≤ dot (realPosition z) ℓ}
  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 := hAD hX j
    change dot (realPosition y) ℓ ≤ dot (realPosition (X j)) ℓ
    change dot (realPosition 0) ℓ ≤ dot (realPosition (X j - y)) ℓ at h
    rw [dot_realPosition_sub] at h
    have hzero : dot (realPosition (0 : Lattice d)) ℓ = 0 := by simp [dot, realPosition]
    rw [hzero] at h
    linarith
  have hST : Disjoint S T := by
    apply Set.disjoint_left.mpr
    intro z hz hz'
    exact (not_le_of_gt (hrecord z hz)) hz'
  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
      (show dot (realPosition y) ℓ ≤ dot (realPosition y) ℓ from le_rfl) B hB hBT)]
  rw [← annealed_wordCylinder, annealed_event_translation ν y A hA]

end DirectionalTransience
end
end

end OAI