import OAI.Probability.FKMaps.TreeCode

namespace OAI

noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.TreeCoding

local instance : MeasurableSpace C(unitInterval, ℝ) := borel _
local instance : BorelSpace C(unitInterval, ℝ) := ⟨rfl⟩

def weakLadderHit (x : ℕ → ℕ) (n k : ℕ) : Prop :=
  negativeSurvival x n ∧ integerSum x (n+1)=(k:ℤ)


lemma measurableSet_weakLadderHit (n k : ℕ) : MeasurableSet {x | weakLadderHit x n k} := by
  unfold weakLadderHit negativeSurvival
  simp only [Set.ofPred_and,Set.ofPred_forall]
  exact (MeasurableSet.iInter fun j => MeasurableSet.iInter fun _ =>
    MeasurableSet.iInter fun _ => measurableSet_lt (measurable_integerSum j) measurable_const).inter
    (measurableSet_eq_fun (measurable_integerSum (n+1)) measurable_const)


lemma weakLadderHit_decomposition (n k : ℕ) :
    {x | weakLadderHit x n k}=⋃ j : ℕ,
      {x | integerSum x n=-(j:ℤ) ∧ negativeSurvival x n} ∩ {x | x n=j+k+1} := by
  ext x
  simp only [Set.mem_ofPred_eq,Set.mem_iUnion,Set.mem_inter_iff]
  constructor
  · rintro ⟨hs,he⟩
    have hn : integerSum x n ≤ 0 := by
      cases n with
      | zero => simp
      | succ n => exact (hs _ (by omega) le_rfl).le
    refine ⟨(-integerSum x n).toNat,⟨?_,hs⟩,?_⟩
    · rw [Int.toNat_of_nonneg (by omega)]
      omega
    · rw [integerSum_succ] at he
      have hj := Int.toNat_of_nonneg (show 0 ≤ -integerSum x n by omega)
      omega
  · rintro ⟨j,⟨he,hs⟩,hx⟩
    refine ⟨hs,?_⟩
    rw [integerSum_succ,he,hx]
    push_cast
    ring


lemma weakLadderHit_decomposition_disjoint (n k : ℕ) :
    Pairwise (fun j l : ℕ => Disjoint
      ({x | integerSum x n=-(j:ℤ) ∧ negativeSurvival x n} ∩ {x | x n=j+k+1})
      ({x | integerSum x n=-(l:ℤ) ∧ negativeSurvival x n} ∩ {x | x n=l+k+1})) := by
  intro j l hjl
  apply Set.disjoint_left.mpr
  intro x hj hl
  exact hjl (by have := hj.1.1; have := hl.1.1; omega)


lemma CriticalEvenOffspring.weakLadderHit_mass (p : CriticalEvenOffspring) (n k : ℕ) :
    p.streamLaw {x | weakLadderHit x n k}=
    ∑' j : ℕ, p.streamLaw {x | integerSum x n=-(j:ℤ) ∧ negativeSurvival x n} * p.law (j+k+1) := by
  rw [weakLadderHit_decomposition,measure_iUnion (weakLadderHit_decomposition_disjoint n k)]
  · apply tsum_congr
    intro j
    exact p.prefix_inter_next n (j+k+1) _ (measurableSet_survival_endpoint j n)
      (survival_endpoint_truncate j n)
  · intro j
    exact (measurableSet_survival_endpoint j n).inter
      (measurableSet_eq_fun (measurable_pi_apply n) measurable_const)


