Blame for lean/OAI/Probability/Ballisticity/Coupling/SeedIteration.lean

import Mathlib
import OAI.Probability.Ballisticity.Estimates.RawPair
import OAI.Probability.Ballisticity.Coupling.SeedStateOrder

namespace OAI

section

open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology Classical
namespace DirectionalTransience

def seedHeight (a : ℤ) (H : ℕ) : ℕ → ℤ
  | 0 => a
  | n+1 => seedHeight a H n+H

lemma seedHeight_eq (a : ℤ) (H n : ℕ) : seedHeight a H n=a+(n:ℤ)*H := by
  induction n with
  | zero => simp [seedHeight]
  | succ n ih => simp only [seedHeight,ih,Nat.cast_add,Nat.cast_one]; ring

lemma seedHeight_mono (a : ℤ) (H : ℕ) : Monotone (seedHeight a H) := by
  intro m n hmn
  rw [seedHeight_eq,seedHeight_eq]
  have hm : (m:ℤ) ≤ n := by exact_mod_cast hmn
  exact add_le_add_right (mul_le_mul_of_nonneg_right hm (Int.natCast_nonneg H)) a

lemma seedBelow_mono {d : ℕ} (e : Direction d) {a b : ℤ} (h : a≤b) : seedBelow e a ⊆ seedBelow e b := fun _ hx => hx.trans_le h

noncomputable def seedRun {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) : (n : ℕ) → Environment d → SeedState e (seedHeight a H n)
  | 0, _ => q
  | n+1, ω => seedStateStep e f (seedHeight a H n) s k H θ z b j
      (seedRun e f a s k H θ z b j q n ω) ω

lemma seedRun_measurable {d : ℕ} (e f : Direction d) (a s : ℤ) (k : ℕ) {H : ℕ} (hH : 0<H)
    (θ z b j : ℝ) (q : SeedState e a) (n : ℕ) :
    @Measurable _ _ (rowSigma (seedBelow e (seedHeight a H n))) _ (seedRun e f a s k H θ z b j q n) := by
  induction n with
  | zero => exact measurable_const
  | succ n ih =>
    have hle := rowSigma_mono (seedBelow_mono e (seedHeight_mono a H (Nat.le_succ n)))
    exact (seedStateStep_joint_rows e f (seedHeight a H n) s k hH θ z b j
      (seedBelow e (seedHeight a H n+H)) (strip_subset_seedBelow e (seedHeight a H n) H)).comp
        ((ih.mono hle le_rfl).prodMk measurable_id)

lemma seedRun_count_step {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (n : ℕ) (ω : Environment d) :
    (seedRun e f a s k H θ z b j q n ω).1 ≤ (seedRun e f a s k H θ z b j q (n+1) ω).1 ∧
    (seedRun e f a s k H θ z b j q (n+1) ω).1 ≤ (seedRun e f a s k H θ z b j q n ω).1+1 :=
  (seedStateStep_count e f (seedHeight a H n) s k H θ z b j _ ω).imp_right And.left

lemma seedRun_count_mono {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (ω : Environment d) :
    Monotone (fun n => (seedRun e f a s k H θ z b j q n ω).1) :=
  monotone_nat_of_le_succ fun n => (seedRun_count_step e f a s k H θ z b j q n ω).1

lemma seedRun_count_bounds {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (hq : 0<q.1) (hqk : q.1≤k) (n : ℕ) (ω : Environment d) :
    0<(seedRun e f a s k H θ z b j q n ω).1 ∧ (seedRun e f a s k H θ z b j q n ω).1≤k := by
  induction n with
  | zero => exact ⟨hq,hqk⟩
  | succ n ih => exact ⟨ih.1.trans_le (seedRun_count_step e f a s k H θ z b j q n ω).1,
      (seedStateStep_count e f (seedHeight a H n) s k H θ z b j _ ω).2.2 ih.2⟩

lemma seedEndpointRaw_zero {d : ℕ} (e : Direction d) (μ : Measure (Lattice d)) (ω : Environment d) :
    seedEndpointRaw e 0 (fun _ _ => True) μ ω=μ := by
  simp only [seedEndpointRaw,Set.ofPred_true,Measure.restrict_univ]
  have he (x : Lattice d) : variableHitKernel (realPosition (step e)) 0 (ω,x)=Measure.dirac x :=
    by
      simpa only [variableHitKernel,Kernel.coe_mk,Nat.cast_zero] using
        hitKernel_height_zero (realPosition (step e)) x ω
  simp_rw [he]
  exact Measure.bind_dirac

lemma seedRun_retained {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j c : ℝ) (μ : SeedProfile e a) (hk : 1≤k) (hj : 0≤j) (hc : 0≤c)
    (n : ℕ) (ω : Environment d)
    (hp : ∀ t<n, SeedPreserved e f (seedHeight a H t) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) t ω) ω) :
    SeedStateRetained e (seedHeight a H n) (n*H) μ.measure ω
      ((ENNReal.ofReal (min c j)/2)^n) (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) := by
  induction n with
  | zero =>
    intro i hi
    simp only [seedRun,pow_zero,one_smul,Nat.zero_mul,seedEndpointRaw_zero]
    exact le_rfl
  | succ n ih =>
    have hh := seedStateStep_retained e f (seedHeight a H n) s k H (n*H) θ z b j c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) ω μ.measure
      ((ENNReal.ofReal (min c j)/2)^n)
      (seedRun_count_bounds e f a s k H θ z b j (1,fun _ => μ) (by norm_num) hk n ω).1 hj hc
      (ih (fun t ht => hp t (ht.trans (Nat.lt_succ_self n)))) (hp n (Nat.lt_succ_self n))
    simpa only [seedRun,seedHeight,Nat.add_mul,Nat.one_mul,pow_succ] using hh

