import OAI.Probability.DirectionalWalk.DirectionalReduction

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

def axisDirection {d : ℕ} (e : Step d) : Fin d → ℝ :=
  Pi.single e.1 (if e.2 then 1 else -1)

def axisHeight {d : ℕ} (e : Step d) (x : Site d) : ℤ :=
  if e.2 then x e.1 else -(x e.1)

lemma height_axisDirection {d : ℕ} (e : Step d) (x : Site d) :
    height (axisDirection e) x = (axisHeight e x : ℝ) := by
  rcases e with ⟨i,b⟩
  cases b <;> simp [height,axisDirection,axisHeight,Pi.single_apply]

lemma axisHeight_zero {d : ℕ} (e : Step d) : axisHeight e 0 = 0 := by
  simp [axisHeight]

lemma axisDirection_ne_zero {d : ℕ} (e : Step d) : axisDirection e ≠ 0 := by
  intro hh
  have h := congr_fun hh e.1
  rcases e with ⟨i,b⟩
  cases b <;> simp [axisDirection] at h

lemma axisDirection_normalized {d : ℕ} (e : Step d) :
    (∀ i, |axisDirection e i| ≤ 1) ∧ ∃ i, |axisDirection e i| = 1 := by
  classical
  constructor
  · intro i
    simp only [axisDirection, Pi.single_apply]
    split_ifs <;> norm_num
  · refine ⟨e.1, ?_⟩
    simp only [axisDirection, Pi.single_eq_same]
    cases e.2 <;> norm_num

lemma axisHeight_add {d : ℕ} (e : Step d) (x y : Site d) :
    axisHeight e (x+y) = axisHeight e x + axisHeight e y := by
  rcases e with ⟨i,b⟩
  cases b <;> simp [axisHeight,add_comm]

lemma axisHeight_step_le {d : ℕ} (e f : Step d) : axisHeight e (stepVector f) ≤ 1 := by
  rcases e with ⟨i,b⟩
  rcases f with ⟨j,c⟩
  cases b <;> cases c <;> simp [axisHeight,stepVector] <;> split_ifs <;> omega

lemma axisHeight_step_ge {d : ℕ} (e f : Step d) : -1 ≤ axisHeight e (stepVector f) := by
  rcases e with ⟨i,b⟩
  rcases f with ⟨j,c⟩
  cases b <;> cases c <;> simp [axisHeight,stepVector] <;> split_ifs <;> omega

lemma axisHeight_nn_le {d : ℕ} (e : Step d) (X : Path d) (hX : nearestNeighbour X) (n : ℕ) :
    axisHeight e (X (n+1)) ≤ axisHeight e (X n) + 1 := by
  obtain ⟨f,hf⟩ := hX n
  rw [hf,axisHeight_add]
  exact add_le_add le_rfl (axisHeight_step_le e f)

lemma axis_recordCount_witness {d : ℕ} (e : Step d) (X : Path d)
    (h0 : axisHeight e (X 0) = 0) (n : ℕ) :
    ∃ j ≤ n, (recordCount (axisDirection e) X n : ℤ) ≤ axisHeight e (X j) := by
  classical
  induction n with
  | zero => exact ⟨0,le_rfl,by simp [recordCount_zero,h0]⟩
  | succ n ih =>
    obtain ⟨j,hj,hcount⟩ := ih
    rw [recordCount_succ]
    by_cases hr : strictRecord (axisDirection e) X (n+1)
    · rw [ite_eq_left hr, Nat.cast_add, Nat.cast_one]
      refine ⟨n+1,le_rfl,?_⟩
      have hh := hr.2 j (by omega)
      simp only [height_axisDirection,Int.cast_lt] at hh
      omega
    · rw [ite_eq_right hr,add_zero]
      exact ⟨j,by omega,hcount⟩

