| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff InnerProductSpace Convolution |
| namespace CoulombAtom |
| section CoerciveOperator |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [CompleteSpace V] |
|
|
| lemma coercive_operator_bijective (A : V →L[ℂ] V) {c : ℝ} (hc : 0 < c) |
| (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : Function.Bijective A := by |
| have hb (u : V) : c * ‖u‖ ≤ ‖A u‖ := by |
| have hi := re_inner_le_norm (𝕜 := ℂ) u (A u) |
| by_cases hu : ‖u‖ = 0 |
| · simp [hu] |
| · have hp : 0 < ‖u‖ := lt_of_le_of_ne (norm_nonneg u) (Ne.symm hu) |
| apply (mul_le_mul_iff_left₀ hp).mp |
| calc |
| c * ‖u‖ * ‖u‖ = c * ‖u‖ ^ 2 := by ring |
| _ ≤ (⟪u, A u⟫_ℂ).re := hA u |
| _ ≤ ‖A u‖ * ‖u‖ := by simpa only [RCLike.re_eq_complex_re, mul_comm] using hi |
| have ha : AntilipschitzWith c⁻¹.toNNReal A := by |
| apply A.antilipschitz_of_bound |
| intro u |
| rw [Real.coe_toNNReal _ (le_of_lt (inv_pos.mpr hc))] |
| exact (le_inv_mul_iff₀ hc).mpr (hb u) |
| have hcl : IsClosed (A.range : Set V) := ha.isClosed_range A.uniformContinuous |
| let : CompleteSpace A.range := hcl.completeSpace_coe |
| have hr : A.range = ⊤ := by |
| rw [← A.range.orthogonal_orthogonal, Submodule.eq_top_iff'] |
| intro u w hw |
| have hw0 : w = 0 := by |
| have hi := hw (A w) ⟨w, rfl⟩ |
| have hh := hA w |
| have hz : (⟪w, A w⟫_ℂ).re = 0 := by |
| rw [← inner_conj_symm, hi] |
| rfl |
| rw [hz] at hh |
| have hs : c * ‖w‖ ^ 2 = 0 := le_antisymm hh (mul_nonneg hc.le (sq_nonneg _)) |
| have hn : ‖w‖ = 0 := (sq_eq_zero_iff).mp ((mul_eq_zero.mp hs).resolve_left hc.ne') |
| exact norm_eq_zero.mp hn |
| simp [hw0] |
| exact ⟨ha.injective, LinearMap.range_eq_top.mp hr⟩ |
|
|
| def coerciveEquiv (A : V →L[ℂ] V) {c : ℝ} (hc : 0 < c) |
| (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : V ≃L[ℂ] V := |
| ContinuousLinearEquiv.ofBijective A |
| (LinearMap.ker_eq_bot.mpr (coercive_operator_bijective A hc hA).1) |
| (LinearMap.range_eq_top.mpr (coercive_operator_bijective A hc hA).2) |
|
|
| end CoerciveOperator |
| section InverseOperator |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| lemma selfAdjoint_denseRange {R : H →L[ℂ] H} (hR : IsSelfAdjoint R) |
| (hinj : Function.Injective R) : DenseRange R := by |
| have horth : R.rangeᗮ = ⊥ := by |
| rw [R.orthogonal_range, hR.adjoint_eq] |
| exact LinearMap.ker_eq_bot.mpr hinj |
| change Dense (R.range : Set H) |
| apply Submodule.dense_iff_topologicalClosure_eq_top.mpr |
| rw [← Submodule.orthogonal_orthogonal_eq_closure, horth, Submodule.bot_orthogonal_eq_top] |
|
|
| def inverseOperator (R : H →L[ℂ] H) : H →ₗ.[ℂ] H := (R.toPMap ⊤).inverse |
|
|
| omit [CompleteSpace H] in |
| lemma toPMap_top_ker {R : H →L[ℂ] H} (hinj : Function.Injective R) : |
| (R.toPMap ⊤).toFun.ker = ⊥ := by |
| apply LinearMap.ker_eq_bot.mpr |
| intro x y hxy |
| apply Subtype.ext |
| exact hinj hxy |
|
|
| omit [CompleteSpace H] in |
| lemma inverseOperator_graph {R : H →L[ℂ] H} (hinj : Function.Injective R) (x y : H) : |
| (x, y) ∈ (inverseOperator R).graph ↔ R y = x := by |
| have hker : (R.toPMap ⊤).ker = ⊥ := by |
| simp only [LinearPMap.ker, toPMap_top_ker hinj, Submodule.map_bot] |
| rw [inverseOperator, LinearPMap.inverse_graph hker] |
| simp only [Submodule.mem_map, LinearPMap.mem_graph_iff, LinearEquiv.coe_coe, |
| LinearEquiv.prodComm_apply, Prod.exists, Prod.swap_prod_mk, Prod.mk.injEq] |
| constructor |
| · rintro ⟨a, b, ⟨z, hz1, hz2⟩, hb, ha⟩ |
| exact (congrArg R (hz1.trans ha).symm).trans (hz2.trans hb) |
| · intro h |
| exact ⟨y, x, ⟨⟨y, trivial⟩, rfl, h⟩, rfl, rfl⟩ |
|
|
| omit [CompleteSpace H] in |
| lemma inverseOperator_domain (R : H →L[ℂ] H) : |
| (inverseOperator R).domain = R.range := by |
| rw [inverseOperator, LinearPMap.inverse_domain] |
| ext x |
| constructor |
| · rintro ⟨a, rfl⟩ |
| exact ⟨a.val, rfl⟩ |
| · rintro ⟨a, rfl⟩ |
| exact ⟨⟨a, trivial⟩, rfl⟩ |
|
|
| theorem inverseOperator_selfAdjoint {R : H →L[ℂ] H} (hR : IsSelfAdjoint R) |
| (hinj : Function.Injective R) : IsSelfAdjoint (inverseOperator R) := by |
| have hd : Dense ((inverseOperator R).domain : Set H) := by |
| rw [inverseOperator_domain] |
| exact selfAdjoint_denseRange hR hinj |
| rw [LinearPMap.isSelfAdjoint_def] |
| apply LinearPMap.eq_of_eq_graph |
| rw [LinearPMap.adjoint_graph_eq_graph_adjoint hd] |
| ext p |
| rcases p with ⟨x, y⟩ |
| rw [Submodule.mem_adjoint_iff, inverseOperator_graph hinj] |
| constructor |
| · intro h |
| apply ext_inner_left ℂ |
| intro z |
| have hh := h (R z) z ((inverseOperator_graph hinj _ _).mpr rfl) |
| rw [sub_eq_zero] at hh |
| have hsym := (ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mp hR) z y |
| exact hsym.symm.trans hh.symm |
| · intro h a b hab |
| have he := (inverseOperator_graph hinj a b).mp hab |
| rw [← he, ← h, ← R.adjoint_inner_right, hR.adjoint_eq, sub_self] |
|
|
| end InverseOperator |
|
|
| variable {V H : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [CompleteSpace V] |
| [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| lemma selfAdjoint_equiv_symm (e : V ≃L[ℂ] V) (he : IsSelfAdjoint e.toContinuousLinearMap) : |
| IsSelfAdjoint e.symm.toContinuousLinearMap := by |
| apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr |
| intro x y |
| have hh := (ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mp he) (e.symm x) (e.symm y) |
| change ⟪e (e.symm x), e.symm y⟫_ℂ = ⟪e.symm x, e (e.symm y)⟫_ℂ at hh |
| change ⟪e.symm x, y⟫_ℂ = ⟪x, e.symm y⟫_ℂ |
| simpa only [e.apply_symm_apply] using hh.symm |
|
|
| lemma adjoint_injective_of_denseRange (j : V →L[ℂ] H) (hd : DenseRange j) : |
| Function.Injective j.adjoint := by |
| intro x y hxy |
| apply hd.eq_of_inner_right ℂ |
| intro v |
| rw [← j.adjoint_inner_right, ← j.adjoint_inner_right, hxy] |
|
|
| def formResolvent (j : V →L[ℂ] H) (A : V →L[ℂ] V) {c : ℝ} (hc : 0 < c) |
| (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : H →L[ℂ] H := |
| j.comp ((coerciveEquiv A hc hA).symm.toContinuousLinearMap.comp j.adjoint) |
|
|
| lemma formResolvent_injective (j : V →L[ℂ] H) (hj : Function.Injective j) (hd : DenseRange j) |
| (A : V →L[ℂ] V) {c : ℝ} (hc : 0 < c) |
| (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : |
| Function.Injective (formResolvent j A hc hA) := |
| hj.comp ((coerciveEquiv A hc hA).symm.injective.comp (adjoint_injective_of_denseRange j hd)) |
|
|
| lemma formResolvent_selfAdjoint (j : V →L[ℂ] H) (A : V →L[ℂ] V) (hs : IsSelfAdjoint A) |
| {c : ℝ} (hc : 0 < c) (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : |
| IsSelfAdjoint (formResolvent j A hc hA) := by |
| have he : IsSelfAdjoint (coerciveEquiv A hc hA).toContinuousLinearMap := hs |
| exact (selfAdjoint_equiv_symm _ he).conj_adjoint j |
|
|
| def representedOperator (j : V →L[ℂ] H) (A : V →L[ℂ] V) {c : ℝ} (hc : 0 < c) |
| (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : H →ₗ.[ℂ] H := |
| inverseOperator (formResolvent j A hc hA) |
|
|
| theorem representedOperator_selfAdjoint (j : V →L[ℂ] H) (hj : Function.Injective j) |
| (hd : DenseRange j) (A : V →L[ℂ] V) (hs : IsSelfAdjoint A) |
| {c : ℝ} (hc : 0 < c) (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) : |
| IsSelfAdjoint (representedOperator j A hc hA) := |
| inverseOperator_selfAdjoint (formResolvent_selfAdjoint j A hs hc hA) |
| (formResolvent_injective j hj hd A hc hA) |
|
|
| theorem representedOperator_graph (j : V →L[ℂ] H) (hj : Function.Injective j) |
| (hd : DenseRange j) (A : V →L[ℂ] V) |
| {c : ℝ} (hc : 0 < c) (hA : ∀ u, c * ‖u‖ ^ 2 ≤ (⟪u, A u⟫_ℂ).re) (x y : H) : |
| (x, y) ∈ (representedOperator j A hc hA).graph ↔ |
| ∃ u : V, j u = x ∧ ∀ v : V, ⟪v, A u⟫_ℂ = ⟪j v, y⟫_ℂ := by |
| rw [representedOperator, inverseOperator_graph (formResolvent_injective j hj hd A hc hA)] |
| constructor |
| · intro h |
| refine ⟨(coerciveEquiv A hc hA).symm (j.adjoint y), h, ?_⟩ |
| intro v |
| have he : A ((coerciveEquiv A hc hA).symm (j.adjoint y)) = j.adjoint y := |
| (coerciveEquiv A hc hA).apply_symm_apply _ |
| rw [he, j.adjoint_inner_right] |
| · rintro ⟨u, hu, h⟩ |
| have he : A u = j.adjoint y := by |
| apply ext_inner_left ℂ |
| intro v |
| rw [j.adjoint_inner_right] |
| exact h v |
| have he' : (coerciveEquiv A hc hA).symm (j.adjoint y) = u := by |
| rw [← he] |
| exact (coerciveEquiv A hc hA).symm_apply_apply u |
| change j ((coerciveEquiv A hc hA).symm (j.adjoint y)) = x |
| rw [he', hu] |
|
|
| end CoulombAtom |
|
|
| end |
|
|
| end OAI |
|
|
