| import Mathlib |
| import OAI.Analysis.CoulombIonization.FormDomain.Restriction |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CoulombAtom |
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
| open MeasureTheory Filter |
| open scoped Topology BigOperators InnerProductSpace |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff InnerProductSpace |
| open MeasureTheory Filter |
| open scoped Topology BigOperators ContDiff InnerProductSpace |
| section Sum |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E] |
| [(volume : Measure E).IsAddHaarMeasure] |
| variable {ι α : Type*} [Fintype ι] [Fintype α] {v : ι → E} |
|
|
| omit [FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E] |
| [(volume : Measure E).IsAddHaarMeasure] [Fintype ι] in |
| lemma lineDeriv_sumSquares (p : α → SmoothMultiplier v) (x d : E) : |
| lineDeriv ℝ (fun y => ∑ i, (p i).value y ^ 2) x d = |
| ∑ i, 2 * (p i).value x * lineDeriv ℝ (p i).value x d := by |
| have hd (i : α) := ((p i).regular.differentiable (by simp) x).hasFDerivAt.pow 2 |
| have hh := (HasFDerivAt.sum (u := Finset.univ) (fun i _ => hd i)).hasLineDerivAt d |
| have he := hh.lineDeriv |
| simp only [sum_apply, smul_apply, smul_eq_mul, Nat.reduceSub, |
| pow_one, nsmul_eq_mul, Nat.cast_ofNat] at he |
| convert he using 1 |
| · congr 1 |
| funext y |
| simp only [Finset.sum_apply] |
| · apply Finset.sum_congr rfl; intro i _ |
| rw [((p i).regular.differentiable (by simp) x).lineDeriv_eq_fderiv] |
|
|
| def SmoothMultiplier.sumSquares (p : α → SmoothMultiplier v) : SmoothMultiplier v where |
| value := fun x => ∑ i, (p i).value x ^ 2 |
| regular := ContDiff.sum (fun i _ => (p i).regular.pow 2) |
| bound := by |
| choose C hC using fun i => (p i).bound |
| refine ⟨∑ i, C i ^ 2, fun x => ?_⟩ |
| rw [abs_of_nonneg (Finset.sum_nonneg fun i _ => sq_nonneg _)] |
| apply Finset.sum_le_sum; intro i _ |
| exact (sq_le_sq₀ (abs_nonneg _) (le_trans (abs_nonneg _) (hC i x))).mpr (hC i x) |> |
| fun h => by simpa only [sq_abs] using h |
| gradient_bound := by |
| intro j |
| choose C hC using fun i => (p i).bound |
| choose D hD using fun i => (p i).gradient_bound j |
| refine ⟨∑ i, 2 * C i * D i, fun x => ?_⟩ |
| rw [lineDeriv_sumSquares] |
| calc |
| _ ≤ ∑ i, |2 * (p i).value x * lineDeriv ℝ (p i).value x (v j)| := |
| Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ _ := by |
| apply Finset.sum_le_sum; intro i _ |
| rw [abs_mul, abs_mul, abs_of_pos (by norm_num : (0:ℝ) < 2)] |
| exact mul_le_mul (mul_le_mul_of_nonneg_left (hC i x) (by norm_num)) |
| (hD i x) (abs_nonneg _) (by linarith [abs_nonneg ((p i).value x), hC i x]) |
|
|
| end Sum |
|
|
| def bindingTotalMultiplier {N : ℕ} {R ε : ℝ} (hR : 0 < R) (hε : 0 < ε) : |
| FermionMultiplier N where |
| toSmoothMultiplier := SmoothMultiplier.sumSquares (bindingMultiplier hR hε) |
| symmetric := by |
| intro π x |
| change (∑ i, bindingRoot R ε ((x ∘ π) i) ^ 2) = ∑ i, bindingRoot R ε (x i) ^ 2 |
| exact Equiv.sum_comp π (fun i => bindingRoot R ε (x i) ^ 2) |
|
|
| lemma bindingTotalMultiplier_value {N : ℕ} {R ε : ℝ} (hR : 0 < R) (hε : 0 < ε) |
| (x : Configuration N) : (bindingTotalMultiplier hR hε).value x = |
| ∑ i, bindingWeight R ε (x i) := by |
| change (∑ i, bindingRoot R ε (x i) ^ 2) = _ |
| simp only [bindingRoot_sq hR hε] |
|
|
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators |
|
|
| lemma l2_coe_finset_sum {X α : Type*} [MeasurableSpace X] (μ : Measure X) |
| (s : Finset α) (f : α → Lp ℂ 2 μ) : |
| ((∑ i ∈ s, f i : Lp ℂ 2 μ) : X → ℂ) =ᵐ[μ] fun x => ∑ i ∈ s, f i x := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => |
| simp only [Finset.sum_empty] |
| filter_upwards [Lp.coeFn_zero ℂ 2 μ] with x hx |
| exact hx |
| | @insert a s ha ih => |
| simp only [Finset.sum_insert ha] |
| filter_upwards [Lp.coeFn_add (f a) (∑ i ∈ s, f i), ih] with x hx hy |
| simp only [Pi.add_apply] at hx |
| rw [hx, hy] |
|
|
| section Sum |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E] |
| [(volume : Measure E).IsAddHaarMeasure] |
| variable {ι α : Type*} [Fintype ι] [Fintype α] {v : ι → E} |
|
|
| omit [Fintype ι] in |
| lemma SmoothMultiplier.sumSquares_apply (p : α → SmoothMultiplier v) (F : weakGraph v) : |
| (SmoothMultiplier.sumSquares p).apply F = ∑ i, (p i).apply ((p i).apply F) := by |
| apply weakGraphValue_injective v |
| rw [map_sum] |
| apply Lp.ext |
| have ha : ∀ᵐ x : E, ∀ i : α, |
| ((p i).apply ((p i).apply F)).val none x = |
| ((p i).value x : ℂ) * ((p i).value x : ℂ) * F.val none x := by |
| apply ae_all_iff.mpr; intro i |
| filter_upwards [(p i).apply_value ((p i).apply F), (p i).apply_value F] with x hx hy |
| rw [hx, hy, mul_assoc] |
| filter_upwards [(SmoothMultiplier.sumSquares p).apply_value F, ha, |
| l2_coe_finset_sum volume Finset.univ |
| (fun i => weakGraphValue v ((p i).apply ((p i).apply F)))] with x hx hy hz |
| change ((SmoothMultiplier.sumSquares p).apply F).val none x = _ |
| rw [hx, hz] |
| change (((∑ i, (p i).value x ^ 2 : ℝ) : ℂ) * F.val none x) = _ |
| simp only [Complex.ofReal_sum, Complex.ofReal_pow, Finset.sum_mul] |
| apply Finset.sum_congr rfl; intro i _ |
| change ((p i).value x : ℂ) ^ 2 * F.val none x = |
| ((p i).apply ((p i).apply F)).val none x |
| rw [hy i, pow_two] |
|
|
| omit [Fintype ι] in |
| lemma weakGraph_sum_component (G : α → weakGraph v) (k : Option ι) : |
| (∑ i, G i).val k = ∑ i, (G i).val k := by |
| rw [Submodule.coe_sum, WithLp.ofLp_sum, Finset.sum_apply] |
|
|
| end Sum |
|
|
| lemma bindingTotalMultiplier_component {N : ℕ} {R ε : ℝ} (hR : 0 < R) (hε : 0 < ε) |
| (F : fermionGraph N) (s : Spins N) (k : Option (Fin N × Fin 3)) : |
| graphComponent s k ((bindingTotalMultiplier hR hε).apply F) = |
| ∑ i, ((bindingMultiplier hR hε i).apply ((bindingMultiplier hR hε i).apply (F.val s))).val k := by |
| change ((SmoothMultiplier.sumSquares (bindingMultiplier hR hε)).apply (F.val s)).val k = _ |
| rw [SmoothMultiplier.sumSquares_apply, weakGraph_sum_component] |
|
|
|
|
| open MeasureTheory Filter |
| open scoped Topology BigOperators InnerProductSpace |
|
|
| end CoulombAtom |
|
|
| end |
|
|
| end OAI |
|
|