lemma axis_record_height {d : ℕ} (e : Step d) (X : Path d) (n : ℕ)
    (h0 : X 0 = 0) (hX : ∀ i < n, axisHeight e (X (i+1)) ≤ axisHeight e (X i)+1)
    (hr : n = 0 ∨ strictRecord (axisDirection e) X n) :
    axisHeight e (X n) = (recordCount (axisDirection e) X n : ℤ) := by
  have hz : axisHeight e (X 0) = 0 := by rw [h0,axisHeight_zero]
  apply le_antisymm
  · have hs : ∀ i < n, height (axisDirection e) (X (i+1)) ≤ height (axisDirection e) (X i)+1 := by
      intro i hi
      simp only [height_axisDirection]
      exact_mod_cast hX i hi
    have hh := height_le_recordCount (axisDirection e) X n (by rw [h0,height_zero]) hs n le_rfl
    rw [height_axisDirection] at hh
    exact_mod_cast hh
  · obtain ⟨j,hj,hjc⟩ := axis_recordCount_witness e X hz n
    apply hjc.trans
    rcases hr with rfl | hr
    · have : j = 0 := by omega
      simp [this]
    · by_cases he : j = n
      · rw [he]
      · have hh := hr.2 j (by omega)
        simp only [height_axisDirection,Int.cast_lt] at hh
        exact hh.le

lemma integer_first_crossing (f : ℕ → ℤ) (n : ℕ) (a : ℤ)
    (hf : ∀ i < n, f (i+1) ≤ f i+1) (h0 : f 0 ≤ a) (hn : a ≤ f n) :
    ∃ j ≤ n, f j = a ∧ ∀ i < j, f i < a := by
  have hex : ∃ k, a ≤ f k := ⟨n,hn⟩
  let j := Nat.find hex
  have hj : a ≤ f j := Nat.find_spec hex
  have hjn : j ≤ n := Nat.find_min' hex hn
  have hmin : ∀ i < j, f i < a := by
    intro i hi
    exact lt_of_not_ge (Nat.find_min hex hi)
  refine ⟨j,hjn,?_,hmin⟩
  apply le_antisymm _ hj
  by_cases hz : j = 0
  · simpa [hz] using h0
  · have hbelow := hmin (j-1) (by omega)
    have hstep := hf (j-1) (by omega)
    have he : j-1+1 = j := by omega
    rw [he] at hstep
    omega

def reachAxis {d : ℕ} (e : Step d) (H : ℕ) : Set (Path d) :=
  {X | ∃ n, axisHeight e (X n) = H ∧ ∀ i ≤ n, 0 ≤ axisHeight e (X i)}

lemma measurableSet_reachAxis {d : ℕ} (e : Step d) (H : ℕ) : MeasurableSet (reachAxis e H) := by
  simp only [reachAxis,Set.ofPred_exists,Set.ofPred_and,Set.ofPred_forall]
  refine MeasurableSet.iUnion (fun n => (measurableSet_eq_fun
    ((measurable_of_countable (axisHeight e)).comp (measurable_pi_apply n)) measurable_const).inter ?_)
  exact MeasurableSet.iInter (fun i => MeasurableSet.iInter (fun _ =>
    measurableSet_le measurable_const ((measurable_of_countable (axisHeight e)).comp (measurable_pi_apply i))))

lemma reachRecord_eq_reachAxis {d : ℕ} (e : Step d) (X : Path d)
    (h0 : X 0 = 0) (hX : nearestNeighbour X) (H : ℕ) :
    X ∈ reachRecord (axisDirection e) H ↔ X ∈ reachAxis e H := by
  constructor
  · intro hh
    obtain ⟨n,hn⟩ := Set.mem_iUnion.mp hh
    refine ⟨n,?_,?_⟩
    · rw [axis_record_height e X n h0 (fun i _ => axisHeight_nn_le e X hX i) hn.1,hn.2.1]
    · intro i hi
      have hh := hn.2.2 i hi
      rw [height_axisDirection] at hh
      exact_mod_cast hh
  · rintro ⟨n,hn,hbelow⟩
    obtain ⟨j,hjn,hj,hmin⟩ := integer_first_crossing (fun i => axisHeight e (X i)) n H
      (fun i _ => axisHeight_nn_le e X hX i) (by simp [h0,axisHeight_zero]) hn.ge
    have hr : j = 0 ∨ strictRecord (axisDirection e) X j := by
      by_cases hz : j = 0
      · exact Or.inl hz
      · refine Or.inr ⟨by omega,fun i hi => ?_⟩
        simp only [height_axisDirection]
        exact_mod_cast (show axisHeight e (X i) < axisHeight e (X j) by rw [hj];exact hmin i hi)
    refine Set.mem_iUnion.mpr ⟨j,hr,?_,?_⟩
    · have hc := axis_record_height e X j h0 (fun i _ => axisHeight_nn_le e X hX i) hr
      rw [hj] at hc
      exact_mod_cast hc.symm
    · intro i hi
      rw [height_axisDirection]
      exact_mod_cast hbelow i (hi.trans hjn)

