Source lean/Determinize/Proof/Primitives/Kernels.lean
import Determinize.Proof.Primitives.Lawsimport Determinize.Proof.Primitives.DiscreteLawsimport Mathlib.Analysis.SpecialFunctions.Gamma.Derivimport Mathlib.Analysis.SpecialFunctions.Pow.Continuityimport Mathlib.Probability.Distributions.Gaussian.Ferniqueimport Mathlib.Probability.Kernel.WithDensitynamespace Determinize.Proof.Paperopen MeasureTheoryprivate theorem measurable_paperMeasure_gaussian :    Measurable (Determinize.Spec.Paper.paperMeasure .gaussian) := by  let fiber := fun params : Determinize.Spec.Paper.Params .gaussian ↦    if h : 0 ≤ params.2 0 then      ProbabilityTheory.gaussianReal (params.1 0)        (params.2 0).toNNReal else 0  have hFiber : Determinize.Spec.Paper.paperMeasure .gaussian = fiber := by    funext params    simp only [Determinize.Spec.Paper.paperMeasure, fiber]    split <;> rename_i h    · have hNNReal : (⟨params.2 0, h⟩ : NNReal) =          (params.2 0).toNNReal := by        ext        exact (Real.coe_toNNReal _ h).symm      rw [hNNReal]    · rfl  rw [hFiber]  apply Measurable.ite (measurableSet_le measurable_const (by fun_prop))  · have hPair : Measurable (fun x : Determinize.Spec.Paper.Params .gaussian ↦        (x.1 0, (x.2 0).toNNReal)) :=      Measurable.prod (by fun_prop) (by fun_prop)    convert ProbabilityTheory.measurable_gaussianReal.comp hPair using 1    funext x    rfl  · exact measurable_constprivate theorem measurable_rpow_uncurry :    Measurable (fun pair : ℝ × ℝ ↦ pair.1 ^ pair.2) := by  fun_propprivate noncomputable def safePos (value : ℝ) : ℝ := if 0 < value then value else 1private theorem safePos_of_pos {value : ℝ} (hValue : 0 < value) :    safePos value = value := by simp [safePos, hValue]private theorem safePos_pos (value : ℝ) : 0 < safePos value := by  unfold safePos  split_ifs <;> positivityprivate theorem measurable_safePos : Measurable safePos := by  unfold safePos  exact Measurable.ite (measurableSet_lt measurable_const measurable_id)    measurable_id measurable_constprivate theorem measurable_gamma_safe :    Measurable (fun value : ℝ ↦ Real.Gamma (safePos value)) := by  have hGamma : Measurable ((Set.Ioi (0 : ℝ)).piecewise Real.Gamma      (fun _ ↦ Real.Gamma 1)) :=    Real.differentiableOn_Gamma_Ioi.continuousOn.measurable_piecewise      continuousOn_const measurableSet_Ioi  have hFunctions : (fun value : ℝ ↦ Real.Gamma (safePos value)) =      (Set.Ioi (0 : ℝ)).piecewise Real.Gamma (fun _ ↦ Real.Gamma 1) := by    funext value    by_cases hValue : 0 < value <;> simp [Set.piecewise, safePos, hValue]  rw [hFunctions]  exact hGammaprivate noncomputable def gammaJointDensity (params : Determinize.Spec.Paper.Params .gamma)    (value : ℝ) : ENNReal :=  ENNReal.ofReal (ProbabilityTheory.gammaPDFReal    (safePos (params.1 0))    (safePos (params.2 0)) value)private theorem measurable_gammaJointDensity :    Measurable (Function.uncurry gammaJointDensity) := by  let shape := fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦    safePos (pair.1.1 0)  let rate := fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦    safePos (pair.1.2 0)  have hShape : Measurable shape := measurable_safePos.comp (by fun_prop)  have hRate : Measurable rate := measurable_safePos.comp (by fun_prop)  have hGamma : Measurable (fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦      Real.Gamma (shape pair)) := measurable_gamma_safe.comp (by fun_prop)  have hRatePow : Measurable (fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦      rate pair ^ shape pair) := by    change Measurable ((fun pair : ℝ × ℝ ↦ pair.1 ^ pair.2) ∘      fun pair ↦ (rate pair, shape pair))    exact measurable_rpow_uncurry.comp (hRate.prodMk hShape)  have hValuePow : Measurable (fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦      pair.2 ^ (shape pair - 1)) :=    by      have hOne : Measurable (fun _ : Determinize.Spec.Paper.Params .gamma × ℝ ↦ (1 : ℝ)) :=        measurable_const      change Measurable ((fun pair : ℝ × ℝ ↦ pair.1 ^ pair.2) ∘        fun pair ↦ (pair.2, shape pair - 1))      exact measurable_rpow_uncurry.comp (measurable_snd.prodMk (hShape.sub hOne))  apply Measurable.ennreal_ofReal  change Measurable (fun pair : Determinize.Spec.Paper.Params .gamma × ℝ ↦    ProbabilityTheory.gammaPDFReal (shape pair) (rate pair) pair.2)  unfold ProbabilityTheory.gammaPDFReal  apply Measurable.ite (measurableSet_le measurable_const measurable_snd)  · exact (((hRatePow.div hGamma).mul hValuePow).mul (by fun_prop))  · exact measurable_constopen scoped Classical inprivate noncomputable def gammaKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .gamma) ℝ :=  ProbabilityTheory.Kernel.piecewise (Determinize.Proof.Paper.measurableSet_inDomain .gamma)    (ProbabilityTheory.Kernel.withDensity      (ProbabilityTheory.Kernel.const _ volume) gammaJointDensity) 0private theorem gammaKernel_apply (params : Determinize.Spec.Paper.Params .gamma) :    gammaKernel params = Determinize.Spec.Paper.paperMeasure .gamma params := by  classical  by_cases hDomain : Determinize.Spec.Paper.InDomain .gamma params  · rw [gammaKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_left hDomain,      ProbabilityTheory.Kernel.withDensity_apply _ measurable_gammaJointDensity,      ProbabilityTheory.Kernel.const_apply]    rcases hDomain with ⟨hShape, hRate⟩    have hPaper : Determinize.Spec.Paper.paperMeasure .gamma params =        ProbabilityTheory.gammaMeasure (params.1 0)          (params.2 0) := by      change (if h : 0 < params.1 0 ∧ 0 < params.2 0        then ProbabilityTheory.gammaMeasure (params.1 0)          (params.2 0) else 0) = _      rw [dite_eq_left ⟨hShape, hRate⟩]    rw [hPaper, ProbabilityTheory.gammaMeasure]    apply withDensity_congr_ae    filter_upwards [volume.ae_ne 0] with value hValueNe    unfold gammaJointDensity    rw [safePos_of_pos hShape, safePos_of_pos hRate]    rfl  · rw [gammaKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_right hDomain]    change 0 = if 0 < params.1 0 ∧ 0 < params.2 0      then ProbabilityTheory.gammaMeasure (params.1 0)        (params.2 0) else 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]private noncomputable def exponentialJointDensity    (params : Determinize.Spec.Paper.Params .exponential) (value : ℝ) : ENNReal :=  ENNReal.ofReal (ProbabilityTheory.exponentialPDFReal    (safePos (params.2 0)) value)private theorem measurable_exponentialJointDensity :    Measurable (Function.uncurry exponentialJointDensity) := by  let rate := fun pair : Determinize.Spec.Paper.Params .exponential × ℝ ↦    safePos (pair.1.2 0)  have hRate : Measurable rate := measurable_safePos.comp (by fun_prop)  apply Measurable.ennreal_ofReal  change Measurable (fun pair : Determinize.Spec.Paper.Params .exponential × ℝ ↦    ProbabilityTheory.exponentialPDFReal (rate pair) pair.2)  unfold ProbabilityTheory.exponentialPDFReal ProbabilityTheory.gammaPDFReal  simp only [Real.rpow_one, Real.Gamma_one, div_one, sub_self, Real.rpow_zero, mul_one]  apply Measurable.ite (measurableSet_le measurable_const measurable_snd)  · exact hRate.mul ((hRate.mul measurable_snd).neg.exp)  · exact measurable_constopen scoped Classical inprivate noncomputable def exponentialKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .exponential) ℝ :=  ProbabilityTheory.Kernel.piecewise    (Determinize.Proof.Paper.measurableSet_inDomain .exponential)    (ProbabilityTheory.Kernel.withDensity      (ProbabilityTheory.Kernel.const _ volume) exponentialJointDensity) 0private theorem exponentialKernel_apply (params : Determinize.Spec.Paper.Params .exponential) :    exponentialKernel params = Determinize.Spec.Paper.paperMeasure .exponential params := by  classical  by_cases hDomain : Determinize.Spec.Paper.InDomain .exponential params  · rw [exponentialKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_left hDomain,      ProbabilityTheory.Kernel.withDensity_apply _ measurable_exponentialJointDensity,      ProbabilityTheory.Kernel.const_apply]    have hRate : 0 < params.2 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    have hPaper : Determinize.Spec.Paper.paperMeasure .exponential params =        ProbabilityTheory.expMeasure (params.2 0) := by      change (if 0 < params.2 0 then        ProbabilityTheory.expMeasure (params.2 0) else 0) = _      rw [ite_eq_left hRate]    rw [hPaper, ProbabilityTheory.expMeasure, ProbabilityTheory.gammaMeasure]    apply withDensity_congr_ae    exact ae_of_all _ fun value ↦ by      unfold exponentialJointDensity ProbabilityTheory.exponentialPDFReal        ProbabilityTheory.gammaPDF      rw [safePos_of_pos hRate]  · rw [exponentialKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_right hDomain]    change 0 = if 0 < params.2 0 then      ProbabilityTheory.expMeasure (params.2 0) else 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]private noncomputable def betaJointDensity (params : Determinize.Spec.Paper.Params .beta)    (value : ℝ) : ENNReal :=  ENNReal.ofReal (ProbabilityTheory.betaPDFReal    (safePos (params.2 0))    (safePos (params.2 1)) value)private theorem measurable_betaJointDensity :    Measurable (Function.uncurry betaJointDensity) := by  let alpha := fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦    safePos (pair.1.2 0)  let beta := fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦    safePos (pair.1.2 1)  have hAlpha : Measurable alpha := measurable_safePos.comp (by fun_prop)  have hBeta : Measurable beta := measurable_safePos.comp (by fun_prop)  have hGammaAlpha : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      Real.Gamma (alpha pair)) := measurable_gamma_safe.comp (by fun_prop)  have hGammaBeta : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      Real.Gamma (beta pair)) := measurable_gamma_safe.comp (by fun_prop)  have hGammaSum : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      Real.Gamma (alpha pair + beta pair)) := by    have hSafe := measurable_gamma_safe.comp (hAlpha.add hBeta)    have hFunctions : (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦        Real.Gamma (alpha pair + beta pair)) =        (fun pair ↦ Real.Gamma (safePos (alpha pair + beta pair))) := by      funext pair      rw [safePos_of_pos (add_pos (safePos_pos _) (safePos_pos _))]    rw [hFunctions]    exact hSafe  have hNorm : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      ProbabilityTheory.beta (alpha pair) (beta pair)) := by    unfold ProbabilityTheory.beta    exact (hGammaAlpha.mul hGammaBeta).div hGammaSum  have hValuePow : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      pair.2 ^ (alpha pair - 1)) := by    have hOne : Measurable (fun _ : Determinize.Spec.Paper.Params .beta × ℝ ↦ (1 : ℝ)) :=      measurable_const    change Measurable ((fun pair : ℝ × ℝ ↦ pair.1 ^ pair.2) ∘      fun pair ↦ (pair.2, alpha pair - 1))    exact measurable_rpow_uncurry.comp (measurable_snd.prodMk (hAlpha.sub hOne))  have hOneSubPow : Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦      (1 - pair.2) ^ (beta pair - 1)) := by    have hOne : Measurable (fun _ : Determinize.Spec.Paper.Params .beta × ℝ ↦ (1 : ℝ)) :=      measurable_const    change Measurable ((fun pair : ℝ × ℝ ↦ pair.1 ^ pair.2) ∘      fun pair ↦ (1 - pair.2, beta pair - 1))    exact measurable_rpow_uncurry.comp      ((hOne.sub measurable_snd).prodMk (hBeta.sub hOne))  apply Measurable.ennreal_ofReal  change Measurable (fun pair : Determinize.Spec.Paper.Params .beta × ℝ ↦    ProbabilityTheory.betaPDFReal (alpha pair) (beta pair) pair.2)  unfold ProbabilityTheory.betaPDFReal  apply Measurable.ite    ((measurableSet_lt measurable_const measurable_snd).inter      (measurableSet_lt measurable_snd measurable_const))  · exact (((measurable_const.div hNorm).mul hValuePow).mul hOneSubPow)  · exact measurable_constopen scoped Classical inprivate noncomputable def betaKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .beta) ℝ :=  ProbabilityTheory.Kernel.piecewise (Determinize.Proof.Paper.measurableSet_inDomain .beta)    (ProbabilityTheory.Kernel.withDensity      (ProbabilityTheory.Kernel.const _ volume) betaJointDensity) 0private theorem betaKernel_apply (params : Determinize.Spec.Paper.Params .beta) :    betaKernel params = Determinize.Spec.Paper.paperMeasure .beta params := by  classical  by_cases hDomain : Determinize.Spec.Paper.InDomain .beta params  · rw [betaKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_left hDomain,      ProbabilityTheory.Kernel.withDensity_apply _ measurable_betaJointDensity,      ProbabilityTheory.Kernel.const_apply]    rcases hDomain with ⟨hAlpha, hBeta⟩    have hPaper : Determinize.Spec.Paper.paperMeasure .beta params =        ProbabilityTheory.betaMeasure (params.2 0)          (params.2 1) := by      change (if 0 < params.2 0 ∧ 0 < params.2 1        then ProbabilityTheory.betaMeasure (params.2 0)          (params.2 1) else 0) = _      rw [ite_eq_left ⟨hAlpha, hBeta⟩]    rw [hPaper, ProbabilityTheory.betaMeasure]    apply withDensity_congr_ae    exact ae_of_all _ fun value ↦ by      unfold betaJointDensity ProbabilityTheory.betaPDF      rw [safePos_of_pos hAlpha, safePos_of_pos hBeta]  · rw [betaKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_right hDomain]    change 0 = if 0 < params.2 0 ∧ 0 < params.2 1      then ProbabilityTheory.betaMeasure (params.2 0)        (params.2 1) else 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]private noncomputable def uniformJointDensity (params : Determinize.Spec.Paper.Params .uniform)    (value : ℝ) : ENNReal :=  (Set.Icc (params.1 0) (params.1 1)).indicator    (fun _ ↦ (ENNReal.ofReal      (params.1 1 - params.1 0))⁻¹) valueprivate theorem measurable_uniformJointDensity :    Measurable (Function.uncurry uniformJointDensity) := by  unfold uniformJointDensity Set.indicator  apply Measurable.ite  · exact (measurableSet_le (by fun_prop) measurable_snd).inter      (measurableSet_le measurable_snd (by fun_prop))  · fun_prop  · exact measurable_constopen scoped Classical inprivate noncomputable def uniformKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .uniform) ℝ :=  let intervalKernel := ProbabilityTheory.Kernel.withDensity    (ProbabilityTheory.Kernel.const (Determinize.Spec.Paper.Params .uniform) volume)      uniformJointDensity  let pointKernel := ProbabilityTheory.Kernel.deterministic    (fun params : Determinize.Spec.Paper.Params .uniform ↦ params.1 0) (by fun_prop)  let hPointSet : MeasurableSet {params : Determinize.Spec.Paper.Params .uniform |      params.1 0 = params.1 1} :=    measurableSet_eq_fun (by fun_prop) (by fun_prop)  let domainKernel := ProbabilityTheory.Kernel.piecewise    hPointSet pointKernel intervalKernel  ProbabilityTheory.Kernel.piecewise (Determinize.Proof.Paper.measurableSet_inDomain .uniform)    domainKernel 0private theorem uniformKernel_apply (params : Determinize.Spec.Paper.Params .uniform) :    uniformKernel params = Determinize.Spec.Paper.paperMeasure .uniform params := by  classical  let lower := params.1 0  let upper := params.1 1  by_cases hDomain : Determinize.Spec.Paper.InDomain .uniform params  · have hle : lower ≤ upper := by      simpa [lower, upper, Determinize.Spec.Paper.InDomain] using hDomain    rw [uniformKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_left hDomain, ProbabilityTheory.Kernel.piecewise_apply]    by_cases hPoint : lower = upper    · rw [ite_eq_left (by simpa [lower, upper] using hPoint),        ProbabilityTheory.Kernel.deterministic_apply]      change Measure.dirac lower = Determinize.Spec.Paper.uniformMeasure lower upper      unfold Determinize.Spec.Paper.uniformMeasure      rw [dite_eq_left hle, dite_eq_left hPoint]    · rw [ite_eq_right (by simpa [lower, upper] using hPoint),        ProbabilityTheory.Kernel.withDensity_apply _ measurable_uniformJointDensity,        ProbabilityTheory.Kernel.const_apply]      change volume.withDensity        ((Set.Icc lower upper).indicator          (fun _ ↦ (ENNReal.ofReal (upper - lower))⁻¹)) =        Determinize.Spec.Paper.uniformMeasure lower upper      unfold Determinize.Spec.Paper.uniformMeasure      rw [dite_eq_left hle, dite_eq_right hPoint, withDensity_indicator measurableSet_Icc,        withDensity_const]  · rw [uniformKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_right hDomain]    change 0 = Determinize.Spec.Paper.uniformMeasure (params.1 0)      (params.1 1)    unfold Determinize.Spec.Paper.uniformMeasure    rw [dite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]private noncomputable def poissonWeight (params : Determinize.Spec.Paper.Params .poisson)    (index : Nat) : ENNReal :=  let rate : ℝ := params.1 0 |>.toNNReal  ENNReal.ofReal (Real.exp (-rate) * rate ^ index / index.factorial)private theorem measurable_poissonWeight (index : Nat) :    Measurable        (fun params : Determinize.Spec.Paper.Params .poisson ↦ poissonWeight params index) := by  unfold poissonWeight  fun_propprivate noncomputable def poissonAtomKernel (index : Nat) :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .poisson) ℝ :=  ProbabilityTheory.Kernel.withDensity    (ProbabilityTheory.Kernel.deterministic      (fun _ : Determinize.Spec.Paper.Params .poisson ↦ (index : ℝ)) measurable_const)    (fun params _ ↦ poissonWeight params index)private theorem measurable_poissonAtomDensity (index : Nat) :    Measurable (Function.uncurry      (fun params : Determinize.Spec.Paper.Params .poisson ↦ fun _ : ℝ ↦          poissonWeight params index)) := by  exact (measurable_poissonWeight index).comp measurable_fstopen scoped Classical inprivate noncomputable def poissonKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .poisson) ℝ :=  ProbabilityTheory.Kernel.piecewise (Determinize.Proof.Paper.measurableSet_inDomain .poisson)    (ProbabilityTheory.Kernel.sum poissonAtomKernel) 0private theorem poissonKernel_apply (params : Determinize.Spec.Paper.Params .poisson) :    poissonKernel params = Determinize.Spec.Paper.paperMeasure .poisson params := by  classical  by_cases hDomain : Determinize.Spec.Paper.InDomain .poisson params  · rw [poissonKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_left hDomain, ProbabilityTheory.Kernel.sum_apply]    have hRate : 0 ≤ params.1 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    let rate : NNReal := (params.1 0).toNNReal    have hPaper : Determinize.Spec.Paper.paperMeasure .poisson params =        (ProbabilityTheory.poissonMeasure rate).map (fun value : Nat ↦ (value : ℝ)) := by      change (if h : 0 ≤ params.1 0 then        (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map          (fun value : Nat ↦ (value : ℝ)) else 0) = _      rw [dite_eq_left hRate]      congr 2      exact Subtype.ext (by simp [rate, Real.toNNReal_of_nonneg hRate])    rw [hPaper, ProbabilityTheory.poissonMeasure,      Measure.map_sum        (measurable_of_countable (fun value : Nat ↦ (value : ℝ))).aemeasurable]    congr 1    funext index    rw [poissonAtomKernel,      ProbabilityTheory.Kernel.withDensity_apply _ (measurable_poissonAtomDensity index),      ProbabilityTheory.Kernel.deterministic_apply, withDensity_const,      Measure.map_smul _ (measurable_of_countable (fun value : Nat ↦ (value : ℝ))).aemeasurable,      Measure.map_dirac' (measurable_of_countable (fun value : Nat ↦ (value : ℝ)))]    unfold poissonWeight    rw [show ((params.1 0).toNNReal : ℝ) = (rate : ℝ) by rfl]  · rw [poissonKernel, ProbabilityTheory.Kernel.piecewise_apply]    simp only [Set.mem_ofPred_eq]    rw [ite_eq_right hDomain]    change 0 = if h : 0 ≤ params.1 0 then      (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map        (fun value : Nat ↦ (value : ℝ)) else 0    rw [dite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]private theorem paperMeasure_univ (op : Determinize.Spec.Paper.Op)    (params : Determinize.Spec.Paper.Params op)    (hDomain : Determinize.Spec.Paper.InDomain op params) :    Determinize.Spec.Paper.paperMeasure op params Set.univ = 1 := by  cases op with  | uniform =>    change Determinize.Spec.Paper.uniformMeasure (params.1 0)      (params.1 1) Set.univ = 1    unfold Determinize.Spec.Paper.uniformMeasure    have hd : params.1 0 ≤ params.1 1 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [dite_eq_left hd]    split <;> rename_i hPoint    · simp    · rw [Measure.smul_apply, Measure.restrict_apply_univ,        Real.volume_Icc]      have hPositive : 0 < params.1 1 - params.1 0 :=        sub_pos.mpr (lt_of_le_of_ne hd hPoint)      apply ENNReal.inv_mul_cancel      · exact (ENNReal.ofReal_pos.mpr hPositive).ne'      · exact ENNReal.ofReal_ne_top  | gaussian =>    change (if h : 0 ≤ params.2 0 then      ProbabilityTheory.gaussianReal (params.1 0)        ⟨params.2 0, h⟩ else 0) Set.univ = 1    have hd : 0 ≤ params.2 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [dite_eq_left hd]    let := ProbabilityTheory.instIsProbabilityMeasureGaussianReal      (params.1 0) ⟨params.2 0, hd⟩    exact measure_univ  | poisson =>    change (if h : 0 ≤ params.1 0 then      (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map        (fun value : Nat ↦ (value : ℝ)) else 0) Set.univ = 1    have hd : 0 ≤ params.1 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [dite_eq_left hd]    have hRate : (⟨params.1 0, hd⟩ : NNReal) =        (params.1 0).toNNReal := by      ext      exact (Real.coe_toNNReal _ hd).symm    rw [hRate]    exact measure_univ  | exponential =>    change (if 0 < params.2 0 then      ProbabilityTheory.expMeasure (params.2 0) else 0) Set.univ = 1    have hd : 0 < params.2 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [ite_eq_left hd]    let := ProbabilityTheory.isProbabilityMeasure_expMeasure hd    exact measure_univ  | beta =>    change (if 0 < params.2 0 ∧ 0 < params.2 1 then      ProbabilityTheory.betaMeasure (params.2 0)        (params.2 1) else 0) Set.univ = 1    have hd : 0 < params.2 0 ∧        0 < params.2 1 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [ite_eq_left hd]    let := ProbabilityTheory.isProbabilityMeasureBeta hd.1 hd.2    exact measure_univ  | gamma =>    change (if 0 < params.1 0 ∧ 0 < params.2 0 then      ProbabilityTheory.gammaMeasure (params.1 0)        (params.2 0) else 0) Set.univ = 1    have hd : 0 < params.1 0 ∧        0 < params.2 0 := by      simpa only [Determinize.Spec.Paper.InDomain] using hDomain    rw [ite_eq_left hd]    let := ProbabilityTheory.isProbabilityMeasure_gammaMeasure hd.1 hd.2    exact measure_univ  | bernoulli =>    let := DiscreteLaws.isProbabilityMeasure_bernoulliFiber (.sample .G) (params.1 0) hDomain    exact measure_univ (μ := Determinize.Spec.Paper.bernoulliFiber (.sample .G) (params.1 0))  | discrete n =>    simp only [Determinize.Spec.Paper.InDomain] at hDomain    rw [Determinize.Spec.Paper.paperMeasure, ite_eq_left hDomain]    exact DiscreteLaws.remainderMeasure_univ n params.1 hDomainprivate theorem paperMeasure_eq_zero_of_not_inDomain (op : Determinize.Spec.Paper.Op)    (params : Determinize.Spec.Paper.Params op)    (hDomain : ¬ Determinize.Spec.Paper.InDomain op params) :    Determinize.Spec.Paper.paperMeasure op params = 0 := by  cases op with  | uniform =>    change Determinize.Spec.Paper.uniformMeasure (params.1 0)      (params.1 1) = 0    unfold Determinize.Spec.Paper.uniformMeasure    rw [dite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | gaussian =>    change (if h : 0 ≤ params.2 0 then      ProbabilityTheory.gaussianReal (params.1 0)        ⟨params.2 0, h⟩ else 0) = 0    rw [dite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | poisson =>    change (if h : 0 ≤ params.1 0 then      (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map        (fun value : Nat ↦ (value : ℝ)) else 0) = 0    rw [dite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | exponential =>    change (if 0 < params.2 0 then      ProbabilityTheory.expMeasure (params.2 0) else 0) = 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | beta =>    change (if 0 < params.2 0 ∧ 0 < params.2 1 then      ProbabilityTheory.betaMeasure (params.2 0)        (params.2 1) else 0) = 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | gamma =>    change (if 0 < params.1 0 ∧ 0 < params.2 0 then      ProbabilityTheory.gammaMeasure (params.1 0)        (params.2 0) else 0) = 0    rw [ite_eq_right (by simpa only [Determinize.Spec.Paper.InDomain] using hDomain)]  | bernoulli => exact DiscreteLaws.bernoulliFiber_eq_zero (.sample .G) (params.1 0) hDomain  | discrete _ =>    simp only [Determinize.Spec.Paper.InDomain] at hDomain    rw [Determinize.Spec.Paper.paperMeasure, ite_eq_right hDomain]private theorem paperMeasure_univ_le_one (op : Determinize.Spec.Paper.Op)    (params : Determinize.Spec.Paper.Params op) :    Determinize.Spec.Paper.paperMeasure op params Set.univ ≤ 1 := by  by_cases hDomain : Determinize.Spec.Paper.InDomain op params  · rw [paperMeasure_univ op params hDomain]  · rw [paperMeasure_eq_zero_of_not_inDomain op params hDomain]    simpprivate theorem integrable_id_paperMeasure_gaussian    (params : Determinize.Spec.Paper.Params .gaussian)    (hDomain : Determinize.Spec.Paper.InDomain .gaussian params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .gaussian params) := by  have hd : 0 ≤ params.2 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  change Integrable id (if h : 0 ≤ params.2 0 then    ProbabilityTheory.gaussianReal (params.1 0)      ⟨params.2 0, h⟩ else 0)  rw [dite_eq_left hd]  let : ProbabilityTheory.IsGaussian      (ProbabilityTheory.gaussianReal (params.1 0)        ⟨params.2 0, hd⟩) :=    ProbabilityTheory.isGaussian_gaussianReal _ _  exact ProbabilityTheory.IsGaussian.integrable_idprivate theorem integral_paperMeasure_gaussian (params : Determinize.Spec.Paper.Params .gaussian)    (hDomain : Determinize.Spec.Paper.InDomain .gaussian params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .gaussian params) =      Determinize.Spec.Paper.meanValue .gaussian params := by  have hd : 0 ≤ params.2 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  change (∫ value : ℝ, value ∂if h : 0 ≤ params.2 0 then    ProbabilityTheory.gaussianReal (params.1 0)      ⟨params.2 0, h⟩ else 0) = _  rw [dite_eq_left hd]  calc    _ = params.1 0 := ProbabilityTheory.integral_id_gaussianReal    _ = _ := by      simp only [Determinize.Proof.Paper.meanValue_eq_affine, Determinize.Proof.Paper.meanConstant,        Determinize.Proof.Paper.meanCoeff,        Determinize.Spec.Paper.affineArity, zero_add, one_mul]      symm      exact Fin.sum_univ_one _private theorem integrable_id_paperMeasure_uniform (params : Determinize.Spec.Paper.Params .uniform)    (hDomain : Determinize.Spec.Paper.InDomain .uniform params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .uniform params) := by  let lower := params.1 0  let upper := params.1 1  have hle : lower ≤ upper := by simpa [lower, upper, Determinize.Spec.Paper.InDomain] using hDomain  change Integrable id (Determinize.Spec.Paper.uniformMeasure lower upper)  unfold Determinize.Spec.Paper.uniformMeasure  rw [dite_eq_left hle]  by_cases hPoint : lower = upper  · rw [dite_eq_left hPoint]    exact integrable_dirac (by simp)  · rw [dite_eq_right hPoint]    have hPositive : 0 < upper - lower := sub_pos.mpr (lt_of_le_of_ne hle hPoint)    have hScaleZero : (ENNReal.ofReal (upper - lower))⁻¹ ≠ 0 :=      ENNReal.inv_ne_zero.mpr ENNReal.ofReal_ne_top    have hScaleTop : (ENNReal.ofReal (upper - lower))⁻¹ ≠ ⊤ :=      ENNReal.inv_ne_top.mpr (ENNReal.ofReal_pos.mpr hPositive).ne'    exact (integrable_smul_measure (f := id) hScaleZero hScaleTop).mpr      continuous_id.continuousOn.integrableOn_Iccprivate theorem integral_paperMeasure_uniform (params : Determinize.Spec.Paper.Params .uniform)    (hDomain : Determinize.Spec.Paper.InDomain .uniform params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .uniform params) =      Determinize.Spec.Paper.meanValue .uniform params := by  let lower := params.1 0  let upper := params.1 1  have hle : lower ≤ upper := by simpa [lower, upper, Determinize.Spec.Paper.InDomain] using hDomain  change (∫ value : ℝ, value ∂Determinize.Spec.Paper.uniformMeasure lower upper) = _  unfold Determinize.Spec.Paper.uniformMeasure  rw [dite_eq_left hle]  by_cases hPoint : lower = upper  · rw [dite_eq_left hPoint]    simp only [integral_dirac]    subst upper    simp only [Determinize.Proof.Paper.meanValue_eq_affine, Determinize.Proof.Paper.meanConstant,      Determinize.Proof.Paper.meanCoeff,      Determinize.Spec.Paper.affineArity, zero_add]    have hSum : (∑ i, 1 / 2 * params.1 i) =        1 / 2 * params.1 0 + 1 / 2 * params.1 1 := by      exact Fin.sum_univ_two _    calc      lower = 1 / 2 * params.1 0 +          1 / 2 * params.1 1 := by            rw [← hPoint]            dsimp [lower]            ring      _ = _ := hSum.symm  · rw [dite_eq_right hPoint, integral_smul_measure]    have hPositive : 0 < upper - lower := sub_pos.mpr (lt_of_le_of_ne hle hPoint)    have hSetIntegral : (∫ value : ℝ in Set.Icc lower upper, value) =        (upper ^ 2 - lower ^ 2) / 2 := by      rw [integral_Icc_eq_integral_Ioc, ← intervalIntegral.integral_of_le hle,        integral_id]    rw [hSetIntegral]    have hScale : (ENNReal.ofReal (upper - lower))⁻¹.toReal =        1 / (upper - lower) := by      rw [ENNReal.toReal_inv]      simp [ENNReal.toReal_ofReal hPositive.le]    rw [hScale]    simp only [smul_eq_mul, Determinize.Proof.Paper.meanValue_eq_affine,      Determinize.Proof.Paper.meanConstant, Determinize.Proof.Paper.meanCoeff,      Determinize.Spec.Paper.affineArity, zero_add]    have hSum : (∑ i, 1 / 2 * params.1 i) =        1 / 2 * params.1 0 + 1 / 2 * params.1 1 := by      exact Fin.sum_univ_two _    calc      1 / (upper - lower) * ((upper ^ 2 - lower ^ 2) / 2) =          1 / 2 * params.1 0 +            1 / 2 * params.1 1 := by              rw [show upper ^ 2 - lower ^ 2 =                (upper - lower) * (upper + lower) by ring]              field_simp [hPositive.ne']              dsimp only [lower, upper]              ring      _ = _ := hSum.symmprivate theorem hasSum_poisson_first_moment (rate : NNReal) :    HasSum (fun n : Nat ↦ Real.exp (-(rate : ℝ)) * (rate : ℝ) ^ n /      n.factorial * (n : ℝ)) (rate : ℝ) := by  let term := fun n : Nat ↦ Real.exp (-(rate : ℝ)) * (rate : ℝ) ^ n /    n.factorial * (n : ℝ)  have hSeries := (NormedSpace.expSeries_div_hasSum_exp (rate : ℝ)).mul_left    (Real.exp (-(rate : ℝ)) * (rate : ℝ))  have hTail : HasSum (fun n : Nat ↦ term (n + 1)) (rate : ℝ) := by    have hTerms : (fun n : Nat ↦ term (n + 1)) =        fun n : Nat ↦ Real.exp (-(rate : ℝ)) * (rate : ℝ) *          ((rate : ℝ) ^ n / n.factorial) := by      funext n      dsimp only [term]      rw [pow_succ, Nat.factorial_succ, Nat.cast_mul, Nat.cast_succ]      field_simp    rw [hTerms]    have hResult : Real.exp (-(rate : ℝ)) * (rate : ℝ) *        NormedSpace.exp (rate : ℝ) = (rate : ℝ) := by      rw [← Real.exp_eq_exp_ℝ]      calc        Real.exp (-(rate : ℝ)) * (rate : ℝ) * Real.exp (rate : ℝ) =            (rate : ℝ) * (Real.exp (-(rate : ℝ)) * Real.exp (rate : ℝ)) := by ring        _ = _ := by rw [← Real.exp_add]; simp    rw [hResult] at hSeries    exact hSeries  apply (hasSum_nat_add_iff' 1).mp  simpa [term] using hTailprivate theorem integrable_id_paperMeasure_poisson (params : Determinize.Spec.Paper.Params .poisson)    (hDomain : Determinize.Spec.Paper.InDomain .poisson params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .poisson params) := by  have hd : 0 ≤ params.1 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  let rate : NNReal := (params.1 0).toNNReal  have hRate : (⟨params.1 0, hd⟩ : NNReal) = rate := by    apply Subtype.ext    simp [rate, Real.toNNReal_of_nonneg hd]  change Integrable id (if h : 0 ≤ params.1 0 then    (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map      (fun value : Nat ↦ (value : ℝ)) else 0)  rw [dite_eq_left hd, hRate,    integrable_map_measure continuous_id.aestronglyMeasurable      (measurable_of_countable (fun value : Nat ↦ (value : ℝ))).aemeasurable,    ProbabilityTheory.integrable_poissonMeasure_iff]  simpa [Function.comp_apply, Real.norm_eq_abs] using    (hasSum_poisson_first_moment rate).summableprivate theorem integral_paperMeasure_poisson (params : Determinize.Spec.Paper.Params .poisson)    (hDomain : Determinize.Spec.Paper.InDomain .poisson params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .poisson params) =      Determinize.Spec.Paper.meanValue .poisson params := by  have hd : 0 ≤ params.1 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  let rate : NNReal := (params.1 0).toNNReal  have hRate : (⟨params.1 0, hd⟩ : NNReal) = rate := by    apply Subtype.ext    simp [rate, Real.toNNReal_of_nonneg hd]  change (∫ value : ℝ, value ∂if h : 0 ≤ params.1 0 then    (ProbabilityTheory.poissonMeasure ⟨params.1 0, h⟩).map      (fun value : Nat ↦ (value : ℝ)) else 0) = _  rw [dite_eq_left hd, hRate]  have hMap : (∫ value : ℝ, value ∂      (ProbabilityTheory.poissonMeasure rate).map (fun value : Nat ↦ (value : ℝ))) =      ∫ value : Nat, (value : ℝ) ∂ProbabilityTheory.poissonMeasure rate := by    exact integral_map_of_stronglyMeasurable      (measurable_of_countable (fun value : Nat ↦ (value : ℝ)))      continuous_id.stronglyMeasurable  rw [hMap, ProbabilityTheory.integral_poissonMeasure rate,    show (∑' n : Nat, (Real.exp (-(rate : ℝ)) * (rate : ℝ) ^ n /      n.factorial) • (n : ℝ)) =        ∑' n : Nat, Real.exp (-(rate : ℝ)) * (rate : ℝ) ^ n /          n.factorial * (n : ℝ) by simp only [smul_eq_mul],    (hasSum_poisson_first_moment rate).tsum_eq]  simp only [Determinize.Proof.Paper.meanValue_eq_affine, Determinize.Proof.Paper.meanConstant,    Determinize.Proof.Paper.meanCoeff,    Determinize.Spec.Paper.affineArity, zero_add, one_mul]  rw [show (rate : ℝ) = params.1 0 by    simp [rate, Real.toNNReal_of_nonneg hd]]  symm  exact Fin.sum_univ_one _private theorem gamma_mul_pdf_ae {shape rate : ℝ} (hShape : 0 < shape)    (hRate : 0 < rate) :    ∀ᵐ value : ℝ ∂volume,      value * ProbabilityTheory.gammaPDFReal shape rate value =        (shape / rate) * ProbabilityTheory.gammaPDFReal (shape + 1) rate value := by  filter_upwards [volume.ae_ne 0] with value hValueNe  by_cases hValueNeg : value < 0  · simp [ProbabilityTheory.gammaPDFReal, not_le.mpr hValueNeg]  · have hValue : 0 < value := lt_of_le_of_ne (le_of_not_gt hValueNeg) (Ne.symm hValueNe)    simp only [ProbabilityTheory.gammaPDFReal, ite_eq_left hValue.le]    rw [Real.Gamma_add_one hShape.ne', Real.rpow_add_one hRate.ne',      show shape + 1 - 1 = shape by ring]    rw [show value ^ shape = value * value ^ (shape - 1) by      calc        value ^ shape = value ^ (1 + (shape - 1)) := by congr 1; ring        _ = value ^ (1 : ℝ) * value ^ (shape - 1) := Real.rpow_add hValue _ _        _ = _ := by rw [Real.rpow_one]]    field_simp [hShape.ne', hRate.ne', (Real.Gamma_pos_of_pos hShape).ne']private theorem integrable_gammaPDFReal {shape rate : ℝ} (hShape : 0 < shape)    (hRate : 0 < rate) :    Integrable (ProbabilityTheory.gammaPDFReal shape rate) volume := by  let : IsProbabilityMeasure (ProbabilityTheory.gammaMeasure shape rate) :=    ProbabilityTheory.isProbabilityMeasure_gammaMeasure hShape hRate  have hOne : Integrable (fun _ : ℝ ↦ (1 : ℝ))      (ProbabilityTheory.gammaMeasure shape rate) := integrable_const _  rw [ProbabilityTheory.gammaMeasure] at hOne  have hWeighted := (integrable_withDensity_iff (μ := volume)    (ProbabilityTheory.measurable_gammaPDFReal shape rate).ennreal_ofReal    (by simp)).mp hOne  apply hWeighted.congr  exact ae_of_all _ fun value ↦ by    simp only [one_mul]    rw [ENNReal.toReal_ofReal      (ProbabilityTheory.gammaPDFReal_nonneg hShape hRate value)]private theorem integral_gammaPDFReal_eq_one {shape rate : ℝ} (hShape : 0 < shape)    (hRate : 0 < rate) :    (∫ value : ℝ, ProbabilityTheory.gammaPDFReal shape rate value) = 1 := by  let : IsProbabilityMeasure (ProbabilityTheory.gammaMeasure shape rate) :=    ProbabilityTheory.isProbabilityMeasure_gammaMeasure hShape hRate  have hOne : (∫ _value : ℝ, (1 : ℝ) ∂      ProbabilityTheory.gammaMeasure shape rate) = 1 := by simp  calc    (∫ value : ℝ, ProbabilityTheory.gammaPDFReal shape rate value) =        ∫ value : ℝ, (ProbabilityTheory.gammaPDF shape rate value).toReal • (1 : ℝ) := by          apply integral_congr_ae          exact ae_of_all _ fun value ↦ by            simp only [smul_eq_mul, mul_one, ProbabilityTheory.gammaPDF]            rw [ENNReal.toReal_ofReal              (ProbabilityTheory.gammaPDFReal_nonneg hShape hRate value)]    _ = ∫ _value : ℝ, (1 : ℝ) ∂ProbabilityTheory.gammaMeasure shape rate := by      rw [ProbabilityTheory.gammaMeasure]      exact (integral_withDensity_eq_integral_toReal_smul        (ProbabilityTheory.measurable_gammaPDFReal shape rate).ennreal_ofReal        (by simp) _).symm    _ = 1 := hOneprivate theorem integrable_id_gammaMeasure {shape rate : ℝ} (hShape : 0 < shape)    (hRate : 0 < rate) :    Integrable id (ProbabilityTheory.gammaMeasure shape rate) := by  rw [ProbabilityTheory.gammaMeasure]  apply (integrable_withDensity_iff (μ := volume)    (ProbabilityTheory.measurable_gammaPDFReal shape rate).ennreal_ofReal    (by simp)).mpr  have hShift := (integrable_gammaPDFReal (add_pos hShape zero_lt_one) hRate).const_mul    (shape / rate)  apply hShift.congr  filter_upwards [gamma_mul_pdf_ae hShape hRate] with value hValue  simpa only [id_eq, ProbabilityTheory.gammaPDF,    ENNReal.toReal_ofReal      (ProbabilityTheory.gammaPDFReal_nonneg hShape hRate value)] using hValue.symmprivate theorem integral_gammaMeasure {shape rate : ℝ} (hShape : 0 < shape)    (hRate : 0 < rate) :    (∫ value : ℝ, value ∂ProbabilityTheory.gammaMeasure shape rate) = shape / rate := by  calc    (∫ value : ℝ, value ∂ProbabilityTheory.gammaMeasure shape rate) =        ∫ value : ℝ, (ProbabilityTheory.gammaPDF shape rate value).toReal • value := by          rw [ProbabilityTheory.gammaMeasure]          exact integral_withDensity_eq_integral_toReal_smul            (ProbabilityTheory.measurable_gammaPDFReal shape rate).ennreal_ofReal            (by simp) _    _ = ∫ value : ℝ, (shape / rate) *        ProbabilityTheory.gammaPDFReal (shape + 1) rate value := by          apply integral_congr_ae          filter_upwards [gamma_mul_pdf_ae hShape hRate] with value hValue          simpa only [smul_eq_mul, ProbabilityTheory.gammaPDF, mul_comm,            ENNReal.toReal_ofReal              (ProbabilityTheory.gammaPDFReal_nonneg hShape hRate value)] using hValue    _ = shape / rate := by      rw [integral_const_mul,        integral_gammaPDFReal_eq_one (add_pos hShape zero_lt_one) hRate, mul_one]private theorem integrable_id_paperMeasure_gamma (params : Determinize.Spec.Paper.Params .gamma)    (hDomain : Determinize.Spec.Paper.InDomain .gamma params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .gamma params) := by  rcases hDomain with ⟨hShape, hRate⟩  change Integrable id (if h : 0 < params.1 0 ∧    0 < params.2 0 then      ProbabilityTheory.gammaMeasure (params.1 0)        (params.2 0) else 0)  rw [dite_eq_left ⟨hShape, hRate⟩]  exact integrable_id_gammaMeasure hShape hRateprivate theorem integral_paperMeasure_gamma (params : Determinize.Spec.Paper.Params .gamma)    (hDomain : Determinize.Spec.Paper.InDomain .gamma params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .gamma params) =      Determinize.Spec.Paper.meanValue .gamma params := by  rcases hDomain with ⟨hShape, hRate⟩  change (∫ value : ℝ, value ∂if h : 0 < params.1 0 ∧    0 < params.2 0 then      ProbabilityTheory.gammaMeasure (params.1 0)        (params.2 0) else 0) = _  rw [dite_eq_left ⟨hShape, hRate⟩, integral_gammaMeasure hShape hRate]  simp only [Determinize.Proof.Paper.meanValue_eq_affine, Determinize.Proof.Paper.meanConstant,    Determinize.Proof.Paper.meanCoeff,    Determinize.Spec.Paper.affineArity, zero_add]  change params.1 (0 : Fin 1) / params.2 (0 : Fin 1) =    ∑ i : Fin 1, 1 / params.2 (0 : Fin 1) * params.1 i  rw [Fin.sum_univ_one]  ringprivate theorem integrable_id_paperMeasure_exponential    (params : Determinize.Spec.Paper.Params .exponential)    (hDomain : Determinize.Spec.Paper.InDomain .exponential params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .exponential params) := by  have hRate : 0 < params.2 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  change Integrable id (if h : 0 < params.2 0 then    ProbabilityTheory.expMeasure (params.2 0) else 0)  rw [dite_eq_left hRate, ProbabilityTheory.expMeasure]  exact integrable_id_gammaMeasure zero_lt_one hRateprivate theorem integral_paperMeasure_exponential    (params : Determinize.Spec.Paper.Params .exponential)    (hDomain : Determinize.Spec.Paper.InDomain .exponential params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .exponential params) =      Determinize.Spec.Paper.meanValue .exponential params := by  have hRate : 0 < params.2 0 := by    simpa only [Determinize.Spec.Paper.InDomain] using hDomain  change (∫ value : ℝ, value ∂if h : 0 < params.2 0 then    ProbabilityTheory.expMeasure (params.2 0) else 0) = _  rw [dite_eq_left hRate, ProbabilityTheory.expMeasure,    integral_gammaMeasure zero_lt_one hRate]  rw [Determinize.Proof.Paper.meanValue_eq_affine]  unfold Determinize.Proof.Paper.meanConstant  have hSum : (∑ i : Fin (Determinize.Spec.Paper.affineArity .exponential),      Determinize.Proof.Paper.meanCoeff .exponential params.2 i * params.1 i) = 0 := by    apply Finset.sum_eq_zero    intro index _    exact Fin.elim0 index  rw [hSum, add_zero]private theorem beta_add_one (alpha beta : ℝ) (hAlpha : 0 < alpha)    (hBeta : 0 < beta) :    ProbabilityTheory.beta (alpha + 1) beta =      alpha / (alpha + beta) * ProbabilityTheory.beta alpha beta := by  unfold ProbabilityTheory.beta  rw [Real.Gamma_add_one hAlpha.ne',    show alpha + 1 + beta = (alpha + beta) + 1 by ring,    Real.Gamma_add_one (add_pos hAlpha hBeta).ne']  field_simp [(Real.Gamma_pos_of_pos hAlpha).ne',    (Real.Gamma_pos_of_pos hBeta).ne',    (Real.Gamma_pos_of_pos (add_pos hAlpha hBeta)).ne',    (add_pos hAlpha hBeta).ne']private theorem betaPDFReal_nonneg (alpha beta : ℝ) (hAlpha : 0 < alpha)    (hBeta : 0 < beta) (value : ℝ) :    0 ≤ ProbabilityTheory.betaPDFReal alpha beta value := by  unfold ProbabilityTheory.betaPDFReal  split_ifs with hValue  · exact mul_nonneg      (mul_nonneg (one_div_nonneg.mpr (ProbabilityTheory.beta_pos hAlpha hBeta).le)        (Real.rpow_nonneg hValue.1.le _))      (Real.rpow_nonneg (sub_nonneg.mpr hValue.2.le) _)  · exact le_rflprivate theorem beta_mul_pdf (alpha beta : ℝ) (hAlpha : 0 < alpha)    (hBeta : 0 < beta) (value : ℝ) :    value * ProbabilityTheory.betaPDFReal alpha beta value =      (alpha / (alpha + beta)) *        ProbabilityTheory.betaPDFReal (alpha + 1) beta value := by  unfold ProbabilityTheory.betaPDFReal  by_cases hValue : 0 < value ∧ value < 1  · rw [ite_eq_left hValue, ite_eq_left hValue, beta_add_one alpha beta hAlpha hBeta]    rw [show alpha + 1 - 1 = alpha by ring]    rw [show value ^ alpha = value * value ^ (alpha - 1) by      calc        value ^ alpha = value ^ (1 + (alpha - 1)) := by congr 1; ring        _ = value ^ (1 : ℝ) * value ^ (alpha - 1) :=          Real.rpow_add hValue.1 _ _        _ = _ := by rw [Real.rpow_one]]    field_simp [(ProbabilityTheory.beta_pos hAlpha hBeta).ne',      (add_pos hAlpha hBeta).ne']  · rw [ite_eq_right hValue, ite_eq_right hValue, mul_zero, mul_zero]private theorem integrable_betaPDFReal {alpha beta : ℝ} (hAlpha : 0 < alpha)    (hBeta : 0 < beta) :    Integrable (ProbabilityTheory.betaPDFReal alpha beta) volume := by  let : IsProbabilityMeasure (ProbabilityTheory.betaMeasure alpha beta) :=    ProbabilityTheory.isProbabilityMeasureBeta hAlpha hBeta  have hOne : Integrable (fun _ : ℝ ↦ (1 : ℝ))      (ProbabilityTheory.betaMeasure alpha beta) := integrable_const _  rw [ProbabilityTheory.betaMeasure] at hOne  have hWeighted := (integrable_withDensity_iff (μ := volume)    (ProbabilityTheory.measurable_betaPDFReal alpha beta).ennreal_ofReal    (by simp)).mp hOne  apply hWeighted.congr  exact ae_of_all _ fun value ↦ by    simp only [one_mul]    rw [ENNReal.toReal_ofReal (betaPDFReal_nonneg alpha beta hAlpha hBeta value)]private theorem integral_betaPDFReal_eq_one {alpha beta : ℝ} (hAlpha : 0 < alpha)    (hBeta : 0 < beta) :    (∫ value : ℝ, ProbabilityTheory.betaPDFReal alpha beta value) = 1 := by  let : IsProbabilityMeasure (ProbabilityTheory.betaMeasure alpha beta) :=    ProbabilityTheory.isProbabilityMeasureBeta hAlpha hBeta  have hOne : (∫ _value : ℝ, (1 : ℝ) ∂      ProbabilityTheory.betaMeasure alpha beta) = 1 := by simp  calc    (∫ value : ℝ, ProbabilityTheory.betaPDFReal alpha beta value) =        ∫ value : ℝ, (ProbabilityTheory.betaPDF alpha beta value).toReal • (1 : ℝ) := by          apply integral_congr_ae          exact ae_of_all _ fun value ↦ by            simp only [smul_eq_mul, mul_one, ProbabilityTheory.betaPDF]            rw [ENNReal.toReal_ofReal (betaPDFReal_nonneg alpha beta hAlpha hBeta value)]    _ = ∫ _value : ℝ, (1 : ℝ) ∂ProbabilityTheory.betaMeasure alpha beta := by      rw [ProbabilityTheory.betaMeasure]      exact (integral_withDensity_eq_integral_toReal_smul        (ProbabilityTheory.measurable_betaPDFReal alpha beta).ennreal_ofReal        (by simp) _).symm    _ = 1 := hOneprivate theorem integrable_id_betaMeasure {alpha beta : ℝ} (hAlpha : 0 < alpha)    (hBeta : 0 < beta) :    Integrable id (ProbabilityTheory.betaMeasure alpha beta) := by  rw [ProbabilityTheory.betaMeasure]  apply (integrable_withDensity_iff (μ := volume)    (ProbabilityTheory.measurable_betaPDFReal alpha beta).ennreal_ofReal    (by simp)).mpr  have hShift := (integrable_betaPDFReal (add_pos hAlpha zero_lt_one) hBeta).const_mul    (alpha / (alpha + beta))  apply hShift.congr  exact ae_of_all _ fun value ↦ by    simpa only [id_eq, ProbabilityTheory.betaPDF,      ENNReal.toReal_ofReal (betaPDFReal_nonneg alpha beta hAlpha hBeta value)] using      (beta_mul_pdf alpha beta hAlpha hBeta value).symmprivate theorem integral_betaMeasure {alpha beta : ℝ} (hAlpha : 0 < alpha)    (hBeta : 0 < beta) :    (∫ value : ℝ, value ∂ProbabilityTheory.betaMeasure alpha beta) =      alpha / (alpha + beta) := by  calc    (∫ value : ℝ, value ∂ProbabilityTheory.betaMeasure alpha beta) =        ∫ value : ℝ, (ProbabilityTheory.betaPDF alpha beta value).toReal • value := by          rw [ProbabilityTheory.betaMeasure]          exact integral_withDensity_eq_integral_toReal_smul            (ProbabilityTheory.measurable_betaPDFReal alpha beta).ennreal_ofReal            (by simp) _    _ = ∫ value : ℝ, (alpha / (alpha + beta)) *        ProbabilityTheory.betaPDFReal (alpha + 1) beta value := by          apply integral_congr_ae          exact ae_of_all _ fun value ↦ by            simpa only [smul_eq_mul, ProbabilityTheory.betaPDF, mul_comm,              ENNReal.toReal_ofReal (betaPDFReal_nonneg alpha beta hAlpha hBeta value)] using              beta_mul_pdf alpha beta hAlpha hBeta value    _ = alpha / (alpha + beta) := by      rw [integral_const_mul,        integral_betaPDFReal_eq_one (add_pos hAlpha zero_lt_one) hBeta, mul_one]private theorem integrable_id_paperMeasure_beta (params : Determinize.Spec.Paper.Params .beta)    (hDomain : Determinize.Spec.Paper.InDomain .beta params) :    Integrable id (Determinize.Spec.Paper.paperMeasure .beta params) := by  rcases hDomain with ⟨hAlpha, hBeta⟩  change Integrable id (if h : 0 < params.2 0 ∧    0 < params.2 1 then      ProbabilityTheory.betaMeasure (params.2 0)        (params.2 1) else 0)  rw [dite_eq_left ⟨hAlpha, hBeta⟩]  exact integrable_id_betaMeasure hAlpha hBetaprivate theorem integral_paperMeasure_beta (params : Determinize.Spec.Paper.Params .beta)    (hDomain : Determinize.Spec.Paper.InDomain .beta params) :    (∫ value : ℝ, value ∂Determinize.Spec.Paper.paperMeasure .beta params) =      Determinize.Spec.Paper.meanValue .beta params := by  rcases hDomain with ⟨hAlpha, hBeta⟩  change (∫ value : ℝ, value ∂if h : 0 < params.2 0 ∧    0 < params.2 1 then      ProbabilityTheory.betaMeasure (params.2 0)        (params.2 1) else 0) = _  rw [dite_eq_left ⟨hAlpha, hBeta⟩, integral_betaMeasure hAlpha hBeta]  rw [Determinize.Proof.Paper.meanValue_eq_affine]  unfold Determinize.Proof.Paper.meanConstant  have hSum : (∑ i : Fin (Determinize.Spec.Paper.affineArity .beta),      Determinize.Proof.Paper.meanCoeff .beta params.2 i * params.1 i) = 0 := by    apply Finset.sum_eq_zero    intro index _    exact Fin.elim0 index  rw [hSum, add_zero]private noncomputable def gaussianKernel :    ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params .gaussian) ℝ :=  ⟨Determinize.Spec.Paper.paperMeasure .gaussian, measurable_paperMeasure_gaussian⟩noncomputable def primitiveKernel :    (op : Determinize.Spec.Paper.Op) → ProbabilityTheory.Kernel (Determinize.Spec.Paper.Params op) ℝ  | .uniform => uniformKernel  | .gaussian => gaussianKernel  | .poisson => poissonKernel  | .exponential => exponentialKernel  | .beta => betaKernel  | .gamma => gammaKernel  | .bernoulli => ⟨Determinize.Spec.Paper.paperMeasure .bernoulli,      DiscreteLaws.measurable_bernoulliFiber (.sample .G) |>.comp        (show Measurable (fun params : Determinize.Spec.Paper.Params .bernoulli ↦          params.1 0) by fun_prop)⟩  | .discrete n => ⟨Determinize.Spec.Paper.paperMeasure (.discrete n), by      apply Measurable.ite (measurableSet_inDomain (.discrete n))      · apply Measurable.add        · exact Finset.measurable_sum _ fun i _ ↦            ((measurable_pi_apply i).comp measurable_fst).ennreal_ofReal.smul_measure _        · apply Measurable.smul_measure          apply Measurable.ennreal_ofReal          fun_prop      · exact measurable_const⟩theorem primitiveKernel_apply (op : Determinize.Spec.Paper.Op)    (params : Determinize.Spec.Paper.Params op) :    primitiveKernel op params = Determinize.Spec.Paper.paperMeasure op params := by  cases op with  | uniform => exact uniformKernel_apply params  | gaussian => rfl  | poisson => exact poissonKernel_apply params  | exponential => exact exponentialKernel_apply params  | beta => exact betaKernel_apply params  | gamma => exact gammaKernel_apply params  | bernoulli => rfl  | discrete _ => rfltheorem isFiniteKernel_primitiveKernel (op : Determinize.Spec.Paper.Op) :    ProbabilityTheory.IsFiniteKernel (primitiveKernel op) := by  constructor  exact ⟨1, ENNReal.one_lt_top, fun params ↦ by    rw [primitiveKernel_apply]    exact paperMeasure_univ_le_one op params⟩noncomputable def primitiveLaws : Determinize.Proof.Paper.PrimitiveLaws where  kernel := primitiveKernel  kernel_eq_paperMeasure := primitiveKernel_apply  kernel_sfinite := by    intro op    let : ProbabilityTheory.IsFiniteKernel (primitiveKernel op) :=      isFiniteKernel_primitiveKernel op    infer_instance  kernel_zero_off_domain := by    intro op params hDomain    rw [primitiveKernel_apply]    exact paperMeasure_eq_zero_of_not_inDomain op params hDomain  mass_one := by    intro op params hDomain    rw [primitiveKernel_apply]    exact paperMeasure_univ op params hDomain  integrable_id := by    intro op params hDomain    rw [primitiveKernel_apply]    cases op with    | uniform => exact integrable_id_paperMeasure_uniform params hDomain    | gaussian => exact integrable_id_paperMeasure_gaussian params hDomain    | poisson => exact integrable_id_paperMeasure_poisson params hDomain    | exponential => exact integrable_id_paperMeasure_exponential params hDomain    | beta => exact integrable_id_paperMeasure_beta params hDomain    | gamma => exact integrable_id_paperMeasure_gamma params hDomain    | bernoulli => exact DiscreteLaws.integrable_bernoulliFiber (.sample .G) (params.1 0) _    | discrete n =>      simp only [Determinize.Spec.Paper.InDomain] at hDomain      rw [Determinize.Spec.Paper.paperMeasure, ite_eq_left hDomain]      exact DiscreteLaws.integrable_remainderMeasure n params.1 (fun x ↦ x)  mean_law := by    intro op params hDomain    rw [primitiveKernel_apply]    cases op with    | uniform => exact integral_paperMeasure_uniform params hDomain    | gaussian => exact integral_paperMeasure_gaussian params hDomain    | poisson => exact integral_paperMeasure_poisson params hDomain    | exponential => exact integral_paperMeasure_exponential params hDomain    | beta => exact integral_paperMeasure_beta params hDomain    | gamma => exact integral_paperMeasure_gamma params hDomain    | bernoulli => exact DiscreteLaws.integral_id_bernoulliFiber (.sample .G) (params.1 0) hDomain    | discrete n =>      simp only [Determinize.Spec.Paper.InDomain] at hDomain      rw [Determinize.Spec.Paper.paperMeasure, ite_eq_left hDomain]      exact DiscreteLaws.integral_id_remainderMeasure n params.1 hDomainend Determinize.Proof.Paper