import Mathlib
import OAI.Analysis.HardSphere.Orbitals.FieldApply

namespace OAI

section
section
noncomputable section
open MeasureTheory Filter Set
open scoped Topology ENNReal BigOperators
open scoped RealInnerProductSpace
namespace ComplexRegularization

def regularize (ε : ℝ) (z : ℂ) : ℂ := (Real.sqrt (‖z‖ ^ 2 + ε ^ 2) - ε : ℝ)

def differential (ε : ℝ) (z : ℂ) : ℂ →L[ℝ] ℂ :=
  (Real.sqrt (‖z‖ ^ 2 + ε ^ 2))⁻¹ • (Complex.ofRealCLM.comp (innerSL ℝ z))

lemma smooth {ε : ℝ} (hε : 0 < ε) :
    ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (regularize ε) := by
  apply Complex.ofRealCLM.contDiff.comp
  apply ContDiff.sub _ contDiff_const
  apply ContDiff.sqrt ((contDiff_norm_sq ℝ).add contDiff_const)
  intro z
  positivity

lemma zero {ε : ℝ} (hε : 0 ≤ ε) : regularize ε 0 = 0 := by
  simp [regularize, Real.sqrt_sq hε]

lemma hasFDerivAt {ε : ℝ} (hε : 0 < ε) (z : ℂ) :
    HasFDerivAt (regularize ε) (differential ε z) z := by
  have hn : ‖z‖ ^ 2 + ε ^ 2 ≠ 0 := by positivity
  have h := Complex.ofRealCLM.hasFDerivAt.comp z
    ((((hasStrictFDerivAt_norm_sq z).hasFDerivAt.add_const (ε ^ 2)).sqrt hn).sub_const ε)
  have hd : differential ε z = Complex.ofRealCLM.comp
      ((1 / (2 * Real.sqrt (‖z‖ ^ 2 + ε ^ 2))) • (2 • innerSL ℝ z)) := by
    ext w
    simp [differential, two_smul, div_eq_mul_inv, mul_inv_rev]
    ring

  rw [hd]
  exact h

lemma sqroot_ge_norm (ε : ℝ) (z : ℂ) : ‖z‖ ≤ Real.sqrt (‖z‖ ^ 2 + ε ^ 2) := by
  exact (Real.le_sqrt (norm_nonneg _) (by positivity)).mpr (by nlinarith [sq_nonneg ε])

lemma differential_apply_le (ε : ℝ) (z w : ℂ) :
    ‖differential ε z w‖ ≤ ‖w‖ := by
  by_cases hz : z = 0
  · simp [hz, differential]
  have hp : 0 < Real.sqrt (‖z‖ ^ 2 + ε ^ 2) :=
    lt_of_lt_of_le (norm_pos_iff.mpr hz) (sqroot_ge_norm ε z)
  simp only [differential, smul_apply, ContinuousLinearMap.comp_apply,
    norm_smul, Complex.ofRealCLM_apply, Complex.norm_real, Real.norm_eq_abs, abs_inv,
    abs_of_pos hp, innerSL_apply_apply]
  change _ * ‖inner ℝ z w‖ ≤ _
  apply le_trans (mul_le_mul_of_nonneg_left (norm_inner_le_norm (𝕜 := ℝ) z w) (by positivity :
    0 ≤ (Real.sqrt (‖z‖ ^ 2 + ε ^ 2))⁻¹))
  rw [← div_eq_inv_mul, div_le_iff₀ hp]
  simpa only [mul_comm] using mul_le_mul_of_nonneg_right (sqroot_ge_norm ε z) (norm_nonneg w)

lemma differential_le (ε : ℝ) (z : ℂ) : ‖differential ε z‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro w
  simpa only [one_mul] using differential_apply_le ε z w

lemma fderiv_eq {ε : ℝ} (hε : 0 < ε) (z : ℂ) :
    fderiv ℝ (regularize ε) z = differential ε z := (hasFDerivAt hε z).fderiv

lemma tendsto_regularize (z : ℂ) {e : ℕ → ℝ} (he : Tendsto e atTop (𝓝 0)) :
    Tendsto (fun n ↦ regularize (e n) z) atTop (𝓝 (‖z‖ : ℂ)) := by
  have h : Tendsto (fun n ↦ Real.sqrt (‖z‖ ^ 2 + e n ^ 2) - e n) atTop (𝓝 ‖z‖) := by
    have h := (((tendsto_const_nhds (x := ‖z‖ ^ 2)).add (he.pow 2)).sqrt.sub he)
    simpa using h

  exact Complex.continuous_ofReal.tendsto _ |>.comp h

lemma tendsto_differential (z : ℂ) {e : ℕ → ℝ} (he : Tendsto e atTop (𝓝 0)) :
    Tendsto (fun n ↦ differential (e n) z) atTop (𝓝 (differential 0 z)) := by
  by_cases hz : z = 0
  · simp only [hz, differential, map_zero, ContinuousLinearMap.comp_zero, smul_zero]
    exact tendsto_const_nhds
  have hp : Real.sqrt (‖z‖ ^ 2 + (0 : ℝ) ^ 2) ≠ 0 := by
    simp [Real.sqrt_sq (norm_nonneg z), hz]
  exact (((tendsto_const_nhds.add (he.pow 2)).sqrt.inv₀ hp).smul tendsto_const_nhds)

