import OAI.Probability.MatroidProphet.Main
import OAI.Probability.MatroidSecretary.Sampling.UniformPermutationImage
import Mathlib.Data.Fintype.Perm
import Mathlib.Data.Fintype.Fin
import Mathlib.Logic.Equiv.Fintype
import Mathlib.Algebra.BigOperators.Group.Finset.Piecewise
import Mathlib.Probability.Distributions.Uniform
import Mathlib.Probability.ProbabilityMassFunction.Integrals

namespace OAI

/-!
Finite combinatorial probability for the random secretary prefix.
The Bernoulli mask used to draw the prefix length is part of the initial seed;
its cardinality has the binomial law, and it is independent of the uniformly
random arrival permutation. No product-law assertion conditional on that full
seed is made.

Source: sections/secretary.tex, eq:secretary-prefix-mask, lines 54–66;
SHA256 3554fe0f7296782edf63cc7f1305c377e7a7b9d8f8948b9510ea4ad02a702d63.
These supporting laws include n=0, k=0, k=n, and Bernoulli rates 0 and 1.
-/

namespace MatroidProphet.Secretary
open Finset
open scoped BigOperators

variable {α : Type*} [Fintype α] [DecidableEq α]

lemma bitsWeight_constant (p : ℝ) (S : Finset α) :
    bitsWeight (fun _ : α => p) univ S =
      p ^ S.card * (1 - p) ^ (Fintype.card α - S.card) := by
  classical
  unfold bitsWeight
  rw [Finset.prod_ite]
  simp only [filter_mem_eq_inter, univ_inter, prod_const]
  congr 1
  rw [show (univ.filter fun e : α => e ∉ S) = univ \ S by ext; simp]
  rw [card_sdiff_of_subset (subset_univ S), card_univ]

lemma bernoulli_cardinality_mass (p : ℝ) (k : ℕ) :
    (∑ S : Finset α, if S.card = k then bitsWeight (fun _ : α => p) univ S else 0) =
      (Nat.choose (Fintype.card α) k : ℝ) * p ^ k * (1 - p) ^ (Fintype.card α - k) := by
  classical
  rw [← Finset.sum_filter]
  have hf : (univ.filter fun S : Finset α => S.card = k) = univ.powersetCard k := by
    ext S
    simp
  rw [hf]
  calc
    (∑ S ∈ univ.powersetCard k, bitsWeight (fun _ : α => p) univ S) =
        ∑ _S ∈ (univ : Finset α).powersetCard k,
          p ^ k * (1 - p) ^ (Fintype.card α - k) := by
      apply sum_congr rfl
      intro S hS
      rw [bitsWeight_constant, (mem_powersetCard.mp hS).2]
    _ = _ := by simp [card_powersetCard, mul_assoc]

lemma bitsWeight_perm (p : ℝ) (σ : Equiv.Perm α) (S : Finset α) :
    bitsWeight (fun _ : α => p) univ (S.map σ.toEmbedding) =
      bitsWeight (fun _ : α => p) univ S := by
  simp only [bitsWeight_constant, card_map]

lemma bitsExpectation_perm (p : ℝ) (σ : Equiv.Perm α) (f : Finset α → ℝ) :
    bitsExpectation (fun _ : α => p) univ (fun S => f (S.map σ.toEmbedding)) =
      bitsExpectation (fun _ : α => p) univ f := by
  classical
  simp only [bitsExpectation, powerset_univ]
  have h := σ.finsetCongr.sum_comp
    (fun S => bitsWeight (fun _ : α => p) univ S * f S)
  simpa only [Equiv.finsetCongr_apply, bitsWeight_perm] using h

lemma prefix_filter_eq_map {n : ℕ} (σ : Equiv.Perm (Fin n)) (k : ℕ) :
    (univ.filter fun e : Fin n => (σ.symm e).val < k) =
      (univ.filter fun i : Fin n => i.val < k).map σ.toEmbedding := by
  classical
  ext e
  simp only [mem_filter, mem_univ, true_and, mem_map, Equiv.toEmbedding_apply]
  constructor
  · intro he
    exact ⟨σ.symm e, he, σ.apply_symm_apply e⟩
  · rintro ⟨i, hi, rfl⟩
    simpa only [σ.symm_apply_apply] using hi

lemma prefix_filter_card {n : ℕ} (σ : Equiv.Perm (Fin n)) {k : ℕ} (hk : k ≤ n) :
    (univ.filter fun e : Fin n => (σ.symm e).val < k).card = k := by
  rw [prefix_filter_eq_map, card_map, Fin.card_filter_val_lt, min_eq_right hk]

omit [DecidableEq α] in
lemma integral_uniform_eq_average [Nonempty α] [MeasurableSpace α]
    [MeasurableSingletonClass α] (f : α → ℝ) :
    (∫ a, f a ∂(PMF.uniformOfFintype α).toMeasure) =
      (Fintype.card α : ℝ)⁻¹ * ∑ a, f a := by
  rw [PMF.integral_eq_sum]
  simp only [PMF.uniformOfFintype_apply, ENNReal.toReal_inv,
    ENNReal.toReal_natCast, smul_eq_mul, ← mul_sum]

/-- Conditional only on the prefix length, the actual uniform-permutation
prefix has the uniform law on all subsets of that cardinality. -/
theorem uniform_prefix_average {n : ℕ} {k : ℕ} (hk : k ≤ n)
    (f : Finset (Fin n) → ℝ) :
    (∑ σ : Equiv.Perm (Fin n),
      f (univ.filter fun e : Fin n => (σ.symm e).val < k)) /
        Fintype.card (Equiv.Perm (Fin n)) =
      (∑ S ∈ (univ : Finset (Fin n)).powersetCard k, f S) /
        Nat.choose n k := by
  simp_rw [prefix_filter_eq_map]
  simpa only [Fin.card_filter_val_lt, min_eq_right hk, Fintype.card_fin] using
    uniform_permutation_image_average
      (univ.filter fun i : Fin n => i.val < k) f

/-- Exact fixed-length atom law, including cardinality mismatch. -/
theorem uniform_prefix_atom {n : ℕ} {k : ℕ} (hk : k ≤ n)
    (S : Finset (Fin n)) :
    (∑ σ : Equiv.Perm (Fin n),
      if (univ.filter fun e : Fin n => (σ.symm e).val < k) = S then (1 : ℝ) else 0) /
        Fintype.card (Equiv.Perm (Fin n)) =
      if k = S.card then (Nat.choose n k : ℝ)⁻¹ else 0 := by
  simp_rw [prefix_filter_eq_map]
  simpa only [Fin.card_filter_val_lt, min_eq_right hk, Fintype.card_fin] using
    uniform_permutation_image_atom
      (univ.filter fun i : Fin n => i.val < k) S

/-- Measure-theoretic form of the fixed-length prefix averaging law. -/
theorem integral_uniform_prefix {n : ℕ} {k : ℕ} (hk : k ≤ n)
    [MeasurableSpace (Equiv.Perm (Fin n))]
    [MeasurableSingletonClass (Equiv.Perm (Fin n))]
    (f : Finset (Fin n) → ℝ) :
    (∫ σ, f (univ.filter fun e : Fin n => (σ.symm e).val < k)
      ∂(PMF.uniformOfFintype (Equiv.Perm (Fin n))).toMeasure) =
      (∑ S ∈ (univ : Finset (Fin n)).powersetCard k, f S) /
        Nat.choose n k := by
  rw [integral_uniform_eq_average]
  simpa only [div_eq_mul_inv, mul_comm] using uniform_prefix_average hk f

end MatroidProphet.Secretary

end OAI