import OAI.Probability.GammaPassage.BKLimit

namespace OAI

namespace GammaFPP.BK
open MeasureTheory ProbabilityTheory Set Finset Filter PlanarFPP
open scoped ENNReal
variable {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {τ : Edge → Ω → ℝ}
variable {shape rate : ℝ}

lemma bitFamily_subset (D : ℝ → ℝ) (S : Finset Edge) (t : ℕ)
    (F : Set StrictPathWitness) : bitFamily D S t F ⊆ (S.product (Finset.univ : Finset (Fin t))).powerset := by
  intro x hx
  exact Finset.mem_powerset.mpr ((mem_bitFamily ..).mp hx).1

lemma bitDisjointFamily_subset (D : ℝ → ℝ) (S : Finset Edge) (t : ℕ)
    (Fs : List (Set StrictPathWitness)) :
    bitDisjointFamily D S t Fs ⊆ (S.product (Finset.univ : Finset (Fin t))).powerset := by
  classical
  exact Finset.filter_subset _ _

lemma single_mass_le (h : GammaEnvironment shape rate P τ) (hs : 0 < shape) (hr : 0 < rate)
    (S : Finset Edge) (t : ℕ) (F : Set StrictPathWitness) :
    fairFamilyMass (S.product (Finset.univ : Finset (Fin t))) (bitFamily (gammaSurvivalQuantile hs hr) S t F) ≤
      P.real {ω | StrictPathEvent S F (fun e => τ e ω)} := by
  let _ := h.probability
  have hmass : P.real (⋃ x ∈ bitFamily (gammaSurvivalQuantile hs hr) S t F,
      gammaDyadicRankCell shape rate τ S t x) =
      fairFamilyMass (S.product (Finset.univ : Finset (Fin t)))
        (bitFamily (gammaSurvivalQuantile hs hr) S t F) := by
    simpa only [Finset.product_eq_sprod] using
      h.gammaDyadicRankCells_real hs hr S t
        (bitFamily (gammaSurvivalQuantile hs hr) S t F)
        (bitFamily_subset (gammaSurvivalQuantile hs hr) S t F)
  rw [← hmass]
  apply ENNReal.toReal_mono (measure_ne_top _ _)
  apply measure_mono_ae
  filter_upwards [h.ae_positive] with ω hpos
  intro hω
  obtain ⟨x,hx⟩ := Set.mem_iUnion.mp hω
  obtain ⟨hx,hcell⟩ := Set.mem_iUnion.mp hx
  obtain ⟨_,p,hp,he,hgood⟩ := (mem_bitFamily ..).mp hx
  exact ⟨p,hp,he,rounded_original hs hr (fun e => (hpos e).le)
    ((cell_path_iff hs hr hcell p he).mpr hgood)⟩

lemma rounded_disjoint_mass_le (h : GammaEnvironment shape rate P τ)
    (hs : 0 < shape) (hr : 0 < rate) (S : Finset Edge) (t : ℕ)
    (Fs : List (Set StrictPathWitness)) :
    P.real {ω | RoundedDisjoint hs hr S Fs t (fun e => τ e ω)} ≤
      fairFamilyMass (S.product (Finset.univ : Finset (Fin t))) (bitDisjointFamily (gammaSurvivalQuantile hs hr) S t Fs) := by
  classical
  let _ := h.probability
  have hmass : P.real (⋃ x ∈ bitDisjointFamily (gammaSurvivalQuantile hs hr) S t Fs,
      gammaDyadicRankCell shape rate τ S t x) =
      fairFamilyMass (S.product (Finset.univ : Finset (Fin t)))
        (bitDisjointFamily (gammaSurvivalQuantile hs hr) S t Fs) := by
    simpa only [Finset.product_eq_sprod] using
      h.gammaDyadicRankCells_real hs hr S t
        (bitDisjointFamily (gammaSurvivalQuantile hs hr) S t Fs)
        (bitDisjointFamily_subset (gammaSurvivalQuantile hs hr) S t Fs)
  rw [← hmass]
  apply ENNReal.toReal_mono (measure_ne_top _ _)
  apply measure_mono_ae
  filter_upwards [h.ae_gammaDyadicRankCell hs hr S t] with ω hω
  intro hd
  obtain ⟨x,hx,hcell⟩ := hω
  obtain ⟨ps,hps,hdis⟩ := hd
  have hmem : x ∈ bitDisjointFamily (gammaSurvivalQuantile hs hr) S t Fs := by
    apply Finset.mem_filter.mpr
    refine ⟨hx,ps,?_,hdis⟩
    exact hps.imp (fun p _ hp =>
      ⟨hp.1,hp.2.1,(cell_path_iff hs hr hcell p hp.2.1).mp hp.2.2⟩)
  exact Set.mem_iUnion.mpr ⟨x,Set.mem_iUnion.mpr ⟨hmem,hcell⟩⟩

lemma probabilities_nonneg (S : Finset Edge) (Fs : List (Set StrictPathWitness)) :
    0 ≤ (Fs.map (fun F => P.real {ω | StrictPathEvent S F (fun e => τ e ω)})).prod := by
  induction Fs with
  | nil => simp
  | cons F Fs ih => exact mul_nonneg measureReal_nonneg ih

lemma factors_le (h : GammaEnvironment shape rate P τ) (hs : 0 < shape) (hr : 0 < rate)
    (S : Finset Edge) (t : ℕ) (Fs : List (Set StrictPathWitness)) :
    (Fs.map (fun F => fairFamilyMass (S.product (Finset.univ : Finset (Fin t)))
      (bitFamily (gammaSurvivalQuantile hs hr) S t F))).prod ≤
    (Fs.map (fun F => P.real {ω | StrictPathEvent S F (fun e => τ e ω)})).prod := by
  induction Fs with
  | nil => simp
  | cons F Fs ih =>
    simp only [List.map_cons,List.prod_cons]
    exact (mul_le_mul_of_nonneg_left ih (fairFamilyMass_nonneg _ _)).trans
      (mul_le_mul_of_nonneg_right (single_mass_le h hs hr S t F)
        (probabilities_nonneg (P := P) (τ := τ) S Fs))

theorem gamma_rounded_strict_path_BK (h : GammaEnvironment shape rate P τ)
    (hs : 0 < shape) (hr : 0 < rate) (S : Finset Edge) (t : ℕ)
    (Fs : List (Set StrictPathWitness)) :
    P.real {ω | RoundedDisjoint hs hr S Fs t (fun e => τ e ω)} ≤
      (Fs.map (fun F => P.real {ω | StrictPathEvent S F (fun e => τ e ω)})).prod :=
  (rounded_disjoint_mass_le h hs hr S t Fs).trans
    ((gamma_decoder_finite_path_BK hs hr S t Fs).trans (factors_le h hs hr S t Fs))

/-- Finite-path repeated BK in the actual Gamma environment, for every
positive real shape and rate. Fs may repeat and regions may overlap; only the
chosen paths' undirected edge sets must be pairwise disjoint. -/
theorem gamma_strict_path_BK (h : GammaEnvironment shape rate P τ)
    (hs : 0 < shape) (hr : 0 < rate) (S : Finset Edge)
    (Fs : List (Set StrictPathWitness)) :
    P.real {ω | StrictDisjointPaths S Fs (fun e => τ e ω)} ≤
      (Fs.map (fun F => P.real {ω | StrictPathEvent S F (fun e => τ e ω)})).prod := by
  let _ := h.probability
  let C : ℝ := (Fs.map (fun F => P.real {ω | StrictPathEvent S F (fun e => τ e ω)})).prod
  have hC : 0 ≤ C := probabilities_nonneg (P := P) (τ := τ) S Fs
  have hh := ae_eventual_measure_le P
    {ω | StrictDisjointPaths S Fs (fun e => τ e ω)}
    (fun t => {ω | RoundedDisjoint hs hr S Fs t (fun e => τ e ω)})
    (ENNReal.ofReal C) (by
      filter_upwards [h.ae_positive] with ω hpos
      intro hω
      exact disjoint_eventually_rounded hs hr (fun e => (hpos e).le) hω) (fun t => by
        calc
          P {ω | RoundedDisjoint hs hr S Fs t (fun e => τ e ω)} =
              ENNReal.ofReal (P.real {ω | RoundedDisjoint hs hr S Fs t (fun e => τ e ω)}) :=
            (ENNReal.ofReal_toReal (measure_ne_top _ _)).symm
          _ ≤ ENNReal.ofReal C := ENNReal.ofReal_le_ofReal
            (gamma_rounded_strict_path_BK h hs hr S t Fs))
  exact (ENNReal.toReal_mono ENNReal.ofReal_ne_top hh).trans_eq (ENNReal.toReal_ofReal hC)
end GammaFPP.BK

end OAI