import Mathlib

namespace OAI

/-! Uniform Fourier decay and localized Taylor amplitudes. -/

open MeasureTheory
open scoped NNReal ENNReal ContDiff
noncomputable section
open Filter
open scoped Topology ContDiff

open MeasureTheory Set
open scoped ContDiff FourierTransform InnerProductSpace ENNReal
namespace DiagonalExtension.UniformFourierDecay
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

theorem weighted_fourier_bound {f : E → ℂ} (hf : ContDiff ℝ ∞ f)
    (hfc : HasCompactSupport f) (n : ℕ) {M : ℝ} (_hM : 0 ≤ M)
    (hderiv : ∀ j ≤ n, ∫ y, ‖iteratedFDeriv ℝ j f y‖ ≤ M) (x : E) :
    (1 + ‖x‖) ^ n * ‖𝓕 f x‖ ≤ (2 : ℝ) ^ n * (1 + 2 ^ n * (n + 1)) * M := by
  have hint (k j : ℕ) : Integrable (fun y : E => ‖y‖ ^ k * ‖iteratedFDeriv ℝ j f y‖) :=
    (((continuous_norm.pow k).mul (hf.continuous_iteratedFDeriv (by exact WithTop.coe_le_coe.mpr le_top)).norm)).integrable_of_hasCompactSupport
      (((hfc.iteratedFDeriv j).norm).mul_left)
  have h0 : ‖𝓕 f x‖ ≤ M := by
    exact (VectorFourier.norm_fourierIntegral_le_integral_norm Real.fourierChar volume (innerₗ E) f x).trans
      (by simpa only [norm_iteratedFDeriv_zero] using hderiv 0 (Nat.zero_le n))
  have hw := Real.pow_mul_norm_iteratedFDeriv_fourier_le (K := (0 : ℕ∞)) (N := ⊤)
    hf (fun k j _ _ => hint k j) (k := 0) (n := n) (by simp) (by simp) x
  have hw' : ‖x‖ ^ n * ‖𝓕 f x‖ ≤ 2 ^ n * ((n + 1) * M) := by
    simp only [pow_zero, zero_add, one_mul, norm_iteratedFDeriv_zero,
      Nat.cast_zero, Finset.range_one, Finset.singleton_product, Finset.sum_map, Function.Embedding.sectR_apply,
      mul_zero] at hw
    refine hw.trans ?_
    apply mul_le_mul_of_nonneg_left _ (by positivity)
    calc
      _ ≤ ∑ j ∈ Finset.range (n + 1), M := by
        apply Finset.sum_le_sum
        intro j hj
        exact hderiv j (Nat.lt_succ_iff.mp (Finset.mem_range.mp hj))
      _ = _ := by simp
  have hp : (1 + ‖x‖) ^ n ≤ 2 ^ n * (1 + ‖x‖ ^ n) := by
    refine (add_pow_le (a := (1:ℝ)) (b := ‖x‖) (by positivity) (norm_nonneg _) n).trans ?_
    simp only [one_pow]
    gcongr
    · norm_num
    · omega
  calc
    _ ≤ 2 ^ n * (1 + ‖x‖ ^ n) * ‖𝓕 f x‖ := mul_le_mul_of_nonneg_right hp (norm_nonneg _)
    _ = 2 ^ n * (‖𝓕 f x‖ + ‖x‖ ^ n * ‖𝓕 f x‖) := by ring
    _ ≤ 2 ^ n * (M + 2 ^ n * ((n + 1) * M)) := by gcongr
    _ = _ := by ring

end DiagonalExtension.UniformFourierDecay

namespace DiagonalExtension.UniformFourierDecay
variable {P : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]

