Source lean/Determinize/Proof/RewardModel/Laws.lean
import Determinize.Proof.RewardModel.Integrabilitynamespace Determinize.Proof.RewardModelopen MeasureTheory Spec.RewardModelopen scoped ENNRealprivate theorem list_measure_apply {α : Type} (xs : List α) (μ : α → Measure ℝ) (s : Set ℝ) :    (xs.map μ).sum s = (xs.map fun x ↦ μ x s).sum := by  induction xs with  | nil => simp  | cons x xs ih => simp [Measure.add_apply, ih]private theorem list_sum_iSup {α : Type} (xs : List α) (f : Nat → α → ℝ≥0∞)    (mono : ∀ a, Monotone (fun n ↦ f n a)) :    (⨆ n, (xs.map (f n)).sum) = (xs.map fun a ↦ ⨆ n, f n a).sum := by  induction xs with  | nil => simp  | cons a xs ih =>    simp only [List.map_cons, List.sum_cons]    rw [← ENNReal.iSup_add_iSup_of_monotone (mono a)      (fun n m h ↦ List.sum_le_sum (fun x _ ↦ mono x h)), ih]theorem shift_iSup (r : Rat) (μ : Nat → Measure ℝ) (mono : Monotone μ) :    shift r (⨆ n, μ n) = ⨆ n, shift r (μ n) := by  ext s hs  have meas : Measurable (fun x : ℝ ↦ x + (r : ℝ)) := measurable_id.add_const _  rw [FiniteModel.monotone_measure_iSup_apply _ (fun _ _ h ↦ shift_mono r (mono h)) s hs]  simp only [shift, Measure.map_apply meas hs,    FiniteModel.monotone_measure_iSup_apply μ mono _ (meas hs)]theorem outputAt_equation (model : Model) (i : Fin model.size) :    model.outputAt i = match model.kind i with    | .returned b => Measure.dirac (b : ℝ)    | .rejected => 0    | .transient => ((model.edges i).map fun e ↦        ENNReal.ofReal (e.probability : ℝ) • shift e.reward (model.outputAt e.target)).sum := by  cases kind : model.kind i with  | returned b =>    have terminal (n : Nat) : model.outputWithin n i = Measure.dirac (b : ℝ) := by      cases n <;> simp [Model.outputWithin, kind]    simp [Model.outputAt, terminal]  | rejected =>    have terminal (n : Nat) : model.outputWithin n i = 0 := by      cases n <;> simp [Model.outputWithin, kind]    simp [Model.outputAt, terminal]  | transient =>    have horizon : model.outputAt i = ⨆ n, model.outputWithin (n + 1) i := by      apply le_antisymm      · exact iSup_le fun n ↦ (outputWithin_mono model i (Nat.le_succ n)).trans          (le_iSup (fun n ↦ model.outputWithin (n + 1) i) n)      · exact iSup_le fun n ↦ le_iSup (fun n ↦ model.outputWithin n i) (n + 1)    rw [horizon]    ext s hs    rw [FiniteModel.monotone_measure_iSup_apply _      (fun n m h ↦ outputWithin_mono model i (Nat.add_le_add_right h 1)) s hs]    simp only [Model.outputWithin, kind, list_measure_apply, Measure.smul_apply, smul_eq_mul]    simp_rw [Model.outputAt, shift_iSup _ _ (outputWithin_mono model _),      FiniteModel.monotone_measure_iSup_apply _        (fun _ _ h ↦ shift_mono _ (outputWithin_mono model _ h)) s hs,      ENNReal.mul_iSup]    exact list_sum_iSup _ _      (fun e _ _ h ↦ mul_le_mul' le_rfl (shift_mono _ (outputWithin_mono model _ h) s))theorem outputAt_mass_le_one (model : Model) (i : Fin model.size) :    model.outputAt i Set.univ ≤ 1 := by  rw [Model.outputAt,    FiniteModel.monotone_measure_iSup_apply _ (outputWithin_mono model i) _ MeasurableSet.univ]  exact iSup_le (fun n ↦ outputWithin_mass_le_one model n i)instance (model : Model) (i : Fin model.size) : IsFiniteMeasure (model.outputAt i) :=  ⟨(outputAt_mass_le_one model i).trans_lt (by simp)⟩private theorem integrable_list_sum {α : Type} (xs : List α) (μ : α → Measure ℝ) (f : ℝ → ℝ)    (integrable : ∀ x ∈ xs, Integrable f (μ x)) : Integrable f (xs.map μ).sum := by  induction xs with  | nil => simp  | cons x xs ih =>    simp only [List.map_cons, List.sum_cons]    exact (integrable x (by simp)).add_measure (ih (fun a ha ↦ integrable a (by simp [ha])))theorem integral_list_sum {α : Type} (xs : List α) (μ : α → Measure ℝ) (f : ℝ → ℝ)    (integrable : ∀ x ∈ xs, Integrable f (μ x)) :    (∫ y, f y ∂(xs.map μ).sum) = (xs.map fun x ↦ ∫ y, f y ∂μ x).sum := by  induction xs with  | nil => simp  | cons x xs ih =>    simp only [List.map_cons, List.sum_cons]    rw [integral_add_measure (integrable x (by simp))      (integrable_list_sum xs μ f (fun a ha ↦ integrable a (by simp [ha]))),      ih (fun a ha ↦ integrable a (by simp [ha]))]end Determinize.Proof.RewardModel