import Mathlib
import OAI.Analysis.HardSphere.Cutoffs.PathLift
import OAI.Analysis.HardSphere.Orbitals.CellPartition
import OAI.Analysis.HardSphere.Conditioning.Sampling

namespace OAI

section

section
noncomputable section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal BigOperators
namespace HardSphere.Sampling
variable {I : Type*} [Fintype I] [DecidableEq I]

abbrev Allocation (m : ℕ) (I : Type*) := Option (Fin m ↪ I)
instance allocationMeasurable (m : ℕ) : MeasurableSpace (Allocation m I) := ⊤
instance allocationSingletons (m : ℕ) : MeasurableSingletonClass (Allocation m I) := ⟨fun _ ↦ trivial⟩
instance allocationFintype (m : ℕ) : Fintype (Allocation m I) := inferInstanceAs (Fintype (Option (Fin m↪I)))

def allocationPMF (E : Finset I) (m : ℕ) : PMF (Allocation m I) := by
  classical
  by_cases h : m≤E.card
  · haveI : Nonempty (Fin m↪E) := Function.Embedding.nonempty_of_card_le (by simpa using h)
    exact (PMF.uniformOfFintype (Fin m↪E)).map (fun f ↦ some (f.trans (Function.Embedding.subtype _)))
  · exact PMF.pure none

omit [Fintype I] [DecidableEq I] in
lemma allocationPMF_large (E : Finset I) (m : ℕ) (h : m≤E.card)
    [Nonempty (Fin m↪E)] :
    allocationPMF E m=(PMF.uniformOfFintype (Fin m↪E)).map (fun f ↦ some (f.trans (Function.Embedding.subtype _))) := by
  simp [allocationPMF,h]

omit [Fintype I] [DecidableEq I] in
lemma allocationPMF_small (E : Finset I) (m : ℕ) (h : ¬m≤E.card) :
    allocationPMF E m=PMF.pure none := by simp [allocationPMF,h]

omit [Fintype I] [DecidableEq I] in
lemma allocationPMF_support (E : Finset I) (m : ℕ) (a : Allocation m I)
    (h : a∈(allocationPMF E m).support) :
    ∀f,a=some f→∀k,f k∈E := by
  classical
  by_cases hm : m≤E.card
  · have : Nonempty (Fin m↪E) := Function.Embedding.nonempty_of_card_le (by simpa using hm)
    rw [allocationPMF_large E m hm,PMF.support_map] at h
    obtain ⟨g,_,rfl⟩ := h
    intro f hf k
    have he : g.trans (Function.Embedding.subtype _)=f := Option.some.inj hf
    exact he ▸ (g k).property
  · rw [allocationPMF_small E m hm,PMF.support_pure] at h
    have ha : a=none := h
    simp only [ha,reduceCtorEq,false_implies,implies_true]

def allocationKernel (m : ℕ) : Kernel (Finset I) (Allocation m I) :=
  ⟨fun E ↦ (allocationPMF E m).toMeasure,measurable_of_countable _⟩
instance allocationKernel_markov (m : ℕ) : IsMarkovKernel (allocationKernel (I:=I) m) :=
  ⟨fun E ↦ by change IsProbabilityMeasure (allocationPMF E m).toMeasure; infer_instance⟩

omit [Fintype I] [DecidableEq I] in
lemma allocated_group_uniform (E : Finset I) (m q : ℕ) (h : m≤E.card)
    (group : Fin q↪Fin m) :
    (allocationPMF E m).map (Option.map (fun f ↦ group.trans f))=allocationPMF E q := by
  classical
  have hqm : q ≤ m := by simpa using Fintype.card_le_of_embedding group
  have hq : q≤E.card := hqm.trans h
  have : Nonempty (Fin m↪E) := Function.Embedding.nonempty_of_card_le (by simpa using h)
  have : Nonempty (Fin q↪E) := Function.Embedding.nonempty_of_card_le (by simpa using hq)
  rw [allocationPMF_large E m h,allocationPMF_large E q hq,PMF.map_comp]
  have hu := congrArg (fun P : PMF (Fin q↪E) ↦ P.map (fun f ↦ some (f.trans (Function.Embedding.subtype _))))
    (embedding_restriction_uniform (V:=E) group)
  rw [PMF.map_comp] at hu
  exact hu

