import Mathlib
import OAI.Probability.Ballisticity.Model

namespace OAI

section

section

open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology

namespace DirectionalTransience

instance environmentLaw_probability {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] : IsProbabilityMeasure (environmentLaw ν) := by
  unfold environmentLaw
  infer_instance

instance initialLaw_probability {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] : IsProbabilityMeasure (initialLaw ν) := by
  unfold initialLaw
  infer_instance

instance annealedLaw_probability {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] : IsProbabilityMeasure (annealedLaw ν) := by
  unfold annealedLaw
  infer_instance

lemma environment_site_law {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] (x : Lattice d) :
    (environmentLaw ν).map (fun ω => ω x) = ν := by
  exact (measurePreserving_eval_infinitePi (fun _ : Lattice d => ν) x).map_eq

lemma environment_uniform_elliptic {d : ℕ} (ν : Measure (Row d))
    [IsProbabilityMeasure ν] (hue : UniformElliptic ν) :
    ∃ κ : ℝ≥0, 0 < κ ∧ ∀ᵐ ω ∂environmentLaw ν, ∀ x e, κ ≤ (ω x).1 e := by
  obtain ⟨κ, hκ, hrows⟩ := hue
  refine ⟨κ, hκ, ae_all_iff.mpr fun x => ?_⟩
  exact (measurePreserving_eval_infinitePi (fun _ : Lattice d => ν) x).quasiMeasurePreserving.ae hrows

lemma row_entry_le_one {d : ℕ} (p : Row d) (e : Direction d) : p.1 e ≤ 1 := by
  calc
    p.1 e ≤ ∑ i, p.1 i := Finset.single_le_sum (fun _ _ => zero_le) (Finset.mem_univ e)
    _ = 1 := p.2

