File size: 7,149 Bytes
159357f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | 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
|