import Mathlib
import OAI.Analysis.HardSphere.Comparison.PermutationPullbackComp

namespace OAI

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

attribute [local instance] scalarL2_addCommMonoid scalarL2_module scalarL2_completeSpace

def optionJetEquiv (N : ℕ) (L : Length) :
    (Option (Direction N) → ScalarL2 N L) ≃L[ℂ] Jet N L where
  toLinearEquiv := LinearEquiv.piOptionEquivProd ℂ
  continuous_toFun := (continuous_apply none).prodMk
    (continuous_pi fun i ↦ continuous_apply (some i))
  continuous_invFun := continuous_pi fun i ↦ by
    cases i with
    | none => exact continuous_fst
    | some p => exact (continuous_apply p).comp continuous_snd

def hilbertJetEquiv (N : ℕ) (L : Length) : HilbertJet N L ≃L[ℂ] Jet N L :=
  (PiLp.continuousLinearEquiv _ ℂ _).trans (optionJetEquiv N L)

@[simp] lemma hilbertJetEquiv_fst {N : ℕ} {L : Length} (u : HilbertJet N L) :
    (hilbertJetEquiv N L u).1 = u.ofLp none := rfl
@[simp] lemma hilbertJetEquiv_snd {N : ℕ} {L : Length} (u : HilbertJet N L) (p : Direction N) :
    (hilbertJetEquiv N L u).2 p = u.ofLp (some p) := rfl

lemma hilbertJet_inner {N : ℕ} {L : Length} (u v : HilbertJet N L) :
    inner ℂ u v = inner ℂ (hilbertJetEquiv N L u).1 (hilbertJetEquiv N L v).1 +
      ∑ p : Direction N, inner ℂ ((hilbertJetEquiv N L u).2 p) ((hilbertJetEquiv N L v).2 p) := by
  rw [PiLp.inner_apply,Fintype.sum_option]
  rfl

lemma hilbertJet_norm_sq {N : ℕ} {L : Length} (u : HilbertJet N L) :
    ‖u‖^2 = ‖(hilbertJetEquiv N L u).1‖^2 + energy (hilbertJetEquiv N L u) := by
  rw [PiLp.norm_sq_eq_of_L2,Fintype.sum_option]
  rfl

def hilbertDomain (N : ℕ) (L : Length) (a : ℝ) : Submodule ℂ (HilbertJet N L) :=
  (dirichletSubmodule N L a).comap (hilbertJetEquiv N L).toLinearMap

instance hilbertDomain_closed (N : ℕ) (L : Length) (a : ℝ) :
    IsClosed (hilbertDomain N L a : Set (HilbertJet N L)) :=
  (Submodule.isClosed_topologicalClosure _).preimage (hilbertJetEquiv N L).continuous
instance hilbertDomain_complete (N : ℕ) (L : Length) (a : ℝ) :
    CompleteSpace (hilbertDomain N L a) := IsClosed.completeSpace_coe

def scalarEmbedding (N : ℕ) (L : Length) (a : ℝ) :
    (hilbertDomain N L a) →L[ℂ] ScalarL2 N L :=
  (PiLp.proj _ _ none).comp (hilbertDomain N L a).subtypeL

lemma scalarEmbedding_norm_le (N : ℕ) (L : Length) (a : ℝ) : ‖scalarEmbedding N L a‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro u
  simpa [scalarEmbedding] using PiLp.norm_apply_le (u : HilbertJet N L) none

def formResolvent (N : ℕ) (L : Length) (a : ℝ) : ScalarL2 N L →L[ℂ] ScalarL2 N L :=
  (scalarEmbedding N L a).comp (scalarEmbedding N L a).adjoint

lemma formResolvent_isPositive (N : ℕ) (L : Length) (a : ℝ) :
    (formResolvent N L a).IsPositive := by
  simpa [formResolvent] using
    ContinuousLinearMap.isPositive_adjoint_comp_self (scalarEmbedding N L a).adjoint

lemma formResolvent_norm_le_one (N : ℕ) (L : Length) (a : ℝ) :
    ‖formResolvent N L a‖ ≤ 1 := by
  have ha : ‖(scalarEmbedding N L a).adjoint‖ = ‖scalarEmbedding N L a‖ :=
    ContinuousLinearMap.adjoint.norm_map _
  have hadj : ‖(scalarEmbedding N L a).adjoint‖ ≤ 1 := by
    rw [ha]
    exact scalarEmbedding_norm_le N L a
  calc
    _ ≤ ‖scalarEmbedding N L a‖ * ‖(scalarEmbedding N L a).adjoint‖ :=
      ContinuousLinearMap.opNorm_comp_le _ _
    _ ≤ 1*1 := mul_le_mul (scalarEmbedding_norm_le N L a)
      hadj (ContinuousLinearMap.opNorm_nonneg _) zero_le_one
    _ = 1 := one_mul 1

