File size: 5,534 Bytes
caec230 | 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 | import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.SpatialCalculus
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.HeatKernels
namespace OAI
noncomputable section
namespace VelocityDetection.HeatKernels
open scoped BigOperators Topology ContDiff
open Set Function Filter
open Set Function Filter MeasureTheory
open scoped Topology BigOperators ContDiff
open scoped Topology ContDiff BigOperators
open scoped Topology ContDiff ZeroAtInfty
open scoped Topology ContDiff ZeroAtInfty BigOperators
open ProbabilityTheory SpatialCalculus
theorem contDiff_kernel (ν t : ℝ) : ContDiff ℝ ∞ (kernel ν t) := by
unfold kernel
fun_prop
theorem partialD_kernel (ν t : ℝ) (i : Fin 2) (X : Coord 2) :
partialD i (kernel ν t) X = -(X i / (2 * ν * t)) * kernel ν t X := by
let q : Coord 2 → ℝ := fun Y => -(Y 0 ^ 2 + Y 1 ^ 2) * (4 * ν * t)⁻¹
have hq (Y : Coord 2) : HasFDerivAt q
((4 * ν * t)⁻¹ • -((2 * Y 0) • (ContinuousLinearMap.proj 0 : Coord 2 →L[ℝ] ℝ) +
(2 * Y 1) • (ContinuousLinearMap.proj 1 : Coord 2 →L[ℝ] ℝ))) Y := by
convert (((hasFDerivAt_apply (𝕜 := ℝ) 0 Y).pow 2).add
((hasFDerivAt_apply (𝕜 := ℝ) 1 Y).pow 2)).neg.const_mul (4 * ν * t)⁻¹ using 1 <;> try rfl
· funext Z; dsimp [q]; ring
· simp
have hk (Y : Coord 2) : HasFDerivAt (kernel ν t)
((4 * Real.pi * ν * t)⁻¹ • (Real.exp (q Y) •
((4 * ν * t)⁻¹ • -((2 * Y 0) • (ContinuousLinearMap.proj 0 : Coord 2 →L[ℝ] ℝ) +
(2 * Y 1) • (ContinuousLinearMap.proj 1 : Coord 2 →L[ℝ] ℝ))))) Y := by
change HasFDerivAt (fun Z => (4 * Real.pi * ν * t)⁻¹ *
Real.exp (-(Z 0 ^ 2 + Z 1 ^ 2) / (4 * ν * t))) _ Y
simpa only [q, div_eq_mul_inv] using (hq Y).exp.const_mul (4 * Real.pi * ν * t)⁻¹
rw [partialD_eq_fderiv i (fun Y => (hk Y).differentiableAt), (hk X).fderiv]
simp only [smul_apply, neg_apply, add_apply, ContinuousLinearMap.proj_apply, smul_eq_mul]
fin_cases i <;> simp [kernel, q, div_eq_mul_inv, mul_inv_rev] <;> ring
def momentKernel (i : Fin 2) (Y : Coord 2) : ℝ := Y i * normal 2 Y
theorem integrable_weighted_gaussian : Integrable (fun y : ℝ => y * gaussianPDFReal 0 1 y) := by
have hh := (integrable_mul_exp_neg_mul_sq (by norm_num : (0 : ℝ) < 1 / 2)).const_mul
(Real.sqrt (2 * Real.pi))⁻¹
convert hh using 1
funext y
simp only [gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero]
have he : -y ^ 2 / 2 = -(1 / 2 : ℝ) * y ^ 2 := by ring
rw [he]
ring
theorem integrable_momentKernel (i : Fin 2) : Integrable (momentKernel i) := by
let w : Fin 2 → ℝ → ℝ := fun j y => if j = i then y * gaussianPDFReal 0 1 y else gaussianPDFReal 0 1 y
have hw (j : Fin 2) : Integrable (w j) := by
by_cases hj : j = i
· simpa [w, hj] using integrable_weighted_gaussian
· simpa [w, hj] using integrable_gaussianPDFReal 0 1
have hh : Integrable (fun Y : Coord 2 => ∏ j : Fin 2, w j (Y j)) := Integrable.fintype_prod hw
convert hh using 1
funext Y
fin_cases i <;> simp [momentKernel, normal, Fin.prod_univ_two, w] <;> ring
theorem partialD_kernel_rescale {ν t : ℝ} (hν : 0 < ν) (ht : 0 < t) (i : Fin 2) :
partialD i (kernel ν t) = fun X =>
-(Real.sqrt (2 * ν * t))⁻¹ *
rescale (momentKernel i) (Real.sqrt (2 * ν * t)) X := by
have hr : 0 < Real.sqrt (2 * ν * t) := Real.sqrt_pos.mpr (by positivity)
have hs : Real.sqrt (2 * ν * t) ^ 2 = 2 * ν * t := Real.sq_sqrt (by positivity)
funext X
rw [partialD_kernel, kernel_eq_rescale hν ht]
simp only [rescale, momentKernel, Pi.smul_apply, smul_eq_mul]
have hi : (2 * ν * t)⁻¹ = (Real.sqrt (2 * ν * t))⁻¹ * (Real.sqrt (2 * ν * t))⁻¹ := by
calc
(2 * ν * t)⁻¹ = (Real.sqrt (2 * ν * t) ^ 2)⁻¹ := congrArg Inv.inv hs.symm
_ = _ := by rw [pow_two, mul_inv_rev]
rw [div_eq_mul_inv, hi]
ring
theorem integrable_partialD_kernel {ν t : ℝ} (hν : 0 < ν) (ht : 0 < t) (i : Fin 2) :
Integrable (partialD i (kernel ν t)) := by
rw [partialD_kernel_rescale hν ht]
exact (integrable_rescale (integrable_momentKernel i)
(Real.sqrt_pos.mpr (by positivity))).const_mul _
def absoluteMoment (i : Fin 2) : ℝ := ∫ Y, ‖momentKernel i Y‖
theorem absoluteMoment_nonneg (i : Fin 2) : 0 ≤ absoluteMoment i :=
integral_nonneg (fun _ => norm_nonneg _)
theorem integral_norm_partialD_kernel {ν t : ℝ} (hν : 0 < ν) (ht : 0 < t) (i : Fin 2) :
(∫ Y, ‖partialD i (kernel ν t) Y‖) =
(Real.sqrt (2 * ν * t))⁻¹ * absoluteMoment i := by
rw [partialD_kernel_rescale hν ht]
simp only [norm_mul, norm_neg, norm_inv,
Real.norm_eq_abs, abs_of_nonneg (Real.sqrt_nonneg _)]
rw [integral_const_mul]
congr 1
have hr : 0 < Real.sqrt (2 * ν * t) := Real.sqrt_pos.mpr (by positivity)
have he : (fun Y => |rescale (momentKernel i) (Real.sqrt (2 * ν * t)) Y|) =
rescale (fun Y => ‖momentKernel i Y‖) (Real.sqrt (2 * ν * t)) := by
funext Y
simp only [rescale, abs_mul, abs_inv, Real.norm_eq_abs,
abs_of_nonneg (sq_nonneg (Real.sqrt (2 * ν * t)))]
rw [he, integral_rescale _ hr]
rfl
theorem integral_norm_partialD_kernel_eq {ν t : ℝ} (hν : 0 < ν) (ht : 0 < t) (i : Fin 2) :
(∫ Y, ‖partialD i (kernel ν t) Y‖) =
(absoluteMoment i / Real.sqrt (2 * ν)) * (Real.sqrt t)⁻¹ := by
rw [integral_norm_partialD_kernel hν ht, Real.sqrt_mul (by positivity), mul_inv_rev]
ring
end VelocityDetection.HeatKernels
end
end OAI
|