import OAI.Probability.MatroidProphet.Main
import Mathlib.Probability.Independence.Basic
import Mathlib.MeasureTheory.Integral.Bochner.Basic

namespace OAI

namespace MatroidProphet.General

open MeasureTheory ProbabilityTheory

/-- A decision uses only the entire initial seed, the initially observed vector,
and the label/value history through the current arrival. -/
structure OnlineRule (n : ℕ) (R : Type*) [MeasurableSpace R] where
  decide : (k : Fin n) → R → Weights n → History n k → Bool
  measurable_decide : ∀ k, Measurable
    (fun x : R × (Weights n × History n k) => decide k x.1 x.2.1 x.2.2)

def decisionAt {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : OnlineRule n R) (r : R) (s v : Weights n)
    (π : ArrivalOrder n) (k : Fin n) : Bool :=
  A.decide k r s (history v π k)

noncomputable def acceptedThrough {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : OnlineRule n R) (r : R) (s v : Weights n)
    (π : ArrivalOrder n) (t : ℕ) : Finset (Fin n) := by
  classical
  exact Finset.univ.filter fun e =>
    (π.symm e).val < t ∧ decisionAt A r s v π (π.symm e) = true

noncomputable def reward {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : OnlineRule n R) (r : R) (s v : Weights n) (π : ArrivalOrder n) : ℝ :=
  ∑ e ∈ acceptedThrough A r s v π n, v e

def Feasible {n : ℕ} {R : Type*} [MeasurableSpace R]
    (M : Matroid (Fin n)) (A : OnlineRule n R) : Prop :=
  ∀ (r : R) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ),
    (∀ e, 0 ≤ s e) → (∀ e, 0 ≤ v e) →
    M.Indep (acceptedThrough A r s v π t : Set (Fin n))

/-- The observation mask is a measurable function of the seed alone. -/
structure HiddenRule (n : ℕ) (R : Type*) [MeasurableSpace R] where
  mask : R → Finset (Fin n)
  measurable_mask : Measurable mask
  core : OnlineRule n R

noncomputable def observed {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (r : R) (w : Weights n) : Weights n := by
  classical
  exact fun e => if e ∈ A.mask r then w e else 0

noncomputable def hiddenAcceptedThrough {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (r : R) (w : Weights n)
    (π : ArrivalOrder n) (t : ℕ) : Finset (Fin n) :=
  acceptedThrough A.core r (observed A r w) w π t \ A.mask r

noncomputable def hiddenReward {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (r : R) (w : Weights n) (π : ArrivalOrder n) : ℝ :=
  ∑ e ∈ hiddenAcceptedThrough A r w π n, w e

noncomputable def hiddenWorstReward {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (w : Weights n) (r : R) : ℝ := by
  classical
  exact Finset.univ.inf' Finset.univ_nonempty (hiddenReward A r w)

def HiddenFeasible {n : ℕ} {R : Type*} [MeasurableSpace R]
    (M : Matroid (Fin n)) (A : HiddenRule n R) : Prop :=
  ∀ (w : Weights n), (∀ e, 0 ≤ w e) →
    ∀ (r : R) (π : ArrivalOrder n) (t : ℕ),
      M.Indep (hiddenAcceptedThrough A r w π t : Set (Fin n))

/-- Sample values on the sacrificed mask, and realized values elsewhere. -/
noncomputable def glue {n : ℕ} (mask : Finset (Fin n)) (s v : Weights n) : Weights n := by
  classical
  exact fun e => if e ∈ mask then s e else v e

noncomputable def simulationHistory {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (r : R) (s : Weights n)
    {k : Fin n} (h : History n k) : History n k := by
  classical
  exact fun j => ((h j).1, if (h j).1 ∈ A.mask r then s (h j).1 else (h j).2)

 

noncomputable def simulationDecision {n : ℕ} {R : Type*} [MeasurableSpace R]
    (A : HiddenRule n R) (k : Fin n) (r : R) (s : Weights n)
    (h : History n k) : Bool := by
  classical
  exact if (h ⟨k.val, Nat.lt_succ_self _⟩).1 ∈ A.mask r then false
    else A.core.decide k r (observed A r s) (simulationHistory A r s h)

/-- Full source contract for `lem:simulation`, with arbitrary measurable seed
and probability spaces.  The simulator is constructed before the distributions
and adversary are supplied.  Its decision function is specified concretely;
the conjunction includes exact execution, feasibility, the seed/glued-vector
joint law, integrability, and preservation of the same competitive ratio. -/
def SimulationContract.{u, v} : Prop :=
  ∀ (n : ℕ) (R : Type v) [MeasurableSpace R]
    (M : Matroid (Fin n)) (A : HiddenRule n R)
    (ν : Measure R), IsProbabilityMeasure ν →
    ∀ (c : ℝ), HiddenFeasible M A →
    (∀ (w : Weights n), (∀ e, 0 ≤ w e) →
      c * optimum M w ≤ ∫ r, hiddenWorstReward A w r ∂ν) →
    ∃ B : OnlineRule n R,
      (∀ (k : Fin n) (r : R) (s : Weights n) (h : History n k),
        B.decide k r s h = simulationDecision A k r s h) ∧
      Feasible M B ∧
      (∀ (r : R) (s v : Weights n) (π : ArrivalOrder n) (t : ℕ),
        acceptedThrough B r s v π t =
          hiddenAcceptedThrough A r (glue (A.mask r) s v) π t) ∧
      (∀ (r : R) (s v : Weights n) (π : ArrivalOrder n),
        reward B r s v π = hiddenReward A r (glue (A.mask r) s v) π) ∧
      ∀ {Ω : Type u} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
        (S V : Ω → Weights n) (seed : Ω → R),
        Measurable S → Measurable V → Measurable seed →
        (∀ᵐ ω ∂μ, ∀ e, 0 ≤ S ω e) →
        (∀ᵐ ω ∂μ, ∀ e, 0 ≤ V ω e) →
        iIndepFun (pairedCoordinates S V) μ →
        (∀ e, μ.map (fun ω => S ω e) = μ.map (fun ω => V ω e)) →
        IndepFun (fun ω => (S ω, V ω)) seed μ → μ.map seed = ν →
        Integrable (fun ω => optimum M (V ω)) μ →
        ∀ (π : Ω → ArrivalOrder n), Measurable π →
          MeasurePreserving (fun ω => (seed ω, glue (A.mask (seed ω)) (S ω) (V ω)))
            μ (ν.prod (μ.map V)) ∧
          Integrable (fun ω => reward B (seed ω) (S ω) (V ω) (π ω)) μ ∧
          c * (∫ ω, optimum M (V ω) ∂μ) ≤
            ∫ ω, reward B (seed ω) (S ω) (V ω) (π ω) ∂μ

end MatroidProphet.General

end OAI