import Mathlib
import OAI.Probability.Ballisticity.Stationary.StationaryArrayLaw
import OAI.Probability.Ballisticity.Stationary.ArrayDust

namespace OAI

section

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

lemma stationary_ae_integer_family {Ω : Type*} [MeasurableSpace Ω]
    (μ : Measure Ω) {T : Ω → Ω} (hT : MeasurePreserving T μ μ)
    (P : ℤ → Ω → Prop) (hp : ∀ i, MeasurableSet {ω | P i ω})
    (hs : ∀ i, ∀ᵐ ω ∂μ, P i (T ω) ↔ P (i+1) ω)
    (h0 : ∀ᵐ ω ∂μ, P 0 ω) : ∀ᵐ ω ∂μ, ∀ i, P i ω := by
  apply ae_all_iff.mpr
  have hb (i : ℤ) : (∀ᵐ ω ∂μ, P i ω) ↔ ∀ᵐ ω ∂μ, P (i+1) ω := by
    have he : (∀ᵐ ω ∂μ, P i (T ω)) ↔ ∀ᵐ ω ∂μ, P (i+1) ω := eventually_congr (hs i)
    rw [←ae_map_iff hT.measurable.aemeasurable (hp i),hT.map_eq] at he
    exact he
  intro i
  induction i using Int.induction_on with
  | zero => exact h0
  | succ n ih => exact (hb n).mp ih
  | pred n ih =>
    apply (hb (-(n:ℤ)-1)).mpr
    simpa only [sub_add_cancel] using ih

structure ArrayGrowthSector {d : ℕ} (e : Direction d)
    (μ : Measure (ActualEpisodeArray e)) where
  event : Set (ActualEpisodeArray e)
  measurable_event : MeasurableSet event
  positive_event : 0<μ event
  invariant : ∀ᵐ Y ∂μ, StationaryCompact.shift Y∈event ↔ Y∈event
  symmetric : ∀ σ, ∀ᵐ Y ∂μ, arrayPerm e σ Y∈event ↔ Y∈event
  ζ : ℝ
  positive_ζ : 0<ζ
  sequence : ℕ → ℕ
  strictMono : StrictMono sequence
  growth : ∀ᵐ Y ∂μ, Y∈event → ∀ᶠ k in atTop,
    ζ*(sequence k:ℝ)<(arrayWindowCost e 0 (sequence k) Y).toReal
  no_dust : ∀ᵐ Y ∂μ, Y∈event → ∀ i a, ¬arrayDust e i a Y

namespace StationaryArrayLaw
variable {d : ℕ} {ν : Measure (Row d)} [IsProbabilityMeasure ν] {e : Direction d}

theorem growth_sector (L : StationaryArrayLaw ν e) (hue : UniformElliptic ν)
    (htrans : DirectionallyTransient ν (realPosition (step e))) :
    Nonempty (ArrayGrowthSector e (L.law : Measure (ActualEpisodeArray e))) := by
  let μ := (L.law : Measure (ActualEpisodeArray e))
  obtain ⟨g,hgm,hgb,hgT,ζ,hζ,hE,ns,hns,hlim,hgrowth⟩ := stationary_positive_growth μ
    L.preserving (arrayRealCost e) (arrayRealCost_measurable e) (arrayRealCost_nonneg e)
      L.integrable_cost L.positive_cost
  let E := {Y | ζ<g Y}
  have hmE : MeasurableSet E := measurableSet_lt measurable_const hgm
  have heT : ∀ᵐ Y ∂μ, StationaryCompact.shift Y∈E ↔ Y∈E := by
    filter_upwards [hgT] with Y hY
    change ζ<g (StationaryCompact.shift Y) ↔ ζ<g Y
    rw [hY]
  have heP (σ : Equiv.Perm ℕ) : ∀ᵐ Y ∂μ, arrayPerm e σ Y∈E ↔ Y∈E := by
    filter_upwards [array_growth_symmetry e μ g ns hlim L.symmetric σ] with Y hY
    change ζ<g (arrayPerm e σ Y) ↔ ζ<g Y
    rw [hY]
  have hc : ∀ᵐ Y ∂μ, ∀ j, (Y.1 j).2.2≠⊤ := L.finite_marks.mono fun Y hY j => (hY j).2.2.2.ne
  have hd : ∀ᵐ Y ∂μ, Y∈E → ∀ ε : ℝ, 0<ε → ∃ m,
      (expNeg (arrayWindowCost e 0 m Y)).toReal<ε := by
    filter_upwards [hc,hgrowth] with Y hY hg hy
    exact array_cost_decay_of_growth e Y hY ζ hζ ns hns (hg hy)
  have hn0 := array_no_dust_on_cost_decay e ν hue htrans μ L.consistent L.zero_sampling
    L.entropy_finite (L.finite_marks.mono fun Y hY j => (hY j).2.1) L.survival L.symmetric 0 E hmE heP hd
  have hnd : ∀ᵐ Y ∂μ, Y∈E → ∀ i a, ¬arrayDust e i a Y := by
    have hh := stationary_ae_integer_family μ L.preserving (fun i Y => Y∈E → ∀ a, ¬arrayDust e i a Y)
      (fun i => hmE.imp (by
        simpa only [Set.ofPred_forall, Set.compl_ofPred] using MeasurableSet.iInter fun a => (arrayDust_measurable e i a).compl))
      (fun i => heT.mono fun Y hY => by
        rw [hY]
        rfl) hn0
    filter_upwards [hh] with Y hY hy i
    exact hY i hy
  refine ⟨⟨E,hmE,hE,heT,heP,ζ,hζ,ns,hns,?_,hnd⟩⟩
  filter_upwards [hc,hgrowth] with Y hY hg hy
  simpa only [arrayWindowCost_toReal e Y hY] using hg hy

end StationaryArrayLaw
end DirectionalTransience

end

end OAI