File size: 8,613 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 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | import Mathlib
import OAI.Analysis.CoulombIonization.Model
import OAI.Analysis.CoulombIonization.FormDomain.WeakDerivative
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 WeakChangeVariables
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
[FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E]
omit [FiniteDimensional ℝ E] in
lemma IsWeakDerivative.comp_linearEquiv {v w : E} {f g : E → ℂ}
(hw : IsWeakDerivative v f g) (e : E ≃L[ℝ] E)
(he : MeasurePreserving e) (hv : e w = v) :
IsWeakDerivative w (f ∘ e) (g ∘ e) := by
intro φ hφ hcφ
let ψ : E → ℝ := φ ∘ e.symm
have hψ : ContDiff ℝ ∞ ψ := hφ.comp e.symm.contDiff
have hcψ : HasCompactSupport ψ := hcφ.comp_homeomorph e.symm.toHomeomorph
have hev : e.symm v = w := by rw [← hv, e.symm_apply_apply]
have hd (x : E) : lineDeriv ℝ ψ (e x) v = lineDeriv ℝ φ x w := by
rw [(hψ.differentiable (by simp) (e x)).lineDeriv_eq_fderiv,
(hφ.differentiable (by simp) x).lineDeriv_eq_fderiv]
have hh := (hφ.differentiable (by simp) (e.symm (e x))).hasFDerivAt.comp
(e x) (e.symm.hasFDerivAt)
have hh' := congrArg (fun A : E →L[ℝ] ℝ => A v) hh.fderiv
simpa only [ContinuousLinearMap.comp_apply, ContinuousLinearEquiv.coe_coe,
e.symm_apply_apply, hev] using hh'
have hi1 : (∫ x, f (e x) * Complex.ofReal (lineDeriv ℝ ψ (e x) v)) =
∫ x, f x * Complex.ofReal (lineDeriv ℝ ψ x v) :=
he.integral_comp e.toHomeomorph.measurableEmbedding
(fun x => f x * Complex.ofReal (lineDeriv ℝ ψ x v))
have hi2 : (∫ x, g (e x) * (ψ (e x) : ℂ)) = ∫ x, g x * (ψ x : ℂ) :=
he.integral_comp e.toHomeomorph.measurableEmbedding
(fun x => g x * (ψ x : ℂ))
have hh := hw ψ hψ hcψ
rw [← hi1, ← hi2] at hh
simpa only [hd, ψ, Function.comp_apply, e.symm_apply_apply] using hh
end WeakChangeVariables
section WeakGraphChange
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
[FiniteDimensional ℝ E] [MeasureSpace E] [BorelSpace E]
[IsLocallyFiniteMeasure (volume : Measure E)]
variable {ι : Type*} [Fintype ι]
def weakGraphChangeAmbient (v : ι → E) (e : E ≃L[ℝ] E) (he : MeasurePreserving e)
(κ : ι → ι) : weakGraph v →L[ℂ] WeakGraphAmbient E ι :=
(PiLp.continuousLinearEquiv 2 ℂ (fun _ : Option ι => Lp ℂ 2 (volume : Measure E))
).symm.toContinuousLinearMap.comp
(ContinuousLinearMap.pi fun j =>
(Lp.compMeasurePreservingₗᵢ ℂ e he).toContinuousLinearMap.comp
((PiLp.proj 2 (fun _ : Option ι => Lp ℂ 2 (volume : Measure E)) (j.map κ)).comp
(weakGraph v).subtypeL))
omit [Fintype ι] in
lemma weakGraphChangeAmbient_mem (v : ι → E) (e : E ≃L[ℝ] E) (he : MeasurePreserving e)
(κ : ι → ι) (hv : ∀ i, e (v i) = v (κ i)) (F : weakGraph v) :
weakGraphChangeAmbient v e he κ F ∈ weakGraph v := by
rw [mem_weakGraph]
intro i
have hh := ((mem_weakGraph v F.val).mp F.property (κ i)).comp_linearEquiv e he (hv i)
exact hh.congr_ae (Lp.coeFn_compMeasurePreserving (F.val none) he).symm
(Lp.coeFn_compMeasurePreserving (F.val (some (κ i))) he).symm
def weakGraphChange (v : ι → E) (e : E ≃L[ℝ] E) (he : MeasurePreserving e)
(κ : ι → ι) (hv : ∀ i, e (v i) = v (κ i)) : weakGraph v →L[ℂ] weakGraph v :=
(weakGraphChangeAmbient v e he κ).codRestrict (weakGraph v)
(weakGraphChangeAmbient_mem v e he κ hv)
end WeakGraphChange
abbrev SectorHilbert (N : ℕ) := PiLp 2 (fun _ : Spins N => Lp ℂ 2 (volume : Measure (Configuration N)))
def permuteConfiguration {N : ℕ} (π : Equiv.Perm (Fin N)) : Configuration N ≃L[ℝ] Configuration N :=
ContinuousLinearEquiv.piCongrLeft ℝ (fun _ : Fin N => Space) π.symm
@[simp] lemma permuteConfiguration_apply {N : ℕ} (π : Equiv.Perm (Fin N)) (x : Configuration N) :
permuteConfiguration π x = x ∘ π := by
ext i
simp [permuteConfiguration, ContinuousLinearEquiv.piCongrLeft, Equiv.piCongrLeft]
lemma permuteConfiguration_preserving {N : ℕ} (π : Equiv.Perm (Fin N)) :
MeasurePreserving (permuteConfiguration π) := by
exact volume_measurePreserving_piCongrLeft (fun _ : Fin N => Space) π.symm
def fermionPermutation {N : ℕ} (π : Equiv.Perm (Fin N)) : SectorHilbert N →L[ℂ] SectorHilbert N :=
(PiLp.continuousLinearEquiv 2 ℂ (fun _ : Spins N => Lp ℂ 2 (volume : Measure (Configuration N)))
).symm.toContinuousLinearMap.comp
(ContinuousLinearMap.pi fun s =>
((((Equiv.Perm.sign π : ℤ) : ℂ)) •
(Lp.compMeasurePreservingₗᵢ ℂ (permuteConfiguration π)
(permuteConfiguration_preserving π)).toContinuousLinearMap).comp
(PiLp.proj 2 (fun _ : Spins N => Lp ℂ 2 (volume : Measure (Configuration N))) (s ∘ π)))
def fermionSpace (N : ℕ) : Submodule ℂ (SectorHilbert N) :=
⨅ π : Equiv.Perm (Fin N), (fermionPermutation π - ContinuousLinearMap.id ℂ _).ker
lemma mem_fermionSpace {N : ℕ} (F : SectorHilbert N) :
F ∈ fermionSpace N ↔ ∀ π : Equiv.Perm (Fin N), fermionPermutation π F = F := by
simp [fermionSpace, sub_eq_zero]
lemma fermionSpace_isClosed (N : ℕ) : IsClosed (fermionSpace N : Set (SectorHilbert N)) := by
simp only [fermionSpace, Submodule.coe_iInf]
exact isClosed_iInter fun π => (fermionPermutation π - ContinuousLinearMap.id ℂ _).isClosed_ker
instance fermionSpace_completeSpace (N : ℕ) : CompleteSpace (fermionSpace N) :=
(fermionSpace_isClosed N).completeSpace_coe
abbrev sectorDirections (N : ℕ) : Fin N × Fin 3 → Configuration N := fun k => direction k.1 k.2
instance weakSectorGraph_normedAddCommGroup (N : ℕ) : NormedAddCommGroup (weakGraph (sectorDirections N)) :=
Submodule.normedAddCommGroup _
instance weakSectorGraph_innerProductSpace (N : ℕ) : InnerProductSpace ℂ (weakGraph (sectorDirections N)) :=
Submodule.innerProductSpace _
instance weakSectorGraph_normedSpace (N : ℕ) : NormedSpace ℂ (weakGraph (sectorDirections N)) :=
Submodule.normedSpace _
abbrev SectorGraph (N : ℕ) := PiLp 2 (fun _ : Spins N => weakGraph (sectorDirections N))
instance sectorGraph_normedAddCommGroup (N : ℕ) : NormedAddCommGroup (SectorGraph N) :=
PiLp.normedAddCommGroup 2 _
instance sectorGraph_innerProductSpace (N : ℕ) : InnerProductSpace ℂ (SectorGraph N) :=
PiLp.innerProductSpace _
instance sectorGraph_normedSpace (N : ℕ) : NormedSpace ℂ (SectorGraph N) :=
PiLp.normedSpace 2 ℂ _
def sectorGraphValue (N : ℕ) : SectorGraph N →L[ℂ] SectorHilbert N :=
(PiLp.continuousLinearEquiv 2 ℂ (fun _ : Spins N => Lp ℂ 2 (volume : Measure (Configuration N)))
).symm.toContinuousLinearMap.comp
(ContinuousLinearMap.pi fun s => (weakGraphValue (sectorDirections N)).comp
(PiLp.proj 2 (fun _ : Spins N => weakGraph (sectorDirections N)) s))
@[simp] lemma sectorGraphValue_apply {N : ℕ} (F : SectorGraph N) (s : Spins N) :
sectorGraphValue N F s = (F s).val none := rfl
lemma sectorGraphValue_injective (N : ℕ) : Function.Injective (sectorGraphValue N) := by
intro F G hFG
apply PiLp.ext
intro s
apply weakGraphValue_injective (sectorDirections N)
exact congrArg (fun h : SectorHilbert N => h s) hFG
def fermionGraph (N : ℕ) : Submodule ℂ (SectorGraph N) :=
(fermionSpace N).comap (sectorGraphValue N).toLinearMap
instance fermionGraph_normedAddCommGroup (N : ℕ) : NormedAddCommGroup (fermionGraph N) :=
Submodule.normedAddCommGroup _
instance fermionGraph_innerProductSpace (N : ℕ) : InnerProductSpace ℂ (fermionGraph N) :=
Submodule.innerProductSpace _
instance fermionGraph_normedSpace (N : ℕ) : NormedSpace ℂ (fermionGraph N) :=
Submodule.normedSpace _
lemma fermionGraph_isClosed (N : ℕ) : IsClosed (fermionGraph N : Set (SectorGraph N)) :=
(fermionSpace_isClosed N).preimage (sectorGraphValue N).continuous
instance fermionGraph_completeSpace (N : ℕ) : CompleteSpace (fermionGraph N) :=
(fermionGraph_isClosed N).completeSpace_coe
def fermionGraphValue (N : ℕ) : fermionGraph N →L[ℂ] fermionSpace N :=
((sectorGraphValue N).comp (fermionGraph N).subtypeL).codRestrict (fermionSpace N)
(fun F => F.property)
lemma fermionGraphValue_injective (N : ℕ) : Function.Injective (fermionGraphValue N) := by
intro F G hFG
apply Subtype.ext
apply sectorGraphValue_injective N
exact congrArg Subtype.val hFG
end CoulombAtom
end
end OAI
|