lemma resolvent_weak_equation {N : ℕ} {L : Length} {a : ℝ} (f : ScalarL2 N L)
    (v : hilbertDomain N L a) :
    let u : Jet N L := hilbertJetEquiv N L ((scalarEmbedding N L a).adjoint f : HilbertJet N L)
    inner ℂ u.1 (hilbertJetEquiv N L (v : HilbertJet N L)).1 +
      ∑ p : Direction N, inner ℂ (u.2 p) ((hilbertJetEquiv N L (v : HilbertJet N L)).2 p) =
      inner ℂ f (scalarEmbedding N L a v) := by
  exact (hilbertJet_inner _ _).symm.trans
    (ContinuousLinearMap.adjoint_inner_left (scalarEmbedding N L a) v f)

lemma IsGroundVector.resolvent_eigenvector {N : ℕ} {L : Length} {a : ℝ}
    {u : Jet N L} (hu : IsGroundVector N L a u) :
    formResolvent N L a u.1 = ((1+(energy u:ℂ))⁻¹) • u.1 := by
  let ug : hilbertDomain N L a := ⟨(hilbertJetEquiv N L).symm u, by
    change hilbertJetEquiv N L ((hilbertJetEquiv N L).symm u) ∈ dirichletSubmodule N L a
    simpa using hu.1⟩
  have hE : 0 ≤ energy u := Finset.sum_nonneg fun _ _ ↦ sq_nonneg _
  have hne : 1+(energy u:ℂ) ≠ 0 := by
    have hreal : (1:ℝ)+energy u ≠ 0 := ne_of_gt (by linarith)
    exact_mod_cast hreal
  have heq : (scalarEmbedding N L a).adjoint u.1 = ((1+(energy u:ℂ))⁻¹) • ug := by
    apply ext_inner_right ℂ
    intro v
    rw [ContinuousLinearMap.adjoint_inner_left]
    rw [inner_smul_left ug v ((1+(energy u:ℂ))⁻¹)]
    have hv : hilbertJetEquiv N L (v : HilbertJet N L) ∈ dirichletDomain N L a := v.property
    have hg : inner ℂ ug v = (1+(energy u:ℂ))*inner ℂ u.1 (scalarEmbedding N L a v) := by
      change inner ℂ (ug : HilbertJet N L) (v : HilbertJet N L) = _
      rw [hilbertJet_inner]
      have hgu : hilbertJetEquiv N L (ug : HilbertJet N L) = u := by simp [ug]
      rw [hgu,hu.full_first_variation _ hv]
      change inner ℂ u.1 (scalarEmbedding N L a v) + (energy u:ℂ)*inner ℂ u.1 (scalarEmbedding N L a v) = _
      ring
    rw [hg]
    simp only [map_inv₀,map_add,map_one,Complex.conj_ofReal]
    rw [← mul_assoc,inv_mul_cancel₀ hne,one_mul]
  change scalarEmbedding N L a ((scalarEmbedding N L a).adjoint u.1) = _
  rw [heq,map_smul]
  congr 1

lemma strong_projection_limit {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]
    (K : Submodule ℂ E) (Kseq : ℕ → Submodule ℂ E)
    [K.HasOrthogonalProjection] [∀ n, (Kseq n).HasOrthogonalProjection]
    (hmono : Monotone Kseq) (hle : ∀ n, Kseq n ≤ K)
    (hdense : closure (⋃ n, (Kseq n : Set E)) = K) (x : E) :
    Tendsto (fun n ↦ (Kseq n).starProjection x) atTop (𝓝 (K.starProjection x)) := by
  apply Metric.tendsto_atTop.mpr
  intro ε hε
  have hy : K.starProjection x ∈ closure (⋃ n, (Kseq n : Set E)) := by
    rw [hdense]
    exact K.starProjection_apply_mem x
  obtain ⟨v, hv, hdist⟩ := Metric.mem_closure_iff.mp hy (ε/2) (half_pos hε)
  obtain ⟨m, hm⟩ := mem_iUnion.mp hv
  refine ⟨m, fun n hn ↦ ?_⟩
  have hvn : (Kseq n).starProjection v = v :=
    (Kseq n).starProjection_eq_self_iff.mpr (hmono hn hm)
  have hcomp : (Kseq n).starProjection (K.starProjection x) = (Kseq n).starProjection x :=
    DFunLike.congr_fun (Submodule.starProjection_comp_starProjection_of_le (hle n)) x
  have hnorm := (Kseq n).norm_starProjection_apply_le (K.starProjection x - v)
  rw [map_sub, hcomp, hvn] at hnorm
  calc
    dist ((Kseq n).starProjection x) (K.starProjection x) =
        ‖(Kseq n).starProjection x - K.starProjection x‖ := dist_eq_norm _ _
    _ ≤ ‖(Kseq n).starProjection x - v‖ + ‖v - K.starProjection x‖ := norm_sub_le_norm_sub_add_norm_sub _ _ _
    _ ≤ ‖K.starProjection x - v‖ + ‖v - K.starProjection x‖ := add_le_add hnorm le_rfl
    _ < ε := by rw [norm_sub_rev v]; rw [dist_eq_norm] at hdist; linarith

