import OAI.Probability.GaussianReplacement.CompletedModel

namespace OAI

open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology
noncomputable section
universe u
namespace CurrentProjection

namespace StreamKernel
open NoiselessRegression unitInterval
namespace CompletedLearner
variable {d M T : ℕ} (K : CompletedLearner d M T)

structure Sampling where
  initial : I → Bool × State M
  measurable_initial : Measurable initial
  initial_law : (volume : Measure I).map initial = K.initial
  transition : ((ℕ × State M) × (NoiselessRegression.Vector d × ℝ)) → I → Bool × State M
  measurable_transition : Measurable (Function.uncurry transition)
  transition_law : ∀ p, (volume : Measure I).map (transition p) = K.borel.transition p.1.1 p.1.2 p.2
  output : (ℕ × State M) → I → UnitSphere d
  measurable_output : Measurable (Function.uncurry output)
  output_law : ∀ p, (volume : Measure I).map (output p) = K.output p.1 p.2

lemma exists_sampling : Nonempty K.Sampling := by
  let : IsProbabilityMeasure K.initial := K.initial_probability
  let : IsProbabilityMeasure (K.output 0 0) := K.output_probability 0 0
  let : Nonempty (UnitSphere d) := nonempty_of_isProbabilityMeasure (K.output 0 0)
  obtain ⟨i, hi, hei⟩ := K.initial.exists_measurable_map_eq
  obtain ⟨t, ht, het⟩ := K.transitionKernel.exists_measurable_map_eq_unitInterval
  obtain ⟨o, ho, heo⟩ := K.outputKernel.exists_measurable_map_eq_unitInterval
  exact ⟨⟨i,hi,hei,t,ht,het,o,ho,heo⟩⟩

def sampling : K.Sampling := Classical.choice K.exists_sampling



def coinIndex (T n : ℕ) : Fin (T+2) := if h : n < T+2 then ⟨n,h⟩ else 0

def Sampling.program (R : K.Sampling) : NoiselessRegression.Learner d M T (Coins (T+1)) where
  initialChoice := fun z => R.initial (z 0)
  transition := fun n z a o => R.transition ((n,a),o) (z (coinIndex T n))
  output := fun n z a => R.output (n,a) (z (Fin.last (T+1)))

lemma Sampling.measurable_initialChoice (R : K.Sampling) :
    Measurable R.program.initialChoice := R.measurable_initial.comp (measurable_pi_apply 0)

lemma Sampling.measurable_program_transition (R : K.Sampling) (n : ℕ) :
    Measurable (fun p : (Coins (T+1) × State M) × (NoiselessRegression.Vector d × ℝ) =>
      R.program.transition n p.1.1 p.1.2 p.2) := by
  exact R.measurable_transition.comp
    (((measurable_const (a:=n)).prodMk measurable_fst.snd |>.prodMk measurable_snd).prodMk
      ((measurable_pi_apply (coinIndex T n)).comp measurable_fst.fst))

lemma Sampling.measurable_program_output (R : K.Sampling) :
    Measurable (fun p : Coins (T+1) × (ℕ × State M) =>
      R.program.output p.2.1 p.1 p.2.2) := by
  exact R.measurable_output.comp
    (measurable_snd.prodMk ((measurable_pi_apply (Fin.last (T+1))).comp measurable_fst))

end CompletedLearner

section BorelProgram
variable {d M T : ℕ} {Ω : Type*} [MeasurableSpace Ω]
  (L : NoiselessRegression.Learner d M T Ω)
  (hi : Measurable L.initialChoice)
  (ht : ∀ n, Measurable (fun p : (Ω × State M) × (NoiselessRegression.Vector d × ℝ) =>
    L.transition n p.1.1 p.1.2 p.2))
  (ho : Measurable (fun p : Ω × (ℕ × State M) => L.output p.2.1 p.1 p.2.2))

include hi ht in
lemma measurable_program_run (n : ℕ) :
    Measurable (fun z : UnitSphere d × (Ω × Samples d T) => L.run z.1 z.2.1 z.2.2 n) := by
  induction n with
  | zero =>
    exact (measurable_of_countable (CompletedLearner.startStatus (M:=M))).comp
      (hi.comp measurable_snd.fst)
  | succ n ih =>
    let F : NoiselessRegression.Learner.RunStatus M × (UnitSphere d × (Ω × Samples d T)) →
        NoiselessRegression.Learner.RunStatus M := fun p =>
      match p.1 with
      | .inr done => .inr done
      | .inl a => if hn : n < T then
          CompletedLearner.choiceStatus (n+1)
            (L.transition (n+1) p.2.2.1 a
              (p.2.2.2 ⟨n,hn⟩, ⟪p.2.2.2 ⟨n,hn⟩,p.2.1.val⟫))
        else .inl a
    have hF : Measurable F := by
      apply measurable_from_prod_countable_right
      intro a
      cases a with
      | inr done => exact measurable_const
      | inl a =>
        by_cases hn : n < T
        · simp only [F, dite_eq_left hn]
          apply (measurable_of_countable (CompletedLearner.choiceStatus (M:=M) (n+1))).comp
          have hr : Measurable (fun z : UnitSphere d × (Ω × Samples d T) => z.2.2 ⟨n,hn⟩) :=
            (measurable_pi_apply _).comp measurable_snd.snd
          exact (ht (n+1)).comp
            ((measurable_snd.fst.prodMk measurable_const).prodMk
              (hr.prodMk (hr.inner measurable_fst.subtype_val)))
        · simpa only [F, dite_eq_right hn] using
            (measurable_const : Measurable (fun _ : UnitSphere d × (Ω × Samples d T) =>
              (Sum.inl a : NoiselessRegression.Learner.RunStatus M)))
    exact hF.comp (ih.prodMk measurable_id)

include hi ht ho in
lemma measurable_program_estimate :
    Measurable (fun z : UnitSphere d × (Ω × Samples d T) => L.estimate z.1 z.2.1 z.2.2) := by
  exact ho.comp (measurable_snd.fst.prodMk
    ((measurable_of_countable (CompletedLearner.terminalStatus (M:=M) (T:=T))).comp
      (measurable_program_run L hi ht T)))

include hi ht ho in
lemma admissible_of_borel (ρ : Measure Ω) : L.Admissible ρ := by
  have he := measurable_program_estimate L hi ht ho
  refine ⟨hi.aemeasurable, ?_, ?_, ?_, he.aemeasurable⟩
  · intro n a
    exact ((ht n).comp
      ((measurable_fst.prodMk measurable_const).prodMk measurable_snd)).aemeasurable
  · intro n a
    exact (ho.comp (measurable_id.prodMk (measurable_const (a:=(n,a))))).aemeasurable
  · intro s
    exact (he.comp (measurable_const.prodMk measurable_id)).aemeasurable
end BorelProgram

namespace CompletedLearner
variable {d M T : ℕ} {K : CompletedLearner d M T}
lemma Sampling.admissible (R : K.Sampling) : R.program.Admissible (coinLaw (T+1)) :=
  admissible_of_borel R.program R.measurable_initialChoice R.measurable_program_transition
    R.measurable_program_output _
end CompletedLearner
end StreamKernel




end CurrentProjection

end

end OAI