lemma seedRun_ordered {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j c : ℝ) (μ : SeedProfile e a) (hk : 1≤k) (hj : 0<j) (hc : 0<c)
    (hs : s=1 ∨ s= -1) (hz : 0≤z) (n : ℕ) (ω : Environment d)
    (hg : 0≤b+z-2*(n:ℝ)*z)
    (hp : ∀ t<n, SeedPreserved e f (seedHeight a H t) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) t ω) ω) :
    SeedStateOrdered f s (b+z-2*(n:ℝ)*z) (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) := by
  induction n with
  | zero => intro i t hit ht; change t<1 at ht; omega
  | succ n ih =>
    have hn : (n:ℝ)+1=(n+1:ℕ) := by norm_num
    have hgprev : 0≤b+z-2*(n:ℝ)*z := by push_cast at hg; nlinarith
    apply seedStateStep_ordered e f (seedHeight a H n) s k H θ z b j c (b+z-2*(n:ℝ)*z) _ _ ω hs
      (seedRun_count_bounds e f a s k H θ z b j (1,fun _ => μ) (by norm_num) hk n ω).1 hj hc hg
    · push_cast; ring_nf; exact le_rfl
    · push_cast; nlinarith [Nat.cast_nonneg (α:=ℝ) n]
    · exact ih hgprev (fun t ht => hp t (ht.trans (Nat.lt_succ_self n)))
    · exact hp n (Nat.lt_succ_self n)

end DirectionalTransience

end

section

open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology Classical
namespace DirectionalTransience