lemma scalarAdjoint_eq_projection {N : ℕ} {L : Length} {a : ℝ} (f : ScalarL2 N L) :
    ((scalarEmbedding N L a).adjoint f : HilbertJet N L) =
      (hilbertDomain N L a).starProjection (PiLp.single 2 none f) := by
  symm
  apply Submodule.eq_starProjection_of_mem_of_inner_eq_zero
  · exact ((scalarEmbedding N L a).adjoint f).property
  · intro v hv
    rw [inner_sub_left]
    have hleft : inner ℂ (PiLp.single 2 none f : HilbertJet N L) v = inner ℂ f (v.ofLp none) := by
      rw [PiLp.inner_apply, Fintype.sum_option]
      simp
    rw [hleft]
    have hh := ContinuousLinearMap.adjoint_inner_left (scalarEmbedding N L a) ⟨v,hv⟩ f
    change inner ℂ ((scalarEmbedding N L a).adjoint f : HilbertJet N L) v = _ at hh
    rw [hh]
    change inner ℂ f (v.ofLp none) - inner ℂ f (v.ofLp none) = 0
    exact sub_self _

lemma formResolvent_eq_projection {N : ℕ} {L : Length} {a : ℝ} (f : ScalarL2 N L) :
    formResolvent N L a f =
      ((hilbertDomain N L a).starProjection (PiLp.single 2 none f)).ofLp none := by
  change (((scalarEmbedding N L a).adjoint f : HilbertJet N L)).ofLp none = _
  rw [scalarAdjoint_eq_projection]

lemma continuous_torusDistance (L : Length) : Continuous (fun p : Torus L × Torus L ↦ torusDistance L p.1 p.2) := by
  unfold torusDistance
  fun_prop

lemma isOpen_allowed (N : ℕ) (L : Length) (a : ℝ) : IsOpen (allowed N L a) := by
  let P := {p : Fin N × Fin N // p.1 < p.2}
  have heq : allowed N L a = ⋂ p : P, {X : Configuration N L | a < torusDistance L (X p.1.1) (X p.1.2)} := by
    ext X
    simp only [allowed, mem_ofPred_eq, mem_iInter]
    exact ⟨fun h p ↦ h _ _ p.2, fun h i j hij ↦ h ⟨(i,j),hij⟩⟩
  rw [heq]
  apply isOpen_iInter_of_finite
  intro p
  have hc : Continuous (fun X : Configuration N L ↦ torusDistance L (X p.1.1) (X p.1.2)) := by
    unfold torusDistance
    fun_prop
  exact isOpen_lt continuous_const hc

lemma allowed_antitone (N : ℕ) (L : Length) : Antitone (allowed N L) := by
  intro a b hab X hX i j hij
  exact lt_of_le_of_lt hab (hX i j hij)

def innerRadius (a : ℝ) (n : ℕ) : ℝ := a + 1 / ((n:ℝ)+1)

lemma innerRadius_gt (a : ℝ) (n : ℕ) : a < innerRadius a n := by
  unfold innerRadius
  have : 0 < 1 / ((n:ℝ)+1) := by positivity
  linarith

lemma innerRadius_antitone (a : ℝ) : Antitone (innerRadius a) := by
  intro m n hmn
  unfold innerRadius
  apply add_le_add le_rfl
  apply one_div_le_one_div_of_le (by positivity)
  exact_mod_cast Nat.add_le_add_right hmn 1

lemma innerRadius_tendsto (a : ℝ) : Tendsto (innerRadius a) atTop (𝓝 a) := by
  change Tendsto (fun n : ℕ ↦ a + 1 / ((n:ℝ)+1)) atTop (𝓝 a)
  simpa only [add_zero] using (tendsto_const_nhds (x := a)).add (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))

