import OAI.Probability.SATComputability.PoissonSemigroup
import OAI.Probability.SATComputability.MarkovOccupation

namespace OAI

namespace FixedClauseThreshold.Computability

open DilutedSpinGlass MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal

theorem candidateResidual_subset {n k d : ℕ} (U : Finset (DeletionCandidate n))
    (cs : Fin d → Fin k → SignedLiteral n) : candidateResidual U cs ⊆ U := by
  classical
  exact Finset.filter_subset _ _

theorem candidateResidual_mono {n k d : ℕ} {U V : Finset (DeletionCandidate n)}
    (h : U ⊆ V) (cs : Fin d → Fin k → SignedLiteral n) :
    candidateResidual U cs ⊆ candidateResidual V cs := by
  classical
  exact Finset.filter_subset_filter _ h

theorem candidateAlive_mono {n : ℕ} :
    Monotone (candidateAlive (n := n)) := by
  intro U V h
  unfold candidateAlive
  split_ifs with hU hV
  · rfl
  · exact (hV (hU.mono h)).elim
  · norm_num
  · rfl

theorem candidateBlock_expect_mono_state {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) {f : Finset (DeletionCandidate n) → ℝ}
    (hf : Monotone f) : Monotone (fun U => (candidateBlock r k U).expect f) := by
  intro U V hUV
  simp only [candidateBlock, poissonMixture_expect]
  apply integral_mono (poissonMixture_integrable_expect r
    (fun d => candidateFixedBlock k d U) f)
    (poissonMixture_integrable_expect r (fun d => candidateFixedBlock k d V) f)
  intro d
  simp only [candidateFixedBlock_expect, candidateStep_iterate]
  exact FiniteLaw.expect_mono _ (fun cs => hf (candidateResidual_mono hUV cs))

theorem candidateBlock_expect_le_of_subset {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n))
    (f g : Finset (DeletionCandidate n) → ℝ)
    (h : ∀ V ⊆ U, f V ≤ g V) :
    (candidateBlock r k U).expect f ≤ (candidateBlock r k U).expect g := by
  simp only [candidateBlock, poissonMixture_expect]
  apply integral_mono (poissonMixture_integrable_expect r _ f)
    (poissonMixture_integrable_expect r _ g)
  intro d
  simp only [candidateFixedBlock_expect, candidateStep_iterate]
  exact FiniteLaw.expect_mono _ (fun cs => h _ (candidateResidual_subset U cs))

theorem candidateBlock_expect_alive {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
    (candidateBlock r k U).expect candidateAlive = 1 - poissonKillProbability U k r := by
  have he : candidateAlive (n := n) = fun V => 1 - (if V = ∅ then 1 else 0) := by
    classical
    funext V
    by_cases h : V = ∅ <;> simp [candidateAlive, h, Finset.nonempty_iff_ne_empty]
  rw [he, FiniteLaw.expect_sub, FiniteLaw.expect_const, candidateBlock_kill]

theorem candidateBlock_empty {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) (f : Finset (DeletionCandidate n) → ℝ) :
    (candidateBlock r k ∅).expect f = f ∅ := by
  simp only [candidateBlock_expect, candidateStep_iterate, candidateResidual,
    Finset.filter_empty, FiniteLaw.expect_const, integral_const, probReal_univ, one_smul]

theorem candidateBlock_survival_le {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
    (candidateBlock r k U).expect candidateAlive ≤ candidateAlive U := by
  apply (candidateBlock_expect_le_of_subset r k U candidateAlive
    (fun _ => candidateAlive U) (fun _ h => candidateAlive_mono h)).trans_eq
  exact FiniteLaw.expect_const _ _

theorem candidateBlock_survival_submultiplicative {n : ℕ} [NeZero n]
    (r s : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
    (candidateBlock (r+s) k U).expect candidateAlive ≤
      (candidateBlock r k U).expect candidateAlive *
        (candidateBlock s k U).expect candidateAlive := by
  rw [candidateBlock_comp]
  calc
    _ ≤ (candidateBlock r k U).expect (fun V =>
        candidateAlive V * (candidateBlock s k U).expect candidateAlive) := by
      apply candidateBlock_expect_le_of_subset
      intro V hV
      by_cases h : V.Nonempty
      · simpa only [candidateAlive, ite_eq_left h, one_mul] using
          candidateBlock_expect_mono_state s k candidateAlive_mono hV
      · have he : V = ∅ := Finset.not_nonempty_iff_eq_empty.mp h
        subst V
        simp [candidateBlock_empty, candidateAlive]
    _ = _ := FiniteLaw.expect_mul_right _ _ _

theorem candidateBlock_survival_geometric {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n))
    {δ : ℝ} (hδ : δ ≤ poissonKillProbability U k r) (m : ℕ) :
    (candidateBlock (r*m) k U).expect candidateAlive ≤ (1-δ)^m := by
  have hs := FiniteLaw.expect_nonneg (candidateBlock r k U) candidateAlive_nonneg
  have hb : (candidateBlock r k U).expect candidateAlive ≤ 1-δ := by
    rw [candidateBlock_expect_alive]
    linarith
  have hd : 0 ≤ 1-δ := hs.trans hb
  induction m with
  | zero => simp [candidateBlock_expect, integral_poissonMeasure, zero_pow_eq, ite_div, ite_mul,
      candidateAlive_le_one]
  | succ m ih =>
    have he : r * ((m+1 : ℕ) : ℝ≥0) = r*m+r := by push_cast; ring
    rw [he, pow_succ]
    exact (candidateBlock_survival_submultiplicative (r*m) r k U).trans
      (mul_le_mul ih hb hs (pow_nonneg hd m))

theorem candidateBlock_occupation {n : ℕ} [NeZero n]
    (r : ℝ≥0) (k L M : ℕ) (bin : Finset (DeletionCandidate n) → Prop)
    [DecidablePred bin] {δ : ℝ} (hδ : 0 < δ)
    (hbin : ∀ U, bin U → U.Nonempty ∧ δ ≤ poissonKillProbability U k (r*L))
    (U : Finset (DeletionCandidate n)) :
    (∑ t ∈ Finset.range M,
      (candidateBlock (r*t) k U).expect (fun V => if bin V then 1 else 0)) ≤
        (L : ℝ)/δ := by
  have hi (m : ℕ) (f : Finset (DeletionCandidate n) → ℝ) :
      (finiteKernelStep (candidateBlock r k))^[m] f U =
        (candidateBlock (r*m) k U).expect f := poissonCandidateStep_iterate r k m U f
  have h := finiteKernel_occupation (candidateBlock r k) candidateAlive
    (fun V => if bin V then 1 else 0) candidateAlive_nonneg candidateAlive_le_one hδ L
    (fun V => ?_) M U
  · simpa only [hi] using h
  · change δ * (if bin V then 1 else 0) ≤ candidateAlive V -
      (poissonCandidateStep r k)^[L] candidateAlive V
    rw [poissonCandidateStep_iterate]
    by_cases hb : bin V
    · obtain ⟨hne, hk⟩ := hbin V hb
      rw [ite_eq_left hb, mul_one, candidateAlive, ite_eq_left hne,
        candidateBlock_expect_alive]
      linarith
    · rw [ite_eq_right hb, mul_zero]
      exact sub_nonneg.mpr (candidateBlock_survival_le _ _ _)

end FixedClauseThreshold.Computability

end OAI