import Mathlib
import OAI.Probability.CriticalPercolation.ProductMeasure.ProductConditioning

namespace OAI

section
section
noncomputable section
open Set Function MeasureTheory ProbabilityTheory
open scoped Classical BigOperators ENNReal

namespace CriticalPercolation.BernoulliProduct

structure RevealPartition (E I : Type*) [Fintype I] where
  block : I → Set E
  cell : I → Set (Set E)
  measurable : ∀ i, MeasurableSet[blockSigma (block i)] (cell i)
  disjoint : Pairwise (Disjoint on cell)
  cover : (⋃ i, cell i)=Set.univ

namespace RevealPartition
variable {E I : Type*} [Fintype I] (P : RevealPartition E I)

lemma cell_measurable (i : I) : MeasurableSet (P.cell i) :=
  (blockSigma_le (P.block i)) _ (P.measurable i)

lemma exists_cell (σ : Set E) : ∃ i, σ∈P.cell i := by
  have h : σ∈⋃ i, P.cell i := by rw [P.cover]; trivial
  exact Set.mem_iUnion.mp h

lemma cell_unique {σ : Set E} {i j : I} (hi : σ∈P.cell i) (hj : σ∈P.cell j) : i=j := by
  by_contra h
  exact Set.disjoint_left.mp (P.disjoint h) hi hj

@[instance_reducible] def historySigma : MeasurableSpace (Set E) where
  MeasurableSet' A := ∀ i, MeasurableSet[blockSigma (P.block i)] (A∩P.cell i)
  measurableSet_empty := by intro i; simp
  measurableSet_compl := by
    intro A hA i
    have he : Aᶜ∩P.cell i=P.cell i\(A∩P.cell i) := by ext σ; simp; tauto
    rw [he]
    exact (P.measurable i).diff (hA i)
  measurableSet_iUnion := by
    intro A hA i
    rw [Set.iUnion_inter]
    exact MeasurableSet.iUnion (fun n => hA n i)

lemma historySigma_le : P.historySigma ≤ (inferInstance : MeasurableSpace (Set E)) := by
  intro A hA
  have he : A=⋃ i, A∩P.cell i := by rw [← Set.inter_iUnion,P.cover,Set.inter_univ]
  rw [he]
  exact MeasurableSet.iUnion (fun i => (blockSigma_le (P.block i)) _ (hA i))

lemma cell_history_measurable (i : I) : MeasurableSet[P.historySigma] (P.cell i) := by
  intro j
  by_cases hij : i=j
  · subst j
    simpa using P.measurable i
  · have he := Set.disjoint_iff_inter_eq_empty.mp (P.disjoint hij)
    rw [he]
    exact @MeasurableSet.empty (Set E) (blockSigma (P.block j))

def probability (q : E → unitInterval) (A : Set (Set E)) (σ : Set E) : ℝ≥0∞ :=
  ∑ i, (P.cell i).indicator (blockProbability q (P.block i) A) σ

lemma probability_on_cell (q : E → unitInterval) (A : Set (Set E))
    {σ : Set E} {i : I} (hi : σ∈P.cell i) :
    P.probability q A σ=blockProbability q (P.block i) A σ := by
  rw [probability,Finset.sum_eq_single i]
  · exact Set.indicator_of_mem hi _
  · intro j _ hji
    apply Set.indicator_of_notMem
    intro hj
    exact hji (P.cell_unique hj hi)
  · simp

lemma probability_le_one (q : E → unitInterval) (A : Set (Set E)) (σ : Set E) :
    P.probability q A σ≤1 := by
  obtain ⟨i,hi⟩ := P.exists_cell σ
  rw [P.probability_on_cell q A hi]
  exact blockProbability_le_one _ _ _ _

lemma probability_measurable (q : E → unitInterval) (A : Set (Set E))
    (hA : MeasurableSet A) : @Measurable (Set E) ℝ≥0∞ P.historySigma inferInstance
      (P.probability q A) := by
  intro U hU i
  have he : P.probability q A ⁻¹' U∩P.cell i=
      blockProbability q (P.block i) A ⁻¹' U∩P.cell i := by
    ext σ
    constructor <;> intro h
    · exact ⟨by change blockProbability q (P.block i) A σ∈U
                rw [← P.probability_on_cell q A h.2]; exact h.1,h.2⟩
    · exact ⟨by rw [Set.mem_preimage,P.probability_on_cell q A h.2]; exact h.1,h.2⟩
  rw [he]
  exact ((measurable_blockProbability q (P.block i) A hA) hU).inter (P.measurable i)

