import Mathlib
import OAI.Probability.Ballisticity.Coupling.SeedProfile

namespace OAI

section

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

lemma ae_at_atom {A : Type*} [MeasurableSpace A] {μ : Measure A} {P : A → Prop}
    (h : ∀ᵐ x ∂μ, P x) {x : A} (hx : μ {x} ≠ 0) : P x := by
  by_contra hnot
  exact hx (measure_mono_null (by simpa only [Set.singleton_subset_iff,Set.mem_ofPred_eq] using hnot) (ae_iff.mp h))

lemma atom_of_ae_domination {A : Type*} [MeasurableSpace A] (μ ρ : Measure A)
    (c : ℝ≥0∞) (hc : c ≠ 0) (h : c • μ ≤ ρ) {x : A} (hx : μ {x} ≠ 0) : ρ {x} ≠ 0 := by
  intro hz
  have hh := h {x}
  simp only [Measure.smul_apply,smul_eq_mul,hz,nonpos_iff_eq_zero,mul_eq_zero] at hh
  exact hh.elim hc hx

lemma seedEndpointRaw_atom_origin {d : ℕ} (e : Direction d) (H : ℕ)
    (R : Lattice d → Lattice d → Prop) (μ : Measure (Lattice d)) (ω : Environment d)
    (y : Lattice d) (hy : seedEndpointRaw e H R μ ω {y} ≠ 0) :
    ∃ x, μ {x} ≠ 0 ∧ R x y := by
  by_contra! hn
  apply hy
  rw [seedEndpointRaw_apply,lintegral_countable']
  apply ENNReal.tsum_eq_zero.mpr
  intro x
  by_cases hx : μ {x}=0
  · simp [hx]
  · have hxy := hn x hx
    have he : {y} ∩ {z | R x z}=∅ := by ext z; simp only [Set.mem_inter_iff,Set.mem_singleton_iff,Set.mem_ofPred_eq,Set.mem_empty_iff_false,iff_false]; rintro ⟨rfl,h⟩; exact hxy h
    simp [he]

lemma seedAdvance_atom_origin {d : ℕ} (e : Direction d) (a : ℤ) (H : ℕ)
    (R : Lattice d → Lattice d → Prop) (μ : SeedProfile e a) (ω : Environment d)
    (hm : seedEndpointRaw e H R μ.measure ω Set.univ ≠ 0)
    (y : Lattice d) (hy : (seedAdvance e a H R μ ω).measure {y} ≠ 0) :
    ∃ x, μ.measure {x} ≠ 0 ∧ R x y := by
  apply seedEndpointRaw_atom_origin e H R μ.measure ω y
  rw [←seedAdvance_mass e a H R μ ω,Measure.smul_apply,smul_eq_mul]
  exact mul_ne_zero hm hy

lemma seedHalfProfile_atom_origin {d : ℕ} (e f : Direction d) (a s : ℤ) (upper : Bool)
    (μ : SeedProfile e a) (x : Lattice d)
    (hx : (seedHalfProfile e f a s upper μ).measure {x} ≠ 0) :
    μ.measure {x} ≠ 0 ∧
      (if upper then seedMedian f s μ.val ≤ s*signedHeight f x
       else s*signedHeight f x ≤ seedMedian f s μ.val) := by
  exact ⟨atom_of_ae_domination _ _ _ (by norm_num) (seedHalf_domination f s upper μ.val) hx,
    ae_at_atom (seedHalf_ae f s upper μ.val) hx⟩

def SeedOrdered {d : ℕ} (f : Direction d) (s : ℤ) (g : ℝ)
    (μ ρ : Measure (Lattice d)) : Prop :=
  ∀ x, μ {x} ≠ 0 → ∀ y, ρ {y} ≠ 0 →
    g ≤ (s:ℝ)*(signedCoordinate f y-signedCoordinate f x)

lemma seedOrdered_mono {d : ℕ} (f : Direction d) (s : ℤ) {g g' : ℝ}
    {μ ρ : Measure (Lattice d)} (h : SeedOrdered f s g μ ρ) (hg : g' ≤ g) : SeedOrdered f s g' μ ρ :=
  fun x hx y hy => hg.trans (h x hx y hy)

lemma seedOrdered_central {d : ℕ} (e f : Direction d) (a s : ℤ) (H : ℕ)
    (θ z g : ℝ) (hs : s=1 ∨ s= -1) (μ ρ : SeedProfile e a) (ω : Environment d)
    (hm : seedEndpointRaw e H (SeedCentral f H θ z) μ.measure ω Set.univ ≠ 0)
    (hr : seedEndpointRaw e H (SeedCentral f H θ z) ρ.measure ω Set.univ ≠ 0)
    (ho : SeedOrdered f s g μ.measure ρ.measure) :
    SeedOrdered f s (g-2*z) (seedAdvance e a H (SeedCentral f H θ z) μ ω).measure
      (seedAdvance e a H (SeedCentral f H θ z) ρ ω).measure := by
  intro x hx y hy
  obtain ⟨u,hu,hux⟩ := seedAdvance_atom_origin e a H _ μ ω hm x hx
  obtain ⟨v,hv,hvy⟩ := seedAdvance_atom_origin e a H _ ρ ω hr y hy
  have huv := ho u hu v hv
  simp only [SeedCentral,signedCoordinate_sub,abs_le] at hux hvy
  rcases hs with rfl | rfl <;> norm_num at huv ⊢ <;> linarith [hux.1,hux.2,hvy.1,hvy.2]

lemma signedHeight_cast_coordinate {d : ℕ} (f : Direction d) (x : Lattice d) :
    (signedHeight f x:ℝ)=signedCoordinate f x := by
  simp only [signedHeight,signedCoordinate,Int.cast_ite,Int.cast_neg]

lemma seedOrdered_split {d : ℕ} (e f : Direction d) (a s : ℤ) (H : ℕ)
    (θ z b : ℝ) (hs : s=1 ∨ s= -1) (μ : SeedProfile e a) (ω : Environment d)
    (hm : seedEndpointRaw e H (SeedCentral f H θ z) (seedHalfProfile e f a s false μ).measure ω Set.univ ≠ 0)
    (hr : seedEndpointRaw e H (SeedJump f H s θ b) (seedHalfProfile e f a s true μ).measure ω Set.univ ≠ 0) :
    SeedOrdered f s (b-z)
      (seedAdvance e a H (SeedCentral f H θ z) (seedHalfProfile e f a s false μ) ω).measure
      (seedAdvance e a H (SeedJump f H s θ b) (seedHalfProfile e f a s true μ) ω).measure := by
  intro x hx y hy
  obtain ⟨u,hu,hux⟩ := seedAdvance_atom_origin e a H _ _ ω hm x hx
  obtain ⟨v,hv,hvy⟩ := seedAdvance_atom_origin e a H _ _ ω hr y hy
  have hlu := (seedHalfProfile_atom_origin e f a s false μ u hu).2
  have hlv := (seedHalfProfile_atom_origin e f a s true μ v hv).2
  simp only [Bool.false_eq_true,↓reduceIte] at hlu
  simp only [↓reduceIte] at hlv
  have ho : (s:ℝ)*signedCoordinate f u ≤ (s:ℝ)*signedCoordinate f v := by
    simpa only [Int.cast_mul,signedHeight_cast_coordinate] using (show ((s*signedHeight f u:ℤ):ℝ) ≤ ((s*signedHeight f v:ℤ):ℝ) from by exact_mod_cast hlu.trans hlv)
  simp only [SeedCentral,signedCoordinate_sub,abs_le] at hux
  simp only [SeedJump,signedCoordinate_sub] at hvy
  rcases hs with rfl | rfl <;> norm_num at ho hvy ⊢ <;> linarith [hux.1,hux.2]

lemma seedOrdered_half_left {d : ℕ} (e f : Direction d) (a s : ℤ) (upper : Bool)
    (μ ρ : SeedProfile e a) (g : ℝ) (ho : SeedOrdered f s g μ.measure ρ.measure) :
    SeedOrdered f s g (seedHalfProfile e f a s upper μ).measure ρ.measure :=
  fun x hx y hy => ho x (seedHalfProfile_atom_origin e f a s upper μ x hx).1 y hy

lemma seedOrdered_half_right {d : ℕ} (e f : Direction d) (a s : ℤ) (upper : Bool)
    (μ ρ : SeedProfile e a) (g : ℝ) (ho : SeedOrdered f s g μ.measure ρ.measure) :
    SeedOrdered f s g μ.measure (seedHalfProfile e f a s upper ρ).measure :=
  fun x hx y hy => ho x hx y (seedHalfProfile_atom_origin e f a s upper ρ y hy).1

end DirectionalTransience

end

section

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

abbrev SeedState {d : ℕ} (e : Direction d) (a : ℤ) := ℕ × (ℕ → SeedProfile e a)

lemma measurable_seedEval {d : ℕ} (e : Direction d) (a : ℤ) :
    Measurable (fun p : (ℕ → SeedProfile e a) × ℕ => p.1 p.2) :=
  measurable_from_prod_countable_left fun n => measurable_pi_apply n

noncomputable def seedCentralInput {d : ℕ} (e f : Direction d) (a s : ℤ) (k : ℕ)
    (q : SeedState e a) (i : ℕ) : SeedProfile e a :=
  if q.1 < k ∧ i=q.1-1 then seedHalfProfile e f a s false (q.2 i) else q.2 i

noncomputable def seedJumpInput {d : ℕ} (e f : Direction d) (a s : ℤ)
    (q : SeedState e a) : SeedProfile e a := seedHalfProfile e f a s true (q.2 (q.1-1))

lemma measurable_seedCentralInput {d : ℕ} (e f : Direction d) (a s : ℤ) (k i : ℕ) :
    Measurable (fun q : SeedState e a => seedCentralInput e f a s k q i) := by
  unfold seedCentralInput
  exact (((measurable_seedHalfProfile e f a s false).comp ((measurable_pi_apply i).comp measurable_snd))).ite
    ((measurableSet_lt measurable_fst measurable_const).inter
      (measurableSet_eq_fun measurable_const (measurable_fst.sub_const 1)))
    ((measurable_pi_apply i).comp measurable_snd)

lemma measurable_seedJumpInput {d : ℕ} (e f : Direction d) (a s : ℤ) :
    Measurable (seedJumpInput e f a s) := by
  apply (measurable_seedHalfProfile e f a s true).comp
  exact (measurable_seedEval e a).comp (measurable_snd.prodMk (measurable_fst.sub_const 1))

noncomputable def seedSplitTest {d : ℕ} (e f : Direction d) (a s : ℤ) (H : ℕ)
    (θ b j : ℝ) (q : SeedState e a) (ω : Environment d) : Prop :=
  j ≤ (seedEndpointRaw e H (SeedJump f H s θ b) (seedJumpInput e f a s q).measure ω Set.univ).toReal

noncomputable def seedStateStep {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (ω : Environment d) : SeedState e (a+H) :=
  let split := q.1<k ∧ seedSplitTest e f a s H θ b j q ω
  (if split then q.1+1 else q.1,
   fun i => if split ∧ i=q.1 then seedAdvance e a H (SeedJump f H s θ b) (seedJumpInput e f a s q) ω
     else seedAdvance e a H (SeedCentral f H θ z) (seedCentralInput e f a s k q i) ω)

def SeedStateOrdered {d : ℕ} (f : Direction d) (s : ℤ) (g : ℝ) {e : Direction d} {a : ℤ}
    (q : SeedState e a) : Prop := ∀ i j, i < j → j < q.1 → SeedOrdered f s g (q.2 i).measure (q.2 j).measure

def SeedStateRetained {d : ℕ} (e : Direction d) (a : ℤ) (H : ℕ) (π : Measure (Lattice d))
    (ω : Environment d) (δ : ℝ≥0∞) (q : SeedState e a) : Prop :=
  ∀ i < q.1, δ • (q.2 i).measure ≤ seedEndpointRaw e H (fun _ _ => True) π ω

noncomputable def SeedPreserved {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z c : ℝ) (q : SeedState e a) (ω : Environment d) : Prop :=
  ∀ i < q.1, c ≤ (seedEndpointRaw e H (SeedCentral f H θ z)
    (seedCentralInput e f a s k q i).measure ω Set.univ).toReal

lemma seedStateStep_count {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (ω : Environment d) :
    q.1 ≤ (seedStateStep e f a s k H θ z b j q ω).1 ∧
    (seedStateStep e f a s k H θ z b j q ω).1 ≤ q.1+1 ∧
    (q.1≤k → (seedStateStep e f a s k H θ z b j q ω).1≤k) := by
  simp only [seedStateStep]
  split_ifs <;> omega

lemma seedStateStep_strict {d : ℕ} (e f : Direction d) (a s : ℤ) (k H : ℕ)
    (θ z b j : ℝ) (q : SeedState e a) (ω : Environment d) (hq : q.1<k)
    (ht : seedSplitTest e f a s H θ b j q ω) :
    q.1 < (seedStateStep e f a s k H θ z b j q ω).1 := by
  simp [seedStateStep,hq,ht]

lemma seedCentralInput_domination {d : ℕ} (e f : Direction d) (a s : ℤ) (k : ℕ)
    (q : SeedState e a) (i : ℕ) :
    (1/2:ℝ≥0∞) • (seedCentralInput e f a s k q i).measure ≤ (q.2 i).measure := by
  unfold seedCentralInput
  split_ifs
  · exact seedHalf_domination f s false (q.2 i).val
  · intro U
    simp only [Measure.smul_apply,smul_eq_mul]
    exact mul_le_of_le_one_left bot_le (by norm_num)

lemma seedCentralInput_atom {d : ℕ} (e f : Direction d) (a s : ℤ) (k : ℕ)
    (q : SeedState e a) (i : ℕ) {x : Lattice d}
    (hx : (seedCentralInput e f a s k q i).measure {x} ≠ 0) : (q.2 i).measure {x} ≠ 0 :=
  atom_of_ae_domination _ _ _ (by norm_num) (seedCentralInput_domination e f a s k q i) hx

lemma seedStateStep_retained {d : ℕ} (e f : Direction d) (a s : ℤ) (k H h : ℕ)
    (θ z b j c : ℝ) (q : SeedState e a) (ω : Environment d) (π : Measure (Lattice d))
    (δ : ℝ≥0∞) (hq : 0 < q.1) (hj : 0 ≤ j) (hc : 0 ≤ c)
    (hr : SeedStateRetained e a h π ω δ q)
    (hp : SeedPreserved e f a s k H θ z c q ω) :
    SeedStateRetained e (a+H) (h+H) π ω (δ*(ENNReal.ofReal (min c j)/2))
      (seedStateStep e f a s k H θ z b j q ω) := by
  intro i hi
  have hcentral (i : ℕ) (hi : i<q.1) :
      (δ*(ENNReal.ofReal (min c j)/2)) •
        (seedAdvance e a H (SeedCentral f H θ z) (seedCentralInput e f a s k q i) ω).measure ≤
          seedEndpointRaw e (h+H) (fun _ _ => True) π ω := by
    have hsub : (δ/2) • (seedCentralInput e f a s k q i).measure ≤ seedEndpointRaw e h (fun _ _ => True) π ω := by
      calc
        _ = δ • ((1/2:ℝ≥0∞) • (seedCentralInput e f a s k q i).measure) := by rw [smul_smul]; congr 1; simp [div_eq_mul_inv]
        _ ≤ δ • (q.2 i).measure := by
          intro U; simpa only [Measure.smul_apply,smul_eq_mul] using mul_le_mul_right (seedCentralInput_domination e f a s k q i U) δ
        _ ≤ _ := hr i hi
    have hmass : ENNReal.ofReal (min c j) ≤ seedEndpointRaw e H (SeedCentral f H θ z) (seedCentralInput e f a s k q i).measure ω Set.univ := by
      apply (ENNReal.toReal_le_toReal ENNReal.ofReal_ne_top (measure_ne_top _ _)).mp
      rw [ENNReal.toReal_ofReal (le_min hc hj)]
      exact (min_le_left _ _).trans (hp i hi)
    have hh := seedAdvance_retained e a h H _ π (seedCentralInput e f a s k q i) ω (δ/2) (ENNReal.ofReal (min c j)) hsub hmass
    convert hh using 1
    simp [div_eq_mul_inv,mul_comm,mul_left_comm]
  by_cases ht : q.1<k ∧ seedSplitTest e f a s H θ b j q ω
  · simp only [seedStateStep,ite_eq_left ht] at hi ⊢
    by_cases he : i=q.1
    · simp only [he]
      have hsub : (δ/2) • (seedJumpInput e f a s q).measure ≤ seedEndpointRaw e h (fun _ _ => True) π ω := by
        calc
          _ = δ • ((1/2:ℝ≥0∞) • (seedJumpInput e f a s q).measure) := by rw [smul_smul]; congr 1; simp [div_eq_mul_inv]
          _ ≤ δ • (q.2 (q.1-1)).measure := by
            intro U; simpa only [Measure.smul_apply,smul_eq_mul,seedJumpInput,seedHalfProfile,SeedProfile.measure] using mul_le_mul_right (seedHalf_domination f s true (q.2 (q.1-1)).val U) δ
          _ ≤ _ := hr (q.1-1) (by omega)
      have hmass : ENNReal.ofReal (min c j) ≤ seedEndpointRaw e H (SeedJump f H s θ b) (seedJumpInput e f a s q).measure ω Set.univ := by
        rw [← ENNReal.ofReal_toReal (measure_ne_top _ _)]
        exact ENNReal.ofReal_le_ofReal ((min_le_right _ _).trans ht.2)
      have hh := seedAdvance_retained e a h H _ π (seedJumpInput e f a s q) ω (δ/2) (ENNReal.ofReal (min c j)) hsub hmass
      simpa [seedStateStep,ht,he,div_eq_mul_inv,mul_assoc,mul_comm,mul_left_comm] using hh
    · simp only [he,and_false,ite_false]
      exact hcentral i (by omega)
  · simp only [seedStateStep,ite_eq_right ht] at hi ⊢
    simpa [seedStateStep,ht] using hcentral i hi

end DirectionalTransience

end

end OAI