lean/OAI/Dynamics/ThreeTorus/NeutralSupport.lean

import OAI.Dynamics.ThreeTorus.Transmission

namespace OAI

/-! Neutral lattice sampling, retained support, and stationary image separation. -/

section

noncomputable section
open MeasureTheory Set Filter
open scoped Topology
namespace ThreeTorus

lemma cell_sample_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f) (a : ℝ) :
    |f a - ∫ x in a..a+1, f x| ≤ ∫ x in a..a+1, |deriv f x| := by
  have hc : Continuous (fun x => |deriv f x|) := (hf.continuous_deriv (by norm_num)).abs
  have hbound (x : ℝ) (hx : x ∈ Icc a (a+1)) :
      |f a-f x| ≤ ∫ t in a..a+1, |deriv f t| := by
    have hFTC := intervalIntegral.integral_deriv_eq_sub
      (fun t _ => hf.differentiable (by norm_num) t)
      ((hf.continuous_deriv (by norm_num)).intervalIntegrable (a := a) (b := x))
    calc
      _ = |∫ t in a..x, deriv f t| := by rw [hFTC, abs_sub_comm]
      _ ≤ ∫ t in a..x, |deriv f t| := by
        simpa only [Real.norm_eq_abs] using intervalIntegral.norm_integral_le_integral_norm hx.1 (f := deriv f)
      _ ≤ ∫ t in a..a+1, |deriv f t| := by
        exact intervalIntegral.integral_mono_interval le_rfl hx.1 hx.2
          (Filter.Eventually.of_forall (fun _ => abs_nonneg _)) (hc.intervalIntegrable _ _)
  calc
    _ = |∫ x in a..a+1, (f a-f x)| := by
      rw [intervalIntegral.integral_sub intervalIntegrable_const (hf.continuous.intervalIntegrable _ _)]
      simp
    _ ≤ ∫ x in a..a+1, |f a-f x| := by
      simpa only [Real.norm_eq_abs] using intervalIntegral.norm_integral_le_integral_norm (by linarith : a ≤ a+1)
        (f := fun x => f a-f x)
    _ ≤ ∫ _ in a..a+1, (∫ t in a..a+1, |deriv f t|) :=
      intervalIntegral.integral_mono_on (by linarith) ((continuous_const.sub hf.continuous).abs.intervalIntegrable _ _)
        intervalIntegrable_const hbound
    _ = _ := by simp

