Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Analysis.HardSphere.Model

namespace OAI

noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology BigOperators
namespace HardSphere

lemma coordDerivative_add {N : ℕ} {L : Length} {a : ℝ}
    (f g : SmoothTest N L a) (p : Direction N) :
    coordDerivative N L (f.toFun + g.toFun) p =
      coordDerivative N L f.toFun p + coordDerivative N L g.toFun p := by
  funext X
  simp only [coordDerivative, Pi.add_apply]
  rw [fderiv_fun_add (f.smooth.differentiable (by simp)).differentiableAt
    (g.smooth.differentiable (by simp)).differentiableAt]
  rfl

lemma coordDerivative_smul {N : ℕ} {L : Length} {a : ℝ}
    (c : ℂ) (f : SmoothTest N L a) (p : Direction N) :
    coordDerivative N L (c • f.toFun) p = c • coordDerivative N L f.toFun p := by
  funext X
  simp only [coordDerivative, Pi.smul_apply]
  rw [fderiv_fun_const_smul (f.smooth.differentiable (by simp)).differentiableAt c]
  rfl

lemma coordDerivative_zero (N : ℕ) (L : Length) (p : Direction N) :
    coordDerivative N L 0 p = 0 := by
  funext X
  simp [coordDerivative]

def SmoothTest.zero (N : ℕ) (L : Length) (a : ℝ) : SmoothTest N L a where
  toFun := 0
  smooth := contDiff_const
  compact := HasCompactSupport.zero
  support_allowed := by simp
  memLp := MemLp.zero
  partial_memLp := by
    intro p
    rw [coordDerivative_zero]
    exact MemLp.zero

def SmoothTest.add {N : ℕ} {L : Length} {a : ℝ}
    (f g : SmoothTest N L a) : SmoothTest N L a where
  toFun := f.toFun + g.toFun
  smooth := f.smooth.add g.smooth
  compact := f.compact.add g.compact
  support_allowed := (tsupport_add _ _).trans (union_subset f.support_allowed g.support_allowed)
  memLp := f.memLp.add g.memLp
  partial_memLp := by
    intro p
    rw [coordDerivative_add]
    exact (f.partial_memLp p).add (g.partial_memLp p)

def SmoothTest.smul {N : ℕ} {L : Length} {a : ℝ}
    (c : ℂ) (f : SmoothTest N L a) : SmoothTest N L a where
  toFun := c • f.toFun
  smooth := f.smooth.const_smul c
  compact := f.compact.smul_left
  support_allowed := (tsupport_smul_subset_right (fun _ ↦ c) f.toFun).trans f.support_allowed
  memLp := f.memLp.const_smul c
  partial_memLp := by
    intro p
    rw [coordDerivative_smul]
    exact (f.partial_memLp p).const_smul c

@[simp] lemma SmoothTest.jet_zero (N : ℕ) (L : Length) (a : ℝ) :
    (SmoothTest.zero N L a).jet = 0 := by
  apply Prod.ext
  · rfl
  · funext p
    change MemLp.toLp (coordDerivative N L 0 p) ((SmoothTest.zero N L a).partial_memLp p) = 0
    simp only [coordDerivative_zero, MemLp.toLp_zero]

@[simp] lemma SmoothTest.jet_add {N : ℕ} {L : Length} {a : ℝ}
    (f g : SmoothTest N L a) : (f.add g).jet = f.jet + g.jet := by
  apply Prod.ext
  · rfl
  · funext p
    change _ = (f.partial_memLp p).toLp _ + (g.partial_memLp p).toLp _
    rw [← MemLp.toLp_add]
    refine MemLp.toLp_congr ((f.add g).partial_memLp p)
      ((f.partial_memLp p).add (g.partial_memLp p)) ?_
    exact Filter.Eventually.of_forall (congrFun (coordDerivative_add f g p))

@[simp] lemma SmoothTest.jet_smul {N : ℕ} {L : Length} {a : ℝ}
    (c : ℂ) (f : SmoothTest N L a) : (f.smul c).jet = c • f.jet := by
  apply Prod.ext
  · rfl
  · funext p
    change _ = c • (f.partial_memLp p).toLp _
    rw [← MemLp.toLp_const_smul]
    refine MemLp.toLp_congr ((f.smul c).partial_memLp p)
      ((f.partial_memLp p).const_smul c) ?_
    exact Filter.Eventually.of_forall (congrFun (coordDerivative_smul c f p))

