lean/OAI/Analysis/HardSphere/Geometry/CoordinateLine.lean

import Mathlib
import OAI.Analysis.HardSphere.Model

namespace OAI

noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology BigOperators
open scoped BigOperators ComplexConjugate
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Real Complex
open scoped ENNReal ComplexConjugate
namespace HardSphere
@[simp] lemma project_representative (N : ℕ) (L : Length) (X : Configuration N L) :
    project N L (representative N L X) = X := by
  funext i j
  exact AddCircle.coe_equivIco

@[simp] lemma project_add {N : ℕ} {L : Length} (X Y : LiftedConfiguration N) :
    project N L (X + Y) = project N L X + project N L Y := by
  funext i j
  exact map_add (QuotientAddGroup.mk' _) _ _

@[simp] lemma project_sub {N : ℕ} {L : Length} (X Y : LiftedConfiguration N) :
    project N L (X - Y) = project N L X - project N L Y := by
  funext i j
  exact map_sub (QuotientAddGroup.mk' _) _ _

lemma continuous_project (N : ℕ) (L : Length) : Continuous (project N L) := by
  apply continuous_pi
  intro i
  apply continuous_pi
  intro j
  exact (AddCircle.continuous_mk' L.val).comp
    ((continuous_apply j).comp (continuous_apply i))

lemma isQuotientMap_project (N : ℕ) (L : Length) :
    Topology.IsQuotientMap (project N L) := by
  have hcircle : Function.Surjective (fun t : ℝ ↦ (t : AddCircle L.val)) := by
    intro x
    exact ⟨(AddCircle.equivIco L.val 0 x).val, AddCircle.coe_equivIco⟩
  have hopen : IsOpenMap (fun X : Fin 3 → ℝ ↦ fun j ↦ (X j : AddCircle L.val)) :=
    IsOpenMap.piMap (fun _ ↦ QuotientAddGroup.isOpenMap_coe)
      (Filter.Eventually.of_forall (fun _ ↦ hcircle))
  have hsurj : Function.Surjective
      (fun X : Fin 3 → ℝ ↦ fun j ↦ (X j : AddCircle L.val)) := by
    intro X
    exact ⟨fun j ↦ (AddCircle.equivIco L.val 0 (X j)).val,
      funext (fun _ ↦ AddCircle.coe_equivIco)⟩
  exact (IsOpenMap.piMap (fun _ : Fin N ↦ hopen)
    (Filter.Eventually.of_forall (fun _ ↦ hsurj))).isQuotientMap
      (continuous_project N L) (fun X ↦ ⟨representative N L X, project_representative N L X⟩)

lemma continuous_of_continuous_lift {N : ℕ} {L : Length}
    {E : Type*} [TopologicalSpace E] {f : Configuration N L → E}
    (hf : Continuous (fun X : LiftedConfiguration N ↦ f (project N L X))) :
    Continuous f :=
  (isQuotientMap_project N L).continuous_iff.mpr hf

lemma fderiv_lift_eq {N : ℕ} {L : Length} (f : Configuration N L → ℂ)
    {X Y : LiftedConfiguration N} (hXY : project N L X = project N L Y) :
    fderiv ℝ (fun Z ↦ f (project N L Z)) X =
      fderiv ℝ (fun Z ↦ f (project N L Z)) Y := by
  have hfun : (fun Z ↦ f (project N L (Z + (X - Y)))) =
      (fun Z ↦ f (project N L Z)) := by
    funext Z
    rw [project_add, project_sub, hXY, sub_self, add_zero]
  have h := congrArg (fun g : LiftedConfiguration N → ℂ ↦ fderiv ℝ g Y) hfun
  have he := fderiv_comp_add_right (𝕜 := ℝ)
    (f := fun Z ↦ f (project N L Z)) (x := Y) (X - Y)
  rw [he] at h
  simpa only [show Y + (X - Y) = X by abel] using h

lemma coordDerivative_project {N : ℕ} {L : Length} (f : Configuration N L → ℂ)
    (p : Direction N) (X : LiftedConfiguration N) :
    coordDerivative N L f p (project N L X) =
      fderiv ℝ (fun Y ↦ f (project N L Y)) X
        (Pi.single p.1 (Pi.single p.2 1)) := by
  unfold coordDerivative
  rw [fderiv_lift_eq f (project_representative N L (project N L X))]

lemma continuous_coordDerivative {N : ℕ} {L : Length} {f : Configuration N L → ℂ}
    (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun X : LiftedConfiguration N ↦ f (project N L X))) (p : Direction N) :
    Continuous (coordDerivative N L f p) := by
  apply continuous_of_continuous_lift
  simp_rw [coordDerivative_project]
  exact (hf.continuous_fderiv (by simp)).clm_apply continuous_const

lemma SmoothTest.continuous {N : ℕ} {L : Length} {a : ℝ} (f : SmoothTest N L a) :
    Continuous f.toFun := continuous_of_continuous_lift f.smooth.continuous

lemma SmoothTest.continuous_partial {N : ℕ} {L : Length} {a : ℝ}
    (f : SmoothTest N L a) (p : Direction N) :
    Continuous (coordDerivative N L f.toFun p) := continuous_coordDerivative f.smooth p

def coordinateLine {N : ℕ} {L : Length} (X : Configuration N L)
    (p : Direction N) (t : AddCircle L.val) : Configuration N L :=
  X + Pi.single p.1 (Pi.single p.2 t)

lemma project_coordinateLine {N : ℕ} {L : Length} (X : Configuration N L)
    (p : Direction N) (t : ℝ) :
    project N L (representative N L X + t • (Pi.single p.1 (Pi.single p.2 1) : LiftedConfiguration N)) =
      coordinateLine X p (t : AddCircle L.val) := by
  rw [project_add, project_representative]
  congr 1
  funext i j
  by_cases hi : i = p.1 <;> by_cases hj : j = p.2 <;>
    simp [project, hi, hj]

lemma hasDerivAt_coordinateLine {N : ℕ} {L : Length} {f : Configuration N L → ℂ}
    (hf : Differentiable ℝ (fun X : LiftedConfiguration N ↦ f (project N L X)))
    (X : Configuration N L) (p : Direction N) (t : ℝ) :
    HasDerivAt (fun s : ℝ ↦ f (coordinateLine X p (s : AddCircle L.val)))
      (coordDerivative N L f p (coordinateLine X p (t : AddCircle L.val))) t := by
  let e : LiftedConfiguration N := Pi.single p.1 (Pi.single p.2 1)
  have he : HasDerivAt (fun s : ℝ ↦ representative N L X + s • e) e t := by
    simpa using ((hasDerivAt_id t).smul_const e).const_add (representative N L X)
  have h := (hf (representative N L X + t • e)).hasFDerivAt.comp_hasDerivAt t he
  have hfun : (fun s : ℝ ↦ f (project N L (representative N L X + s • e))) =
      (fun s : ℝ ↦ f (coordinateLine X p (s : AddCircle L.val))) := by
    funext s
    rw [project_coordinateLine]
  change HasDerivAt (fun s ↦ f (project N L (representative N L X + s • e)))
    (fderiv ℝ (fun Y ↦ f (project N L Y)) (representative N L X + t • e) e) t at h
  rw [hfun] at h
  rw [← coordDerivative_project f p (representative N L X + t • e),
    project_coordinateLine] at h
  exact h

lemma continuous_coordinateLine {N : ℕ} {L : Length}
    (X : Configuration N L) (p : Direction N) : Continuous (coordinateLine X p) := by
  unfold coordinateLine
  apply Continuous.add continuous_const
  apply continuous_pi
  intro i
  apply continuous_pi
  intro j
  by_cases hi : i = p.1 <;> by_cases hj : j = p.2 <;>
    simp only [Pi.single_apply, hi, hj, ↓reduceIte]
  · exact continuous_id
  all_goals exact continuous_const

lemma integral_partial_coordinateLine {N : ℕ} {L : Length} {f : Configuration N L → ℂ}
    (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun X : LiftedConfiguration N ↦ f (project N L X)))
    (X : Configuration N L) (p : Direction N) :
    (∫ t : AddCircle L.val, coordDerivative N L f p (coordinateLine X p t)) = 0 := by
  rw [← AddCircle.intervalIntegral_preimage L.val 0]
  have hcont : Continuous (fun t : ℝ ↦
      coordDerivative N L f p (coordinateLine X p (t : AddCircle L.val))) :=
    (continuous_coordDerivative hf p).comp
      ((continuous_coordinateLine X p).comp (AddCircle.continuous_mk' L.val))
  rw [intervalIntegral.integral_eq_sub_of_hasDerivAt
    (fun t _ ↦ hasDerivAt_coordinateLine (hf.differentiable (by simp)) X p t)
    (hcont.intervalIntegrable _ _)]
  rw [zero_add, AddCircle.coe_period, AddCircle.coe_zero, sub_self]

lemma integral_coordDerivative {N : ℕ} {L : Length} {f : Configuration N L → ℂ}
    (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun X : LiftedConfiguration N ↦ f (project N L X))) (p : Direction N) :
    (∫ X : Configuration N L, coordDerivative N L f p X) = 0 := by
  let : BorelSpace (Configuration N L) := Pi.borelSpace
  have hcont : Continuous (fun z : AddCircle L.val × Configuration N L ↦
      coordDerivative N L f p (coordinateLine z.2 p z.1)) := by
    apply (continuous_coordDerivative hf p).comp
    unfold coordinateLine
    apply Continuous.add continuous_snd
    apply continuous_pi
    intro i
    apply continuous_pi
    intro j
    by_cases hi : i = p.1 <;> by_cases hj : j = p.2 <;>
      simp [hi, hj, continuous_const, continuous_fst]
  have hint : Integrable (fun z : AddCircle L.val × Configuration N L ↦
      coordDerivative N L f p (coordinateLine z.2 p z.1)) (volume.prod volume) := by
    exact integrableOn_univ.mp (hcont.continuousOn.integrableOn_compact isCompact_univ)
  have hswap := integral_integral_swap
    (f := fun t X ↦ coordDerivative N L f p (coordinateLine X p t)) hint
  have hcir := integral_partial_coordinateLine hf
  simp_rw [hcir] at hswap
  simp only [integral_zero] at hswap
  let : (volume : Measure (Torus L)).IsAddLeftInvariant := by
    rw [volume_pi]
    exact Measure.pi.isAddLeftInvariant _
  let : (volume : Measure (Configuration N L)).IsAddLeftInvariant := by
    rw [volume_pi]
    exact Measure.pi.isAddLeftInvariant _
  let : (volume : Measure (Configuration N L)).IsAddRightInvariant :=
    IsAddLeftInvariant.isAddRightInvariant
  have hc : ∀ t : AddCircle L.val,
      (∫ X : Configuration N L, coordDerivative N L f p (coordinateLine X p t)) =
        ∫ X : Configuration N L, coordDerivative N L f p X := fun t ↦
    integral_add_right_eq_self _ _
  simp_rw [hc] at hswap
  have hvol : (volume (univ : Set (AddCircle L.val))).toReal = L.val := by
    rw [AddCircle.measure_univ, ENNReal.toReal_ofReal L.property.le]
  simp only [integral_const, Measure.real, hvol, Complex.real_smul] at hswap
  exact (mul_eq_zero.mp hswap).resolve_left (Complex.ofReal_ne_zero.mpr L.property.ne')

open scoped ComplexConjugate

lemma coordDerivative_mul {N : ℕ} {L : Length} {f g : Configuration N L → ℂ}
    (hf : Differentiable ℝ (fun X : LiftedConfiguration N ↦ f (project N L X)))
    (hg : Differentiable ℝ (fun X : LiftedConfiguration N ↦ g (project N L X)))
    (p : Direction N) :
    coordDerivative N L (f * g) p = f * coordDerivative N L g p + g * coordDerivative N L f p := by
  funext X
  simp only [coordDerivative, Pi.mul_apply]
  rw [fderiv_fun_mul hf.differentiableAt hg.differentiableAt]
  simp only [add_apply, smul_apply,
    smul_eq_mul, project_representative, Pi.add_apply, Pi.mul_apply]
  rfl

lemma coordDerivative_conj {N : ℕ} {L : Length} {f : Configuration N L → ℂ}
    (hf : Differentiable ℝ (fun X : LiftedConfiguration N ↦ f (project N L X)))
    (p : Direction N) :
    coordDerivative N L (fun X ↦ conj (f X)) p = fun X ↦ conj (coordDerivative N L f p X) := by
  funext X
  unfold coordDerivative
  have h := Complex.conjCLE.toContinuousLinearMap.hasFDerivAt.comp (representative N L X)
    (hf _).hasFDerivAt
  exact congrArg (fun A : LiftedConfiguration N →L[ℝ] ℂ ↦
    A (Pi.single p.1 (Pi.single p.2 1))) h.fderiv

section

local instance complexTopologicalSemiring : IsTopologicalSemiring ℂ := inferInstance

local instance configurationContinuousMapStarModule (N : ℕ) (L : Length) :
    StarModule ℂ C(Configuration N L, ℂ) := inferInstance

def smoothAlgebra (N : ℕ) (L : Length) : StarSubalgebra ℂ C(Configuration N L, ℂ) where
  carrier := {f | ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
    (fun X : LiftedConfiguration N ↦ f (project N L X))}
  mul_mem' := by
    intro f g hf hg
    simp only [Set.mem_ofPred_eq] at *
    exact hf.mul hg
  add_mem' := by
    intro f g hf hg
    simp only [Set.mem_ofPred_eq] at *
    exact hf.add hg
  algebraMap_mem' := by
    intro c
    simp only [Set.mem_ofPred_eq, algebraMap_apply]
    exact contDiff_const
  star_mem' := by
    intro f hf
    simp only [Set.mem_ofPred_eq] at *
    exact Complex.conjCLE.contDiff.comp hf
  zero_mem' := by
    simp only [Set.mem_ofPred_eq, ContinuousMap.zero_apply]
    exact contDiff_const
  one_mem' := by
    simp only [Set.mem_ofPred_eq, ContinuousMap.one_apply]
    exact contDiff_const

end

def coordinateCharacter {N : ℕ} {L : Length} (p : Direction N) : C(Configuration N L, ℂ) :=
  (fourier 1).comp ⟨fun X ↦ X p.1 p.2,
    (continuous_apply p.2).comp (continuous_apply p.1)⟩

lemma coordinateCharacter_smooth {N : ℕ} {L : Length} (p : Direction N) :
    coordinateCharacter p ∈ smoothAlgebra N L := by
  change ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
    (fun X : LiftedConfiguration N ↦ fourier 1 (X p.1 p.2 : AddCircle L.val))
  simp_rw [fourier_coe_apply]
  exact Complex.contDiff_exp.comp
    ((((contDiff_const.mul contDiff_const).mul contDiff_const).mul contDiff_const).mul
      (Complex.ofRealCLM.contDiff.comp (contDiff_apply_apply ℝ ℝ p.1 p.2)) |>.div_const _)

lemma smoothAlgebra_separatesPoints (N : ℕ) (L : Length) :
    (smoothAlgebra N L).SeparatesPoints := by
  intro X Y hXY
  obtain ⟨i, hi⟩ := Function.ne_iff.mp hXY
  obtain ⟨j, hj⟩ := Function.ne_iff.mp hi
  refine ⟨_, ⟨coordinateCharacter (i,j), coordinateCharacter_smooth (i,j), rfl⟩, ?_⟩
  change fourier 1 (X i j) ≠ fourier 1 (Y i j)
  rw [fourier_one, fourier_one]
  intro he
  apply hj
  exact AddCircle.injective_toCircle L.property.ne' (Subtype.ext he)

lemma smoothAlgebra_dense (N : ℕ) (L : Length) :
    Dense (smoothAlgebra N L : Set C(Configuration N L, ℂ)) := by
  have hh := ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints
    (smoothAlgebra N L) (smoothAlgebra_separatesPoints N L)
  rw [dense_iff_closure_eq]
  exact congrArg (fun A : StarSubalgebra ℂ C(Configuration N L, ℂ) ↦ (A : Set C(Configuration N L, ℂ))) hh

lemma smoothAlgebra_toLp_dense (N : ℕ) (L : Length) :
    DenseRange (fun f : smoothAlgebra N L ↦
      ContinuousMap.toLp 2 volume ℂ (f : C(Configuration N L, ℂ))) := by
  exact (ContinuousMap.toLp_denseRange ℂ volume ℂ (by simp : (2 : ℝ≥0∞) ≠ ∞)).comp
    (smoothAlgebra_dense N L).denseRange_val (ContinuousMap.toLp 2 volume ℂ).continuous

lemma integral_integration_by_parts {N : ℕ} {L : Length}
    {f g : Configuration N L → ℂ}
    (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun X : LiftedConfiguration N ↦ f (project N L X)))
    (hg : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun X : LiftedConfiguration N ↦ g (project N L X))) (p : Direction N) :
    (∫ X, conj (f X) * coordDerivative N L g p X) +
      (∫ X, conj (coordDerivative N L f p X) * g X) = 0 := by
  have hconj := Complex.conjCLE.contDiff.comp hf
  have h := integral_coordDerivative (f := (fun X ↦ conj (f X)) * g)
    (hconj.mul hg) p
  rw [coordDerivative_mul (hconj.differentiable (by simp)) (hg.differentiable (by simp)),
    coordDerivative_conj (hf.differentiable (by simp))] at h
  have hfg : Integrable (fun X ↦ conj (f X) * coordDerivative N L g p X) := by
    exact integrableOn_univ.mp
      ((((continuous_of_continuous_lift hf.continuous).star).mul
        (continuous_coordDerivative hg p)).continuousOn.integrableOn_compact isCompact_univ)
  have hgf : Integrable (fun X ↦ g X * conj (coordDerivative N L f p X)) := by
    exact integrableOn_univ.mp
      (((continuous_of_continuous_lift hg.continuous).mul
        (continuous_coordDerivative hf p).star).continuousOn.integrableOn_compact isCompact_univ)
  simp only [Pi.add_apply, Pi.mul_apply] at h
  rw [integral_add hfg hgf] at h
  simpa only [Pi.mul_apply, mul_comm (g _)] using h

def smoothPartial {N : ℕ} {L : Length} (f : smoothAlgebra N L) (p : Direction N) :
    C(Configuration N L, ℂ) :=
  ⟨coordDerivative N L f.val p, continuous_coordDerivative f.property p⟩

section

local instance configurationProductBorel (N : ℕ) (L : Length) :
    BorelSpace (Configuration N L) := Pi.borelSpace

lemma SmoothTest.weak_derivative {N : ℕ} {L : Length} {a : ℝ}
    (u : SmoothTest N L a) (f : smoothAlgebra N L) (p : Direction N) :
    inner ℂ (ContinuousMap.toLp 2 volume ℂ f.val) (u.jet.2 p) +
      inner ℂ (ContinuousMap.toLp 2 volume ℂ (smoothPartial f p)) u.jet.1 = 0 := by
  rw [L2.inner_def, L2.inner_def]
  have h₁ : (∫ X, inner ℂ ((ContinuousMap.toLp 2 volume ℂ f.val) X) ((u.jet.2 p) X)) =
      ∫ X, conj (f.val X) * coordDerivative N L u.toFun p X := by
    apply integral_congr_ae
    filter_upwards [ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume f.val, (u.partial_memLp p).coeFn_toLp]
      with X hX hY
    change inner ℂ _ ((u.partial_memLp p).toLp _ X) = _
    rw [hX, hY, RCLike.inner_apply, mul_comm]
  have h₂ : (∫ X, inner ℂ ((ContinuousMap.toLp 2 volume ℂ (smoothPartial f p)) X) (u.jet.1 X)) =
      ∫ X, conj (coordDerivative N L f.val p X) * u.toFun X := by
    apply integral_congr_ae
    filter_upwards [ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume (smoothPartial f p), u.memLp.coeFn_toLp]
      with X hX hY
    change inner ℂ _ (u.memLp.toLp _ X) = _
    rw [hX, hY, RCLike.inner_apply, mul_comm]
    rfl
  rw [h₁, h₂]
  exact integral_integration_by_parts f.property u.smooth p

lemma weak_derivative {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
    (hu : u ∈ dirichletDomain N L a) (f : smoothAlgebra N L) (p : Direction N) :
    inner ℂ (ContinuousMap.toLp 2 volume ℂ f.val) (u.2 p) +
      inner ℂ (ContinuousMap.toLp 2 volume ℂ (smoothPartial f p)) u.1 = 0 := by
  have hc : IsClosed {v : Jet N L |
      inner ℂ (ContinuousMap.toLp 2 volume ℂ f.val) (v.2 p) +
      inner ℂ (ContinuousMap.toLp 2 volume ℂ (smoothPartial f p)) v.1 = 0} :=
    isClosed_eq ((continuous_const.inner ((continuous_apply p).comp continuous_snd)).add
      (continuous_const.inner continuous_fst)) continuous_const
  exact closure_minimal (by rintro _ ⟨v, rfl⟩; exact v.weak_derivative f p) hc hu

end

lemma derivative_zero_of_scalar_zero {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
    (hu : u ∈ dirichletDomain N L a) (hz : u.1 = 0) : u.2 = 0 := by
  funext p
  apply (inner_self_eq_zero (𝕜 := ℂ)).mp
  refine (smoothAlgebra_toLp_dense N L).induction_on
    (p := fun w ↦ inner ℂ w (u.2 p) = 0) (u.2 p)
    (isClosed_eq (continuous_id.inner continuous_const) continuous_const) ?_
  intro f
  have h := weak_derivative hu f p
  simpa only [hz, inner_zero_right, add_zero] using h

end HardSphere

end

end OAI