theorem setLIntegral_probability (q : E → unitInterval) (A B : Set (Set E))
    (hA : MeasurableSet A) (hB : MeasurableSet[P.historySigma] B) :
    (∫⁻ σ in B, P.probability q A σ ∂law q)=law q (A∩B) := by
  have hmB := P.historySigma_le _ hB
  have hf (i : I) : Measurable ((P.cell i).indicator (blockProbability q (P.block i) A)) :=
    ((measurable_blockProbability q (P.block i) A hA).mono (blockSigma_le _) le_rfl).indicator
      (P.cell_measurable i)
  change (∫⁻ σ in B, ∑ i, (P.cell i).indicator (blockProbability q (P.block i) A) σ ∂law q)=_
  rw [lintegral_finsetSum _ (fun i _ => hf i)]
  have he (i : I) :
      (∫⁻ σ in B, (P.cell i).indicator (blockProbability q (P.block i) A) σ ∂law q)=
      law q (A∩(B∩P.cell i)) := by
    rw [lintegral_indicator (P.cell_measurable i),Measure.restrict_restrict
      (P.cell_measurable i),Set.inter_comm (P.cell i) B]
    exact setLIntegral_blockProbability q (P.block i) A (B∩P.cell i) hA (hB i)
  simp_rw [he]
  have hd : Pairwise (Disjoint on (fun i => A∩(B∩P.cell i))) := by
    intro i j hij
    exact (P.disjoint hij).mono (fun _ h => h.2.2) (fun _ h => h.2.2)
  rw [← tsum_fintype (L := .unconditional _),← measure_iUnion hd (fun i => hA.inter (hmB.inter (P.cell_measurable i)))]
  congr 1
  rw [← Set.inter_iUnion,← Set.inter_iUnion,P.cover,Set.inter_univ]

def enlarge (T : I → Set E) (hT : ∀ i, P.block i⊆T i) : RevealPartition E I where
  block := T
  cell := P.cell
  measurable i := (by
    have hmono : blockSigma (P.block i) ≤ blockSigma (T i) :=
      iSup₂_mono' (fun e he => ⟨e,hT i he,le_rfl⟩)
    exact hmono _ (P.measurable i))
  disjoint := P.disjoint
  cover := P.cover

def decide {J : Type*} [Fintype J] [MeasurableSpace J] [MeasurableSingletonClass J]
    (d : I → Set E → J)
    (hd : ∀ i, @Measurable (Set E) J (blockSigma (P.block i)) inferInstance (d i)) :
    RevealPartition E (I×J) where
  block ij := P.block ij.1
  cell ij := P.cell ij.1∩(d ij.1 ⁻¹' {ij.2})
  measurable ij := (P.measurable ij.1).inter (hd ij.1 (MeasurableSet.singleton _))
  disjoint := by
    intro ij kl hne
    apply Set.disjoint_left.mpr
    intro σ hσ hτ
    have hi : ij.1=kl.1 := P.cell_unique hσ.1 hτ.1
    have hj : ij.2=kl.2 := by
      have ht : d kl.1 σ=kl.2 := hτ.2
      rw [← hi] at ht
      exact hσ.2.symm.trans ht
    exact hne (Prod.ext hi hj)
  cover := by
    apply Set.eq_univ_of_forall
    intro σ
    obtain ⟨i,hi⟩ := P.exists_cell σ
    exact Set.mem_iUnion.mpr ⟨(i,d i σ),hi,rfl⟩

lemma historySigma_le_enlarge (T : I → Set E) (hT : ∀ i, P.block i⊆T i) :
    P.historySigma ≤ (P.enlarge T hT).historySigma := by
  intro A hA i
  have hmono : blockSigma (P.block i) ≤ blockSigma (T i) :=
    iSup₂_mono' (fun e he => ⟨e,hT i he,le_rfl⟩)
  exact hmono _ (hA i)

lemma historySigma_le_decide {J : Type*} [Fintype J] [MeasurableSpace J]
    [MeasurableSingletonClass J] (d : I → Set E → J)
    (hd : ∀ i, @Measurable (Set E) J (blockSigma (P.block i)) inferInstance (d i)) :
    P.historySigma ≤ (P.decide d hd).historySigma := by
  intro A hA ij
  change MeasurableSet[blockSigma (P.block ij.1)]
    (A∩(P.cell ij.1∩(d ij.1 ⁻¹' {ij.2})))
  rw [← Set.inter_assoc]
  exact (hA ij.1).inter (hd ij.1 (MeasurableSet.singleton _))

lemma measureReal_inter_le (q : E → unitInterval) (A B : Set (Set E))
    (hA : MeasurableSet A) (hB : MeasurableSet[P.historySigma] B)
    (ε : ℝ) (hε : 0≤ε)
    (hb : ∀ σ∈B, P.probability q A σ≤ENNReal.ofReal ε) :
    (law q).real (B∩A)≤ε*(law q).real B := by
  have hh : law q (A∩B)≤ENNReal.ofReal ε*law q B := by
    rw [← P.setLIntegral_probability q A B hA hB]
    calc
      (∫⁻ σ in B, P.probability q A σ ∂law q) ≤
          ∫⁻ _ in B, ENNReal.ofReal ε ∂law q :=
        setLIntegral_mono' (P.historySigma_le _ hB) hb
      _ = _ := by rw [lintegral_const,Measure.restrict_apply_univ]
  have ht := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.ofReal_ne_top
    (measure_ne_top _ _)) hh
  simpa only [Set.inter_comm A B,ENNReal.toReal_mul,ENNReal.toReal_ofReal hε,
    Measure.real] using ht

end RevealPartition
end CriticalPercolation.BernoulliProduct
end
end
end

end OAI