lean/OAI/Probability/FKMaps/ExcursionKernel.lean

import OAI.Probability.FKMaps.SimpleWalk

namespace OAI

noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.Histogram
variable {ι : Type*} [Fintype ι]

def cube (δ : ℝ) (a : ι → ℝ) : Set (ι → ℝ) := pi univ (fun i => Ico (a i) (a i+δ))

lemma measurableSet_cube (δ : ℝ) (a : ι → ℝ) : MeasurableSet (cube δ a) :=
  MeasurableSet.pi (Set.to_countable _) (fun _ _ => measurableSet_Ico)

lemma volume_cube (δ : ℝ) (a : ι → ℝ) :
    volume (cube δ a)=ENNReal.ofReal δ ^ Fintype.card ι := by
  rw [cube,volume_pi,Measure.pi_pi]
  simp

lemma mem_cube_dist {δ : ℝ} {a x : ι → ℝ} (hδ : 0≤δ) (hx : x∈cube δ a) : dist x a≤δ := by
  apply (dist_pi_le_iff hδ).mpr
  intro i
  have hi := hx i (mem_univ i)
  rw [Real.dist_eq]
  exact abs_le.mpr ⟨by linarith [hi.1],by linarith [hi.2]⟩

def boxLaw (δ : ℝ) (a : ι → ℝ) : Measure (ι → ℝ) :=
  (ENNReal.ofReal δ ^ Fintype.card ι)⁻¹ • volume.restrict (cube δ a)

lemma boxLaw_probability {δ : ℝ} (hδ : 0<δ) (a : ι → ℝ) :
    IsProbabilityMeasure (boxLaw δ a) := by
  constructor
  simp only [boxLaw,Measure.smul_apply,Measure.restrict_apply_univ,smul_eq_mul,volume_cube]
  exact ENNReal.inv_mul_cancel (pow_ne_zero _ (ne_of_gt (ENNReal.ofReal_pos.mpr hδ)))
    (ENNReal.pow_ne_top ENNReal.ofReal_ne_top)

lemma boxLaw_dist {δ : ℝ} (hδ : 0≤δ) (a : ι → ℝ) :
    ∀ᵐ x ∂boxLaw δ a, dist x a≤δ := by
  apply Measure.ae_smul_measure
  filter_upwards [ae_restrict_mem (measurableSet_cube δ a)] with x hx
  exact mem_cube_dist hδ hx

lemma boxLaw_withDensity (δ : ℝ) (a : ι → ℝ) :
    boxLaw δ a=volume.withDensity ((cube δ a).indicator
      (fun _ => (ENNReal.ofReal δ ^ Fintype.card ι)⁻¹)) := by
  rw [withDensity_indicator (measurableSet_cube δ a),withDensity_const]
  rfl

end FKCRT.Histogram
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.Histogram
variable {ι Ω : Type*} [Fintype ι] [Fintype Ω] [MeasurableSpace Ω]
  [MeasurableSingletonClass Ω]

def mixture (μ : Measure Ω) (φ : Ω → ι → ℝ) (δ : ℝ) : Measure (ι → ℝ) :=
  ∑ ω, μ {ω} • boxLaw δ (φ ω)

lemma mixture_probability (μ : Measure Ω) [IsProbabilityMeasure μ]
    (φ : Ω → ι → ℝ) {δ : ℝ} (hδ : 0<δ) :
    IsProbabilityMeasure (mixture μ φ δ) := by
  have (ω : Ω) : IsProbabilityMeasure (boxLaw δ (φ ω)) := boxLaw_probability hδ (φ ω)
  constructor
  simp only [mixture,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul,
    measure_univ,mul_one]
  rw [sum_measure_singleton,Finset.coe_univ,measure_univ]

def density (μ : Measure Ω) (φ : Ω → ι → ℝ) (δ : ℝ) (x : ι → ℝ) : ℝ≥0∞ :=
  ∑ ω,μ {ω} * (cube δ (φ ω)).indicator
    (fun _ => (ENNReal.ofReal δ ^ Fintype.card ι)⁻¹) x

omit [MeasurableSingletonClass Ω] in
lemma measurable_density (μ : Measure Ω) (φ : Ω → ι → ℝ) (δ : ℝ) :
    Measurable (density μ φ δ) := by
  apply Finset.measurable_sum
  intro ω hω
  exact measurable_const.mul (measurable_const.indicator (measurableSet_cube δ (φ ω)))