lemma allocation_half_bad (E B : Finset I) (m : ℕ) (hE : 2*m≤E.card)
    (hB : 10*(E∩B).card≤E.card) :
    (allocationPMF E (2*m)).toMeasure
      {a | ∃f,a=some f ∧ m≤(Finset.univ.filter (fun k ↦ f k∈B)).card}≤
      ENNReal.ofReal ((2/5:ℝ)^m) := by
  classical
  have : Nonempty (Fin (2*m)↪E) := Function.Embedding.nonempty_of_card_le (by simpa using hE)
  let : MeasurableSpace (Fin (2*m)↪E) := ⊤
  let : MeasurableSingletonClass (Fin (2*m)↪E) := ⟨fun _ ↦ trivial⟩
  by_cases hempty : E.Nonempty
  · have : Nonempty E := hempty.to_subtype
    rw [allocationPMF_large E (2*m) hE,←PMF.toMeasure_map _ _ (measurable_of_countable _)]
    rw [Measure.map_apply (measurable_of_countable _) (by exact MeasurableSet.of_discrete)]
    let bad : Set E := {i | i.val∈B}
    have hc : Fintype.card bad=(E∩B).card := by
      let equiv : bad ≃ (E∩B : Finset I) :=
        { toFun := fun i ↦ ⟨i.val.val,Finset.mem_inter.mpr ⟨i.val.property,i.property⟩⟩
          invFun := fun i ↦ ⟨⟨i.val,(Finset.mem_inter.mp i.property).1⟩,(Finset.mem_inter.mp i.property).2⟩
          left_inv := fun i ↦ by cases i; rfl
          right_inv := fun i ↦ by cases i; rfl }
      exact (Fintype.card_congr equiv).trans (Fintype.card_coe (E∩B))
    have hb : (Nat.card bad:ℝ)≤(Fintype.card E:ℝ)/10 := by
      rw [Nat.card_eq_fintype_card,hc,Fintype.card_coe]
      have hb' : (10:ℝ)*((E∩B).card:ℝ)≤(E.card:ℝ) := by exact_mod_cast hB
      linarith
    rw [PMF.toMeasure_apply_eq_toOuterMeasure_apply _ (by exact MeasurableSet.of_discrete)]
    have hset : (fun f : Fin (2*m)↪E ↦ some (f.trans (Function.Embedding.subtype _))) ⁻¹'
        {a : Allocation (2*m) I | ∃f,a=some f ∧ m≤(Finset.univ.filter (fun k ↦ f k∈B)).card}=
        {f : Fin (2*m)↪E | m≤(Finset.univ.filter (fun k ↦ f k∈bad)).card} := by
      ext f
      simp [bad]
    rw [hset]
    have he : ENNReal.ofReal ((2/5:ℝ)^m)=(2/5:ℝ≥0∞)^m := by
      rw [ENNReal.ofReal_pow (by norm_num),ENNReal.ofReal_div_of_pos (by norm_num)]
      norm_num
    rw [he]
    convert uniform_half_bad (V:=E) m bad hb using 1
    congr 1
    ext f
    simp only [Set.mem_ofPred_eq]
    apply iff_of_eq
    congr 1
    congr 1
    ext k
    simp only [Finset.mem_filter,Finset.mem_univ,true_and]
  · have hz : E=∅ := Finset.not_nonempty_iff_eq_empty.mp hempty
    have hm : m=0 := by simp [hz] at hE; omega
    subst m
    simp only [pow_zero,ENNReal.ofReal_one]
    exact prob_le_one

end HardSphere.Sampling

end
end

section
noncomputable section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal Topology BigOperators
namespace HardSphere.Groups
open Wiener CellOrbital
attribute [local instance] Classical.propDecidable
attribute [local irreducible] torusDistance

def Confined {L : Length} (v : Torus L) (ω : ConfigurationPath 1 L) : Prop :=
  ∀s : Time,torusDistance L (ω s 0) v≤10

lemma confined_closed {L : Length} (v : Torus L) : IsClosed {ω | Confined v ω} := by
  simp only [Confined,ofPred_forall]
  apply isClosed_iInter
  intro s
  apply isClosed_le _ continuous_const
  exact (torusDistance_continuous_pair L).comp (f:=fun ω : ConfigurationPath 1 L ↦ (ω s 0,v)) (by fun_prop)

def EndpointEligible {N K : ℕ} {L : Length} (v : Fin 3→Fin K) (s₀ : ℝ)
    (Y Z : Configuration N L) (i : Fin N) : Prop :=
  Y i∈centeredCell L (gridCenter L v) ∧
  torusDistance L (Z i) (gridCenter L v)≤3 ∧
  ∀j,j≠i→s₀<torusDistance L (Y i) (Y j) ∧ s₀<torusDistance L (Z i) (Z j)

