Source lean/Determinize/Proof/Primitives/Laws.lean
import Determinize.Spec.Semanticsimport Mathlib.Probability.Kernel.Basic/-!# Analytic laws of the paper primitivesThe proof indexes the primitives uniformly by `Op` and parameter tables; thereviewer-facing per-primitive fibers of `Spec/Primitives.lean` are recovered fromthese tables. The second part records the analytic facts required of the canonicalprimitive measures.-/namespace Determinize.Spec.Paperopen MeasureTheory ProbabilityTheorynoncomputable section/-! The proof indexes the primitives uniformly by `Op`: an affine parameter positionis one in which the primitive's mean is affine (and which may therefore be typed at affinity E),a general position must be typed at affinity G. The reviewer-facing fibers in`Spec/Primitives.lean` are recovered from these tables below. -/abbrev affineArity : Op → Nat  | .uniform => 2  | .gaussian => 1  | .poisson => 1  | .exponential => 0  | .beta => 0  | .gamma => 1  | .bernoulli => 1  | .discrete n => nabbrev generalArity : Op → Nat  | .uniform => 0  | .gaussian => 1  | .poisson => 0  | .exponential => 1  | .beta => 2  | .gamma => 1  | .bernoulli => 0  | .discrete _ => 0/-- Evaluated parameters, indexed by the primitive's two arities. -/abbrev Params (op : Op) :=  (Fin (affineArity op) → ℝ) × (Fin (generalArity op) → ℝ)/-- Parse evaluated operand lists into the primitive's arity-indexed parameters. -/def parseParams (op : Op) (affine general : List ℝ) : Option (Params op) :=  if ha : affine.length = affineArity op then    if hg : general.length = generalArity op then      some        (fun i ↦ affine[i.1]'(ha.symm ▸ i.2),         fun i ↦ general[i.1]'(hg.symm ▸ i.2))    else none  else nonedef InDomain : (op : Op) → Params op → Prop  | .uniform, (a, _) => a 0 ≤ a 1  | .gaussian, (_, g) => 0 ≤ g 0  | .poisson, (a, _) => 0 ≤ a 0  | .exponential, (_, g) => 0 < g 0  | .beta, (_, g) => 0 < g 0 ∧ 0 < g 1  | .gamma, (a, g) => 0 < a 0 ∧ 0 < g 0  | .bernoulli, (a, _) => 0 ≤ a 0 ∧ a 0 ≤ 1  | .discrete _, (a, _) => (∀ i, 0 ≤ a i) ∧ ∑ i, a i ≤ 1/-- The primitive means on evaluated parameters. -/def meanValue : (op : Op) → Params op → ℝ  | .uniform, (a, _) => (a 0 + a 1) / 2  | .gaussian, (a, _) => a 0  | .poisson, (a, _) => a 0  | .exponential, (_, g) => 1 / g 0  | .beta, (_, g) => g 0 / (g 0 + g 1)  | .gamma, (a, g) => a 0 / g 0  | .bernoulli, (a, _) => a 0  | .discrete n, (a, _) => (n : ℝ) + ∑ i : Fin n, (((i : ℕ) : ℝ) - n) * a i/-- Canonical primitive measure; an off-domain call has zero measure. -/def paperMeasure : (op : Op) → Params op → Measure ℝ  | .uniform, params =>    uniformMeasure (params.1 0) (params.1 1)  | .gaussian, params =>    let mean := params.1 0    let variance := params.2 0    if h : 0 ≤ variance then gaussianReal mean ⟨variance, h⟩ else 0  | .poisson, params =>    let rate := params.1 0    if h : 0 ≤ rate then      (poissonMeasure ⟨rate, h⟩).map (fun value : Nat ↦ (value : ℝ))    else 0  | .exponential, params =>    let rate := params.2 0    if 0 < rate then expMeasure rate else 0  | .beta, params =>    let alpha := params.2 0    let betaParam := params.2 1    if 0 < alpha ∧ 0 < betaParam then betaMeasure alpha betaParam else 0  | .gamma, params =>    let shape := params.1 0    let rate := params.2 0    if 0 < shape ∧ 0 < rate then gammaMeasure shape rate else 0  | .bernoulli, params => bernoulliFiber (.sample .G) (params.1 0)  | .discrete n, params =>    if (∀ i, 0 ≤ params.1 i) ∧ ∑ i, params.1 i ≤ 1 then      (∑ i : Fin n, ENNReal.ofReal (params.1 i) • Measure.dirac ((i : ℕ) : ℝ)) +        ENNReal.ofReal (1 - ∑ i, params.1 i) • Measure.dirac (n : ℝ)    else 0open scoped Classical in/-- The stochastic or mean fiber of a primitive at evaluated operand lists. -/def primitiveFiber (kind : DistributionAction) (op : Op) (affine general : List ℝ) : Measure ℝ :=  match parseParams op affine general with  | none => 0  | some params =>    match kind with    | .sample _ => paperMeasure op params    | .mean => if InDomain op params then Measure.dirac (meanValue op params) else 0/-! The reviewer-facing fibers are the generic one at the primitive's operand lists. -/theorem uniformFiber_eq (kind : DistributionAction) (lower upper : ℝ) :    uniformFiber kind lower upper = primitiveFiber kind .uniform [lower, upper] [] := by  cases kind <;> by_cases h : lower ≤ upper <;>    simp [uniformFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue,      uniformMeasure, h]theorem gaussianFiber_eq (kind : DistributionAction) (mean variance : ℝ) :    gaussianFiber kind mean variance = primitiveFiber kind .gaussian [mean] [variance] := by  cases kind <;> by_cases h : 0 ≤ variance <;>    simp [gaussianFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem poissonFiber_eq (kind : DistributionAction) (rate : ℝ) :    poissonFiber kind rate = primitiveFiber kind .poisson [rate] [] := by  cases kind <;> by_cases h : 0 ≤ rate <;>    simp [poissonFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem exponentialFiber_eq (kind : DistributionAction) (rate : ℝ) :    exponentialFiber kind rate = primitiveFiber kind .exponential [] [rate] := by  cases kind <;> by_cases h : 0 < rate <;>    simp [exponentialFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem betaFiber_eq (kind : DistributionAction) (alpha beta : ℝ) :    betaFiber kind alpha beta = primitiveFiber kind .beta [] [alpha, beta] := by  cases kind <;> by_cases h : 0 < alpha ∧ 0 < beta <;>    simp [betaFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem gammaFiber_eq (kind : DistributionAction) (shape rate : ℝ) :    gammaFiber kind shape rate = primitiveFiber kind .gamma [shape] [rate] := by  cases kind <;> by_cases h : 0 < shape ∧ 0 < rate <;>    simp [gammaFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem bernoulliFiber_eq (kind : DistributionAction) (p : ℝ) :    bernoulliFiber kind p = primitiveFiber kind .bernoulli [p] [] := by  cases kind <;> by_cases h : 0 ≤ p ∧ p ≤ 1 <;>    simp [bernoulliFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue, h]theorem discreteFiber_eq (kind : DistributionAction) (probabilities : List ℝ) :    discreteFiber kind probabilities =      primitiveFiber kind (.discrete probabilities.length) probabilities [] := by  cases kind <;>    simp [discreteFiber, primitiveFiber, parseParams, paperMeasure, InDomain, meanValue]endend Determinize.Spec.Papernamespace Determinize.Proof.Paperopen MeasureTheory ProbabilityTheoryopen Determinize.Spec.Papernoncomputable section/-- The part of a primitive mean independent of affine-position parameters. -/def meanConstant : (op : Op) → (Fin (generalArity op) → ℝ) → ℝ  | .uniform, _ => 0  | .gaussian, _ => 0  | .poisson, _ => 0  | .exponential, general => 1 / general      0  | .beta, general =>    general 0 /      (general 0 +        general 1)  | .gamma, _ => 0  | .bernoulli, _ => 0  | .discrete n, _ => (n : ℝ)/-- Coefficient of an affine-position parameter in a primitive mean. -/def meanCoeff : (op : Op) →    (Fin (generalArity op) → ℝ) → Fin (affineArity op) → ℝ  | .uniform, _, _ => 1 / 2  | .gaussian, _, _ => 1  | .poisson, _, _ => 1  | .exponential, _, index => Fin.elim0 index  | .beta, _, index => Fin.elim0 index  | .gamma, general, _ => 1 / general      0  | .bernoulli, _, _ => 1  | .discrete n, _, index => ((index : ℕ) : ℝ) - ntheorem meanValue_eq_affine (op : Op) (params : Params op) :    meanValue op params = meanConstant op params.2 +      ∑ i, meanCoeff op params.2 i * params.1 i := by  cases op <;> simp [meanValue, meanConstant, meanCoeff, affineArity,    Fin.sum_univ_two] <;> ringtheorem measurableSet_inDomain (op : Op) :    MeasurableSet {params | InDomain op params} := by  cases op  · change MeasurableSet {params : Params .uniform | params.1 0 ≤ params.1 1}    apply measurableSet_le <;> fun_prop  · change MeasurableSet {params : Params .gaussian | 0 ≤ params.2 0}    apply measurableSet_le <;> fun_prop  · change MeasurableSet {params : Params .poisson | 0 ≤ params.1 0}    apply measurableSet_le <;> fun_prop  · change MeasurableSet {params : Params .exponential | 0 < params.2 0}    apply measurableSet_lt <;> fun_prop  · exact MeasurableSet.inter      ((show Measurable (fun params : Params .beta ↦ params.2 0) by fun_prop)        measurableSet_Ioi)      ((show Measurable (fun params : Params .beta ↦ params.2 1) by fun_prop)        measurableSet_Ioi)  · exact MeasurableSet.inter      ((show Measurable (fun params : Params .gamma ↦ params.1 0) by fun_prop)        measurableSet_Ioi)      ((show Measurable (fun params : Params .gamma ↦ params.2 0) by fun_prop)        measurableSet_Ioi)  · change MeasurableSet {params : Params .bernoulli | 0 ≤ params.1 0 ∧ params.1 0 ≤ 1}    have hp : Measurable (fun params : Params .bernoulli ↦ params.1 0) := by fun_prop    exact (measurableSet_le measurable_const hp).inter      (measurableSet_le hp measurable_const)  · rename_i n    change MeasurableSet {params : Params (.discrete n) |      (∀ i, 0 ≤ params.1 i) ∧ ∑ i, params.1 i ≤ 1}    have nonnegative : MeasurableSet {params : Params (.discrete n) | ∀ i, 0 ≤ params.1 i} := by      rw [Set.ofPred_forall]      exact MeasurableSet.iInter fun i ↦ measurableSet_le measurable_const (by fun_prop)    have bounded : MeasurableSet {params : Params (.discrete n) | ∑ i, params.1 i ≤ 1} :=      measurableSet_le (by fun_prop) measurable_const    exact nonnegative.inter bounded/-- Analytic facts about the canonical primitive measures used by the soundness proof. -/structure PrimitiveLaws where  kernel : (op : Op) → Kernel (Params op) ℝ  kernel_eq_paperMeasure : ∀ op params, kernel op params = paperMeasure op params  kernel_sfinite : ∀ op, IsSFiniteKernel (kernel op)  kernel_zero_off_domain : ∀ op params, ¬ InDomain op params → kernel op params = 0  mass_one : ∀ op params, InDomain op params → kernel op params Set.univ = 1  integrable_id : ∀ op params, InDomain op params →    Integrable (fun value : ℝ ↦ value) (kernel op params)  mean_law : ∀ op params, InDomain op params →    (∫ value : ℝ, value ∂kernel op params) = meanValue op paramsendend Determinize.Proof.Paper