lemma reachAxis_antitone {d : ℕ} (e : Step d) (X : Path d)
    (h0 : X 0 = 0) (hX : nearestNeighbour X) {m n : ℕ} (hmn : m ≤ n) :
    X ∈ reachAxis e n → X ∈ reachAxis e m := by
  rintro ⟨k,hk,hbelow⟩
  obtain ⟨j,hjk,hj,_⟩ := integer_first_crossing (fun i => axisHeight e (X i)) k m
    (fun i _ => axisHeight_nn_le e X hX i) (by simp [h0,axisHeight_zero])
    (by rw [hk];exact_mod_cast hmn)
  exact ⟨j,hj,fun i hi => hbelow i (hi.trans hjk)⟩

lemma last_record_cut_partition {d : ℕ} (v : Fin d → ℝ) (X : Path d)
    (h0 : X 0 = 0) (hD : X ∈ nonBacktracking v) (N : ℕ) :
    X ∈ ⋃ j ∈ Finset.range (N+1), recordTailEvent v j (noCutBeforeRecord v (N-j)) := by
  classical
  let s := (Finset.range (N+1)).filter (fun j => ∃ n, recordPrefix v j X n ∧
    relativeTail n X ∈ nonBacktracking v)
  have h0s : 0 ∈ s := by
    refine Finset.mem_filter.mpr ⟨by simp,0,⟨Or.inl rfl, recordCount_zero v X,?_⟩,?_⟩
    · intro i hi
      have : i = 0 := by omega
      rw [this,h0,height_zero]
    · intro k
      simpa [relativeTail_apply,height_sub,h0,height_zero] using hD k
  let j := s.max' ⟨0,h0s⟩
  have hjs := s.max'_mem ⟨0,h0s⟩
  obtain ⟨hj, n, hpre, htail⟩ := Finset.mem_filter.mp hjs
  have hjN : j ≤ N := by have := Finset.mem_range.mp hj; omega
  refine Set.mem_iUnion.mpr ⟨j,Set.mem_iUnion.mpr ⟨hj,Set.mem_iUnion.mpr ⟨n,hpre,?_,htail⟩⟩⟩
  intro m hm
  have hmpos := hm.1.1
  have hcut : trueCut v X (n+m) := (trueCut_relativeTail v X hpre.1 hm.1.1).mp hm
  have hcount := recordCount_relativeTail v X hpre.1 m
  rw [hpre.2.1] at hcount
  by_contra hlt
  have hk : recordCount v X (n+m) ≤ N := by omega
  have hk_mem : recordCount v X (n+m) ∈ s := by
    refine Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by omega),n+m,?_,?_⟩
    · exact ⟨Or.inr hcut.1,rfl,fun i _ => hD i⟩
    · exact (relativeTail_nonBacktracking_iff v X (n+m)).mpr hcut.2
  have hle := s.le_max' (recordCount v X (n+m)) hk_mem
  have hgt := recordCount_strict v X (show n < n+m by omega) hcut.1
  rw [hpre.2.1] at hgt
  exact (not_lt_of_ge hle) hgt

