import OAI.Probability.FKMaps.ConditionedWalk

namespace OAI

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

lemma LadderEnumeration.prefixMaximum {S : ℕ → ℤ} {τ : ℕ → ℕ}
    (h : LadderEnumeration S τ) (n : ℕ) :
    prefixMaximum S n = S (τ (renewalCount τ n)) :=
  prefixMaximum_eq (renewalCount_spec h.zero n) (fun _ hk => h.maximum hk)

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

lemma CriticalEvenOffspring.prefix_record_uniform_remainder (p : CriticalEvenOffspring)
    {ε : ℝ} (hε : 0<ε) :
    ∀ᵐ x ∂p.streamLaw, ∃ A : ℕ, ∀ n,
      |(prefixMaximum (integerSum x) n:ℝ)-(p.variance/2)*(weakRecords (integerSum x) n).card| ≤
        ε*(prefixMaximum (integerSum x) n:ℝ)+A := by
  filter_upwards [p.ae_all_ladders,p.renewal_uniform_remainder hε] with x hx hrem
  obtain ⟨A,hA⟩ := hrem
  exact ⟨A,fun n => prefix_record_remainder hx _ _ _ hA n⟩

lemma CriticalEvenOffspring.prefix_record_remainder_probability (p : CriticalEvenOffspring)
    {ε : ℝ} (hε : 0<ε) :
    Tendsto (fun A : ℕ => p.streamLaw {x | ∃ n,
      ε*(prefixMaximum (integerSum x) n:ℝ)+A <
        |(prefixMaximum (integerSum x) n:ℝ)-(p.variance/2)*(weakRecords (integerSum x) n).card|})
      atTop (𝓝 0) := by
  have hb (A : ℕ) : p.streamLaw {x | ∃ n,
      ε*(prefixMaximum (integerSum x) n:ℝ)+A <
        |(prefixMaximum (integerSum x) n:ℝ)-(p.variance/2)*(weakRecords (integerSum x) n).card|} ≤
      p.streamLaw {x | ∃ r, ε*renewalLevel r x+A < |renewalLevel r x-(p.variance/2)*r|} := by
    apply measure_mono_ae
    filter_upwards [p.ae_all_ladders] with x hx
    rintro ⟨n,hn⟩
    refine ⟨renewalCount (ladderTime x) n, ?_⟩
    rwa [(ladderTime_enumeration hx).prefixMaximum,
      (ladderTime_enumeration hx).card_records, ladderTime_level_real hx] at hn
  exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds
    (p.renewal_remainder_probability hε) (fun _ => bot_le) hb

lemma le_prefixMaximum (S : ℕ → ℤ) {i n : ℕ} (hi : i≤n) :
    S i ≤ prefixMaximum S n :=
  Finset.le_sup' S (Finset.mem_range.mpr (by omega))

lemma prefixMaximum_le {S : ℕ → ℤ} {n : ℕ} {a : ℤ}
    (h : ∀ k, k≤n → S k≤a) : prefixMaximum S n≤a :=
  Finset.sup'_le _ _ (fun k hk => h k (by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hk))

lemma prefixMaximum_mono (S : ℕ → ℤ) {m n : ℕ} (h : m≤n) :
    prefixMaximum S m≤prefixMaximum S n :=
  prefixMaximum_le fun _ hk => le_prefixMaximum S (hk.trans h)

lemma prefixMaximum_attained (S : ℕ → ℤ) (n : ℕ) :
    ∃ k≤n, prefixMaximum S n = S k := by
  obtain ⟨k,hk,he⟩ := Finset.exists_mem_eq_sup' (s := Finset.range (n+1)) Finset.nonempty_range_add_one S
  exact ⟨k,by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hk,he⟩

