lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/FiniteKernels.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Counting.SurvivalLayout

namespace OAI

/-!
# Finite dependent sampling kernels

A dependent second draw uses its own normalized mass in each first-draw
fiber. In particular, this construction does not replace sequential uniform
draws with the generally different uniform law on their sigma type.
-/

namespace LowSpaceSubsetSum

open scoped BigOperators

universe u v

structure FiniteLaw (Ω : Type u) [Fintype Ω] where
  mass : Ω → ℝ
  nonneg : ∀ ω, 0 ≤ mass ω
  total : ∑ ω, mass ω = 1

namespace FiniteLaw

variable {Ω : Type u} [Fintype Ω]

noncomputable def probability (μ : FiniteLaw Ω) (P : Ω → Prop) : ℝ := by
  classical
  exact ∑ ω, if P ω then μ.mass ω else 0

theorem probability_nonneg (μ : FiniteLaw Ω) (P : Ω → Prop) : 0 ≤ μ.probability P := by
  classical
  apply Finset.sum_nonneg
  intro ω _
  by_cases h : P ω
  · simpa only [h, ↓reduceIte] using μ.nonneg ω
  · simp only [h, ↓reduceIte, le_refl]

theorem probability_true (μ : FiniteLaw Ω) : μ.probability (fun _ => True) = 1 := by
  classical
  simpa only [probability, ↓reduceIte] using μ.total

theorem probability_mono (μ : FiniteLaw Ω) {P Q : Ω → Prop}
    (h : ∀ ω, P ω → Q ω) : μ.probability P ≤ μ.probability Q := by
  classical
  apply Finset.sum_le_sum
  intro ω _
  by_cases hp : P ω
  · simp only [hp, h ω hp, ↓reduceIte, le_refl]
  · simp only [hp, ↓reduceIte]
    by_cases hq : Q ω
    · simpa only [hq, ↓reduceIte] using μ.nonneg ω
    · simp only [hq, ↓reduceIte, le_refl]

theorem probability_le_one (μ : FiniteLaw Ω) (P : Ω → Prop) : μ.probability P ≤ 1 := by
  rw [← μ.probability_true]
  exact μ.probability_mono (fun _ _ => trivial)

theorem probability_compl (μ : FiniteLaw Ω) (P : Ω → Prop) :
    μ.probability (fun ω => ¬P ω) = 1 - μ.probability P := by
  classical
  have h : μ.probability (fun ω => ¬P ω) + μ.probability P = 1 := by
    rw [probability, probability, ← Finset.sum_add_distrib, ← μ.total]
    apply Finset.sum_congr rfl
    intro ω _
    by_cases hp : P ω <;> simp [hp]
  linarith

noncomputable def uniform [Nonempty Ω] : FiniteLaw Ω where
  mass _ := 1 / Fintype.card Ω
  nonneg _ := by positivity
  total := by
    have h : (Fintype.card Ω : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
    simp [h]

theorem uniform_probability [Nonempty Ω] (P : Ω → Prop) :
    (uniform : FiniteLaw Ω).probability P = finiteUniformProbability P := by
  classical
  rw [finiteUniformProbability_eq_indicator_mean, probability, Finset.sum_div]
  simp only [uniform, ite_div, one_div, zero_div]

/-- The output retains the preceding draw, making its dependence explicit. -/
noncomputable def bind (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω)) : FiniteLaw (Σ ω, Ψ ω) where
  mass z := μ.mass z.1 * (K z.1).mass z.2
  nonneg z := mul_nonneg (μ.nonneg _) ((K _).nonneg _)
  total := by
    rw [Fintype.sum_sigma]
    simp_rw [← Finset.mul_sum, (K _).total, mul_one]
    exact μ.total

theorem bind_probability (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω))
    (P : (Σ ω, Ψ ω) → Prop) :
    (μ.bind Ψ K).probability P =
      ∑ ω, μ.mass ω * (K ω).probability (fun y => P ⟨ω, y⟩) := by
  classical
  simp only [probability, bind, Fintype.sum_sigma, Finset.mul_sum, mul_ite, mul_zero]

theorem bind_first_probability (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω)) (P : Ω → Prop) :
    (μ.bind Ψ K).probability (fun z => P z.1) = μ.probability P := by
  classical
  rw [bind_probability, probability]
  apply Finset.sum_congr rfl
  intro ω _
  by_cases hp : P ω
  · simp only [probability, hp, ↓reduceIte, (K ω).total, mul_one]
  · simp [probability, hp]

theorem bind_good_lower (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω))
    (P : Ω → Prop) (Q : ∀ ω, Ψ ω → Prop) {p q : ℝ}
    (hq : 0 ≤ q) (hp : p ≤ μ.probability P)
    (hQ : ∀ ω, P ω → q ≤ (K ω).probability (Q ω)) :
    p * q ≤ (μ.bind Ψ K).probability (fun z => P z.1 ∧ Q z.1 z.2) := by
  classical
  apply (mul_le_mul_of_nonneg_right hp hq).trans
  rw [bind_probability, probability, Finset.sum_mul]
  apply Finset.sum_le_sum
  intro ω _
  by_cases hP : P ω
  · simpa only [hP, ↓reduceIte, true_and] using
      mul_le_mul_of_nonneg_left (hQ ω hP) (μ.nonneg ω)
  · simp [hP, probability]

theorem probability_inter_ge_sub (μ : FiniteLaw Ω) (P Q : Ω → Prop) :
    μ.probability P - μ.probability (fun ω => ¬Q ω) ≤
      μ.probability (fun ω => P ω ∧ Q ω) := by
  classical
  have h : μ.probability P ≤ μ.probability (fun ω => P ω ∧ Q ω) +
      μ.probability (fun ω => ¬Q ω) := by
    rw [probability, probability, probability, ← Finset.sum_add_distrib]
    apply Finset.sum_le_sum
    intro ω _
    by_cases hp : P ω <;> by_cases hq : Q ω <;> simp [hp, hq, μ.nonneg ω]
  linarith

theorem probability_eq (μ : FiniteLaw Ω) (ω : Ω) :
    μ.probability (fun x => x = ω) = μ.mass ω := by
  classical
  simp [probability]

/-- Conditioning on one retained history leaves exactly its prescribed
next-draw law. The formula is valid even when that history has zero mass. -/
theorem bind_point_probability (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω))
    (Q : ∀ ω, Ψ ω → Prop) (ω : Ω) :
    (μ.bind Ψ K).probability (fun z => z.1 = ω ∧ Q z.1 z.2) =
      μ.mass ω * (K ω).probability (Q ω) := by
  classical
  rw [bind_probability]
  rw [Finset.sum_eq_single ω]
  · simp only [true_and]
  · intro x _ hx
    simp [hx, probability]
  · simp

theorem bind_conditional_probability (μ : FiniteLaw Ω) (Ψ : Ω → Type v)
    [∀ ω, Fintype (Ψ ω)] (K : ∀ ω, FiniteLaw (Ψ ω))
    (Q : ∀ ω, Ψ ω → Prop) (ω : Ω) (hω : μ.mass ω ≠ 0) :
    (μ.bind Ψ K).probability (fun z => z.1 = ω ∧ Q z.1 z.2) /
      μ.probability (fun x => x = ω) = (K ω).probability (Q ω) := by
  rw [bind_point_probability, probability_eq]
  exact mul_div_cancel_left₀ _ hω

end FiniteLaw

end LowSpaceSubsetSum

end OAI