import Mathlib
import OAI.Analysis.CoulombIonization.FormDomain.WeakChangeVariables

namespace OAI

noncomputable section

open MeasureTheory Filter
open scoped Topology BigOperators ContDiff
open MeasureTheory Filter
open scoped Topology BigOperators ContDiff InnerProductSpace Convolution
namespace CoulombAtom

@[simp] lemma fermionPermutation_apply {N : ℕ} (π : Equiv.Perm (Fin N))
    (F : SectorHilbert N) (s : Spins N) :
    fermionPermutation π F s = (((Equiv.Perm.sign π : ℤ) : ℂ)) •
      Lp.compMeasurePreserving (permuteConfiguration π) (permuteConfiguration_preserving π)
        (F (s ∘ π)) := rfl

lemma permuteConfiguration_mul {N : ℕ} (π σ : Equiv.Perm (Fin N)) :
    (permuteConfiguration (π * σ) : Configuration N → Configuration N) =
      permuteConfiguration σ ∘ permuteConfiguration π := by
  funext x i
  simp only [Function.comp_apply, permuteConfiguration_apply, Equiv.Perm.coe_mul]

lemma fermionPermutation_mul {N : ℕ} (π σ : Equiv.Perm (Fin N)) (F : SectorHilbert N) :
    fermionPermutation π (fermionPermutation σ F) = fermionPermutation (π * σ) F := by
  apply PiLp.ext
  intro s
  simp only [fermionPermutation_apply]
  change _ • (Lp.compMeasurePreservingₗ ℂ (permuteConfiguration π)
    (permuteConfiguration_preserving π)) (_ • _) = _
  rw [map_smul]
  rw [smul_smul]
  have hsign : (((Equiv.Perm.sign (π * σ) : ℤ) : ℂ)) =
      (((Equiv.Perm.sign π : ℤ) : ℂ)) * (((Equiv.Perm.sign σ : ℤ) : ℂ)) := by
    simp
  rw [hsign]
  congr 1
  have hs : (s ∘ π) ∘ σ = s ∘ (π * σ) := rfl
  rw [hs]
  change Lp.compMeasurePreserving (permuteConfiguration π) _
    (Lp.compMeasurePreserving (permuteConfiguration σ) _ _) = _
  rw [← Lp.compMeasurePreserving_comp_apply]
  simp only [← permuteConfiguration_mul]

lemma sectorDirections_permute {N : ℕ} (π : Equiv.Perm (Fin N)) (k : Fin N × Fin 3) :
    permuteConfiguration π (sectorDirections N k) = sectorDirections N (π.symm k.1, k.2) := by
  classical
  ext i a
  simp only [permuteConfiguration_apply, Function.comp_apply, sectorDirections, direction]
  by_cases h : i = π.symm k.1
  · subst i
    simp
  · have h' : π i ≠ k.1 := by
      intro hh
      apply h
      exact π.injective (by simpa using hh)
    simp [h, h']

def sectorGraphPermutation {N : ℕ} (π : Equiv.Perm (Fin N)) : SectorGraph N →L[ℂ] SectorGraph N :=
  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Spins N => weakGraph (sectorDirections N))
    ).symm.toContinuousLinearMap.comp
    (ContinuousLinearMap.pi fun s =>
      ((((Equiv.Perm.sign π : ℤ) : ℂ)) • weakGraphChange (sectorDirections N)
        (permuteConfiguration π) (permuteConfiguration_preserving π)
        (fun k => (π.symm k.1, k.2)) (sectorDirections_permute π)).comp
        (PiLp.proj 2 (fun _ : Spins N => weakGraph (sectorDirections N)) (s ∘ π)))

lemma sectorGraphPermutation_value {N : ℕ} (π : Equiv.Perm (Fin N)) (F : SectorGraph N) :
    sectorGraphValue N (sectorGraphPermutation π F) = fermionPermutation π (sectorGraphValue N F) := by
  rfl