lemma record_tail_sum_eq_one {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (v : Fin d → ℝ) (hp : 0 < annealed μ 0 (nonBacktracking v)) (N : ℕ) :
    ∑ j ∈ Finset.range (N+1), annealed μ 0 (reachRecord v j) *
      conditioned μ v (noCutBeforeRecord v (N-j)) = 1 := by
  let := conditioned_probability μ v hp
  calc
    _ = ∑ j ∈ Finset.range (N+1), conditioned μ v
        (recordTailEvent v j (noCutBeforeRecord v (N-j))) := by
      apply Finset.sum_congr rfl
      intro j _
      exact (recordTail_factorization μ v j (measurableSet_noCutBeforeRecord v (N-j))).symm
    _ = conditioned μ v (⋃ j ∈ Finset.range (N+1),
        recordTailEvent v j (noCutBeforeRecord v (N-j))) := by
      symm
      exact measure_biUnion_finset (recordTailEvent_disjoint v N)
        (fun j _ => measurableSet_recordTailEvent v j (measurableSet_noCutBeforeRecord v (N-j)))
    _ = 1 := by
      apply (mem_ae_iff_prob_eq_one (MeasurableSet.biUnion (Finset.countable_toSet _)
        (fun j _ => measurableSet_recordTailEvent v j (measurableSet_noCutBeforeRecord v (N-j))))).mp
      have h0 := (cond_absolutelyContinuous (s := nonBacktracking v) (μ := annealed μ 0)).ae_le
        (ae_start_and_nearestNeighbour μ 0)
      have hD : ∀ᵐ X ∂conditioned μ v, X ∈ nonBacktracking v :=
        ae_cond_mem (measurableSet_nonBacktracking v)
      filter_upwards [h0,hD] with X hX hXD
      exact last_record_cut_partition v X hX.1 hXD N

noncomputable def axisReachProb {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) (H : ℕ) : ℝ≥0∞ := annealed μ 0 (reachAxis e H)

lemma axisReachProb_eq_record {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) (H : ℕ) : axisReachProb μ e H = annealed μ 0 (reachRecord (axisDirection e) H) := by
  apply measure_congr
  filter_upwards [ae_start_and_nearestNeighbour μ 0] with X hX
  exact propext (reachRecord_eq_reachAxis e X hX.1 hX.2 H).symm

lemma axisReachProb_antitone {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) : Antitone (axisReachProb μ e) := by
  intro m n hmn
  apply measure_mono_ae
  filter_upwards [ae_start_and_nearestNeighbour μ 0] with X hX
  exact reachAxis_antitone e X hX.1 hX.2 hmn

lemma axisReachProb_lower {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d) (H : ℕ) :
    annealed μ 0 (nonBacktracking (axisDirection e)) ≤ axisReachProb μ e H := by
  rw [axisReachProb_eq_record]
  exact reachRecord_mass_ge μ hell (axisDirection e) (axisDirection_ne_zero e) H

lemma axisReachProb_zero {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) : axisReachProb μ e 0 = 1 := by
  apply (mem_ae_iff_prob_eq_one (measurableSet_reachAxis e 0)).mp
  filter_upwards [ae_start_and_nearestNeighbour μ 0] with X hX
  refine ⟨0,by rw [hX.1,axisHeight_zero]; rfl,?_⟩
  intro i hi
  have : i = 0 := by omega
  simp [this,hX.1,axisHeight_zero]

noncomputable def axisWidthTail {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) (H : ℕ) : ℝ≥0∞ :=
  slabLaw μ (axisDirection e) {γ | H < slabRecords (axisDirection e) γ}

lemma axis_renewal_tail_identity {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) (N : ℕ) :
    ∑ j ∈ Finset.range (N+1), axisReachProb μ e j * axisWidthTail μ e (N-j) = 1 := by
  simp_rw [axisReachProb_eq_record,axisWidthTail,
    slabRecords_tail μ hell (axisDirection e) (axisDirection_ne_zero e) hp]
  exact record_tail_sum_eq_one μ (axisDirection e) hp N

lemma slabRecords_pos {d : ℕ} (v : Fin d → ℝ) (γ : Word d) (hγ : RegenerationWord v γ) :
    0 < slabRecords v γ := by
  have hr : strictRecord v (wordPath γ) γ.1 :=
    ⟨hγ.1,fun j hj => (hγ.2.2.2.1 j hj).2⟩
  have hh := recordCount_strict v (wordPath γ) hγ.1 hr
  simpa only [recordCount_zero, slabRecords] using hh

lemma axis_slabWidth_eq_records {d : ℕ} (e : Step d) (γ : Word d)
    (hγ : RegenerationWord (axisDirection e) γ) :
    slabWidth (axisDirection e) γ = (slabRecords (axisDirection e) γ : ℝ) := by
  have hh := axis_record_height e (wordPath γ) γ.1 hγ.2.1 (fun j hj => by
    obtain ⟨f,hf⟩ := hγ.2.2.1 j hj
    rw [hf,axisHeight_add]
    exact add_le_add le_rfl (axisHeight_step_le e f))
    (Or.inr ⟨hγ.1,fun j hj => (hγ.2.2.2.1 j hj).2⟩)
  change height (axisDirection e) (wordPath γ γ.1) = _
  rw [height_axisDirection]
  exact_mod_cast hh

lemma axisWidthTail_zero {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) : axisWidthTail μ e 0 = 1 := by
  let := slabLaw_probability μ (axisDirection e) hp
  apply (mem_ae_iff_prob_eq_one (measurableSet_lt measurable_const (measurable_of_countable _))).mp
  filter_upwards [ae_slabLaw_regeneration μ hell (axisDirection e) (axisDirection_ne_zero e) hp] with γ hγ
  exact slabRecords_pos (axisDirection e) γ hγ

lemma axisWidthTail_antitone {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (e : Step d) : Antitone (axisWidthTail μ e) := by
  intro m n hmn
  exact measure_mono (fun _ hn => hmn.trans_lt hn)

lemma renewal_step_bound (u F : ℕ → ℝ) (hu : Antitone u) (hF : ∀ n, 0 ≤ F n)
    (hu0 : u 0 = 1) (hF0 : F 0 = 1)
    (hid : ∀ n, ∑ j ∈ Finset.range (n+1), u j * F (n-j) = 1) (n : ℕ) :
    u n - u (n+1) ≤ F (n+1) := by
  have hid' := hid (n+1)
  rw [Finset.sum_range_succ'] at hid'
  simp only [Nat.succ_sub_succ_eq_sub,hu0,one_mul,Nat.sub_zero] at hid'
  have heq : ∑ j ∈ Finset.range (n+1), (u j-u (j+1))*F (n-j) = F (n+1) := by
    simp_rw [sub_mul]
    rw [Finset.sum_sub_distrib,hid n]
    linarith
  have hle := Finset.single_le_sum (s := Finset.range (n+1))
    (f := fun j => (u j-u (j+1))*F (n-j))
    (fun j _ => mul_nonneg (sub_nonneg.mpr (hu (Nat.le_succ j))) (hF (n-j)))
    (show n ∈ Finset.range (n+1) by simp)
  simpa only [Nat.sub_self,hF0,mul_one,heq] using hle

lemma renewal_interval_bound (u F : ℕ → ℝ) (hu : Antitone u) (hF : Antitone F)
    (hstep : ∀ n, u n-u (n+1) ≤ F (n+1)) {n m : ℕ} (hnm : n ≤ m) :
    0 ≤ u n-u m ∧ u n-u m ≤ (m-n)*F n := by
  refine ⟨sub_nonneg.mpr (hu hnm),?_⟩
  obtain ⟨k,rfl⟩ := Nat.exists_eq_add_of_le hnm
  simp only [Nat.cast_add, add_sub_cancel_left]
  induction k with
  | zero => simp
  | succ k ih =>
    have ih := ih (by omega)
    have hs := (hstep (n+k)).trans (hF (show n ≤ n+k+1 by omega))
    have he : n+(k+1) = n+k+1 := by omega
    rw [he,Nat.cast_add,Nat.cast_one]
    nlinarith

lemma axis_renewal_identity_real {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) (N : ℕ) :
    ∑ j ∈ Finset.range (N+1), (axisReachProb μ e j).toReal *
      (axisWidthTail μ e (N-j)).toReal = 1 := by
  let := slabLaw_probability μ (axisDirection e) hp
  have h := congrArg ENNReal.toReal (axis_renewal_tail_identity μ hell e hp N)
  rw [ENNReal.toReal_sum (f := fun j => axisReachProb μ e j * axisWidthTail μ e (N-j))
    (fun j _ => ENNReal.mul_ne_top (measure_ne_top _ _) (measure_ne_top _ _))] at h
  simpa only [ENNReal.toReal_mul,ENNReal.toReal_one] using h

lemma axis_renewal_tail_bound {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) {n m : ℕ} (hnm : n ≤ m) :
    0 ≤ (axisReachProb μ e n).toReal-(axisReachProb μ e m).toReal ∧
      (axisReachProb μ e n).toReal-(axisReachProb μ e m).toReal ≤
        (m-n)*(axisWidthTail μ e n).toReal := by
  let := slabLaw_probability μ (axisDirection e) hp
  have hu : Antitone (fun n => (axisReachProb μ e n).toReal) :=
    fun _ _ h => ENNReal.toReal_mono (measure_ne_top _ _) (axisReachProb_antitone μ e h)
  have hF : Antitone (fun n => (axisWidthTail μ e n).toReal) :=
    fun _ _ h => ENNReal.toReal_mono (measure_ne_top _ _) (axisWidthTail_antitone μ e h)
  apply renewal_interval_bound _ _ hu hF _ hnm
  intro k
  apply renewal_step_bound _ _ hu (fun _ => ENNReal.toReal_nonneg) _ _
    (axis_renewal_identity_real μ hell e hp) k
  · rw [axisReachProb_zero,ENNReal.toReal_one]
  · rw [axisWidthTail_zero μ hell e hp,ENNReal.toReal_one]

lemma summable_axisWidthTail {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) :
    Summable (fun n => (axisWidthTail μ e n).toReal) := by
  apply ENNReal.summable_toReal
  change (∑' n, slabLaw μ (axisDirection e) {γ | n < slabRecords (axisDirection e) γ}) ≠ ⊤
  rw [← lintegral_nat_tail _ _ (measurable_of_countable _)]
  exact ((lintegral_slabRecords_le μ hell (axisDirection e) (axisDirection_ne_zero e) hp).trans_lt
    (ENNReal.inv_lt_top.mpr hp)).ne

lemma summable_dyadic_axisWidthTail {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) :
    Summable (fun l => (2:ℝ)^l*(axisWidthTail μ e (2^l)).toReal) := by
  let := slabLaw_probability μ (axisDirection e) hp
  apply (summable_condensed_iff_of_nonneg (fun _ => ENNReal.toReal_nonneg) (fun _ _ _ h =>
    ENNReal.toReal_mono (measure_ne_top _ _) (axisWidthTail_antitone μ e h))).mpr
  exact summable_axisWidthTail μ hell e hp

lemma iterated_cutSuffix_eq_relativeTail {d : ℕ} (v : Fin d → ℝ) (X : Path d)
    (h0 : X 0 = 0) (k : ℕ) : (cutSuffix v)^[k] X = relativeTail (slabTime v X k) X := by
  funext n
  exact iterated_cutSuffix v X h0 k n

lemma slabTime_boundary {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X)
    (k : ℕ) : slabTime v X k = 0 ∨ trueCut v X (slabTime v X k) := by
  induction k with
  | zero => exact Or.inl (slabTime_zero v X)
  | succ k ih =>
    right
    have hp : 0 < firstCutTime v ((cutSuffix v)^[k] X) := (hX.2 k).1
    have hc := ((firstCutTime_eq_pos_iff v ((cutSuffix v)^[k] X) hp).mp rfl).1
    have hc' : trueCut v (relativeTail (slabTime v X k) X) (slabs v X k).1 := by
      rw [← iterated_cutSuffix_eq_relativeTail v X hX.1 k]
      exact hc
    rw [slabTime_succ]
    exact (trueCut_relativeTail v X (ih.imp_right And.left) hp).mp hc'

lemma trueCut_eq_slabTime {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X)
    {n : ℕ} (hn : trueCut v X n) : ∃ k, slabTime v X k = n := by
  obtain ⟨k,hkn,hnk⟩ := slab_location v X hX n
  refine ⟨k,?_⟩
  by_contra hne
  have hlt : slabTime v X k < n := lt_of_le_of_ne hkn hne
  have hc : trueCut v (relativeTail (slabTime v X k) X) (n-slabTime v X k) := by
    apply (trueCut_relativeTail v X ((slabTime_boundary v X hX k).imp_right And.left)
      (Nat.sub_pos_of_lt hlt)).mpr
    simpa only [Nat.add_sub_of_le hkn] using hn
  rw [← iterated_cutSuffix_eq_relativeTail v X hX.1 k] at hc
  have hp : 0 < firstCutTime v ((cutSuffix v)^[k] X) := (hX.2 k).1
  have hm := ((firstCutTime_eq_pos_iff v ((cutSuffix v)^[k] X) hp).mp rfl).2
  apply hm (n-slabTime v X k) _ hc
  rw [slabTime_succ] at hnk
  change n-slabTime v X k < (slabs v X k).1
  omega

lemma recordCount_slabTime {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X)
    (k : ℕ) : recordCount v X (slabTime v X k) =
      ∑ i ∈ Finset.range k, slabRecords v (slabs v X i) := by
  induction k with
  | zero => simp [slabTime_zero,recordCount_zero]
  | succ k ih =>
    rw [slabTime_succ,recordCount_relativeTail v X
      ((slabTime_boundary v X hX k).imp_right And.left),ih,Finset.sum_range_succ]
    congr 1
    rw [← iterated_cutSuffix_eq_relativeTail v X hX.1 k]
    exact (slabRecords_firstWord v ((cutSuffix v)^[k] X)).symm

def tapeCut {d : ℕ} (v : Fin d → ℝ) (H : ℕ) : Set (ℕ → Word d) :=
  {Z | ∃ k, ∑ i ∈ Finset.range k, slabRecords v (Z i) = H}

lemma measurableSet_tapeCut {d : ℕ} (v : Fin d → ℝ) (H : ℕ) :
    MeasurableSet (tapeCut v H) := by
  simp only [tapeCut,Set.ofPred_exists]
  apply MeasurableSet.iUnion
  intro k
  exact measurableSet_eq_fun (Finset.measurable_sum _ (fun i _ =>
    (measurable_of_countable (slabRecords v)).comp (measurable_pi_apply i))) measurable_const

lemma tapeCut_iff_recordTailEvent {d : ℕ} (v : Fin d → ℝ) (X : Path d)
    (hX : GoodSlabPath v X) (H : ℕ) :
    slabs v X ∈ tapeCut v H ↔ X ∈ recordTailEvent v H Set.univ := by
  have hD : X ∈ nonBacktracking v := fun t => goodSlabPath_height_nonneg v X hX t
  constructor
  · rintro ⟨k,hk⟩
    have hb := slabTime_boundary v X hX k
    refine Set.mem_iUnion.mpr ⟨slabTime v X k,⟨hb.imp_right And.left,?_,fun i _ => hD i⟩,
      Set.mem_univ _,?_⟩
    · rw [recordCount_slabTime v X hX k,hk]
    · rcases hb with hz | hc
      · intro i
        simpa [relativeTail_apply,hz,hX.1,height_sub,height_zero] using hD i
      · exact (relativeTail_nonBacktracking_iff v X _).mpr hc.2
  · intro ht
    obtain ⟨n,hn,_,hD'⟩ := Set.mem_iUnion.mp ht
    have hncut : n = 0 ∨ trueCut v X n := hn.1.imp_right
      (fun hr => ⟨hr,(relativeTail_nonBacktracking_iff v X n).mp hD'⟩)
    have hk : ∃ k, slabTime v X k = n := by
      rcases hncut with hz | hc
      · exact ⟨0,(slabTime_zero v X).trans hz.symm⟩
      · exact trueCut_eq_slabTime v X hX hc
    obtain ⟨k,rfl⟩ := hk
    refine ⟨k,?_⟩
    rw [← recordCount_slabTime v X hX k]
    exact hn.2.1

lemma tapeCut_mass {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0)
    (hp : 0 < annealed μ 0 (nonBacktracking v)) (H : ℕ) :
    Measure.infinitePi (fun _ : ℕ => slabLaw μ v) (tapeCut v H) =
      annealed μ 0 (reachRecord v H) := by
  let := conditioned_probability μ v hp
  rw [← slabs_map_eq_infinitePi μ hell v hv hp,
    Measure.map_apply (measurable_slabs v) (measurableSet_tapeCut v H)]
  have he : conditioned μ v (slabs v ⁻¹' tapeCut v H) =
      conditioned μ v (recordTailEvent v H Set.univ) := by
    apply measure_congr
    filter_upwards [ae_goodSlabPath μ hell v hv hp] with X hX
    exact propext (tapeCut_iff_recordTailEvent v X hX H)
  rw [he,recordTail_factorization μ v H MeasurableSet.univ,measure_univ,mul_one]

lemma axis_tapeCut_mass {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : 0 < annealed μ 0 (nonBacktracking (axisDirection e))) (H : ℕ) :
    Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection e)) (tapeCut (axisDirection e) H) =
      axisReachProb μ e H := by
  rw [tapeCut_mass μ hell _ (axisDirection_ne_zero e) hp,axisReachProb_eq_record]

end DirectionalZeroOne

end OAI