/-- Arbitrary-offset unit lattice estimate, before scaling to the neutral refresh mesh. -/
lemma lattice_sample_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f)
    (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) (a : ℝ) :
    Summable (fun j : ℤ => f (a+j)) ∧
      |(∑' j : ℤ, f (a+j)) - ∫ x, f x| ≤ ∫ x, |deriv f x| := by
  let c (j : ℤ) := ∫ x in (a+j)..(a+j+1), f x
  let b (j : ℤ) := ∫ x in (a+j)..(a+j+1), |deriv f x|
  let e (j : ℤ) := f (a+j)-c j
  have hc : HasSum c (∫ x, f x) := hi.hasSum_intervalIntegral a
  have hb : HasSum b (∫ x, |deriv f x|) := hdi.hasSum_intervalIntegral a
  have heB (j : ℤ) : ‖e j‖ ≤ b j := by
    exact cell_sample_error hf (a+j)
  have he : Summable e := hb.summable.of_norm_bounded heB
  have hid (j : ℤ) : e j+c j = f (a+j) := by dsimp [e,c]; ring
  have hsum : HasSum (fun j : ℤ => f (a+j)) ((∑' j, e j)+(∫ x, f x)) :=
    (he.hasSum.add hc).congr_fun (fun j => (hid j).symm)
  refine ⟨hsum.summable, ?_⟩
  rw [hsum.tsum_eq, add_sub_cancel_right]
  calc
    _ ≤ ∑' j, ‖e j‖ := by simpa only [Real.norm_eq_abs] using norm_tsum_le_tsum_norm he.norm
    _ ≤ ∑' j, b j := he.norm.tsum_le_tsum heB hb.summable
    _ = _ := hb.tsum_eq

/-- The mesh version of the arbitrary-offset Riemann estimate in neutral refresh. -/
lemma mesh_sample_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f)
    (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|))
    {h : ℝ} (hh : 0 < h) (a : ℝ) :
    Summable (fun j : ℤ => f (a+h*j)) ∧
      |h*(∑' j : ℤ, f (a+h*j)) - ∫ x, f x| ≤ h*∫ x, |deriv f x| := by
  let g : ℝ → ℝ := fun x => f (h*x)
  have hg : ContDiff ℝ 1 g := hf.comp (contDiff_const.mul contDiff_id)
  have hgi : Integrable g := hi.comp_mul_left' hh.ne'
  have hd (x : ℝ) : deriv g x = deriv f (h*x)*h := by
    simpa only [g, Function.comp_def, mul_one] using (((hf.differentiable (by norm_num) (h*x)).hasDerivAt).comp x
      ((hasDerivAt_id x).const_mul h)).deriv
  have hdgi : Integrable (fun x => |deriv g x|) := by
    simp_rw [hd, abs_mul, abs_of_pos hh]
    exact (hdi.comp_mul_left' hh.ne').mul_const h
  have hid (j : ℤ) : g (a/h+j) = f (a+h*j) := by
    dsimp [g]; congr 1; field_simp
  obtain ⟨hs,hb⟩ := lattice_sample_error hg hgi hdgi (a/h)
  simp_rw [hid] at hs hb
  refine ⟨hs, ?_⟩
  have hgint : (∫ x, g x) = h⁻¹*(∫ x, f x) := by
    exact (Measure.integral_comp_mul_left f h).trans (by rw [abs_of_pos (inv_pos.mpr hh)]; rfl)
  have hdint : (∫ x, |deriv g x|) = ∫ x, |deriv f x| := by
    simp_rw [hd, abs_mul, abs_of_pos hh]
    rw [integral_mul_const, Measure.integral_comp_mul_left (fun x => |deriv f x|) h]
    rw [abs_of_pos (inv_pos.mpr hh)]
    simp only [smul_eq_mul]
    field_simp
  rw [hgint, hdint] at hb
  calc
    _ = |h*((∑' j : ℤ, f (a+h*j)) - h⁻¹*(∫ x, f x))| := by
      congr 1
      rw [mul_sub, ← mul_assoc, mul_inv_cancel₀ hh.ne', one_mul]
    _ = h*|(∑' j : ℤ, f (a+h*j)) - h⁻¹*(∫ x, f x)| := by
      rw [abs_mul, abs_of_pos hh]
    _ ≤ _ := mul_le_mul_of_nonneg_left hb hh.le

/-- Exact normalization for a residue class of the neutral refresh lattice. -/
lemma neutral_residue_riemann_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f)
    (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|))
    {P s L : ℝ} (hP : 0 < P) (hs : 0 < s) (hL : 0 < L) (a : ℝ) :
    |(s*L)⁻¹*(∑' j : ℤ, f (a+P/(s*L)*j)) - P⁻¹*(∫ x, f x)|
      ≤ (s*L)⁻¹*(∫ x, |deriv f x|) := by
  have hh : 0 < P/(s*L) := by positivity
  have hb := (mesh_sample_error hf hi hdi hh a).2
  calc
    _ = |P⁻¹*((P/(s*L))*(∑' j : ℤ, f (a+P/(s*L)*j)) - ∫ x, f x)| := by
      congr 1
      field_simp
    _ = P⁻¹*|(P/(s*L))*(∑' j : ℤ, f (a+P/(s*L)*j)) - ∫ x, f x| := by
      rw [abs_mul, abs_of_pos (inv_pos.mpr hP)]
    _ ≤ P⁻¹*((P/(s*L))*(∫ x, |deriv f x|)) :=
      mul_le_mul_of_nonneg_left hb (by positivity)
    _ = _ := by field_simp

end ThreeTorus

namespace ThreeTorus
open MeasureTheory Set Function Filter
open scoped Topology NNReal

/-- Mesh reversal uses the actual integer negation bijection; negative old
angular indices have the same arbitrary-offset Riemann estimate. -/
lemma signed_mesh_sample_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f)
    (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|))
    {h : ℝ} (hh : h ≠ 0) (a : ℝ) :
    Summable (fun j : ℤ => f (a+h*j)) ∧
      |(|h| *(∑' j : ℤ, f (a+h*j))) - ∫ x, f x| ≤ |h| *∫ x, |deriv f x| := by
  rcases lt_or_gt_of_ne hh with hh | hh
  · obtain ⟨hs,hb⟩ := mesh_sample_error hf hi hdi (h := -h) (by linarith) a
    have he (j : ℤ) : f (a+h*j) = f (a+(-h)*(-j:ℤ)) := by
      push_cast; congr 1; ring
    have ht : (∑' j : ℤ, f (a+h*j)) = ∑' j : ℤ, f (a+(-h)*j) := by
      simp_rw [he]
      exact (Equiv.neg ℤ).tsum_eq (fun j : ℤ => f (a+(-h)*j))
    refine ⟨?_,?_⟩
    · simpa only [Function.comp_def, he] using hs.comp_injective (neg_injective : Injective (Neg.neg : ℤ → ℤ))
    · rw [abs_of_neg hh,ht]
      exact hb
  · simpa only [abs_of_pos hh] using mesh_sample_error hf hi hdi hh a

/-- Exact signed normalization, with arbitrary offset and arbitrary positive
integer residue spacing. This is source (neutral-riemann-error). -/
lemma signed_neutral_residue_error {f : ℝ → ℝ} (hf : ContDiff ℝ 1 f)
    (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|))
    {P s L : ℝ} (hP : 0 < P) (hs : s ≠ 0) (hL : 0 < L) (y β : ℝ) :
    Summable (fun j : ℤ => (|s| *L)⁻¹*f (((y+j*P)/s-β)/L)) ∧
      |(∑' j : ℤ, (|s| *L)⁻¹*f (((y+j*P)/s-β)/L))-
          P⁻¹*(∫ a, f a)| ≤ (|s| *L)⁻¹*(∫ a, |deriv f a|) := by
  have hh : P/(s*L) ≠ 0 := div_ne_zero hP.ne' (mul_ne_zero hs hL.ne')
  obtain ⟨hsum,hb⟩ := signed_mesh_sample_error hf hi hdi hh ((y/s-β)/L)
  have hi' (j : ℤ) : (y/s-β)/L+(P/(s*L))*j = ((y+j*P)/s-β)/L := by ring
  simp_rw [hi'] at hsum hb
  have hab : |P/(s*L)| = P/(|s| *L) := by rw [abs_div,abs_mul,abs_of_pos hP,abs_of_pos hL]
  rw [hab] at hb
  refine ⟨hsum.mul_left _,?_⟩
  rw [tsum_mul_left]
  calc
    _ = |P⁻¹*((P/(|s| *L))*(∑' j : ℤ, f (((y+j*P)/s-β)/L)) - ∫ a, f a)| := by
      generalize (∑' j : ℤ, f (((y+j*P)/s-β)/L)) = S
      congr 1; field_simp
    _ = P⁻¹*|(P/(|s| *L))*(∑' j : ℤ, f (((y+j*P)/s-β)/L)) - ∫ a, f a| := by
      rw [abs_mul,abs_of_pos (inv_pos.mpr hP)]
    _ ≤ P⁻¹*((P/(|s| *L))*(∫ a, |deriv f a|)) :=
      mul_le_mul_of_nonneg_left hb (by positivity)
    _ = _ := by field_simp

lemma fine_affine_neutral_error {F : ℝ × ℝ → ℝ} {P n : ℕ} {h : ℤ} {L s : ℝ}
    (hP : 0 < P) (hs : s ≠ 0) (hL : 0 < L) (β : ℝ)
    (hF : ContDiff ℝ 1 (fun a => F (s,a)))
    (hi : Integrable (fun a => F (s,a)))
    (hd : Integrable (fun a => |deriv (fun a => F (s,a)) a|)) :
    |fineResidueKernel (affineKernel F L β) P h n s-
      (P:ℝ)⁻¹*(∫ a, F (s,a))| ≤
      (|s| *L)⁻¹*(∫ a, |deriv (fun a => F (s,a)) a|) := by
  have hh := (signed_neutral_residue_error (P := (P:ℝ)) hF hi hd (by exact_mod_cast hP) hs hL
    ((n:ℝ)*s-h) β).2
  have he : fineResidueKernel (affineKernel F L β) P h n s =
      ∑' j : ℤ, (|s| *L)⁻¹*F (s,((((n:ℝ)*s-h)+j*P)/s-β)/L) := by
    unfold fineResidueKernel affineKernel
    have ht := (Equiv.neg ℤ).tsum_eq
      (fun j : ℤ => (|s| *L)⁻¹*F (s,((((n:ℝ)*s-h)+j*P)/s-β)/L))
    convert ht using 1
    apply tsum_congr
    intro j
    simp only [Equiv.neg_apply,Int.cast_neg]
    congr 3; ring
  rw [he]
  exact hh

end ThreeTorus

namespace ThreeTorus
open MeasureTheory Set Function Filter
open scoped Topology NNReal

lemma compact_slice_tsupport {F : ℝ × ℝ → ℝ} {D : ℝ}
    (hFa : ∀ s a, D < |a| → F (s,a) = 0) (s : ℝ) :
    tsupport (fun a => F (s,a)) ⊆ Icc (-D) D := by
  apply closure_minimal _ isClosed_Icc
  intro a ha
  by_contra hn
  exact ha (hFa s a (lt_of_not_ge (by simpa only [mem_Icc,← abs_le] using hn)))

lemma compact_slice_support {F : ℝ × ℝ → ℝ} {D : ℝ}
    (hFa : ∀ s a, D < |a| → F (s,a) = 0) (s : ℝ) :
    HasCompactSupport (fun a => F (s,a)) :=
  isCompact_Icc.of_isClosed_subset isClosed_closure (compact_slice_tsupport hFa s)

lemma compact_slice_derivative_bound {F : ℝ × ℝ → ℝ} {D : ℝ} {C : ℝ≥0}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F)
    (hFa : ∀ s a, D < |a| → F (s,a) = 0) (hD : 0 ≤ D)
    (hC : LipschitzWith C F) (s : ℝ) :
    Integrable (fun a => F (s,a)) ∧
    Integrable (fun a => |deriv (fun a => F (s,a)) a|) ∧
    (∫ a, |deriv (fun a => F (s,a)) a|) ≤ 2*D*C := by
  have hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (fun a => F (s,a)) :=
    hF.comp ((contDiff_const (c := s)).prodMk contDiff_id)
  have hc := compact_slice_support hFa s
  have hfd : Continuous (deriv (fun a => F (s,a))) := hf.continuous_deriv (by simp)
  have hdi : Integrable (fun a => |deriv (fun a => F (s,a)) a|) :=
    hfd.abs.integrable_of_hasCompactSupport (hc.deriv.comp_left (abs_zero))
  have hl : LipschitzWith C (fun a => F (s,a)) := by
    apply LipschitzWith.of_dist_le_mul
    intro a b
    simpa only [Prod.dist_eq,dist_self,max_eq_right dist_nonneg] using hC.dist_le_mul (s,a) (s,b)
  refine ⟨hf.continuous.integrable_of_hasCompactSupport hc,hdi,?_⟩
  have hzero (a : ℝ) (ha : a ∉ Icc (-D) D) : deriv (fun a => F (s,a)) a = 0 := by
    by_contra hn
    exact ha (compact_slice_tsupport hFa s (support_deriv_subset hn))
  rw [← setIntegral_eq_integral_of_forall_compl_eq_zero (s := Icc (-D) D)
    (f := fun a => |deriv (fun a => F (s,a)) a|) (fun a ha => by rw [hzero a ha,abs_zero])]
  calc
    _ ≤ ∫ _ in Icc (-D) D, (C:ℝ) :=
      setIntegral_mono_on hdi.integrableOn (integrableOn_const (by simp)) measurableSet_Icc
        (fun a _ => by simpa only [← Real.norm_eq_abs] using norm_deriv_le_of_lipschitz (x₀ := a) hl)
    _ = _ := by
      rw [setIntegral_const,Real.volume_real_Icc_of_le (by linarith : -D ≤ D)]
      simp only [smul_eq_mul]
      ring

lemma compact_slice_integral_continuous {F : ℝ × ℝ → ℝ} {D : ℝ}
    (hF : Continuous F) (hFa : ∀ s a, D < |a| → F (s,a) = 0) :
    Continuous (fun s => ∫ a, F (s,a)) := by
  apply continuousOn_univ.mp
  apply continuousOn_integral_of_compact_support (k := Icc (-D) D) isCompact_Icc
  · exact hF.continuousOn
  · intro s a _ ha
    exact hFa s a (lt_of_not_ge (by simpa only [mem_Icc,← abs_le] using ha))

lemma fine_affine_neutral_uniform {F : ℝ × ℝ → ℝ} {P n : ℕ} {h : ℤ}
    {D ε L : ℝ} {C : ℝ≥0}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F)
    (hFa : ∀ s a, D < |a| → F (s,a) = 0) (hD : 0 ≤ D)
    (hC : LipschitzWith C F) (hε : 0 < ε)
    (hz : ∀ s a, |s| < ε → F (s,a) = 0)
    (hP : 0 < P) (hL : 0 < L) (β s : ℝ) :
    |fineResidueKernel (affineKernel F L β) P h n s-
      (P:ℝ)⁻¹*(∫ a, F (s,a))| ≤ (ε*L)⁻¹*(2*D*C) := by
  by_cases hs : |s| < ε
  · have he : (∫ a, F (s,a)) = 0 := by simp [hz s _ hs]
    have hk : fineResidueKernel (affineKernel F L β) P h n s = 0 := by
      unfold fineResidueKernel affineKernel
      simp [hz s _ hs]
    rw [hk,he,mul_zero,sub_self,abs_zero]
    positivity
  · have hsε : ε ≤ |s| := le_of_not_gt hs
    have hs0 : s ≠ 0 := by intro hh; simp [hh] at hsε; linarith
    obtain ⟨hi,hd,hb⟩ := compact_slice_derivative_bound hF hFa hD hC s
    calc
      _ ≤ (|s| *L)⁻¹*(∫ a, |deriv (fun a => F (s,a)) a|) :=
        fine_affine_neutral_error hP hs0 hL β
          ((hF.comp (contDiff_const.prodMk contDiff_id)).of_le (by simp)) hi hd
      _ ≤ (|s| *L)⁻¹*(2*D*C) := mul_le_mul_of_nonneg_left hb (by positivity)
      _ ≤ _ := mul_le_mul_of_nonneg_right
        (inv_anti₀ (by positivity) (mul_le_mul_of_nonneg_right hsε hL.le)) (by positivity)

end ThreeTorus

namespace ThreeTorus
open MeasureTheory Set Function Filter
open scoped Topology NNReal

lemma fine_affine_neutral_l1_error {F : ℝ × ℝ → ℝ} {P n : ℕ} {h : ℤ}
    {A D ε L : ℝ} {C : ℝ≥0}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F)
    (hFs : ∀ s a, A < |s| → F (s,a) = 0) (hA : 0 ≤ A)
    (hFa : ∀ s a, D < |a| → F (s,a) = 0) (hD : 0 ≤ D)
    (hC : LipschitzWith C F) (hε : 0 < ε)
    (hz : ∀ s a, |s| < ε → F (s,a) = 0)
    (hn : 0 < n) (hP : 0 < P) (hL : 0 < L) (β : ℝ) :
    (∫ s, |fineResidueKernel (affineKernel F L β) P h n s-
      (P:ℝ)⁻¹*(∫ a, F (s,a))|) ≤ (2*A)*((ε*L)⁻¹*(2*D*C)) := by
  obtain ⟨M,hM⟩ := exists_nat_ge (A*(L*D+|β|))
  have hk := fineResidueKernel_regular (h := h) (n := n)
    (affineKernel_smooth (L := L) (β := β) hF hε hz).continuous
    (show 0 < max A 1 from lt_max_of_lt_right zero_lt_one)
    (fun s y hh => affineKernel_eq_zero_s hFs (lt_of_le_of_lt (le_max_left _ _) hh))
    (fun s y hh => affineKernel_eq_zero_y hL hA hD hFs hFa (lt_of_le_of_lt hM hh)) hn hP
  have hZ := compact_slice_integral_continuous hF.continuous hFa
  have hcZ : HasCompactSupport (fun s => ∫ a, F (s,a)) := by
    apply HasCompactSupport.intro (isCompact_Icc (a := -A) (b := A))
    intro s hs
    have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,← abs_le] using hs)
    simp [hFs s _ hab]
  have hi := (hk.2.sub ((hZ.integrable_of_hasCompactSupport hcZ).const_mul (P:ℝ)⁻¹)).abs
  have hzero (s : ℝ) (hs : s ∉ Icc (-A) A) :
      |fineResidueKernel (affineKernel F L β) P h n s-(P:ℝ)⁻¹*(∫ a, F (s,a))| = 0 := by
    have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,← abs_le] using hs)
    rw [fineResidueKernel_eq_zero (fun s y hh => affineKernel_eq_zero_s hFs hh) hab]
    simp [hFs s _ hab]
  rw [← setIntegral_eq_integral_of_forall_compl_eq_zero (s := Icc (-A) A) hzero]
  calc
    _ ≤ ∫ _ in Icc (-A) A, (ε*L)⁻¹*(2*D*C) :=
      setIntegral_mono_on hi.integrableOn (integrableOn_const (by simp)) measurableSet_Icc
        (fun s _ => fine_affine_neutral_uniform hF hFa hD hC hε hz hP hL β s)
    _ = _ := by
      rw [setIntegral_const,Real.volume_real_Icc_of_le (by linarith : -A ≤ A)]
      simp only [smul_eq_mul]
      ring

lemma compact_rect_bounds {F : ℝ × ℝ → ℝ} (hc : HasCompactSupport F) :
    ∃ A D : ℝ, 0 ≤ A ∧ 0 ≤ D ∧
      (∀ s a, A < |s| → F (s,a) = 0) ∧ (∀ s a, D < |a| → F (s,a) = 0) := by
  obtain ⟨R,hR⟩ := hc.isBounded.subset_closedBall (0 : ℝ × ℝ)
  refine ⟨max R 0,max R 0,le_max_right _ _,le_max_right _ _,?_,?_⟩
  · intro s a hs
    by_contra hn
    have hh := hR (subset_tsupport _ hn)
    rw [Metric.mem_closedBall,dist_zero_right,Prod.norm_def] at hh
    have hh' : |s| ≤ R := by simpa only [Real.norm_eq_abs] using (le_max_left ‖s‖ ‖a‖).trans hh
    exact (not_lt_of_ge (hh'.trans (le_max_left _ _))) hs
  · intro s a hs
    by_contra hn
    have hh := hR (subset_tsupport _ hn)
    rw [Metric.mem_closedBall,dist_zero_right,Prod.norm_def] at hh
    have hh' : |a| ≤ R := by simpa only [Real.norm_eq_abs] using (le_max_right ‖s‖ ‖a‖).trans hh
    exact (not_lt_of_ge (hh'.trans (le_max_left _ _))) hs

/-- Uniform residue equalization for actual compact smooth stationary weight.
One slope is chosen before the passage integer, with all lattice phases,
all residues, and both signs controlled. -/
lemma neutral_fine_l1_bound {F : ℝ × ℝ → ℝ}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F) (hcF : HasCompactSupport F)
    {ε : ℝ} (hε : 0 < ε) (hz : ∀ s a, |s| < ε → F (s,a) = 0) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ {P n : ℕ}, 0 < P → 0 < n → ∀ h : ℤ, ∀ L : ℝ, 0 < L → ∀ β : ℝ,
      (∫ s, |fineResidueKernel (affineKernel F L β) P h n s-
        (P:ℝ)⁻¹*(∫ a, F (s,a))|) ≤ C/L := by
  obtain ⟨A,D,hA,hD,hFs,hFa⟩ := compact_rect_bounds hcF
  obtain ⟨C,hC⟩ := compact_smooth_lipschitz hF hcF
  refine ⟨(2*A)*(2*D*C)/ε,by positivity,?_⟩
  intro P n hP hn h L hL β
  have hb := fine_affine_neutral_l1_error (h := h) hF hFs hA hFa hD hC hε hz hn hP hL β
  convert hb using 1; ring

end ThreeTorus

namespace ThreeTorus
open MeasureTheory Set Function Filter
open scoped Topology NNReal

lemma deriv_affine_on {I : Set ℝ} {J : ℝ → ℝ} {L β : ℝ}
    (hIo : IsOpen I) (he : ∀ a ∈ I, J a = L*a+β) {a : ℝ} (ha : a ∈ I) :
    deriv J a = L := by
  have hev : J =ᶠ[𝓝 a] (fun x => L*x+β) := by
    filter_upwards [hIo.mem_nhds ha] with x hx using he x hx
  rw [hev.deriv_eq]
  simp

/-- The branch is the actual inverse of the affine jitter on the good arc.
Off that image both sides vanish because the old stationary weight is cut off. -/
lemma branchKernel_affine_on {I : Set ℝ} {J : ℝ → ℝ} {F : ℝ × ℝ → ℝ} {L β : ℝ}
    (hIo : IsOpen I) (hL : 0 < L) (he : ∀ a ∈ I, J a = L*a+β)
    (hs : tsupport F ⊆ I ×ˢ univ) (y s : ℝ) :
    branchKernel I J F (y,s) = L⁻¹*F ((y-β)/L,s) := by
  classical
  have hinj : InjOn J I := by
    intro a ha b hb hab
    rw [he a ha,he b hb] at hab
    nlinarith
  by_cases hy : y ∈ J '' I
  · obtain ⟨a,ha,rfl⟩ := hy
    have hg := hinj.leftInvOn_invFunOn ha
    have ht : (J a-β)/L = a := by rw [he a ha]; field_simp; ring
    rw [branchKernel,ite_eq_left (mem_image_of_mem J ha),hg,deriv_affine_on hIo he ha,
      abs_of_pos hL,ht]
    ring
  · have ha : (y-β)/L ∉ I := by
      intro hh
      apply hy
      refine ⟨(y-β)/L,hh,?_⟩
      rw [he _ hh]
      field_simp
      ring
    have hz : F ((y-β)/L,s) = 0 := by
      by_contra hn
      exact ha (hs (subset_tsupport _ hn)).1
    rw [branchKernel,ite_eq_right hy,hz,mul_zero]

lemma passageBranchKernel_affine_on {I : Set ℝ} {J : ℝ → ℝ} {F : ℝ × ℝ → ℝ} {L β : ℝ}
    (hIo : IsOpen I) (hL : 0 < L) (he : ∀ a ∈ I, J a = L*a+β)
    (hs : tsupport F ⊆ I ×ˢ univ) :
    passageBranchKernel I J F = affineKernel (F ∘ Prod.swap) L β := by
  funext s y
  rw [passageBranchKernel_formula,branchKernel_affine_on hIo hL he hs]
  simp only [affineKernel,Function.comp_apply,Prod.swap_prod_mk,mul_inv_rev]
  ring

lemma compact_slice_integral_regular {F : ℝ × ℝ → ℝ}
    (hF : Continuous F) (hcF : HasCompactSupport F) :
    Continuous (fun s => ∫ a, F (s,a)) ∧ Integrable (fun s => ∫ a, F (s,a)) := by
  obtain ⟨A,D,_,_,hFs,hFa⟩ := compact_rect_bounds hcF
  have hZ := compact_slice_integral_continuous hF hFa
  refine ⟨hZ,hZ.integrable_of_hasCompactSupport ?_⟩
  apply HasCompactSupport.intro (isCompact_Icc (a := -A) (b := A))
  intro s hs
  have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,← abs_le] using hs)
  simp [hFs s _ hab]

lemma affine_fine_regular {F : ℝ × ℝ → ℝ}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F) (hcF : HasCompactSupport F)
    {ε : ℝ} (hε : 0 < ε) (hz : ∀ s a, |s| < ε → F (s,a) = 0)
    {P n : ℕ} (hP : 0 < P) (hn : 0 < n) (h : ℤ) {L : ℝ} (hL : 0 < L) (β : ℝ) :
    Continuous (fineResidueKernel (affineKernel F L β) P h n) ∧
      Integrable (fineResidueKernel (affineKernel F L β) P h n) := by
  obtain ⟨A,D,hA,hD,hFs,hFa⟩ := compact_rect_bounds hcF
  obtain ⟨M,hM⟩ := exists_nat_ge (A*(L*D+|β|))
  apply fineResidueKernel_regular
    (affineKernel_smooth (L := L) (β := β) hF hε hz).continuous
    (show 0 < max A 1 from lt_max_of_lt_right zero_lt_one)
    (fun s y hh => affineKernel_eq_zero_s hFs (lt_of_le_of_lt (le_max_left _ _) hh))
    (fun s y hh => affineKernel_eq_zero_y hL hA hD hFs hFa (lt_of_le_of_lt hM hh)) hn hP

/-- The neutral equalization estimate on the actual temporal circle, uniformly
in the large preparation integer, residues, offsets and affine good-arc jitter.
The constant is fixed using only the old cut-off stationary weight. -/
lemma neutral_branch_circle_l1_bound {F : ℝ × ℝ → ℝ}
    (hF : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F) (hcF : HasCompactSupport F)
    {ε : ℝ} (hε : 0 < ε) (hz : ∀ a s, |s| < ε → F (a,s) = 0) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ {I : Set ℝ} {J : ℝ → ℝ} {P n : ℕ},
      IsOpen I → tsupport F ⊆ I ×ˢ univ → 0 < P → 0 < n →
      ∀ h : ℤ, ∀ L : ℝ, 0 < L → ∀ β : ℝ, (∀ a ∈ I, J a = L*a+β) →
      (∫ z, |foldCircleDensity (fineResidueKernel (passageBranchKernel I J F) P h n) z-
        foldCircleDensity (fun s => (P:ℝ)⁻¹*(∫ a, F (a,s))) z| ∂AddCircle.haarAddCircle) ≤ C/L := by
  have hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (F ∘ Prod.swap) :=
    hF.comp (contDiff_snd.prodMk contDiff_fst)
  have hc : HasCompactSupport (F ∘ Prod.swap) := hcF.comp_homeomorph (Homeomorph.prodComm ℝ ℝ)
  have hzf : ∀ s a, |s| < ε → (F ∘ Prod.swap) (s,a) = 0 := fun s a hs => hz a s hs
  obtain ⟨C,hC,hb⟩ := neutral_fine_l1_bound hf hc hε hzf
  refine ⟨C,hC,?_⟩
  intro I J P n hIo hsF hP hn h L hL β he
  rw [passageBranchKernel_affine_on hIo hL he hsF]
  have hq := affine_fine_regular hf hc hε hzf hP hn h hL β
  have hr := compact_slice_integral_regular hf.continuous hc
  calc
    _ ≤ ∫ s, |fineResidueKernel (affineKernel (F ∘ Prod.swap) L β) P h n s-
        (P:ℝ)⁻¹*(∫ a, F (a,s))| :=
      foldCircleDensity_l1_difference hq.1.measurable hq.2
        (measurable_const.mul hr.1.measurable) (hr.2.const_mul _)
    _ ≤ _ := hb hP hn h L hL β

end ThreeTorus

namespace ThreeTorus
open MeasureTheory Set Function Filter
open scoped Topology NNReal

/-- The broad slope is chosen after the cutoff weight and before the periodic jitter is fixed;
the final passage integer is only subject to a lower bound. The displayed
reference density is exactly the old cutoff stationary marginal, folded to
the temporal circle and divided by the residue modulus. -/
lemma exact_neutral_circle_spectral_estimate
    {A : UnitAddCircle × UnitAddCircle → ℂ} {A₀ : UnitAddCircle → ℝ → ℂ}
    {Pr V : ℝ → ℝ} {m : ℤ} {δ : ℕ → ℝ} {H : ℕ → UnitAddCircle → UnitAddCircle}
    {o l u R : ℝ}
    (hm : m ≠ 0)
    (hH : ∀ n (x : ℝ), H n (x : UnitAddCircle) = ((n:ℝ)*(Pr x+δ n*x) : UnitAddCircle))
    (hA : ∀ a x, x ∈ Ioc o (o+1) → A ((x : UnitAddCircle),a) = A₀ a x)
    (hA₀ : ∀ a, ContDiff ℝ 2 (A₀ a)) (hAc : Continuous A₀.uncurry)
    (hAd : Continuous (fun p : UnitAddCircle × ℝ => deriv (A₀ p.1) p.2))
    (hAr : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞)
      (fun p : ℝ × ℝ => A₀ (p.2 : UnitAddCircle) p.1))
    (hsupp : ∀ a, support (A₀ a) ⊆ Ioc l u)
    (hlo : o ≤ l) (huo : u ≤ o+1) (hlu : l ≤ u) (hR : 0 < R)
    (hPr : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) Pr)
    (hV : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V) (hPV : deriv Pr = V)
    (hdV : ∀ x ∈ Icc (l-2*R) (u+2*R), 0 < deriv V x)
    (h0 : 0 ∉ (fun x => (m:ℝ)*V x) '' Icc l u)
    (hHc : ∀ n, Continuous (H n)) (hAcont : Continuous A) (hδt : Tendsto δ atTop (𝓝 0))
    {I : Set ℝ} {o' : ℝ}
    {χ : ℝ → UnitAddCircle → ℝ} {ψ : UnitAddCircle → ℝ} {ψ₀ : ℝ → ℝ}
    (hIo : IsOpen I)
    (hψ₀ : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) ψ₀) (hcψ₀ : HasCompactSupport ψ₀)
    (hsψ₀ : tsupport ψ₀ ⊆ Ioc o' (o'+1) ∩ I)
    (heψ : ∀ x ∈ Ioc o' (o'+1), ψ₀ x = ψ (x : UnitAddCircle))
    (hψc : Continuous ψ) (hχc : Continuous χ.uncurry) (hcχ : HasCompactSupport χ.uncurry)
    (hzχ : ∀ a, χ 0 a = 0)
    (hψ : ∀ a, 0 ≤ ψ a ∧ ψ a ≤ 1) (hχ : ∀ s a, 0 ≤ χ s a ∧ χ s a ≤ 1)
    (hχW : ∀ s a, stationaryWeight (Icc (l-R) (u+R)) (fun x => (m:ℝ)*V x) (A₀ a) s ≠ 0 → χ s a = 1)
    {Q : ℕ} (hQ : 0 < Q) (h : ℤ) :
    let F := stationaryCutoffLift (Icc (l-R) (u+R)) (fun x => (m:ℝ)*V x)
      (fun p : ℝ × ℝ => A₀ (p.2 : UnitAddCircle) p.1) ψ₀
    ∃ C : ℝ, 0 ≤ C ∧ ∀ L : ℝ, 0 < L → ∀ β : ℝ,
      ∀ (J₀ : ℝ → ℝ) (J : UnitAddCircle → ℝ),
      (∀ a ∈ I, J₀ a = L*a+β) →
      ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) J₀ → Measurable J →
      (∀ x ∈ I, J (x : UnitAddCircle) = J₀ x) →
      ∃ S : ℕ → Finset ℤ,
        (∀ n, 0 < n → ∀ k ∈ S n, h+k*(Q:ℤ) ≠ 0) ∧
        (∀ n, 0 < n → ∀ k ∉ S n, ∀ a, χ (((h+k*(Q:ℤ):ℤ):ℝ)/n) a = 0) ∧
        ∀ η : ℝ, 0 < η → ∀ᶠ n : ℕ in atTop,
          (∫ a, |foldCircleDensity (fun t => ∑ k ∈ S n,
            unfoldedModeDensity I J₀ (invFunOn J₀ I) (deriv J₀)
              (circleDensityLift o' (retainedCircleWeight ψ χ
                (fun n j => exactPassageCoeff m (H n) A j) n (h+k*(Q:ℤ))))
              n ((h+k*(Q:ℤ):ℤ):ℝ) t) a-
            foldCircleDensity (fun s => (Q:ℝ)⁻¹*(∫ a, F (a,s))) a|
            ∂AddCircle.haarAddCircle) < C/L+η := by
  let B : ℝ × ℝ → ℂ := fun p => A₀ (p.2 : UnitAddCircle) p.1
  let F := stationaryCutoffLift (Icc (l-R) (u+R)) (fun x => (m:ℝ)*V x) B ψ₀
  change ∃ C, _
  obtain ⟨hF,hcF,ε,hε,hz⟩ := exact_cutoff_weight_regular hm hR hV hdV hAr
    (fun a => (hsupp a).trans Ioc_subset_Icc_self) hψ₀ hcψ₀ h0
  have hKA : ∀ p : ℝ × ℝ, B p ≠ 0 → p.1 ∈ Icc l u :=
    fun p hp => Ioc_subset_Icc_self (hsupp _ hp)
  have hsF : tsupport F ⊆ I ×ˢ univ := by
    intro p hp
    exact ⟨(hsψ₀ (stationaryCutoffLift_support (continuous_const.mul hV.continuous)
      isCompact_Icc hKA hp).1).2,mem_univ _⟩
  obtain ⟨C,hC,hBound⟩ := neutral_branch_circle_l1_bound hF hcF hε hz
  refine ⟨C,hC,?_⟩
  intro L hL β J₀ J he hJ hj hJe
  have hinj : InjOn J₀ I := by
    intro a ha b hb hab
    rw [he a ha,he b hb] at hab
    nlinarith
  have hd : ∀ x ∈ I, deriv J₀ x ≠ 0 := fun x hx => by
    rw [deriv_affine_on hIo he hx]
    exact hL.ne'
  obtain ⟨S,hSN,hST,ht⟩ := exact_passage_circle_spectral_limit hm hH hA hA₀ hAc hAd hAr
    hsupp hlo huo hlu hR hPr hV hPV hdV h0 hHc hAcont hδt hJ hIo hinj hd hj hJe
    hψ₀ hcψ₀ hsψ₀ heψ hψc hχc hcχ hzχ hψ hχ hχW hQ h
  refine ⟨S,hSN,hST,?_⟩
  intro η hη
  have hηt := ht.eventually (gt_mem_nhds hη)
  have hu (n : ℕ) (hn : 0 < n) :
      Integrable (foldCircleDensity (fun t => ∑ k ∈ S n,
        unfoldedModeDensity I J₀ (invFunOn J₀ I) (deriv J₀)
          (circleDensityLift o' (retainedCircleWeight ψ χ
            (fun n j => exactPassageCoeff m (H n) A j) n (h+k*(Q:ℤ))))
          n ((h+k*(Q:ℤ):ℤ):ℝ) t)) AddCircle.haarAddCircle := by
    apply integrable_foldCircleDensity
    · exact (S n).measurable_fun_sum (fun k hk => (retained_unfolded_regular hJ hIo hinj hd
        hψc hχc (fun n j => continuous_exactPassageCoeff (hHc n) hAcont j)
        o' hn (hSN n hn k hk)).1)
    · exact integrable_finsetSum _ (fun k hk => (retained_unfolded_regular hJ hIo hinj hd
        hψc hχc (fun n j => continuous_exactPassageCoeff (hHc n) hAcont j)
        o' hn (hSN n hn k hk)).2)
  obtain ⟨hK,AK,hAK,MK,hsK,hyK⟩ := passageBranchKernel_regular hJ hIo hinj hd hF hcF hsF hε hz
  have hv (n : ℕ) (hn : 0 < n) := fineResidueKernel_regular (h := h) hK hAK hsK hyK hn hQ
  have hw := compact_slice_integral_regular ((hF.comp (contDiff_snd.prodMk contDiff_fst)).continuous)
    (hcF.comp_homeomorph (Homeomorph.prodComm ℝ ℝ))
  have hwi : Integrable (foldCircleDensity (fun s => (Q:ℝ)⁻¹*(∫ a, F (a,s))))
      AddCircle.haarAddCircle :=
    integrable_foldCircleDensity (measurable_const.mul hw.1.measurable) (hw.2.const_mul _)
  filter_upwards [hηt,eventually_gt_atTop (0 : ℕ)] with n hn hn0
  have hbn := hBound hIo hsF hQ hn0 h L hL β he
  exact (integral_abs_sub_triangle (hu n hn0)
    (integrable_foldCircleDensity (hv n hn0).1.measurable (hv n hn0).2) hwi).trans_lt
    (by linarith)

end ThreeTorus
end
end

section

/-! The two exact support separations in the passage and stage construction.
No spectral or asymptotic separation is substituted for actual disjoint sets. -/
noncomputable section
open Set Function
open scoped Topology
namespace ThreeTorus

/-- One integral shift separates the speed ranges for all distinct integer
angular indices in a finite list. It also keeps every range away from zero. -/
theorem exists_integral_speed_separation {ι X : Type*} [Finite ι]
    [TopologicalSpace X] [CompactSpace X] (m : ι → ℤ) (φ : X → ℝ)
    (hm : ∀ i, m i ≠ 0) (hφ : Continuous φ) :
    ∃ c : ℕ, 0 < c ∧
      (∀ i x, (m i : ℝ) * ((c:ℝ) + φ x) ≠ 0) ∧
      (∀ i j x y, (m i : ℝ) * ((c:ℝ) + φ x) =
        (m j : ℝ) * ((c:ℝ) + φ y) → m i = m j) := by
  obtain ⟨R,hR⟩ := (isCompact_range hφ).isBounded.exists_norm_le
  obtain ⟨D,hD⟩ := (Set.finite_range (fun i => (m i : ℝ))).isCompact.isBounded.exists_norm_le
  let B := max R 0
  let M := max D 0
  have hB : 0 ≤ B := le_max_right _ _
  have hM : 0 ≤ M := le_max_right _ _
  have hφB x : |φ x| ≤ B := (hR _ (mem_range_self x)).trans (le_max_left _ _)
  have hmM i : |(m i : ℝ)| ≤ M := (hD _ (mem_range_self i)).trans (le_max_left _ _)
  obtain ⟨c,hc⟩ := exists_nat_gt (2*M*B+B+1)
  have hMB : 0 ≤ M*B := mul_nonneg hM hB
  have hcB : B < (c:ℝ) := by nlinarith
  have hcp : (0:ℝ) < c := hB.trans_lt hcB
  refine ⟨c,by exact_mod_cast hcp,?_,?_⟩
  · intro i x
    apply mul_ne_zero (by exact_mod_cast hm i)
    have ht := (abs_le.mp (hφB x)).1
    linarith
  · intro i j x y he
    by_contra hij
    have hd : 1 ≤ |((m i-m j : ℤ):ℝ)| := by
      exact_mod_cast Int.one_le_abs (sub_ne_zero.mpr hij)
    have he' : ((m i:ℝ)-(m j:ℝ))*(c:ℝ) = (m j:ℝ)*φ y-(m i:ℝ)*φ x := by
      nlinarith [he]
    have hh : |(m j:ℝ)*φ y-(m i:ℝ)*φ x| ≤ 2*M*B := calc
      _ ≤ |(m j:ℝ)*φ y|+|(m i:ℝ)*φ x| := abs_sub _ _
      _ = |(m j:ℝ)| *|φ y|+|(m i:ℝ)| *|φ x| := by rw [abs_mul,abs_mul]
      _ ≤ M*B+M*B := add_le_add
        (mul_le_mul (hmM j) (hφB y) (abs_nonneg _) hM)
        (mul_le_mul (hmM i) (hφB x) (abs_nonneg _) hM)
      _ = 2*M*B := by ring
    rw [← he',abs_mul,abs_of_pos hcp] at hh
    simp only [Int.cast_sub] at hd
    nlinarith

/-- A stationary image of an amplitude support. The pair records frequency
and the unchanged slow coordinate. -/
def stationaryImage (m : ℤ) (V : ℝ → ℝ) (K : Set (ℝ × UnitAddCircle)) :
    Set (ℝ × UnitAddCircle) :=
  (fun p : ℝ × UnitAddCircle => ((m:ℝ)*V p.1,p.2)) '' K

lemma stationaryImage_compact {m : ℤ} {V : ℝ → ℝ} {K : Set (ℝ × UnitAddCircle)}
    (hV : Continuous V) (hK : IsCompact K) : IsCompact (stationaryImage m V K) :=
  hK.image ((continuous_const.mul (hV.comp continuous_fst)).prodMk continuous_snd)

/-- For equal angular indices, branch injectivity preserves the exact gaps
between disjoint coefficient supports. -/
lemma stationaryImage_disjoint_same {m : ℤ} (hm : m ≠ 0) {V : ℝ → ℝ} {I : Set ℝ}
    (hV : InjOn V I) {K L : Set (ℝ × UnitAddCircle)}
    (hK : K ⊆ I ×ˢ univ) (hL : L ⊆ I ×ˢ univ) (hd : Disjoint K L) :
    Disjoint (stationaryImage m V K) (stationaryImage m V L) := by
  rw [Set.disjoint_left]
  rintro _ ⟨p,hp,rfl⟩ ⟨q,hq,he⟩
  have he1 := congrArg Prod.fst he
  have he2 := congrArg Prod.snd he
  have heV : V q.1 = V p.1 := mul_left_cancel₀ (by exact_mod_cast hm) he1
  have hep : q = p := Prod.ext (hV (hL hq).1 (hK hp).1 heV) he2
  exact Set.disjoint_left.mp hd hp (hep ▸ hq)

/-- Different angular indices are separated by their frequency ranges. -/
lemma stationaryImage_disjoint_distinct {m n : ℤ} {V : ℝ → ℝ}
    {K L : Set (ℝ × UnitAddCircle)}
    (hsep : ∀ p ∈ K, ∀ q ∈ L, (m:ℝ)*V p.1 ≠ (n:ℝ)*V q.1) :
    Disjoint (stationaryImage m V K) (stationaryImage n V L) := by
  rw [Set.disjoint_left]
  rintro _ ⟨p,hp,rfl⟩ ⟨q,hq,he⟩
  exact hsep p hp q hq (congrArg Prod.fst he).symm

end ThreeTorus
end
end

end OAI