import OAI.Probability.MatroidProphet.Certificates.Budget

namespace OAI

namespace MatroidProphet

open Finset

variable {α : Type*} [DecidableEq α]

def QueryProgram.run (cert : Finset α → Prop) [DecidablePred cert]
    (S : Finset α) : QueryProgram α → Finset α → ℝ
  | .stop, _ => 0
  | .query e no yes, I => if e ∈ S then yes.run cert S (insert e I) else no.run cert S I
  | .finish rest, I => (if cert I then 1 else 0) + rest.run cert S ∅

lemma QueryProgram.run_congr (cert : Finset α → Prop) [DecidablePred cert]
    (prog : QueryProgram α) (V I S S' : Finset α) (fresh : prog.Fresh V)
    (agree : ∀ e ∈ V, (e ∈ S ↔ e ∈ S')) :
    prog.run cert S I = prog.run cert S' I := by
  induction prog generalizing V I with
  | stop => rfl
  | finish rest ih =>
    simp only [run]
    rw [ih V ∅ fresh agree]
  | query e no yes ihn ihy =>
    rcases fresh with ⟨he, hn, hy⟩
    have ha := agree e he
    have har : ∀ x ∈ V.erase e, (x ∈ S ↔ x ∈ S') :=
      fun x hx => agree x (mem_of_mem_erase hx)
    by_cases h : e ∈ S
    · simp only [run, ite_eq_left h, ite_eq_left (ha.mp h)]
      exact ihy (V.erase e) (insert e I) hy har
    · have h' : e ∉ S' := fun hx => h (ha.mpr hx)
      simp only [run, ite_eq_right h, ite_eq_right h']
      exact ihn (V.erase e) I hn har

lemma QueryProgram.expected_eq_product (cert : Finset α → Prop) [DecidablePred cert]
    (q : α → ℝ) (prog : QueryProgram α) (V I : Finset α) (fresh : prog.Fresh V) :
    bitsExpectation q V (fun S => prog.run cert S I) = prog.expected cert q I := by
  induction prog generalizing V I with
  | stop => simp only [run, expected, bitsExpectation_const]
  | finish rest ih =>
    simp only [run, expected, bitsExpectation_add, bitsExpectation_const]
    rw [ih V ∅ fresh]
  | query e no yes ihn ihy =>
    rcases fresh with ⟨he, hn, hy⟩
    have hsplit := bitsExpectation_insert q (V.erase e) e (notMem_erase e V)
      (fun S => (QueryProgram.query e no yes).run cert S I)
    rw [insert_erase he] at hsplit
    have hno : bitsExpectation q (V.erase e)
        (fun S => (QueryProgram.query e no yes).run cert S I) =
        bitsExpectation q (V.erase e) (fun S => no.run cert S I) := by
      apply bitsExpectation_congr
      intro S hS
      have heS : e ∉ S := fun hx => (notMem_erase e V) (hS hx)
      simp only [run, ite_eq_right heS]
    have hyes : bitsExpectation q (V.erase e)
        (fun S => (QueryProgram.query e no yes).run cert (insert e S) I) =
        bitsExpectation q (V.erase e) (fun S => yes.run cert S (insert e I)) := by
      apply bitsExpectation_congr
      intro S hS
      simp only [run, mem_insert_self, ite_true]
      apply yes.run_congr cert (V.erase e) (insert e I) (insert e S) S hy
      intro x hx
      have hxe : x ≠ e := (mem_erase.1 hx).1
      simp only [mem_insert, hxe, false_or]
    rw [hsplit, hno, hyes, ihn (V.erase e) I hn, ihy (V.erase e) (insert e I) hy]
    rfl

theorem disjoint_query_certificates_product [Fintype α]
    (cert : Finset α → Prop) [DecidablePred cert] (hcert : Monotone cert)
    (q : α → ℝ) (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1)
    (hδ : 0 < bitsFailure cert q univ ∅)
    (prog : QueryProgram α) (fresh : prog.Fresh univ) :
    bitsExpectation q univ (fun S => prog.run cert S ∅) ≤
      Real.log (1 / bitsFailure cert q univ ∅) := by
  rw [prog.expected_eq_product cert q univ ∅ fresh]
  exact disjoint_query_certificates cert hcert q hq0 hq1 hδ prog fresh

end MatroidProphet

end OAI