| import Mathlib |
| import OAI.Analysis.CoulombIonization.FormDomain.WeakProduct |
| import OAI.Analysis.CoulombIonization.FormDomain.CoulombCoercivity |
| import OAI.Analysis.CoulombIonization.FormDomain.FormBottom |
| import OAI.Analysis.CoulombIonization.Variational.L2 |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff InnerProductSpace Convolution |
| open Filter |
| open scoped Topology InnerProductSpace |
| open MeasureTheory Complex Filter |
| open scoped Topology InnerProductSpace |
| open MeasureTheory Complex Filter |
| open scoped Topology InnerProductSpace ContDiff |
| namespace CoulombAtom |
| section Multiplier |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E] |
| [IsLocallyFiniteMeasure (volume : Measure E)] |
| variable {ι : Type*} [Fintype ι] |
|
|
| structure SmoothMultiplier (v : ι → E) where |
| value : E → ℝ |
| regular : ContDiff ℝ ∞ value |
| bound : ∃ C : ℝ, ∀ x, |value x| ≤ C |
| gradient_bound : ∀ i, ∃ C : ℝ, ∀ x, |lineDeriv ℝ value x (v i)| ≤ C |
|
|
| omit [NormedSpace ℝ E] [FiniteDimensional ℝ E] |
| [IsLocallyFiniteMeasure (volume : Measure E)] in |
| lemma memLp_bounded_mul {p : E → ℝ} (hp : Continuous p) |
| (hb : ∃ C : ℝ, ∀ x, |p x| ≤ C) {f : E → ℂ} (hf : MemLp f 2) : |
| MemLp (fun x => (p x : ℂ) * f x) 2 := by |
| obtain ⟨C, hC⟩ := hb |
| have ht : MemLp (fun x => (p x : ℂ)) ⊤ := memLp_top_of_bound |
| (Complex.continuous_ofReal.comp hp).aestronglyMeasurable C |
| (Eventually.of_forall fun x => by simpa using hC x) |
| exact ht.fun_mul hf |
|
|
| omit [FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E] |
| [IsLocallyFiniteMeasure (volume : Measure E)] [Fintype ι] in |
| lemma SmoothMultiplier.derivative_continuous {v : ι → E} |
| (p : SmoothMultiplier v) (i : ι) : |
| Continuous (fun x => lineDeriv ℝ p.value x (v i)) := by |
| have he : (fun x => lineDeriv ℝ p.value x (v i)) = |
| fun x => fderiv ℝ p.value x (v i) := by |
| funext x |
| exact (p.regular.differentiable (by simp) x).lineDeriv_eq_fderiv |
| rw [he] |
| exact (p.regular.continuous_fderiv (by simp)).clm_apply continuous_const |
|
|
| omit [Fintype ι] in |
| lemma SmoothMultiplier.value_memLp {v : ι → E} (p : SmoothMultiplier v) |
| (F : weakGraph v) : MemLp (fun x => (p.value x : ℂ) * F.val none x) 2 := |
| memLp_bounded_mul p.regular.continuous p.bound (Lp.memLp _) |
|
|
| omit [Fintype ι] in |
| lemma SmoothMultiplier.gradient_memLp {v : ι → E} (p : SmoothMultiplier v) |
| (F : weakGraph v) (i : ι) : |
| MemLp (fun x => (p.value x : ℂ) * F.val (some i) x + |
| Complex.ofReal (lineDeriv ℝ p.value x (v i)) * F.val none x) 2 := |
| (memLp_bounded_mul p.regular.continuous p.bound (Lp.memLp _)).add |
| (memLp_bounded_mul (p.derivative_continuous i) (p.gradient_bound i) (Lp.memLp _)) |
|
|
| def SmoothMultiplier.apply {v : ι → E} (p : SmoothMultiplier v) (F : weakGraph v) : |
| weakGraph v := by |
| let G : WeakGraphAmbient E ι := WithLp.toLp 2 fun k => match k with |
| | none => (p.value_memLp F).toLp _ |
| | some i => (p.gradient_memLp F i).toLp _ |
| refine ⟨G, (mem_weakGraph v G).mpr ?_⟩ |
| intro i |
| exact (((mem_weakGraph v F.val).mp F.property i).mul_smooth |
| (Lp.memLp _) (Lp.memLp _) p.regular).congr_ae |
| (p.value_memLp F).coeFn_toLp.symm (p.gradient_memLp F i).coeFn_toLp.symm |
|
|
| omit [Fintype ι] in |
| lemma SmoothMultiplier.apply_value {v : ι → E} (p : SmoothMultiplier v) |
| (F : weakGraph v) : |
| ((p.apply F).val none : E → ℂ) =ᵐ[volume] fun x => (p.value x : ℂ) * F.val none x := |
| (p.value_memLp F).coeFn_toLp |
|
|
| omit [Fintype ι] in |
| lemma SmoothMultiplier.apply_gradient {v : ι → E} (p : SmoothMultiplier v) |
| (F : weakGraph v) (i : ι) : |
| ((p.apply F).val (some i) : E → ℂ) =ᵐ[volume] |
| fun x => (p.value x : ℂ) * F.val (some i) x + |
| Complex.ofReal (lineDeriv ℝ p.value x (v i)) * F.val none x := |
| (p.gradient_memLp F i).coeFn_toLp |
|
|
| end Multiplier |
|
|
| structure FermionMultiplier (N : ℕ) extends SmoothMultiplier (sectorDirections N) where |
| symmetric : ∀ (π : Equiv.Perm (Fin N)) (x : Configuration N), value (x ∘ π) = value x |
|
|
| def FermionMultiplier.apply {N : ℕ} (p : FermionMultiplier N) (F : fermionGraph N) : |
| fermionGraph N := by |
| let G : SectorGraph N := WithLp.toLp 2 fun s => p.toSmoothMultiplier.apply (F.val s) |
| refine ⟨G, (mem_fermionSpace_ae (sectorGraphValue N G)).mpr ?_⟩ |
| intro π s |
| have hl := (permuteConfiguration_preserving π).quasiMeasurePreserving.ae |
| (p.toSmoothMultiplier.apply_value (F.val (s ∘ π))) |
| filter_upwards [hl, p.toSmoothMultiplier.apply_value (F.val s), |
| (mem_fermionSpace_ae (sectorGraphValue N F.val)).mp F.property π s] with x hx hy hz |
| change (p.toSmoothMultiplier.apply (F.val (s ∘ π))).val none (x ∘ π) = |
| (((Equiv.Perm.sign π : ℤ) : ℂ)) * (p.toSmoothMultiplier.apply (F.val s)).val none x |
| simp only [sectorGraphValue_apply] at hz |
| simp only [permuteConfiguration_apply] at hx |
| rw [hx, hy, p.symmetric, hz] |
| ring |
|
|
| lemma FermionMultiplier.apply_value {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) : |
| (graphComponent s none (p.apply F) : Configuration N → ℂ) =ᵐ[volume] |
| fun x => (p.value x : ℂ) * graphComponent s none F x := |
| p.toSmoothMultiplier.apply_value (F.val s) |
|
|
| lemma FermionMultiplier.apply_gradient {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i : Fin N) (a : Fin 3) : |
| (graphComponent s (some (i, a)) (p.apply F) : Configuration N → ℂ) =ᵐ[volume] |
| fun x => (p.value x : ℂ) * graphComponent s (some (i, a)) F x + |
| Complex.ofReal (lineDeriv ℝ p.value x (direction i a)) * graphComponent s none F x := |
| p.toSmoothMultiplier.apply_gradient (F.val s) (i, a) |
|
|
| lemma graphNuclear_ae {N : ℕ} (s : Spins N) (i : Fin N) (F : fermionGraph N) : |
| (graphNuclear s i F : Configuration N → ℂ) =ᵐ[volume] |
| fun x => graphComponent s none F x / (Real.sqrt ‖x i‖ : ℂ) := by |
| exact (rootCoulombFn_memLp (sectorDirections N) (ContinuousLinearMap.proj i) |
| (fun a => (i, a)) (by intro a; simp [sectorDirections, direction]) (F.val s)).coeFn_toLp |
|
|
| lemma graphPair_ae {N : ℕ} (s : Spins N) (i j : Fin N) (hij : i ≠ j) |
| (F : fermionGraph N) : |
| (graphPair s i j hij F : Configuration N → ℂ) =ᵐ[volume] |
| fun x => graphComponent s none F x / (Real.sqrt ‖x i - x j‖ : ℂ) := by |
| exact (rootCoulombFn_memLp (sectorDirections N) (electronProjection i - electronProjection j) |
| (fun a => (i, a)) (by |
| intro a |
| change direction i a i - direction i a j = EuclideanSpace.single a 1 |
| simp [direction, Ne.symm hij]) (F.val s)).coeFn_toLp |
|
|
| attribute [local irreducible] graphNuclear graphPair graphComponent FermionMultiplier.apply |
|
|
| lemma FermionMultiplier.apply_nuclear {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i : Fin N) : |
| (graphNuclear s i (p.apply F) : Configuration N → ℂ) =ᵐ[volume] |
| fun x => (p.value x : ℂ) * graphNuclear s i F x := by |
| filter_upwards [graphNuclear_ae s i (p.apply F), graphNuclear_ae s i F, |
| p.apply_value F s] with x hx hy hz |
| exact hx.trans ((congrArg (fun z : ℂ => z / _) hz).trans |
| ((mul_div_assoc (p.value x : ℂ) _ _).trans (congrArg (fun z : ℂ => (p.value x : ℂ) * z) hy.symm))) |
|
|
| lemma FermionMultiplier.apply_pair {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i j : Fin N) (hij : i ≠ j) : |
| (graphPair s i j hij (p.apply F) : Configuration N → ℂ) =ᵐ[volume] |
| fun x => (p.value x : ℂ) * graphPair s i j hij F x := by |
| filter_upwards [graphPair_ae s i j hij (p.apply F), graphPair_ae s i j hij F, |
| p.apply_value F s] with x hx hy hz |
| exact hx.trans ((congrArg (fun z : ℂ => z / _) hz).trans |
| ((mul_div_assoc (p.value x : ℂ) _ _).trans (congrArg (fun z : ℂ => (p.value x : ℂ) * z) hy.symm))) |
|
|
| lemma coulombFormOperator_pairing (Z : ℝ) (N : ℕ) (F G : fermionGraph N) : |
| (⟪G, coulombFormOperator Z N F⟫_ℂ).re = |
| (1 / 2 : ℝ) * (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| (⟪graphComponent s (some (i, a)) G, graphComponent s (some (i, a)) F⟫_ℂ).re) - |
| Z * (∑ s : Spins N, ∑ i : Fin N, |
| (⟪graphNuclear s i G, graphNuclear s i F⟫_ℂ).re) + |
| (∑ s : Spins N, ∑ i : Fin N, ∑ j : Fin N, |
| if hij : i < j then (⟪graphPair s i j (ne_of_lt hij) G, |
| graphPair s i j (ne_of_lt hij) F⟫_ℂ).re else 0) := by |
| have ht : (1 / 2 : ℂ) = ((1 / 2 : ℝ) : ℂ) := by norm_num |
| unfold coulombFormOperator |
| simp only [ht, add_apply, sub_apply, smul_apply, sum_apply, inner_add_right, inner_sub_right, |
| inner_smul_right, inner_sum, Complex.add_re, Complex.sub_re, Complex.mul_re, |
| Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero, Complex.re_sum, |
| ContinuousLinearMap.comp_apply, ContinuousLinearMap.adjoint_inner_right] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro s _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| split_ifs <;> simp [ContinuousLinearMap.adjoint_inner_right] |
|
|
| lemma energy_le_graphForm {Z : ℝ} (hZ : 0 ≤ Z) {N : ℕ} |
| (F : fermionGraph N) (hF : ‖fermionGraphValue N F‖ ^ 2 = 1) : |
| energy Z N ≤ (⟪F, coulombFormOperator Z N F⟫_ℂ).re := by |
| rw [coulombFormOperator_inner] |
| unfold energy |
| split_ifs with hN |
| · subst N |
| simp [formEnergy] |
| · exact csInf_le (sector_energies_bddBelow Z hZ N) |
| ⟨graphFormVector F, graphFormVector_admissible F hF, rfl⟩ |
|
|
| attribute [local irreducible] fermionGraphValue coulombFormOperator |
|
|
| theorem quantum_ground_form_equation {Z : ℝ} (hZ : 0 ≤ Z) {N : ℕ} |
| (F : fermionGraph N) (hn : ‖fermionGraphValue N F‖ ^ 2 = 1) |
| (hF : formEnergy Z (graphFormVector F) = energy Z N) (G : fermionGraph N) : |
| ⟪G, coulombFormOperator Z N F⟫_ℂ = |
| (energy Z N : ℂ) * ⟪fermionGraphValue N G, fermionGraphValue N F⟫_ℂ := by |
| have hlow : ∀ U : fermionGraph N, |
| energy Z N * ‖fermionGraphValue N U‖ ^ 2 ≤ (⟪U, coulombFormOperator Z N U⟫_ℂ).re := |
| form_lower_of_unit (fermionGraphValue N) (fermionGraphValue_injective N) |
| (coulombFormOperator Z N) (fun U hU => energy_le_graphForm hZ U hU) |
| have he : (⟪F, coulombFormOperator Z N F⟫_ℂ).re = |
| energy Z N * ‖fermionGraphValue N F‖ ^ 2 := by |
| rw [coulombFormOperator_inner, hF, hn, mul_one] |
| exact ground_form_equation (V := fermionGraph N) (H := fermionSpace N) |
| (fermionGraphValue N) (coulombFormOperator Z N) |
| (coulombFormOperator_selfAdjoint Z N) hlow he G |
|
|
| lemma FermionMultiplier.gradient_ims {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i : Fin N) (a : Fin 3) : |
| ‖graphComponent s (some (i, a)) (p.apply F)‖ ^ 2 - |
| (⟪graphComponent s (some (i, a)) (p.apply (p.apply F)), |
| graphComponent s (some (i, a)) F⟫_ℂ).re = |
| ∫ x, (lineDeriv ℝ p.value x (direction i a)) ^ 2 * |
| ‖graphComponent s none F x‖ ^ 2 := by |
| apply l2_ims_identity p.value (fun x => lineDeriv ℝ p.value x (direction i a)) |
| (graphComponent s (some (i, a)) F) (graphComponent s none F) |
| · exact p.apply_gradient F s i a |
| · filter_upwards [p.apply_gradient (p.apply F) s i a, p.apply_value F s] with x hx hy |
| exact hx.trans (congrArg (fun z : ℂ => |
| (p.value x : ℂ) * graphComponent s (some (i, a)) (p.apply F) x + |
| Complex.ofReal (lineDeriv ℝ p.value x (direction i a)) * z) hy) |
|
|
| lemma graphValue_pairing {N : ℕ} (F G : fermionGraph N) : |
| (⟪fermionGraphValue N G, fermionGraphValue N F⟫_ℂ).re = |
| ∑ s : Spins N, (⟪graphComponent s none G, graphComponent s none F⟫_ℂ).re := by |
| change (⟪(fermionGraphValue N G).val, (fermionGraphValue N F).val⟫_ℂ).re = _ |
| have hi := PiLp.inner_apply (𝕜 := ℂ) |
| (x := (fermionGraphValue N G).val) (y := (fermionGraphValue N F).val) |
| have he := congrArg Complex.re hi |
| rw [Complex.re_sum] at he |
| have hc (U : fermionGraph N) (s : Spins N) : |
| (fermionGraphValue N U).val s = graphComponent s none U := by |
| unfold fermionGraphValue graphComponent |
| rfl |
| simpa only [hc] using he |
|
|
| lemma FermionMultiplier.value_pairing {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) : |
| (⟪fermionGraphValue N (p.apply (p.apply F)), fermionGraphValue N F⟫_ℂ).re = |
| ‖fermionGraphValue N (p.apply F)‖ ^ 2 := by |
| rw [graphValue_pairing, graphValue_norm_sq] |
| apply Finset.sum_congr rfl |
| intro s _ |
| exact l2_multiplier_pairing p.value (graphComponent s none F) |
| (graphComponent s none (p.apply F)) (graphComponent s none (p.apply (p.apply F))) |
| (p.apply_value F s) (p.apply_value (p.apply F) s) |
|
|
| attribute [local irreducible] formEnergy graphFormVector |
|
|
| lemma FermionMultiplier.nuclear_pairing {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i : Fin N) : |
| (⟪graphNuclear s i (p.apply (p.apply F)), graphNuclear s i F⟫_ℂ).re = |
| ‖graphNuclear s i (p.apply F)‖ ^ 2 := |
| l2_multiplier_pairing p.value _ _ _ (p.apply_nuclear F s i) |
| (p.apply_nuclear (p.apply F) s i) |
|
|
| lemma FermionMultiplier.pair_pairing {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) (s : Spins N) (i j : Fin N) (hij : i ≠ j) : |
| (⟪graphPair s i j hij (p.apply (p.apply F)), graphPair s i j hij F⟫_ℂ).re = |
| ‖graphPair s i j hij (p.apply F)‖ ^ 2 := |
| l2_multiplier_pairing p.value _ _ _ (p.apply_pair F s i j hij) |
| (p.apply_pair (p.apply F) s i j hij) |
|
|
| lemma FermionMultiplier.kinetic_ims {N : ℕ} (p : FermionMultiplier N) |
| (F : fermionGraph N) : |
| (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| ‖graphComponent s (some (i, a)) (p.apply F)‖ ^ 2) - |
| (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| (⟪graphComponent s (some (i, a)) (p.apply (p.apply F)), |
| graphComponent s (some (i, a)) F⟫_ℂ).re) = |
| ∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| ∫ x, (lineDeriv ℝ p.value x (direction i a)) ^ 2 * |
| ‖graphComponent s none F x‖ ^ 2 := by |
| simp only [← Finset.sum_sub_distrib] |
| exact Finset.sum_congr rfl fun s _ => Finset.sum_congr rfl fun i _ => |
| Finset.sum_congr rfl fun a _ => p.gradient_ims F s i a |
|
|
| lemma coulombFormOperator_diagonal (Z : ℝ) (N : ℕ) (G : fermionGraph N) : |
| (⟪G, coulombFormOperator Z N G⟫_ℂ).re = |
| (1 / 2 : ℝ) * (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| ‖graphComponent s (some (i, a)) G‖ ^ 2) - |
| Z * (∑ s : Spins N, ∑ i : Fin N, ‖graphNuclear s i G‖ ^ 2) + |
| (∑ s : Spins N, ∑ i : Fin N, ∑ j : Fin N, |
| if hij : i < j then ‖graphPair s i j (ne_of_lt hij) G‖ ^ 2 else 0) := by |
| rw [coulombFormOperator_pairing Z N G G] |
| have hs (u : Lp ℂ 2 (volume : Measure (Configuration N))) : |
| (⟪u, u⟫_ℂ).re = ‖u‖ ^ 2 := (norm_sq_eq_re_inner (𝕜 := ℂ) u).symm |
| simp only [hs] |
|
|
| lemma FermionMultiplier.operator_pairing {N : ℕ} (p : FermionMultiplier N) |
| (Z : ℝ) (F : fermionGraph N) : |
| (⟪p.apply (p.apply F), coulombFormOperator Z N F⟫_ℂ).re = |
| (1 / 2 : ℝ) * (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| (⟪graphComponent s (some (i, a)) (p.apply (p.apply F)), |
| graphComponent s (some (i, a)) F⟫_ℂ).re) - |
| Z * (∑ s : Spins N, ∑ i : Fin N, ‖graphNuclear s i (p.apply F)‖ ^ 2) + |
| (∑ s : Spins N, ∑ i : Fin N, ∑ j : Fin N, |
| if hij : i < j then ‖graphPair s i j (ne_of_lt hij) (p.apply F)‖ ^ 2 else 0) := by |
| calc |
| _ = _ := coulombFormOperator_pairing Z N F (p.apply (p.apply F)) |
| _ = _ := by simp only [p.nuclear_pairing, p.pair_pairing] |
|
|
| private lemma ims_arithmetic (K L A B R : ℝ) (h : K - L = R) : |
| (1 / 2 * K - A + B) - (1 / 2 * L - A + B) = 1 / 2 * R := by |
| rw [← h] |
| ring |
|
|
| lemma FermionMultiplier.form_ims {N : ℕ} (p : FermionMultiplier N) |
| (Z : ℝ) (F : fermionGraph N) : |
| formEnergy Z (graphFormVector (p.apply F)) - |
| (⟪p.apply (p.apply F), coulombFormOperator Z N F⟫_ℂ).re = |
| (1 / 2 : ℝ) * (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| ∫ x, (lineDeriv ℝ p.value x (direction i a)) ^ 2 * |
| ‖graphComponent s none F x‖ ^ 2) := by |
| calc |
| _ = _ := congrArg (fun t : ℝ => t - |
| (⟪p.apply (p.apply F), coulombFormOperator Z N F⟫_ℂ).re) |
| (coulombFormOperator_inner Z N (p.apply F)).symm |
| _ = _ := congrArg₂ (fun a b : ℝ => a - b) |
| (coulombFormOperator_diagonal Z N (p.apply F)) (p.operator_pairing Z F) |
| _ = _ := ims_arithmetic _ _ _ _ _ (p.kinetic_ims F) |
|
|
| theorem quantum_ground_multiplier_smooth {Z : ℝ} (hZ : 0 ≤ Z) {N : ℕ} |
| (F : fermionGraph N) (hn : ‖fermionGraphValue N F‖ ^ 2 = 1) |
| (hF : formEnergy Z (graphFormVector F) = energy Z N) (p : FermionMultiplier N) : |
| formEnergy Z (graphFormVector (p.apply F)) - |
| energy Z N * ‖fermionGraphValue N (p.apply F)‖ ^ 2 = |
| (1 / 2 : ℝ) * (∑ s : Spins N, ∑ i : Fin N, ∑ a : Fin 3, |
| ∫ x, (lineDeriv ℝ p.value x (direction i a)) ^ 2 * |
| ‖graphComponent s none F x‖ ^ 2) := by |
| have he := congrArg Complex.re (quantum_ground_form_equation hZ F hn hF |
| (p.apply (p.apply F))) |
| simp only [Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero, |
| p.value_pairing] at he |
| rw [← he] |
| exact p.form_ims Z F |
|
|
| end CoulombAtom |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff InnerProductSpace Convolution |
|
|
| end |
|
|
| end OAI |
|
|