lemma iteratedFDeriv_section {F : P × E → ℂ} (hF : ContDiff ℝ ∞ F)
    (p : P) (z : E) (j : ℕ) :
    iteratedFDeriv ℝ j (fun y => F (p,y)) z =
      (iteratedFDeriv ℝ j F (p,z)).compContinuousLinearMap
        (fun _ => ContinuousLinearMap.inr ℝ P E) := by
  let g : P × E → ℂ := fun q => F ((p,0) + q)
  have hg : ContDiff ℝ ∞ g := hF.comp (contDiff_const.add contDiff_id)
  have heq := (ContinuousLinearMap.inr ℝ P E).iteratedFDeriv_comp_right hg z
    (i := j) (by exact WithTop.coe_le_coe.mpr le_top)
  have ht := iteratedFDerivWithin_comp_add_left (𝕜 := ℝ) (f := F) (s := Set.univ)
    j (p, (0:E)) ((0:P),z)
  simp only [Set.vadd_set_univ, iteratedFDerivWithin_univ, Prod.mk_add_mk,
    add_zero, zero_add] at ht
  simp only [Function.comp_def, g, ContinuousLinearMap.inr_apply,
    Prod.mk_add_mk, add_zero, zero_add] at heq
  rw [show iteratedFDeriv ℝ j (fun q : P × E => F ((p,0) + q)) (0,z) =
    iteratedFDeriv ℝ j F (p,z) from ht] at heq
  exact heq

lemma continuous_section_derivative {F : P × E → ℂ} (hF : ContDiff ℝ ∞ F) (j : ℕ) :
    Continuous (fun q : P × E => iteratedFDeriv ℝ j (fun y => F (q.1,y)) q.2) := by
  simp_rw [iteratedFDeriv_section hF]
  exact (ContinuousMultilinearMap.compContinuousLinearMapL
    (fun _ : Fin j => ContinuousLinearMap.inr ℝ P E)).continuous.comp
    (hF.continuous_iteratedFDeriv (by exact WithTop.coe_le_coe.mpr le_top))