def smoothGraph (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) where
  carrier := Set.range (SmoothTest.jet (N := N) (L := L) (a := a))
  zero_mem' := ⟨SmoothTest.zero N L a, SmoothTest.jet_zero N L a⟩
  add_mem' := by
    rintro _ _ ⟨f, rfl⟩ ⟨g, rfl⟩
    exact ⟨f.add g, f.jet_add g⟩
  smul_mem' := by
    rintro c _ ⟨f, rfl⟩
    exact ⟨f.smul c, f.jet_smul c⟩
def dirichletSubmodule (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) :=
  (smoothGraph N L a).topologicalClosure
@[simp] lemma mem_dirichletSubmodule {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} :
    u ∈ dirichletSubmodule N L a ↔ u ∈ dirichletDomain N L a := Iff.rfl
def permuteConfiguration {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N))
    (X : Configuration N L) : Configuration N L := fun i ↦ X (σ i)
lemma measurePreserving_permute {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N)) :
    MeasurePreserving (permuteConfiguration (L := L) σ) volume volume := by
  have h := volume_measurePreserving_piCongrLeft (fun _ : Fin N ↦ Torus L) σ.symm
  convert h using 1
  funext X i
  simp [permuteConfiguration, MeasurableEquiv.coe_piCongrLeft, Equiv.piCongrLeft_apply]
section
attribute [local instance] scalarL2_addCommMonoid scalarL2_module
def permutationPullback {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N)) :
    ScalarL2 N L →ₗ[ℂ] ScalarL2 N L :=
  Lp.compMeasurePreservingₗ ℂ _ (measurePreserving_permute σ)
end
lemma bosonic_iff_pullback {N : ℕ} {L : Length} (ψ : ScalarL2 N L) :
    bosonic ψ ↔ ∀ σ, permutationPullback σ ψ = ψ := by
  have hae (σ : Equiv.Perm (Fin N)) :
      (permutationPullback σ ψ : Configuration N L → ℂ) =ᵐ[volume]
        fun X ↦ ψ (permuteConfiguration σ X) :=
    Lp.coeFn_compMeasurePreserving ψ (measurePreserving_permute σ)
  constructor
  · intro h σ
    exact Lp.ext ((hae σ).trans (h σ))
  · intro h σ
    have hh := hae σ
    rw [h σ] at hh
    exact hh.symm
section
attribute [local instance] scalarL2_normedAddCommGroup scalarL2_module
def bosonicSubmodule (N : ℕ) (L : Length) : Submodule ℂ (ScalarL2 N L) :=
  ⨅ σ : Equiv.Perm (Fin N),
    @LinearMap.ker ℂ ℂ (ScalarL2 N L) (ScalarL2 N L)
      Complex.instSemiring Complex.instSemiring
      (scalarL2_normedAddCommGroup N L).toAddCommMonoid
      (scalarL2_normedAddCommGroup N L).toAddCommMonoid
      (scalarL2_module N L) (scalarL2_module N L) (RingHom.id ℂ)
      (@HSub.hSub _ _ _
        (@instHSub _ (@LinearMap.instSub ℂ ℂ (ScalarL2 N L) (ScalarL2 N L)
          Complex.instSemiring Complex.instSemiring
          (scalarL2_normedAddCommGroup N L).toAddCommMonoid
          (scalarL2_normedAddCommGroup N L).toAddCommGroup
          (scalarL2_module N L) (scalarL2_module N L) (RingHom.id ℂ)))
        (permutationPullback σ)
        (@LinearMap.id ℂ (ScalarL2 N L) Complex.instSemiring
          (scalarL2_normedAddCommGroup N L).toAddCommMonoid (scalarL2_module N L)))
