| import Mathlib |
| import OAI.Analysis.CoulombIonization.Localization.CoreHistoryAverageBarrier |
| import OAI.Analysis.CoulombIonization.RadialBounds.dShellForm |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CoulombAtom |
|
|
| section |
| open MeasureTheory Filter |
| open scoped BigOperators |
| attribute [local irreducible] graphComponent graphFormVector fermionGraph weakGraph |
| FermionMultiplier.apply oneBodySquareTotal fermionGraphValue |
|
|
| lemma weightedMass_eq_integral {N : ℕ} (F : fermionGraph N) |
| (w : Configuration N → ℝ) (hm : Measurable w) {A : ℝ} (hb : ∀ x, ‖w x‖ ≤ A) : |
| weightedMass F w = ∫ x, w x ∂graphRawLaw F := by |
| have hh := rawFormPair_eq_integral (graphFormVector_sobolev F).sobolevVector hm hb |
| simpa only [rawFormPair,weightedMass,graphFormVector_value_eq,formRawLaw_graph] using hh |
|
|
| lemma graph_weight_integrable {N : ℕ} (F : fermionGraph N) |
| (w : Configuration N → ℝ) (hm : Measurable w) {A : ℝ} (hb : ∀ x, ‖w x‖ ≤ A) : |
| Integrable w (graphRawLaw F) := |
| Integrable.of_bound hm.aestronglyMeasurable A (ae_of_all _ hb) |
|
|
| lemma gradientError_eq_weightedMass {N : ℕ} (p : SmoothMultiplier spaceDirections) |
| (F : fermionGraph N) : oneBodyGradientError p F = |
| ∑ i : Fin N,∑ a : Fin 3,weightedMass F (fun x => |
| (lineDeriv ℝ p.value (x i) (spaceDirections a))^2) := by |
| unfold oneBodyGradientError weightedMass |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Finset.sum_comm] |
|
|
| def rawGradientWeight {N : ℕ} (p : SmoothMultiplier spaceDirections) |
| (x : Configuration N) : ℝ := ∑ i : Fin N, ∑ a : Fin 3, |
| (lineDeriv ℝ p.value (x i) (spaceDirections a))^2 |
| lemma rawGradientWeight_nonneg {N : ℕ} (p : SmoothMultiplier spaceDirections) |
| (x : Configuration N) : 0 ≤ rawGradientWeight p x := |
| Finset.sum_nonneg fun _ _ => Finset.sum_nonneg fun _ _ => sq_nonneg _ |
| lemma rawGradientWeight_measurable {N : ℕ} (p : SmoothMultiplier spaceDirections) : |
| Measurable (rawGradientWeight (N := N) p) := |
| Finset.measurable_sum _ (fun i _ => Finset.measurable_sum _ (fun a _ => |
| (((smooth_lineDeriv_continuous p.regular (spaceDirections a)).comp (continuous_apply i)).pow 2).measurable)) |
| lemma rawGradientWeight_le {N : ℕ} (p : SmoothMultiplier spaceDirections) {D : ℝ} |
| (hD : ∀ a x, |lineDeriv ℝ p.value x (spaceDirections a)| ≤ D) (x : Configuration N) : |
| rawGradientWeight p x ≤ 3*N*D^2 := by |
| calc |
| _ ≤ ∑ _i : Fin N, ∑ _a : Fin 3, D^2 := Finset.sum_le_sum fun i _ => |
| Finset.sum_le_sum fun a _ => by simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg _) (hD a (x i)) 2 |
| _ = _ := by simp; ring |
| lemma rawGradientWeight_integrable {N : ℕ} (p : SmoothMultiplier spaceDirections) |
| (F : fermionGraph N) {D : ℝ} (hD : ∀ a x, |lineDeriv ℝ p.value x (spaceDirections a)| ≤ D) : |
| Integrable (rawGradientWeight p) (graphRawLaw F) := |
| graph_weight_integrable F _ (rawGradientWeight_measurable p) (fun x => by |
| rw [Real.norm_of_nonneg (rawGradientWeight_nonneg p x)]; exact rawGradientWeight_le p hD x) |
|
|
| lemma gradientError_eq_integral {N : ℕ} (p : SmoothMultiplier spaceDirections) |
| (F : fermionGraph N) {D : ℝ} (hD : ∀ a x, |lineDeriv ℝ p.value x (spaceDirections a)| ≤ D) : |
| oneBodyGradientError p F = ∫ x, rawGradientWeight p x ∂graphRawLaw F := by |
| have hm (i : Fin N) (a : Fin 3) : Measurable (fun x : Configuration N => |
| (lineDeriv ℝ p.value (x i) (spaceDirections a))^2) := |
| (((smooth_lineDeriv_continuous p.regular (spaceDirections a)).comp (continuous_apply i)).pow 2).measurable |
| have hb (i : Fin N) (a : Fin 3) (x : Configuration N) : |
| ‖(lineDeriv ℝ p.value (x i) (spaceDirections a))^2‖ ≤ D^2 := by |
| rw [Real.norm_of_nonneg (sq_nonneg _)] |
| simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg _) (hD a (x i)) 2 |
| have hi (i : Fin N) (a : Fin 3) := graph_weight_integrable F _ (hm i a) (hb i a) |
| rw [gradientError_eq_weightedMass] |
| simp_rw [weightedMass_eq_integral F _ (hm _ _) (hb _ _)] |
| unfold rawGradientWeight |
| rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun a _ => hi i a))] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact (integral_finsetSum _ (fun a _ => hi i a)).symm |
|
|
| end |
| open MeasureTheory Filter |
| open scoped BigOperators |
| attribute [local irreducible] graphComponent fermionGraph weakGraph FermionMultiplier.apply |
|
|
| lemma graph_sum_value {α : Type*} {N : ℕ} (T : Finset α) (G : α → fermionGraph N) (s : Spins N) : |
| ∀ᵐ x, graphComponent s none (∑ k ∈ T, G k) x = ∑ k ∈ T, graphComponent s none (G k) x := by |
| have he := map_sum (graphComponent s none) G T |
| rw [he] |
| exact l2_coe_finset_sum volume T (fun k => graphComponent s none (G k)) |
|
|
| lemma graph_sub_value {N : ℕ} (F G : fermionGraph N) (s : Spins N) : |
| ∀ᵐ x, graphComponent s none (F-G) x = graphComponent s none F x-graphComponent s none G x := by |
| have he := map_sub (graphComponent s none) F G |
| rw [he] |
| exact Lp.coeFn_sub _ _ |
|
|
| lemma finite_apply_sum_value {α : Type*} {N : ℕ} (T : Finset α) |
| (p : α → FermionMultiplier N) (F : fermionGraph N) (s : Spins N) : |
| ∀ᵐ x, graphComponent s none (∑ k ∈ T, (p k).apply F) x = |
| ((∑ k ∈ T, (p k).value x : ℝ) : ℂ)*graphComponent s none F x := by |
| classical |
| have ha : ∀ᵐ x : Configuration N, ∀ k ∈ T, |
| graphComponent s none ((p k).apply F) x = ((p k).value x : ℂ)*graphComponent s none F x := by |
| apply (ae_ball_iff T.finite_toSet.countable).mpr |
| intro k hk |
| exact (p k).apply_value F s |
| filter_upwards [ha,graph_sum_value T (fun k => (p k).apply F) s] with x ha hx |
| calc |
| _ = ∑ k ∈ T, graphComponent s none ((p k).apply F) x := hx |
| _ = ∑ k ∈ T, ((p k).value x : ℂ)*graphComponent s none F x := Finset.sum_congr rfl ha |
| _ = (∑ k ∈ T, ((p k).value x : ℂ))*graphComponent s none F x := (Finset.sum_mul ..).symm |
| _ = _ := congrArg (fun z : ℂ => z*graphComponent s none F x) (Complex.ofReal_sum _ _).symm |
|
|
| lemma ofReal_sub_mul_complex (a b : ℝ) (z : ℂ) : |
| ((a-b:ℝ):ℂ)*z = (a:ℂ)*z-(b:ℂ)*z := by rw [Complex.ofReal_sub,sub_mul] |
|
|
| lemma finite_apply_sum_eq_sub {α : Type*} {N : ℕ} (T : Finset α) |
| (p : α → FermionMultiplier N) (q t : FermionMultiplier N) |
| (he : ∀ x, (∑ k ∈ T, (p k).value x) = q.value x-t.value x) (F : fermionGraph N) : |
| (∑ k ∈ T, (p k).apply F) = q.apply F-t.apply F := by |
| classical |
| apply graph_value_components_ext |
| intro s |
| apply Lp.ext |
| filter_upwards [finite_apply_sum_value T p F s, |
| graph_sub_value (q.apply F) (t.apply F) s,q.apply_value F s,t.apply_value F s] with x hx hs hq ht |
| calc |
| _ = ((∑ k ∈ T, (p k).value x : ℝ) : ℂ)*graphComponent s none F x := hx |
| _ = ((q.value x-t.value x : ℝ) : ℂ)*graphComponent s none F x := congrArg (fun z : ℝ => (z:ℂ)*graphComponent s none F x) (he x) |
| _ = (q.value x : ℂ)*graphComponent s none F x-(t.value x : ℂ)*graphComponent s none F x := ofReal_sub_mul_complex _ _ _ |
| _ = graphComponent s none ((q.apply F)-(t.apply F)) x := (congrArg₂ (fun a b : ℂ => a-b) hq ht).symm.trans hs.symm |
|
|
| end CoulombAtom |
|
|
| end |
|
|
| end OAI |
|
|