lemma endpointEligible_measurable {N K : ℕ} {L : Length} (v : Fin 3→Fin K) (s₀ : ℝ) (i : Fin N) :
    MeasurableSet {p : Configuration N L×Configuration N L | EndpointEligible v s₀ p.1 p.2 i} := by
  have h₁ : MeasurableSet {p : Configuration N L×Configuration N L | p.1 i∈centeredCell L (gridCenter L v)} :=
    (centeredCell_measurable L _).preimage ((measurable_pi_apply i).comp measurable_fst)
  have h₂ : MeasurableSet {p : Configuration N L×Configuration N L | torusDistance L (p.2 i) (gridCenter L v)≤3} :=
    measurableSet_le ((torusDistance_continuous_pair L).measurable.comp
      (f:=fun p : Configuration N L×Configuration N L ↦ (p.2 i,gridCenter L v)) (by fun_prop)) measurable_const
  have h₃ : MeasurableSet {p : Configuration N L×Configuration N L | ∀j,j≠i→
      s₀<torusDistance L (p.1 i) (p.1 j) ∧ s₀<torusDistance L (p.2 i) (p.2 j)} := by
    simp only [ofPred_forall]
    apply MeasurableSet.iInter
    intro j
    apply MeasurableSet.iInter
    intro hj
    exact (measurableSet_lt measurable_const ((torusDistance_continuous_pair L).measurable.comp
      (f:=fun p : Configuration N L×Configuration N L ↦ (p.1 i,p.1 j)) (by fun_prop))).inter
      (measurableSet_lt measurable_const ((torusDistance_continuous_pair L).measurable.comp
      (f:=fun p : Configuration N L×Configuration N L ↦ (p.2 i,p.2 j)) (by fun_prop)))
  exact h₁.inter (h₂.inter h₃)

def Eligible {N K : ℕ} {L : Length} (m : ℕ) (r R C S s₀ : ℝ) (u : Time)
    (v : Fin 3→Fin K) (i : Fin N) (ω : ConfigurationPath N L) : Prop :=
  EndpointEligible v s₀ (ω 0) (ω 1) i ∧
  PathCutoff.Regular m r R C u S (onePathAt i ω) ∧ Confined (gridCenter L v) (onePathAt i ω)

lemma eligible_measurable {N K : ℕ} {L : Length} (m : ℕ) (r R C S s₀ : ℝ) (u : Time)
    (v : Fin 3→Fin K) (i : Fin N) : MeasurableSet {ω | Eligible (L:=L) m r R C S s₀ u v i ω} :=
  ((endpointEligible_measurable v s₀ i).preimage
    ((continuous_eval_const 0).measurable.prodMk (continuous_eval_const 1).measurable)).inter
      (((PathCutoff.regular_measurable m r R C u S).preimage (onePathAt_continuous i).measurable).inter
        ((confined_closed (gridCenter L v)).measurableSet.preimage (onePathAt_continuous i).measurable))

def eligibleList {N K : ℕ} {L : Length} (m : ℕ) (r R C S s₀ : ℝ) (u : Time)
    (v : Fin 3→Fin K) (ω : ConfigurationPath N L) : Finset (Fin N) :=
  Finset.univ.filter (fun i ↦ Eligible m r R C S s₀ u v i ω)

lemma eligibleList_disjoint {N K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) (hK : 1≤K)
    (m : ℕ) (r R C S s₀ : ℝ) (u : Time) (ω : ConfigurationPath N L)
    {v w : Fin 3→Fin K} (hvw : v≠w) :
    Disjoint (eligibleList m r R C S s₀ u v ω) (eligibleList m r R C S s₀ u w ω) := by
  apply Finset.disjoint_left.mpr
  intro i hi hj
  exact Set.disjoint_left.mp (centeredCell_disjoint hL hK hvw)
    (Finset.mem_filter.mp hi).2.1.1 (Finset.mem_filter.mp hj).2.1.1

lemma eligibleList_measurable {N K : ℕ} {L : Length} (m : ℕ) (r R C S s₀ : ℝ) (u : Time)
    (v : Fin 3→Fin K) : Measurable (eligibleList (N:=N) (L:=L) m r R C S s₀ u v) := by
  apply measurable_to_countable'
  intro a
  have h : eligibleList (N:=N) (L:=L) m r R C S s₀ u v ⁻¹' {a}=
      ⋂i : Fin N, {ω | (i∈a) ↔ Eligible m r R C S s₀ u v i ω} := by
    ext ω
    simp only [mem_preimage,mem_singleton_iff,mem_iInter,mem_ofPred_eq]
    constructor
    · intro h i
      rw [←h]
      simp [eligibleList]
    · intro h
      ext i
      simpa only [eligibleList,Finset.mem_filter,Finset.mem_univ,true_and] using (h i).symm
  rw [h]
  apply MeasurableSet.iInter
  intro i
  by_cases hi : i∈a
  · simpa only [hi,true_iff] using eligible_measurable (N:=N) (L:=L) m r R C S s₀ u v i
  · simpa only [hi,false_iff,←Set.compl_ofPred] using (eligible_measurable (N:=N) (L:=L) m r R C S s₀ u v i).compl

end HardSphere.Groups

end
end

end

end OAI