omit [MeasurableSingletonClass Ω] in
lemma mixture_withDensity (μ : Measure Ω) (φ : Ω → ι → ℝ) (δ : ℝ) :
    mixture μ φ δ=volume.withDensity (density μ φ δ) := by
  ext s hs
  rw [withDensity_apply _ hs]
  simp only [mixture,Measure.finsetSum_apply,density]
  have hm (ω : Ω) : Measurable (fun x : ι → ℝ => μ {ω} * (cube δ (φ ω)).indicator
      (fun _ => (ENNReal.ofReal δ ^ Fintype.card ι)⁻¹) x) :=
    measurable_const.mul (measurable_const.indicator (measurableSet_cube δ (φ ω)))
  rw [lintegral_finsetSum _ (fun ω _ => hm ω)]
  apply Finset.sum_congr rfl
  intro ω _
  rw [Measure.smul_apply,smul_eq_mul,boxLaw_withDensity,
    withDensity_apply _ hs,lintegral_const_mul _
      (measurable_const.indicator (measurableSet_cube δ (φ ω)))]

omit [MeasurableSingletonClass Ω] in
lemma integral_mixture (μ : Measure Ω) [IsProbabilityMeasure μ]
    (φ : Ω → ι → ℝ) {δ : ℝ} (hδ : 0<δ) (F : BoundedContinuousFunction (ι → ℝ) ℝ) :
    (∫ x,F x ∂mixture μ φ δ)=∑ ω,(μ {ω}).toReal * ∫ x,F x ∂boxLaw δ (φ ω) := by
  have (ω : Ω) : IsProbabilityMeasure (boxLaw δ (φ ω)) := boxLaw_probability hδ (φ ω)
  have hi (ω : Ω) : Integrable F (μ {ω} • boxLaw δ (φ ω)) := by
    exact (F.integrable (boxLaw δ (φ ω))).smul_measure (measure_ne_top _ _)
  rw [mixture,integral_finsetSum_measure (fun ω _ => hi ω)]
  simp only [integral_smul_measure,smul_eq_mul]

lemma box_integral_lipschitz {δ : ℝ} (hδ : 0<δ) (a : ι → ℝ)
    (F : BoundedContinuousFunction (ι → ℝ) ℝ) {L : ℝ≥0} (hF : LipschitzWith L F) :
    |(∫ x,F x ∂boxLaw δ a)-F a|≤L*δ := by
  have := boxLaw_probability hδ a
  have hconst : (∫ x,F a ∂boxLaw δ a)=F a := by simp
  rw [← hconst,← integral_sub (F.integrable _) (integrable_const _)]
  apply abs_integral_le_integral_abs.trans
  calc
    (∫ x,|F x-F a| ∂boxLaw δ a) ≤ ∫ x,(L:ℝ)*δ ∂boxLaw δ a := by
      apply integral_mono_ae ((F.integrable _).sub (integrable_const _)).abs (integrable_const _)
      filter_upwards [boxLaw_dist hδ.le a] with x hx
      exact (hF.dist_le_mul x a).trans (mul_le_mul_of_nonneg_left hx L.coe_nonneg)
    _ = _ := by simp

lemma integral_mixture_close (μ : Measure Ω) [IsProbabilityMeasure μ]
    (φ : Ω → ι → ℝ) {δ : ℝ} (hδ : 0<δ)
    (F : BoundedContinuousFunction (ι → ℝ) ℝ) {L : ℝ≥0} (hF : LipschitzWith L F) :
    |(∫ x,F x ∂mixture μ φ δ)-(∫ ω,F (φ ω) ∂μ)|≤L*δ := by
  have hi : Integrable (fun ω => F (φ ω)) μ := Integrable.of_finite
  rw [integral_mixture μ φ hδ F,integral_fintype hi,← Finset.sum_sub_distrib]
  calc
    _ ≤ ∑ ω,|(μ {ω}).toReal * (∫ x,F x ∂boxLaw δ (φ ω)) - μ.real {ω} • F (φ ω)| :=
      Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ ω,(μ {ω}).toReal*((L:ℝ)*δ) := by
      apply Finset.sum_le_sum
      intro ω _
      rw [smul_eq_mul,measureReal_def,← mul_sub,abs_mul,abs_of_nonneg ENNReal.toReal_nonneg]
      exact mul_le_mul_of_nonneg_left (box_integral_lipschitz hδ (φ ω) F hF) ENNReal.toReal_nonneg
    _ = _ := by
      rw [← Finset.sum_mul,← ENNReal.toReal_sum (fun _ _ => measure_ne_top _ _),
        sum_measure_singleton,Finset.coe_univ,measure_univ,ENNReal.toReal_one,one_mul]

end FKCRT.Histogram
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.Histogram
variable {ι Ω : Type*} [Fintype ι] [Fintype Ω] [MeasurableSpace Ω]
  [MeasurableSingletonClass Ω]