end ComplexRegularization

namespace HardSphere
open ComplexRegularization

def regularization (ε : ℝ) (hε : 0 < ε) : SmoothContraction where
  toFun := regularize ε
  smooth := smooth hε
  zero := zero hε.le
  derivative_le z := by rw [fderiv_eq hε]; exact differential_le ε z

def regularizationScale (n : ℕ) : ℝ := 1 / ((n : ℝ) + 1)

lemma regularizationScale_pos (n : ℕ) : 0 < regularizationScale n := by
  unfold regularizationScale
  positivity

lemma tendsto_regularizationScale : Tendsto regularizationScale atTop (𝓝 0) :=
  tendsto_one_div_add_atTop_nhds_zero_nat

lemma modulus_lipschitz : LipschitzWith 1 (fun z : ℂ ↦ (‖z‖ : ℂ)) := by
  apply LipschitzWith.of_dist_le_mul
  intro z w
  simpa only [dist_eq_norm, ← Complex.ofReal_sub, Complex.norm_real, NNReal.coe_one, one_mul]
    using dist_norm_norm_le z w

def modulusScalar {N : ℕ} {L : Length} (u : ScalarL2 N L) : ScalarL2 N L :=
  modulus_lipschitz.compLp (by simp) u

lemma coe_modulusScalar {N : ℕ} {L : Length} (u : ScalarL2 N L) :
    modulusScalar u =ᵐ[volume] fun X ↦ (‖u X‖ : ℂ) :=
  modulus_lipschitz.coeFn_compLp (by simp) u

lemma modulusCoefficient_meas {N : ℕ} {L : Length} (u : ScalarL2 N L) :
    AEStronglyMeasurable (fun X ↦ differential 0 (u X)) volume := by
  apply aestronglyMeasurable_of_tendsto_ae atTop (f := fun n X ↦
    differential (regularizationScale n) (u X))
  · intro n
    have he : differential (regularizationScale n) =
        fderiv ℝ (regularize (regularizationScale n)) :=
      funext fun z ↦ (fderiv_eq (regularizationScale_pos n) z).symm
    rw [he]
    exact ((smooth (regularizationScale_pos n)).continuous_fderiv (by simp)).comp_aestronglyMeasurable
      (Lp.aestronglyMeasurable u)
  · exact Eventually.of_forall fun X ↦ tendsto_differential (u X) tendsto_regularizationScale

def modulusPartial {N : ℕ} {L : Length} (u v : ScalarL2 N L) : ScalarL2 N L :=
  L2Contraction.fieldApply (fun X ↦ differential 0 (u X)) (modulusCoefficient_meas u)
    (Eventually.of_forall fun X ↦ differential_le 0 (u X)) v

def modulusJet {N : ℕ} {L : Length} (u : Jet N L) : Jet N L :=
  (modulusScalar u.1, fun p ↦ modulusPartial u.1 (u.2 p))

lemma coe_modulusPartial {N : ℕ} {L : Length} (u v : ScalarL2 N L) :
    modulusPartial u v =ᵐ[volume] fun X ↦ differential 0 (u X) (v X) :=
  L2Contraction.coe_fieldApply _ _ _ v

lemma tendsto_regularization_partial {N : ℕ} {L : Length} (u v : ScalarL2 N L) :
    Tendsto (fun n ↦ (regularization (regularizationScale n) (regularizationScale_pos n)).onPartial u v)
      atTop (𝓝 (modulusPartial u v)) := by
  refine L2Contraction.tendsto_toLp_of_domination
    (fun n ↦ L2Contraction.field_memLp _
      (L2Contraction.coeff_meas _ (regularization _ (regularizationScale_pos n)).derivative_continuous u)
      (Eventually.of_forall fun X ↦ (regularization _ (regularizationScale_pos n)).derivative_le (u X)) v)
    (L2Contraction.field_memLp _ (modulusCoefficient_meas u)
      (Eventually.of_forall fun X ↦ differential_le 0 (u X)) v)
    (Lp.memLp v) ?_ ?_
  · intro n
    apply Eventually.of_forall
    intro X
    change ‖fderiv ℝ (regularize (regularizationScale n)) (u X) (v X)‖ ≤ ‖v X‖
    rw [fderiv_eq (regularizationScale_pos n)]
    exact differential_apply_le _ _ _
  · apply Eventually.of_forall
    intro X
    change Tendsto (fun n ↦ fderiv ℝ (regularize (regularizationScale n)) (u X) (v X))
      atTop (𝓝 (differential 0 (u X) (v X)))
    simp only [fderiv_eq (regularizationScale_pos _)]
    exact ((ContinuousLinearMap.apply ℝ ℂ (v X)).continuous.tendsto _).comp
      (tendsto_differential (u X) tendsto_regularizationScale)