def fermionAverage (N : ℕ) : SectorHilbert N →L[ℂ] SectorHilbert N :=
  (Fintype.card (Equiv.Perm (Fin N)) : ℂ)⁻¹ • ∑ π : Equiv.Perm (Fin N), fermionPermutation π

lemma fermionAverage_mem {N : ℕ} (F : SectorHilbert N) : fermionAverage N F ∈ fermionSpace N := by
  classical
  rw [mem_fermionSpace]
  intro π
  simp only [fermionAverage, smul_apply, sum_apply,
    map_smul, map_sum, fermionPermutation_mul]
  congr 1
  exact Fintype.sum_equiv (Equiv.mulLeft π) _ _ (fun σ => rfl)

lemma fermionAverage_eq_self {N : ℕ} (F : fermionSpace N) : fermionAverage N F = F := by
  classical
  have hF := (mem_fermionSpace F.val).mp F.property
  simp only [fermionAverage, smul_apply, sum_apply, hF]
  simp [← Nat.cast_smul_eq_nsmul ℂ, smul_smul]

lemma sectorGraphValue_average (N : ℕ) (F : SectorGraph N) :
    sectorGraphValue N (((Fintype.card (Equiv.Perm (Fin N)) : ℂ)⁻¹ •
      ∑ π : Equiv.Perm (Fin N), sectorGraphPermutation π) F) =
      fermionAverage N (sectorGraphValue N F) := by
  simp only [smul_apply, sum_apply, map_smul, map_sum, sectorGraphPermutation_value,
    fermionAverage]

def fermionGraphAverage (N : ℕ) : SectorGraph N →L[ℂ] fermionGraph N :=
  ((Fintype.card (Equiv.Perm (Fin N)) : ℂ)⁻¹ • ∑ π : Equiv.Perm (Fin N), sectorGraphPermutation π
    ).codRestrict (fermionGraph N) (by
      intro F
      change sectorGraphValue N _ ∈ fermionSpace N
      rw [sectorGraphValue_average]
      exact fermionAverage_mem _)

lemma fermionGraphAverage_value {N : ℕ} (F : SectorGraph N) :
    (fermionGraphValue N (fermionGraphAverage N F)).val = fermionAverage N (sectorGraphValue N F) :=
  sectorGraphValue_average N F

lemma sectorGraphValue_denseRange (N : ℕ) : DenseRange (sectorGraphValue N) := by
  let eV := PiLp.continuousLinearEquiv 2 ℂ (fun _ : Spins N => weakGraph (sectorDirections N))
  let eH := PiLp.continuousLinearEquiv 2 ℂ
    (fun _ : Spins N => Lp ℂ 2 (volume : Measure (Configuration N)))
  have hd := DenseRange.piMap (fun _ : Spins N => weakGraphValue_denseRange (sectorDirections N))
  have hc : Continuous (Pi.map (fun _ : Spins N => weakGraphValue (sectorDirections N))) := by
    fun_prop
  exact eH.symm.surjective.denseRange.comp (hd.comp eV.surjective.denseRange hc) eH.symm.continuous

theorem fermionGraphValue_denseRange (N : ℕ) : DenseRange (fermionGraphValue N) := by
  let p : SectorHilbert N →L[ℂ] fermionSpace N :=
    (fermionAverage N).codRestrict (fermionSpace N) fermionAverage_mem
  have hp : Function.Surjective p := by
    intro F
    exact ⟨F.val, Subtype.ext (fermionAverage_eq_self F)⟩
  have hd := hp.denseRange.comp (sectorGraphValue_denseRange N) p.continuous
  have he : p ∘ sectorGraphValue N = fermionGraphValue N ∘ fermionGraphAverage N := by
    funext F
    exact Subtype.ext (fermionGraphAverage_value F).symm
  rw [he] at hd
  exact hd.of_comp

end CoulombAtom

end

end OAI