variable [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

theorem compact_uniform_decay {F : P × E → ℂ} (hF : ContDiff ℝ ∞ F)
    {K : Set P} (hK : IsCompact K) {S : Set E} (hS : IsCompact S)
    (hsupp : ∀ p ∈ K, tsupport (fun z => F (p,z)) ⊆ S) (n : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ p ∈ K, ∀ x : E,
      (1 + ‖x‖) ^ n * ‖𝓕 (fun z => F (p,z)) x‖ ≤ C := by
  have hb (j : ℕ) : ∃ C : ℝ, 0 ≤ C ∧ ∀ p ∈ K,
      ∫ z, ‖iteratedFDeriv ℝ j (fun y => F (p,y)) z‖ ≤ C := by
    obtain ⟨B,hB⟩ := (hK.prod hS).exists_bound_of_continuousOn
      (continuous_section_derivative hF j).continuousOn
    refine ⟨max B 0 * (volume S).toReal, by positivity, ?_⟩
    intro p hp
    have hf : ContDiff ℝ ∞ (fun z => F (p,z)) :=
      hF.comp (contDiff_const.prodMk contDiff_id)
    have hfc : HasCompactSupport (fun z => F (p,z)) :=
      hS.of_isClosed_subset isClosed_closure (hsupp p hp)
    have hc : Continuous (fun z => ‖iteratedFDeriv ℝ j (fun y => F (p,y)) z‖) :=
      (hf.continuous_iteratedFDeriv (by exact WithTop.coe_le_coe.mpr le_top)).norm
    rw [← setIntegral_eq_integral_of_forall_compl_eq_zero (s := S) (fun z hz => ?_)]
    · calc
        _ ≤ ∫ _ in S, max B 0 := by
          apply setIntegral_mono_on (hc.continuousOn.integrableOn_compact hS)
            (integrableOn_const hS.measure_lt_top.ne) hS.measurableSet
          intro z hz
          exact (hB (p,z) ⟨hp,hz⟩).trans (le_max_left _ _)
        _ = _ := by simp [mul_comm, Measure.real_def]
    · exact norm_eq_zero.mpr (Function.notMem_support.mp fun h => hz
        (hsupp p hp (support_iteratedFDeriv_subset j h)))
  choose B hB hbound using hb
  let M := ∑ j ∈ Finset.range (n+1), B j
  have hM : 0 ≤ M := Finset.sum_nonneg fun j _ => hB j
  refine ⟨2 ^ n * (1 + 2 ^ n * (n+1)) * M, by positivity, ?_⟩
  intro p hp x
  apply weighted_fourier_bound (hF.comp (contDiff_const.prodMk contDiff_id))
    (hS.of_isClosed_subset isClosed_closure (hsupp p hp)) n hM _ x
  intro j hj
  exact (hbound j p hp).trans (Finset.single_le_sum (fun i _ => hB i)
    (Finset.mem_range.mpr (Nat.lt_succ_of_le hj)))

end DiagonalExtension.UniformFourierDecay
open MeasureTheory Set Filter Metric
open scoped ContDiff Topology
namespace DiagonalExtension.SmoothCompactIntegral
universe u
variable {P A B : Type u}
  [NormedAddCommGroup P] [NormedSpace ℝ P]
  [NormedAddCommGroup A] [NormedSpace ℝ A]
  [NormedAddCommGroup B] [NormedSpace ℝ B]

def paramDeriv (F : P × A → B) (q : P × A) : P →L[ℝ] B :=
  (fderiv ℝ F q).comp (ContinuousLinearMap.inl ℝ P A)

lemma smooth_partial {F : P × A → B} (hF : ContDiff ℝ ∞ F) :
    ContDiff ℝ ∞ (paramDeriv F) :=
  (hF.fderiv_right (by simp)).clm_comp contDiff_const

lemma partial_hasFDerivAt {F : P × A → B} (hF : ContDiff ℝ ∞ F) (p : P) (a : A) :
    HasFDerivAt (fun q => F (q,a)) (paramDeriv F (p,a)) p := by
  convert ((hF.differentiable (by simp)) (p,a)).hasFDerivAt.comp p
    ((hasFDerivAt_id (𝕜 := ℝ) p).prodMk (hasFDerivAt_const (𝕜 := ℝ) a p)) using 1 <;> rfl

variable [FiniteDimensional ℝ P] [FiniteDimensional ℝ A]
  [MeasurableSpace A] [BorelSpace A]
variable {μ : Measure A} [IsFiniteMeasureOnCompacts μ]

lemma hasFDerivAt_integral {K : Set A} (hK : IsCompact K) {F : P × A → B}
    (hF : ContDiff ℝ ∞ F) (p : P) :
    HasFDerivAt (fun q => ∫ a in K, F (q,a) ∂μ)
      (∫ a in K, paramDeriv F (p,a) ∂μ) p := by
  have : IsFiniteMeasure (μ.restrict K) := ⟨by simpa using (hK.measure_lt_top (μ := μ))⟩
  obtain ⟨C,hC⟩ := ((isCompact_closedBall p 1).prod hK).exists_bound_of_continuousOn
    (smooth_partial hF).continuous.continuousOn
  refine hasFDerivAt_integral_of_dominated_of_fderiv_le
    (s := closedBall p 1) (F' := fun q a => paramDeriv F (q,a)) (bound := fun _ => C)
    (closedBall_mem_nhds p (by norm_num)) ?_ ?_ ?_ ?_ (integrable_const C) ?_
  · exact Filter.Eventually.of_forall fun q =>
      (hF.continuous.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  · exact (hF.continuous.comp (continuous_const.prodMk continuous_id)).continuousOn.integrableOn_compact hK
  · exact ((smooth_partial hF).continuous.comp
      (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  · filter_upwards [ae_restrict_mem hK.measurableSet] with a ha
    intro q hq
    exact hC (q,a) ⟨hq,ha⟩
  · exact Filter.Eventually.of_forall fun a q _ => partial_hasFDerivAt hF q a

private lemma smooth_integral_nat (n : ℕ) {K : Set A} (hK : IsCompact K)
    {F : P × A → B} (hF : ContDiff ℝ ∞ F) :
    ContDiff ℝ n (fun q => ∫ a in K, F (q,a) ∂μ) := by
  induction n generalizing B with
  | zero =>
    exact contDiff_zero.mpr (Differentiable.continuous
      (fun p => (hasFDerivAt_integral hK hF p).differentiableAt))
  | succ n ih =>
    rw [Nat.cast_add, Nat.cast_one, contDiff_succ_iff_fderiv]
    refine ⟨fun p => (hasFDerivAt_integral hK hF p).differentiableAt, by simp, ?_⟩
    have heq : fderiv ℝ (fun q => ∫ a in K, F (q,a) ∂μ) =
        (fun q => ∫ a in K, paramDeriv F (q,a) ∂μ) :=
      funext fun p => (hasFDerivAt_integral hK hF p).fderiv
    rw [heq]
    exact ih (smooth_partial hF)

theorem contDiff_integral {K : Set A} (hK : IsCompact K) {F : P × A → B}
    (hF : ContDiff ℝ ∞ F) : ContDiff ℝ ∞ (fun q => ∫ a in K, F (q,a) ∂μ) :=
  contDiff_infty.mpr fun n => smooth_integral_nat n hK hF

end DiagonalExtension.SmoothCompactIntegral

namespace DiagonalExtension.PacketTaylor
open MeasureTheory Set
open scoped ContDiff FourierTransform InnerProductSpace
variable {E : Type} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E]

def remainder (φ : E → ℝ) (q : (E × ℝ) × E) : ℝ :=
  ∫ s in Set.Icc (0:ℝ) 1, (1-s) *
    (fderiv ℝ (fderiv ℝ φ) (q.1.1 + (s*q.1.2) • q.2) q.2) q.2

lemma smooth_remainder {φ : E → ℝ} (hφ : ContDiff ℝ ∞ φ) :
    ContDiff ℝ ∞ (remainder φ) := by
  unfold remainder
  apply SmoothCompactIntegral.contDiff_integral (μ := (volume : Measure ℝ))
    (F := fun q : ((E × ℝ) × E) × ℝ => (1-q.2) *
      (fderiv ℝ (fderiv ℝ φ) (q.1.1.1 + (q.2*q.1.1.2) • q.1.2) q.1.2) q.1.2)
    isCompact_Icc
  have hH : ContDiff ℝ ∞ (fderiv ℝ (fderiv ℝ φ)) :=
    (hφ.fderiv_right (m := ∞) (by simp)).fderiv_right (by simp)
  have hloc : ContDiff ℝ ∞ (fun q : ((E × ℝ) × E) × ℝ =>
      q.1.1.1 + (q.2*q.1.1.2) • q.1.2) := by fun_prop
  exact (contDiff_const.sub contDiff_snd).mul
    (((hH.comp hloc).clm_apply (contDiff_snd.comp contDiff_fst)).clm_apply
      (contDiff_snd.comp contDiff_fst))

omit [FiniteDimensional ℝ E] in
lemma taylor_identity {φ : E → ℝ} (hφ : ContDiff ℝ ∞ φ)
    (ν z : E) (δ : ℝ) :
    φ (ν + δ • z) = φ ν + δ * (fderiv ℝ φ ν z) + δ^2 * remainder φ ((ν,δ),z) := by
  have ht := map_add_eq_sum_add_integral_iteratedFDeriv (f := φ) (x := ν) (y := δ • z)
    (n := 1) (fun _ _ => (hφ.of_le (by exact WithTop.coe_le_coe.mpr le_top)).contDiffAt)
  simp only [Nat.reduceAdd, Finset.sum_range_succ, Finset.sum_range_zero, zero_add,
    Nat.factorial_zero, Nat.factorial_one, Nat.cast_one, inv_one, one_smul,
    iteratedFDeriv_zero_apply, iteratedFDeriv_one_apply, pow_one,
    iteratedFDeriv_two_apply] at ht
  rw [intervalIntegral.integral_of_le (by norm_num : (0:ℝ) ≤ 1),
    ← integral_Icc_eq_integral_Ioc] at ht
  simp only [smul_smul, map_smul, smul_apply, smul_eq_mul] at ht
  rw [ht, remainder, ← integral_const_mul]
  congr 1
  apply setIntegral_congr_fun measurableSet_Icc
  intro s hs
  ring

abbrev Param (E : Type) := (E × ℝ) × (ℝ × (E × ℝ))

def amplitude (φ χ : E → ℝ) (q : Param E × E) : ℂ :=
  (χ q.2 : ℂ) * (χ (q.1.2.2.1 + q.1.2.2.2 • q.2) : ℂ) *
    Complex.exp ((2 * Real.pi * (q.1.2.1 * remainder φ (q.1.1,q.2)) : ℝ) * Complex.I)

lemma smooth_amplitude {φ χ : E → ℝ} (hφ : ContDiff ℝ ∞ φ) (hχ : ContDiff ℝ ∞ χ) :
    ContDiff ℝ ∞ (amplitude φ χ) := by
  have hr : ContDiff ℝ ∞ (fun q : Param E × E => remainder φ (q.1.1,q.2)) :=
    (smooth_remainder hφ).comp (by fun_prop)
  have h1 : ContDiff ℝ ∞ (fun q : Param E × E => (χ q.2 : ℂ)) :=
    Complex.ofRealCLM.contDiff.comp (hχ.comp contDiff_snd)
  have h2 : ContDiff ℝ ∞ (fun q : Param E × E => (χ (q.1.2.2.1 + q.1.2.2.2 • q.2) : ℂ)) :=
    Complex.ofRealCLM.contDiff.comp (hχ.comp (by fun_prop))
  have ht : ContDiff ℝ ∞ (fun q : Param E × E => q.1.2.1) := by fun_prop
  have h3 : ContDiff ℝ ∞ (fun q : Param E × E => ((2 * Real.pi * (q.1.2.1 * remainder φ (q.1.1,q.2)) : ℝ) : ℂ)) :=
    Complex.ofRealCLM.contDiff.comp (contDiff_const.mul (ht.mul hr))
  exact (h1.mul h2).mul (((Complex.contDiff_exp : ContDiff ℂ ∞ Complex.exp).restrict_scalars ℝ).comp (h3.mul contDiff_const))

variable [MeasurableSpace E] [BorelSpace E]

theorem normalized_locality {φ χ : E → ℝ} (hφ : ContDiff ℝ ∞ φ)
    (hχ : ContDiff ℝ ∞ χ) (hχc : HasCompactSupport χ) (R A : ℝ) (L : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ ν δ τ a ρ,
      ‖ν‖ ≤ R → δ ∈ Icc (0:ℝ) 1 → τ ∈ Icc (0:ℝ) 1 →
      ‖a‖ ≤ A → ρ ∈ Icc (0:ℝ) 1 → ∀ x : E,
      (1 + ‖x‖)^L * ‖𝓕 (fun z => amplitude φ χ (((ν,δ),(τ,(a,ρ))),z)) x‖ ≤ C := by
  let K : Set (Param E) := (Metric.closedBall 0 R ×ˢ Icc 0 1) ×ˢ
    (Icc 0 1 ×ˢ (Metric.closedBall 0 A ×ˢ Icc 0 1))
  have hK : IsCompact K := ((isCompact_closedBall 0 R).prod isCompact_Icc).prod
    (isCompact_Icc.prod ((isCompact_closedBall 0 A).prod isCompact_Icc))
  have hsupp : ∀ p ∈ K, tsupport (fun z => amplitude φ χ (p,z)) ⊆ tsupport χ := by
    intro p hp
    apply closure_mono
    intro z hz
    simp only [Function.mem_support] at *
    intro h
    apply hz
    simp [amplitude,h]
  obtain ⟨C,hC,h⟩ := UniformFourierDecay.compact_uniform_decay (smooth_amplitude hφ hχ)
    hK hχc hsupp L
  refine ⟨C,hC,?_⟩
  intro ν δ τ a ρ hν hδ hτ ha hρ x
  apply h ((ν,δ),(τ,(a,ρ))) _ x
  exact ⟨⟨by simpa using hν,hδ⟩,hτ,by simpa using ha,hρ⟩

end DiagonalExtension.PacketTaylor

end

end OAI