| import Mathlib | |
| import OAI.Probability.SKRatio.Matrices.StandardGaussianProduct | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory InformationTheory Real Set | |
| open scoped NNReal ENNReal | |
| open Filter | |
| open scoped Topology | |
| noncomputable section | |
| open Matrix Real | |
| open scoped BigOperators Matrix.Norms.Frobenius ENNReal NNReal | |
| noncomputable section | |
| open Matrix Real | |
| open scoped BigOperators Matrix.Norms.Frobenius NNReal | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Real Set Filter | |
| open MeasureTheory.Measure | |
| open scoped ENNReal NNReal MeasureTheory Topology | |
| open MeasureTheory | |
| noncomputable section | |
| noncomputable section | |
| open MeasureTheory Set NormedSpace | |
| open scoped Topology | |
| noncomputable section | |
| open Matrix Real | |
| open scoped BigOperators Matrix.Norms.Frobenius | |
| noncomputable section | |
| open Set Real | |
| open scoped Topology | |
| noncomputable section | |
| open Matrix Set Filter | |
| open scoped Topology Matrix.Norms.Frobenius | |
| noncomputable section | |
| open Matrix NormedSpace ContinuousLinearMap | |
| open scoped Matrix.Norms.Frobenius | |
| noncomputable section | |
| open Matrix | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Real Set | |
| open scoped ENNReal NNReal | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory InformationTheory Real Set | |
| open scoped NNReal ENNReal | |
| namespace SKRatioGaussian | |
| instance (n : ℕ) : IsProbabilityMeasure (standardGaussianProduct n) := by | |
| unfold standardGaussianProduct | |
| infer_instance | |
| variable {ι : Type*} [Fintype ι] [Nonempty ι] | |
| def expSum (κ : ℝ) (x : ι → ℝ) : ℝ := ∑ i, Real.exp (κ * x i) | |
| def softWeight (κ : ℝ) (x : ι → ℝ) (i : ι) : ℝ := Real.exp (κ * x i) / expSum κ x | |
| def smoothMax (κ : ℝ) (x : ι → ℝ) : ℝ := log (expSum κ x) / κ | |
| theorem expSum_pos (κ : ℝ) (x : ι → ℝ) : 0 < expSum κ x := by | |
| exact Finset.sum_pos (fun i _ => exp_pos _) Finset.univ_nonempty | |
| theorem softWeight_pos (κ : ℝ) (x : ι → ℝ) (i : ι) : 0 < softWeight κ x i := | |
| div_pos (exp_pos _) (expSum_pos κ x) | |
| theorem sum_softWeight (κ : ℝ) (x : ι → ℝ) : ∑ i, softWeight κ x i = 1 := by | |
| simp only [softWeight, ← Finset.sum_div] | |
| exact div_self (expSum_pos κ x).ne' | |
| theorem softWeight_le_one (κ : ℝ) (x : ι → ℝ) (i : ι) : softWeight κ x i ≤ 1 := by | |
| rw [← sum_softWeight κ x] | |
| exact Finset.single_le_sum (fun j _ => (softWeight_pos κ x j).le) (Finset.mem_univ i) | |
| theorem continuous_softWeight (κ : ℝ) (i : ι) : Continuous (fun x : ι → ℝ => softWeight κ x i) := by | |
| apply Continuous.div | |
| · exact continuous_exp.comp (continuous_const.mul (continuous_apply i)) | |
| · exact continuous_finsetSum _ (fun j _ => continuous_exp.comp (continuous_const.mul (continuous_apply j))) | |
| · exact fun x => (expSum_pos κ x).ne' | |
| theorem continuous_smoothMax (κ : ℝ) : Continuous (smoothMax κ : (ι → ℝ) → ℝ) := by | |
| apply Continuous.div_const | |
| exact (continuous_finsetSum _ (fun j _ => continuous_exp.comp (continuous_const.mul (continuous_apply j)))).log | |
| (fun x => (expSum_pos κ x).ne') | |
| omit [Nonempty ι] in | |
| theorem hasDerivAt_expSum {κ t : ℝ} {f : ι → ℝ → ℝ} {df : ι → ℝ} | |
| (hf : ∀ i, HasDerivAt (f i) (df i) t) : | |
| HasDerivAt (fun s => expSum κ (fun i => f i s)) | |
| (∑ i, Real.exp (κ * f i t) * (κ * df i)) t := by | |
| convert! HasDerivAt.fun_sum (fun i _ => ((hf i).const_mul κ).exp) using 1 | |
| theorem hasDerivAt_smoothMax {κ t : ℝ} (hκ : κ ≠ 0) {f : ι → ℝ → ℝ} {df : ι → ℝ} | |
| (hf : ∀ i, HasDerivAt (f i) (df i) t) : | |
| HasDerivAt (fun s => smoothMax κ (fun i => f i s)) | |
| (∑ i, softWeight κ (fun j => f j t) i * df i) t := by | |
| convert! ((hasDerivAt_expSum hf).log (expSum_pos κ (fun j => f j t)).ne').div_const κ using 1 | |
| simp only [softWeight] | |
| have hs : (∑ i, Real.exp (κ * f i t) * (κ * df i)) = | |
| κ * ∑ i, Real.exp (κ * f i t) * df i := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| rw [hs] | |
| simp_rw [div_mul_eq_mul_div, ← Finset.sum_div] | |
| field_simp [hκ, (expSum_pos κ (fun j => f j t)).ne'] | |
| theorem hasDerivAt_softWeight {κ t : ℝ} {f : ι → ℝ → ℝ} {df : ι → ℝ} | |
| (hf : ∀ i, HasDerivAt (f i) (df i) t) (i : ι) : | |
| HasDerivAt (fun s => softWeight κ (fun j => f j s) i) | |
| (κ * softWeight κ (fun j => f j t) i * | |
| (df i - ∑ j, softWeight κ (fun k => f k t) j * df j)) t := by | |
| convert! (((hf i).const_mul κ).exp).div (hasDerivAt_expSum hf) | |
| (expSum_pos κ (fun j => f j t)).ne' using 1 | |
| simp only [softWeight] | |
| have hs : (∑ j, Real.exp (κ * f j t) * (κ * df j)) = | |
| κ * ∑ j, Real.exp (κ * f j t) * df j := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| ring | |
| rw [hs] | |
| simp_rw [div_mul_eq_mul_div, ← Finset.sum_div] | |
| field_simp [(expSum_pos κ (fun j => f j t)).ne'] | |
| theorem weighted_abs_le (κ : ℝ) (x v : ι → ℝ) : | |
| |∑ i, softWeight κ x i * v i| ≤ ∑ i, |v i| := by | |
| calc | |
| _ ≤ ∑ i, |softWeight κ x i * v i| := Finset.abs_sum_le_sum_abs _ _ | |
| _ ≤ ∑ i, |v i| := by | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| rw [abs_mul, abs_of_pos (softWeight_pos κ x i)] | |
| exact mul_le_of_le_one_left (abs_nonneg _) (softWeight_le_one κ x i) | |
| omit [Nonempty ι] in | |
| theorem smoothMax_ge {κ : ℝ} (hκ : 0 < κ) (x : ι → ℝ) (i : ι) : | |
| x i ≤ smoothMax κ x := by | |
| rw [smoothMax, le_div_iff₀ hκ] | |
| calc | |
| x i * κ = log (Real.exp (κ * x i)) := by rw [log_exp]; ring | |
| _ ≤ log (expSum κ x) := log_le_log (exp_pos _) <| | |
| Finset.single_le_sum (fun j _ => (exp_pos (κ * x j)).le) (Finset.mem_univ i) | |
| theorem smoothMax_le {κ : ℝ} (hκ : 0 < κ) (x : ι → ℝ) {b : ℝ} | |
| (hb : ∀ i, x i ≤ b) : smoothMax κ x ≤ b + log (Fintype.card ι) / κ := by | |
| have hn : (0 : ℝ) < Fintype.card ι := Nat.cast_pos.mpr Fintype.card_pos | |
| rw [smoothMax, div_le_iff₀ hκ] | |
| calc | |
| log (expSum κ x) ≤ log ((Fintype.card ι : ℝ) * Real.exp (κ * b)) := by | |
| apply log_le_log (expSum_pos _ _) | |
| calc | |
| _ ≤ ∑ _ : ι, Real.exp (κ * b) := Finset.sum_le_sum (fun i _ => exp_le_exp.mpr (mul_le_mul_of_nonneg_left (hb i) hκ.le)) | |
| _ = _ := by simp | |
| _ = _ := by rw [log_mul hn.ne' (exp_pos _).ne', log_exp]; field_simp; ring | |
| variable {ι : Type*} [Fintype ι] [Nonempty ι] | |
| def affineProcess {n : ℕ} (m : ι → ℝ) (a : ι → Fin n → ℝ) (z : Fin n → ℝ) (i : ι) : ℝ := | |
| m i + ∑ k, a i k * z k | |
| omit [Fintype ι] [Nonempty ι] in | |
| theorem continuous_affineProcess {n : ℕ} (m : ι → ℝ) (a : ι → Fin n → ℝ) : | |
| Continuous (affineProcess m a) := by | |
| apply continuous_pi | |
| intro i | |
| exact continuous_const.add (continuous_finsetSum _ (fun k _ => continuous_const.mul (continuous_apply k))) | |
| omit [Fintype ι] [Nonempty ι] in | |
| theorem affineProcess_coordinate_hasDerivAt {n : ℕ} (m : ι → ℝ) | |
| (a : ι → Fin (n + 1) → ℝ) (i : ι) (k : Fin (n + 1)) (u : Fin n → ℝ) (z : ℝ) : | |
| HasDerivAt (fun z => affineProcess m a (k.insertNth z u) i) (a i k) z := by | |
| have he (z : ℝ) : affineProcess m a (k.insertNth z u) i = | |
| a i k * z + (m i + ∑ l, a i (k.succAbove l) * u l) := by | |
| rw [affineProcess, Fin.sum_univ_succAbove _ k] | |
| simp only [Fin.insertNth_apply_same, Fin.insertNth_apply_succAbove] | |
| ring | |
| simp_rw [he] | |
| convert! ((hasDerivAt_id z).const_mul (a i k)).add_const (m i + ∑ l, a i (k.succAbove l) * u l) using 1 | |
| simp | |
| theorem affine_softWeight_coordinate_IBP {n : ℕ} (κ : ℝ) (m : ι → ℝ) | |
| (a : ι → Fin (n + 1) → ℝ) (i : ι) (k : Fin (n + 1)) : | |
| (∫ z, z k * softWeight κ (affineProcess m a z) i ∂standardGaussianProduct (n + 1)) = | |
| ∫ z, κ * softWeight κ (affineProcess m a z) i * | |
| (a i k - ∑ j, softWeight κ (affineProcess m a z) j * a j k) | |
| ∂standardGaussianProduct (n + 1) := by | |
| apply gaussianProduct_coordinate_IBP (C := 1) (D := |κ| * (|a i k| + ∑ j, |a j k|)) k | |
| · exact (continuous_softWeight κ i).comp (continuous_affineProcess m a) | |
| · exact (continuous_const.mul ((continuous_softWeight κ i).comp (continuous_affineProcess m a))).mul | |
| (continuous_const.sub (continuous_finsetSum _ (fun j _ => | |
| ((continuous_softWeight κ j).comp (continuous_affineProcess m a)).mul continuous_const))) | |
| · intro z | |
| rw [Real.norm_eq_abs, abs_of_pos (softWeight_pos _ _ _)] | |
| exact softWeight_le_one _ _ _ | |
| · intro z | |
| rw [norm_mul, norm_mul, Real.norm_eq_abs κ, | |
| Real.norm_eq_abs (softWeight _ _ _), abs_of_pos (softWeight_pos _ _ _), Real.norm_eq_abs] | |
| apply mul_le_mul | |
| · exact mul_le_of_le_one_right (abs_nonneg κ) (softWeight_le_one _ _ _) | |
| · exact (abs_sub _ _).trans (add_le_add_right (weighted_abs_le κ _ (fun j => a j k)) _) | |
| · positivity | |
| · positivity | |
| · intro u z | |
| exact hasDerivAt_softWeight (fun j => affineProcess_coordinate_hasDerivAt m a j k u z) i | |
| omit [Nonempty ι] in | |
| theorem weighted_covariance_identity (p u v : ι → ℝ) (hp : ∑ i, p i = 1) : | |
| (∑ i, p i * u i * v i) - (∑ i, p i * u i) * (∑ i, p i * v i) = | |
| (1 / 2 : ℝ) * ∑ i, ∑ j, p i * p j * (u i - u j) * (v i - v j) := by | |
| have he (i j : ι) : p i * p j * (u i - u j) * (v i - v j) = | |
| (p i * u i * v i) * p j + p i * (p j * u j * v j) - | |
| (p i * u i) * (p j * v j) - (p i * v i) * (p j * u j) := by ring | |
| simp_rw [he, Finset.sum_sub_distrib, Finset.sum_add_distrib, | |
| ← Finset.mul_sum, ← Finset.sum_mul] | |
| rw [hp] | |
| ring | |
| theorem smoothMax_norm_le {κ : ℝ} (hκ : 0 < κ) (x : ι → ℝ) : | |
| ‖smoothMax κ x‖ ≤ ∑ i, |x i| + log (Fintype.card ι) / κ := by | |
| have hn : (1 : ℝ) ≤ Fintype.card ι := by exact_mod_cast Fintype.card_pos | |
| have hlog : 0 ≤ log (Fintype.card ι) / κ := div_nonneg (log_nonneg hn) hκ.le | |
| have hb (i : ι) : |x i| ≤ ∑ j, |x j| := | |
| Finset.single_le_sum (fun j _ => abs_nonneg (x j)) (Finset.mem_univ i) | |
| rw [Real.norm_eq_abs] | |
| apply abs_le.mpr | |
| constructor | |
| · let i : ι := Classical.choice inferInstance | |
| have hlo := smoothMax_ge hκ x i | |
| have ha := (abs_le.mp (hb i)).1 | |
| linarith | |
| · exact smoothMax_le hκ x (fun i => (le_abs_self _).trans (hb i)) | |
| def interpolatedCoeff {n : ℕ} (a b : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : ℝ := | |
| sin t * a i k + cos t * b i k | |
| def interpolatedCoeffDeriv {n : ℕ} (a b : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : ℝ := | |
| cos t * a i k - sin t * b i k | |
| def processBound {n : ℕ} (a b : ι → Fin n → ℝ) (z : Fin n → ℝ) : ℝ := | |
| ∑ i, ∑ k, (|a i k| + |b i k|) * |z k| | |
| omit [Fintype ι] [Nonempty ι] in | |
| theorem interpolatedCoeff_abs_le {n : ℕ} (a b : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : | |
| |interpolatedCoeff a b t i k| ≤ |a i k| + |b i k| := by | |
| calc | |
| _ ≤ |sin t * a i k| + |cos t * b i k| := abs_add_le _ _ | |
| _ ≤ 1 * |a i k| + 1 * |b i k| := by | |
| simp only [abs_mul] | |
| gcongr | |
| · exact abs_sin_le_one t | |
| · exact abs_cos_le_one t | |
| _ = _ := by ring | |
| omit [Fintype ι] [Nonempty ι] in | |
| theorem interpolatedCoeffDeriv_abs_le {n : ℕ} (a b : ι → Fin n → ℝ) (t : ℝ) (i : ι) (k : Fin n) : | |
| |interpolatedCoeffDeriv a b t i k| ≤ |a i k| + |b i k| := by | |
| calc | |
| _ ≤ |cos t * a i k| + |sin t * b i k| := abs_sub _ _ | |
| _ ≤ 1 * |a i k| + 1 * |b i k| := by | |
| simp only [abs_mul] | |
| gcongr | |
| · exact abs_cos_le_one t | |
| · exact abs_sin_le_one t | |
| _ = _ := by ring | |
| omit [Nonempty ι] in | |
| theorem integrable_processBound {n : ℕ} (a b : ι → Fin n → ℝ) : | |
| Integrable (processBound a b) (standardGaussianProduct n) := by | |
| apply integrable_finsetSum | |
| intro i _ | |
| apply integrable_finsetSum | |
| intro k _ | |
| exact ((integrable_eval (i := k) IsGaussian.integrable_id).norm).const_mul _ | |
| omit [Fintype ι] [Nonempty ι] in | |
| theorem interpolated_affine_hasDerivAt {n : ℕ} (m : ι → ℝ) (a b : ι → Fin n → ℝ) | |
| (z : Fin n → ℝ) (t : ℝ) (i : ι) : | |
| HasDerivAt (fun t => affineProcess m (interpolatedCoeff a b t) z i) | |
| (∑ k, interpolatedCoeffDeriv a b t i k * z k) t := by | |
| convert! (HasDerivAt.fun_sum (fun k _ => | |
| (((Real.hasDerivAt_sin t).mul_const (a i k)).add | |
| ((Real.hasDerivAt_cos t).mul_const (b i k))).mul_const (z k))).const_add (m i) using 1 | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| dsimp [interpolatedCoeffDeriv] | |
| ring | |
| def interpolationDerivative {n : ℕ} (κ : ℝ) (m : ι → ℝ) (a b : ι → Fin n → ℝ) | |
| (t : ℝ) (z : Fin n → ℝ) : ℝ := | |
| ∑ i, softWeight κ (affineProcess m (interpolatedCoeff a b t) z) i * | |
| ∑ k, interpolatedCoeffDeriv a b t i k * z k | |
| theorem interpolationDerivative_norm_le {n : ℕ} (κ : ℝ) (m : ι → ℝ) | |
| (a b : ι → Fin n → ℝ) (t : ℝ) (z : Fin n → ℝ) : | |
| ‖interpolationDerivative κ m a b t z‖ ≤ processBound a b z := by | |
| rw [Real.norm_eq_abs] | |
| calc | |
| _ ≤ ∑ i, |∑ k, interpolatedCoeffDeriv a b t i k * z k| := weighted_abs_le _ _ _ | |
| _ ≤ ∑ i, ∑ k, (|a i k| + |b i k|) * |z k| := by | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| apply (Finset.abs_sum_le_sum_abs _ _).trans | |
| apply Finset.sum_le_sum | |
| intro k _ | |
| rw [abs_mul] | |
| exact mul_le_mul_of_nonneg_right (interpolatedCoeffDeriv_abs_le a b t i k) (abs_nonneg _) | |
| theorem interpolated_smoothMax_norm_le {n : ℕ} {κ : ℝ} (hκ : 0 < κ) (m : ι → ℝ) | |
| (a b : ι → Fin n → ℝ) (t : ℝ) (z : Fin n → ℝ) : | |
| ‖smoothMax κ (affineProcess m (interpolatedCoeff a b t) z)‖ ≤ | |
| (∑ i, |m i|) + processBound a b z + log (Fintype.card ι) / κ := by | |
| apply (smoothMax_norm_le hκ _).trans | |
| gcongr | |
| rw [processBound, ← Finset.sum_add_distrib] | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| apply (abs_add_le _ _).trans | |
| gcongr | |
| apply (Finset.abs_sum_le_sum_abs _ _).trans | |
| apply Finset.sum_le_sum | |
| intro k _ | |
| rw [abs_mul] | |
| exact mul_le_mul_of_nonneg_right (interpolatedCoeff_abs_le a b t i k) (abs_nonneg _) | |
| theorem interpolation_hasDerivAt {n : ℕ} {κ : ℝ} (hκ : 0 < κ) | |
| (m : ι → ℝ) (a b : ι → Fin n → ℝ) (t : ℝ) : | |
| HasDerivAt (fun t => ∫ z, smoothMax κ (affineProcess m (interpolatedCoeff a b t) z) | |
| ∂standardGaussianProduct n) | |
| (∫ z, interpolationDerivative κ m a b t z ∂standardGaussianProduct n) t := by | |
| have hp (t : ℝ) (i : ι) : | |
| Continuous (fun z => softWeight κ (affineProcess m (interpolatedCoeff a b t) z) i) := | |
| (continuous_softWeight κ i).comp (continuous_affineProcess m _) | |
| have hf (t : ℝ) : Continuous (fun z => smoothMax κ (affineProcess m (interpolatedCoeff a b t) z)) := | |
| (continuous_smoothMax κ).comp (continuous_affineProcess m _) | |
| have hdf (t : ℝ) : Continuous (interpolationDerivative κ m a b t) := by | |
| apply continuous_finsetSum | |
| intro i _ | |
| exact (hp t i).mul (continuous_finsetSum _ (fun k _ => continuous_const.mul (continuous_apply k))) | |
| have hb : Integrable (fun z => (∑ i, |m i|) + processBound a b z + log (Fintype.card ι) / κ) | |
| (standardGaussianProduct n) := | |
| ((integrable_const _).add (integrable_processBound a b)).add (integrable_const _) | |
| exact (hasDerivAt_integral_of_dominated_loc_of_deriv_le | |
| (μ := standardGaussianProduct n) (s := univ) (x₀ := t) | |
| (F := fun t z => smoothMax κ (affineProcess m (interpolatedCoeff a b t) z)) | |
| (F' := fun t z => interpolationDerivative κ m a b t z) | |
| (bound := processBound a b) | |
| Filter.univ_mem (Filter.Eventually.of_forall (fun t => (hf t).aestronglyMeasurable)) | |
| (hb.mono' (hf t).aestronglyMeasurable (ae_of_all _ (interpolated_smoothMax_norm_le hκ m a b t))) | |
| (hdf t).aestronglyMeasurable | |
| (ae_of_all _ (fun z t _ => interpolationDerivative_norm_le κ m a b t z)) | |
| (integrable_processBound a b) | |
| (ae_of_all _ (fun z t _ => hasDerivAt_smoothMax hκ.ne' | |
| (fun i => interpolated_affine_hasDerivAt m a b z t i)))).2 | |
| theorem integrable_affine_weight {n : ℕ} (κ : ℝ) (m : ι → ℝ) (a : ι → Fin n → ℝ) (i : ι) : | |
| Integrable (fun z => softWeight κ (affineProcess m a z) i) (standardGaussianProduct n) := by | |
| apply Integrable.of_bound ((continuous_softWeight κ i).comp (continuous_affineProcess m a)).aestronglyMeasurable 1 | |
| exact ae_of_all _ (fun z => by | |
| simp only [Function.comp_def] | |
| rw [Real.norm_eq_abs, abs_of_pos (softWeight_pos _ _ _)] | |
| exact softWeight_le_one _ _ _) | |
| theorem integrable_coordinate_weight {n : ℕ} (κ : ℝ) (m : ι → ℝ) | |
| (a : ι → Fin n → ℝ) (i : ι) (k : Fin n) : | |
| Integrable (fun z => z k * softWeight κ (affineProcess m a z) i) (standardGaussianProduct n) := by | |
| apply Integrable.mul_bdd (integrable_eval (i := k) IsGaussian.integrable_id) | |
| ((continuous_softWeight κ i).comp (continuous_affineProcess m a)).aestronglyMeasurable | |
| exact ae_of_all _ (fun z => by | |
| simp only [Function.comp_def] | |
| rw [Real.norm_eq_abs, abs_of_pos (softWeight_pos _ _ _)] | |
| exact softWeight_le_one _ _ _) | |
| theorem integrable_weight_covariance {n : ℕ} (κ : ℝ) (m : ι → ℝ) | |
| (a : ι → Fin n → ℝ) (i : ι) (k : Fin n) : | |
| Integrable (fun z => κ * softWeight κ (affineProcess m a z) i * | |
| (a i k - ∑ j, softWeight κ (affineProcess m a z) j * a j k)) | |
| (standardGaussianProduct n) := by | |
| have hi : Integrable (fun z => a i k - ∑ j, softWeight κ (affineProcess m a z) j * a j k) | |
| (standardGaussianProduct n) := by | |
| apply (integrable_const _).sub | |
| exact integrable_finsetSum _ (fun j _ => (integrable_affine_weight κ m a j).mul_const _) | |
| have hm := hi.bdd_mul ((continuous_softWeight κ i).comp (continuous_affineProcess m a)).aestronglyMeasurable | |
| (ae_of_all _ (fun z => by | |
| simp only [Function.comp_def] | |
| rw [Real.norm_eq_abs, abs_of_pos (softWeight_pos κ (affineProcess m a z) i)] | |
| exact softWeight_le_one _ _ _)) | |
| convert! hm.const_mul κ using 1 | |
| ext z | |
| simp only [Function.comp_def] | |
| ring | |
| omit [Nonempty ι] in | |
| theorem weighted_matrix_covariance_identity {n : ℕ} (p : ι → ℝ) (a d : ι → Fin n → ℝ) | |
| (hp : ∑ i, p i = 1) : | |
| (∑ i, ∑ k, d i k * p i * (a i k - ∑ j, p j * a j k)) = | |
| (1 / 2 : ℝ) * ∑ i, ∑ j, p i * p j * ∑ k, (d i k - d j k) * (a i k - a j k) := by | |
| have hk (k : Fin n) : | |
| (∑ i, d i k * p i * (a i k - ∑ j, p j * a j k)) = | |
| (1/2:ℝ) * ∑ i, ∑ j, p i * p j * (d i k - d j k) * (a i k - a j k) := by | |
| rw [← weighted_covariance_identity p (fun i => d i k) (fun i => a i k) hp] | |
| simp_rw [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul] | |
| congr 1 | |
| · apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| · congr 1 | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| rw [Finset.sum_comm] | |
| simp_rw [hk, ← Finset.mul_sum] | |
| congr 1 | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| ring | |
| theorem gaussian_linear_weight_IBP {n : ℕ} (κ : ℝ) (m : ι → ℝ) | |
| (a d : ι → Fin (n + 1) → ℝ) : | |
| (∫ z, ∑ i, softWeight κ (affineProcess m a z) i * ∑ k, d i k * z k | |
| ∂standardGaussianProduct (n + 1)) = | |
| (κ / 2) * ∫ z, ∑ i, ∑ j, | |
| softWeight κ (affineProcess m a z) i * softWeight κ (affineProcess m a z) j * | |
| ∑ k, (d i k - d j k) * (a i k - a j k) | |
| ∂standardGaussianProduct (n + 1) := by | |
| let p := fun z i => softWeight κ (affineProcess m a z) i | |
| have hi (i : ι) (k : Fin (n + 1)) : Integrable (fun z => d i k * (z k * p z i)) | |
| (standardGaussianProduct (n + 1)) := (integrable_coordinate_weight κ m a i k).const_mul _ | |
| have hr (i : ι) (k : Fin (n + 1)) : Integrable (fun z => d i k * | |
| (κ * p z i * (a i k - ∑ j, p z j * a j k))) (standardGaussianProduct (n + 1)) := | |
| (integrable_weight_covariance κ m a i k).const_mul _ | |
| calc | |
| _ = ∫ z, ∑ i, ∑ k, d i k * (z k * p z i) ∂standardGaussianProduct (n + 1) := by | |
| apply integral_congr_ae | |
| filter_upwards [] with z | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| dsimp [p] | |
| ring | |
| _ = ∑ i, ∑ k, d i k * ∫ z, z k * p z i ∂standardGaussianProduct (n + 1) := by | |
| rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun k _ => hi i k))] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [integral_finsetSum _ (fun k _ => hi i k)] | |
| simp only [integral_const_mul] | |
| _ = ∑ i, ∑ k, d i k * ∫ z, κ * p z i * (a i k - ∑ j, p z j * a j k) | |
| ∂standardGaussianProduct (n + 1) := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| rw [affine_softWeight_coordinate_IBP] | |
| _ = ∫ z, ∑ i, ∑ k, d i k * (κ * p z i * (a i k - ∑ j, p z j * a j k)) | |
| ∂standardGaussianProduct (n + 1) := by | |
| rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun k _ => hr i k))] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [integral_finsetSum _ (fun k _ => hr i k)] | |
| simp only [integral_const_mul] | |
| _ = _ := by | |
| rw [← integral_const_mul] | |
| apply integral_congr_ae | |
| filter_upwards [] with z | |
| have he := weighted_matrix_covariance_identity (p z) a d (sum_softWeight κ _) | |
| calc | |
| _ = κ * ∑ i, ∑ k, d i k * p z i * (a i k - ∑ j, p z j * a j k) := by | |
| simp only [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| ring | |
| _ = _ := by rw [he]; dsimp [p]; ring | |
| end SKRatioGaussian | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end OAI | |