| import Mathlib |
| import OAI.Analysis.CoulombIonization.Localization.QuantumRawLaw |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CoulombObservation |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| section Work_ObservationSmooth_scope |
|
|
| open MeasureTheory Set |
| open scoped ContDiff |
|
|
| lemma compactNoiseWeight_eq_glue (u : ℝ) : |
| compactNoiseWeight u = expNegInvGlue (1-u^2) := by |
| have hh : |u| < 1 ↔ ¬ 1-u^2 ≤ 0 := by |
| rw [not_le, sub_pos, sq_lt_one_iff_abs_lt_one] |
| simp only [compactNoiseWeight, expNegInvGlue, hh] |
| split_ifs < |
|
|
| lemma compactNoiseWeight_contDiff {n : ℕ∞} : ContDiff ℝ n compactNoiseWeight := by |
| simp_rw [funext compactNoiseWeight_eq_glue] |
| exact expNegInvGlue.contDiff.comp (contDiff_const.sub (contDiff_id.pow 2)) |
|
|
| lemma compactNoiseDensity_contDiff {n : ℕ∞} : ContDiff ℝ n compactNoiseDensity := |
| contDiff_const.mul compactNoiseWeight_contDiff |
|
|
| lemma compactNoiseWeight_hasDerivAt (u : ℝ) : |
| HasDerivAt compactNoiseWeight (compactNoiseScore u * compactNoiseWeight u) u := by |
| have hc : HasDerivAt expNegInvGlue ((1-u^2)⁻¹^2 * expNegInvGlue (1-u^2)) (1-u^2) := by |
| simpa using expNegInvGlue.hasDerivAt_polynomial_eval_inv_mul 1 (1-u^2) |
| have hh := hc.comp u ((hasDerivAt_const u 1).sub ((hasDerivAt_id u).pow 2)) |
| simp only [Nat.cast_ofNat, mul_one, zero_sub, id_eq, Nat.reduceSub, pow_one] at hh |
| have he : ((((1-u^2)⁻¹^2 * expNegInvGlue (1-u^2)) * -(2*u))) = |
| compactNoiseScore u * compactNoiseWeight u := by |
| rw [← compactNoiseWeight_eq_glue] |
| by_cases hu : |u| < 1 |
| · simp only [compactNoiseScore, ite_eq_left hu, div_eq_mul_inv, inv_pow] |
| · simp [compactNoiseScore, compactNoiseWeight, hu] |
| rw [he] at hh |
| simpa only [Function.comp_def, Pi.sub_apply, Pi.pow_apply, id_eq, ← compactNoiseWeight_eq_glue] using hh |
|
|
| lemma compactNoiseDensity_hasDerivAt (u : ℝ) : |
| HasDerivAt compactNoiseDensity (compactNoiseScore u * compactNoiseDensity u) u := by |
| convert! (compactNoiseWeight_hasDerivAt u).const_mul compactNoiseNormalizer using 1 |
| dsimp [compactNoiseDensity] |
| ring |
|
|
| lemma compactNoiseWeight_compactSupport : HasCompactSupport compactNoiseWeight := by |
| apply HasCompactSupport.intro (isCompact_Icc : IsCompact (Icc (-1:ℝ) 1)) |
| intro u hu |
| have hh : ¬ |u| < 1 := by |
| intro h |
| apply hu |
| exact ⟨(abs_lt.mp h).1.le, (abs_lt.mp h).2.le⟩ |
| simp [compactNoiseWeight, hh] |
|
|
| lemma compactNoiseDensity_compactSupport : HasCompactSupport compactNoiseDensity := |
| compactNoiseWeight_compactSupport.mul_left |
| |
| end Work_ObservationSmooth_scope |
|
|
| open MeasureTheory Set Finset |
| open scoped ENNReal NNReal BigOperators ContDiff |
|
|
| def compactNoiseKernel {ι : Type*} [Fintype ι] (u : ι → ℝ) : ℝ := |
| ∏ i, compactNoiseDensity (u i) |
|
|
| lemma compactNoiseKernel_nonneg {ι : Type*} [Fintype ι] (u : ι → ℝ) : |
| 0 ≤ compactNoiseKernel u := prod_nonneg (fun _ _ => compactNoiseDensity_nonneg _) |
|
|
| lemma compactNoiseKernel_even {ι : Type*} [Fintype ι] (u : ι → ℝ) : |
| compactNoiseKernel (-u) = compactNoiseKernel u := by |
| simp only [compactNoiseKernel, Pi.neg_apply, compactNoiseDensity, compactNoiseWeight_even] |
|
|
| lemma compactNoiseKernel_contDiff {ι : Type*} [Fintype ι] {n : ℕ∞} : |
| ContDiff ℝ n (compactNoiseKernel : (ι → ℝ) → ℝ) := by |
| exact contDiff_prod (fun i _ => compactNoiseDensity_contDiff.comp (contDiff_apply ℝ ℝ i)) |
|
|
| lemma compactNoiseKernel_integrable {ι : Type*} [Fintype ι] : |
| Integrable (compactNoiseKernel : (ι → ℝ) → ℝ) := by |
| exact Integrable.fintype_prod (fun _ => compactNoiseDensity_integrable) |
|
|
| lemma compactNoiseKernel_compactSupport {ι : Type*} [Fintype ι] : |
| HasCompactSupport (compactNoiseKernel : (ι → ℝ) → ℝ) := by |
| classical |
| apply HasCompactSupport.intro (isCompact_univ_pi (fun _ : ι => isCompact_Icc (a := (-1:ℝ)) (b := 1))) |
| intro u hu |
| simp only [mem_univ_pi] at hu |
| push Not at hu |
| obtain ⟨i, hi⟩ := hu |
| apply prod_eq_zero (mem_univ i) |
| have hh : ¬|u i| < 1 := by |
| intro h |
| exact hi ⟨(abs_lt.mp h).1.le, (abs_lt.mp h).2.le⟩ |
| simp [compactNoiseDensity, compactNoiseWeight, hh] |
|
|
| lemma compactNoiseLaw_apply {s : Set ℝ} (hs : MeasurableSet s) : |
| compactNoiseLaw s = ENNReal.ofReal (∫ u in s, compactNoiseDensity u) := by |
| rw [compactNoiseLaw, withDensity_apply _ hs] |
| exact (ofReal_integral_eq_lintegral_ofReal compactNoiseDensity_integrable.integrableOn |
| (ae_of_all _ compactNoiseDensity_nonneg)).symm |
|
|
| lemma compactNoiseLaw_pi {ι : Type*} [Fintype ι] : |
| Measure.pi (fun _ : ι => compactNoiseLaw) = |
| volume.withDensity (fun u : ι → ℝ => ENNReal.ofReal (compactNoiseKernel u)) := by |
| apply Measure.pi_eq |
| intro s hs |
| rw [withDensity_apply _ (MeasurableSet.univ_pi hs), |
| ← ofReal_integral_eq_lintegral_ofReal compactNoiseKernel_integrable.integrableOn |
| (ae_of_all _ compactNoiseKernel_nonneg)] |
| simp only [volume_pi, Measure.restrict_pi_pi, compactNoiseKernel, |
| integral_fintype_prod_eq_prod, compactNoiseLaw_apply (hs _)] |
| exact ENNReal.ofReal_prod_of_nonneg (fun i _ => |
| integral_nonneg (fun _ => compactNoiseDensity_nonneg _)) |
|
|
| lemma compactNoiseLaw_pi_integral {ι : Type*} [Fintype ι] (f : (ι → ℝ) → ℝ) : |
| (∫ u, f u ∂Measure.pi (fun _ : ι => compactNoiseLaw)) = |
| ∫ u, compactNoiseKernel u * f u := by |
| rw [compactNoiseLaw_pi, integral_withDensity_eq_integral_toReal_smul |
| (compactNoiseKernel_contDiff (n := 0)).continuous.measurable.ennreal_ofReal |
| (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))] |
| simp only [ENNReal.toReal_ofReal (compactNoiseKernel_nonneg _), smul_eq_mul] |
|
|
| lemma compactNoiseKernel_hasFDerivAt {ι : Type*} [Fintype ι] (u : ι → ℝ) : |
| HasFDerivAt compactNoiseKernel |
| (∑ i, (compactNoiseScore (u i) * compactNoiseKernel u) • |
| (ContinuousLinearMap.proj i : (ι → ℝ) →L[ℝ] ℝ)) u := by |
| classical |
| have hi (i : ι) : HasFDerivAt (fun v : ι → ℝ => compactNoiseDensity (v i)) |
| ((compactNoiseScore (u i) * compactNoiseDensity (u i)) • |
| (ContinuousLinearMap.proj i : (ι → ℝ) →L[ℝ] ℝ)) u := |
| by |
| convert! HasDerivAt.comp_hasFDerivAt (f := fun v : ι → ℝ => v i) u |
| (compactNoiseDensity_hasDerivAt (u i)) (ContinuousLinearMap.proj i : (ι → ℝ) →L[ℝ] ℝ).hasFDerivAt using 1 |
| convert! HasFDerivAt.finsetProd (u := univ) (fun i _ => hi i) using 1 |
| apply sum_congr rfl |
| intro i _ |
| rw [smul_smul] |
| congr 1 |
| rw [mul_left_comm, prod_erase_mul _ _ (mem_univ i)] |
| rfl |
|
|
| lemma compactNoiseKernel_fderiv_apply {ι : Type*} [Fintype ι] (u v : ι → ℝ) : |
| fderiv ℝ compactNoiseKernel u v = |
| compactNoiseKernel u * ∑ i, compactNoiseScore (u i) * v i := by |
| rw [(compactNoiseKernel_hasFDerivAt u).fderiv] |
| simp only [_root_.sum_apply, smul_apply, |
| ContinuousLinearMap.proj_apply, smul_eq_mul, mul_sum] |
| apply sum_congr rfl |
| intro i _ |
| ring |
|
|
| end CoulombObservation |
|
|
| end |
|
|
| end OAI |
|
|
