File size: 6,951 Bytes
159357f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | 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 <;> rfl
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]; ring
· 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
|