omit [Fintype ι] in
lemma mem_lattice_cube {δ : ℝ} (hδ : 0<δ) (a : ι → ℕ) {x : ι → ℝ}
    (hx : ∀ i,0≤x i) : x∈cube δ (fun i => δ*(a i:ℝ))↔a=fun i => ⌊x i/δ⌋₊ := by
  constructor
  · intro h
    apply funext
    intro i
    have hi := h i (mem_univ i)
    symm
    apply (Nat.floor_eq_iff (div_nonneg (hx i) hδ.le)).mpr
    constructor
    · exact (le_div_iff₀ hδ).mpr (by simpa only [mul_comm] using hi.1)
    · apply (div_lt_iff₀ hδ).mpr
      simpa only [add_mul,mul_add,one_mul,mul_one,mul_comm] using hi.2
  · rintro rfl
    intro i _
    have hfloor := (Nat.floor_eq_iff (div_nonneg (hx i) hδ.le)).mp (rfl : ⌊x i/δ⌋₊=⌊x i/δ⌋₊)
    constructor
    · simpa only [mul_comm] using (le_div_iff₀ hδ).mp hfloor.1
    · simpa only [add_mul,mul_add,one_mul,mul_one,mul_comm] using (div_lt_iff₀ hδ).mp hfloor.2

