import Mathlib
import OAI.Probability.Ballisticity.Coupling.SeedIteration

namespace OAI

section

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

def SeedOptions {d : ℕ} (f : Direction d) (k : ℕ) (s : ℤ) (g : ℝ)
    (δ : ℝ≥0∞) (ρ : Measure (Lattice d)) : Prop :=
  ∃ μ : Fin k → ProbabilityMeasure (Lattice d),
    (∀ i, δ • (μ i).toMeasure ≤ ρ) ∧
    ∀ i j, i<j → SeedOrdered f s g (μ i).toMeasure (μ j).toMeasure

lemma seedOptions_of_run {d : ℕ} (e f : Direction d) (a s : ℤ) (k h J L : ℕ)
    (θ z b j c : ℝ) (μ : SeedProfile e a) (hk : 1≤k) (hj : 0<j) (hc : 0<c)
    (hs : s=1 ∨ s= -1) (hz : 0≤z) (ω : Environment d)
    (hg : 0≤b+z-2*(J:ℝ)*z)
    (hcount : (seedRun e f a s k h θ z b j (1,fun _ => μ) J ω).1=k)
    (hp : ∀ t<J, 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 ω) ω)
    (ht : ∀ i<k, c≤(seedEndpointRaw e L (SeedCentral f L θ z)
      ((seedRun e f a s k h θ z b j (1,fun _ => μ) J ω).2 i).measure ω Set.univ).toReal) :
    SeedOptions f k s (b-z-2*(J:ℝ)*z)
      (((ENNReal.ofReal (min c j)/2)^J)*ENNReal.ofReal c)
      (seedEndpointRaw e (J*h+L) (fun _ _ => True) μ.measure ω) := by
  let q := seedRun e f a s k h θ z b j (1,fun _ => μ) J ω
  refine ⟨fun i => (seedAdvance e (seedHeight a h J) L (SeedCentral f L θ z) (q.2 i) ω).val,?_,?_⟩
  · intro i
    have hr := seedRun_retained e f a s k h θ z b j c μ hk hj.le hc.le J ω hp i.val (hcount.symm ▸ i.isLt)
    have hm : ENNReal.ofReal c ≤ seedEndpointRaw e L (SeedCentral f L θ z) (q.2 i).measure ω Set.univ := by
      rw [← ENNReal.ofReal_toReal (measure_ne_top _ _)]
      exact ENNReal.ofReal_le_ofReal (ht i.val i.isLt)
    exact seedAdvance_retained e (seedHeight a h J) (J*h) L (SeedCentral f L θ z) μ.measure (q.2 i) ω _ _ hr hm
  · intro i t hit
    have ho := seedRun_ordered e f a s k h θ z b j c μ hk hj hc hs hz J ω hg hp i.val t.val hit (hcount.symm ▸ t.isLt)
    have hm (i : Fin k) : seedEndpointRaw e L (SeedCentral f L θ z) (q.2 i).measure ω Set.univ≠0 := by
      intro he
      have hh := ht i.val i.isLt
      change c≤(seedEndpointRaw e L (SeedCentral f L θ z) (q.2 i).measure ω Set.univ).toReal at hh
      rw [he,ENNReal.toReal_zero] at hh
      exact (not_le_of_gt hc) hh
    have hh := seedOrdered_central e f (seedHeight a h J) s L θ z (b+z-2*(J:ℝ)*z) hs (q.2 i) (q.2 t) ω (hm i) (hm t) ho
    convert hh using 1 <;> first | rfl | ring