lemma iUnion_allowed_innerRadius (N : ℕ) (L : Length) (a : ℝ) :
    (⋃ n, allowed N L (innerRadius a n)) = allowed N L a := by
  apply Subset.antisymm
  · exact iUnion_subset fun n ↦ allowed_antitone N L (innerRadius_gt a n).le
  · intro X hX
    have h : ∀ i j : Fin N, ∀ᶠ n in atTop, i < j → innerRadius a n < torusDistance L (X i) (X j) := by
      intro i j
      by_cases hij : i < j
      · exact ((innerRadius_tendsto a).eventually (gt_mem_nhds (hX i j hij))).mono fun _ hn _ ↦ hn
      · exact Filter.Eventually.of_forall fun _ h ↦ (hij h).elim
    have hh : ∀ᶠ n in atTop, ∀ i j : Fin N, i < j → innerRadius a n < torusDistance L (X i) (X j) := by
      exact Filter.eventually_all.mpr fun i ↦ Filter.eventually_all.mpr (h i)
    obtain ⟨n, hn⟩ := hh.exists
    exact mem_iUnion.mpr ⟨n,hn⟩

lemma SmoothTest.exists_innerRadius {N : ℕ} {L : Length} {a : ℝ} (f : SmoothTest N L a) :
    ∃ n, tsupport f.toFun ⊆ allowed N L (innerRadius a n) := by
  apply f.compact.isCompact.elim_directed_cover (fun n ↦ allowed N L (innerRadius a n))
  · exact fun n ↦ isOpen_allowed _ _ _
  · rw [iUnion_allowed_innerRadius]
    exact f.support_allowed
  · intro m n
    exact ⟨max m n, allowed_antitone N L (innerRadius_antitone a (le_max_left _ _)),
      allowed_antitone N L (innerRadius_antitone a (le_max_right _ _))⟩

lemma dirichletDomain_antitone (N : ℕ) (L : Length) : Antitone (dirichletDomain N L) := by
  intro a b hab
  apply closure_mono
  rintro _ ⟨f,rfl⟩
  let g : SmoothTest N L a := {f with support_allowed := fun X hX ↦ allowed_antitone N L hab (f.support_allowed hX)}
  exact ⟨g,rfl⟩

lemma hilbertDomain_antitone (N : ℕ) (L : Length) : Antitone (hilbertDomain N L) := by
  intro a b hab u hu
  exact dirichletDomain_antitone N L hab hu

lemma hilbertDomain_exhaustion (N : ℕ) (L : Length) (a : ℝ) :
    closure (⋃ n, (hilbertDomain N L (innerRadius a n) : Set (HilbertJet N L))) = hilbertDomain N L a := by
  apply Subset.antisymm
  · apply closure_minimal
    · exact iUnion_subset fun n ↦ hilbertDomain_antitone N L (innerRadius_gt a n).le
    · exact hilbertDomain_closed N L a
  · intro u hu
    let S := closure (⋃ n, (hilbertDomain N L (innerRadius a n) : Set (HilbertJet N L)))
    have hclosed : IsClosed ((hilbertJetEquiv N L).symm ⁻¹' S) :=
      isClosed_closure.preimage (hilbertJetEquiv N L).symm.continuous
    have hsub : dirichletDomain N L a ⊆ (hilbertJetEquiv N L).symm ⁻¹' S := by
      apply closure_minimal _ hclosed
      rintro _ ⟨f,rfl⟩
      obtain ⟨n, hn⟩ := f.exists_innerRadius
      let g : SmoothTest N L (innerRadius a n) := {f with support_allowed := hn}
      apply subset_closure
      apply mem_iUnion.mpr
      refine ⟨n,?_⟩
      change hilbertJetEquiv N L ((hilbertJetEquiv N L).symm f.jet) ∈ dirichletDomain N L (innerRadius a n)
      simp only [ContinuousLinearEquiv.apply_symm_apply]
      exact subset_closure ⟨g,rfl⟩
    have hx := hsub hu
    change (hilbertJetEquiv N L).symm (hilbertJetEquiv N L u) ∈ S at hx
    rwa [ContinuousLinearEquiv.symm_apply_apply] at hx

lemma formResolvent_innerRadius_tendsto (N : ℕ) (L : Length) (a : ℝ) (f : ScalarL2 N L) :
    Tendsto (fun n ↦ formResolvent N L (innerRadius a n) f) atTop (𝓝 (formResolvent N L a f)) := by
  simp only [formResolvent_eq_projection]
  apply (PiLp.proj (𝕜 := ℂ) 2 (fun _ : Option (Direction N) ↦ ScalarL2 N L) none).continuous.tendsto _ |>.comp
  apply strong_projection_limit
  · exact fun m n hmn ↦ hilbertDomain_antitone N L (innerRadius_antitone a hmn)
  · exact fun n ↦ hilbertDomain_antitone N L (innerRadius_gt a n).le
  · exact hilbertDomain_exhaustion N L a

end HardSphere

noncomputable section
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators

end
end
end
end
end

end OAI