math / data /lean /OAI /Probability /FKMaps /HeightCoding.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
49.2 kB
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
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)