import OAI.Probability.MatroidProphet.Reverse.Certificates
import OAI.Probability.MatroidProphet.RevealContinuation
import OAI.Probability.MatroidProphet.ProductRestriction

namespace OAI

namespace MatroidProphet
open Finset
variable {α : Type*} [Fintype α] [DecidableEq α]
attribute [local instance] Classical.propDecidable

noncomputable def reverseCost (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ) :
    ℕ → ℤ → (ℕ → Set α) → Finset α → ℝ
  | 0, _, _, _ => 0
  | m+1, k, S, C => cost k S ((reverseStepTree M hE κ k D S G n).run C) +
      reverseCost M hE κ D G n cost m (k-1)
        ((reverseStepTree M hE κ k D S G n).run C) C

lemma reverseCost_congr (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (hG : Pairwise (fun i j => Disjoint (G i) (G j)))
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S)
    (C C' : Finset α)
    (agree : ∀ j < n, ∀ e ∈ G j, e ∈ S j → (e ∈ C ↔ e ∈ C')) :
    reverseCost M hE κ D G n cost m k S C = reverseCost M hE κ D G n cost m k S C' := by
  induction m generalizing k S with
  | zero => rfl
  | succ m ih =>
    let V := (range n).biUnion (fun j => (G j).filter (fun e => e ∈ S j))
    have hV : ∀ j < n, (G j).filter (fun e => e ∈ S j) ⊆ V := by
      intro j hj e he
      exact mem_biUnion.mpr ⟨j, mem_range.mpr hj, he⟩
    have ha : ∀ e ∈ V, (e ∈ C ↔ e ∈ C') := by
      intro e he
      obtain ⟨j, hj, hje⟩ := mem_biUnion.mp he
      exact agree j (mem_range.mp hj) e (mem_filter.mp hje).1 (mem_filter.mp hje).2
    have hs := (reverseStepTree M hE κ k D S G n).run_congr V C C'
      (reverseStepTree_fresh M hE κ k D S G n hG V hV) ha
    simp only [reverseCost, hs]
    congr 1
    apply ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C')
    intro j hj e heG heS
    exact agree j hj e heG (reverseStepTree_contracts M hE κ k D S G n closed C' j heS)

lemma reverseCost_add (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (f g : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (C : Finset α) :
    reverseCost M hE κ D G n (fun k S S' => f k S S' + g k S S') m k S C =
      reverseCost M hE κ D G n f m k S C + reverseCost M hE κ D G n g m k S C := by
  induction m generalizing k S with
  | zero => simp [reverseCost]
  | succ m ih => simp only [reverseCost, ih]; ring

lemma reverseCost_mul (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (f : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ) (a : ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (C : Finset α) :
    reverseCost M hE κ D G n (fun k S S' => a * f k S S') m k S C =
      a * reverseCost M hE κ D G n f m k S C := by
  induction m generalizing k S with
  | zero => simp [reverseCost]
  | succ m ih => simp only [reverseCost, ih]; ring

lemma reverseCost_mono (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (f g : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (hfg : ∀ k S S', f k S S' ≤ g k S S')
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (C : Finset α) :
    reverseCost M hE κ D G n f m k S C ≤ reverseCost M hE κ D G n g m k S C := by
  induction m generalizing k S with
  | zero => exact le_rfl
  | succ m ih => exact add_le_add (hfg _ _ _) (ih _ _)

noncomputable def reverseMeanCost (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ)
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) : ℝ :=
  bitsExpectation q univ (reverseCost M hE κ D G n cost m k S)

lemma reverseCost_erase_step (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (hG : Pairwise (fun i j => Disjoint (G i) (G j)))
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) (C : Finset α) :
    reverseCost M hE κ D G n cost m (k-1) ((reverseStepTree M hE κ k D S G n).run C) C =
      reverseCost M hE κ D G n cost m (k-1) ((reverseStepTree M hE κ k D S G n).run C)
        (C \ (reverseStepTree M hE κ k D S G n).queried C) := by
  apply reverseCost_congr M hE κ D G n hG cost m (k-1) _
    (reverseStepTree_closed M hE κ k D S G n C)
  intro j hj e heG heS
  have he := reverseStepTree_remaining M hE κ k D S G n hG univ
    (fun _ _ => subset_univ _) closed C j hj (mem_filter.mpr ⟨heG, heS⟩)
  simp only [mem_sdiff, (mem_sdiff.mp he).2, not_false_eq_true, and_true]

theorem reverseMeanCost_succ (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (hG : Pairwise (fun i j => Disjoint (G i) (G j))) (q : α → ℝ)
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) :
    reverseMeanCost M hE κ D G n q cost (m+1) k S =
      bitsExpectation q univ (fun C => cost k S ((reverseStepTree M hE κ k D S G n).run C) +
        reverseMeanCost M hE κ D G n q cost m (k-1) ((reverseStepTree M hE κ k D S G n).run C)) := by
  let tree := reverseStepTree M hE κ k D S G n
  let f := fun (S' : ℕ → Set α) (C : Finset α) => reverseCost M hE κ D G n cost m (k-1) S' C
  have hfresh : tree.Fresh univ := reverseStepTree_fresh M hE κ k D S G n hG univ
    (fun _ _ => subset_univ _)
  have herase : bitsExpectation q univ (fun C => f (tree.run C) C) =
      bitsExpectation q univ (fun C => f (tree.run C) (C \ tree.queried C)) := by
    apply bitsExpectation_congr
    intro C hC
    exact reverseCost_erase_step M hE κ D G n hG cost m k S closed C
  have hrestrict : bitsExpectation q univ (fun C => bitsExpectation q (univ \ tree.queried C)
      (f (tree.run C))) = bitsExpectation q univ (fun C => bitsExpectation q univ (f (tree.run C))) := by
    apply bitsExpectation_congr
    intro C hC
    symm
    apply bitsExpectation_restrict q univ _ (subset_univ _) (f (tree.run C))
    intro T T' hT
    apply reverseCost_congr M hE κ D G n hG cost m (k-1) _
      (reverseStepTree_closed M hE κ k D S G n C)
    intro j hj e heG heS
    exact hT e (reverseStepTree_remaining M hE κ k D S G n hG univ
      (fun _ _ => subset_univ _) closed C j hj (mem_filter.mpr ⟨heG, heS⟩))
  have htower := tree.continuation_expectation q univ hfresh f
  change bitsExpectation q univ (fun C => cost k S (tree.run C) + f (tree.run C) C) =
    bitsExpectation q univ (fun C => cost k S (tree.run C) + bitsExpectation q univ (f (tree.run C)))
  rw [bitsExpectation_add, bitsExpectation_add, herase, htower, hrestrict]

@[simp] lemma reverseMeanCost_zero (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ)
    (cost : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ) (k : ℤ) (S : ℕ → Set α) :
    reverseMeanCost M hE κ D G n q cost 0 k S = 0 := by
  simp only [reverseMeanCost, reverseCost, bitsExpectation_const]

lemma reverseMeanCost_add (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ)
    (f g : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) :
    reverseMeanCost M hE κ D G n q (fun k S S' => f k S S' + g k S S') m k S =
      reverseMeanCost M hE κ D G n q f m k S + reverseMeanCost M hE κ D G n q g m k S := by
  unfold reverseMeanCost
  rw [← bitsExpectation_add]
  exact bitsExpectation_congr q univ (fun C _ => reverseCost_add M hE κ D G n f g m k S C)

lemma reverseMeanCost_mul (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ)
    (f : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ) (a : ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) :
    reverseMeanCost M hE κ D G n q (fun k S S' => a * f k S S') m k S =
      a * reverseMeanCost M hE κ D G n q f m k S := by
  unfold reverseMeanCost
  rw [← bitsExpectation_mul_left]
  exact bitsExpectation_congr q univ (fun C _ => reverseCost_mul M hE κ D G n f a m k S C)

theorem reverseMeanCost_le_of_step (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (hG : Pairwise (fun i j => Disjoint (G i) (G j))) (q : α → ℝ)
    (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1)
    (f g : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (hfg : ∀ k S, ReverseClosed M hE κ D k S →
      bitsExpectation q univ (fun C => f k S ((reverseStepTree M hE κ k D S G n).run C)) ≤
      bitsExpectation q univ (fun C => g k S ((reverseStepTree M hE κ k D S G n).run C)))
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) :
    reverseMeanCost M hE κ D G n q f m k S ≤ reverseMeanCost M hE κ D G n q g m k S := by
  induction m generalizing k S with
  | zero => simp only [reverseMeanCost_zero, le_refl]
  | succ m ih =>
    rw [reverseMeanCost_succ M hE κ D G n hG q f m k S closed,
      reverseMeanCost_succ M hE κ D G n hG q g m k S closed,
      bitsExpectation_add, bitsExpectation_add]
    apply add_le_add (hfg k S closed)
    apply bitsExpectation_mono q hq0 hq1
    intro C hC
    exact ih (k-1) _ (reverseStepTree_closed M hE κ k D S G n C)

theorem reverseMeanCost_eq_of_step (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (hG : Pairwise (fun i j => Disjoint (G i) (G j))) (q : α → ℝ)
    (hq0 : ∀ e, 0 ≤ q e) (hq1 : ∀ e, q e ≤ 1)
    (f g : ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (hfg : ∀ k S, ReverseClosed M hE κ D k S →
      bitsExpectation q univ (fun C => f k S ((reverseStepTree M hE κ k D S G n).run C)) =
      bitsExpectation q univ (fun C => g k S ((reverseStepTree M hE κ k D S G n).run C)))
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (closed : ReverseClosed M hE κ D k S) :
    reverseMeanCost M hE κ D G n q f m k S = reverseMeanCost M hE κ D G n q g m k S :=
  le_antisymm (reverseMeanCost_le_of_step M hE κ D G n hG q hq0 hq1 f g
    (fun k S hS => (hfg k S hS).le) m k S closed)
    (reverseMeanCost_le_of_step M hE κ D G n hG q hq0 hq1 g f
    (fun k S hS => (hfg k S hS).ge) m k S closed)

lemma reverseCost_sum {ι : Type*} (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ)
    (I : Finset ι) (f : ι → ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) (C : Finset α) :
    reverseCost M hE κ D G n (fun k S S' => ∑ i ∈ I, f i k S S') m k S C =
      ∑ i ∈ I, reverseCost M hE κ D G n (f i) m k S C := by
  induction m generalizing k S with
  | zero => simp only [reverseCost, sum_const_zero]
  | succ m ih => simp only [reverseCost, ih, sum_add_distrib]

lemma reverseMeanCost_sum {ι : Type*} (M : Matroid α) (hE : M.E = Set.univ)
    (κ : ℕ) (D : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (q : α → ℝ)
    (I : Finset ι) (f : ι → ℤ → (ℕ → Set α) → (ℕ → Set α) → ℝ)
    (m : ℕ) (k : ℤ) (S : ℕ → Set α) :
    reverseMeanCost M hE κ D G n q (fun k S S' => ∑ i ∈ I, f i k S S') m k S =
      ∑ i ∈ I, reverseMeanCost M hE κ D G n q (f i) m k S := by
  unfold reverseMeanCost
  rw [← bitsExpectation_sum]
  exact bitsExpectation_congr q univ (fun C _ => reverseCost_sum M hE κ D G n I f m k S C)

end MatroidProphet

end OAI