import OAI.Probability.SATComputability.ClauseProcess
import OAI.Probability.SATComputability.PoissonMaskAggregation

namespace OAI

namespace FixedClauseThreshold.Computability

open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped BigOperators NNReal Classical

abbrev SingleIncident (n : ℕ) := Fin 3 × SignedLiteral n × SignedLiteral n
abbrev BadIncident (n : ℕ) := (Fin 3 × SignedLiteral n) ⊕ Unit

def singleIncidentEquiv (n : ℕ) : SingleIncident n ≃ (Fin 2 → SignedLiteral n) × Fin 3 where
  toFun p := (![p.2.1,p.2.2],p.1)
  invFun p := (p.2,p.1 0,p.1 1)
  left_inv := by rintro ⟨i,a,b⟩; rfl
  right_inv := by
    rintro ⟨f,i⟩
    apply Prod.ext
    · funext j; fin_cases j <;> rfl
    · rfl

noncomputable def singleIncidentMask {n : ℕ} (p : SingleIncident n) :
    Finset (DeletionCandidate n) := clauseMask ![p.2.1,p.2.2]

theorem singleIncident_law {n : ℕ} [NeZero n] (r : ℝ≥0)
    (f : Finset (DeletionCandidate n) → ℝ) :
    (∫ c, f (countsMask singleIncidentMask c) ∂poissonCountLaw (SingleIncident n) r) =
      (candidateBlock (3*r*Fintype.card (Fin 2 → SignedLiteral n)) 2 Finset.univ).expect f := by
  have he : singleIncidentMask (n := n) =
      (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) ∘ singleIncidentEquiv n := rfl
  rw [he]
  simp_rw [countsMask_equiv]
  rw [show (∫ c, f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1)
      (c ∘ (singleIncidentEquiv n).symm)) ∂poissonCountLaw (SingleIncident n) r) =
      ∫ c, f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) c)
        ∂poissonCountLaw ((Fin 2 → SignedLiteral n) × Fin 3) r from by
      simpa only [Function.comp_def] using poissonCountLaw_equiv (singleIncidentEquiv n) r
        (fun c => f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) c)),
    poissonCountLaw_redundant_mask]
  rw [candidateBlock_counts]
  congr 2
  simp only [Fintype.card_fin, mul_div_cancel_right₀ _ (show
    (Fintype.card (Fin 2 → SignedLiteral n) : ℝ≥0) ≠ 0 by
      exact_mod_cast Fintype.card_ne_zero)]
  norm_num

theorem incident_killing_pointwise {n : ℕ} (U : Finset (DeletionCandidate n))
    (c : IncidentClass n → ℕ) :
    (if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0) ≤
      (if U ∩ countsMask singleIncidentMask (fun a => c (.inl a)) = ∅ then 1 else 0) +
      (∑ b : BadIncident n, c (.inr b) : ℕ) := by
  by_cases hz : ∑ b : BadIncident n, c (.inr b) = 0
  · have hb (b : BadIncident n) : c (.inr b) = 0 :=
      (Finset.sum_eq_zero_iff_of_nonneg (fun j _ => Nat.zero_le (c (.inr j)))).mp hz b
        (Finset.mem_univ b)
    have hm : countsMask incidentMask c =
        countsMask singleIncidentMask (fun a => c (.inl a)) := by
      ext x
      simp [countsMask, incidentMask, singleIncidentMask, Sum.forall, hb]
    rw [hm,hz,Nat.cast_zero,add_zero]
  · have hpos : (1 : ℝ) ≤ (∑ b : BadIncident n, c (.inr b) : ℕ) := by
      exact_mod_cast Nat.one_le_iff_ne_zero.mpr hz
    split_ifs <;> linarith

theorem incident_killing_bound {n : ℕ} [NeZero n] (r : ℝ≥0)
    (U : Finset (DeletionCandidate n)) :
    (∫ c, if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0
      ∂poissonCountLaw (IncidentClass n) r) ≤
      poissonKillProbability U 2 (3*r*Fintype.card (Fin 2 → SignedLiteral n)) +
      Fintype.card (BadIncident n)*(r : ℝ) := by
  let μ := poissonCountLaw (IncidentClass n) r
  let g := fun c : IncidentClass n → ℕ =>
    if U ∩ countsMask singleIncidentMask (fun a => c (.inl a)) = ∅ then (1 : ℝ) else 0
  let b := fun c : IncidentClass n → ℕ => ((∑ a : BadIncident n, c (.inr a) : ℕ) : ℝ)
  have hg : Integrable g μ := by
    apply Integrable.of_bound (measurable_of_countable _).aestronglyMeasurable 1
    filter_upwards [] with c
    dsimp only [g]
    split_ifs <;> norm_num
  have hres : HasLaw (fun c : IncidentClass n → ℕ => fun a : BadIncident n => c (.inr a))
      (poissonCountLaw (BadIncident n) r) μ :=
    ⟨(measurable_of_countable _).aemeasurable,
      poissonCountLaw_embedding Sum.inr Sum.inr_injective r⟩
  have hsum := (poissonCountLaw_hasLaw_sum (fun _ : BadIncident n => r)).comp hres
  have hb : Integrable b μ :=
    hsum.integrable_comp (poisson_integrable_count _)
  have hi : Integrable (fun c : IncidentClass n → ℕ =>
      if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0) μ := by
    apply Integrable.of_bound (measurable_of_countable _).aestronglyMeasurable 1
    filter_upwards [] with c
    split_ifs <;> norm_num
  have h := integral_mono hi (hg.add hb) (incident_killing_pointwise U)
  simp only [Pi.add_apply] at h
  rw [integral_add hg hb] at h
  have hbg : (∫ c, b c ∂μ) = Fintype.card (BadIncident n)*(r : ℝ) := by
    have he := hsum.integral_comp (f := fun k : ℕ => (k : ℝ))
      (measurable_of_countable _).aestronglyMeasurable
    rw [poisson_mean] at he
    simpa only [Function.comp_def, Finset.sum_const, Finset.card_univ, nsmul_eq_mul,
      NNReal.coe_mul, NNReal.coe_natCast] using he
  have hgg : (∫ c, g c ∂μ) =
      poissonKillProbability U 2 (3*r*Fintype.card (Fin 2 → SignedLiteral n)) := by
    have he := poissonCountLaw_embedding_integral (A := IncidentClass n) (B := SingleIncident n)
      Sum.inl Sum.inl_injective r
      (fun c => if U ∩ countsMask singleIncidentMask c = ∅ then (1 : ℝ) else 0)
    change (∫ c, g c ∂μ) = _ at he
    rw [he, singleIncident_law r (fun I => if U ∩ I = ∅ then (1 : ℝ) else 0)]
    rw [candidateBlock_mask _ _ U (fun V => if V = ∅ then (1 : ℝ) else 0), candidateBlock_kill]
  rwa [hbg,hgg] at h

end FixedClauseThreshold.Computability

end OAI