lemma seed_tail_failure_bound {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a : ℤ) (k : ℕ) {L : ℕ} (hL : 0<L) (θ z c : ℝ) (ε : ℝ≥0∞)
    (μ : Environment d → ℕ → SeedProfile e a)
    (hμ : @Measurable _ _ (rowSigma (seedBelow e a)) _ μ)
    (hc : ∀ μ : ProbabilityMeasure (Lattice d), environmentLaw ν {ω |
      (seedEndpointRaw e L (SeedCentral f L θ z) μ.toMeasure ω Set.univ).toReal<c} ≤ ε) :
    environmentLaw ν {ω | ∃ i<k, (seedEndpointRaw e L (SeedCentral f L θ z) (μ ω i).measure ω Set.univ).toReal<c} ≤ k*ε := by
  have hb (i : ℕ) : environmentLaw ν {ω | (seedEndpointRaw e L (SeedCentral f L θ z) (μ ω i).measure ω Set.univ).toReal<c}≤ε := by
    have hh := seed_fresh_test_bound ν e a (fun ω => μ ω i) ((measurable_pi_apply i).comp hμ)
      Set.univ MeasurableSet.univ
      {p : SeedProfile e a × Environment d | (seedEndpointRaw e L (SeedCentral f L θ z) p.1.measure p.2 Set.univ).toReal<c}
      (measurableSet_lt (seedProfileRaw_joint_rows e a hL (SeedCentral f L θ z) (seedAbove e a)
        (strip_subset_seedAbove e a L)) measurable_const) ε (fun η _ => hc (μ η i).val)
    simpa only [Set.mem_univ,true_and,Set.mem_ofPred_eq,measure_univ,mul_one] using hh
  have he : {ω | ∃ i<k, (seedEndpointRaw e L (SeedCentral f L θ z) (μ ω i).measure ω Set.univ).toReal<c} = ⋃ i∈Finset.range k,
      {ω | (seedEndpointRaw e L (SeedCentral f L θ z) (μ ω i).measure ω Set.univ).toReal<c} := by ext ω; simp
  rw [he]
  exact (measure_biUnion_finset_le _ _).trans ((Finset.sum_le_sum fun i _ => hb i).trans_eq (by simp))

