import Mathlib
import OAI.Analysis.CoulombIonization.FieldAnalysis.NeumannCube
import OAI.Analysis.CoulombIonization.FieldAnalysis.NeumannSine

namespace OAI

noncomputable section

namespace CoulombNeumann

open MeasureTheory Filter
open scoped Topology BigOperators ContDiff
section Work_NeumannGradient_scope

open MeasureTheory Set
open scoped BigOperators unitInterval ComplexConjugate ENNReal ContDiff

variable {d : ℕ}

lemma cubeNeumannMode_split (i : Fin (d+1)) (n : Fin (d+1) → ℕ)
    (t : I) (y : Fin d → I) :
    cubeNeumannMode n (i.insertNth t y) =
      neumannMode (n i) t * cubeNeumannMode (n ∘ i.succAbove) y := by
  simp only [cubeNeumannMode,ContinuousMap.coe_mk,i.prod_univ_succAbove,
    Fin.insertNth_apply_same,Fin.insertNth_apply_succAbove,Function.comp_def]

lemma cubeSineMode_split (i : Fin (d+1)) (n : {n : Fin (d+1) → ℕ // n i ≠ 0})
    (t : I) (y : Fin d → I) :
    cubeSineMode i n (i.insertNth t y) =
      sineMode (n.1 i-1) t * cubeNeumannMode (n.1 ∘ i.succAbove) y := by
  simp [cubeSineMode,cubeNeumannMode,i.prod_univ_succAbove,Fin.succAbove_ne]

lemma coe_insertNth (i : Fin (d+1)) (t : I) (y : Fin d → I) :
    (fun j => (i.insertNth (α := fun _ => I) t y j : ℝ)) = i.insertNth (α := fun _ => ℝ) (t:ℝ) (fun j => (y j:ℝ)) := by
  ext j
  refine i.succAboveCases ?_ (fun k => ?_) j <;> simp

lemma contDiff_insertNth (i : Fin (d+1)) (y : Fin d → ℝ) :
    ContDiff ℝ 1 (fun t : ℝ => i.insertNth (α := fun _ => ℝ) t y) := by
  rw [contDiff_pi]
  intro j
  refine i.succAboveCases ?_ (fun k => ?_) j <;> simp only [Fin.insertNth_apply_same,Fin.insertNth_apply_succAbove] <;> fun_prop

lemma hasDerivAt_insertNth (i : Fin (d+1)) (y : Fin d → ℝ) (t : ℝ) :
    HasDerivAt (fun t : ℝ => i.insertNth (α := fun _ => ℝ) t y) (Pi.single i 1) t := by
  rw [hasDerivAt_pi]
  intro j
  refine i.succAboveCases ?_ (fun k => ?_) j
  · simpa only [Fin.insertNth_apply_same,Pi.single_eq_same] using hasDerivAt_id' t
  · simpa only [Fin.insertNth_apply_succAbove,Pi.single_eq_of_ne (Fin.succAbove_ne i k)] using hasDerivAt_const t (y k)

def cubeFunction {f : (Fin (d+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f) : C(Fin (d+1) → I,ℂ) where
  toFun x := f (fun i => (x i:ℝ))
  continuous_toFun := hf.continuous.comp (by fun_prop)

def cubeGradient {f : (Fin (d+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f) (i : Fin (d+1)) :
    C(Fin (d+1) → I,ℂ) where
  toFun x := fderiv ℝ f (fun j => (x j:ℝ)) (Pi.single i 1)
  continuous_toFun := ((hf.continuous_fderiv (by simp)).clm_apply continuous_const).comp (by fun_prop)

lemma deriv_slice {f : (Fin (d+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f)
    (i : Fin (d+1)) (y : Fin d → ℝ) (t : ℝ) :
    deriv (fun t => f (i.insertNth t y)) t =
      fderiv ℝ f (i.insertNth t y) (Pi.single i 1) := by
  exact (((hf.differentiable (by simp)) _).hasFDerivAt.comp_hasDerivAt t
    (hasDerivAt_insertNth i y t)).deriv

lemma cube_derivative_pairing {f : (Fin (d+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f)
    (i : Fin (d+1)) (n : {n : Fin (d+1) → ℕ // n i ≠ 0}) :
    (∫ x, conj (cubeSineMode i n x)*cubeGradient hf i x) =
      -(Real.pi*n.1 i:ℝ)*(∫ x, conj (cubeNeumannMode n.1 x)*cubeFunction hf x) := by
  have hs : Integrable (fun x => conj (cubeSineMode i n x)*cubeGradient hf i x) :=
    (by fun_prop : Continuous (fun x => conj (cubeSineMode i n x)*cubeGradient hf i x)).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _)
  have hc : Integrable (fun x => conj (cubeNeumannMode n.1 x)*cubeFunction hf x) :=
    (by fun_prop : Continuous (fun x => conj (cubeNeumannMode n.1 x)*cubeFunction hf x)).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _)
  rw [integral_cube_split i _ hs,integral_cube_split i _ hc,← integral_const_mul]
  apply integral_congr_ae
  filter_upwards [] with y
  simp only [cubeSineMode_split,cubeNeumannMode_split,map_mul,cubeGradient,cubeFunction,
    ContinuousMap.coe_mk,coe_insertNth]
  have hp := normalized_sine_derivative_pairing
    (hf.comp (contDiff_insertNth i (fun j => (y j:ℝ)))) n.2
  simp only [Function.comp_def,deriv_slice hf] at hp
  simp only [mul_right_comm _ (conj (cubeNeumannMode (n.1 ∘ i.succAbove) y)),integral_mul_const]
  rw [hp]
  ring

end Work_NeumannGradient_scope

open MeasureTheory Set
open scoped BigOperators unitInterval ComplexConjugate ENNReal ContDiff

lemma continuous_toLp_norm_sq {X : Type*} [TopologicalSpace X] [CompactSpace X]
    [MeasurableSpace X] [BorelSpace X] (μ : Measure X) [IsFiniteMeasure μ]
    (f : C(X,ℂ)) : ‖ContinuousMap.toLp 2 μ ℂ f‖^2 = ∫ x, ‖f x‖^2 ∂μ := by
  rw [norm_sq_eq_re_inner (𝕜 := ℂ),ContinuousMap.inner_toLp]
  simp_rw [Complex.mul_conj,Complex.normSq_eq_norm_sq]
  rw [integral_complex_ofReal]
  rfl

variable {d : Type*} [Fintype d]

def neumannCoeff (f : C(d → I,ℂ)) (n : d → ℕ) : ℂ :=
  ∫ x, conj (cubeNeumannMode n x)*f x

lemma neumannCoeff_eq_inner (f : C(d → I,ℂ)) (n : d → ℕ) :
    neumannCoeff f n = inner ℂ (neumannLp n) (ContinuousMap.toLp 2 volume ℂ f) := by
  rw [ContinuousMap.inner_toLp]
  simp only [neumannCoeff,mul_comm]

lemma neumann_parseval (f : C(d → I,ℂ)) :
    (∑' n, ‖neumannCoeff f n‖^2) = ∫ x, ‖f x‖^2 := by
  let v := ContinuousMap.toLp 2 volume ℂ f
  have h := lp.norm_rpow_eq_tsum (p := (2:ENNReal)) (by norm_num)
    (neumannBasis.repr v)
  simp only [ENNReal.toReal_ofNat,Real.rpow_two,HilbertBasis.repr_apply_apply,
    neumannBasis_apply,LinearIsometryEquiv.norm_map] at h
  simpa only [v,neumannCoeff_eq_inner,continuous_toLp_norm_sq] using h.symm

lemma neumannCoeff_summable (f : C(d → I,ℂ)) :
    Summable (fun n => ‖neumannCoeff f n‖^2) := by
  simp only [neumannCoeff_eq_inner]
  exact orthonormal_neumann.inner_products_summable _

variable {D : ℕ}

lemma neumann_derivative_bessel {f : (Fin (D+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f)
    (i : Fin (D+1)) (S : Finset {n : Fin (D+1) → ℕ // n i ≠ 0}) :
    ∑ n ∈ S, (Real.pi*(n.1 i:ℝ))^2*‖neumannCoeff (cubeFunction hf) n.1‖^2 ≤
      ∫ x, ‖cubeGradient hf i x‖^2 := by
  have h := (orthonormal_cubeSine i).sum_inner_products_le
    (s := S) (ContinuousMap.toLp 2 volume ℂ (cubeGradient hf i))
  rw [continuous_toLp_norm_sq] at h
  refine le_trans (le_of_eq ?_) h
  apply Finset.sum_congr rfl
  intro n _
  rw [ContinuousMap.inner_toLp]
  have he : (∫ x, cubeGradient hf i x*conj (cubeSineMode i n x)) =
      -(Real.pi*n.1 i:ℝ)*neumannCoeff (cubeFunction hf) n.1 := by
    simpa only [neumannCoeff,mul_comm] using cube_derivative_pairing hf i n
  simp only [he,norm_mul,norm_neg,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs]

theorem neumann_spectral_lower {f : (Fin (D+1) → ℝ) → ℂ} (hf : ContDiff ℝ 1 f)
    (S : Finset (Fin (D+1) → ℕ)) :
    ∑ n ∈ S, (∑ i, (Real.pi*(n i:ℝ))^2)*‖neumannCoeff (cubeFunction hf) n‖^2 ≤
      ∑ i, ∫ x, ‖cubeGradient hf i x‖^2 := by
  classical
  simp only [Finset.sum_mul]
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro i _
  let S' := S.subtype (fun n => n i ≠ 0)
  have h := neumann_derivative_bessel hf i S'
  refine le_trans (le_of_eq ?_) h
  dsimp only [S']
  rw [Finset.sum_subtype_eq_sum_filter
    (fun n : Fin (D+1) → ℕ => (Real.pi*(n i:ℝ))^2*‖neumannCoeff (cubeFunction hf) n‖^2),
    Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro n _
  by_cases hn : n i = 0 <;> simp [hn]

end CoulombNeumann

end

end OAI