import OAI.Probability.MatroidProphet.ProductRestriction
import OAI.Probability.MatroidProphet.Residual.Constants

namespace OAI

namespace MatroidProphet

open Finset

variable {α : Type*} [DecidableEq α]

lemma bitsExpectation_contains (q : α → ℝ) (V R : Finset α) (hR : R ⊆ V) :
    bitsExpectation q V (fun S => if R ⊆ S then 1 else 0) = ∏ e ∈ R, q e := by
  induction V using Finset.induction_on generalizing R with
  | empty =>
    have h : R = ∅ := Finset.subset_empty.mp hR
    subst R
    simp
  | @insert e V he ih =>
    rw [bitsExpectation_insert q V e he]
    by_cases heR : e ∈ R
    · have hRV : R.erase e ⊆ V := by
        intro x hx
        have hm := hR (mem_of_mem_erase hx)
        rcases mem_insert.mp hm with rfl | hm
        · exact (notMem_erase _ _ hx).elim
        · exact hm
      have hzero : bitsExpectation q V (fun S => if R ⊆ S then 1 else 0) = 0 := by
        conv_rhs => rw [← bitsExpectation_const q V 0]
        apply bitsExpectation_congr
        intro S hS
        have hn : ¬ R ⊆ S := fun hh => he (hS (hh heR))
        simp [hn]
      have hyes : bitsExpectation q V (fun S => if R ⊆ insert e S then 1 else 0) =
          bitsExpectation q V (fun S => if R.erase e ⊆ S then 1 else 0) := by
        apply bitsExpectation_congr
        intro S hS
        have hiff : R ⊆ insert e S ↔ R.erase e ⊆ S := by
          constructor
          · intro h x hx
            exact (mem_insert.mp (h (mem_of_mem_erase hx))).resolve_left (ne_of_mem_erase hx)
          · intro h x hx
            by_cases hxe : x = e
            · simp [hxe]
            · exact mem_insert_of_mem (h (mem_erase.mpr ⟨hxe, hx⟩))
        simp only [hiff]
      rw [hzero, hyes, ih _ hRV]
      simpa using (mul_prod_erase R q heR)
    · have hRV : R ⊆ V := by
        intro x hx
        exact (mem_insert.mp (hR hx)).resolve_left (fun h => heR (h ▸ hx))
      have hyes : bitsExpectation q V (fun S => if R ⊆ insert e S then 1 else 0) =
          bitsExpectation q V (fun S => if R ⊆ S then 1 else 0) := by
        apply bitsExpectation_congr
        intro S hS
        have hiff : R ⊆ insert e S ↔ R ⊆ S := by
          constructor
          · intro h x hx
            exact (mem_insert.mp (h hx)).resolve_left (fun h => heR (h ▸ hx))
          · exact fun h => h.trans (subset_insert e S)
        simp only [hiff]
      rw [hyes, ih _ hRV]
      ring

lemma bitsExpectation_mul_const (q : α → ℝ) (V : Finset α) (c : ℝ) (f : Finset α → ℝ) :
    bitsExpectation q V (fun S => c * f S) = c * bitsExpectation q V f := by
  simp only [bitsExpectation, mul_sum]
  apply sum_congr rfl
  intro S hS
  ring

lemma bitsExpectation_contains_le_half_pow (q : α → ℝ)
    (hq0 : ∀ e, 0 ≤ q e) (hqhalf : ∀ e, q e ≤ 1 / 2)
    (V R : Finset α) (hR : R ⊆ V) :
    bitsExpectation q V (fun S => if R ⊆ S then 1 else 0) ≤ (1 / 2 : ℝ) ^ R.card := by
  rw [bitsExpectation_contains q V R hR]
  simpa using prod_le_prod₀ (fun e _ => hq0 e) (fun e _ => hqhalf e)

noncomputable def residualBad (F : Finset (Finset α)) (t : ℝ) (S : Finset α) : Prop :=
  ∃ R ∈ F, t < (R.card : ℝ) ∧ R ⊆ S

noncomputable def residualBadIndicator (F : Finset (Finset α)) (t : ℝ) (S : Finset α) : ℝ := by
  classical
  exact if residualBad F t S then 1 else 0

lemma residualBad_indicator_le (F : Finset (Finset α)) (t : ℝ) (S : Finset α) :
    residualBadIndicator F t S ≤
      ∑ R ∈ F, if t < (R.card : ℝ) then (if R ⊆ S then (1 : ℝ) else 0) else 0 := by
  classical
  unfold residualBadIndicator
  split_ifs with hb
  · obtain ⟨R, hRF, hRt, hRS⟩ := hb
    have h := single_le_sum (f := fun R : Finset α =>
      if t < (R.card : ℝ) then (if R ⊆ S then (1 : ℝ) else 0) else 0)
      (fun R _ => by split_ifs <;> norm_num) hRF
    simpa [hRt, hRS] using h
  · exact sum_nonneg (fun R _ => by split_ifs <;> norm_num)

lemma bitsExpectation_residualBad_le (q : α → ℝ)
    (hq0 : ∀ e, 0 ≤ q e) (hqhalf : ∀ e, q e ≤ 1 / 2)
    (V : Finset α) (F : Finset (Finset α)) (hF : ∀ R ∈ F, R ⊆ V) (t : ℝ) :
    bitsExpectation q V (fun S => residualBadIndicator F t S) ≤
      (F.card : ℝ) * Real.exp (-t * Real.log 2) := by
  classical
  have hq1 : ∀ e, q e ≤ 1 := fun e => (hqhalf e).trans (by norm_num)
  calc
    _ ≤ bitsExpectation q V (fun S => ∑ R ∈ F,
        if t < (R.card : ℝ) then (if R ⊆ S then (1 : ℝ) else 0) else 0) :=
      bitsExpectation_mono q hq0 hq1 V (fun S _ => residualBad_indicator_le F t S)
    _ = ∑ R ∈ F, bitsExpectation q V (fun S =>
        if t < (R.card : ℝ) then (if R ⊆ S then (1 : ℝ) else 0) else 0) := bitsExpectation_sum q V F _
    _ ≤ ∑ _R ∈ F, Real.exp (-t * Real.log 2) := by
      apply sum_le_sum
      intro R hRF
      by_cases hRt : t < (R.card : ℝ)
      · simp only [hRt, ite_true]
        apply (bitsExpectation_contains_le_half_pow q hq0 hqhalf V R (hF R hRF)).trans
        have heq : (1 / 2 : ℝ) ^ R.card = Real.exp (-(R.card : ℝ) * Real.log 2) := by
          rw [neg_mul, Real.exp_neg, Real.exp_nat_mul, Real.exp_log (by norm_num)]
          simp
        rw [heq]
        apply Real.exp_le_exp.mpr
        have hlog : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
        exact mul_le_mul_of_nonneg_right (by linarith) hlog
      · simp only [hRt, ite_false, bitsExpectation_const]
        exact Real.exp_nonneg _
    _ = _ := by simp

end MatroidProphet

end OAI