| import Mathlib |
| import OAI.Analysis.CoulombIonization.RadialBounds.GlobalDensityBarrier |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter Complex TopologicalSpace |
| open scoped Topology InnerProductSpace ENNReal |
| namespace CoulombPauli |
| variable {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| {μ : Measure A} {ν : Measure B} [SigmaFinite μ] [SigmaFinite ν] |
|
|
| omit [SigmaFinite μ] in |
| lemma tensor_add_left (u w : Lp ℂ 2 μ) (v : Lp ℂ 2 ν) : |
| tensor (u+w) v = tensor u v + tensor w v := by |
| apply Lp.ext |
| filter_upwards [tensor_ae (u+w) v, tensor_ae u v, tensor_ae w v, |
| Lp.coeFn_add (tensor u v) (tensor w v), |
| Measure.quasiMeasurePreserving_fst.ae (Lp.coeFn_add u w)] with z h1 h2 h3 h4 h5 |
| simp only [h1,h2,h3,h4,h5,Pi.add_apply,add_mul] |
|
|
| omit [SigmaFinite μ] in |
| lemma tensor_smul_left (c : ℂ) (u : Lp ℂ 2 μ) (v : Lp ℂ 2 ν) : |
| tensor (c • u) v = c • tensor u v := by |
| apply Lp.ext |
| filter_upwards [tensor_ae (c • u) v, tensor_ae u v, |
| Lp.coeFn_smul c (tensor u v), |
| Measure.quasiMeasurePreserving_fst.ae (Lp.coeFn_smul c u)] with z h1 h2 h3 h4 |
| simp only [h1,h2,h3,h4,Pi.smul_apply,smul_eq_mul,mul_assoc] |
|
|
| def tensorRight (v : Lp ℂ 2 ν) : Lp ℂ 2 μ →L[ℂ] Lp ℂ 2 (μ.prod ν) := |
| LinearMap.mkContinuous |
| ({ toFun := fun u => tensor u v |
| map_add' := fun u w => tensor_add_left u w v |
| map_smul' := fun c u => tensor_smul_left c u v } : |
| Lp ℂ 2 μ →ₗ[ℂ] Lp ℂ 2 (μ.prod ν)) |
| ‖v‖ (fun u => by |
| change ‖tensor u v‖ ≤ ‖v‖ * ‖u‖ |
| rw [tensor_norm, mul_comm]) |
|
|
| lemma tensorRight_apply (u : Lp ℂ 2 μ) (v : Lp ℂ 2 ν) : tensorRight v u = tensor u v := rfl |
|
|
| lemma tensor_adjoint_exchange (u : Lp ℂ 2 μ) (v : Lp ℂ 2 ν) |
| (ψ : Lp ℂ 2 (μ.prod ν)) : |
| inner ℂ v ((tensorLeft u).adjoint ψ) = inner ℂ u ((tensorRight v).adjoint ψ) := by |
| rw [ContinuousLinearMap.adjoint_inner_right,ContinuousLinearMap.adjoint_inner_right] |
| rfl |
|
|
| omit [SigmaFinite μ] [SigmaFinite ν] in |
| lemma hilbertBasis_inner_eq_zero {H : Type*} [NormedAddCommGroup H] |
| [InnerProductSpace ℂ H] {ι : Type*} (b : HilbertBasis ι ℂ H) (u : H) |
| (h : ∀ i, inner ℂ (b i) u = 0) : u = 0 := by |
| apply b.repr.injective |
| ext i |
| simp [b.repr_apply_apply, h] |
|
|
| variable {ι κ : Type*} |
|
|
| lemma tensor_orthonormal (a : HilbertBasis ι ℂ (Lp ℂ 2 μ)) |
| (b : HilbertBasis κ ℂ (Lp ℂ 2 ν)) : |
| Orthonormal ℂ (fun p : ι × κ => tensor (a p.1) (b p.2)) := by |
| classical |
| rw [orthonormal_iff_ite] |
| intro p q |
| rw [tensor_inner, orthonormal_iff_ite.mp a.orthonormal, |
| orthonormal_iff_ite.mp b.orthonormal] |
| by_cases h1 : p.1 = q.1 <;> by_cases h2 : p.2 = q.2 <;> |
| simp [h1,h2,Prod.ext_iff] |
| |
| lemma tensor_basis_total (a : HilbertBasis ι ℂ (Lp ℂ 2 μ)) |
| (b : HilbertBasis κ ℂ (Lp ℂ 2 ν)) : |
| (Submodule.span ℂ (Set.range (fun p : ι × κ => tensor (a p.1) (b p.2))))ᗮ = ⊥ := by |
| apply le_antisymm _ bot_le |
| intro ψ hψ |
| change ψ = 0 |
| have hij (i : ι) (j : κ) : inner ℂ (tensor (a i) (b j)) ψ = 0 := |
| Submodule.inner_right_of_mem_orthogonal |
| (Submodule.subset_span (Set.mem_range_self (i,j))) hψ |
| have hleft (i : ι) : (tensorLeft (a i)).adjoint ψ = 0 := by |
| apply hilbertBasis_inner_eq_zero b |
| intro j |
| rw [ContinuousLinearMap.adjoint_inner_right,tensorLeft_apply] |
| exact hij i j |
| apply eq_zero_of_tensor_orthogonal |
| intro u v |
| have hr : (tensorRight v).adjoint ψ = 0 := by |
| apply hilbertBasis_inner_eq_zero a |
| intro i |
| rw [← tensor_adjoint_exchange, hleft, inner_zero_right] |
| rw [← tensorRight_apply, ← ContinuousLinearMap.adjoint_inner_right, hr, inner_zero_right] |
|
|
| def tensorBasis (a : HilbertBasis ι ℂ (Lp ℂ 2 μ)) |
| (b : HilbertBasis κ ℂ (Lp ℂ 2 ν)) : HilbertBasis (ι × κ) ℂ (Lp ℂ 2 (μ.prod ν)) := |
| HilbertBasis.mkOfOrthogonalEqBot (tensor_orthonormal a b) (tensor_basis_total a b) |
|
|
| lemma tensorBasis_apply (a : HilbertBasis ι ℂ (Lp ℂ 2 μ)) |
| (b : HilbertBasis κ ℂ (Lp ℂ 2 ν)) (p : ι × κ) : |
| tensorBasis a b p = tensor (a p.1) (b p.2) := by |
| simp [tensorBasis] |
|
|
| omit [SigmaFinite μ] [SigmaFinite ν] in |
| lemma basis_parseval {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] |
| (b : HilbertBasis ι ℂ H) (u : H) : |
| HasSum (fun i => ‖inner ℂ (b i) u‖^2) (‖u‖^2) := by |
| have hh := (b.hasSum_inner_mul_inner u u).mapL Complex.reCLM |
| convert hh using 1 |
| · ext i |
| simp only [Complex.reCLM_apply, ← inner_conj_symm u (b i), |
| ← Complex.normSq_eq_conj_mul_self, Complex.ofReal_re, Complex.normSq_eq_norm_sq] |
| · simp only [Complex.reCLM_apply, inner_self_eq_norm_sq_to_K, |
| ← RCLike.ofReal_pow] |
| rfl |
|
|
| lemma tensorRight_parseval (a : HilbertBasis ι ℂ (Lp ℂ 2 μ)) |
| (b : HilbertBasis κ ℂ (Lp ℂ 2 ν)) (ψ : Lp ℂ 2 (μ.prod ν)) : |
| ∑' j, ENNReal.ofReal (‖(tensorRight (b j)).adjoint ψ‖^2) = |
| ENNReal.ofReal (‖ψ‖^2) := by |
| have hs (j : κ) := basis_parseval a ((tensorRight (b j)).adjoint ψ) |
| have hsb := basis_parseval (tensorBasis a b) ψ |
| calc |
| _ = ∑' j, ∑' i, ENNReal.ofReal (‖inner ℂ (tensor (a i) (b j)) ψ‖^2) := by |
| congr 1; funext j |
| rw [← (hs j).tsum_eq, ENNReal.ofReal_tsum_of_nonneg (fun _ => sq_nonneg _) (hs j).summable] |
| simp only [ContinuousLinearMap.adjoint_inner_right, tensorRight_apply] |
| _ = ∑' p : ι × κ, ENNReal.ofReal (‖inner ℂ (tensor (a p.1) (b p.2)) ψ‖^2) := by |
| rw [ENNReal.tsum_comm] |
| exact ENNReal.tsum_prod.symm |
| _ = _ := by |
| simp_rw [← tensorBasis_apply] |
| rw [← ENNReal.ofReal_tsum_of_nonneg (fun _ => sq_nonneg _) hsb.summable, hsb.tsum_eq] |
|
|
| omit [SigmaFinite μ] [SigmaFinite ν] in |
| lemma hilbertBasis_countable {H : Type*} [NormedAddCommGroup H] |
| [InnerProductSpace ℂ H] [SeparableSpace H] (b : HilbertBasis ι ℂ H) : Countable ι := by |
| classical |
| have hd : Pairwise (fun i j => Disjoint (Metric.ball (b i) (1/2 : ℝ)) (Metric.ball (b j) (1/2 : ℝ))) := by |
| intro i j hij |
| apply Metric.ball_disjoint_ball |
| have h := norm_inner_le_norm (𝕜 := ℂ) (b i) (b i - b j) |
| have hi := b.orthonormal.norm_eq_one i |
| have hii := orthonormal_iff_ite.mp b.orthonormal i i |
| have hij' := orthonormal_iff_ite.mp b.orthonormal i j |
| have h' : (1 : ℝ) ≤ ‖b i - b j‖ := by |
| simpa [inner_sub_right, hii, hij', hi, hij] using h |
| norm_num only [dist_eq_norm] at ⊢ |
| exact h' |
| exact hd.countable_of_isOpen_disjoint (fun _ => Metric.isOpen_ball) |
| (fun i => ⟨b i, Metric.mem_ball_self (by norm_num)⟩) |
|
|
| end CoulombPauli |
|
|
| open MeasureTheory Filter Complex |
| open scoped Topology BigOperators ComplexConjugate FourierTransform SchwartzMap ENNReal |
|
|
| namespace CoulombPackets |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] |
| [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] |
|
|
| def windowed (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) (z : V) : 𝓢(V, ℂ) := |
| SchwartzMap.smulLeftCLM ℂ (fun x => (g (x-z) : ℂ)) v |
|
|
| omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in |
| lemma windowed_apply (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) (z x : V) : |
| windowed g v z x = (g (x-z) : ℂ) * v x := by |
| have hg : (fun x => (g (x-z) : ℂ)).HasTemperateGrowth := by |
| have ht := (g.compSubConstCLM ℝ z).hasTemperateGrowth |
| simpa only [SchwartzMap.compSubConstCLM_apply, Function.comp_def, Complex.ofRealCLM_apply] using |
| Complex.ofRealCLM.hasTemperateGrowth.comp ht |
| exact SchwartzMap.smulLeftCLM_apply_apply hg v x |
|
|
| omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in |
| lemma norm_windowed (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) (z x : V) : |
| ‖windowed g v z x‖^2 = g (x-z)^2 * ‖v x‖^2 := by |
| rw [windowed_apply, norm_mul, Complex.norm_real, mul_pow, Real.norm_eq_abs, sq_abs] |
|
|
| lemma integrable_shift_product (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) : |
| Integrable (fun p : V × V => g (p.2-p.1)^2 * ‖v p.2‖^2) (volume.prod volume) := by |
| have hg : Integrable (fun x => g x^2) := by |
| simpa [Real.norm_eq_abs, sq_abs] using |
| (memLp_two_iff_integrable_sq_norm (g.memLp 2).aestronglyMeasurable).1 (g.memLp 2) |
| have hv : Integrable (fun x => ‖v x‖^2) := |
| (memLp_two_iff_integrable_sq_norm (v.memLp 2).aestronglyMeasurable).1 (v.memLp 2) |
| have he : MeasurePreserving (fun p : V × V => (p.2-p.1,p.2)) (volume.prod volume) (volume.prod volume) := by |
| simpa only [Function.comp_def, Prod.map_apply, neg_sub, id_eq] using |
| ((Measure.measurePreserving_neg (volume : Measure V)).prod |
| (MeasurePreserving.id (volume : Measure V))).comp |
| (measurePreserving_sub_prod (volume : Measure V) volume) |
| exact he.integrable_comp_of_integrable (hg.mul_prod hv) |
|
|
| lemma integrated_plancherel (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) : |
| (∫ z : V, ∫ ξ : V, ‖𝓕 (windowed g v z) ξ‖^2) = |
| (∫ x : V, g x^2) * (∫ x : V, ‖v x‖^2) := by |
| simp_rw [SchwartzMap.integral_norm_sq_fourier, norm_windowed] |
| rw [integral_integral_swap (integrable_shift_product g v)] |
| simp_rw [integral_mul_const] |
| have h (x : V) := integral_sub_left_eq_self (fun y : V => g y^2) volume x |
| simp_rw [h] |
| rw [integral_const_mul] |
|
|
| def frameFunction (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) (p : V × V) : ℂ := |
| 𝓕 (windowed g v p.1) p.2 |
|
|
| lemma frameFunction_stronglyMeasurable (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) : |
| StronglyMeasurable (frameFunction g v) := by |
| have h : Continuous (fun q : (V × V) × V => |
| Real.fourierChar (-inner ℝ q.2 q.1.2) • ((g (q.2-q.1.1) : ℂ) * v q.2)) := by |
| exact (Real.continuous_fourierChar.comp ((continuous_snd.inner |
| (continuous_snd.comp continuous_fst)).neg)).smul |
| (((Complex.continuous_ofReal.comp (g.continuous.comp |
| (continuous_snd.sub (continuous_fst.comp continuous_fst)))).mul |
| (v.continuous.comp continuous_snd))) |
| convert (h.stronglyMeasurable.integral_prod_right' (ν := volume)) using 1 |
| ext p |
| simp only [frameFunction, SchwartzMap.fourier_coe, Real.fourier_eq, windowed_apply] |
|
|
| lemma frameFunction_memLp (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) : |
| MemLp (frameFunction g v) 2 (volume.prod volume) := by |
| apply (memLp_two_iff_integrable_sq_norm |
| (frameFunction_stronglyMeasurable g v).aestronglyMeasurable).2 |
| apply (integrable_prod_iff |
| ((frameFunction_stronglyMeasurable g v).norm.pow 2).aestronglyMeasurable).2 |
| constructor |
| · refine Filter.Eventually.of_forall fun z => ?_ |
| change Integrable (fun ξ : V => ‖𝓕 (windowed g v z) ξ‖^2) volume |
| exact (memLp_two_iff_integrable_sq_norm |
| ((𝓕 (windowed g v z)).memLp 2 volume).aestronglyMeasurable).1 |
| ((𝓕 (windowed g v z)).memLp 2 volume) |
| · have h := (integrable_shift_product g v).integral_prod_left |
| change Integrable (fun z : V => ∫ ξ : V, |‖𝓕 (windowed g v z) ξ‖^2|) volume |
| simpa only [abs_sq, SchwartzMap.integral_norm_sq_fourier, norm_windowed] using h |
|
|
| lemma l2_norm_sq {α : Type*} [MeasurableSpace α] {μ : Measure α} |
| (u : Lp ℂ 2 μ) : ‖u‖^2 = ∫ x, ‖u x‖^2 ∂μ := by |
| rw [@norm_sq_eq_re_inner ℂ, L2.inner_def] |
| simp only [inner_self_eq_norm_sq_to_K] |
| change (∫ x, (‖u x‖ : ℂ)^2 ∂μ).re = _ |
| simp_rw [← Complex.ofReal_pow] |
| rw [integral_complex_ofReal] |
| rfl |
|
|
| lemma frame_norm_sq (g : 𝓢(V, ℝ)) (v : 𝓢(V, ℂ)) : |
| ‖(frameFunction_memLp g v).toLp (frameFunction g v)‖^2 = |
| (∫ x : V, g x^2) * ‖v.toLp 2 volume‖^2 := by |
| rw [l2_norm_sq, l2_norm_sq] |
| calc |
| _ = ∫ p : V × V, ‖frameFunction g v p‖^2 ∂(volume.prod volume) := by |
| apply integral_congr_ae |
| filter_upwards [(frameFunction_memLp g v).coeFn_toLp] with p hp |
| rw [hp] |
| _ = (∫ x : V, g x^2) * (∫ x : V, ‖v x‖^2) := by |
| rw [integral_prod _ ((memLp_two_iff_integrable_sq_norm |
| (frameFunction_memLp g v).aestronglyMeasurable).1 (frameFunction_memLp g v))] |
| exact integrated_plancherel g v |
| _ = _ := by |
| congr 1 |
| apply integral_congr_ae |
| filter_upwards [v.coeFn_toLp 2 volume] with x hx |
| rw [hx] |
|
|
| def frameLinear (g : 𝓢(V, ℝ)) : |
| 𝓢(V, ℂ) →ₗ[ℂ] Lp ℂ 2 ((volume : Measure V).prod (volume : Measure V)) where |
| toFun v := (frameFunction_memLp g v).toLp _ |
| map_add' u v := by |
| apply Lp.ext |
| filter_upwards [(frameFunction_memLp g (u+v)).coeFn_toLp, |
| (frameFunction_memLp g u).coeFn_toLp, (frameFunction_memLp g v).coeFn_toLp, |
| Lp.coeFn_add ((frameFunction_memLp g u).toLp _) |
| ((frameFunction_memLp g v).toLp _)] with p h1 h2 h3 h4 |
| simp only [h1, h4, Pi.add_apply, h2, h3] |
| simp only [frameFunction, windowed, map_add, FourierTransform.fourier_add, |
| add_apply] |
| map_smul' c v := by |
| apply Lp.ext |
| filter_upwards [(frameFunction_memLp g (c • v)).coeFn_toLp, |
| (frameFunction_memLp g v).coeFn_toLp, |
| Lp.coeFn_smul c ((frameFunction_memLp g v).toLp _)] with p h1 h2 h3 |
| simp only [RingHom.id_apply, h1, h3, Pi.smul_apply, h2] |
| simp only [frameFunction, windowed, map_smul, FourierTransform.fourier_smul, |
| smul_apply] |
|
|
| lemma frameLinear_norm (g : 𝓢(V, ℝ)) (hg : ∫ x : V, g x^2 = 1) |
| (v : 𝓢(V, ℂ)) : ‖frameLinear g v‖ = ‖v.toLp 2 volume‖ := by |
| have h := frame_norm_sq g v |
| rw [hg, one_mul] at h |
| exact (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).1 h |
|
|
| def frame (g : 𝓢(V, ℝ)) : Lp ℂ 2 (volume : Measure V) →L[ℂ] |
| Lp ℂ 2 ((volume : Measure V).prod (volume : Measure V)) := |
| (frameLinear g).extendOfNorm (SchwartzMap.toLpCLM ℂ ℂ 2 volume).toLinearMap |
|
|
| lemma frame_toLp (g : 𝓢(V, ℝ)) (hg : ∫ x : V, g x^2 = 1) (v : 𝓢(V, ℂ)) : |
| frame g (v.toLp 2 volume) = frameLinear g v := by |
| apply LinearMap.extendOfNorm_eq |
| · exact SchwartzMap.denseRange_toLpCLM ENNReal.ofNat_ne_top |
| · exact ⟨1, fun v => by simpa using (frameLinear_norm g hg v).le⟩ |
|
|
| lemma frame_norm (g : 𝓢(V, ℝ)) (hg : ∫ x : V, g x^2 = 1) |
| (v : Lp ℂ 2 (volume : Measure V)) : ‖frame g v‖ = ‖v‖ := by |
| refine (SchwartzMap.denseRange_toLpCLM (μ := (volume : Measure V)) |
| (F := ℂ) (p := 2) ENNReal.ofNat_ne_top).induction_on v ?_ ?_ |
| · exact isClosed_eq (by fun_prop) (by fun_prop) |
| · intro u |
| rw [SchwartzMap.toLpCLM_apply, frame_toLp g hg] |
| exact frameLinear_norm g hg u |
|
|
| def frameIsometry (g : 𝓢(V, ℝ)) (hg : ∫ x : V, g x^2 = 1) : |
| Lp ℂ 2 (volume : Measure V) →ₗᵢ[ℂ] Lp ℂ 2 ((volume : Measure V).prod (volume : Measure V)) where |
| toLinearMap := (frame g).toLinearMap |
| norm_map' := frame_norm g hg |
|
|
| end CoulombPackets |
|
|
| end |
|
|
| end OAI |
|
|