@[simp] lemma mem_bosonicSubmodule {N : ℕ} {L : Length} {ψ : ScalarL2 N L} :
    ψ ∈ bosonicSubmodule N L ↔ bosonic ψ := by
  simp only [bosonicSubmodule, Submodule.mem_iInf, LinearMap.mem_ker,
    LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
  exact (bosonic_iff_pullback ψ).symm
end
def groundFormSubmodule (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) :=
  dirichletSubmodule N L a ⊓
    (bosonicSubmodule N L).comap (LinearMap.fst ℂ (ScalarL2 N L) (Direction N → ScalarL2 N L))
@[simp] lemma mem_groundFormSubmodule {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} :
    u ∈ groundFormSubmodule N L a ↔ u ∈ dirichletDomain N L a ∧ bosonic u.1 := by
  simp [groundFormSubmodule]
end HardSphere
end
end OAI

	import Mathlib
	import OAI.Analysis.HardSphere.Model

	namespace OAI

	noncomputable section
	open MeasureTheory Filter Set
	open scoped ENNReal Topology BigOperators
	namespace HardSphere

	lemma coordDerivative_add {N : ℕ} {L : Length} {a : ℝ}
	(f g : SmoothTest N L a) (p : Direction N) :
	coordDerivative N L (f.toFun + g.toFun) p =
	coordDerivative N L f.toFun p + coordDerivative N L g.toFun p := by
	funext X
	simp only [coordDerivative, Pi.add_apply]
	rw [fderiv_fun_add (f.smooth.differentiable (by simp)).differentiableAt
	(g.smooth.differentiable (by simp)).differentiableAt]
	rfl

	lemma coordDerivative_smul {N : ℕ} {L : Length} {a : ℝ}
	(c : ℂ) (f : SmoothTest N L a) (p : Direction N) :
	coordDerivative N L (c • f.toFun) p = c • coordDerivative N L f.toFun p := by
	funext X
	simp only [coordDerivative, Pi.smul_apply]
	rw [fderiv_fun_const_smul (f.smooth.differentiable (by simp)).differentiableAt c]
	rfl

	lemma coordDerivative_zero (N : ℕ) (L : Length) (p : Direction N) :
	coordDerivative N L 0 p = 0 := by
	funext X
	simp [coordDerivative]

	def SmoothTest.zero (N : ℕ) (L : Length) (a : ℝ) : SmoothTest N L a where
	toFun := 0
	smooth := contDiff_const
	compact := HasCompactSupport.zero
	support_allowed := by simp
	memLp := MemLp.zero
	partial_memLp := by
	intro p
	rw [coordDerivative_zero]
	exact MemLp.zero

	def SmoothTest.add {N : ℕ} {L : Length} {a : ℝ}
	(f g : SmoothTest N L a) : SmoothTest N L a where
	toFun := f.toFun + g.toFun
	smooth := f.smooth.add g.smooth
	compact := f.compact.add g.compact
	support_allowed := (tsupport_add _ _).trans (union_subset f.support_allowed g.support_allowed)
	memLp := f.memLp.add g.memLp
	partial_memLp := by
	intro p
	rw [coordDerivative_add]
	exact (f.partial_memLp p).add (g.partial_memLp p)

	def SmoothTest.smul {N : ℕ} {L : Length} {a : ℝ}
	(c : ℂ) (f : SmoothTest N L a) : SmoothTest N L a where
	toFun := c • f.toFun
	smooth := f.smooth.const_smul c
	compact := f.compact.smul_left
	support_allowed := (tsupport_smul_subset_right (fun _ ↦ c) f.toFun).trans f.support_allowed
	memLp := f.memLp.const_smul c
	partial_memLp := by
	intro p
	rw [coordDerivative_smul]
	exact (f.partial_memLp p).const_smul c

	@[simp] lemma SmoothTest.jet_zero (N : ℕ) (L : Length) (a : ℝ) :
	(SmoothTest.zero N L a).jet = 0 := by
	apply Prod.ext
	· rfl
	· funext p
	change MemLp.toLp (coordDerivative N L 0 p) ((SmoothTest.zero N L a).partial_memLp p) = 0
	simp only [coordDerivative_zero, MemLp.toLp_zero]

	@[simp] lemma SmoothTest.jet_add {N : ℕ} {L : Length} {a : ℝ}
	(f g : SmoothTest N L a) : (f.add g).jet = f.jet + g.jet := by
	apply Prod.ext
	· rfl
	· funext p
	change _ = (f.partial_memLp p).toLp _ + (g.partial_memLp p).toLp _
	rw [← MemLp.toLp_add]
	refine MemLp.toLp_congr ((f.add g).partial_memLp p)
	((f.partial_memLp p).add (g.partial_memLp p)) ?_
	exact Filter.Eventually.of_forall (congrFun (coordDerivative_add f g p))

	@[simp] lemma SmoothTest.jet_smul {N : ℕ} {L : Length} {a : ℝ}
	(c : ℂ) (f : SmoothTest N L a) : (f.smul c).jet = c • f.jet := by
	apply Prod.ext
	· rfl
	· funext p
	change _ = c • (f.partial_memLp p).toLp _
	rw [← MemLp.toLp_const_smul]
	refine MemLp.toLp_congr ((f.smul c).partial_memLp p)
	((f.partial_memLp p).const_smul c) ?_
	exact Filter.Eventually.of_forall (congrFun (coordDerivative_smul c f p))

	def smoothGraph (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) where
	carrier := Set.range (SmoothTest.jet (N := N) (L := L) (a := a))
	zero_mem' := ⟨SmoothTest.zero N L a, SmoothTest.jet_zero N L a⟩
	add_mem' := by
	rintro _ _ ⟨f, rfl⟩ ⟨g, rfl⟩
	exact ⟨f.add g, f.jet_add g⟩
	smul_mem' := by
	rintro c _ ⟨f, rfl⟩
	exact ⟨f.smul c, f.jet_smul c⟩

	def dirichletSubmodule (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) :=
	(smoothGraph N L a).topologicalClosure

	@[simp] lemma mem_dirichletSubmodule {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} :
	u ∈ dirichletSubmodule N L a ↔ u ∈ dirichletDomain N L a := Iff.rfl

	def permuteConfiguration {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N))
	(X : Configuration N L) : Configuration N L := fun i ↦ X (σ i)

	lemma measurePreserving_permute {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N)) :
	MeasurePreserving (permuteConfiguration (L := L) σ) volume volume := by
	have h := volume_measurePreserving_piCongrLeft (fun _ : Fin N ↦ Torus L) σ.symm
	convert h using 1
	funext X i
	simp [permuteConfiguration, MeasurableEquiv.coe_piCongrLeft, Equiv.piCongrLeft_apply]

	section

	attribute [local instance] scalarL2_addCommMonoid scalarL2_module

	def permutationPullback {N : ℕ} {L : Length} (σ : Equiv.Perm (Fin N)) :
	ScalarL2 N L →ₗ[ℂ] ScalarL2 N L :=
	Lp.compMeasurePreservingₗ ℂ _ (measurePreserving_permute σ)

	end

	lemma bosonic_iff_pullback {N : ℕ} {L : Length} (ψ : ScalarL2 N L) :
	bosonic ψ ↔ ∀ σ, permutationPullback σ ψ = ψ := by
	have hae (σ : Equiv.Perm (Fin N)) :
	(permutationPullback σ ψ : Configuration N L → ℂ) =ᵐ[volume]
	fun X ↦ ψ (permuteConfiguration σ X) :=
	Lp.coeFn_compMeasurePreserving ψ (measurePreserving_permute σ)
	constructor
	· intro h σ
	exact Lp.ext ((hae σ).trans (h σ))
	· intro h σ
	have hh := hae σ
	rw [h σ] at hh
	exact hh.symm

	section

	attribute [local instance] scalarL2_normedAddCommGroup scalarL2_module

	def bosonicSubmodule (N : ℕ) (L : Length) : Submodule ℂ (ScalarL2 N L) :=
	⨅ σ : Equiv.Perm (Fin N),
	@LinearMap.ker ℂ ℂ (ScalarL2 N L) (ScalarL2 N L)
	Complex.instSemiring Complex.instSemiring
	(scalarL2_normedAddCommGroup N L).toAddCommMonoid
	(scalarL2_normedAddCommGroup N L).toAddCommMonoid
	(scalarL2_module N L) (scalarL2_module N L) (RingHom.id ℂ)
	(@HSub.hSub _ _ _
	(@instHSub _ (@LinearMap.instSub ℂ ℂ (ScalarL2 N L) (ScalarL2 N L)
	Complex.instSemiring Complex.instSemiring
	(scalarL2_normedAddCommGroup N L).toAddCommMonoid
	(scalarL2_normedAddCommGroup N L).toAddCommGroup
	(scalarL2_module N L) (scalarL2_module N L) (RingHom.id ℂ)))
	(permutationPullback σ)
	(@LinearMap.id ℂ (ScalarL2 N L) Complex.instSemiring
	(scalarL2_normedAddCommGroup N L).toAddCommMonoid (scalarL2_module N L)))

	@[simp] lemma mem_bosonicSubmodule {N : ℕ} {L : Length} {ψ : ScalarL2 N L} :
	ψ ∈ bosonicSubmodule N L ↔ bosonic ψ := by
	simp only [bosonicSubmodule, Submodule.mem_iInf, LinearMap.mem_ker,
	LinearMap.sub_apply, LinearMap.id_apply, sub_eq_zero]
	exact (bosonic_iff_pullback ψ).symm

	end

	def groundFormSubmodule (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (Jet N L) :=
	dirichletSubmodule N L a ⊓
	(bosonicSubmodule N L).comap (LinearMap.fst ℂ (ScalarL2 N L) (Direction N → ScalarL2 N L))

	@[simp] lemma mem_groundFormSubmodule {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} :
	u ∈ groundFormSubmodule N L a ↔ u ∈ dirichletDomain N L a ∧ bosonic u.1 := by
	simp [groundFormSubmodule]

	end HardSphere

	end

	end OAI