lean/OAI/Probability/FKMaps/HeightCoding.lean

import OAI.Probability.FKMaps.LadderRecords
import OAI.Probability.FKMaps.Model

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 reversedPath (S : ℕ → ℤ) (b k : ℕ) : ℤ := S b-S (b-k)


lemma reverse_record_iff (S : ℕ → ℤ) {a b j : ℕ} (haj : a ≤ j) (hjb : j < b) :
    j ∈ reverseRecords S a b ↔ b-j ∈ weakRecords (reversedPath S b) (b-a) := by
  rw [mem_reverseRecords,mem_weakRecords]
  constructor
  · rintro ⟨_,_,hrec⟩
    refine ⟨by omega,by omega,?_⟩
    intro k hk
    have hr := hrec (b-k) (by omega) (by omega)
    dsimp [reversedPath]
    have he : b-(b-j)=j := by omega
    rw [he]
    omega
  · rintro ⟨_,_,hrec⟩
    refine ⟨haj,hjb,?_⟩
    intro r hjr hrb
    have hr := hrec (b-r) (by omega)
    dsimp [reversedPath] at hr
    have he : b-(b-r)=r := by omega
    have he' : b-(b-j)=j := by omega
    rw [he,he'] at hr
    omega


lemma reverse_record_filter_card (S : ℕ → ℤ) (a b : ℕ) (P : ℕ → Prop)
    [DecidablePred P] :
    ((reverseRecords S a b).filter P).card=
      ((weakRecords (reversedPath S b) (b-a)).filter fun k => P (b-k)).card := by
  classical
  apply Finset.card_bij (fun j _ => b-j)
  · intro j hj
    obtain ⟨hrec,hP⟩ := Finset.mem_filter.mp hj
    obtain ⟨haj,hjb,_⟩ := (mem_reverseRecords S a b j).mp hrec
    refine Finset.mem_filter.mpr ⟨(reverse_record_iff S haj hjb).mp hrec,?_⟩
    convert hP using 1
    omega
  · intro j hj k hk he
    have hjb := ((mem_reverseRecords S a b j).mp (Finset.mem_filter.mp hj).1).2.1
    have hkb := ((mem_reverseRecords S a b k).mp (Finset.mem_filter.mp hk).1).2.1
    omega
  · intro k hk
    obtain ⟨hrec,hP⟩ := Finset.mem_filter.mp hk
    obtain ⟨hk1,hkba,_⟩ := (mem_weakRecords _ _ _).mp hrec
    refine ⟨b-k,?_,by omega⟩
    refine Finset.mem_filter.mpr ⟨?_,hP⟩
    apply (reverse_record_iff S (by omega : a ≤ b-k) (by omega : b-k < b)).mpr
    convert hrec using 1
    omega


lemma recordHeight_dual (S : ℕ → ℤ) (a b : ℕ) :
    recordHeight S a b=(weakRecords (reversedPath S b) (b-a)).card := by
  simpa [recordHeight] using reverse_record_filter_card S a b (fun _ => True)


lemma reverseRecords_surviving_at_minimum {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b c : ℕ} (hac : a ≤ c) (hcb : c ≤ b)
    (hmin : ∀ r, a ≤ r → r ≤ b → S c ≤ S r)
    (hfirst : ∀ r, a ≤ r → r < c → S c < S r) :
    reverseRecords S 0 c=(reverseRecords S 0 a).filter fun j => S j ≤ S c := by
  classical
  ext j
  simp only [Finset.mem_filter,mem_reverseRecords]
  constructor
  · rintro ⟨hj0,hjc,hrec⟩
    have hja : j<a := by
      by_contra hn
      exact not_le_of_gt (hfirst j (by omega) hjc) (hrec c hjc.le le_rfl)
    exact ⟨⟨hj0,hja,fun r hjr hra => hrec r hjr (hra.trans hac)⟩,hrec c hjc.le le_rfl⟩
  · rintro ⟨⟨hj0,hja,hrec⟩,hjc⟩
    refine ⟨hj0,lt_of_lt_of_le hja hac,?_⟩
    intro r hjr hrc
    by_cases hra : r ≤ a
    · exact hrec r hjr hra
    · exact hjc.trans (hmin r (by omega) (hrc.trans hcb))


lemma recordHeight_fall_dual (S : ℕ → ℤ) {a b c : ℕ} (hac : a ≤ c) (hcb : c ≤ b)
    (hmin : ∀ r, a ≤ r → r ≤ b → S c ≤ S r)
    (hfirst : ∀ r, a ≤ r → r < c → S c < S r) :
    recordHeight S 0 a-recordHeight S 0 c=
      ((weakRecords (reversedPath S a) a).filter fun k => reversedPath S a k<S a-S c).card := by
  classical
  have he := reverseRecords_surviving_at_minimum S hac hcb hmin hfirst
  have hd := Finset.card_filter_add_card_filter_not (s := reverseRecords S 0 a)
    (p := fun j => S j ≤ S c)
  have hc : ((reverseRecords S 0 a).filter fun j => S c<S j).card=
      recordHeight S 0 a-recordHeight S 0 c := by
    unfold recordHeight
    rw [he]
    simp only [not_le] at hd
    omega
  rw [← hc,reverse_record_filter_card]
  simp only [Nat.sub_zero]
  congr 2
  funext k
  apply propext
  dsimp [reversedPath]
  omega


lemma recordHeight_at_first_minimum_split {α : Type*} [LinearOrder α] (S : ℕ → α)
    {a b c : ℕ} (hac : a ≤ c) (hcb : c ≤ b)
    (hmin : ∀ r, a ≤ r → r ≤ b → S c ≤ S r)
    (hfirst : ∀ r, a ≤ r → r < c → S c < S r) :
    recordHeight S 0 c ≤ recordHeight S 0 a ∧
      recordHeight S 0 b=recordHeight S 0 c+recordHeight S a b := by
  classical
  have he := reverseRecords_at_first_minimum S hac hcb hmin hfirst
  constructor
  · unfold recordHeight
    rw [reverseRecords_surviving_at_minimum S hac hcb hmin hfirst]
    exact Finset.card_filter_le _ _
  · unfold recordHeight
    rw [he]
    nth_rw 1 [reverseRecords_split S (hac.trans hcb)]
    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


lemma height_oscillation_of_reverse_ladders (S : ℕ → ℤ) (a b m : ℕ) (hab : a ≤ b)
    (d : ℤ) (τa τb : ℕ → ℕ)
    (ha : LadderEnumeration (reversedPath S a) τa)
    (hb : LadderEnumeration (reversedPath S b) τb)
    (hla : d ≤ reversedPath S a (τa m)) (hlb : d ≤ reversedPath S b (τb m))
    (hosc : ∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b → S u-S v<d) :
    recordHeight S 0 b ≤ recordHeight S 0 a+m ∧
      recordHeight S 0 a ≤ recordHeight S 0 b+m := by
  obtain ⟨c,hac,hcb,hmin,hfirst⟩ := exists_first_path_minimum S hab
  obtain ⟨hca,hsplit⟩ := recordHeight_at_first_minimum_split S hac hcb hmin hfirst
  have hfall : recordHeight S 0 a-recordHeight S 0 c ≤ m := by
    rw [recordHeight_fall_dual S hac hcb hmin hfirst]
    exact ha.first_records_below a m (S a-S c) ((hosc a c le_rfl hab hac hcb).le.trans hla)
  have hrise : recordHeight S a b ≤ m := by
    rw [recordHeight_dual,hb.card_records]
    by_contra hn
    have hl : τb m ≤ b-a :=
      (le_renewalCount_iff hb.strictMono hb.zero m (b-a)).mp (by omega)
    have hh := hosc b (b-τb m) hab le_rfl (by omega) (by omega)
    dsimp [reversedPath] at hlb
    omega
  omega


lemma weakRecords_congr_prefix {S T : ℕ → ℤ} {n : ℕ}
    (he : ∀ k, k ≤ n → S k=T k) : weakRecords S n=weakRecords T n := by
  ext k
  simp only [mem_weakRecords]
  constructor <;> rintro ⟨hk,hkn,hr⟩ <;> refine ⟨hk,hkn,?_⟩
  · intro j hj
    rw [← he j (by omega),← he k hkn]
    exact hr j hj
  · intro j hj
    rw [he j (by omega),he k hkn]
    exact hr j hj


lemma height_oscillation_of_reverse_extensions (S : ℕ → ℤ) (a b m : ℕ) (hab : a ≤ b)
    (d : ℤ) (Ra Rb : ℕ → ℤ) (τa τb : ℕ → ℕ)
    (hea : ∀ k, k ≤ a → Ra k=reversedPath S a k)
    (heb : ∀ k, k ≤ b → Rb k=reversedPath S b k)
    (ha : LadderEnumeration Ra τa) (hb : LadderEnumeration Rb τb)
    (hla : d ≤ Ra (τa m)) (hlb : d ≤ Rb (τb m))
    (hosc : ∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b → S u-S v<d) :
    recordHeight S 0 b ≤ recordHeight S 0 a+m ∧
      recordHeight S 0 a ≤ recordHeight S 0 b+m := by
  classical
  obtain ⟨c,hac,hcb,hmin,hfirst⟩ := exists_first_path_minimum S hab
  obtain ⟨hca,hsplit⟩ := recordHeight_at_first_minimum_split S hac hcb hmin hfirst
  have hfall : recordHeight S 0 a-recordHeight S 0 c ≤ m := by
    rw [recordHeight_fall_dual S hac hcb hmin hfirst,
      ← weakRecords_congr_prefix hea]
    have he : ((weakRecords Ra a).filter fun k => reversedPath S a k<S a-S c)=
        ((weakRecords Ra a).filter fun k => Ra k<S a-S c) := by
      apply Finset.filter_congr
      intro k hk
      rw [hea k ((mem_weakRecords ..).mp hk).2.1]
    rw [he]
    exact ha.first_records_below a m (S a-S c) ((hosc a c le_rfl hab hac hcb).le.trans hla)
  have hrise : recordHeight S a b ≤ m := by
    rw [recordHeight_dual,← weakRecords_congr_prefix (fun k hk => heb k (by omega)),hb.card_records]
    by_contra hn
    have hl : τb m ≤ b-a :=
      (le_renewalCount_iff hb.strictMono hb.zero m (b-a)).mp (by omega)
    rw [heb (τb m) (by omega)] at hlb
    have hh := hosc b (b-τb m) hab le_rfl (by omega) (by omega)
    dsimp [reversedPath] at hlb
    omega
  omega


lemma height_oscillation_of_reverse_extensions_real (S : ℕ → ℤ) (a b m : ℕ) (hab : a ≤ b)
    (d : ℝ) (Ra Rb : ℕ → ℤ) (τa τb : ℕ → ℕ)
    (hea : ∀ k, k ≤ a → Ra k=reversedPath S a k)
    (heb : ∀ k, k ≤ b → Rb k=reversedPath S b k)
    (ha : LadderEnumeration Ra τa) (hb : LadderEnumeration Rb τb)
    (hla : d ≤ (Ra (τa m):ℝ)) (hlb : d ≤ (Rb (τb m):ℝ))
    (hosc : ∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b → (S u:ℝ)-(S v:ℝ)<d) :
    recordHeight S 0 b ≤ recordHeight S 0 a+m ∧
      recordHeight S 0 a ≤ recordHeight S 0 b+m := by
  classical
  obtain ⟨c,hac,hcb,hmin,hfirst⟩ := exists_first_path_minimum S hab
  obtain ⟨hca,hsplit⟩ := recordHeight_at_first_minimum_split S hac hcb hmin hfirst
  have hfall : recordHeight S 0 a-recordHeight S 0 c ≤ m := by
    rw [recordHeight_fall_dual S hac hcb hmin hfirst,
      ← weakRecords_congr_prefix hea]
    have he : ((weakRecords Ra a).filter fun k => reversedPath S a k<S a-S c)=
        ((weakRecords Ra a).filter fun k => Ra k<S a-S c) := by
      apply Finset.filter_congr
      intro k hk
      rw [hea k ((mem_weakRecords ..).mp hk).2.1]
    rw [he]
    apply ha.first_records_below a m (S a-S c)
    have hh := (hosc a c le_rfl hab hac hcb).le.trans hla
    exact_mod_cast hh
  have hrise : recordHeight S a b ≤ m := by
    rw [recordHeight_dual,← weakRecords_congr_prefix (fun k hk => heb k (by omega)),hb.card_records]
    by_contra hn
    have hl : τb m ≤ b-a :=
      (le_renewalCount_iff hb.strictMono hb.zero m (b-a)).mp (by omega)
    rw [heb (τb m) (by omega)] at hlb
    have hh := hosc b (b-τb m) hab le_rfl (by omega) (by omega)
    simp only [reversedPath,Int.cast_sub] at hlb
    linarith
  omega


def heightModulusFailure (N m : ℕ) (d : ℝ) : Set (ℕ → ℕ) :=
  {x | ∃ a b, a ≤ b ∧ b ≤ N ∧
    (∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b →
      (integerSum x u:ℝ)-(integerSum x v:ℝ)<d) ∧
    ¬(recordHeight (integerSum x) 0 b ≤ recordHeight (integerSum x) 0 a+m ∧
      recordHeight (integerSum x) 0 a ≤ recordHeight (integerSum x) 0 b+m)}


lemma CriticalEvenOffspring.ae_reverse_ladders (p : CriticalEvenOffspring) :
    ∀ᵐ x ∂p.streamLaw, ∀ b, HasAllLadders (reverseFirst b x) := by
  rw [ae_all_iff]
  intro b
  exact (reverseFirst_preserving p b).quasiMeasurePreserving.ae p.ae_all_ladders


lemma height_modulus_failure_subset {x : ℕ → ℕ} {N m : ℕ} {d : ℝ}
    (hx : ∀ b, HasAllLadders (reverseFirst b x)) (hbad : x ∈ heightModulusFailure N m d) :
    ∃ b ≤ N, renewalLevel m (reverseFirst b x) ≤ d := by
  by_contra hn
  push Not at hn
  obtain ⟨a,b,hab,hb,hosc,hfail⟩ := hbad
  apply hfail
  apply height_oscillation_of_reverse_extensions_real (integerSum x) a b m hab d
    (integerSum (reverseFirst a x)) (integerSum (reverseFirst b x))
    (ladderTime (reverseFirst a x)) (ladderTime (reverseFirst b x))
    (fun k hk => integerSum_reverseFirst x a k hk)
    (fun k hk => integerSum_reverseFirst x b k hk)
    (ladderTime_enumeration (hx a)) (ladderTime_enumeration (hx b))
  · rw [ladderTime_level_real (hx a)]
    exact (hn a (hab.trans hb)).le
  · rw [ladderTime_level_real (hx b)]
    exact (hn b hb).le
  · exact hosc


theorem CriticalEvenOffspring.height_modulus_probability (p : CriticalEvenOffspring) :
    ∃ c ρ : ℝ, 0<c ∧ 0<ρ ∧ ρ<1 ∧ ∀ N m : ℕ,
      p.streamLaw (heightModulusFailure N m (c*m)) ≤
        (N+1:ℕ)*ENNReal.ofReal (ρ^m) := by
  obtain ⟨c,ρ,hc,hr0,hr1,hbound⟩ := p.renewal_lower_tail
  refine ⟨c,ρ,hc,hr0,hr1,fun N m => ?_⟩
  let B := fun b => {x : ℕ → ℕ | renewalLevel m (reverseFirst b x) ≤ c*m}
  have hsub : heightModulusFailure N m (c*m) ≤ᵐ[p.streamLaw]
      ⋃ b ∈ Finset.range (N+1), B b := by
    filter_upwards [p.ae_reverse_ladders] with x hx
    intro hfail
    obtain ⟨b,hb,hbad⟩ := height_modulus_failure_subset hx hfail
    exact Set.mem_iUnion.mpr ⟨b,Set.mem_iUnion.mpr ⟨Finset.mem_range.mpr (by omega),hbad⟩⟩
  apply (measure_mono_ae hsub).trans
  apply (measure_biUnion_finset_le (Finset.range (N+1)) B).trans
  calc
    ∑ b ∈ Finset.range (N+1),p.streamLaw (B b) ≤
        ∑ _b ∈ Finset.range (N+1),ENNReal.ofReal (ρ^m) := by
      apply Finset.sum_le_sum
      intro b _
      have he : B b=reverseFirst b ⁻¹' {x | renewalLevel m x ≤ c*m} := rfl
      rw [he,(reverseFirst_preserving p b).measure_preimage
        (measurableSet_le (measurable_renewalLevel m) measurable_const).nullMeasurableSet]
      exact hbound m
    _ = _ := by simp [nsmul_eq_mul]


lemma conditional_event_bound {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
    {E : Set Ω} (hE : MeasurableSet E) (B : Set Ω) {a : ℝ≥0∞} (hB : μ B ≤ a) :
    cond μ E B ≤ (μ E)⁻¹*a := by
  rw [cond_apply hE]
  exact mul_le_mul le_rfl ((measure_mono Set.inter_subset_right).trans hB) bot_le bot_le


lemma CriticalEvenOffspring.conditional_height_modulus_probability (p : CriticalEvenOffspring) :
    ∃ c ρ : ℝ, 0<c ∧ 0<ρ ∧ ρ<1 ∧ ∀ N m : ℕ,
      ∀ E : Set (ℕ → ℕ), MeasurableSet E →
      cond p.streamLaw E (heightModulusFailure N m (c*m)) ≤
        (p.streamLaw E)⁻¹*((N+1:ℕ)*ENNReal.ofReal (ρ^m)) := by
  obtain ⟨c,ρ,hc,hr0,hr1,hb⟩ := p.height_modulus_probability
  exact ⟨c,ρ,hc,hr0,hr1,fun N m E hE => conditional_event_bound p.streamLaw hE _ (hb N m)⟩


def standardExcursion {Ω : Type} (B : Fin 3 → ℝ≥0 → Ω → ℝ) (ω : Ω)
    (t : unitInterval) : ℝ :=
  Real.sqrt (∑ i : Fin 3, (B i ⟨(t : ℝ), t.property.1⟩ ω -
    (t : ℝ) * B i 1 ω) ^ 2)


def diagonalExcursion {Ω : Type} (B : Fin 3 → ℝ≥0 → Ω → ℝ) (ω : Ω) :
    C(unitInterval, ℝ × ℝ) := by
  classical
  exact if h : Continuous (standardExcursion B ω) then
    (⟨standardExcursion B ω, h⟩ : C(unitInterval, ℝ)).prodMk ⟨standardExcursion B ω, h⟩
  else 0


def jointBrownianExpectation {Ω : Type} [MeasurableSpace Ω] (P : Measure Ω)
    (B : Fin 3 → ℝ≥0 → Ω → ℝ) (F : C(unitInterval, ℝ × ℝ) → ℝ) : ℝ :=
  ∫ ω, F (diagonalExcursion B ω) ∂P


def JointCodingStatement (p : CriticalEvenOffspring) : Prop :=
  ∀ (Ω : Type) (mΩ : MeasurableSpace Ω) (P : @Measure Ω mΩ),
    @IsProbabilityMeasure Ω mΩ P →
    ∀ B : Fin 3 → ℝ≥0 → Ω → ℝ,
      (∀ i, @IsBrownianReal Ω mΩ (B i) P) →
      @iIndepFun Ω (Fin 3) mΩ (fun _ => ℝ≥0 → ℝ) (fun _ => inferInstance)
        (fun i ω t => B i t ω) P →
      ∀ F : BoundedContinuousFunction C(unitInterval, ℝ × ℝ) ℝ,
        Tendsto (fun n : ℕ => codeExpectation p (2*n+1) F) atTop
          (𝓝 (@jointBrownianExpectation Ω mΩ P B F))


def circularReversePath (S : ℕ → ℤ) (N v k : ℕ) : ℤ :=
  if k ≤ v then S v-S (v-k) else S v-1-S (N+v-k)


lemma circularReversePath_prefix (S : ℕ → ℤ) (N v k : ℕ) (hk : k ≤ v) :
    circularReversePath S N v k=reversedPath S v k := by
  simp only [circularReversePath,ite_eq_left hk,reversedPath]


lemma circular_records_of_good {S : ℕ → ℤ} {N v : ℕ} (hv : v<N)
    (hzero : S 0=0) (hpos : ∀ k, k<N → 0 ≤ S k) :
    weakRecords (circularReversePath S N v) N=weakRecords (reversedPath S v) v := by
  ext k
  simp only [mem_weakRecords]
  constructor
  · rintro ⟨hk1,hkN,hrec⟩
    have hkv : k ≤ v := by
      by_contra hn
      have hh := hrec v (by omega)
      simp only [circularReversePath,ite_eq_left le_rfl,Nat.sub_self,hzero,sub_zero,
        ite_eq_right (show ¬k ≤ v from hn)] at hh
      have hh' := hpos (N+v-k) (by omega)
      omega
    refine ⟨hk1,hkv,?_⟩
    intro j hj
    simpa only [circularReversePath_prefix _ _ _ _ (hj.trans hkv),
      circularReversePath_prefix _ _ _ _ hkv] using hrec j hj
  · rintro ⟨hk1,hkv,hrec⟩
    refine ⟨hk1,hkv.trans hv.le,?_⟩
    intro j hj
    simpa only [circularReversePath_prefix _ _ _ _ (hj.trans hkv),
      circularReversePath_prefix _ _ _ _ hkv] using hrec j hj


lemma circular_record_height_of_good {S : ℕ → ℤ} {N v : ℕ} (hv : v<N)
    (hzero : S 0=0) (hpos : ∀ k, k<N → 0 ≤ S k) :
    (weakRecords (circularReversePath S N v) N).card=recordHeight S 0 v := by
  rw [circular_records_of_good hv hzero hpos,recordHeight_dual,Nat.sub_zero]


lemma circular_maximum_of_good {S : ℕ → ℤ} {N v : ℕ} (hv : v<N)
    (hzero : S 0=0) (hpos : ∀ k, k<N → 0 ≤ S k) :
    circularReversePath S N v v=S v ∧
      ∀ k, k ≤ N → circularReversePath S N v k ≤ S v := by
  constructor
  · simp [circularReversePath,hzero]
  · intro k hk
    by_cases hkv : k ≤ v
    · simp only [circularReversePath,ite_eq_left hkv]
      have := hpos (v-k) (by omega)
      omega
    · simp only [circularReversePath,ite_eq_right hkv]
      have := hpos (N+v-k) (by omega)
      omega


lemma height_eq_recordHeight {N : ℕ} (d : Fin N → Fin N) {j : ℕ} (hj : j ≤ N) :
    height d j=recordHeight (walk d) 0 j := by
  classical
  unfold height recordHeight
  apply Finset.card_bij (fun k _ => k.val)
  · intro k hk
    obtain ⟨_,hkj,hrec⟩ := Finset.mem_filter.mp hk
    apply (mem_reverseRecords ..).mpr
    refine ⟨Nat.zero_le _,hkj,?_⟩
    intro r hkr hrj
    exact hrec ⟨r,by omega⟩ hkr hrj
  · intro k _ l _ he
    exact Fin.ext he
  · intro k hk
    obtain ⟨_,hkj,hrec⟩ := (mem_reverseRecords ..).mp hk
    refine ⟨⟨k,by omega⟩,?_,rfl⟩
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,hkj,fun r hr hjr => hrec r.val hr hjr⟩


lemma walk_rotate_left {N : ℕ} [NeZero N] (m : Fin N) (d : Fin N → Fin N)
    {j : ℕ} (hj : j ≤ N-m.val) :
    walk (rotateDegrees m d) j=walk d (m.val+j)-walk d m.val := by
  rw [← degreeList_prefixSum,degreeList_rotate,
    prefixSum_rotate_left _ (by simp) (by simpa using hj),
    degreeList_prefixSum,degreeList_prefixSum]


lemma walk_rotate_right {N : ℕ} [NeZero N] (m : Fin N) (d : Fin N → Fin N)
    {j : ℕ} (hj : N-m.val ≤ j) (hjN : j ≤ N) :
    walk (rotateDegrees m d) j=walk d N-walk d m.val+walk d (j-(N-m.val)) := by
  rw [← degreeList_prefixSum,degreeList_rotate,
    prefixSum_rotate_right _ (by simp) (by simpa using hj) (by simpa using hjN),
    degreeList_sum,degreeList_prefixSum,degreeList_length,degreeList_prefixSum]


lemma circular_reverse_rotate {N : ℕ} [NeZero N] (d : Bridge N) (v : Fin N)
    {k : ℕ} (hk : k ≤ N) :
    reversedPath (walk (rotateBridge v d).val) N k=
      circularReversePath (walk d.val) N v.val k := by
  change walk (rotateDegrees v d.val) N-walk (rotateDegrees v d.val) (N-k)=_
  rw [walk_rotate_terminal]
  by_cases hkv : k ≤ v.val
  · rw [walk_rotate_right v d.val (by omega) (by omega)]
    have he : N-k-(N-v.val)=v.val-k := by omega
    simp only [circularReversePath,ite_eq_left hkv,he]
    omega
  · rw [walk_rotate_left v d.val (by omega)]
    have he : v.val+(N-k)=N+v.val-k := by omega
    simp only [circularReversePath,ite_eq_right hkv,he]
    rw [d.property]
    omega


lemma rotated_code_reverse_records {N : ℕ} [NeZero N] (d : Code N) (v : Fin N) :
    (weakRecords (reversedPath (walk (rotateDegrees v d.val)) N) N).card=height d.val v.val := by
  have he : ∀ k, k ≤ N → reversedPath (walk (rotateDegrees v d.val)) N k=
      circularReversePath (walk d.val) N v.val k :=
    fun k hk => circular_reverse_rotate (⟨d.val,d.property.1⟩ : Bridge N) v hk
  rw [weakRecords_congr_prefix he,
    circular_record_height_of_good v.isLt (walk_zero d.val) d.property.2,
    height_eq_recordHeight d.val v.isLt.le]


def prefixMaximum (S : ℕ → ℤ) (N : ℕ) : ℤ :=
  (Finset.range (N+1)).sup' Finset.nonempty_range_add_one S


lemma prefixMaximum_congr {S T : ℕ → ℤ} {N : ℕ} (h : ∀ k, k ≤ N → S k=T k) :
    prefixMaximum S N=prefixMaximum T N := by
  unfold prefixMaximum
  apply Finset.sup'_congr _ rfl
  intro k hk
  exact h k (by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hk)


lemma prefixMaximum_eq {S : ℕ → ℤ} {N v : ℕ} (hv : v ≤ N)
    (h : ∀ k, k ≤ N → S k ≤ S v) : prefixMaximum S N=S v := by
  apply le_antisymm
  · exact Finset.sup'_le _ _ (fun k hk => h k (by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hk))
  · exact Finset.le_sup' S (Finset.mem_range.mpr (by omega))


lemma rotated_code_reverse_maximum {N : ℕ} [NeZero N] (d : Code N) (v : Fin N) :
    prefixMaximum (reversedPath (walk (rotateDegrees v d.val)) N) N=walk d.val v.val := by
  have hp : ∀ k, k ≤ N → reversedPath (walk (rotateDegrees v d.val)) N k=
      circularReversePath (walk d.val) N v.val k :=
    fun k hk => circular_reverse_rotate (⟨d.val,d.property.1⟩ : Bridge N) v hk
  rw [prefixMaximum_congr hp]
  obtain ⟨he,hmax⟩ := circular_maximum_of_good v.isLt (walk_zero d.val) d.property.2
  rw [← he]
  exact prefixMaximum_eq v.isLt.le (by simpa only [he] using hmax)


lemma rotation_sum_invariant {N : ℕ} [NeZero N] (G : Bridge N → ℝ) (d : Bridge N) (m : Fin N) :
    (∑ v : Fin N,G (rotateBridge v (rotateBridge m d)))=
      ∑ v : Fin N,G (rotateBridge v d) := by
  simp_rw [rotateBridge_add]
  exact Equiv.sum_comp (Equiv.addRight m) (fun v => G (rotateBridge v d))


lemma canonical_rotation_sum {N : ℕ} [NeZero N] (G : Bridge N → ℝ) (d : Bridge N) :
    (∑ v : Fin N,G (rotateBridge v ⟨(canonicalCode d).val,(canonicalCode d).property.1⟩))=
      ∑ v : Fin N,G (rotateBridge v d) := by
  exact rotation_sum_invariant G d (goodRotation d)


theorem uniform_vertex_cyclic_identity (p : CriticalEvenOffspring) (n : ℕ)
    (G : Bridge (2*n+1) → ℝ) :
    (∑ d : Code (2*n+1), (codeWeight p d/codePartition p (2*n+1)) *
      ((∑ v : Fin (2*n+1),G (rotateBridge v ⟨d.val,d.property.1⟩))/(2*n+1)))=
    ∑ d : Bridge (2*n+1),(bridgeWeight p d/bridgePartition p (2*n+1))*G d := by
  let N := 2*n+1
  let : NeZero N := ⟨by dsimp [N]; omega⟩
  rw [← canonicalCode_expectation p n]
  simp_rw [canonical_rotation_sum,Finset.sum_div,Finset.mul_sum]
  rw [Finset.sum_comm]
  have hrow (v : Fin N) :
      (∑ d : Bridge N,(bridgeWeight p d/bridgePartition p N)*(G (rotateBridge v d)/(N:ℝ)))=
        (∑ d : Bridge N,(bridgeWeight p d/bridgePartition p N)*G d)/(N:ℝ) := by
    simp_rw [← mul_div_assoc]
    rw [← Finset.sum_div]
    congr 1
    calc
      _ = ∑ d : Bridge N,(bridgeWeight p (rotateBridge v d)/bridgePartition p N)*G (rotateBridge v d) := by
        simp only [bridgeWeight_rotate]
      _ = _ := Equiv.sum_comp (rotateBridge v) (fun d : Bridge N => (bridgeWeight p d/bridgePartition p N)*G d)
  have hNR : (2*(n:ℝ)+1)=(N:ℝ) := by dsimp [N]; push_cast; rfl
  rw [hNR]
  change (∑ v : Fin N, ∑ d : Bridge N,
    (bridgeWeight p d/bridgePartition p N)*(G (rotateBridge v d)/(N:ℝ)))=_
  simp_rw [hrow]
  simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
  exact mul_div_cancel₀ _ (by dsimp [N]; positivity : (N:ℝ)≠0)


theorem uniform_vertex_height_error (p : CriticalEvenOffspring) (n : ℕ) (ν a : ℝ) :
    (∑ d : Code (2*n+1), (codeWeight p d/codePartition p (2*n+1)) *
      ((∑ v : Fin (2*n+1), if a < |(walk d.val v.val:ℝ)-ν*height d.val v.val| then (1:ℝ) else 0)/(2*n+1)))=
    ∑ d : Bridge (2*n+1),(bridgeWeight p d/bridgePartition p (2*n+1))*
      (if a < |(prefixMaximum (reversedPath (walk d.val) (2*n+1)) (2*n+1):ℝ)-
        ν*(weakRecords (reversedPath (walk d.val) (2*n+1)) (2*n+1)).card| then (1:ℝ) else 0) := by
  classical
  let G : Bridge (2*n+1) → ℝ := fun d =>
    if a < |(prefixMaximum (reversedPath (walk d.val) (2*n+1)) (2*n+1):ℝ)-
      ν*(weakRecords (reversedPath (walk d.val) (2*n+1)) (2*n+1)).card| then 1 else 0
  have he : ∀ d : Code (2*n+1), ∀ v : Fin (2*n+1),
      G (rotateBridge v ⟨d.val,d.property.1⟩)=
        if a < |(walk d.val v.val:ℝ)-ν*height d.val v.val| then 1 else 0 := by
    intro d v
    change (if a < |(prefixMaximum (reversedPath (walk (rotateDegrees v d.val)) (2*n+1)) (2*n+1):ℝ)-
      ν*(weakRecords (reversedPath (walk (rotateDegrees v d.val)) (2*n+1)) (2*n+1)).card| then 1 else 0)=_
    rw [rotated_code_reverse_records d v,rotated_code_reverse_maximum d v]
  simpa only [he] using uniform_vertex_cyclic_identity p n G


def CriticalEvenOffspring.bridgeFourier (p : CriticalEvenOffspring) (n : ℕ) (t : ℝ) : ℂ :=
  p.fourierCutoff n t * Complex.exp ((t / (p.sigma * Real.sqrt (n+1)) : ℝ) * Complex.I)


lemma integral_standard_gaussian_complex :
    (∫ t : ℝ, Complex.exp (-(t : ℂ)^2/2)) = (Real.sqrt (2 * Real.pi) : ℂ) := by
  have heq (t : ℝ) : Complex.exp (-(t : ℂ)^2/2) =
      (Real.exp (-(1/2 : ℝ)*t^2) : ℂ) := by
    rw [Complex.ofReal_exp]
    congr 1
    push_cast
    ring
  simp_rw [heq]
  rw [integral_complex_ofReal, integral_gaussian]
  congr 2
  ring


lemma CriticalEvenOffspring.bridgeFourier_limit (p : CriticalEvenOffspring) :
    Tendsto (fun n : ℕ => ∫ t : ℝ, p.bridgeFourier n t) atTop
      (𝓝 (Real.sqrt (2 * Real.pi) : ℂ)) := by
  obtain ⟨c, hc, hg⟩ := p.charFun_global_gaussian
  have hden : Tendsto (fun n : ℕ => p.sigma * Real.sqrt (n+1)) atTop atTop :=
    (Real.tendsto_sqrt_atTop.comp
      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)).const_mul_atTop
        p.sigma_pos
  have hp (t : ℝ) : Tendsto (fun n => p.bridgeFourier n t) atTop
      (𝓝 (Complex.exp (-(t : ℂ)^2/2))) := by
    have hr : Tendsto (fun n : ℕ => t / (p.sigma * Real.sqrt (n+1))) atTop (𝓝 0) :=
      tendsto_const_nhds.div_atTop hden
    have he := ((Complex.continuous_ofReal.tendsto 0).comp hr).mul_const Complex.I
    have hex := Complex.continuous_exp.tendsto 0 |>.comp (by simpa using he)
    simpa [bridgeFourier] using (p.cutoff_pointwise t).mul hex
  have hm (n : ℕ) : AEStronglyMeasurable (p.bridgeFourier n) volume := by
    exact ((p.cutoff_measurable n).mul (by fun_prop)).aestronglyMeasurable
  have hn (n : ℕ) : ∀ᵐ t ∂volume, ‖p.bridgeFourier n t‖ ≤ Real.exp (-c*t^2) := by
    apply ae_of_all
    intro t
    simpa only [bridgeFourier, norm_mul, Complex.norm_exp_ofReal_mul_I, mul_one] using
      p.cutoff_gaussian_bound hg n t
  have hi := tendsto_integral_of_dominated_convergence (μ := volume)
    (fun t : ℝ => Real.exp (-c*t^2)) hm (integrable_exp_neg_mul_sq hc) hn
      (ae_of_all _ hp)
  simpa only [integral_standard_gaussian_complex] using hi


lemma CriticalEvenOffspring.bridgeFourier_integral (p : CriticalEvenOffspring) (n : ℕ) :
    (∫ t : ℝ, p.bridgeFourier n t) =
      (p.sigma * Real.sqrt (n+1)) •
        ∫ t : ℝ in -(Real.pi/2)..Real.pi/2,
          Complex.exp ((t : ℂ) * Complex.I) *
            (charFun (p.law.toMeasure.map p.standardStep) (p.sigma * t))^(n+1) := by
  let A := (p.sigma * Real.pi / 2) * Real.sqrt (n+1)
  let scale := p.sigma * Real.sqrt (n+1)
  let f : ℝ → ℂ := fun t =>
    (charFun (p.law.toMeasure.map p.standardStep) (t / Real.sqrt (n+1)))^(n+1) *
      Complex.exp ((t / scale : ℝ) * Complex.I)
  have hsqrt : 0 < Real.sqrt (n+1 : ℝ) := Real.sqrt_pos.mpr (by positivity)
  have hscale : 0 < scale := mul_pos p.sigma_pos hsqrt
  have hA : 0 ≤ A := mul_nonneg
    (div_nonneg (mul_nonneg p.sigma_pos.le Real.pi_pos.le) (by norm_num)) hsqrt.le
  have heq : p.bridgeFourier n = (Icc (-A) A).indicator f := by
    ext t
    simp only [bridgeFourier, fourierCutoff, Set.indicator_apply, mem_Icc, ← abs_le]
    split_ifs <;> simp [f, scale]
  rw [heq, integral_indicator measurableSet_Icc, integral_Icc_eq_integral_Ioc,
    ← intervalIntegral.integral_of_le (neg_le_self hA)]
  have hlo : -(Real.pi/2) * scale = -A := by dsimp [scale, A]; ring
  have hhi : (Real.pi/2) * scale = A := by dsimp [scale, A]; ring
  have hsub := intervalIntegral.smul_integral_comp_mul_right
    (a := -(Real.pi/2)) (b := Real.pi/2) f scale
  rw [hlo, hhi] at hsub
  rw [← hsub]
  congr 1
  apply intervalIntegral.integral_congr
  intro t _
  dsimp [f]
  rw [mul_div_cancel_right₀ _ hscale.ne']
  have ht : t * scale / Real.sqrt (n+1) = p.sigma * t := by
    dsimp [scale]
    field_simp
  rw [ht, mul_comm]


lemma CriticalEvenOffspring.bridgeFourier_partition (p : CriticalEvenOffspring) (n : ℕ) :
    (∫ t : ℝ, p.bridgeFourier (2*n) t) =
      (p.sigma * Real.sqrt (2*n+1) * Real.pi * bridgePartition p (2*n+1) : ℝ) := by
  have hpar : Even (((2*n+1 : ℕ) : ℤ) + (-1)) := by
    refine ⟨n, ?_⟩
    push_cast
    ring
  have hi := spanTwo_inversion (p.iidLaw (2*n+1)) totalStep
    (totalStep_measurable _) (-1) (p.iid_totalStep_parity _ hpar)
  simp only [Int.cast_neg, Int.cast_one, neg_neg, one_mul, p.iid_charFun] at hi
  rw [p.bridgeFourier_integral, hi, ← p.bridgePartition_eq_iid]
  simp only [Complex.real_smul, Complex.ofReal_mul]
  push_cast
  ring


lemma CriticalEvenOffspring.bridgePartition_limit (p : CriticalEvenOffspring) :
    Tendsto (fun n : ℕ => Real.sqrt (2*n+1) * bridgePartition p (2*n+1)) atTop
      (𝓝 (Real.sqrt (2*Real.pi) / (p.sigma * Real.pi))) := by
  have hsub : Tendsto (fun n : ℕ => 2*n) atTop atTop :=
    tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id
  have h := Complex.continuous_re.continuousAt.tendsto.comp
    (p.bridgeFourier_limit.comp hsub)
  change Tendsto (fun n : ℕ => (∫ t : ℝ, p.bridgeFourier (2*n) t).re)
    atTop (𝓝 (Real.sqrt (2*Real.pi))) at h
  simp only [p.bridgeFourier_partition, Complex.ofReal_re] at h
  have hdiv := h.div_const (p.sigma * Real.pi)
  convert hdiv using 1
  ext n
  have hs := p.sigma_pos.ne'
  have hpi := Real.pi_pos.ne'
  field_simp


theorem CriticalEvenOffspring.codePartition_asymptotic (p : CriticalEvenOffspring) :
    Tendsto (fun n : ℕ => (2*n+1 : ℝ) * Real.sqrt (2*n+1) *
      codePartition p (2*n+1)) atTop (𝓝 (2 / (p.sigma * Real.sqrt (2*Real.pi)))) := by
  have hc : Real.sqrt (2*Real.pi) / (p.sigma * Real.pi) =
      2 / (p.sigma * Real.sqrt (2*Real.pi)) := by
    have hsq := Real.sq_sqrt (show 0 ≤ 2*Real.pi by positivity)
    have hsp : 0 < Real.sqrt (2*Real.pi) := Real.sqrt_pos.mpr (by positivity)
    field_simp [p.sigma_pos.ne', Real.pi_pos.ne', hsp.ne']
    nlinarith
  rw [← hc]
  convert p.bridgePartition_limit using 1
  ext n
  rw [codePartition_cyclic p (by omega)]
  push_cast
  ring


def CriticalEvenOffspring.squareTail (p : CriticalEvenOffspring) (R : ℝ) : ℝ :=
  ∑' k : ℕ, if R < (k : ℝ) then (k : ℝ)^2 * p.mass k else 0


lemma CriticalEvenOffspring.squareTail_tendsto (p : CriticalEvenOffspring) :
    Tendsto p.squareTail atTop (𝓝 0) := by
  have h := tendsto_tsum_of_dominated_convergence p.second
    (f := fun R : ℝ => fun k : ℕ => if R < (k : ℝ) then (k : ℝ)^2 * p.mass k else 0)
    (g := fun _ => (0 : ℝ)) (𝓕 := atTop) ?_ ?_
  · change Tendsto (fun R : ℝ => ∑' k : ℕ,
      if R < (k : ℝ) then (k : ℝ)^2 * p.mass k else 0) atTop (𝓝 0)
    simpa only [tsum_apply, tsum_zero] using h
  · intro k
    apply tendsto_const_nhds.congr'
    filter_upwards [eventually_ge_atTop (k : ℝ)] with R hR
    simp [not_lt.mpr hR]
  · apply Eventually.of_forall
    intro R k
    split_ifs
    · rw [Real.norm_of_nonneg (mul_nonneg (sq_nonneg _) (p.nonneg k))]
    · simp [mul_nonneg (sq_nonneg _) (p.nonneg k)]


lemma CriticalEvenOffspring.squareTail_bound (p : CriticalEvenOffspring)
    (R : ℝ) (hR : 0 ≤ R) :
    R^2 * p.law.toMeasure.real {k | R < (k : ℝ)} ≤ p.squareTail R := by
  rw [p.law_real_set, ← tsum_mul_left]
  simp only [Set.indicator_apply, Set.mem_ofPred_eq]
  have hs : Summable (fun k : ℕ => if R < (k : ℝ) then p.mass k else 0) :=
    p.total.summable.of_nonneg_of_le
      (fun k => by split_ifs <;> simp [p.nonneg])
      (fun k => by split_ifs <;> simp [p.nonneg])
  have hs₂ : Summable (fun k : ℕ => if R < (k : ℝ) then (k : ℝ)^2 * p.mass k else 0) :=
    p.second.of_nonneg_of_le
      (fun k => by split_ifs <;> simp [mul_nonneg (sq_nonneg _) (p.nonneg k)])
      (fun k => by split_ifs <;> simp [mul_nonneg (sq_nonneg _) (p.nonneg k)])
  apply Summable.tsum_le_tsum _ (hs.mul_left _) hs₂
  intro k
  split_ifs with hk
  · exact mul_le_mul_of_nonneg_right
      ((sq_le_sq₀ hR (Nat.cast_nonneg k)).mpr hk.le) (p.nonneg k)
  · simp


theorem CriticalEvenOffspring.sqrt_tail_small (p : CriticalEvenOffspring)
    (ε : ℝ) (hε : 0 < ε) :
    Tendsto (fun n : ℕ => (n+1 : ℝ) *
      p.law.toMeasure.real {k | ε * Real.sqrt (n+1) < (k : ℝ)}) atTop (𝓝 0) := by
  have hR : Tendsto (fun n : ℕ => ε * Real.sqrt (n+1)) atTop atTop :=
    (Real.tendsto_sqrt_atTop.comp
      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)).const_mul_atTop hε
  have hlim := (p.squareTail_tendsto.comp hR).div_const (ε^2)
  simp only [zero_div] at hlim
  refine squeeze_zero (fun n => by positivity) (fun n => ?_) hlim
  rw [le_div_iff₀ (sq_pos_of_pos hε)]
  have h := p.squareTail_bound (ε * Real.sqrt (n+1)) (by positivity)
  rw [mul_pow, Real.sq_sqrt (by positivity)] at h
  dsimp only [Function.comp_apply] at *
  nlinarith


noncomputable def codeEventMass (p : CriticalEvenOffspring) (N : ℕ)
    (E : (Fin N → Fin N) → Prop) : ℝ := by
  classical
  exact ∑ d : Code N, if E d.val then codeWeight p d else 0


noncomputable def bridgeEventMass (p : CriticalEvenOffspring) (N : ℕ)
    (E : (Fin N → Fin N) → Prop) : ℝ := by
  classical
  exact ∑ d : Bridge N, if E d.val then bridgeWeight p d else 0


theorem codeEventMass_cyclic (p : CriticalEvenOffspring) {N : ℕ} [NeZero N]
    (E : (Fin N → Fin N) → Prop)
    (hE : ∀ (m : Fin N) d, E (rotateDegrees m d) ↔ E d) :
    bridgeEventMass p N E = (N : ℝ) * codeEventMass p N E := by
  classical
  have h := weighted_unique_rotation (rotateBridge (N := N))
    (fun d => if E d.val then bridgeWeight p d else 0)
    (fun d => IsTreeCode d.val)
    (fun m d => by
      change (if E (rotateDegrees m d.val) then bridgeWeight p (rotateBridge m d) else 0) = _
      rw [hE, bridgeWeight_rotate])
    (fun d => d.unique_good_rotation)
  rw [Fintype.card_fin] at h
  change (∑ d : Bridge N, if E d.val then bridgeWeight p d else 0) = _
  rw [h]
  congr 1
  rw [← Finset.sum_filter]
  unfold codeEventMass
  rw [Finset.sum_subtype (p := fun d : Bridge N => IsTreeCode d.val) _ (by simp)]
  let e : Code N ≃ {d : Bridge N // IsTreeCode d.val} := {
    toFun := fun d => ⟨⟨d.val, d.property.1⟩, d.property⟩
    invFun := fun d => ⟨d.val.val, d.property⟩
    left_inv := fun _ => rfl
    right_inv := fun _ => rfl }
  exact (Equiv.sum_comp e (fun d => if E d.val.val then bridgeWeight p d.val else 0)).symm


lemma CriticalEvenOffspring.bridgeEventMass_eq_iid (p : CriticalEvenOffspring)
    (N : ℕ) (E : (Fin N → ℕ) → Prop) :
    bridgeEventMass p N (fun d => E (fun i => (d i).val)) =
      (p.iidLaw N).real {d | totalStep d = -1 ∧ E d} := by
  classical
  let s : Bridge N → Set (Fin N → ℕ) := fun b =>
    if E (bridgeEmbedding N b) then {bridgeEmbedding N b} else ∅
  have hset : {d : Fin N → ℕ | totalStep d = -1 ∧ E d} = ⋃ b, s b := by
    ext d
    constructor
    · rintro ⟨h₁, h₂⟩
      have hr : d ∈ Set.range (bridgeEmbedding N) := by
        rw [← totalStep_bridge_range]
        exact h₁
      obtain ⟨b, rfl⟩ := hr
      exact mem_iUnion.mpr ⟨b, by simp [s, h₂]⟩
    · intro hd
      obtain ⟨b, hb⟩ := mem_iUnion.mp hd
      dsimp [s] at hb
      split_ifs at hb with hE
      · have heq : d = bridgeEmbedding N b := hb
        exact ⟨heq ▸ totalStep_bridge b, heq ▸ hE⟩
      · exact hb.elim
  have hd : Pairwise (fun b c => Disjoint (s b) (s c)) := by
    intro b c hbc
    dsimp [s]
    split_ifs
    · exact Set.disjoint_singleton.mpr ((bridgeEmbedding N).injective.ne hbc)
    all_goals simp
  have hm (b : Bridge N) : MeasurableSet (s b) := by dsimp [s]; split_ifs <;> measurability
  rw [hset, measureReal_iUnion_fintype hd hm]
  unfold bridgeEventMass
  apply Finset.sum_congr rfl
  intro b _
  change (if E (bridgeEmbedding N b) then bridgeWeight p b else 0) = _
  dsimp [s]
  split_ifs
  · exact (p.iid_bridge_singleton b).symm
  · simp


def codeEventProbability (p : CriticalEvenOffspring) (N : ℕ)
    (E : (Fin N → Fin N) → Prop) : ℝ :=
  codeEventMass p N E / codePartition p N


lemma codeEventProbability_eq_bridge (p : CriticalEvenOffspring) {N : ℕ} (hN : 0 < N)
    (E : (Fin N → Fin N) → Prop)
    (hE : letI : NeZero N := ⟨hN.ne'⟩
      ∀ (m : Fin N) d, E (rotateDegrees m d) ↔ E d) :
    codeEventProbability p N E = bridgeEventMass p N E / bridgePartition p N := by
  let : NeZero N := ⟨hN.ne'⟩
  rw [codeEventMass_cyclic p E hE, codePartition_cyclic p hN, mul_div_mul_left]
  · rfl
  · exact_mod_cast hN.ne'


lemma maxDegree_rotation {N : ℕ} [NeZero N] (R : ℝ) (m : Fin N)
    (d : Fin N → Fin N) :
    (∃ i, R < ((rotateDegrees m d i).val : ℝ)) ↔ ∃ i, R < ((d i).val : ℝ) := by
  change (∃ i, R < ((d (i+m)).val : ℝ)) ↔ _
  constructor
  · rintro ⟨i, hi⟩
    exact ⟨i+m, hi⟩
  · rintro ⟨i, hi⟩
    exact ⟨i-m, by simpa using hi⟩


lemma code_max_probability_eq_iid (p : CriticalEvenOffspring) {N : ℕ} (hN : 0 < N)
    (R : ℝ) :
    codeEventProbability p N (fun d => ∃ i, R < ((d i).val : ℝ)) =
      (p.iidLaw N).real {d | (∃ i, R < (d i : ℝ)) ∧ totalStep d = -1} /
        (p.iidLaw N).real {d | totalStep d = -1} := by
  let : NeZero N := ⟨hN.ne'⟩
  rw [codeEventProbability_eq_bridge p hN _ (by
    intro m d
    exact maxDegree_rotation R m d), p.bridgePartition_eq_iid,
    p.bridgeEventMass_eq_iid N (fun d => ∃ i, R < (d i : ℝ))]
  congr 2
  ext d
  exact and_comm


theorem CriticalEvenOffspring.conditioned_max_degree (p : CriticalEvenOffspring)
    (ε : ℝ) (hε : 0 < ε) :
    Tendsto (fun n : ℕ => codeEventProbability p (2*n+1)
      (fun d => ∃ i, ε * Real.sqrt (2*n+1) < ((d i).val : ℝ))) atTop (𝓝 0) := by
  obtain ⟨C, hCpos, hC⟩ := p.iid_site_uniform_bound
  have hsub : Tendsto (fun n : ℕ => 2*n+2) atTop atTop :=
    tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id
  have htail := (p.sqrt_tail_small ε hε).comp hsub
  have hnum : Tendsto (fun n : ℕ => Real.sqrt (2*n+3) *
      (p.iidLaw (2*n+3)).real
        {d | (∃ i, ε * Real.sqrt (2*n+3) < (d i : ℝ)) ∧ totalStep d = -1})
      atTop (𝓝 0) := by
    have hupper := htail.const_mul (2*C)
    simp only [mul_zero] at hupper
    simp only [Function.comp_apply, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat,
      add_assoc, show (2:ℝ)+1=3 by norm_num] at hupper
    apply squeeze_zero (fun n => by positivity) (fun n => ?_) hupper
    have hb := p.iid_max_tail_bound hC (2*n+1) (ε * Real.sqrt (2*n+3)) (-1)
    have hs : Real.sqrt (2*n+3) ≤ 2 * Real.sqrt (2*n+2) := by
      have h₁ := Real.sq_sqrt (show 0 ≤ (2*n+3 : ℝ) by positivity)
      have h₂ := Real.sq_sqrt (show 0 ≤ (2*n+2 : ℝ) by positivity)
      have hn : (0 : ℝ) ≤ n := Nat.cast_nonneg _
      nlinarith [Real.sqrt_nonneg (2*n+3), Real.sqrt_nonneg (2*n+2)]
    have hh := mul_le_mul_of_nonneg_right hs
      (show 0 ≤ (p.iidLaw (2*n+3)).real
        {d | (∃ i, ε * Real.sqrt (2*n+3) < (d i : ℝ)) ∧ totalStep d = -1} from
          measureReal_nonneg)
    norm_num [Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, add_assoc] at hb
    nlinarith
  have hden := p.bridgePartition_limit.comp (tendsto_add_atTop_nat 1)
  have hden' : Tendsto (fun n : ℕ => Real.sqrt (2*n+3) *
      (p.iidLaw (2*n+3)).real {d | totalStep d = -1}) atTop
      (𝓝 (Real.sqrt (2*Real.pi) / (p.sigma * Real.pi))) := by
    convert hden using 1
    ext n
    dsimp only [Function.comp_apply]
    rw [p.bridgePartition_eq_iid]
    congr 2; push_cast; ring
  have hB : Real.sqrt (2*Real.pi) / (p.sigma * Real.pi) ≠ 0 := by
    exact ne_of_gt (div_pos (Real.sqrt_pos.mpr (by positivity))
      (mul_pos p.sigma_pos Real.pi_pos))
  have hratio := hnum.div hden' hB
  simp only [zero_div] at hratio
  apply (tendsto_add_atTop_iff_nat 1).mp
  convert hratio using 1
  ext n
  dsimp only [Pi.div_apply]
  rw [code_max_probability_eq_iid p (by omega), mul_div_mul_left]
  · congr 2; push_cast; ring_nf; rfl
  · exact (Real.sqrt_pos.mpr (by positivity)).ne'


lemma CriticalEvenOffspring.iid_fixed_site_limit (p : CriticalEvenOffspring)
    (m : ℕ → ℕ) (hm : Tendsto m atTop atTop) (j : ℤ)
    (hpar : ∀ n, Even (((m n+1:ℕ):ℤ)+j)) :
    Tendsto (fun n : ℕ => Real.sqrt (m n+1) *
      (p.iidLaw (m n+1)).real {d | totalStep d = j}) atTop
      (𝓝 (Real.sqrt (2*Real.pi)/(p.sigma*Real.pi))) := by
  obtain ⟨E, _, hE, hbound⟩ := p.uniform_local_limit
  have herr : Tendsto (fun n : ℕ =>
      |Real.sqrt (m n+1) * (p.iidLaw (m n+1)).real {d | totalStep d = j} -
        (Real.sqrt (2*Real.pi)/(p.sigma*Real.pi)) *
        Real.exp (-((j:ℝ)/(p.sigma*Real.sqrt (m n+1)))^2/2)|) atTop (𝓝 0) :=
    squeeze_zero (fun _ => abs_nonneg _) (fun n => hbound (m n) j (hpar n)) (hE.comp hm)
  have hden : Tendsto (fun n : ℕ => p.sigma * Real.sqrt (m n+1)) atTop atTop :=
    ((Real.tendsto_sqrt_atTop.comp
      (tendsto_atTop_add_const_right atTop 1 tendsto_natCast_atTop_atTop)).comp hm).const_mul_atTop
      p.sigma_pos
  have hz : Tendsto (fun n : ℕ => (j:ℝ)/(p.sigma*Real.sqrt (m n+1))) atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop hden
  have hg := (Real.continuous_exp.continuousAt.tendsto.comp
    ((hz.pow 2).neg.div_const 2)).const_mul
    (Real.sqrt (2*Real.pi)/(p.sigma*Real.pi))
  simp only [zero_pow (by norm_num : 2 ≠ 0), neg_zero, zero_div, Real.exp_zero,
    mul_one] at hg
  have hd : Tendsto (fun n : ℕ =>
      Real.sqrt (m n+1) * (p.iidLaw (m n+1)).real {d | totalStep d = j} -
        (Real.sqrt (2*Real.pi)/(p.sigma*Real.pi)) *
        Real.exp (-((j:ℝ)/(p.sigma*Real.sqrt (m n+1)))^2/2)) atTop (𝓝 0) :=
    tendsto_zero_iff_norm_tendsto_zero.mpr (by simpa only [Real.norm_eq_abs] using herr)
  simpa only [Function.comp_apply, sub_add_cancel, zero_add] using hd.add hg


lemma sqrt_affine_ratio_limit (a b : ℝ) (hb : 0 < b) :
    Tendsto (fun n : ℕ => Real.sqrt (2*n+a) / Real.sqrt (2*n+b)) atTop (𝓝 1) := by
  have hden : Tendsto (fun n : ℕ => (2*n+b : ℝ)) atTop atTop :=
    tendsto_atTop_add_const_right atTop b
      (tendsto_natCast_atTop_atTop.const_mul_atTop (by norm_num : (0:ℝ)<2))
  have hz : Tendsto (fun n : ℕ => (a-b)/(2*n+b)) atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop hden
  have hh := ((tendsto_const_nhds (x := (1:ℝ))).add hz).sqrt
  have heq (n : ℕ) : (1:ℝ)+(a-b)/(2*n+b) = (2*n+a)/(2*n+b) := by
    have hb' : 2*(n:ℝ)+b ≠ 0 := ne_of_gt (by positivity)
    field_simp [hb']
    ring
  simp only [heq, add_zero, Real.sqrt_one] at hh
  have hsq (n : ℕ) : Real.sqrt ((2*n+a)/(2*n+b)) =
      Real.sqrt (2*n+a) / Real.sqrt (2*n+b) :=
    Real.sqrt_div' _ (by positivity)
  simpa only [hsq] using hh


lemma CriticalEvenOffspring.bridge_coordinate_limit (p : CriticalEvenOffspring) (k : ℕ) :
    Tendsto (fun n : ℕ =>
      (p.iidLaw (2*n+3)).real {d | d 0 = k ∧ totalStep d = -1} /
        (p.iidLaw (2*n+3)).real {d | totalStep d = -1}) atTop (𝓝 (p.mass k)) := by
  by_cases hk : Even k
  · have hd := p.iid_fixed_site_limit (fun n => 2*n+2)
      (tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id) (-1) (by
        intro n
        refine ⟨n+1, ?_⟩
        push_cast
        ring)
    have hn := p.iid_fixed_site_limit (fun n => 2*n+1)
      (tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id) (-(k:ℤ)) (by
        intro n
        have hk' : Even (k:ℤ) := by exact_mod_cast hk
        obtain ⟨r, hr⟩ := hk'
        refine ⟨(n:ℤ)+1-r, ?_⟩
        push_cast
        rw [hr]
        ring)
    have hc : Real.sqrt (2*Real.pi)/(p.sigma*Real.pi) ≠ 0 := by
      exact (div_pos (Real.sqrt_pos.mpr (by positivity))
        (mul_pos p.sigma_pos Real.pi_pos)).ne'
    have hr := (hn.div hd hc).mul (sqrt_affine_ratio_limit 3 2 (by norm_num))
    have hr' := hr.const_mul (p.mass k)
    simp only [div_self hc, mul_one] at hr'
    convert hr' using 1
    ext n
    rw [p.iid_coordinate_site (2*n+2)]
    have hs : -1 - ((k:ℤ)-1) = -(k:ℤ) := by omega
    rw [hs]
    dsimp only [Pi.div_apply]
    norm_num [Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, add_assoc]
    have hs₂ : Real.sqrt (2*n+2) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
    have hs₃ : Real.sqrt (2*n+3) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
    field_simp [hs₂, hs₃]
  · have hk0 := p.even_support k (Nat.not_even_iff_odd.mp hk)
    rw [hk0]
    convert tendsto_const_nhds (x := (0:ℝ)) using 1
    ext n
    rw [p.iid_coordinate_site (2*n+2), hk0]
    simp


lemma CriticalEvenOffspring.iid_pair_site (p : CriticalEvenOffspring)
    (N : ℕ) (i : Fin (N+2)) (i' : Fin (N+1)) (k l : ℕ) (j : ℤ) :
    (p.iidLaw (N+2)).real
      {d | d i = k ∧ d (i.succAbove i') = l ∧ totalStep d = j} =
      p.mass k * p.mass l *
        (p.iidLaw N).real {d | totalStep d = j - ((k : ℤ)-1) - ((l : ℤ)-1)} := by
  let e := MeasurableEquiv.piFinSuccAbove (fun _ : Fin (N+2) => ℕ) i
  have hp : MeasurePreserving e (p.iidLaw (N+2))
      (p.law.toMeasure.prod (p.iidLaw (N+1))) :=
    measurePreserving_piFinSuccAbove (fun _ => p.law.toMeasure) i
  have hset : {d : Fin (N+2) → ℕ | d i = k ∧ d (i.succAbove i') = l ∧ totalStep d = j} =
      e ⁻¹' (({k} : Set ℕ) ×ˢ
        {d : Fin (N+1) → ℕ | d i' = l ∧ totalStep d = j - ((k : ℤ) - 1)}) := by
    ext d
    change (d i = k ∧ d (i.succAbove i') = l ∧ totalStep d = j) ↔
      (d i = k ∧ d (i.succAbove i') = l ∧
        totalStep (fun a => d (i.succAbove a)) = j - ((k : ℤ) - 1))
    rw [totalStep_succAbove d i]
    constructor <;> rintro ⟨h₁, h₂, h₃⟩ <;> refine ⟨h₁, h₂, ?_⟩ <;>
      rw [h₁] at * <;> omega
  rw [measureReal_def, hset, hp.measure_preimage (by measurability),
    Measure.prod_prod, ENNReal.toReal_mul, p.law_singleton,
    ENNReal.toReal_ofReal (p.nonneg _)]
  change p.mass k * (p.iidLaw (N+1)).real _ = _
  rw [p.iid_coordinate_site]
  ring


lemma CriticalEvenOffspring.bridge_coordinate_limit_any (p : CriticalEvenOffspring)
    (k : ℕ) (i : ∀ n, Fin (2*n+3)) :
    Tendsto (fun n : ℕ =>
      (p.iidLaw (2*n+3)).real {d | d (i n) = k ∧ totalStep d = -1} /
        (p.iidLaw (2*n+3)).real {d | totalStep d = -1}) atTop (𝓝 (p.mass k)) := by
  convert p.bridge_coordinate_limit k using 1
  ext n
  rw [p.iid_coordinate_site (2*n+2), p.iid_coordinate_site (2*n+2)]


lemma CriticalEvenOffspring.bridge_pair_limit (p : CriticalEvenOffspring)
    (k l : ℕ) (i : ∀ n, Fin (2*n+5)) (i' : ∀ n, Fin (2*n+4)) :
    Tendsto (fun n : ℕ =>
      (p.iidLaw (2*n+5)).real
        {d | d (i n) = k ∧ d ((i n).succAbove (i' n)) = l ∧ totalStep d = -1} /
        (p.iidLaw (2*n+5)).real {d | totalStep d = -1}) atTop (𝓝 (p.mass k * p.mass l)) := by
  by_cases hk : Even k
  · by_cases hl : Even l
    · have hd := p.iid_fixed_site_limit (fun n => 2*n+4)
        (tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id) (-1) (by
          intro n
          refine ⟨(n:ℤ)+2, ?_⟩
          push_cast
          ring)
      have hn := p.iid_fixed_site_limit (fun n => 2*n+2)
        (tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id)
        (1-(k:ℤ)-(l:ℤ)) (by
          intro n
          have hk' : Even (k:ℤ) := by exact_mod_cast hk
          have hl' : Even (l:ℤ) := by exact_mod_cast hl
          obtain ⟨r, hr⟩ := hk'
          obtain ⟨s, hs⟩ := hl'
          refine ⟨(n:ℤ)+2-r-s, ?_⟩
          push_cast
          rw [hr, hs]
          ring)
      have hc : Real.sqrt (2*Real.pi)/(p.sigma*Real.pi) ≠ 0 := by
        exact (div_pos (Real.sqrt_pos.mpr (by positivity))
          (mul_pos p.sigma_pos Real.pi_pos)).ne'
      have hr := (hn.div hd hc).mul (sqrt_affine_ratio_limit 5 3 (by norm_num))
      have hr' := hr.const_mul (p.mass k * p.mass l)
      simp only [div_self hc, mul_one] at hr'
      convert hr' using 1
      ext n
      rw [p.iid_pair_site (2*n+3)]
      have hs : -1 - ((k:ℤ)-1) - ((l:ℤ)-1) = 1-(k:ℤ)-(l:ℤ) := by omega
      rw [hs]
      dsimp only [Pi.div_apply]
      norm_num [Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat, add_assoc]
      have hs₃ : Real.sqrt (2*n+3) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
      have hs₅ : Real.sqrt (2*n+5) ≠ 0 := (Real.sqrt_pos.mpr (by positivity)).ne'
      field_simp [hs₃, hs₅]
    · have hl0 := p.even_support l (Nat.not_even_iff_odd.mp hl)
      rw [hl0, mul_zero]
      convert tendsto_const_nhds (x := (0:ℝ)) using 1
      ext n
      rw [p.iid_pair_site (2*n+3), hl0]
      simp
  · have hk0 := p.even_support k (Nat.not_even_iff_odd.mp hk)
    rw [hk0, zero_mul]
    convert tendsto_const_nhds (x := (0:ℝ)) using 1
    ext n
    rw [p.iid_pair_site (2*n+3), hk0]
    simp

end FKCRT.TreeCoding
end

end OAI