lemma density_lattice (μ : Measure Ω) (a : Ω → ι → ℕ) {δ : ℝ} (hδ : 0<δ)
    {x : ι → ℝ} (hx : ∀ i,0≤x i) :
    density μ (fun ω i => δ*(a ω i:ℝ)) δ x=
      μ {ω | a ω=fun i => ⌊x i/δ⌋₊}*(ENNReal.ofReal δ ^ Fintype.card ι)⁻¹ := by
  classical
  let s : Finset Ω := Finset.univ.filter (fun ω => a ω=fun i => ⌊x i/δ⌋₊)
  have hset : (s : Set Ω)={ω | a ω=fun i => ⌊x i/δ⌋₊} := by ext ω; simp [s]
  rw [density,← hset,← sum_measure_singleton,Finset.sum_mul]
  simp only [s,Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro ω _
  by_cases h : a ω=fun i => ⌊x i/δ⌋₊
  · rw [ite_eq_left h,indicator_of_mem ((mem_lattice_cube hδ _ hx).mpr h)]
  · rw [ite_eq_right h,indicator_of_notMem (mt (mem_lattice_cube hδ _ hx).mp h),mul_zero]

omit [MeasurableSingletonClass Ω] in
lemma density_lattice_negative (μ : Measure Ω) (a : Ω → ι → ℕ) {δ : ℝ}
    (hδ : 0≤δ) {x : ι → ℝ} (hx : ∃ i,x i<0) :
    density μ (fun ω i => δ*(a ω i:ℝ)) δ x=0 := by
  obtain ⟨i,hi⟩ := hx
  apply Finset.sum_eq_zero
  intro ω _
  have hn : x∉cube δ (fun i => δ*(a ω i:ℝ)) := by
    intro h
    have hh := (h i (mem_univ i)).1
    have hz : 0≤δ*(a ω i:ℝ) := mul_nonneg hδ (Nat.cast_nonneg _)
    linarith
  rw [indicator_of_notMem hn,mul_zero]

lemma floor_mesh_tendsto {δ : ℕ → ℝ} (hδ : ∀ n,0<δ n)
    (hlim : Tendsto δ atTop (𝓝 0)) {x : ℝ} (hx : 0≤x) :
    Tendsto (fun n => δ n*(⌊x/δ n⌋₊:ℝ)) atTop (𝓝 x) := by
  have hl (n : ℕ) := Nat.floor_le (div_nonneg hx (hδ n).le)
  have hu (n : ℕ) := Nat.lt_floor_add_one (x/δ n)
  have hlow : Tendsto (fun n => x-δ n) atTop (𝓝 x) := by
    simpa only [sub_zero] using tendsto_const_nhds.sub hlim
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le hlow tendsto_const_nhds
  · intro n
    have h := (div_lt_iff₀ (hδ n)).mp (hu n)
    nlinarith
  · intro n
    simpa only [mul_comm] using (le_div_iff₀ (hδ n)).mp (hl n)

end FKCRT.Histogram
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.SimpleWalk
attribute [local instance] Classical.propDecidable

def located : List (ℕ×ℕ) → List (ℕ×ℕ)
  | [] => []
  | x::xs => x::(located xs).map (fun y => (x.1+y.1,y.2))

def observed {N : ℕ} (a : ℕ) (xs : List (ℕ×ℕ)) (d : Path N) : Prop :=
  ∀ x∈located xs,(a:ℤ)+pathSum d x.1=x.2

lemma tracePoints_observed (a R : ℕ) (xs : List (ℕ×ℕ)) (d : Path (traceSize R xs)) :
    tracePoints a R xs d↔observed a xs d := by
  induction xs generalizing a with
  | nil => simp [tracePoints,observed,located]
  | cons x xs ih =>
    obtain ⟨⟨d,e⟩,rfl⟩ := (splitPathAt x.1 (traceSize R xs)).symm.surjective d
    simp only [tracePoints,Equiv.apply_symm_apply,ih,observed,located,List.mem_cons,
      List.mem_map,forall_eq_or_imp,forall_exists_index,and_imp,forall_apply_eq_imp_iff₂]
    change ((a:ℤ)+pathSum d x.1=x.2 ∧
      ∀ y∈located xs,(x.2:ℤ)+pathSum e y.1=y.2)↔
      ((a:ℤ)+pathSum (Fin.append d e) x.1=x.2 ∧
      ∀ y∈located xs,(a:ℤ)+pathSum (Fin.append d e) (x.1+y.1)=y.2)
    simp only [pathSum_append_left d e le_rfl,pathSum_append_right]
    constructor <;> rintro ⟨hx,hxs⟩ <;> refine ⟨hx,?_⟩ <;> intro y hy
    · have h := hxs y hy; linarith
    · have h := hxs y hy; linarith

lemma pathMass_firstHit_observed (a R : ℕ) (xs : List (ℕ×ℕ)) :
    pathMass (traceSize R xs) (fun d => firstHit a d ∧ observed a xs d)=
      traceKilledWeight a R xs := by
  rw [← pathMass_traceExcursion]
  apply pathMass_congr
  intro d
  rw [traceExcursion_iff,tracePoints_observed]

lemma traceSize_eq_sum (R : ℕ) (xs : List (ℕ×ℕ)) :
    traceSize R xs=(xs.map Prod.fst).sum+R := by
  induction xs with
  | nil => simp [traceSize]
  | cons x xs ih => simp [traceSize,ih,Nat.add_assoc]

lemma pathSum_cast {N M : ℕ} (h : N=M) (d : Path N) (k : ℕ) :
    pathSum (fun i : Fin M => d (Fin.cast h.symm i)) k=pathSum d k := by
  subst M
  rfl

lemma pathMass_cast {N M : ℕ} (h : N=M) (P : Path M → Prop) :
    pathMass N (fun d => P (fun i : Fin M => d (Fin.cast h.symm i)))=pathMass M P := by
  subst M
  rfl

end FKCRT.SimpleWalk
end


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

/-- Even grid time immediately below t, for the odd duration 2n+1. -/
def evenGrid (n : ℕ) (t : ℝ) : ℕ := 2*⌊((2*n+1:ℕ):ℝ)*t/2⌋₊

lemma even_evenGrid (n : ℕ) (t : ℝ) : Even (evenGrid n t) := even_two_mul _

lemma evenGrid_mono (n : ℕ) {s t : ℝ} (h : s≤t) : evenGrid n s≤evenGrid n t := by
  unfold evenGrid
  exact Nat.mul_le_mul_left _ (Nat.floor_mono (div_le_div_of_nonneg_right
    (mul_le_mul_of_nonneg_left h (Nat.cast_nonneg _)) (by norm_num)))

@[simp] lemma evenGrid_zero (n : ℕ) : evenGrid n 0=0 := by simp [evenGrid]

lemma evenGrid_le (n : ℕ) {t : ℝ} (ht : t≤1) : evenGrid n t≤2*n := by
  have h : ((2*n+1:ℕ):ℝ)*t/2<(n:ℝ)+1 := by
    have he := mul_le_mul_of_nonneg_left ht (Nat.cast_nonneg (2*n+1) : (0:ℝ)≤(2*n+1:ℕ))
    push_cast at he ⊢
    linarith
  have hh : ⌊((2*n+1:ℕ):ℝ)*t/2⌋₊≤n := (Nat.floor_lt' (by omega : n+1≠0)).mpr
    (by exact_mod_cast h) |> Nat.le_of_lt_succ
  exact Nat.mul_le_mul_left 2 hh

lemma evenGrid_error (n : ℕ) {t : ℝ} (ht : 0≤t) :
    0≤((2*n+1:ℕ):ℝ)*t-(evenGrid n t:ℝ) ∧
    ((2*n+1:ℕ):ℝ)*t-(evenGrid n t:ℝ)<2 := by
  have hnonneg : 0≤((2*n+1:ℕ):ℝ)*t/2 := by positivity
  have hl := Nat.floor_le hnonneg
  have hu := Nat.lt_floor_add_one (((2*n+1:ℕ):ℝ)*t/2)
  unfold evenGrid
  push_cast at hl hu ⊢
  constructor <;> linarith

lemma evenGrid_ratio (t : ℝ) (ht : 0≤t) :
    Tendsto (fun n => (evenGrid n t:ℝ)/((2*n+1:ℕ):ℝ)) atTop (𝓝 t) := by
  have hN : Tendsto (fun n : ℕ => ((2*n+1:ℕ):ℝ)) atTop atTop :=
    tendsto_natCast_atTop_atTop.comp (tendsto_atTop_mono (fun n => by show n≤2*n+1; omega) tendsto_id)
  have hzero : Tendsto (fun n => (2:ℝ)/((2*n+1:ℕ):ℝ)) atTop (𝓝 0) :=
    tendsto_const_nhds.div_atTop hN
  have hl : Tendsto (fun n => t-2/((2*n+1:ℕ):ℝ)) atTop (𝓝 t) := by
    simpa using tendsto_const_nhds.sub hzero
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le hl tendsto_const_nhds
  · intro n
    have hpos : 0<((2*n+1:ℕ):ℝ) := by positivity
    have he := (evenGrid_error n ht).2
    apply (le_div_iff₀ hpos).mpr
    rw [sub_mul,div_mul_cancel₀ _ hpos.ne']
    linarith
  · intro n
    exact (div_le_iff₀ (by positivity : 0<((2*n+1:ℕ):ℝ))).mpr
      (by have h := (evenGrid_error n ht).1; linarith)

/-- Successive durations at a deterministic increasing list of observation times. -/
def gridDurations {m : ℕ} (u : Fin (m+1) → unitInterval) (n : ℕ) (i : Fin m) : ℕ :=
  evenGrid n (u i.succ)-evenGrid n (u i.castSucc)

def gridRemainder {m : ℕ} (u : Fin (m+1) → unitInterval) (n : ℕ) : ℕ :=
  2*n-evenGrid n (u (Fin.last m))

lemma gridDurations_even {m : ℕ} (u : Fin (m+1) → unitInterval) (hu : Monotone u)
    (n : ℕ) (i : Fin m) : Even (gridDurations u n i) := by
  exact (Nat.even_sub (evenGrid_mono n (hu i.castSucc_lt_succ.le))).mpr
    (iff_of_true (even_evenGrid n _) (even_evenGrid n _))

lemma gridRemainder_even {m : ℕ} (u : Fin (m+1) → unitInterval) (n : ℕ) :
    Even (gridRemainder u n) :=
  (Nat.even_sub (evenGrid_le n (u (Fin.last m)).property.2)).mpr
    (iff_of_true (even_two_mul n) (even_evenGrid n _))

lemma gridDurations_ratio {m : ℕ} (u : Fin (m+1) → unitInterval) (hu : Monotone u)
    (i : Fin m) :
    Tendsto (fun n => (gridDurations u n i:ℝ)/((2*n+1:ℕ):ℝ)) atTop
      (𝓝 ((u i.succ:ℝ)-(u i.castSucc:ℝ))) := by
  have h := (evenGrid_ratio (u i.succ) (u i.succ).property.1).sub
    (evenGrid_ratio (u i.castSucc) (u i.castSucc).property.1)
  apply h.congr'
  exact Filter.Eventually.of_forall (fun n => by
    dsimp only [gridDurations]
    rw [Nat.cast_sub (evenGrid_mono n (hu i.castSucc_lt_succ.le)),sub_div])

end FKCRT.SimpleWalk
end


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

/-- The heat density for one-dimensional standard Brownian motion. -/
def heat (t x : ℝ) : ℝ := Real.exp (-x^2/(2*t))/Real.sqrt (2*Real.pi*t)

lemma heat_pos {t : ℝ} (ht : 0<t) (x : ℝ) : 0<heat t x := by
  exact div_pos (Real.exp_pos _) (Real.sqrt_pos.mpr (by positivity))

lemma heat_continuousOn : ContinuousOn (fun tx : ℝ×ℝ => heat tx.1 tx.2) {tx | 0<tx.1} := by
  intro tx htx
  change 0<tx.1 at htx
  unfold heat
  have h1 : 2*tx.1≠0 := by positivity
  have h2 : Real.sqrt (2*Real.pi*tx.1)≠0 := by positivity
  apply ContinuousAt.continuousWithinAt
  fun_prop (disch := assumption)

/-- Full span-two uniform local limit, now for the explicitly reflected simple kernel. -/
theorem kernel_uniform_local_limit :
    ∃ E : ℕ → ℝ, (∀ n,0≤E n) ∧ Tendsto E atTop (𝓝 0) ∧
      ∀ (N : ℕ), 0<N → ∀ z : ℤ, Even ((N:ℤ)+z) →
        |Real.sqrt N*kernel N z-(Real.sqrt (2*Real.pi)/Real.pi)*
          Real.exp (-((z:ℝ)/Real.sqrt N)^2/2)|≤E N := by
  obtain ⟨E,hE,hEt,h⟩ := binaryOffspring.uniform_local_limit
  have hsub : Tendsto (fun n : ℕ => n-1) atTop atTop := by
    apply tendsto_atTop.mpr
    intro b
    exact eventually_atTop.mpr ⟨b+1,fun n hn => by omega⟩
  refine ⟨fun N => E (N-1),fun N => hE _,hEt.comp hsub,?_⟩
  intro N hN z hz
  have hn : N-1+1=N := by omega
  have hnR : ((N-1:ℕ):ℝ)+1=(N:ℝ) := by exact_mod_cast hn
  simpa only [hn,hnR,binary_kernel,binaryOffspring_sigma,one_mul] using h (N-1) z (by simpa only [hn] using hz)

lemma kernel_local_limit {N : ℕ → ℕ} {z : ℕ → ℤ} {x : ℝ}
    (hN : Tendsto N atTop atTop)
    (hz : ∀ᶠ n in atTop,Even ((N n:ℤ)+z n))
    (hx : Tendsto (fun n => (z n:ℝ)/Real.sqrt (N n:ℝ)) atTop (𝓝 x)) :
    Tendsto (fun n => Real.sqrt (N n:ℝ)*kernel (N n) (z n)) atTop
      (𝓝 ((Real.sqrt (2*Real.pi)/Real.pi)*Real.exp (-x^2/2))) := by
  obtain ⟨E,_hE,hEt,hE⟩ := kernel_uniform_local_limit
  have hmodel := ((Real.continuous_exp.tendsto (-x^2/2)).comp ((hx.pow 2).neg.div_const 2)).const_mul
      (Real.sqrt (2*Real.pi)/Real.pi)
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
    (show Tendsto (fun n => (Real.sqrt (2*Real.pi)/Real.pi)*
      Real.exp (-((z n:ℝ)/Real.sqrt (N n:ℝ))^2/2)-E (N n)) atTop _ by
      simpa using hmodel.sub (hEt.comp hN))
    (show Tendsto (fun n => (Real.sqrt (2*Real.pi)/Real.pi)*
      Real.exp (-((z n:ℝ)/Real.sqrt (N n:ℝ))^2/2)+E (N n)) atTop _ by
      simpa using hmodel.add (hEt.comp hN))
  · filter_upwards [hz,hN.eventually (eventually_gt_atTop 0)] with n hn hnn
    have hh := (abs_le.mp (hE (N n) hnn (z n) hn)).1
    linarith
  · filter_upwards [hz,hN.eventually (eventually_gt_atTop 0)] with n hn hnn
    have hh := (abs_le.mp (hE (N n) hnn (z n) hn)).2
    linarith

lemma sqrt_ratio_tendsto {N T : ℕ → ℕ} {t : ℝ}
    (hr : Tendsto (fun n => (N n:ℝ)/(T n:ℝ)) atTop (𝓝 t)) :
    Tendsto (fun n => Real.sqrt (N n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 (Real.sqrt t)) := by
  simpa only [Function.comp_def,Real.sqrt_div (Nat.cast_nonneg _)] using Real.continuous_sqrt.tendsto t |>.comp hr

/-- Kernel limit at arbitrary macroscopic times and spatial lattice sites. -/
theorem kernel_scaled_limit {N T : ℕ → ℕ} {z : ℕ → ℤ} {t x : ℝ}
    (ht : 0<t) (hN : Tendsto N atTop atTop) (hT : Tendsto T atTop atTop)
    (hr : Tendsto (fun n => (N n:ℝ)/(T n:ℝ)) atTop (𝓝 t))
    (hz : ∀ᶠ n in atTop,Even ((N n:ℤ)+z n))
    (hx : Tendsto (fun n => (z n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 x)) :
    Tendsto (fun n => Real.sqrt (T n:ℝ)*kernel (N n) (z n)) atTop (𝓝 (2*heat t x)) := by
  have hs := sqrt_ratio_tendsto hr
  have ht' : 0<Real.sqrt t := Real.sqrt_pos.mpr ht
  have hz' : Tendsto (fun n => (z n:ℝ)/Real.sqrt (N n:ℝ)) atTop (𝓝 (x/Real.sqrt t)) := by
    apply (hx.div hs (ne_of_gt ht')).congr'
    filter_upwards [hT.eventually (eventually_gt_atTop 0),hN.eventually (eventually_gt_atTop 0)] with n hn hnn
    have htp : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hn))
    have hnp : Real.sqrt (N n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hnn))
    dsimp only [Pi.div_apply]
    field_simp
  have hc := (kernel_local_limit hN hz hz').div hs (ne_of_gt ht')
  have hm : ((Real.sqrt (2*Real.pi)/Real.pi)*Real.exp (-(x/Real.sqrt t)^2/2))/Real.sqrt t=2*heat t x := by
    rw [heat,div_pow,Real.sq_sqrt ht.le,Real.sqrt_mul (by positivity : 0≤2*Real.pi)]
    have hpi : Real.sqrt (2*Real.pi)^2=2*Real.pi := Real.sq_sqrt (by positivity)
    have hpis : Real.sqrt (2*Real.pi)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by positivity))
    have harg : -(x^2/t)/2= -x^2/(2*t) := by ring
    rw [harg]
    field_simp
    nlinarith
  rw [hm] at hc
  apply hc.congr'
  filter_upwards [hN.eventually (eventually_gt_atTop 0),hT.eventually (eventually_gt_atTop 0)] with n hn hnt
  have hnp : Real.sqrt (N n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hn))
  have htp : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hnt))
  dsimp only [Pi.div_apply]
  field_simp