lemma CriticalEvenOffspring.integerSum_scaled (p : CriticalEvenOffspring) (x : ℕ → ℕ) (n : ℕ) :
    (integerSum x n:ℝ)=p.sigma*(∑ j∈Finset.range n,p.streamStep j x) := by
  simp only [integerSum,Int.cast_sum,Int.cast_sub,Int.cast_natCast,Int.cast_one,
    streamStep,standardStep,← Finset.sum_div]
  field_simp [p.sigma_pos.ne']

lemma CriticalEvenOffspring.prefix_maximum_bound (p : CriticalEvenOffspring)
    {N : ℕ} (hN : 0<N) {R : ℝ} (hR : 0<R) :
    p.streamLaw.real {x | p.sigma*R*Real.sqrt N ≤ (prefixMaximum (integerSum x) N:ℝ)} ≤ 1/R^2 := by
  have hb := independent_sum_scaled_maximal_bound p.streamStep
    (fun _ => by unfold streamStep; fun_prop) p.streamStep_memLp
    p.streamStep_indep p.streamStep_integral (fun k => (p.streamStep_integral_sq k).le) hN hR
  apply (measureReal_mono ?_).trans hb
  intro x hx
  obtain ⟨k,hk,he⟩ := prefixMaximum_attained (integerSum x) N
  refine ⟨k,hk,?_⟩
  change p.sigma*R*Real.sqrt N ≤ (prefixMaximum (integerSum x) N:ℝ) at hx
  rw [he,p.integerSum_scaled] at hx
  have hh : R*Real.sqrt N ≤ ∑ j∈Finset.range k,p.streamStep j x := by
    apply (mul_le_mul_iff_right₀ p.sigma_pos).mp
    simpa only [mul_assoc] using hx
  exact hh.trans (le_abs_self _)

lemma CriticalEvenOffspring.prefix_record_error_bound (p : CriticalEvenOffspring)
    {N : ℕ} (hN : 0<N) {R ε : ℝ} (hR : 0<R) (hε : 0≤ε) (A : ℕ) :
    p.streamLaw.real {x | ∃ k≤N,
      ε*(p.sigma*R*Real.sqrt N)+A <
        |(prefixMaximum (integerSum x) k:ℝ)-(p.variance/2)*(weakRecords (integerSum x) k).card|} ≤
      (p.streamLaw {x | ∃ r, ε*renewalLevel r x+A < |renewalLevel r x-(p.variance/2)*r|}).toReal + 1/R^2 := by
  let E : Set (ℕ → ℕ) := {x | ∃ r, ε*renewalLevel r x+A < |renewalLevel r x-(p.variance/2)*r|}
  let F : Set (ℕ → ℕ) := {x | p.sigma*R*Real.sqrt N ≤ (prefixMaximum (integerSum x) N:ℝ)}
  have hs : ∀ᵐ x ∂p.streamLaw, (∃ k≤N, ε*(p.sigma*R*Real.sqrt N)+A <
      |(prefixMaximum (integerSum x) k:ℝ)-(p.variance/2)*(weakRecords (integerSum x) k).card|) →
      x∈E∪F := by
    filter_upwards [p.ae_all_ladders] with x hx
    rintro ⟨k,hk,hbad⟩
    by_cases he : x∈E
    · exact Or.inl he
    apply Or.inr
    by_contra hf
    have hrem : ∀ r, |renewalLevel r x-(p.variance/2)*r| ≤ ε*renewalLevel r x+A := by
      simpa only [E,Set.mem_ofPred_eq,not_exists,not_lt] using he
    have hmax : (prefixMaximum (integerSum x) k:ℝ) ≤ p.sigma*R*Real.sqrt N := by
      exact (Int.cast_le.mpr (prefixMaximum_mono _ hk)).trans (le_of_lt (not_le.mp hf))
    exact (not_lt_of_ge ((prefix_record_remainder hx _ _ _ hrem k).trans
      (add_le_add (mul_le_mul_of_nonneg_left hmax hε) le_rfl))) hbad
  calc
    _ ≤ p.streamLaw.real (E∪F) := ENNReal.toReal_mono (measure_ne_top _ _) (measure_mono_ae hs)
    _ ≤ p.streamLaw.real E+p.streamLaw.real F := measureReal_union_le _ _
    _ ≤ _ := add_le_add le_rfl (p.prefix_maximum_bound hN hR)

/-- Finite variance suffices for the uniform renewal-record approximation on
an unconditioned iid prefix; no upper exponential moment is used. -/
theorem CriticalEvenOffspring.iid_prefix_record_error (p : CriticalEvenOffspring)
    {δ : ℝ} (hδ : 0<δ) :
    Tendsto (fun N : ℕ => p.streamLaw.real {x | ∃ k≤N,
      δ*Real.sqrt N <
        |(prefixMaximum (integerSum x) k:ℝ)-(p.variance/2)*(weakRecords (integerSum x) k).card|})
      atTop (𝓝 0) := by
  apply tendsto_order.2
  constructor
  · intro a ha
    exact Eventually.of_forall fun _ => ha.trans_le measureReal_nonneg
  · intro η hη
    let R := Real.sqrt (4/η)
    have hR : 0<R := Real.sqrt_pos.mpr (by positivity)
    have hR2 : R^2=4/η := Real.sq_sqrt (by positivity)
    have htail : 1/R^2=η/4 := by rw [hR2]; field_simp
    have hσ := p.sigma_pos
    let ε := δ/(2*p.sigma*R)
    have hε : 0<ε := div_pos hδ (by positivity)
    have heq : ε*(p.sigma*R)=δ/2 := by dsimp [ε]; field_simp [hR.ne',hσ.ne']
    have hlim : Tendsto (fun A : ℕ => (p.streamLaw {x | ∃ r,
        ε*renewalLevel r x+A < |renewalLevel r x-(p.variance/2)*r|}).toReal)
        atTop (𝓝 0) := by
      simpa only [ENNReal.toReal_zero,Function.comp_def] using
        (ENNReal.tendsto_toReal (by simp : (0:ℝ≥0∞)≠∞)).comp (p.renewal_remainder_probability hε)
    obtain ⟨A,hA⟩ := (hlim.eventually (eventually_lt_nhds (show (0:ℝ)<η/2 from half_pos hη))).exists
    have hscale : Tendsto (fun N : ℕ => δ/2*Real.sqrt N) atTop atTop :=
      (Real.tendsto_sqrt_atTop.comp tendsto_natCast_atTop_atTop).const_mul_atTop (half_pos hδ)
    filter_upwards [hscale.eventually_ge_atTop (A:ℝ),eventually_gt_atTop 0] with N hN hNpos
    have hbound := p.prefix_record_error_bound hNpos hR hε.le A
    have hs : ε*(p.sigma*R*Real.sqrt N)+A ≤ δ*Real.sqrt N := by
      rw [← mul_assoc,heq]
      linarith
    have hmono : p.streamLaw.real {x | ∃ k≤N,
        δ*Real.sqrt N <
          |(prefixMaximum (integerSum x) k:ℝ)-(p.variance/2)*(weakRecords (integerSum x) k).card|} ≤
        p.streamLaw.real {x | ∃ k≤N, ε*(p.sigma*R*Real.sqrt N)+A <
          |(prefixMaximum (integerSum x) k:ℝ)-(p.variance/2)*(weakRecords (integerSum x) k).card|} := by
      refine measureReal_mono ?_ (measure_ne_top _ _)
      rintro x ⟨k,hk,hx⟩
      exact ⟨k,hk,hs.trans_lt hx⟩
    apply (hmono.trans hbound).trans_lt
    rw [htail]
    linarith

end FKCRT.TreeCoding
end


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

lemma map_cond_preimage {Ω Ξ : Type*} [MeasurableSpace Ω] [MeasurableSpace Ξ]
    (μ : Measure Ω) {f : Ω → Ξ} (hf : Measurable f) {s : Set Ξ} (hs : MeasurableSet s) :
    (cond μ (f ⁻¹' s)).map f = cond (μ.map f) s := by
  rw [ProbabilityTheory.cond,ProbabilityTheory.cond,Measure.map_smul _ hf.aemeasurable,
    ← Measure.restrict_map hf hs,Measure.map_apply hf hs]

def streamPrefix (N : ℕ) (x : ℕ → ℕ) : Fin N → ℕ := fun i => x i.val

lemma measurable_streamPrefix (N : ℕ) : Measurable (streamPrefix N) :=
  Measurable.of_eval (fun index => measurable_pi_apply index.val)

lemma totalStep_streamPrefix (N : ℕ) (x : ℕ → ℕ) :
    totalStep (streamPrefix N x)=integerSum x N := by
  exact Fin.sum_univ_eq_sum_range (fun k => ((x k:ℤ)-1)) N

lemma CriticalEvenOffspring.streamPrefix_hasLaw (p : CriticalEvenOffspring) (N : ℕ) :
    HasLaw (streamPrefix N) (p.iidLaw N) p.streamLaw := p.stream_restrict_law N

def CriticalEvenOffspring.streamBridgeLaw (p : CriticalEvenOffspring) (n : ℕ) :
    Measure (ℕ → ℕ) := cond p.streamLaw {x | integerSum x (2*n+1)=-1}

lemma CriticalEvenOffspring.streamBridge_restrict (p : CriticalEvenOffspring) (n : ℕ) :
    HasLaw (streamPrefix (2*n+1)) (p.iidBridgeLaw n) (p.streamBridgeLaw n) := by
  refine ⟨(measurable_streamPrefix _).aemeasurable,?_⟩
  have hh := map_cond_preimage p.streamLaw (measurable_streamPrefix (2*n+1))
    (show MeasurableSet {d : Fin (2*n+1) → ℕ | totalStep d=-1} from by measurability)
  simpa only [streamBridgeLaw,iidBridgeLaw,Set.preimage_ofPred_eq,totalStep_streamPrefix,
    (p.streamPrefix_hasLaw (2*n+1)).map_eq] using hh

instance (p : CriticalEvenOffspring) (n : ℕ) : IsProbabilityMeasure (p.streamBridgeLaw n) := by
  have : IsProbabilityMeasure ((p.streamBridgeLaw n).map (streamPrefix (2*n+1))) := by
    rw [(p.streamBridge_restrict n).map_eq]
    infer_instance
  exact Measure.isProbabilityMeasure_of_map (measurable_streamPrefix (2*n+1)).aemeasurable

def arrayStream {N : ℕ} (d : Fin N → ℕ) : ℕ → ℕ :=
  fun k => if h:k<N then d ⟨k,h⟩ else 0

lemma integerSum_arrayStream_prefix (N : ℕ) (x : ℕ → ℕ) {k : ℕ} (hk : k ≤ N) :
    integerSum (arrayStream (streamPrefix N x)) k = integerSum x k := by
  unfold integerSum
  apply Finset.sum_congr rfl
  intro i hi
  simp only [arrayStream,streamPrefix,dite_eq_left ((Finset.mem_range.mp hi).trans_le hk)]

def recordError (ν : ℝ) (S : ℕ → ℤ) (k : ℕ) : ℝ :=
  |(prefixMaximum S k:ℝ)-ν*(weakRecords S k).card|

lemma recordError_congr {ν : ℝ} {S T : ℕ → ℤ} {k : ℕ}
    (h : ∀ j, j ≤ k → S j=T j) : recordError ν S k=recordError ν T k := by
  rw [recordError,recordError,prefixMaximum_congr h,weakRecords_congr_prefix h]

lemma recordError_arrayStream_prefix (N : ℕ) (x : ℕ → ℕ) {k : ℕ} (hk : k ≤ N) (ν : ℝ) :
    recordError ν (integerSum (arrayStream (streamPrefix N x))) k = recordError ν (integerSum x) k :=
  recordError_congr fun _ hj => integerSum_arrayStream_prefix N x (hj.trans hk)

lemma iidSplit_streamPrefix (m r : ℕ) (x : ℕ → ℕ) :
    (iidSplit m r (streamPrefix (m+r) x)).1=streamPrefix m x := rfl

lemma CriticalEvenOffspring.prefix_domination_stream (p : CriticalEvenOffspring)
    {n J : ℕ} {K : ℝ} (hdom : p.PrefixDominatedFraction (2*n+1) J K)
    {m r : ℕ} (hs : m+r=2*n+1) (hfrac : 2*n+1 ≤ J*r) (E : Set (Fin m → ℕ)) :
    (p.streamBridgeLaw n).real (streamPrefix m ⁻¹' E)  ≤ 
      K*p.streamLaw.real (streamPrefix m ⁻¹' E) := by
  have hmap := (p.streamPrefix_hasLaw m).measurePreserving (measurable_streamPrefix m)
  rw [hmap.measureReal_preimage (by measurability)]
  have hb := hdom m r hs hfrac E
  have heq : (cond (p.iidLaw (m+r)) {d | totalStep d=-1})=
      (p.streamBridgeLaw n).map (streamPrefix (m+r)) := by
    rw [hs]
    exact (p.streamBridge_restrict n).map_eq.symm
  rw [heq] at hb
  have hm : Measurable (streamPrefix (m+r)) := measurable_streamPrefix _
  rw [map_measureReal_apply hm (by measurability)] at hb
  exact hb

lemma CriticalEvenOffspring.prefix_record_domination (p : CriticalEvenOffspring)
    {n J : ℕ} {K : ℝ} (hdom : p.PrefixDominatedFraction (2*n+1) J K)
    {m r : ℕ} (hs : m+r=2*n+1) (hfrac : 2*n+1 ≤ J*r) (a : ℝ) :
    (p.streamBridgeLaw n).real {x | ∃ k ≤ m, a<recordError (p.variance/2) (integerSum x) k}  ≤ 
      K*p.streamLaw.real {x | ∃ k ≤ m, a<recordError (p.variance/2) (integerSum x) k} := by
  let E : Set (Fin m → ℕ) := {d | ∃ k ≤ m, a<recordError (p.variance/2) (integerSum (arrayStream d)) k}
  have he : streamPrefix m ⁻¹' E={x | ∃ k ≤ m, a<recordError (p.variance/2) (integerSum x) k} := by
    ext x
    change (∃ k ≤ m, a<recordError (p.variance/2) (integerSum (arrayStream (streamPrefix m x))) k) ↔ _
    constructor <;> rintro ⟨k,hk,he⟩ <;> refine ⟨k,hk,?_⟩
    · rwa [recordError_arrayStream_prefix m x hk] at he
    · rwa [recordError_arrayStream_prefix m x hk]
  simpa only [he] using p.prefix_domination_stream hdom hs hfrac E

/-- The uniform record approximation survives conditioning on every fixed
proper prefix. The remaining terminal segment is handled separately. -/
theorem CriticalEvenOffspring.bridge_prefix_record_error (p : CriticalEvenOffspring)
    {J : ℕ} (hJ : 0<J) (m r : ℕ → ℕ)
    (hs : ∀ n, m n+r n=2*n+1) (hfrac : ∀ᶠ n in atTop, 2*n+1 ≤ J*r n)
    {δ : ℝ} (hδ : 0<δ) :
    Tendsto (fun n => (p.streamBridgeLaw n).real {x | ∃ k ≤ m n,
      δ*Real.sqrt ((2*n+1:ℕ):ℝ)<recordError (p.variance/2) (integerSum x) k}) atTop (𝓝 0) := by
  obtain ⟨K,hK,hdom⟩ := p.bridge_prefix_domination_fraction J hJ
  have hN : Tendsto (fun n : ℕ => 2*n+1) atTop atTop := by
    exact tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id
  have hi := (p.iid_prefix_record_error hδ).comp hN
  have hlim := hi.const_mul K
  simp only [mul_zero] at hlim
  apply squeeze_zero' (Eventually.of_forall fun _ => measureReal_nonneg) ?_ hlim
  filter_upwards [hdom,hfrac] with n hn hf
  have hb := p.prefix_record_domination hn (hs n) hf (δ*Real.sqrt ((2*n+1:ℕ):ℝ))
  apply hb.trans
  apply mul_le_mul_of_nonneg_left _ hK.le
  refine measureReal_mono ?_ (measure_ne_top _ _)
  rintro x ⟨k,hk,hx⟩
  exact ⟨k,by dsimp; have hh := hs n; omega,hx⟩

lemma CriticalEvenOffspring.streamBridge_reverse (p : CriticalEvenOffspring) (n : ℕ) :
    MeasurePreserving (reverseFirst (2*n+1)) (p.streamBridgeLaw n) (p.streamBridgeLaw n) := by
  apply measurePreserving_cond (reverseFirst_preserving p (2*n+1))
    (measurableSet_eq_fun (measurable_integerSum _) measurable_const)
  ext x
  simp only [Set.mem_preimage,Set.mem_ofPred_eq,integerSum_reverseFirst x (2*n+1) (2*n+1) le_rfl,
    Nat.sub_self,integerSum_zero,sub_zero]

lemma CriticalEvenOffspring.integer_maximal_bound (p : CriticalEvenOffspring)
    (r : ℕ) {a : ℝ} (ha : 0<a) :
    p.streamLaw.real {x | ∃ k ≤ r, a ≤ |(integerSum x k:ℝ)|}  ≤  (r:ℝ)*p.sigma^2/a^2 := by
  have hb := independent_sum_maximal_bound p.streamStep
    (fun _ => by unfold streamStep; fun_prop) p.streamStep_memLp p.streamStep_indep
    p.streamStep_integral r (div_pos ha p.sigma_pos)
  simp only [p.streamStep_integral_sq,Finset.sum_const,Finset.card_range,nsmul_eq_mul,mul_one] at hb
  have hs : {x | ∃ k ≤ r, a ≤ |(integerSum x k:ℝ)|} ⊆
      {x | ∃ k ≤ r, a/p.sigma ≤ |∑ j∈Finset.range k,p.streamStep j x|} := by
    rintro x ⟨k,hk,hx⟩
    refine ⟨k,hk,?_⟩
    rw [p.integerSum_scaled,abs_mul,abs_of_pos p.sigma_pos] at hx
    exact (div_le_iff₀ p.sigma_pos).mpr (by simpa [mul_comm] using hx)
  apply ((measureReal_mono hs).trans hb).trans_eq
  field_simp

lemma integerSum_prefix_event (r : ℕ) (a : ℝ) :
    streamPrefix r ⁻¹' {d | ∃ k ≤ r, a ≤ |(integerSum (arrayStream d) k:ℝ)|}=
      {x | ∃ k ≤ r, a ≤ |(integerSum x k:ℝ)|} := by
  ext x
  change (∃ k ≤ r, a ≤ |(integerSum (arrayStream (streamPrefix r x)) k:ℝ)|) ↔ _
  constructor <;> rintro ⟨k,hk,he⟩ <;> refine ⟨k,hk,?_⟩
  · rwa [integerSum_arrayStream_prefix r x hk] at he
  · rwa [integerSum_arrayStream_prefix r x hk]

lemma CriticalEvenOffspring.bridge_initial_maximal_bound (p : CriticalEvenOffspring)
    {n : ℕ} {K : ℝ} (hK : 0 ≤ K) (hdom : p.PrefixDominatedFraction (2*n+1) 2 K)
    {r : ℕ} (hr : 2*r ≤ 2*n+1) {a : ℝ} (ha : 0<a) :
    (p.streamBridgeLaw n).real {x | ∃ k ≤ r, a ≤ |(integerSum x k:ℝ)|}  ≤  K*((r:ℝ)*p.sigma^2/a^2) := by
  let E : Set (Fin r → ℕ) := {d | ∃ k ≤ r, a ≤ |(integerSum (arrayStream d) k:ℝ)|}
  have hh := p.prefix_domination_stream hdom (m := r) (r := 2*n+1-r) (by omega) (by omega) E
  rw [integerSum_prefix_event] at hh
  exact hh.trans (mul_le_mul_of_nonneg_left (p.integer_maximal_bound r ha) hK)

end FKCRT.TreeCoding
end


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

lemma weakRecords_mono (S : ℕ → ℤ) {m n : ℕ} (h : m ≤ n) :
    weakRecords S m ⊆ weakRecords S n := by
  intro k hk
  obtain ⟨hk0,hkm,hrec⟩ := (mem_weakRecords S m k).mp hk
  exact (mem_weakRecords S n k).mpr ⟨hk0,hkm.trans h,hrec⟩

/-- New absolute weak records are a subset of records in the translated suffix. -/
lemma weakRecords_suffix_card_le (S : ℕ → ℤ) {m n : ℕ} (h : m ≤ n) :
    (weakRecords S n).card  ≤  (weakRecords S m).card+
      (weakRecords (fun k => S (m+k)-S m) (n-m)).card := by
  classical
  have hs : weakRecords S n ⊆ weakRecords S m ∪
      (weakRecords (fun k => S (m+k)-S m) (n-m)).image (fun k => m+k) := by
    intro k hk
    obtain ⟨hk0,hkn,hrec⟩ := (mem_weakRecords S n k).mp hk
    by_cases hkm : k ≤ m
    · exact Finset.mem_union_left _ ((mem_weakRecords S m k).mpr ⟨hk0,hkm,hrec⟩)
    apply Finset.mem_union_right
    refine Finset.mem_image.mpr ⟨k-m,?_,by omega⟩
    apply (mem_weakRecords ..).mpr
    refine ⟨by omega,by omega,?_⟩
    intro j hj
    have hh := hrec (m+j) (by omega)
    have he : m+(k-m)=k := by omega
    rw [he]
    omega
  exact (Finset.card_le_card hs).trans ((Finset.card_union_le _ _).trans
    (add_le_add le_rfl (Finset.card_image_le)))

lemma weakRecords_suffix_of_ladder_level (x : ℕ → ℕ) {m n h : ℕ} (hmn : m ≤ n)
    (hx : HasAllLadders (streamShift m x)) {a : ℝ}
    (hla : a  ≤  renewalLevel h (streamShift m x))
    (hosc : ∀ k, m ≤ k → k ≤ n → (integerSum x k:ℝ)-(integerSum x m:ℝ)<a) :
    (weakRecords (integerSum x) n).card  ≤  (weakRecords (integerSum x) m).card+h := by
  have hb := weakRecords_suffix_card_le (integerSum x) hmn
  have he : (fun k => integerSum x (m+k)-integerSum x m)=integerSum (streamShift m x) := by
    funext k
    exact (integerSum_shift x m k).symm
  rw [he,(ladderTime_enumeration hx).card_records] at hb
  have hcount : renewalCount (ladderTime (streamShift m x)) (n-m) ≤ h := by
    by_contra hn
    have htime : ladderTime (streamShift m x) h ≤ n-m :=
      (le_renewalCount_iff (ladderTime_enumeration hx).strictMono
        (ladderTime_enumeration hx).zero h (n-m)).mp (by omega)
    have hosc' := hosc (m+ladderTime (streamShift m x) h) (by omega) (by omega)
    rw [← ladderTime_level_real hx] at hla
    rw [integerSum_shift] at hla
    push_cast at hla
    linarith
  omega

lemma prefixMaximum_tail_le {S : ℕ → ℤ} {m n : ℕ} {a : ℝ}
    (ha : 0 ≤ a) (hosc : ∀ k, m ≤ k → k ≤ n → (S k:ℝ)-(S m:ℝ) ≤ a) :
    (prefixMaximum S n:ℝ)  ≤  (prefixMaximum S m:ℝ)+a := by
  obtain ⟨k,hk,he⟩ := prefixMaximum_attained S n
  rw [he]
  by_cases hkm : k ≤ m
  · exact (Int.cast_le.mpr (le_prefixMaximum S hkm)).trans (le_add_of_nonneg_right ha)
  · have hh := hosc k (by omega) hk
    have hsup : (S m:ℝ) ≤ prefixMaximum S m := Int.cast_le.mpr (le_prefixMaximum S le_rfl)
    linarith

/-- Uniform numerical estimate used to pass from a truncated bridge to its
full record count. It needs only attained maxima and a one-sided suffix bound. -/
lemma prefix_record_error_tail {x : ℕ → ℕ} {m n h : ℕ} (hmn : m ≤ n)
    (hx : HasAllLadders (streamShift m x)) {ν a : ℝ} (hν : 0 ≤ ν) (ha : 0 ≤ a)
    (hla : a  ≤  renewalLevel h (streamShift m x))
    (hosc : ∀ k, m ≤ k → k ≤ n → (integerSum x k:ℝ)-(integerSum x m:ℝ)<a) :
    |(prefixMaximum (integerSum x) n:ℝ)-ν*(weakRecords (integerSum x) n).card|  ≤ 
      |(prefixMaximum (integerSum x) m:ℝ)-ν*(weakRecords (integerSum x) m).card|+a+ν*h := by
  have hcount := weakRecords_suffix_of_ladder_level x hmn hx hla hosc
  have hcount' : ((weakRecords (integerSum x) n).card:ℝ)  ≤ 
      ((weakRecords (integerSum x) m).card:ℝ)+h := by exact_mod_cast hcount
  have hcountlo : ((weakRecords (integerSum x) m).card:ℝ)  ≤ 
      ((weakRecords (integerSum x) n).card:ℝ) := by
    exact_mod_cast Finset.card_le_card (weakRecords_mono (integerSum x) hmn)
  have hmax := prefixMaximum_tail_le ha (fun k hk hn => (hosc k hk hn).le)
  have hmaxlo : (prefixMaximum (integerSum x) m:ℝ)  ≤  prefixMaximum (integerSum x) n :=
    Int.cast_le.mpr (prefixMaximum_mono _ hmn)
  apply abs_le.mpr
  have hh := abs_le.mp (le_refl |(prefixMaximum (integerSum x) m:ℝ)-ν*(weakRecords (integerSum x) m).card|)
  constructor <;> nlinarith

end FKCRT.TreeCoding
end


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

lemma cond_real_le {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ]
    {E : Set Ω} (hE : MeasurableSet E) (B : Set Ω) :
    (cond μ E).real B ≤ μ.real B / μ.real E := by
  rw [measureReal_def,cond_apply hE,ENNReal.toReal_mul,ENNReal.toReal_inv]
  change (μ.real E)⁻¹ * μ.real (E ∩ B) ≤ _
  rw [div_eq_mul_inv,mul_comm (μ.real B)]
  exact mul_le_mul_of_nonneg_left (measureReal_mono Set.inter_subset_right) (inv_nonneg.mpr measureReal_nonneg)

lemma CriticalEvenOffspring.stream_endpoint_probability (p : CriticalEvenOffspring) (N : ℕ) :
    p.streamLaw.real {x | integerSum x N = -1} =
      (p.iidLaw N).real {d | totalStep d = -1} := by
  have hh := (p.streamPrefix_hasLaw N).measurePreserving (measurable_streamPrefix N)
  simpa only [Set.preimage_ofPred_eq,totalStep_streamPrefix] using
    hh.measureReal_preimage (show MeasurableSet {d : Fin N → ℕ | totalStep d = -1} from by measurability).nullMeasurableSet

lemma CriticalEvenOffspring.stream_endpoint_limit (p : CriticalEvenOffspring) :
    Tendsto (fun n => Real.sqrt ((2*n+1:ℕ):ℝ)*
      p.streamLaw.real {x | integerSum x (2*n+1) = -1}) atTop (𝓝 p.bridgeConstant) := by
  simpa only [p.stream_endpoint_probability] using p.iid_endpoint_limit

lemma CriticalEvenOffspring.streamBridge_shift_ladders (p : CriticalEvenOffspring) (n m : ℕ) :
    ∀ᵐ x ∂p.streamBridgeLaw n, HasAllLadders (streamShift m x) :=
  cond_absolutelyContinuous.ae_le ((p.streamShift_preserving m).quasiMeasurePreserving.ae p.ae_all_ladders)

lemma CriticalEvenOffspring.bridge_shift_ladder_bound (p : CriticalEvenOffspring)
    {c ρ : ℝ} (hρ : 0 ≤ ρ)
    (hb : ∀ h, p.streamLaw {x | renewalLevel h x ≤ c*h} ≤ ENNReal.ofReal (ρ^h))
    (n m h : ℕ) :
    (p.streamBridgeLaw n).real {x | renewalLevel h (streamShift m x) ≤ c*h} ≤
      ρ^h / p.streamLaw.real {x | integerSum x (2*n+1) = -1} := by
  have hr : MeasurableSet {x | renewalLevel h x ≤ c*h} :=
    measurableSet_le (measurable_renewalLevel h) measurable_const
  have ht := (p.streamShift_preserving m).measureReal_preimage hr.nullMeasurableSet
  have hreal : p.streamLaw.real {x | renewalLevel h x ≤ c*h} ≤ ρ^h := by
    exact (ENNReal.toReal_mono (by finiteness) (hb h)).trans_eq (ENNReal.toReal_ofReal (pow_nonneg hρ _))
  apply (cond_real_le p.streamLaw (measurableSet_eq_fun (measurable_integerSum _) measurable_const) _).trans
  exact div_le_div_of_nonneg_right (ht.le.trans hreal) measureReal_nonneg

lemma CriticalEvenOffspring.bridge_terminal_maximal_bound (p : CriticalEvenOffspring)
    {n : ℕ} {K : ℝ} (hK : 0 ≤ K) (hdom : p.PrefixDominatedFraction (2*n+1) 2 K)
    {r : ℕ} (hr : 2*r ≤ 2*n+1) {a : ℝ} (ha : 0<a) :
    (p.streamBridgeLaw n).real {x | ∃ k, 2*n+1-r ≤ k ∧ k ≤ 2*n+1 ∧
      a ≤ (integerSum x k:ℝ)-(integerSum x (2*n+1-r):ℝ)} ≤ K*((r:ℝ)*p.sigma^2/(a/2)^2) := by
  let E : Set (ℕ → ℕ) := {x | ∃ k ≤ r, a/2 ≤ |(integerSum x k:ℝ)|}
  have hsub : {x | ∃ k, 2*n+1-r ≤ k ∧ k ≤ 2*n+1 ∧
      a ≤ (integerSum x k:ℝ)-(integerSum x (2*n+1-r):ℝ)} ⊆
      reverseFirst (2*n+1) ⁻¹' E := by
    rintro x ⟨k,hkm,hkn,hx⟩
    by_contra hn
    have hn' : ∀ j ≤ r, |(integerSum (reverseFirst (2*n+1) x) j:ℝ)| < a/2 := by
      simpa only [Set.mem_preimage,E,Set.mem_ofPred_eq,not_exists,not_and,not_le] using hn
    have h1 := hn' r le_rfl
    have h2 := hn' (2*n+1-k) (by omega)
    rw [integerSum_reverseFirst x (2*n+1) r (by omega)] at h1
    rw [integerSum_reverseFirst x (2*n+1) (2*n+1-k) (by omega),Nat.sub_sub_self hkn] at h2
    push_cast at h1 h2
    have h1' := (abs_lt.mp h1).2
    have h2' := (abs_lt.mp h2).1
    linarith
  have hE : MeasurableSet E := by
    simp only [E,Set.ofPred_exists]
    exact MeasurableSet.iUnion fun k => (MeasurableSet.const (k ≤ r)).inter
      (measurableSet_le measurable_const ((measurable_of_countable (fun z : ℤ => (z:ℝ))).comp (measurable_integerSum k)).abs)
  have hh := (p.streamBridge_reverse n).measureReal_preimage hE.nullMeasurableSet
  exact (measureReal_mono hsub).trans (hh.le.trans (p.bridge_initial_maximal_bound hK hdom hr (half_pos ha)))

end FKCRT.TreeCoding
end


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

lemma tendsto_natCeil_comp_atTop {s : ℕ → ℝ} (hs : Tendsto s atTop atTop) :
    Tendsto (fun n => ⌈s n⌉₊) atTop atTop := by
  refine tendsto_atTop.2 fun b => ?_
  filter_upwards [hs.eventually (eventually_ge_atTop (b:ℝ))] with n hn
  exact_mod_cast hn.trans (Nat.le_ceil (s n))

lemma polynomial_geometric_ceil {s : ℕ → ℝ} (hs : Tendsto s atTop atTop)
    (hs0 : ∀ n, 0 ≤ s n) {ε ρ : ℝ} (hε : 0<ε) (hρ : 0 ≤ ρ) (hρ1 : ρ<1) (k : ℕ) :
    Tendsto (fun n => (s n)^k*ρ^⌈ε*s n⌉₊) atTop (𝓝 0) := by
  have hh : Tendsto (fun n => ⌈ε*s n⌉₊) atTop atTop :=
    tendsto_natCeil_comp_atTop (hs.const_mul_atTop hε)
  have ht := ((tendsto_pow_const_mul_const_pow_of_lt_one k hρ hρ1).comp hh).div_const (ε^k)
  simp only [zero_div] at ht
  apply squeeze_zero (fun n => mul_nonneg (pow_nonneg (hs0 n) _) (pow_nonneg hρ _)) ?_ ht
  intro n
  have hr : s n ≤ (⌈ε*s n⌉₊:ℝ)/ε := (le_div_iff₀ hε).mpr (by simpa [mul_comm] using Nat.le_ceil (ε*s n))
  calc
    (s n)^k*ρ^⌈ε*s n⌉₊ ≤ ((⌈ε*s n⌉₊:ℝ)/ε)^k*ρ^⌈ε*s n⌉₊ := by gcongr; exact hs0 n
    _ = _ := by dsimp; rw [div_pow]; ring

lemma odd_size_tendsto : Tendsto (fun n : ℕ => 2*n+1) atTop atTop :=
  tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id

lemma odd_sqrt_tendsto : Tendsto (fun n : ℕ => Real.sqrt ((2*n+1:ℕ):ℝ)) atTop atTop :=
  Real.tendsto_sqrt_atTop.comp (tendsto_natCast_atTop_atTop.comp odd_size_tendsto)

lemma CriticalEvenOffspring.bridge_geometric_vanish (p : CriticalEvenOffspring)
    {ε ρ : ℝ} (hε : 0<ε) (hρ : 0 ≤ ρ) (hρ1 : ρ<1) :
    Tendsto (fun n => ρ^⌈ε*Real.sqrt ((2*n+1:ℕ):ℝ)⌉₊ /
      p.streamLaw.real {x | integerSum x (2*n+1) = -1}) atTop (𝓝 0) := by
  have ht := (polynomial_geometric_ceil odd_sqrt_tendsto (fun _ => Real.sqrt_nonneg _) hε hρ hρ1 1).div
    p.stream_endpoint_limit p.bridgeConstant_pos.ne'
  simp only [zero_div,pow_one] at ht
  convert ht using 1
  funext n
  exact (mul_div_mul_left _ _ (Real.sqrt_pos.mpr (by positivity : (0:ℝ)<((2*n+1:ℕ):ℝ))).ne').symm

end FKCRT.TreeCoding
end


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

lemma CriticalEvenOffspring.bridge_record_tail_bound (p : CriticalEvenOffspring)
    {n m r h : ℕ} (hs : m+r=2*n+1) {t a : ℝ} (ha : 0 ≤ a) :
    (p.streamBridgeLaw n).real {x | t+a+(p.variance/2)*h<recordError (p.variance/2) (integerSum x) (2*n+1)} ≤
      (p.streamBridgeLaw n).real {x | t<recordError (p.variance/2) (integerSum x) m} +
      (p.streamBridgeLaw n).real {x | renewalLevel h (streamShift m x) ≤ a} +
      (p.streamBridgeLaw n).real {x | ∃ k, m ≤ k ∧ k ≤ 2*n+1 ∧
          a ≤ (integerSum x k:ℝ)-(integerSum x m:ℝ)} := by
  let A : Set (ℕ → ℕ) := {x | t<recordError (p.variance/2) (integerSum x) m}
  let B : Set (ℕ → ℕ) := {x | renewalLevel h (streamShift m x) ≤ a}
  let C : Set (ℕ → ℕ) := {x | ∃ k, m ≤ k ∧ k ≤ 2*n+1 ∧ a ≤ (integerSum x k:ℝ)-(integerSum x m:ℝ)}
  have hsub : ∀ᵐ x ∂p.streamBridgeLaw n, t+a+(p.variance/2)*h<recordError (p.variance/2) (integerSum x) (2*n+1) →
      x ∈ (A ∪ B) ∪ C := by
    filter_upwards [p.streamBridge_shift_ladders n m] with x hx
    intro hb
    by_contra hn
    have hn' : ¬x∈A ∧ ¬x∈B ∧ ¬x∈C := by simpa only [Set.mem_union,not_or,and_assoc] using hn
    have hA : recordError (p.variance/2) (integerSum x) m ≤ t := le_of_not_gt hn'.1
    have hB : a < renewalLevel h (streamShift m x) := lt_of_not_ge hn'.2.1
    have hC : ∀ k, m ≤ k → k ≤ 2*n+1 → (integerSum x k:ℝ)-(integerSum x m:ℝ)<a := by
      simpa only [C,Set.mem_ofPred_eq,not_exists,not_and,not_le] using hn'.2.2
    have hh := prefix_record_error_tail (x := x) (h := h) (by omega : m ≤ 2*n+1)
      hx (half_pos p.variance_pos).le ha hB.le hC
    change recordError _ _ _ ≤ recordError _ _ _+a+(p.variance/2)*h at hh
    exact (not_lt_of_ge (hh.trans (by linarith))) hb
  have hb := ENNReal.toReal_mono (measure_ne_top _ _) (measure_mono_ae hsub)
  exact hb.trans ((measureReal_union_le (A ∪ B) C).trans
    (add_le_add (measureReal_union_le A B) le_rfl))

lemma terminal_ratio_bound {N r J : ℕ} (hN : 0<N) (hJ : 0<J) (hr : J*r ≤ N)
    {c ε K σ : ℝ} (hc : 0<c) (hε : 0<ε) (hK : 0 ≤ K) :
    K*((r:ℝ)*σ^2/(c*⌈ε*Real.sqrt (N:ℝ)⌉₊/2)^2) ≤
      4*K*σ^2/(c^2*ε^2*(J:ℝ)) := by
  have hs : 0<Real.sqrt (N:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast hN)
  have hN' : (0:ℝ)<N := by exact_mod_cast hN
  have hJ' : (0:ℝ)<J := by exact_mod_cast hJ
  have hceil := Nat.le_ceil (ε*Real.sqrt (N:ℝ))
  have hden : 0<c*ε*Real.sqrt (N:ℝ)/2 := by positivity
  have hdiv : (r:ℝ)/(N:ℝ) ≤ 1/(J:ℝ) := by
    rw [div_le_div_iff₀ hN' hJ']
    simpa [mul_comm] using (show (J:ℝ)*r ≤ N by exact_mod_cast hr)
  calc
    K*((r:ℝ)*σ^2/(c*⌈ε*Real.sqrt (N:ℝ)⌉₊/2)^2) ≤
        K*((r:ℝ)*σ^2/(c*ε*Real.sqrt (N:ℝ)/2)^2) := by
      apply mul_le_mul_of_nonneg_left _ hK
      apply div_le_div_of_nonneg_left (by positivity) (sq_pos_of_pos hden)
      have hbase : c*ε*Real.sqrt (N:ℝ)/2 ≤ c*⌈ε*Real.sqrt (N:ℝ)⌉₊/2 := by
        nlinarith [mul_le_mul_of_nonneg_left hceil hc.le]
      exact pow_le_pow_left₀ hden.le hbase 2
    _ = (4*K*σ^2/(c^2*ε^2))*((r:ℝ)/(N:ℝ)) := by
      rw [div_pow,mul_pow,mul_pow,Real.sq_sqrt hN'.le]
      ring
    _ ≤ (4*K*σ^2/(c^2*ε^2))*(1/(J:ℝ)) :=
      mul_le_mul_of_nonneg_left hdiv (by positivity)
    _ = _ := by ring

lemma division_prefix_properties {N J : ℕ} (hJ : 2 ≤ J) (hN : J ≤ N) :
    (N-N/J)+N/J=N ∧ 2*(N/J) ≤ N ∧ N ≤ (2*J)*(N/J) := by
  have hJ0 : 0<J := by omega
  have hr : 1 ≤ N/J := (Nat.le_div_iff_mul_le hJ0).mpr (by omega)
  have hm := Nat.div_mul_le_self N J
  have hmod := Nat.mod_lt N hJ0
  have hdecomp := Nat.mod_add_div N J
  have h2 := Nat.mul_le_mul_right (N/J) hJ
  have hjr := Nat.mul_le_mul_left J hr
  have hmul : (2*J)*(N/J)=2*(J*(N/J)) := by ring
  rw [mul_comm (N/J) J] at hm
  constructor
  · exact Nat.sub_add_cancel (Nat.div_le_self N J)
  constructor
  · exact h2.trans hm
  · rw [hmul]
    omega

/-- The weak-record approximation for the **whole** conditioned bridge.
The terminal part is controlled by reversal and a second-moment maximal
inequality, not by independence at the random Vervaat cut. -/
theorem CriticalEvenOffspring.bridge_record_error (p : CriticalEvenOffspring)
    {δ : ℝ} (hδ : 0<δ) :
    Tendsto (fun n => (p.streamBridgeLaw n).real {x |
      δ*Real.sqrt ((2*n+1:ℕ):ℝ)<recordError (p.variance/2) (integerSum x) (2*n+1)})
      atTop (𝓝 0) := by
  obtain ⟨K,hK,hdom⟩ := p.bridge_prefix_domination_fraction 2 (by norm_num)
  obtain ⟨c,ρ,hc,hρ,hρ1,hbound⟩ := p.renewal_lower_tail
  let ν := p.variance/2
  have hν : 0<ν := half_pos p.variance_pos
  let ε := δ/(4*(c+ν))
  have hε : 0<ε := div_pos hδ (by positivity)
  have heq : (c+ν)*ε=δ/4 := by dsimp [ε]; field_simp
  let C := 4*K*p.sigma^2/(c^2*ε^2)
  have hC : 0 ≤ C := by positivity
  apply tendsto_order.2
  constructor
  · intro a ha
    exact Eventually.of_forall fun _ => ha.trans_le measureReal_nonneg
  intro η hη
  have hjlim : Tendsto (fun J : ℕ => C/(J:ℝ)) atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
  obtain ⟨J,hJ,hCJ⟩ := ((eventually_ge_atTop 2).and
    (hjlim.eventually (eventually_lt_nhds (show (0:ℝ)<η/3 by positivity)))).exists
  have hJ0 : 0<J := by omega
  let r : ℕ → ℕ := fun n => (2*n+1)/J
  let m : ℕ → ℕ := fun n => 2*n+1-r n
  have hs : ∀ n, m n+r n=2*n+1 := fun n => Nat.sub_add_cancel (Nat.div_le_self (2*n+1) J)
  have hfrac : ∀ᶠ n in atTop, 2*n+1 ≤ (2*J)*r n := by
    filter_upwards [odd_size_tendsto.eventually_ge_atTop J] with n hn
    exact (division_prefix_properties hJ hn).2.2
  have hpre := p.bridge_prefix_record_error (by omega : 0<2*J) m r hs hfrac (half_pos hδ)
  have hgeo := p.bridge_geometric_vanish hε hρ.le hρ1
  have hlarge : ∀ᶠ n in atTop, c+ν ≤ δ/4*Real.sqrt ((2*n+1:ℕ):ℝ) :=
    (odd_sqrt_tendsto.const_mul_atTop (by positivity : 0<δ/4)).eventually_ge_atTop (c+ν)
  filter_upwards [hdom,odd_size_tendsto.eventually_ge_atTop J,hlarge,
    hpre.eventually (eventually_lt_nhds (show (0:ℝ)<η/3 by positivity)),
    hgeo.eventually (eventually_lt_nhds (show (0:ℝ)<η/3 by positivity))] with n hn hJn hln hpn hgn
  let s := Real.sqrt ((2*n+1:ℕ):ℝ)
  let h := ⌈ε*s⌉₊
  have hsp : 0<s := Real.sqrt_pos.mpr (by positivity)
  have hhp : (0:ℝ)<h := (mul_pos hε hsp).trans_le (Nat.le_ceil _)
  have hsmall : (c+ν)*h ≤ δ/2*s := by
    have hh : (h:ℝ) ≤ ε*s+1 := (Nat.ceil_lt_add_one (mul_nonneg hε.le hsp.le)).le
    have hh' := mul_le_mul_of_nonneg_left hh (show 0 ≤ c+ν by positivity)
    have heq' := congrArg (fun t : ℝ => t*s) heq
    dsimp [s] at heq' ⊢
    nlinarith
  have hthresh : δ/2*s+c*h+ν*h ≤ δ*s := by nlinarith
  have hmono : (p.streamBridgeLaw n).real {x | δ*s<recordError ν (integerSum x) (2*n+1)} ≤
      (p.streamBridgeLaw n).real {x | δ/2*s+c*h+ν*h<recordError ν (integerSum x) (2*n+1)} := by
    refine measureReal_mono ?_ (measure_ne_top _ _)
    intro x hx
    exact hthresh.trans_lt hx
  have hb := p.bridge_record_tail_bound (hs n) (h := h) (t := δ/2*s) (mul_nonneg hc.le hhp.le)
  have hp : (p.streamBridgeLaw n).real {x | δ/2*s<recordError ν (integerSum x) (m n)} < η/3 := by
    apply lt_of_le_of_lt _ hpn
    refine measureReal_mono ?_ (measure_ne_top _ _)
    intro x hx
    exact ⟨m n,le_rfl,hx⟩
  have hg : (p.streamBridgeLaw n).real {x | renewalLevel h (streamShift (m n) x) ≤ c*h} < η/3 :=
    (p.bridge_shift_ladder_bound hρ.le hbound n (m n) h).trans_lt hgn
  have ht : (p.streamBridgeLaw n).real {x | ∃ k, m n ≤ k ∧ k ≤ 2*n+1 ∧
      c*h ≤ (integerSum x k:ℝ)-(integerSum x (m n):ℝ)} ≤ C/(J:ℝ) := by
    have hhalf : 2*r n ≤ 2*n+1 := (division_prefix_properties hJ hJn).2.1
    have hh := p.bridge_terminal_maximal_bound hK.le hn hhalf (mul_pos hc hhp)
    apply hh.trans
    have he := terminal_ratio_bound (by omega : 0<2*n+1) hJ0
      (show J*r n ≤ 2*n+1 by simpa only [r,mul_comm] using Nat.div_mul_le_self (2*n+1) J)
      hc hε hK.le (σ := p.sigma)
    exact he.trans_eq (by dsimp only [C]; ring)
  have hh := (hmono.trans hb).trans (add_le_add (add_le_add hp.le hg.le) ht)
  change (p.streamBridgeLaw n).real {x | δ*s<recordError ν (integerSum x) (2*n+1)} < η
  linarith

end FKCRT.TreeCoding
end


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

instance (N : ℕ) : MeasurableSpace (Code N) := ⊤
instance (N : ℕ) : MeasurableSingletonClass (Code N) := ⟨fun _ => trivial⟩

def CriticalEvenOffspring.codeLaw (p : CriticalEvenOffspring) (n : ℕ) : Measure (Code (2*n+1)) :=
  (p.iidBridgeLaw n).map (arrayTree n)

instance (p : CriticalEvenOffspring) (n : ℕ) : IsProbabilityMeasure (p.codeLaw n) :=
  inferInstanceAs (IsProbabilityMeasure ((p.iidBridgeLaw n).map (arrayTree n)))

lemma CriticalEvenOffspring.code_integral (p : CriticalEvenOffspring) (n : ℕ)
    (F : Code (2*n+1) → ℝ) :
    (∫ d,F d ∂p.codeLaw n)=∑ d : Code (2*n+1), (codeWeight p d/codePartition p (2*n+1))*F d := by
  rw [codeLaw,integral_map (measurable_of_countable (arrayTree n)).aemeasurable
    (measurable_of_countable F).aestronglyMeasurable]
  exact p.arrayTree_expectation n F

lemma integerSum_arrayStream_bridge {N : ℕ} (d : Bridge N) {k : ℕ} (hk : k ≤ N) :
    integerSum (arrayStream (bridgeEmbedding N d)) k=walk d.val k := by
  unfold integerSum walk
  rw [← Fin.sum_univ_eq_sum_range]
  symm
  rw [← Finset.sum_filter]
  apply Finset.sum_bij (fun i hi => (⟨i.val,by
    have hh := Finset.mem_filter.mp hi
    exact hh.2⟩ : Fin k))
  · intro i hi
    exact Finset.mem_univ _
  · intro i hi j hj he
    exact Fin.ext (congrArg (fun z : Fin k => z.val) he)
  · intro i _
    exact ⟨⟨i.val,i.isLt.trans_le hk⟩,by simp [i.isLt],rfl⟩
  · intro i hi
    have hi' : i.val<k := (Finset.mem_filter.mp hi).2
    simp only [arrayStream,dite_eq_left (hi'.trans_le hk),bridgeEmbedding]
    rfl

lemma measurable_recordError_integerSum (ν : ℝ) (N : ℕ) :
    Measurable (fun x => recordError ν (integerSum x) N) := by
  have hh := (measurable_of_countable (fun d : Fin N → ℕ => recordError ν (integerSum (arrayStream d)) N)).comp
    (measurable_streamPrefix N)
  simpa only [Function.comp_def,recordError_arrayStream_prefix N _ le_rfl] using hh

def badHeightFraction {N : ℕ} (ν a : ℝ) (d : Code N) : ℝ :=
  (∑ v : Fin N, if a < |(walk d.val v.val:ℝ)-ν*height d.val v.val| then (1:ℝ) else 0)/(N:ℝ)

lemma badHeightFraction_nonneg {N : ℕ} (ν a : ℝ) (d : Code N) : 0 ≤ badHeightFraction ν a d := by
  unfold badHeightFraction
  positivity

lemma recordError_reverse_array_bridge {N : ℕ} (ν : ℝ) (b : Bridge N) :
    recordError ν (reversedPath (integerSum (arrayStream (bridgeEmbedding N b))) N) N =
      recordError ν (reversedPath (walk b.val) N) N := by
  apply recordError_congr
  intro k hk
  simp only [reversedPath,integerSum_arrayStream_bridge b le_rfl,
    integerSum_arrayStream_bridge b (Nat.sub_le N k)]

lemma recordError_reverse_streamPrefix (ν : ℝ) (N : ℕ) (x : ℕ → ℕ) :
    recordError ν (reversedPath (integerSum (arrayStream (streamPrefix N x))) N) N =
      recordError ν (integerSum (reverseFirst N x)) N := by
  apply recordError_congr
  intro k hk
  rw [reversedPath,integerSum_arrayStream_prefix N x le_rfl,
    integerSum_arrayStream_prefix N x (Nat.sub_le N k),integerSum_reverseFirst x N k hk]

lemma CriticalEvenOffspring.code_average_height_error (p : CriticalEvenOffspring) (n : ℕ) (ν a : ℝ) :
    (∫ d,badHeightFraction ν a d ∂p.codeLaw n) =
      (p.streamBridgeLaw n).real {x | a<recordError ν (integerSum x) (2*n+1)} := by
  classical
  let N := 2*n+1
  let F : (Fin N → ℕ) → ℝ := fun d =>
    if a<recordError ν (reversedPath (integerSum (arrayStream d)) N) N then 1 else 0
  have hsum : (∫ d,badHeightFraction ν a d ∂p.codeLaw n) = ∫ d,F d ∂p.iidBridgeLaw n := by
    rw [p.code_integral, CriticalEvenOffspring.iidBridgeLaw, p.bridge_integral_eq]
    have hh := uniform_vertex_height_error p n ν a
    unfold badHeightFraction
    convert hh using 1
    · simp only [Nat.cast_add,Nat.cast_mul,Nat.cast_ofNat,Nat.cast_one]
    · apply Finset.sum_congr rfl
      intro b _
      dsimp only [F,N]
      rw [recordError_reverse_array_bridge]
      rfl
  rw [hsum]
  have hr := (p.streamBridge_restrict n).integral_comp (measurable_of_countable F).aestronglyMeasurable
  rw [← hr]
  have hF : (fun x => F (streamPrefix N x)) = fun x =>
      if a<recordError ν (integerSum (reverseFirst N x)) N then (1:ℝ) else 0 := by
    funext x
    simp only [F,recordError_reverse_streamPrefix]
  change (∫ x,F (streamPrefix N x) ∂p.streamBridgeLaw n)=_
  rw [hF]
  have hE : MeasurableSet {x | a<recordError ν (integerSum x) N} :=
    measurableSet_lt measurable_const (measurable_recordError_integerSum ν N)
  have hm := (p.streamBridge_reverse n).measureReal_preimage hE.nullMeasurableSet
  rw [← hm]
  exact integral_indicator_one (hE.preimage (reverseFirst_preserving p N).measurable)

/-- The expected proportion of vertices with macroscopic height/walk error
vanishes. This is an exact consequence of cyclic averaging and the full
conditioned-bridge weak-record theorem. -/
theorem CriticalEvenOffspring.average_height_error_limit (p : CriticalEvenOffspring)
    {δ : ℝ} (hδ : 0<δ) :
    Tendsto (fun n => ∫ d,badHeightFraction (p.variance/2)
      (δ*Real.sqrt ((2*n+1:ℕ):ℝ)) d ∂p.codeLaw n) atTop (𝓝 0) := by
  simpa only [p.code_average_height_error] using p.bridge_record_error hδ

end FKCRT.TreeCoding
end

end OAI