lemma seedPreserved_failure_bound {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a s : ℤ) (k H : ℕ) (θ z c : ℝ) (ε : ℝ≥0∞)
    (hc : ∀ μ : ProbabilityMeasure (Lattice d), environmentLaw ν {ω |
      (seedEndpointRaw e H (SeedCentral f H θ z) μ.toMeasure ω Set.univ).toReal<c} ≤ ε)
    (q : SeedState e a) (hq : q.1≤k) :
    environmentLaw ν {ω | ¬SeedPreserved e f a s k H θ z c q ω} ≤ k*ε := by
  have hs : {ω | ¬SeedPreserved e f a s k H θ z c q ω} ⊆ ⋃ i∈Finset.range k,
      {ω | (seedEndpointRaw e H (SeedCentral f H θ z) (seedCentralInput e f a s k q i).measure ω Set.univ).toReal<c} := by
    intro ω hω
    obtain ⟨i,hi⟩ := not_forall.mp hω
    have hi' : i<q.1 := by by_contra h; exact hi (fun h' => (h h').elim)
    have hm := not_le.mp (fun h => hi (fun _ => h))
    exact Set.mem_iUnion.mpr ⟨i,Set.mem_iUnion.mpr ⟨Finset.mem_range.mpr (hi'.trans_le hq),hm⟩⟩
  calc
    _ ≤ _ := measure_mono hs
    _ ≤ ∑ i∈Finset.range k, environmentLaw ν {ω |
      (seedEndpointRaw e H (SeedCentral f H θ z) (seedCentralInput e f a s k q i).measure ω Set.univ).toReal<c} := measure_biUnion_finset_le _ _
    _ ≤ ∑ _i∈Finset.range k, ε := Finset.sum_le_sum fun i _ => hc (seedCentralInput e f a s k q i).val
    _ = _ := by simp

lemma seedRun_preservation_failure {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a s : ℤ) (k : ℕ) {H : ℕ} (hH : 0<H)
    (θ z b j c : ℝ) (ε : ℝ≥0∞) (μ : SeedProfile e a) (hk : 1≤k)
    (hc : ∀ μ : ProbabilityMeasure (Lattice d), environmentLaw ν {ω |
      (seedEndpointRaw e H (SeedCentral f H θ z) μ.toMeasure ω Set.univ).toReal<c} ≤ ε)
    (J : ℕ) : environmentLaw ν {ω | ∃ n<J, ¬SeedPreserved e f (seedHeight a H n) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) ω} ≤ J*(k*ε) := by
  have hb (n : ℕ) : environmentLaw ν {ω | ¬SeedPreserved e f (seedHeight a H n) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) ω} ≤ k*ε := by
    have hh := seed_fresh_test_bound ν e (seedHeight a H n)
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n)
      (seedRun_measurable e f a s k hH θ z b j _ n) Set.univ MeasurableSet.univ
      {p | ¬SeedPreserved e f (seedHeight a H n) s k H θ z c p.1 p.2}
      (seedPreserved_joint_rows e f (seedHeight a H n) s k hH θ z c (seedAbove e (seedHeight a H n))
        (strip_subset_seedAbove e (seedHeight a H n) H)).compl (k*ε)
      (fun η _ => seedPreserved_failure_bound ν e f (seedHeight a H n) s k H θ z c ε hc _
        (seedRun_count_bounds e f a s k H θ z b j (1,fun _ => μ) (by norm_num) hk n η).2)
    simpa only [Set.mem_univ,true_and,measure_univ,mul_one,Set.mem_ofPred_eq] using hh
  have he : {ω | ∃ n<J, ¬SeedPreserved e f (seedHeight a H n) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) ω} = ⋃ n∈Finset.range J,
      {ω | ¬SeedPreserved e f (seedHeight a H n) s k H θ z c
      (seedRun e f a s k H θ z b j (1,fun _ => μ) n ω) ω} := by ext ω; simp
  rw [he]
  exact (measure_biUnion_finset_le _ _).trans ((Finset.sum_le_sum fun n _ => hb n).trans_eq (by simp))

lemma seedRun_stall_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a s : ℤ) (k : ℕ) {H : ℕ} (hH : 0<H)
    (θ z b j : ℝ) (q : SeedState e a) (ρ : ℝ≥0∞)
    (hf : ∀ (a : ℤ) (q : SeedState e a), environmentLaw ν {ω | ¬seedSplitTest e f a s H θ b j q ω}≤ρ)
    (u N : ℕ) : environmentLaw ν {ω | (seedRun e f a s k H θ z b j q u ω).1<k ∧
      (seedRun e f a s k H θ z b j q (u+N) ω).1=(seedRun e f a s k H θ z b j q u ω).1} ≤ ρ^N := by
  let run := seedRun e f a s k H θ z b j q
  let E := fun n => {ω : Environment d | (run u ω).1<k ∧ (run (u+n) ω).1=(run u ω).1}
  have hm (n : ℕ) : MeasurableSet[rowSigma (seedBelow e (seedHeight a H (u+n)))] (E n) := by
    have hn := (measurable_fst.comp (seedRun_measurable e f a s k hH θ z b j q (u+n)))
    have hu := (measurable_fst.comp (seedRun_measurable e f a s k hH θ z b j q u)).mono
      (rowSigma_mono (seedBelow_mono e (seedHeight_mono a H (Nat.le_add_right u n)))) le_rfl
    exact (measurableSet_lt hu measurable_const).inter (measurableSet_eq_fun hn hu)
  have hb (n : ℕ) : environmentLaw ν (E (n+1)) ≤ ρ*environmentLaw ν (E n) := by
    have hs : E (n+1) ⊆ {ω | ω∈E n ∧ ¬seedSplitTest e f (seedHeight a H (u+n)) s H θ b j (run (u+n) ω) ω} := by
      intro ω hω
      change (run u ω).1<k ∧ (run (u+(n+1)) ω).1=(run u ω).1 at hω
      have hmono := seedRun_count_mono e f a s k H θ z b j q ω
      have hlow := hmono (Nat.le_add_right u n)
      have hhigh := hmono (show u+n≤u+(n+1) by omega)
      change (run u ω).1 ≤ (run (u+n) ω).1 at hlow
      change (run (u+n) ω).1 ≤ (run (u+(n+1)) ω).1 at hhigh
      have he : (run (u+n) ω).1=(run u ω).1 := by omega
      refine ⟨⟨hω.1,he⟩,fun ht => ?_⟩
      have ht' := seedStateStep_strict e f (seedHeight a H (u+n)) s k H θ z b j (run (u+n) ω) ω (he.symm ▸ hω.1) ht
      change (run (u+n) ω).1<(run (u+n+1) ω).1 at ht'
      have he' : (run (u+n+1) ω).1=(run u ω).1 :=
        (congrArg (fun t => (run t ω).1) (by omega : u+n+1=u+(n+1))).trans hω.2
      omega
    apply (measure_mono hs).trans
    exact seed_fresh_test_bound ν e (seedHeight a H (u+n)) (run (u+n))
      (seedRun_measurable e f a s k hH θ z b j q (u+n)) (E n) (hm n)
      {p | ¬seedSplitTest e f (seedHeight a H (u+n)) s H θ b j p.1 p.2}
      (seedSplitTest_joint_rows e f (seedHeight a H (u+n)) s hH θ b j (seedAbove e (seedHeight a H (u+n)))
        (strip_subset_seedAbove e (seedHeight a H (u+n)) H)).compl ρ (fun η _ => hf _ _)
  change environmentLaw ν (E N)≤ρ^N
  induction N with
  | zero => simpa using (measure_mono (μ:=environmentLaw ν) (Set.subset_univ (E 0)))
  | succ n ih =>
    calc
      _ ≤ ρ*environmentLaw ν (E n) := hb n
      _ ≤ ρ*ρ^n := by gcongr
      _ = ρ^(n+1) := by rw [pow_succ,mul_comm]