lemma seedOptions_failure_bound {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (e f : Direction d) (a s : ℤ) (k N : ℕ) {h L : ℕ} (hh : 0<h) (hL : 0<L)
    (θ z b j c : ℝ) (μ : SeedProfile e a) (hk : 1≤k) (hj : 0<j) (hc : 0<c)
    (hs : s=1 ∨ s= -1) (hz : 0≤z) (ε ρ : ℝ≥0∞)
    (hg : 0≤b+z-2*((k-1)*N:ℕ)*z)
    (hclip : ∀ t∈({h,L}:Finset ℕ), ∀ μ : ProbabilityMeasure (Lattice d), environmentLaw ν {ω |
      (seedEndpointRaw e t (SeedCentral f t θ z) μ.toMeasure ω Set.univ).toReal<c}≤ε)
    (hjump : ∀ (a : ℤ) (q : SeedState e a), environmentLaw ν {ω | ¬seedSplitTest e f a s h θ b j q ω}≤ρ) :
    environmentLaw ν {ω | ¬SeedOptions f k s (b-z-2*((k-1)*N:ℕ)*z)
      (((ENNReal.ofReal (min c j)/2)^((k-1)*N))*ENNReal.ofReal c)
      (seedEndpointRaw e (((k-1)*N)*h+L) (fun _ _ => True) μ.measure ω)} ≤
        (k-1:ℕ)*ρ^N+((k-1)*N:ℕ)*(k*ε)+k*ε := by
  let J := (k-1)*N
  let run := seedRun e f a s k h θ z b j (1,fun _ => μ)
  let A := {ω | (run J ω).1<k}
  let B := {ω | ∃ t<J, ¬SeedPreserved e f (seedHeight a h t) s k h θ z c (run t ω) ω}
  let C := {ω | ∃ i<k, (seedEndpointRaw e L (SeedCentral f L θ z) ((run J ω).2 i).measure ω Set.univ).toReal<c}
  have hA : environmentLaw ν A≤(k-1:ℕ)*ρ^N := seedRun_completion_probability ν e f a s k hh θ z b j μ hk ρ hjump N
  have hB : environmentLaw ν B≤J*(k*ε) := seedRun_preservation_failure ν e f a s k hh θ z b j c ε μ hk (hclip h (by simp)) J
  have hC : environmentLaw ν C≤k*ε := seed_tail_failure_bound ν e f (seedHeight a h J) k hL θ z c ε
    (fun ω => (run J ω).2) (measurable_snd.comp (seedRun_measurable e f a s k hh θ z b j _ J)) (hclip L (by simp))
  have he : {ω | ¬SeedOptions f k s (b-z-2*(J:ℝ)*z)
      (((ENNReal.ofReal (min c j)/2)^J)*ENNReal.ofReal c)
      (seedEndpointRaw e (J*h+L) (fun _ _ => True) μ.measure ω)} ⊆ (A∪B)∪C := by
    intro ω hω
    by_contra hn
    have ha : ω∉A := fun ha => hn (Or.inl (Or.inl ha))
    have hb : ω∉B := fun hb => hn (Or.inl (Or.inr hb))
    have hc' : ω∉C := fun hc => hn (Or.inr hc)
    apply hω
    apply seedOptions_of_run e f a s k h J L θ z b j c μ hk hj hc hs hz ω hg
    · have hcount := (seedRun_count_bounds e f a s k h θ z b j (1,fun _ => μ) (by norm_num) hk J ω).2
      exact le_antisymm hcount (Nat.le_of_not_gt ha)
    · intro t ht
      exact not_not.mp (fun hbad => hb ⟨t,ht,hbad⟩)
    · intro i hi
      exact le_of_not_gt (fun hbad => hc' ⟨i,hi,hbad⟩)
  exact (measure_mono he).trans ((measure_union_le _ _).trans
    (add_le_add ((measure_union_le _ _).trans (add_le_add hA hB)) hC))

end DirectionalTransience

end

section

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

lemma seedOrdered_near_impossible {d : ℕ} (f : Direction d) (s : ℤ) (g r : ℝ)
    (hs : s=1 ∨ s= -1) (hg : 2*r<g) (μ ρ : Measure (Lattice d))
    (ho : SeedOrdered f s g μ ρ) (x y z : Lattice d) (hx : μ {x}≠0) (hy : ρ {y}≠0)
    (hxn : |signedCoordinate f x-signedCoordinate f z|<r)
    (hyn : |signedCoordinate f y-signedCoordinate f z|<r) : False := by
  have hh := ho x hx y hy
  rw [abs_lt] at hxn hyn
  rcases hs with rfl | rfl <;> norm_num at hh <;> linarith [hxn.1,hxn.2,hyn.1,hyn.2]

lemma seedOptions_avoid_mass {d k n : ℕ} (f : Direction d) (s : ℤ) (g r : ℝ)
    (hs : s=1 ∨ s= -1) (hg : 2*r<g) (δ : ℝ≥0∞) (ρ : Measure (Lattice d))
    (ho : SeedOptions f k s g δ ρ) (hn : n<k) (v : Fin n → Lattice d) :
    δ ≤ ρ {x | ∀ j, r≤|signedCoordinate f x-signedCoordinate f (v j)|} := by
  obtain ⟨μ,hdom,hord⟩ := ho
  have hex : ∃ i : Fin k, ∀ x, (μ i).toMeasure {x}≠0 → ∀ j : Fin n,
      r≤|signedCoordinate f x-signedCoordinate f (v j)| := by
    by_contra hnex
    have hbad (i : Fin k) : ∃ j : Fin n, ∃ x, (μ i).toMeasure {x}≠0 ∧
        |signedCoordinate f x-signedCoordinate f (v j)|<r := by
      have hi : ¬∀ x, (μ i).toMeasure {x}≠0 → ∀ j : Fin n,
          r≤|signedCoordinate f x-signedCoordinate f (v j)| := fun hi => hnex ⟨i,hi⟩
      push Not at hi
      obtain ⟨x,hx,j,hj⟩ := hi
      exact ⟨j,x,hx,hj⟩
    choose j x hx hnear using hbad
    have hj : Function.Injective j := by
      intro i t he
      by_contra hit
      rcases lt_or_gt_of_ne hit with hit | hti
      · exact seedOrdered_near_impossible f s g r hs hg _ _ (hord i t hit) (x i) (x t) (v (j i)) (hx i) (hx t)
          (hnear i) (he.symm ▸ hnear t)
      · exact seedOrdered_near_impossible f s g r hs hg _ _ (hord t i hti) (x t) (x i) (v (j i)) (hx t) (hx i)
          (he.symm ▸ hnear t) (hnear i)
    have hc := Fintype.card_le_of_injective j hj
    simp only [Fintype.card_fin] at hc
    omega
  obtain ⟨i,hi⟩ := hex
  have hae : ∀ᵐ x ∂(μ i).toMeasure, ∀ j, r≤|signedCoordinate f x-signedCoordinate f (v j)| :=
    ae_iff_of_countable.mpr hi
  have hm : (μ i).toMeasure {x | ∀ j, r≤|signedCoordinate f x-signedCoordinate f (v j)|}=1 :=
    (prob_compl_eq_zero_iff (Set.to_countable _).measurableSet).mp (ae_iff.mp hae)
  have hh := hdom i {x | ∀ j, r≤|signedCoordinate f x-signedCoordinate f (v j)|}
  simpa only [Measure.smul_apply,smul_eq_mul,hm,mul_one] using hh

lemma countable_pi_cons_apply {A : Type*} [MeasurableSpace A] [Countable A]
    [MeasurableSingletonClass A] (n : ℕ) (μ : Fin (n+1) → Measure A) [∀ i, SigmaFinite (μ i)]
    (S : Set (Fin (n+1) → A)) :
    Measure.pi μ S = ∫⁻ t, μ 0 {x | Fin.cons x t∈S} ∂Measure.pi (fun j => μ j.succ) := by
  have hm := (measurePreserving_piFinSuccAbove μ 0).symm.map_eq
  rw [← hm,Measure.map_apply (measurable_of_countable _) (Set.to_countable _).measurableSet,
    Measure.prod_apply_symm (Set.to_countable _).measurableSet]
  simp only [MeasurableEquiv.piFinSuccAbove_symm_apply,Fin.insertNthEquiv,Fin.insertNth_zero,Fin.zero_succAbove]
  rfl

lemma tupleSeparated_cons {d n : ℕ} (f : Direction d) (r : ℝ) (x : Lattice d) (v : Fin n → Lattice d)
    (hv : TupleSeparated f r v) (hx : ∀ j, r≤|signedCoordinate f x-signedCoordinate f (v j)|) :
    TupleSeparated f r (Fin.cons x v) := by
  intro i j hij
  cases i using Fin.cases with
  | zero =>
    cases j using Fin.cases with
    | zero => exact (hij rfl).elim
    | succ j => simpa using hx j
  | succ i =>
    cases j using Fin.cases with
    | zero => simpa only [Fin.cons_succ,Fin.cons_zero,abs_sub_comm] using hx i
    | succ j => simpa only [Fin.cons_succ] using hv i j (fun he => hij (congrArg Fin.succ he))

lemma seedOptions_product_mass {d k n : ℕ} (f : Direction d) (s : ℤ) (g r : ℝ)
    (hs : s=1 ∨ s= -1) (hg : 2*r<g) (δ : ℝ≥0∞) (μ : Fin n → Measure (Lattice d))
    [∀ i, IsFiniteMeasure (μ i)] (hn : n≤k)
    (ho : ∀ i, SeedOptions f k s g δ (μ i)) :
    δ^n ≤ Measure.pi μ {v | TupleSeparated f r v} := by
  induction n with
  | zero =>
    have he : {v : Fin 0 → Lattice d | TupleSeparated f r v}=Set.univ := by
      ext v; simp only [Set.mem_ofPred_eq,Set.mem_univ,iff_true]; intro i; exact Fin.elim0 i
    rw [he,Measure.pi_univ,pow_zero]
    simp
  | succ n ih =>
    have hi := ih (fun i => μ i.succ) (by omega) (fun i => ho i.succ)
    rw [countable_pi_cons_apply]
    have hb (v : Fin n → Lattice d) :
        {v | TupleSeparated f r v}.indicator (fun _ => δ) v ≤ μ 0 {x | TupleSeparated f r (Fin.cons x v)} := by
      by_cases hv : TupleSeparated f r v
      · simp only [Set.indicator,Set.mem_ofPred_eq,ite_eq_left hv]
        exact (seedOptions_avoid_mass f s g r hs hg δ (μ 0) (ho 0) (by omega) v).trans
          (measure_mono fun x hx => tupleSeparated_cons f r x v hv hx)
      · simp only [Set.indicator,Set.mem_ofPred_eq,ite_eq_right hv]; exact bot_le
    calc
      δ^(n+1) = δ*δ^n := by rw [pow_succ,mul_comm]
      _ ≤ δ*Measure.pi (fun i => μ i.succ) {v | TupleSeparated f r v} := by gcongr
      _ = ∫⁻ v, {v | TupleSeparated f r v}.indicator (fun _ => δ) v ∂Measure.pi (fun i => μ i.succ) := by
        rw [lintegral_indicator (Set.to_countable _).measurableSet,lintegral_const,Measure.restrict_apply MeasurableSet.univ,Set.univ_inter]
      _ ≤ _ := lintegral_mono hb

end DirectionalTransience

end

end OAI