theorem CriticalEvenOffspring.weakLadder_overshoot_mass (p : CriticalEvenOffspring) (k : ℕ) :
    (∑' n, p.streamLaw {x | weakLadderHit x n k})=∑' j : ℕ, p.law (j+k+1) := by
  simp_rw [p.weakLadderHit_mass]
  rw [ENNReal.tsum_comm]
  apply tsum_congr
  intro j
  rw [ENNReal.tsum_mul_right,p.negative_potential,one_mul]


lemma tail_tsum_ite (f : ℕ → ℝ≥0∞) (k : ℕ) :
    (∑' j : ℕ, f (j+k+1))=∑' r : ℕ, if k<r then f r else 0 := by
  have hi : Function.Injective (fun j : ℕ => j+k+1) := by intro a b h; dsimp at h; omega
  have hs : Function.support (fun r => if k<r then f r else 0) ⊆
      Set.range (fun j : ℕ => j+k+1) := by
    intro r hr
    have hkr : k<r := by by_contra hn; simp [Function.support,hn] at hr
    exact ⟨r-k-1,by dsimp; omega⟩
  simpa only [show ∀ j : ℕ, k<j+k+1 from by omega,ite_true] using hi.tsum_eq hs


lemma tail_tsum_total (f : ℕ → ℝ≥0∞) :
    (∑' k : ℕ, ∑' j : ℕ, f (j+k+1))=∑' r : ℕ, (r:ℝ≥0∞)*f r := by
  simp_rw [tail_tsum_ite]
  rw [ENNReal.tsum_comm]
  apply tsum_congr
  intro r
  rw [tsum_eq_sum (s := Finset.range r) (fun k hk => by simp [show ¬ k<r from by simpa using hk])]
  calc
    (∑ k ∈ Finset.range r, if k<r then f r else 0) = ∑ _k ∈ Finset.range r, f r := by
      apply Finset.sum_congr rfl
      intro k hk
      rw [ite_eq_left (Finset.mem_range.mp hk)]
    _ = _ := by simp


lemma sum_range_cast_nat (r : ℕ) :
    (∑ k ∈ Finset.range r,(k:ℝ))=((r:ℝ)^2-r)/2 := by
  induction r with
  | zero => simp
  | succ r ih =>
    rw [Finset.sum_range_succ,ih]
    push_cast
    ring


lemma tail_tsum_first_moment (f : ℕ → ℝ≥0∞) :
    (∑' k : ℕ, (k:ℝ≥0∞)*(∑' j : ℕ, f (j+k+1)))=
    ∑' r : ℕ, ENNReal.ofReal (((r:ℝ)^2-r)/2)*f r := by
  simp_rw [tail_tsum_ite,← ENNReal.tsum_mul_left]
  rw [ENNReal.tsum_comm]
  apply tsum_congr
  intro r
  rw [tsum_eq_sum (s := Finset.range r) (fun k hk => by simp [show ¬ k<r from by simpa using hk])]
  have he : (∑ k ∈ Finset.range r, (k:ℝ≥0∞)*(if k<r then f r else 0))=
      (∑ k ∈ Finset.range r,(k:ℝ≥0∞))*f r := by
    rw [Finset.sum_mul]
    exact Finset.sum_congr rfl fun k hk => by rw [ite_eq_left (Finset.mem_range.mp hk)]
  rw [he]
  congr 1
  rw [← sum_range_cast_nat,ENNReal.ofReal_sum_of_nonneg (fun k _ => Nat.cast_nonneg k)]
  simp


lemma CriticalEvenOffspring.ladder_total (p : CriticalEvenOffspring) :
    (∑' k : ℕ, ∑' j : ℕ, p.law (j+k+1))=1 := by
  rw [tail_tsum_total]
  have h := ENNReal.ofReal_tsum_of_nonneg
    (fun k : ℕ => mul_nonneg (Nat.cast_nonneg k) (p.nonneg k)) p.mean.summable
  rw [p.mean.tsum_eq] at h
  simpa [ENNReal.ofReal_mul,Nat.cast_nonneg] using h.symm


def CriticalEvenOffspring.ladderLaw (p : CriticalEvenOffspring) : PMF ℕ :=
  ⟨fun k => ∑' j : ℕ, p.law (j+k+1), ENNReal.summable.hasSum_iff.mpr p.ladder_total⟩


@[simp] lemma CriticalEvenOffspring.ladderLaw_apply (p : CriticalEvenOffspring) (k : ℕ) :
    p.ladderLaw k=∑' j : ℕ, p.law (j+k+1) := rfl


lemma CriticalEvenOffspring.variance_eq_second_sub_one (p : CriticalEvenOffspring) :
    p.variance=(∑' k : ℕ, (k:ℝ)^2*p.mass k)-1 := by
  have he : (fun k : ℕ => ((k:ℝ)-1)^2*p.mass k)=
      (fun k : ℕ => (k:ℝ)^2*p.mass k-2*((k:ℝ)*p.mass k)+p.mass k) := by
    funext k
    ring
  rw [variance,he]
  rw [Summable.tsum_add (p.second.sub (p.mean.summable.mul_left 2)) p.total.summable,
    Summable.tsum_sub p.second (p.mean.summable.mul_left 2),tsum_mul_left,p.mean.tsum_eq,p.total.tsum_eq]
  ring


lemma CriticalEvenOffspring.ladder_first_moment (p : CriticalEvenOffspring) :
    (∑' k : ℕ, (k:ℝ≥0∞)*p.ladderLaw k)=ENNReal.ofReal (p.variance/2) := by
  simp only [p.ladderLaw_apply]
  rw [tail_tsum_first_moment]
  have hs : Summable (fun r : ℕ => (((r:ℝ)^2-r)/2)*p.mass r) := by
    apply Summable.congr ((p.second.sub p.mean.summable).div_const 2)
    intro r
    ring
  have hn (r : ℕ) : 0 ≤ (((r:ℝ)^2-r)/2)*p.mass r := by
    apply mul_nonneg _ (p.nonneg r)
    have hr : r=0 ∨ 1 ≤ r := by omega
    rcases hr with hr | hr
    · simp [hr]
    · have hr' : (1:ℝ) ≤ r := by exact_mod_cast hr
      nlinarith
  have he : (∑' r : ℕ, (((r:ℝ)^2-r)/2)*p.mass r)=p.variance/2 := by
    have hf : (fun r : ℕ => (((r:ℝ)^2-r)/2)*p.mass r)=
        fun r : ℕ => ((r:ℝ)^2*p.mass r-(r:ℝ)*p.mass r)/2 := by funext r; ring
    rw [hf,tsum_div_const,
      Summable.tsum_sub p.second p.mean.summable,p.mean.tsum_eq,p.variance_eq_second_sub_one]
  rw [← he,ENNReal.ofReal_tsum_of_nonneg hn hs]
  apply tsum_congr
  intro r
  rw [p.law_apply,ENNReal.ofReal_mul (by
    have hr : r=0 ∨ 1 ≤ r := by omega
    rcases hr with hr | hr
    · simp [hr]
    · have hr' : (1:ℝ) ≤ r := by exact_mod_cast hr
      nlinarith)]


def streamShift (n : ℕ) (x : ℕ → ℕ) : ℕ → ℕ := fun k => x (n+k)


lemma measurable_streamShift (n : ℕ) : Measurable (streamShift n) := by
  apply Measurable.of_eval
  intro k
  exact measurable_pi_apply _


lemma CriticalEvenOffspring.streamShift_preserving (p : CriticalEvenOffspring) (n : ℕ) :
    MeasurePreserving (streamShift n) p.streamLaw p.streamLaw := by
  have hi : iIndepFun (fun k (x : ℕ → ℕ) => x k) p.streamLaw :=
    iIndepFun_infinitePi (X := fun _ (k : ℕ) => k) (fun _ => measurable_id)
  have hinj : Function.Injective (fun k : ℕ => n+k) := by intro a b h; dsimp at h; omega
  have h := (hi.precomp hinj).map_fun_eq_infinitePi_map (fun k => measurable_pi_apply (n+k))
  refine ⟨measurable_streamShift n,?_⟩
  change p.streamLaw.map (fun ω i => ω (n+i))=p.streamLaw
  rw [h]
  unfold CriticalEvenOffspring.streamLaw
  congr 1
  funext k
  exact (measurePreserving_eval_infinitePi (fun _ : ℕ => p.law.toMeasure) (n+k)).map_eq


lemma CriticalEvenOffspring.truncate_indep_shift (p : CriticalEvenOffspring) (n : ℕ) :
    IndepFun (truncateStream n) (streamShift n) p.streamLaw := by
  classical
  apply IndepFun.indepFun_process (measurable_truncateStream n) (fun k => measurable_pi_apply (n+k))
  intro I
  have hi : iIndepFun (fun k (x : ℕ → ℕ) => x k) p.streamLaw :=
    iIndepFun_infinitePi (X := fun _ (k : ℕ) => k) (fun _ => measurable_id)
  have hd : Disjoint (Finset.range n) (I.image (fun k => n+k)) := by
    apply Finset.disjoint_left.mpr
    intro k hk hi
    obtain ⟨j,_,rfl⟩ := Finset.mem_image.mp hi
    have := Finset.mem_range.mp hk
    omega
  have h := hi.indepFun_finset (Finset.range n) (I.image (fun k => n+k)) hd
    (fun k => measurable_pi_apply k)
  let f : ((Finset.range n) → ℕ) → (ℕ → ℕ) :=
    fun x k => if hk : k<n then x ⟨k,Finset.mem_range.mpr hk⟩ else 0
  let g : (I.image (fun k => n+k) → ℕ) → (I → ℕ) :=
    fun x k => x ⟨n+k,Finset.mem_image.mpr ⟨k,k.property,rfl⟩⟩
  have hf : Measurable f := by
    apply Measurable.of_eval
    intro k
    dsimp [f]
    split_ifs <;> fun_prop
  have hg : Measurable g := by fun_prop
  exact h.comp hf hg


lemma CriticalEvenOffspring.prefix_inter_shift (p : CriticalEvenOffspring)
    (n : ℕ) (E F : Set (ℕ → ℕ)) (hE : MeasurableSet E) (hF : MeasurableSet F)
    (htr : (truncateStream n) ⁻¹' E=E) :
    p.streamLaw (E ∩ (streamShift n) ⁻¹' F)=p.streamLaw E*p.streamLaw F := by
  have h := (p.truncate_indep_shift n).measure_inter_preimage_eq_mul E F hE hF
  rw [htr,(p.streamShift_preserving n).measure_preimage hF.nullMeasurableSet] at h
  exact h


lemma weakLadderHit_truncate (n k : ℕ) :
    (truncateStream (n+1)) ⁻¹' {x | weakLadderHit x n k}={x | weakLadderHit x n k} := by
  ext x
  change weakLadderHit (truncateStream (n+1) x) n k ↔ weakLadderHit x n k
  simp only [weakLadderHit,negativeSurvival,integerSum_truncateStream x le_rfl]
  constructor <;> rintro ⟨hs,he⟩ <;> refine ⟨?_,he⟩
  · intro j hj hjn
    simpa only [integerSum_truncateStream x (by omega : j ≤ n+1)] using hs j hj hjn
  · intro j hj hjn
    simpa only [integerSum_truncateStream x (by omega : j ≤ n+1)] using hs j hj hjn


lemma weakLadderHit_unique {x : ℕ → ℕ} {n k m l : ℕ}
    (hn : weakLadderHit x n k) (hm : weakLadderHit x m l) : n=m ∧ k=l := by
  have he : n=m := by
    by_contra hne
    rcases lt_or_gt_of_ne hne with h | h
    · have hh := hm.1 (n+1) (by omega) (by omega)
      rw [hn.2] at hh
      omega
    · have hh := hn.1 (m+1) (by omega) (by omega)
      rw [hm.2] at hh
      omega
  refine ⟨he,?_⟩
  subst m
  have := hn.2
  have := hm.2
  omega


lemma weakLadderHit_pairwise : Pairwise (fun a b : ℕ × ℕ =>
    Disjoint {x | weakLadderHit x a.1 a.2} {x | weakLadderHit x b.1 b.2}) := by
  intro a b hab
  apply Set.disjoint_left.mpr
  intro x ha hb
  have h := weakLadderHit_unique ha hb
  exact hab (Prod.ext h.1 h.2)


lemma CriticalEvenOffspring.ae_weakLadderHit (p : CriticalEvenOffspring) :
    ∀ᵐ x ∂p.streamLaw, ∃ n k, weakLadderHit x n k := by
  have he : {x | ∃ n k, weakLadderHit x n k}=⋃ a : ℕ×ℕ,{x | weakLadderHit x a.1 a.2} := by
    ext x
    simp
  apply (mem_ae_iff_prob_eq_one (show MeasurableSet {x | ∃ n k, weakLadderHit x n k} from by
    rw [he]; exact MeasurableSet.iUnion fun a => measurableSet_weakLadderHit a.1 a.2)).mpr
  rw [he,measure_iUnion weakLadderHit_pairwise (fun a => measurableSet_weakLadderHit a.1 a.2),
    ENNReal.tsum_prod',ENNReal.tsum_comm]
  simp_rw [p.weakLadder_overshoot_mass]
  exact p.ladder_total


lemma measurableSet_hasWeakLadder : MeasurableSet {x : ℕ → ℕ | ∃ n, 0 ≤ integerSum x (n+1)} := by
  simp only [Set.ofPred_exists]
  exact MeasurableSet.iUnion fun n => measurableSet_le measurable_const (measurable_integerSum (n+1))


def ladderPredicate (x : ℕ → ℕ) (n : ℕ) : Prop :=
  0 ≤ integerSum x (n+1) ∨ (¬ ∃ m, 0 ≤ integerSum x (m+1)) ∧ n=0


lemma ladderPredicate_exists (x : ℕ → ℕ) : ∃ n, ladderPredicate x n := by
  by_cases h : ∃ n, 0 ≤ integerSum x (n+1)
  · obtain ⟨n,hn⟩ := h
    exact ⟨n,Or.inl hn⟩
  · exact ⟨0,Or.inr ⟨h,rfl⟩⟩


def ladderIndex (x : ℕ → ℕ) : ℕ := by
  classical
  exact Nat.find (ladderPredicate_exists x)


lemma measurable_ladderIndex : Measurable ladderIndex := by
  classical
  apply measurable_find (fun x => ladderPredicate_exists x)
  intro n
  unfold ladderPredicate
  simp only [Set.ofPred_or,Set.ofPred_and,← Set.compl_ofPred]
  exact (measurableSet_le measurable_const (measurable_integerSum (n+1))).union
    (measurableSet_hasWeakLadder.compl.inter (MeasurableSet.const _))


lemma ladderIndex_eq_of_hit {x : ℕ → ℕ} {n k : ℕ} (h : weakLadderHit x n k) :
    ladderIndex x=n := by
  classical
  apply (Nat.find_eq_iff (ladderPredicate_exists x)).mpr
  refine ⟨Or.inl (by rw [h.2]; positivity),?_⟩
  intro j hj
  rintro (hj' | hj')
  · have hh := h.1 (j+1) (by omega) (by omega)
    omega
  · exact hj'.1 ⟨n,by rw [h.2]; positivity⟩


def ladderOvershoot (x : ℕ → ℕ) : ℕ := (integerSum x (ladderIndex x+1)).toNat


def ladderTail (x : ℕ → ℕ) : ℕ → ℕ := streamShift (ladderIndex x+1) x


lemma measurable_ladderOvershoot : Measurable ladderOvershoot := by
  have hs : Measurable (fun x : ℕ → ℕ => (x,ladderIndex x+1)) :=
    measurable_id.prodMk (measurable_ladderIndex.add_const 1)
  have he : Measurable (fun z : (ℕ → ℕ)×ℕ => integerSum z.1 z.2) := by
    apply measurable_from_prod_countable_left
    intro n
    exact measurable_integerSum n
  exact (measurable_of_countable (f := Int.toNat)).comp (he.comp hs)


lemma measurable_ladderTail : Measurable ladderTail := by
  apply Measurable.of_eval
  intro k
  have hs : Measurable (fun x : ℕ → ℕ => (x,ladderIndex x+1+k)) :=
    measurable_id.prodMk ((measurable_ladderIndex.add_const 1).add_const k)
  have he : Measurable (fun z : (ℕ → ℕ)×ℕ => z.1 z.2) := by
    apply measurable_from_prod_countable_left
    intro n
    exact measurable_pi_apply n
  exact he.comp hs


lemma ladderOvershoot_of_hit {x : ℕ → ℕ} {n k : ℕ} (h : weakLadderHit x n k) :
    ladderOvershoot x=k := by
  rw [ladderOvershoot,ladderIndex_eq_of_hit h,h.2,Int.toNat_natCast]


lemma ladderTail_of_hit {x : ℕ → ℕ} {n k : ℕ} (h : weakLadderHit x n k) :
    ladderTail x=streamShift (n+1) x := by
  rw [ladderTail,ladderIndex_eq_of_hit h]


lemma CriticalEvenOffspring.ladder_slice_mass (p : CriticalEvenOffspring)
    (k : ℕ) (F : Set (ℕ → ℕ)) (hF : MeasurableSet F) :
    p.streamLaw ({x | ladderOvershoot x=k} ∩ ladderTail ⁻¹' F)=
      p.ladderLaw k*p.streamLaw F := by
  have he : ({x | ladderOvershoot x=k} ∩ ladderTail ⁻¹' F : Set (ℕ → ℕ)) =ᵐ[p.streamLaw]
      ⋃ n : ℕ, {x | weakLadderHit x n k} ∩ (streamShift (n+1)) ⁻¹' F := by
    filter_upwards [p.ae_weakLadderHit] with x hx
    apply propext
    obtain ⟨n,l,hh⟩ := hx
    constructor
    · intro hm
      have hl : l=k := (ladderOvershoot_of_hit hh).symm.trans hm.1
      subst l
      exact Set.mem_iUnion.mpr ⟨n,hh,by simpa only [Set.mem_preimage,← ladderTail_of_hit hh] using hm.2⟩
    · intro hm
      obtain ⟨m,hm,hxF⟩ := Set.mem_iUnion.mp hm
      exact ⟨ladderOvershoot_of_hit hm,by simpa only [Set.mem_preimage,ladderTail_of_hit hm] using hxF⟩
  rw [measure_congr he,measure_iUnion]
  · simp_rw [p.prefix_inter_shift (n := _)
      (hE := measurableSet_weakLadderHit _ _) (hF := hF) (htr := weakLadderHit_truncate _ _)]
    rw [ENNReal.tsum_mul_right,p.weakLadder_overshoot_mass]
    rfl
  · intro n m hnm
    apply Set.disjoint_left.mpr
    intro x hn hm
    exact hnm (weakLadderHit_unique hn.1 hm.1).1
  · intro n
    exact (measurableSet_weakLadderHit n k).inter ((measurable_streamShift (n+1)) hF)


lemma countable_slice_rectangle {Ω β : Type*} [MeasurableSpace Ω] [MeasurableSpace β]
    (μ : Measure Ω) (ν : Measure β) (q : PMF ℕ) (Y : Ω → ℕ) (T : Ω → β)
    (hY : Measurable Y) (hT : Measurable T)
    (h : ∀ k E, MeasurableSet E → μ ({x | Y x=k} ∩ T ⁻¹' E)=q k*ν E)
    (A : Set ℕ) (E : Set β) (hA : MeasurableSet A) (hE : MeasurableSet E) :
    μ (Y ⁻¹' A ∩ T ⁻¹' E)=q.toMeasure A*ν E := by
  classical
  have he : Y ⁻¹' A ∩ T ⁻¹' E=⋃ k ∈ A, {x | Y x=k} ∩ T ⁻¹' E := by
    ext x
    simp only [Set.mem_inter_iff,Set.mem_preimage,Set.mem_iUnion,Set.mem_ofPred_eq]
    constructor
    · intro hx
      exact ⟨Y x,hx.1,rfl,hx.2⟩
    · rintro ⟨k,hk,he,hx⟩
      exact ⟨he.symm ▸ hk,hx⟩
  rw [he,measure_biUnion (Set.to_countable A)]
  · simp_rw [h _ E hE]
    rw [ENNReal.tsum_mul_right]
    congr 1
    rw [tsum_subtype,PMF.toMeasure_apply _ hA]
  · intro k _ l _ hkl
    apply Set.disjoint_left.mpr
    intro x hk hl
    exact hkl (hk.1.symm.trans hl.1)
  · intro k _
    exact (measurableSet_eq_fun hY measurable_const).inter (hT hE)


lemma CriticalEvenOffspring.ladder_rectangle (p : CriticalEvenOffspring)
    (A : Set ℕ) (F : Set (ℕ → ℕ)) (hF : MeasurableSet F) :
    p.streamLaw (ladderOvershoot ⁻¹' A ∩ ladderTail ⁻¹' F)=
      p.ladderLaw.toMeasure A*p.streamLaw F :=
  countable_slice_rectangle p.streamLaw p.streamLaw p.ladderLaw ladderOvershoot ladderTail
    measurable_ladderOvershoot measurable_ladderTail p.ladder_slice_mass A F ((Set.to_countable A).measurableSet) hF


lemma CriticalEvenOffspring.ladder_hasLaw (p : CriticalEvenOffspring) :
    HasLaw ladderOvershoot p.ladderLaw.toMeasure p.streamLaw := by
  refine ⟨measurable_ladderOvershoot.aemeasurable,?_⟩
  apply Measure.ext
  intro A hA
  rw [Measure.map_apply measurable_ladderOvershoot hA]
  simpa using p.ladder_rectangle A Set.univ MeasurableSet.univ


lemma CriticalEvenOffspring.ladderTail_preserving (p : CriticalEvenOffspring) :
    MeasurePreserving ladderTail p.streamLaw p.streamLaw := by
  refine ⟨measurable_ladderTail,?_⟩
  apply Measure.ext
  intro F hF
  rw [Measure.map_apply measurable_ladderTail hF]
  simpa using p.ladder_rectangle Set.univ F hF


lemma CriticalEvenOffspring.ladder_indep_tail (p : CriticalEvenOffspring) :
    IndepFun ladderOvershoot ladderTail p.streamLaw := by
  apply indepFun_iff_measure_inter_preimage_eq_mul.mpr
  intro A F hA hF
  rw [(p.ladderTail_preserving).measure_preimage hF.nullMeasurableSet]
  have h := (p.ladder_hasLaw.measurePreserving measurable_ladderOvershoot).measure_preimage hA.nullMeasurableSet
  rw [h]
  exact p.ladder_rectangle A F hF


lemma CriticalEvenOffspring.ladder_integrable (p : CriticalEvenOffspring) :
    Integrable (fun k : ℕ => (k:ℝ)) p.ladderLaw.toMeasure := by
  rw [← Measure.sum_smul_dirac p.ladderLaw.toMeasure,integrable_sum_dirac_iff]
  · have hs : Summable (fun k : ℕ => ((k:ℝ≥0∞)*p.ladderLaw k).toReal) :=
      ENNReal.summable_toReal (by rw [p.ladder_first_moment]; exact ENNReal.ofReal_ne_top)
    simpa [PMF.toMeasure_apply_singleton,ENNReal.toReal_mul,mul_comm] using hs
  · intro k
    exact measure_ne_top _ _


lemma CriticalEvenOffspring.ladder_integral (p : CriticalEvenOffspring) :
    ∫ k : ℕ,(k:ℝ) ∂p.ladderLaw.toMeasure=p.variance/2 := by
  rw [integral_countable p.ladder_integrable]
  have h := congrArg ENNReal.toReal p.ladder_first_moment
  rw [ENNReal.toReal_ofReal (div_nonneg p.variance_pos.le (by norm_num)),
    ENNReal.tsum_toReal_eq (fun k => ENNReal.mul_ne_top (by simp) (PMF.apply_ne_top _ _))] at h
  simpa [measureReal_def,PMF.toMeasure_apply_singleton,ENNReal.toReal_mul,mul_comm] using h


lemma regenerative_cylinder {Ω β : Type*} [MeasurableSpace Ω] [MeasurableSpace β]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (Y : Ω → β) (T : Ω → Ω)
    (hY : Measurable Y) (hT : MeasurePreserving T μ μ) (h : IndepFun Y T μ)
    (A : ℕ → Set β) (hA : ∀ i, MeasurableSet (A i)) (n : ℕ) :
    μ {x | ∀ i < n, Y (T^[i] x) ∈ A i} =
      ∏ i ∈ Finset.range n, μ (Y ⁻¹' A i) := by
  induction n generalizing A with
  | zero => simp
  | succ n ih =>
    let E : Set Ω := {x | ∀ i < n, Y (T^[i] x) ∈ A (i+1)}
    have hE : MeasurableSet E := by
      dsimp [E]
      simp only [Set.ofPred_forall]
      exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun (_ : i < n) =>
        (hY.comp (hT.measurable.iterate i)) (hA (i+1))
    have he : {x | ∀ i < n+1, Y (T^[i] x) ∈ A i}=Y ⁻¹' A 0 ∩ T ⁻¹' E := by
      ext x
      simp only [Set.mem_ofPred_eq,Set.mem_inter_iff,Set.mem_preimage,E]
      constructor
      · intro hx
        refine ⟨by simpa using hx 0 (by omega),?_⟩
        intro i hi
        simpa only [Function.iterate_succ_apply] using hx (i+1) (by omega)
      · rintro ⟨h₀,hs⟩ i hi
        cases i with
        | zero => simpa using h₀
        | succ i => simpa only [Function.iterate_succ_apply] using hs i (by omega)
    rw [he,h.measure_inter_preimage_eq_mul _ _ (hA 0) hE,
      hT.measure_preimage hE.nullMeasurableSet,ih (fun i => A (i+1)) (fun i => hA (i+1)),
      Finset.prod_range_succ']
    exact mul_comm _ _


lemma regenerative_iIndepFun {Ω β : Type*} [MeasurableSpace Ω] [MeasurableSpace β]
    (μ : Measure Ω) [IsProbabilityMeasure μ] (Y : Ω → β) (T : Ω → Ω)
    (hY : Measurable Y) (hT : MeasurePreserving T μ μ) (h : IndepFun Y T μ) :
    iIndepFun (fun i x => Y (T^[i] x)) μ := by
  classical
  apply iIndepFun_iff_measure_inter_preimage_eq_mul.mpr
  intro S A hA
  let n := S.sup id+1
  have hsub : S ⊆ Finset.range n := by
    intro i hi
    exact Finset.mem_range.mpr (Nat.lt_succ_of_le (Finset.le_sup (f := id) hi))
  let B : ℕ → Set β := fun i => if i ∈ S then A i else Set.univ
  have hB : ∀ i, MeasurableSet (B i) := by
    intro i
    dsimp [B]
    split_ifs with hi
    · exact hA i hi
    · exact MeasurableSet.univ
  have he : (⋂ i ∈ S, (fun x => Y (T^[i] x)) ⁻¹' A i) =
      {x | ∀ i < n, Y (T^[i] x) ∈ B i} := by
    ext x
    simp only [Set.mem_iInter,Set.mem_preimage,Set.mem_ofPred_eq]
    constructor
    · intro hx i _
      dsimp [B]
      split_ifs with hi
      · exact hx i hi
      · trivial
    · intro hx i hi
      simpa [B,hi] using hx i (Finset.mem_range.mp (hsub hi))
  rw [he,regenerative_cylinder μ Y T hY hT h B hB]
  calc
    ∏ i ∈ Finset.range n, μ (Y ⁻¹' B i) = ∏ i ∈ S, μ (Y ⁻¹' B i) := by
      symm
      apply Finset.prod_subset hsub
      intro i _ hi
      simp [B,hi]
    _ = ∏ i ∈ S, μ ((fun x => Y (T^[i] x)) ⁻¹' A i) := by
      apply Finset.prod_congr rfl
      intro i hi
      rw [show B i=A i by simp [B,hi]]
      symm
      exact (hT.iterate i).measure_preimage (hY (hA i hi)).nullMeasurableSet


def renewalIncrement (i : ℕ) (x : ℕ → ℕ) : ℕ :=
  ladderOvershoot (ladderTail^[i] x)


lemma measurable_renewalIncrement (i : ℕ) : Measurable (renewalIncrement i) :=
  measurable_ladderOvershoot.comp (measurable_ladderTail.iterate i)


lemma CriticalEvenOffspring.renewal_iid (p : CriticalEvenOffspring) :
    iIndepFun renewalIncrement p.streamLaw :=
  regenerative_iIndepFun p.streamLaw ladderOvershoot ladderTail
    measurable_ladderOvershoot p.ladderTail_preserving p.ladder_indep_tail


lemma CriticalEvenOffspring.renewal_hasLaw (p : CriticalEvenOffspring) (i : ℕ) :
    HasLaw (renewalIncrement i) p.ladderLaw.toMeasure p.streamLaw :=
  p.ladder_hasLaw.comp (p.ladderTail_preserving.iterate i).hasLaw


lemma CriticalEvenOffspring.renewal_strong_law (p : CriticalEvenOffspring) :
    ∀ᵐ x ∂p.streamLaw,
      Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n,(renewalIncrement i x : ℝ))/(n:ℝ))
        atTop (𝓝 (p.variance/2)) := by
  let X : ℕ → (ℕ → ℕ) → ℝ := fun i x => (renewalIncrement i x : ℝ)
  have hind : iIndepFun X p.streamLaw := p.renewal_iid.comp (fun _ => Nat.cast)
    (fun _ => measurable_of_countable _)
  have hint : Integrable (X 0) p.streamLaw :=
    ((p.renewal_hasLaw 0).measurePreserving (measurable_renewalIncrement 0)).integrable_comp_of_integrable
      p.ladder_integrable
  have hid : ∀ i, IdentDistrib (X i) (X 0) p.streamLaw p.streamLaw := by
    intro i
    exact ((p.renewal_hasLaw i).identDistrib (p.renewal_hasLaw 0)).comp (measurable_of_countable _)
  have hm : ∫ x, X 0 x ∂p.streamLaw=p.variance/2 := by
    exact ((p.renewal_hasLaw 0).integral_comp
      (measurable_of_countable (fun k : ℕ => (k:ℝ))).aestronglyMeasurable).trans p.ladder_integral
  simpa only [hm] using strong_law_ae_real X hint (fun _ _ hij => hind.indepFun hij) hid


def renewalCount (τ : ℕ → ℕ) (n : ℕ) : ℕ := Nat.findGreatest (fun r => τ r ≤ n) n


lemma renewalCount_spec {τ : ℕ → ℕ} (h₀ : τ 0=0) (n : ℕ) :
    τ (renewalCount τ n) ≤ n :=
  Nat.findGreatest_spec (P := fun r => τ r ≤ n) (Nat.zero_le n) (by simp [h₀])


lemma le_renewalCount_iff {τ : ℕ → ℕ} (hτ : StrictMono τ) (h₀ : τ 0=0)
    (r n : ℕ) : r ≤ renewalCount τ n ↔ τ r ≤ n := by
  constructor
  · intro h
    exact (hτ.monotone h).trans (renewalCount_spec h₀ n)
  · intro h
    exact Nat.le_findGreatest ((hτ.le_apply (x := r)).trans h) h


lemma renewalCount_succ_gt {τ : ℕ → ℕ} (hτ : StrictMono τ) (h₀ : τ 0=0)
    (n : ℕ) : n < τ (renewalCount τ n+1) := by
  rw [← not_le,← le_renewalCount_iff hτ h₀]
  omega


lemma renewalCount_mono {τ : ℕ → ℕ} (hτ : StrictMono τ) (h₀ : τ 0=0) :
    Monotone (renewalCount τ) := by
  intro m n hmn
  rw [le_renewalCount_iff hτ h₀]
  exact (renewalCount_spec h₀ m).trans hmn


lemma renewalCount_at {τ : ℕ → ℕ} (hτ : StrictMono τ) (h₀ : τ 0=0) (r : ℕ) :
    renewalCount τ (τ r)=r := by
  apply le_antisymm
  · exact hτ.le_iff_le.mp (renewalCount_spec h₀ (τ r))
  · exact (le_renewalCount_iff hτ h₀ r (τ r)).mpr le_rfl


lemma renewalCount_tendsto {τ : ℕ → ℕ} (hτ : StrictMono τ) (h₀ : τ 0=0) :
    Tendsto (renewalCount τ) atTop atTop := by
  apply tendsto_atTop.mpr
  intro r
  filter_upwards [Filter.eventually_ge_atTop (τ r)] with n hn
  exact (le_renewalCount_iff hτ h₀ r n).mpr hn


structure LadderEnumeration {α : Type*} [LinearOrder α] (S : ℕ → α) (τ : ℕ → ℕ) : Prop where
  zero : τ 0=0
  strictMono : StrictMono τ
  level_mono : Monotone (S ∘ τ)
  between : ∀ r k, τ r < k → k < τ (r+1) → S k < S (τ r)


lemma LadderEnumeration.le_level {α : Type*} [LinearOrder α] {S : ℕ → α} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) (k : ℕ) : S k ≤ S (τ (renewalCount τ k)) := by
  have hk := renewalCount_spec h.zero k
  by_cases he : τ (renewalCount τ k)=k
  · rw [he]
  · exact (h.between _ k (lt_of_le_of_ne hk he) (renewalCount_succ_gt h.strictMono h.zero k)).le


lemma LadderEnumeration.maximum {α : Type*} [LinearOrder α] {S : ℕ → α} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) {k n : ℕ} (hkn : k ≤ n) :
    S k ≤ S (τ (renewalCount τ n)) :=
  (h.le_level k).trans (h.level_mono (renewalCount_mono h.strictMono h.zero hkn))


lemma LadderEnumeration.record_at {α : Type*} [LinearOrder α] {S : ℕ → α} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) (r : ℕ) {k : ℕ} (hk : k ≤ τ r) :
    S k ≤ S (τ r) := by
  simpa only [renewalCount_at h.strictMono h.zero] using h.maximum hk


def weakRecords {α : Type*} [LinearOrder α] (S : ℕ → α) (n : ℕ) : Finset ℕ :=
  (Finset.Icc 1 n).filter fun k => ∀ j ≤ k, S j ≤ S k


@[simp] lemma mem_weakRecords {α : Type*} [LinearOrder α] (S : ℕ → α) (n k : ℕ) :
    k ∈ weakRecords S n ↔ 1 ≤ k ∧ k ≤ n ∧ ∀ j ≤ k, S j ≤ S k := by
  simp only [weakRecords,Finset.mem_filter,Finset.mem_Icc,and_assoc]


lemma LadderEnumeration.records {α : Type*} [LinearOrder α] {S : ℕ → α} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) (n : ℕ) :
    weakRecords S n=(Finset.Icc 1 (renewalCount τ n)).image τ := by
  classical
  ext k
  rw [mem_weakRecords,Finset.mem_image]
  constructor
  · rintro ⟨hk1,hkn,hrec⟩
    let r := renewalCount τ k
    have hr : τ r=k := by
      by_contra he
      have hlt := lt_of_le_of_ne (renewalCount_spec h.zero k) he
      exact not_lt_of_ge (hrec (τ r) (renewalCount_spec h.zero k))
        (h.between r k hlt (renewalCount_succ_gt h.strictMono h.zero k))
    refine ⟨r,Finset.mem_Icc.mpr ⟨?_,?_⟩,hr⟩
    · by_contra hn
      have : r=0 := by omega
      rw [this,h.zero] at hr
      omega
    · exact (le_renewalCount_iff h.strictMono h.zero r n).mpr (hr ▸ hkn)
  · rintro ⟨r,hr,rfl⟩
    obtain ⟨hr1,hrn⟩ := Finset.mem_Icc.mp hr
    refine ⟨?_,(le_renewalCount_iff h.strictMono h.zero r n).mp hrn,fun j hj => h.record_at r hj⟩
    exact hr1.trans h.strictMono.le_apply


lemma LadderEnumeration.card_records {α : Type*} [LinearOrder α] {S : ℕ → α} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) (n : ℕ) :
    (weakRecords S n).card=renewalCount τ n := by
  classical
  rw [h.records,Finset.card_image_of_injective _ h.strictMono.injective,Nat.card_Icc]
  omega


lemma LadderEnumeration.first_records_below {α : Type*} [LinearOrder α]
    {S : ℕ → α} {τ : ℕ → ℕ} (h : LadderEnumeration S τ) (n m : ℕ)
    (z : α) (hz : z ≤ S (τ m)) :
    ((weakRecords S n).filter fun k => S k < z).card ≤ m := by
  classical
  have hsub : (weakRecords S n).filter (fun k => S k < z) ⊆
      (Finset.range m).image τ := by
    intro k hk
    obtain ⟨hkr,hkz⟩ := Finset.mem_filter.mp hk
    rw [h.records] at hkr
    obtain ⟨r,_,rfl⟩ := Finset.mem_image.mp hkr
    refine Finset.mem_image.mpr ⟨r,Finset.mem_range.mpr ?_,rfl⟩
    by_contra hn
    exact not_lt_of_ge (hz.trans (h.level_mono (by omega : m ≤ r))) hkz
  exact (Finset.card_le_card hsub).trans ((Finset.card_image_le).trans_eq (Finset.card_range m))


def ladderTime (x : ℕ → ℕ) : ℕ → ℕ
  | 0 => 0
  | r+1 => ladderTime x r+(ladderIndex (ladderTail^[r] x)+1)


@[simp] lemma ladderTime_zero (x : ℕ → ℕ) : ladderTime x 0=0 := rfl


lemma ladderTime_strictMono (x : ℕ → ℕ) : StrictMono (ladderTime x) := by
  apply strictMono_nat_of_lt_succ
  intro r
  dsimp [ladderTime]
  omega


lemma streamShift_add (a b : ℕ) (x : ℕ → ℕ) :
    streamShift a (streamShift b x)=streamShift (b+a) x := by
  funext k
  change x (b+(a+k))=x ((b+a)+k)
  rw [Nat.add_assoc]


lemma ladderTail_iterate (x : ℕ → ℕ) (r : ℕ) :
    ladderTail^[r] x=streamShift (ladderTime x r) x := by
  induction r with
  | zero =>
    change x=(fun k => x (0+k))
    funext k
    rw [Nat.zero_add]
  | succ r ih =>
    rw [Function.iterate_succ_apply',ladderTail,ih,streamShift_add,ladderTime,ih]


lemma integerSum_shift (x : ℕ → ℕ) (a k : ℕ) :
    integerSum (streamShift a x) k=integerSum x (a+k)-integerSum x a := by
  unfold integerSum streamShift
  rw [Finset.sum_range_add]
  ring


def HasAllLadders (x : ℕ → ℕ) : Prop :=
  ∀ r, ∃ n k, weakLadderHit (ladderTail^[r] x) n k


lemma CriticalEvenOffspring.ae_all_ladders (p : CriticalEvenOffspring) :
    ∀ᵐ x ∂p.streamLaw, HasAllLadders x := by
  rw [show HasAllLadders=(fun x => ∀ r, ∃ n k, weakLadderHit (ladderTail^[r] x) n k) from rfl,
    ae_all_iff]
  intro r
  exact (p.ladderTail_preserving.iterate r).quasiMeasurePreserving.ae p.ae_weakLadderHit


lemma ladderTime_step_level {x : ℕ → ℕ} (hx : HasAllLadders x) (r : ℕ) :
    integerSum x (ladderTime x (r+1))-integerSum x (ladderTime x r)=
      (renewalIncrement r x:ℤ) := by
  obtain ⟨n,k,h⟩ := hx r
  have hidx := ladderIndex_eq_of_hit h
  have hval := ladderOvershoot_of_hit h
  change _=(ladderOvershoot (ladderTail^[r] x):ℤ)
  rw [hval,ladderTime,hidx,← integerSum_shift,← ladderTail_iterate]
  exact h.2


lemma ladderTime_between {x : ℕ → ℕ} (hx : HasAllLadders x) (r k : ℕ)
    (hlo : ladderTime x r<k) (hhi : k<ladderTime x (r+1)) :
    integerSum x k < integerSum x (ladderTime x r) := by
  obtain ⟨n,j,h⟩ := hx r
  have hidx := ladderIndex_eq_of_hit h
  have hhi' : k<ladderTime x r+(n+1) := by simpa only [ladderTime,hidx] using hhi
  have hs := h.1 (k-ladderTime x r) (by omega) (by omega)
  rw [ladderTail_iterate,integerSum_shift,Nat.add_sub_of_le hlo.le] at hs
  omega


lemma ladderTime_enumeration {x : ℕ → ℕ} (hx : HasAllLadders x) :
    LadderEnumeration (integerSum x) (ladderTime x) := by
  refine ⟨rfl,ladderTime_strictMono x,?_,ladderTime_between hx⟩
  apply monotone_nat_of_le_succ
  intro r
  have := ladderTime_step_level hx r
  dsimp only [Function.comp_apply]
  omega


lemma ladderTime_level_sum {x : ℕ → ℕ} (hx : HasAllLadders x) (r : ℕ) :
    integerSum x (ladderTime x r)=∑ i ∈ Finset.range r,(renewalIncrement i x:ℤ) := by
  induction r with
  | zero => simp [integerSum]
  | succ r ih =>
    rw [Finset.sum_range_succ,← ih]
    have := ladderTime_step_level hx r
    omega


lemma linear_remainder_of_ratio {L : ℕ → ℝ} {ν ε : ℝ} (hν : 0<ν) (hε : 0<ε)
    (hL : ∀ r, 0 ≤ L r) (ht : Tendsto (fun r : ℕ => L r/(r:ℝ)) atTop (𝓝 ν)) :
    ∃ A : ℕ, ∀ r, |L r-ν*r| ≤ ε*L r+A := by
  let δ := min (ε*ν/2) (ν/2)
  have hδ : 0<δ := lt_min (by positivity) (by positivity)
  obtain ⟨N,hN⟩ := eventually_atTop.mp ((Metric.tendsto_nhds.mp ht) δ hδ)
  have hlarge (r : ℕ) (hr : N+1 ≤ r) : |L r-ν*r| ≤ ε*L r := by
    have hr0 : (0:ℝ)<r := by exact_mod_cast (show 0<r by omega)
    have h := hN r (by omega)
    rw [Real.dist_eq,abs_sub_lt_iff] at h
    have hlo : ν/2*(r:ℝ) ≤ L r := by
      have hδν : δ ≤ ν/2 := min_le_right _ _
      have hh : ν/2 ≤ L r/(r:ℝ) := by linarith
      exact (le_div_iff₀ hr0).mp hh
    have he : |L r-ν*r| ≤ δ*r := by
      have hh : |L r/(r:ℝ)-ν| ≤ δ := abs_le.mpr ⟨by linarith,by linarith⟩
      have heq : L r/(r:ℝ)-ν=(L r-ν*r)/(r:ℝ) := by field_simp
      rw [heq,abs_div,abs_of_pos hr0] at hh
      exact (div_le_iff₀ hr0).mp hh
    exact he.trans (by have hh := min_le_left (ε*ν/2) (ν/2); nlinarith)
  obtain ⟨A,hA⟩ := exists_nat_ge (∑ r ∈ Finset.range (N+1),|L r-ν*r|)
  refine ⟨A,fun r => ?_⟩
  by_cases hr : N+1 ≤ r
  · exact (hlarge r hr).trans (le_add_of_nonneg_right (Nat.cast_nonneg A))
  · have hh : |L r-ν*r| ≤ ∑ k ∈ Finset.range (N+1),|L k-ν*k| :=
      Finset.single_le_sum (f := fun k => |L k-ν*k|) (fun _ _ => abs_nonneg _) (Finset.mem_range.mpr (show r<N+1 by omega))
    exact (hh.trans hA).trans (le_add_of_nonneg_left (mul_nonneg hε.le (hL r)))


lemma uniform_remainder_probability {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) [IsFiniteMeasure μ] (L : ℕ → Ω → ℝ) (hL : ∀ r, Measurable (L r))
    (ν ε : ℝ) (hae : ∀ᵐ x ∂μ, ∃ A : ℕ, ∀ r, |L r x-ν*r| ≤ ε*L r x+A) :
    Tendsto (fun A : ℕ => μ {x | ∃ r, ε*L r x+A < |L r x-ν*r|}) atTop (𝓝 0) := by
  let E : ℕ → Set Ω := fun A => {x | ∃ r, ε*L r x+A < |L r x-ν*r|}
  have hm (A : ℕ) : MeasurableSet (E A) := by
    dsimp [E]
    simp only [ofPred_exists]
    exact MeasurableSet.iUnion fun r => measurableSet_lt
      ((hL r).const_mul ε |>.add_const A) (((hL r).sub_const (ν*r)).abs)
  have hanti : Antitone E := by
    intro A B hAB x hx
    obtain ⟨r,hr⟩ := hx
    exact ⟨r,lt_of_le_of_lt (add_le_add le_rfl (Nat.cast_le.mpr hAB)) hr⟩
  have hz : μ (⋂ A, E A)=0 := by
    apply measure_eq_zero_iff_ae_notMem.mpr
    filter_upwards [hae] with x hx
    obtain ⟨A,hA⟩ := hx
    intro hmem
    obtain ⟨r,hr⟩ := Set.mem_iInter.mp hmem A
    exact not_lt_of_ge (hA r) hr
  simpa only [hz,Function.comp_def,E] using tendsto_measure_iInter_atTop (μ := μ) (fun A => (hm A).nullMeasurableSet)
    hanti ⟨0,measure_ne_top _ _⟩


lemma integrable_neg_exp_nat {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
    [IsProbabilityMeasure μ] (Y : Ω → ℕ) (hY : Measurable Y) :
    Integrable (fun x => Real.exp (-(Y x:ℝ))) μ := by
  apply Integrable.of_bound ((measurable_of_countable (fun k : ℕ => Real.exp (-(k:ℝ)))).comp hY).aestronglyMeasurable 1
  filter_upwards with x
  dsimp only [Function.comp_apply]
  rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
  exact Real.exp_le_one_iff.mpr (neg_nonpos.mpr (Nat.cast_nonneg _))


lemma nat_laplace_lt_one {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
    [IsProbabilityMeasure μ] (Y : Ω → ℕ) (hY : Measurable Y)
    (hint : Integrable (fun x => (Y x:ℝ)) μ) (hmean : 0 < ∫ x,(Y x:ℝ) ∂μ) :
    0 < (∫ x,Real.exp (-(Y x:ℝ)) ∂μ) ∧ (∫ x,Real.exp (-(Y x:ℝ)) ∂μ)<1 := by
  have hi := integrable_neg_exp_nat μ Y hY
  have hle : (fun x => Real.exp (-(Y x:ℝ))) ≤ᵐ[μ] fun _ => 1 :=
    ae_of_all _ fun _ => Real.exp_le_one_iff.mpr (neg_nonpos.mpr (Nat.cast_nonneg _))
  refine ⟨integral_exp_pos hi,lt_of_le_of_ne ?_ ?_⟩
  · simpa using integral_mono_ae hi (integrable_const (1:ℝ)) hle
  · intro he
    have he' : (∫ x,Real.exp (-(Y x:ℝ)) ∂μ)=∫ _ : Ω,(1:ℝ) ∂μ := by simpa using he
    have hae := (integral_eq_iff_of_ae_le hi (integrable_const (1:ℝ)) hle).mp he'
    have hz : (fun x => (Y x:ℝ)) =ᵐ[μ] 0 := by
      filter_upwards [hae] with x hx
      have : -(Y x:ℝ)=0 := (Real.exp_eq_one_iff _).mp hx
      simpa using neg_eq_zero.mp this
    have : (∫ x,(Y x:ℝ) ∂μ)=0 := (integral_eq_zero_iff_of_nonneg (fun _ => Nat.cast_nonneg _) hint).mpr hz
    linarith


lemma iid_nat_laplace_sum {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
    [IsProbabilityMeasure μ] (Y : ℕ → Ω → ℕ) (hY : ∀ i, Measurable (Y i))
    (hind : iIndepFun Y μ) (hident : ∀ i, IdentDistrib (Y i) (Y 0) μ μ) (n : ℕ) :
    (∫ x,Real.exp (-(∑ i ∈ Finset.range n,(Y i x:ℝ))) ∂μ)=
      (∫ x,Real.exp (-(Y 0 x:ℝ)) ∂μ)^n := by
  let Z : Fin n → Ω → ℝ := fun i x => Real.exp (-(Y i x:ℝ))
  have hZ : iIndepFun Z μ := (hind.precomp Fin.val_injective).comp
    (fun (_ : Fin n) (k : ℕ) => Real.exp (-(k:ℝ))) (fun _ => measurable_of_countable _)
  have he : ∀ x, Real.exp (-(∑ i ∈ Finset.range n,(Y i x:ℝ)))=∏ i : Fin n,Z i x := by
    intro x
    rw [← Finset.sum_neg_distrib,Real.exp_sum]
    exact (Fin.prod_univ_eq_prod_range _ n).symm
  simp_rw [he]
  rw [hZ.integral_fun_prod_eq_prod_integral (fun i =>
    ((measurable_of_countable (fun k : ℕ => Real.exp (-(k:ℝ)))).comp (hY i)).aestronglyMeasurable)]
  have hm (i : Fin n) : (∫ x,Z i x ∂μ)=∫ x,Real.exp (-(Y 0 x:ℝ)) ∂μ :=
    ((hident i).comp (measurable_of_countable (fun k : ℕ => Real.exp (-(k:ℝ))))).integral_eq
  simp_rw [hm]
  simp


lemma iid_nat_lower_tail {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
    [IsProbabilityMeasure μ] (Y : ℕ → Ω → ℕ) (hY : ∀ i, Measurable (Y i))
    (hind : iIndepFun Y μ) (hident : ∀ i, IdentDistrib (Y i) (Y 0) μ μ)
    (hint : Integrable (fun x => (Y 0 x:ℝ)) μ) (hmean : 0 < ∫ x,(Y 0 x:ℝ) ∂μ) :
    ∃ c ρ : ℝ, 0<c ∧ 0<ρ ∧ ρ<1 ∧ ∀ n : ℕ,
      μ {x | (∑ i ∈ Finset.range n,(Y i x:ℝ)) ≤ c*n} ≤ ENNReal.ofReal (ρ^n) := by
  let q := ∫ x,Real.exp (-(Y 0 x:ℝ)) ∂μ
  obtain ⟨hq0,hq1⟩ := nat_laplace_lt_one μ (Y 0) (hY 0) hint hmean
  change 0<q at hq0
  change q<1 at hq1
  let c := -Real.log q/2
  have hc : 0<c := by
    dsimp [c]
    have : Real.log q<0 := Real.log_neg hq0 hq1
    linarith
  let ρ := Real.exp (-c)
  have hr0 : 0<ρ := Real.exp_pos _
  have hr1 : ρ<1 := Real.exp_lt_one_iff.mpr (by linarith)
  have hprod : Real.exp c*q=ρ := by
    change Real.exp c*q=Real.exp (-c)
    rw [← Real.exp_log hq0,← Real.exp_add]
    congr 1
    dsimp [c]
    ring
  refine ⟨c,ρ,hc,hr0,hr1,fun n => ?_⟩
  let F : Ω → ℝ := fun x => Real.exp (-(∑ i ∈ Finset.range n,(Y i x:ℝ)))
  have hm : Measurable F := by
    dsimp [F]
    fun_prop
  have hi : Integrable F μ := by
    apply Integrable.of_bound hm.aestronglyMeasurable 1
    filter_upwards with x
    rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
    exact Real.exp_le_one_iff.mpr (neg_nonpos.mpr (Finset.sum_nonneg fun i _ => Nat.cast_nonneg _))
  have hmark := mul_meas_ge_le_integral_of_nonneg
    (ae_of_all μ fun x => (Real.exp_pos _).le) hi (Real.exp (-c*n))
  have he : {x | Real.exp (-c*n) ≤ F x}=
      {x | (∑ i ∈ Finset.range n,(Y i x:ℝ)) ≤ c*n} := by
    ext x
    simp only [Set.mem_ofPred_eq,F,Real.exp_le_exp,neg_mul,neg_le_neg_iff]
  rw [he,iid_nat_laplace_sum μ Y hY hind hident n] at hmark
  have hp : μ.real {x | (∑ i ∈ Finset.range n,(Y i x:ℝ)) ≤ c*n} ≤ ρ^n := by
    have heq : Real.exp (-c*n)*ρ^n=q^n := by
      rw [← hprod,mul_pow,← Real.exp_nat_mul]
      rw [← mul_assoc,← Real.exp_add]
      have : -c*(n:ℝ)+(n:ℝ)*c=0 := by ring
      rw [this,Real.exp_zero,one_mul]
    rw [← heq] at hmark
    exact (mul_le_mul_iff_right₀ (Real.exp_pos _)).mp hmark
  have hp' := ENNReal.ofReal_le_ofReal hp
  rwa [measureReal_def,ENNReal.ofReal_toReal (measure_ne_top _ _)] at hp'


def renewalLevel (r : ℕ) (x : ℕ → ℕ) : ℝ :=
  ∑ i ∈ Finset.range r,(renewalIncrement i x:ℝ)


lemma measurable_renewalLevel (r : ℕ) : Measurable (renewalLevel r) := by
  unfold renewalLevel
  exact Finset.measurable_sum _ fun i _ =>
    (measurable_of_countable (fun k : ℕ => (k:ℝ))).comp (measurable_renewalIncrement i)


lemma renewalLevel_nonneg (r : ℕ) (x : ℕ → ℕ) : 0 ≤ renewalLevel r x :=
  Finset.sum_nonneg fun _ _ => Nat.cast_nonneg _


lemma CriticalEvenOffspring.renewal_uniform_remainder (p : CriticalEvenOffspring)
    {ε : ℝ} (hε : 0<ε) :
    ∀ᵐ x ∂p.streamLaw, ∃ A : ℕ, ∀ r,
      |renewalLevel r x-(p.variance/2)*r| ≤ ε*renewalLevel r x+A := by
  filter_upwards [p.renewal_strong_law] with x hx
  exact linear_remainder_of_ratio (half_pos p.variance_pos) hε
    (fun r => renewalLevel_nonneg r x) hx


lemma CriticalEvenOffspring.renewal_remainder_probability (p : CriticalEvenOffspring)
    {ε : ℝ} (hε : 0<ε) :
    Tendsto (fun A : ℕ => p.streamLaw {x | ∃ r,
      ε*renewalLevel r x+A < |renewalLevel r x-(p.variance/2)*r|}) atTop (𝓝 0) :=
  uniform_remainder_probability p.streamLaw renewalLevel measurable_renewalLevel
    (p.variance/2) ε (p.renewal_uniform_remainder hε)


lemma CriticalEvenOffspring.renewal_lower_tail (p : CriticalEvenOffspring) :
    ∃ c ρ : ℝ, 0<c ∧ 0<ρ ∧ ρ<1 ∧ ∀ m : ℕ,
      p.streamLaw {x | renewalLevel m x ≤ c*m} ≤ ENNReal.ofReal (ρ^m) := by
  have hint : Integrable (fun x => (renewalIncrement 0 x:ℝ)) p.streamLaw :=
    ((p.renewal_hasLaw 0).measurePreserving (measurable_renewalIncrement 0)).integrable_comp_of_integrable
      p.ladder_integrable
  have hm : (∫ x,(renewalIncrement 0 x:ℝ) ∂p.streamLaw)=p.variance/2 :=
    ((p.renewal_hasLaw 0).integral_comp
      (measurable_of_countable (fun k : ℕ => (k:ℝ))).aestronglyMeasurable).trans p.ladder_integral
  exact iid_nat_lower_tail p.streamLaw renewalIncrement measurable_renewalIncrement p.renewal_iid
    (fun i => (p.renewal_hasLaw i).identDistrib (p.renewal_hasLaw 0)) hint
    (by rw [hm]; exact half_pos p.variance_pos)


lemma ladderTime_level_real {x : ℕ → ℕ} (hx : HasAllLadders x) (r : ℕ) :
    (integerSum x (ladderTime x r):ℝ)=renewalLevel r x := by
  rw [ladderTime_level_sum hx]
  simp only [Int.cast_sum,Int.cast_natCast,renewalLevel]


lemma record_count_remainder {x : ℕ → ℕ} (hx : HasAllLadders x)
    (ν ε A : ℝ) (h : ∀ r, |renewalLevel r x-ν*r| ≤ ε*renewalLevel r x+A) (n : ℕ) :
    |(integerSum x (ladderTime x (renewalCount (ladderTime x) n)):ℝ)-
      ν*(weakRecords (integerSum x) n).card| ≤
      ε*(integerSum x (ladderTime x (renewalCount (ladderTime x) n)):ℝ)+A := by
  rw [(ladderTime_enumeration hx).card_records,ladderTime_level_real hx]
  exact h _


def reverseRecords {α : Type*} [LinearOrder α] (S : ℕ → α) (a b : ℕ) : Finset ℕ :=
  (Finset.Ico a b).filter fun j => ∀ r, j ≤ r → r ≤ b → S j ≤ S r


def recordHeight {α : Type*} [LinearOrder α] (S : ℕ → α) (a b : ℕ) : ℕ :=
  (reverseRecords S a b).card


@[simp] lemma mem_reverseRecords {α : Type*} [LinearOrder α] (S : ℕ → α) (a b j : ℕ) :
    j ∈ reverseRecords S a b ↔ a ≤ j ∧ j < b ∧ ∀ r, j ≤ r → r ≤ b → S j ≤ S r := by
  simp only [reverseRecords, Finset.mem_filter, Finset.mem_Ico, and_assoc]


lemma exists_first_path_minimum {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b : ℕ} (hab : a ≤ b) :
    ∃ i, a ≤ i ∧ i ≤ b ∧ (∀ r, a ≤ r → r ≤ b → S i ≤ S r) ∧
      ∀ r, a ≤ r → r < i → S i < S r := by
  classical
  have hex : ∃ i, a ≤ i ∧ i ≤ b ∧ ∀ r, a ≤ r → r ≤ b → S i ≤ S r := by
    obtain ⟨i,hi,hmin⟩ := (Finset.Icc a b).exists_min_image S ⟨a,Finset.mem_Icc.mpr ⟨le_rfl,hab⟩⟩
    exact ⟨i,(Finset.mem_Icc.mp hi).1,(Finset.mem_Icc.mp hi).2,
      fun r ha hb => hmin r (Finset.mem_Icc.mpr ⟨ha,hb⟩)⟩
  refine ⟨Nat.find hex,(Nat.find_spec hex).1,(Nat.find_spec hex).2.1,
    (Nat.find_spec hex).2.2,?_⟩
  intro r hra hri
  by_contra hn
  have hr : r ≤ b := le_trans (le_of_lt hri) (Nat.find_spec hex).2.1
  exact Nat.find_min hex hri ⟨hra,hr,fun k hka hkb =>
    (le_of_not_gt hn).trans ((Nat.find_spec hex).2.2 k hka hkb)⟩


lemma reverseRecords_at_first_minimum {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b i : ℕ} (hai : a ≤ i) (hib : i ≤ b)
    (hmin : ∀ r, a ≤ r → r ≤ b → S i ≤ S r)
    (hfirst : ∀ r, a ≤ r → r < i → S i < S r) :
    reverseRecords S 0 i = (reverseRecords S 0 b).filter (fun j => j < a) := by
  ext j
  simp only [mem_reverseRecords, Finset.mem_filter]
  constructor
  · rintro ⟨h0,hji,hrec⟩
    have hja : j < a := by
      by_contra hn
      exact (not_le_of_gt (hfirst j (by omega) hji)) (hrec i hji.le le_rfl)
    refine ⟨⟨h0,lt_of_lt_of_le hji hib,?_⟩,hja⟩
    intro r hjr hrb
    by_cases hri : r ≤ i
    · exact hrec r hjr hri
    · exact (hrec i hji.le le_rfl).trans (hmin r (by omega) hrb)
  · rintro ⟨⟨h0,hjb,hrec⟩,hja⟩
    exact ⟨h0,lt_of_lt_of_le hja hai,fun r hjr hri => hrec r hjr (hri.trans hib)⟩


lemma reverseRecords_split {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b : ℕ} (_hab : a ≤ b) :
    reverseRecords S 0 b =
      ((reverseRecords S 0 b).filter (fun j => j < a)) ∪ reverseRecords S a b := by
  ext j
  simp only [Finset.mem_union,Finset.mem_filter,mem_reverseRecords]
  constructor
  · intro hj
    by_cases hja : j < a
    · exact Or.inl ⟨hj,hja⟩
    · exact Or.inr ⟨by omega,hj.2⟩
  · rintro (⟨hj,_⟩ | hj)
    · exact hj
    · exact ⟨Nat.zero_le j,hj.2⟩


lemma reverseRecords_shared_prefix_subset {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b r : ℕ} (har : a ≤ r) (hrb : r ≤ b) :
    (reverseRecords S 0 b).filter (fun j => j < a) ⊆ reverseRecords S 0 r := by
  intro j hj
  obtain ⟨hj,hja⟩ := Finset.mem_filter.mp hj
  obtain ⟨h0,hjb,hrec⟩ := (mem_reverseRecords ..).mp hj
  exact (mem_reverseRecords ..).mpr
    ⟨h0,lt_of_lt_of_le hja har,fun k hjk hkr => hrec k hjk (hkr.trans hrb)⟩


theorem recordHeight_interval_identity {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b : ℕ} (hab : a ≤ b) :
    ∃ i, a ≤ i ∧ i ≤ b ∧
      (∀ r, a ≤ r → r ≤ b → recordHeight S 0 i ≤ recordHeight S 0 r) ∧
      recordHeight S 0 b = recordHeight S 0 i + recordHeight S a b := by
  classical
  obtain ⟨i,hai,hib,hmin,hfirst⟩ := exists_first_path_minimum S hab
  have he := reverseRecords_at_first_minimum S hai hib hmin hfirst
  refine ⟨i,hai,hib,?_,?_⟩
  · intro r har hrb
    unfold recordHeight
    rw [he]
    exact Finset.card_le_card (reverseRecords_shared_prefix_subset S har hrb)
  · unfold recordHeight
    rw [he]
    nth_rw 1 [reverseRecords_split S hab]
    apply Finset.card_union_of_disjoint
    apply Finset.disjoint_left.mpr
    intro j hj hj'
    have hja := (Finset.mem_filter.mp hj).2
    have haj := ((mem_reverseRecords ..).mp hj').1
    omega

end FKCRT.TreeCoding
end

end OAI