end FKCRT.SimpleWalk
end


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

lemma cast_div_sqrt_tendsto_zero {T : ℕ → ℕ} (hT : Tendsto T atTop atTop) (c : ℝ) :
  Tendsto (fun n => c/Real.sqrt (T n:ℝ)) atTop (𝓝 0) :=
  tendsto_const_nhds.div_atTop (Real.tendsto_sqrt_atTop.comp (tendsto_natCast_atTop_atTop.comp hT))

/-- The killed heat kernel obtained from the proved discrete reflection principle. -/
def killedHeat (t x y : ℝ) : ℝ := heat t (y-x)-heat t (y+x)

lemma killed_scaled_limit {N T a b : ℕ → ℕ} {t x y : ℝ}
    (ht : 0<t) (hN : Tendsto N atTop atTop) (hT : Tendsto T atTop atTop)
    (hr : Tendsto (fun n => (N n:ℝ)/(T n:ℝ)) atTop (𝓝 t))
    (hz : ∀ᶠ n in atTop,Even ((N n:ℤ)+(b n:ℤ)-a n))
    (hx : Tendsto (fun n => (a n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 x))
    (hy : Tendsto (fun n => (b n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 y)) :
    Tendsto (fun n => Real.sqrt (T n:ℝ)*killed (N n) (a n) (b n)) atTop
      (𝓝 (2*killedHeat t x y)) := by
  have hm : Tendsto (fun n => (((b n:ℤ)-a n:ℤ):ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 (y-x)) := by
    simpa only [Int.cast_sub,Int.cast_natCast,sub_div] using hy.sub hx
  have hp : Tendsto (fun n => (((b n:ℤ)+a n+2:ℤ):ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 (y+x)) := by
    simpa only [Int.cast_add,Int.cast_ofNat,Int.cast_natCast,add_div,add_zero] using
      (hy.add hx).add (cast_div_sqrt_tendsto_zero hT 2)
  have hz1 : ∀ᶠ n in atTop, Even ((N n:ℤ)+((b n:ℤ)-a n)) := by
    filter_upwards [hz] with n hn; convert hn using 1; ring
  have hz2 : ∀ᶠ n in atTop, Even ((N n:ℤ)+((b n:ℤ)+a n+2)) := by
    filter_upwards [hz] with n hn
    have he : (N n:ℤ)+((b n:ℤ)+a n+2)=((N n:ℤ)+b n-a n)+2*((a n:ℤ)+1) := by ring
    rw [he]
    exact hn.add (even_two_mul ((a n:ℤ)+1))
  have h := (kernel_scaled_limit ht hN hT hr hz1 hm).sub (kernel_scaled_limit ht hN hT hr hz2 hp)
  simpa only [killed_reflection,mul_sub,killedHeat] using h

lemma sqrt_div_nat_tendsto_zero {T : ℕ → ℕ} (hT : Tendsto T atTop atTop) :
    Tendsto (fun n => Real.sqrt (T n:ℝ)/(T n:ℝ)) atTop (𝓝 0) := by
  apply (cast_div_sqrt_tendsto_zero hT 1).congr'
  filter_upwards [hT.eventually (eventually_gt_atTop 0)] with n hn
  have htp : 0<(T n:ℝ) := by exact_mod_cast hn
  have hsp : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr htp)
  have hs := Real.sq_sqrt htp.le
  field_simp
  nlinarith

lemma entrance_scaled_limit {N T b : ℕ → ℕ} {t y : ℝ}
    (ht : 0<t) (hN : Tendsto N atTop atTop) (hT : Tendsto T atTop atTop)
    (hr : Tendsto (fun n => (N n:ℝ)/(T n:ℝ)) atTop (𝓝 t))
    (hz : ∀ᶠ n in atTop,Even ((N n:ℤ)+b n))
    (hy : Tendsto (fun n => (b n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 y)) :
    Tendsto (fun n => (T n:ℝ)*killed (N n) 0 (b n)) atTop (𝓝 (4*y/t*heat t y)) := by
  have hsmall : Tendsto (fun n => (b n:ℝ)/(T n:ℝ)) atTop (𝓝 0) := by
    have h := hy.mul (sqrt_div_nat_tendsto_zero hT)
    simp only [mul_zero] at h
    apply h.congr'
    filter_upwards [hT.eventually (eventually_gt_atTop 0)] with n hn
    have hs : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hn))
    field_simp
  have hnum : Tendsto (fun n => 2*((b n:ℝ)+1)/Real.sqrt (T n:ℝ)) atTop (𝓝 (2*y)) := by
    simpa only [add_zero,mul_div_assoc,add_div] using (hy.add (cast_div_sqrt_tendsto_zero hT 1)).const_mul 2
  have hden : Tendsto (fun n => ((N n:ℝ)+b n+2)/(T n:ℝ)) atTop (𝓝 t) := by
    simpa only [add_div,add_zero] using (hr.add hsmall).add
      (tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.comp hT) :
        Tendsto (fun n => (2:ℝ)/(T n:ℝ)) atTop (𝓝 0))
  have hk := kernel_scaled_limit ht hN hT hr hz (by simpa only [Int.cast_natCast] using hy)
  have h := (hnum.div hden (ne_of_gt ht)).mul hk
  have hi : 2*y/t*(2*heat t y)=4*y/t*heat t y := by ring
  rw [hi] at h
  apply h.congr'
  filter_upwards [hT.eventually (eventually_gt_atTop 0)] with n hn
  have htp : (T n:ℝ)≠0 := by exact_mod_cast (Nat.ne_of_gt hn)
  have hs : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hn))
  have hd : (N n:ℝ)+b n+2≠0 := by positivity
  rw [killed_entrance]
  dsimp only [Pi.mul_apply,Pi.div_apply]
  field_simp