lemma monotone_count_failure_stall (v : ℕ → ℕ) (hv : Monotone v) (hzero : 1≤v 0)
    (k N : ℕ) (hk : 1≤k) (hfail : v ((k-1)*N)<k) :
    ∃ l<k-1, v (l*N)<k ∧ v ((l+1)*N)=v (l*N) := by
  by_contra h
  have hstrict (l : ℕ) (hl : l<k-1) : v (l*N)<v ((l+1)*N) := by
    have he : v ((l+1)*N)≠v (l*N) := fun he => h ⟨l,hl,
      (hv (Nat.mul_le_mul_right N (by omega))).trans_lt hfail,he⟩
    exact lt_of_le_of_ne (hv (Nat.mul_le_mul_right N (Nat.le_succ l))) (Ne.symm he)
  have hcount (l : ℕ) (hl : l≤k-1) : l+1≤v (l*N) := by
    induction l with
    | zero => simpa using hzero
    | succ l ih => have hh := hstrict l (by omega); have hi := ih (by omega); omega
  have hf := hcount (k-1) le_rfl
  omega

lemma seedRun_completion_probability {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a s : ℤ) (k : ℕ) {H : ℕ} (hH : 0<H)
    (θ z b j : ℝ) (μ : SeedProfile e a) (hk : 1≤k) (ρ : ℝ≥0∞)
    (hf : ∀ (a : ℤ) (q : SeedState e a), environmentLaw ν {ω | ¬seedSplitTest e f a s H θ b j q ω}≤ρ)
    (N : ℕ) : environmentLaw ν {ω | (seedRun e f a s k H θ z b j (1,fun _ => μ) ((k-1)*N) ω).1<k} ≤ (k-1:ℕ)*ρ^N := by
  let run := seedRun e f a s k H θ z b j (1,fun _ => μ)
  let E := fun l => {ω : Environment d | (run (l*N) ω).1<k ∧ (run (l*N+N) ω).1=(run (l*N) ω).1}
  have hs : {ω | (run ((k-1)*N) ω).1<k} ⊆ ⋃ l∈Finset.range (k-1), E l := by
    intro ω hω
    obtain ⟨l,hl,hcount,he⟩ := monotone_count_failure_stall (fun n => (run n ω).1)
      (seedRun_count_mono e f a s k H θ z b j _ ω) (by exact le_rfl) k N hk hω
    exact Set.mem_iUnion.mpr ⟨l,Set.mem_iUnion.mpr ⟨Finset.mem_range.mpr hl,hcount,(congrArg (fun t => (run t ω).1) (by simp [Nat.add_mul] : l*N+N=(l+1)*N)).trans he⟩⟩
  calc
    _ ≤ _ := measure_mono hs
    _ ≤ ∑ l∈Finset.range (k-1), environmentLaw ν (E l) := measure_biUnion_finset_le _ _
    _ ≤ ∑ _l∈Finset.range (k-1), ρ^N := Finset.sum_le_sum fun l _ => seedRun_stall_probability ν e f a s k hH θ z b j _ ρ hf (l*N) N
    _ = _ := by simp

end DirectionalTransience

end

end OAI