| 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 |
|
|