lemma tendsto_regularization_scalar {N : ℕ} {L : Length} (u : ScalarL2 N L) :
    Tendsto (fun n ↦ (regularization (regularizationScale n) (regularizationScale_pos n)).onScalar u)
      atTop (𝓝 (modulusScalar u)) := by
  have he (f : ℂ → ℂ) (hf : LipschitzWith 1 f) (h0 : f 0 = 0) :
      hf.compLp h0 u = (hf.comp_memLp h0 (Lp.memLp u)).toLp (f ∘ u) := by
    apply Lp.ext
    exact (hf.coeFn_compLp h0 u).trans (MemLp.coeFn_toLp _).symm
  simp only [SmoothContraction.onScalar, modulusScalar, he]
  refine L2Contraction.tendsto_toLp_of_domination
    (fun n ↦ (regularization _ (regularizationScale_pos n)).lipschitz.comp_memLp
      (regularization _ (regularizationScale_pos n)).zero (Lp.memLp u))
    (modulus_lipschitz.comp_memLp (by simp) (Lp.memLp u)) (Lp.memLp u) ?_ ?_
  · intro n
    apply Eventually.of_forall
    intro X
    have h := (regularization (regularizationScale n) (regularizationScale_pos n)).lipschitz.norm_sub_le
      (u X) 0
    simpa only [SmoothContraction.zero, sub_zero, NNReal.coe_one, one_mul, Function.comp_apply] using h
  · exact Eventually.of_forall fun X ↦ tendsto_regularize (u X) tendsto_regularizationScale

lemma tendsto_regularization_jet {N : ℕ} {L : Length} (u : Jet N L) :
    Tendsto (fun n ↦ (regularization (regularizationScale n) (regularizationScale_pos n)).onJet u)
      atTop (𝓝 (modulusJet u)) :=
  (tendsto_regularization_scalar u.1).prodMk_nhds
    (tendsto_pi_nhds.mpr fun p ↦ tendsto_regularization_partial u.1 (u.2 p))

lemma modulusJet_mem_domain {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
    (hu : u ∈ dirichletDomain N L a) : modulusJet u ∈ dirichletDomain N L a :=
  isClosed_closure.mem_of_tendsto (tendsto_regularization_jet u)
    (Eventually.of_forall fun n ↦
      (regularization (regularizationScale n) (regularizationScale_pos n)).onJet_mem_domain hu)

lemma norm_modulusScalar {N : ℕ} {L : Length} (u : ScalarL2 N L) :
    ‖modulusScalar u‖ = ‖u‖ := by
  have he : ∀ᵐ X ∂volume, ‖modulusScalar u X‖ = ‖u X‖ := by
    filter_upwards [coe_modulusScalar u] with X hX
    simp [hX]
  exact le_antisymm (Lp.norm_le_norm_of_ae_le (he.mono fun _ hx ↦ hx.le))
    (Lp.norm_le_norm_of_ae_le (he.mono fun _ hx ↦ hx.ge))

lemma energy_modulusJet_le {N : ℕ} {L : Length} (u : Jet N L) :
    energy (modulusJet u) ≤ energy u := by
  apply Finset.sum_le_sum
  intro p _
  apply pow_le_pow_left₀ (norm_nonneg _) _ 2
  exact L2Contraction.norm_fieldApply_le _ (modulusCoefficient_meas u.1)
    (Eventually.of_forall fun X ↦ differential_le 0 (u.1 X)) (u.2 p)

lemma bosonic_modulusScalar {N : ℕ} {L : Length} {u : ScalarL2 N L}
    (hu : bosonic u) : bosonic (modulusScalar u) := by
  intro σ
  have hp : MeasurePreserving (fun X : Configuration N L ↦ fun i ↦ X (σ i)) volume volume := by
    have h := volume_measurePreserving_piCongrLeft (fun _ : Fin N ↦ Torus L) σ.symm
    convert h using 1
    funext X i
    simp [MeasurableEquiv.coe_piCongrLeft, Equiv.piCongrLeft_apply]
  have hae := hp.quasiMeasurePreserving.ae_eq_comp (coe_modulusScalar u)
  filter_upwards [hae, coe_modulusScalar u, hu σ] with X h1 h2 h3
  change modulusScalar u (fun i ↦ X (σ i)) = (‖u (fun i ↦ X (σ i))‖ : ℂ) at h1
  rw [h1, h2, h3]

lemma IsGroundVector.modulus {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
    (hu : IsGroundVector N L a u) : IsGroundVector N L a (modulusJet u) := by
  refine ⟨modulusJet_mem_domain hu.1, bosonic_modulusScalar hu.2.1, ?_, ?_⟩
  · exact (norm_modulusScalar u.1).trans hu.2.2.1
  · intro v hv hb hn
    exact (energy_modulusJet_le u).trans (hu.2.2.2 v hv hb hn)

lemma IsGroundVector.energy_modulus {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
    (hu : IsGroundVector N L a u) : energy (modulusJet u) = energy u :=
  le_antisymm (energy_modulusJet_le u)
    (hu.2.2.2 _ hu.modulus.1 hu.modulus.2.1 hu.modulus.2.2.1)

end HardSphere

end
end
end

end OAI