/-- Terminal first-hitting density at macroscopic time. -/
lemma firstHit_scaled_limit {N T b : ℕ → ℕ} {t y : ℝ}
    (ht : 0<t) (hN : Tendsto N atTop atTop) (hT : Tendsto T atTop atTop)
    (hr : Tendsto (fun n => ((N n:ℝ)+1)/(T n:ℝ)) atTop (𝓝 t))
    (hz : ∀ᶠ n in atTop,Even (((N n+1:ℕ):ℤ)+((b n:ℤ)+1)))
    (hy : Tendsto (fun n => (b n:ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 y)) :
    Tendsto (fun n => (T n:ℝ)*pathMass (N n+1) (firstHit (b n))) atTop
      (𝓝 (2*y/t*heat t y)) := by
  have hN' : Tendsto (fun n => N n+1) atTop atTop := tendsto_atTop_mono (fun n => by omega) hN
  have hy' : Tendsto (fun n => (((b n:ℤ)+1:ℤ):ℝ)/Real.sqrt (T n:ℝ)) atTop (𝓝 y) := by
    simpa only [Int.cast_add,Int.cast_one,Int.cast_natCast,add_div,add_zero] using
      hy.add (cast_div_sqrt_tendsto_zero hT 1)
  have hk := kernel_scaled_limit ht hN' hT (by simpa only [Nat.cast_add,Nat.cast_one] using hr) hz hy'
  have hnum : Tendsto (fun n => ((b n:ℝ)+1)/Real.sqrt (T n:ℝ)) atTop (𝓝 y) := by
    simpa only [Int.cast_add,Int.cast_one,Int.cast_natCast] using hy'
  have h := (hnum.div hr (ne_of_gt ht)).mul hk
  have hi : y/t*(2*heat t y)=2*y/t*heat t y := by ring
  rw [hi] at h
  apply h.congr'
  filter_upwards [hT.eventually (eventually_gt_atTop 0)] with n hn
  have htp : (T n:ℝ)≠0 := by exact_mod_cast (Nat.ne_of_gt hn)
  have hs : Real.sqrt (T n:ℝ)≠0 := ne_of_gt (Real.sqrt_pos.mpr (by exact_mod_cast hn))
  have hd : (N n:ℝ)+1≠0 := by positivity
  rw [firstHit_formula]
  dsimp only [Pi.mul_apply,Pi.div_apply]
  field_simp

end FKCRT.SimpleWalk
end

end OAI