lemma hasVelocity_unique {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    {v w : Vector d} (hv : HasVelocity ν v) (hw : HasVelocity ν w) : v = w := by
  obtain ⟨X, hXv, hXw⟩ := (hv.and hw).exists
  exact tendsto_nhds_unique hXv hXw

noncomputable def stateTrajectory {d : ℕ} : Kernel (State d) (ℕ → State d) :=
  (Kernel.traj (historyTransition (d := d)) 0).comap
    (fun z _ => z) (Measurable.of_eval fun _ => measurable_id)

instance stateTrajectory_markov {d : ℕ} : IsMarkovKernel (stateTrajectory (d := d)) := by
  unfold stateTrajectory
  infer_instance

noncomputable def quenchedKernel {d : ℕ} : Kernel (State d) (Path d) :=
  stateTrajectory.map (fun z n => (z n).2)

instance quenchedKernel_markov {d : ℕ} : IsMarkovKernel (quenchedKernel (d := d)) := by
  apply Kernel.IsMarkovKernel.map
  exact Measurable.of_eval fun n => measurable_snd.comp (measurable_pi_apply n)

lemma stateTrajectory_eq {d : ℕ} (μ : Measure (State d)) :
    stateTrajectory ∘ₘ μ = Kernel.trajMeasure μ (historyTransition (d := d)) := by
  unfold Kernel.trajMeasure stateTrajectory
  rw [← Kernel.comp_deterministic_eq_comap, ← Measure.comp_assoc,
    Measure.deterministic_comp_eq_map]
  rfl

lemma annealed_eq_quenched_mixture {d : ℕ} (ν : Measure (Row d)) :
    annealedLaw ν = quenchedKernel ∘ₘ initialLaw ν := by
  unfold annealedLaw quenchedKernel
  rw [← stateTrajectory_eq, Measure.map_comp]
  exact Measurable.of_eval fun n => measurable_snd.comp (measurable_pi_apply n)

lemma annealed_apply {d : ℕ} (ν : Measure (Row d)) {A : Set (Path d)}
    (hA : MeasurableSet A) :
    annealedLaw ν A = ∫⁻ ω, quenchedKernel (ω, (0 : Lattice d)) A ∂environmentLaw ν := by
  rw [annealed_eq_quenched_mixture, Measure.bind_apply hA (Kernel.aemeasurable _),
    initialLaw, lintegral_map]
  · exact Kernel.measurable_coe _ hA
  · exact measurable_id.prodMk measurable_const

lemma environment_translation {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    (z : Lattice d) :
    (environmentLaw ν).map (fun ω x => ω (z + x)) = environmentLaw ν := by
  apply Measure.map_infinitePi_infinitePi_of_inj
  exact add_right_injective z

lemma stateTrajectory_initial {d : ℕ} (z : State d) :
    (stateTrajectory z).map (fun X => X 0) = Measure.dirac z := by
  rw [stateTrajectory, Kernel.comap_apply]
  have h := Kernel.traj_map_frestrictLe_apply (X := fun _ => State d)
    (κ := historyTransition (d := d))
    0 0 (fun _ => z)
  rw [Kernel.partialTraj_self, Kernel.id_apply] at h
  have hm : Measurable (fun X : (i : Finset.Iic 0) → State d =>
      X ⟨0, Finset.mem_Iic.mpr le_rfl⟩) := measurable_pi_apply _
  have := congrArg (fun μ => μ.map
    (fun X : (i : Finset.Iic 0) → State d => X ⟨0, Finset.mem_Iic.mpr le_rfl⟩)) h
  rw [Measure.map_map hm (Preorder.measurable_frestrictLe 0), Measure.map_dirac' hm] at this
  exact this

lemma quenched_initial {d : ℕ} (z : State d) :
    (quenchedKernel z).map (fun X => X 0) = Measure.dirac z.2 := by
  have hm : Measurable (fun z : ℕ → State d => fun n => (z n).2) := by fun_prop
  rw [quenchedKernel, Kernel.map_apply _ hm, Measure.map_map (measurable_pi_apply 0) hm]
  have h := congrArg (fun μ => μ.map Prod.snd) (stateTrajectory_initial z)
  rw [Measure.map_map measurable_snd (measurable_pi_apply 0),
    Measure.map_dirac' measurable_snd] at h
  exact h

lemma quenched_initial_ae {d : ℕ} (z : State d) :
    ∀ᵐ X ∂quenchedKernel z, X 0 = z.2 := by
  have h : ∀ᵐ x ∂(quenchedKernel z).map (fun X => X 0), x = z.2 := by
    rw [quenched_initial]
    exact ae_dirac_iff (measurableSet_singleton _ ) |>.mpr rfl
  exact (ae_map_iff (measurable_pi_apply 0).aemeasurable
    (measurableSet_singleton _)).mp h

instance state_measurableEq {d : ℕ} : MeasurableEq (State d) where
  measurableSet_diagonal := by
    change MeasurableSet {zz : State d × State d | zz.1 = zz.2}
    simp only [Prod.ext_iff, Set.ofPred_and]
    exact (measurableSet_eq_fun (measurable_fst.comp measurable_fst)
      (measurable_fst.comp measurable_snd)).inter
      (measurableSet_eq_fun (measurable_snd.comp measurable_fst)
        (measurable_snd.comp measurable_snd))

instance state_measurableSingleton {d : ℕ} : MeasurableSingletonClass (State d) := by
  infer_instance

def AdmissibleStep {d : ℕ} (z z' : State d) : Prop :=
  ∃ e : Direction d, z' = (z.1, z.2 + step e)

lemma measurableSet_admissibleStep {d : ℕ} :
    MeasurableSet {zz : State d × State d | AdmissibleStep zz.1 zz.2} := by
  simp only [AdmissibleStep, Prod.ext_iff, Set.ofPred_exists, Set.ofPred_and]
  apply MeasurableSet.iUnion
  intro e
  exact (measurableSet_eq_fun (measurable_fst.comp measurable_snd)
    (measurable_fst.comp measurable_fst)).inter
    (measurableSet_eq_fun (measurable_snd.comp measurable_snd)
      ((measurable_snd.comp measurable_fst).add_const (step e)))

lemma transition_admissible {d : ℕ} (z : State d) :
    ∀ᵐ z' ∂transition z, AdmissibleStep z z' := by
  change ∀ᵐ z' ∂∑ e : Direction d,
    ((z.1 z.2).1 e : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step e), AdmissibleStep z z'
  apply ae_finsetSum_measure_iff.mpr
  intro e _
  apply Measure.ae_smul_measure
  apply (ae_dirac_iff _).mpr
  · exact ⟨e, rfl⟩
  · exact measurableSet_admissibleStep.preimage (measurable_const.prodMk measurable_id)

lemma stateTrajectory_admissible {d : ℕ} (z : State d) :
    ∀ᵐ X ∂stateTrajectory z, ∀ n, AdmissibleStep (X n) (X (n + 1)) := by
  rw [stateTrajectory, Kernel.comap_apply]
  apply ae_all_iff.mpr
  intro n
  let p := fun zz : ((i : Finset.Iic n) → State d) × State d =>
    AdmissibleStep (zz.1 ⟨n, Finset.mem_Iic.mpr le_rfl⟩) zz.2
  have hm : Measurable (fun zz : ((i : Finset.Iic n) → State d) × State d =>
      (zz.1 ⟨n, Finset.mem_Iic.mpr le_rfl⟩, zz.2)) := by fun_prop
  have hp : MeasurableSet {zz | p zz} :=
    measurableSet_admissibleStep.preimage hm
  have h : ∀ᵐ zz ∂(Kernel.partialTraj (X := fun _ => State d) (historyTransition (d := d)) 0 n (fun _ => z))
      ⊗ₘ historyTransition (d := d) n, p zz := by
    apply Measure.ae_compProd_of_ae_ae hp
    exact ae_of_all _ fun x => transition_admissible _
  rw [Kernel.partialTraj_compProd_eq_map_traj (Nat.zero_le n)] at h
  exact (ae_map_iff (by fun_prop) hp).mp h

lemma stateTrajectory_environment {d : ℕ} (z : State d) :
    ∀ᵐ X ∂stateTrajectory z, ∀ n, (X n).1 = z.1 := by
  have h0 : ∀ᵐ X ∂stateTrajectory z, X 0 = z := by
    have h : ∀ᵐ y ∂(stateTrajectory z).map (fun X => X 0), y = z := by
      rw [stateTrajectory_initial]
      exact (ae_dirac_iff (measurableSet_singleton _)).mpr rfl
    exact (ae_map_iff (measurable_pi_apply 0).aemeasurable
      (measurableSet_singleton _)).mp h
  filter_upwards [h0, stateTrajectory_admissible z] with X hX hstep n
  induction n with
  | zero => rw [hX]
  | succ n ih =>
    obtain ⟨e, he⟩ := hstep n
    rw [he]
    exact ih

lemma quenched_nearest_neighbor {d : ℕ} (z : State d) :
    ∀ᵐ X ∂quenchedKernel z, ∀ n, ∃ e : Direction d, X (n + 1) = X n + step e := by
  have hm : Measurable (fun z : ℕ → State d => fun n => (z n).2) := by fun_prop
  rw [quenchedKernel, Kernel.map_apply _ hm]
  apply (ae_map_iff hm.aemeasurable _).mpr
  · filter_upwards [stateTrajectory_admissible z] with X hX n
    obtain ⟨e, he⟩ := hX n
    exact ⟨e, congrArg Prod.snd he⟩
  · simp only [Set.ofPred_forall, Set.ofPred_exists]
    apply MeasurableSet.iInter
    intro n
    apply MeasurableSet.iUnion
    intro e
    exact measurableSet_eq_fun (measurable_pi_apply _) ((measurable_pi_apply _).add_const _)

lemma step_injective {d : ℕ} : Function.Injective (step (d := d)) := by
  rintro ⟨i, b⟩ ⟨j, c⟩ he
  have hij : i = j := by
    by_contra hne
    have hi := congrFun he i
    cases b <;> simp [step, hne] at hi
  subst j
  have hi := congrFun he i
  cases b <;> cases c <;> simp_all [step]

lemma transition_singleton_step {d : ℕ} (z : State d) (e : Direction d) :
    transition z {(z.1, z.2 + step e)} = ((z.1 z.2).1 e : ℝ≥0∞) := by
  change (∑ f : Direction d,
    ((z.1 z.2).1 f : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step f))
      {(z.1, z.2 + step e)} = _
  simp only [Measure.finsetSum_apply, Measure.smul_apply, smul_eq_mul]
  rw [Finset.sum_eq_single e]
  · simp
  · intro f _ hne
    have hh : (z.1, z.2 + step f) ∉ ({(z.1, z.2 + step e)} : Set (State d)) := by
      intro he
      apply hne
      exact step_injective (add_left_cancel (congrArg Prod.snd (Set.mem_singleton_iff.mp he)))
    simp [Measure.dirac_apply' _ (measurableSet_singleton _), hh]
  · simp

def stateCylinder {d : ℕ} (f : ℕ → State d) (n : ℕ) : Set (ℕ → State d) :=
  {X | ∀ i ≤ n, X i = f i}

lemma measurableSet_stateCylinder {d : ℕ} (f : ℕ → State d) (n : ℕ) :
    MeasurableSet (stateCylinder f n) := by
  simp only [stateCylinder, Set.ofPred_forall]
  exact MeasurableSet.iInter fun i => MeasurableSet.iInter fun _ =>
    measurableSet_eq_fun (measurable_pi_apply i : Measurable (fun X : ℕ → State d => X i))
      measurable_const

lemma stateCylinder_eq_preimage {d : ℕ} (f : ℕ → State d) (n : ℕ) :
    stateCylinder f n = (fun X : ℕ → State d => Preorder.frestrictLe n X) ⁻¹' {fun i : Finset.Iic n => f i} := by
  ext X
  simp only [stateCylinder, Set.mem_ofPred_eq, Set.mem_preimage, Set.mem_singleton_iff]
  constructor
  · intro h
    funext i
    exact h i (Finset.mem_Iic.mp i.2)
  · intro h i hi
    exact congrFun h ⟨i, Finset.mem_Iic.mpr hi⟩

lemma stateTrajectory_cylinder_succ {d : ℕ} (z : State d) (f : ℕ → State d) (n : ℕ) :
    stateTrajectory z (stateCylinder f (n + 1)) =
      transition (f n) {f (n + 1)} * stateTrajectory z (stateCylinder f n) := by
  rw [stateTrajectory, Kernel.comap_apply]
  have h := Kernel.partialTraj_compProd_eq_map_traj (X := fun _ => State d)
    (κ := historyTransition (d := d)) (x₀ := fun _ => z) (Nat.zero_le n)
  have hm : Measurable (fun X : ℕ → State d => (Preorder.frestrictLe n X, X (n + 1))) := by
    fun_prop
  have he : (fun X : ℕ → State d => (Preorder.frestrictLe n X, X (n + 1))) ⁻¹'
      ({fun i : Finset.Iic n => f i} ×ˢ {f (n + 1)}) = stateCylinder f (n + 1) := by
    ext X
    simp only [Set.mem_preimage, Set.mem_prod, Set.mem_singleton_iff,
      stateCylinder, Set.mem_ofPred_eq]
    constructor
    · rintro ⟨h₁, h₂⟩ i hi
      obtain hi | rfl := Nat.lt_or_eq_of_le hi
      · exact congrFun h₁ ⟨i, Finset.mem_Iic.mpr (by omega)⟩
      · exact h₂
    · intro hX
      exact ⟨funext fun i => hX i (by have := Finset.mem_Iic.mp i.2; omega), hX _ le_rfl⟩
  have hs := congrArg (fun μ : Measure (((i : Finset.Iic n) → State d) × State d) =>
    μ ({fun i : Finset.Iic n => f i} ×ˢ {f (n + 1)})) h
  rw [Measure.compProd_apply_prod (measurableSet_singleton _) (measurableSet_singleton _),
    lintegral_singleton, Measure.map_apply hm
      ((measurableSet_singleton _).prod (measurableSet_singleton _)), he] at hs
  rw [← hs]
  congr 1
  rw [stateCylinder_eq_preimage, ← Measure.map_apply (Preorder.measurable_frestrictLe n)
    (measurableSet_singleton _), Kernel.traj_map_frestrictLe_apply]

lemma stateTrajectory_cylinder {d : ℕ} (z : State d) (f : ℕ → State d)
    (hf : f 0 = z) (n : ℕ) :
    stateTrajectory z (stateCylinder f n) =
      ∏ i ∈ Finset.range n, transition (f i) {f (i + 1)} := by
  induction n with
  | zero =>
    have he : stateCylinder f 0 = (fun X : ℕ → State d => X 0) ⁻¹' {z} := by
      ext X
      simp [stateCylinder, hf]
    rw [he, ← Measure.map_apply (measurable_pi_apply 0) (measurableSet_singleton _),
      stateTrajectory_initial]
    simp
  | succ n ih =>
    rw [stateTrajectory_cylinder_succ, ih, Finset.prod_range_succ, mul_comm]

abbrev rowSigma {d : ℕ} (S : Set (Lattice d)) : MeasurableSpace (Environment d) :=
  ⨆ x ∈ S, MeasurableSpace.comap (fun ω : Environment d => ω x) inferInstance

lemma rowSigma_le {d : ℕ} (S : Set (Lattice d)) : rowSigma S ≤ (inferInstance : MeasurableSpace (Environment d)) := by
  exact iSup_le fun x => iSup_le fun _ => (measurable_pi_apply x).comap_le

lemma measurable_row_on {d : ℕ} {S : Set (Lattice d)} {x : Lattice d} (hx : x ∈ S) :
    @Measurable _ _ (rowSigma S) _ (fun ω : Environment d => ω x) := by
  apply Measurable.of_comap_le
  exact le_iSup_of_le x (le_iSup_of_le hx le_rfl)

lemma environment_indep_rows {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    {S T : Set (Lattice d)} (hST : Disjoint S T) :
    Indep (rowSigma S) (rowSigma T) (environmentLaw ν) := by
  exact indep_iSup_of_disjoint (fun x => (measurable_pi_apply x).comap_le)
    (iIndepFun_infinitePi (P := fun _ : Lattice d => ν)
      (X := fun _ p => p) (fun _ => measurable_id)).iIndep hST

lemma rowSigma_mono {d : ℕ} {S T : Set (Lattice d)} (hST : S ⊆ T) :
    rowSigma S ≤ rowSigma T :=
  iSup₂_le fun x hx => le_iSup_of_le x (le_iSup_of_le (hST hx) le_rfl)

lemma environment_tail_zero_one {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν]
    {E : Set (Environment d)}
    (hE : ∀ S ∈ (cofinite : Filter (Lattice d)), MeasurableSet[rowSigma S] E) :
    environmentLaw ν E = 0 ∨ environmentLaw ν E = 1 := by
  let s : Lattice d → MeasurableSpace (Environment d) := fun x =>
    MeasurableSpace.comap (fun ω : Environment d => ω x) inferInstance
  have hind : iIndep s (environmentLaw ν) :=
    (iIndepFun_infinitePi (P := fun _ : Lattice d => ν)
      (X := fun _ p => p) (fun _ => measurable_id)).iIndep
  have ht : MeasurableSet[limsup s cofinite] E := by
    rw [limsup_eq_iInf_iSup]
    apply MeasurableSpace.measurableSet_iInf.mpr
    intro S
    apply MeasurableSpace.measurableSet_iInf.mpr
    exact hE S
  apply measure_zero_or_one_of_measurableSet_limsup
    (s := s) (p := Set.Finite) (ns := fun F : Finset (Lattice d) => (F : Set (Lattice d)))
    (fun x => (measurable_pi_apply x).comap_le) hind
    (fun S hS => by simpa only [mem_cofinite, compl_compl] using hS) _
    (fun F => F.finite_toSet) (fun x => ⟨{x}, by simp⟩) ht
  intro F G
  exact ⟨F ∪ G, Finset.coe_subset.mpr Finset.subset_union_left,
    Finset.coe_subset.mpr Finset.subset_union_right⟩

end DirectionalTransience
end
end

end OAI