diff --git a/LeanPool/CarlesonLT.lean b/LeanPool/CarlesonLT.lean
new file mode 100644
index 0000000000..3c417911a8
--- /dev/null
+++ b/LeanPool/CarlesonLT.lean
@@ -0,0 +1,28 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+
+module
+
+/- Adapted for Lean Pool from roos-j/lean-lt-carleson. -/
+
+public import LeanPool.CarlesonLT.Auto.ModelOperator
+public import LeanPool.CarlesonLT.Auto.AnisotropicCarleson
+public import LeanPool.CarlesonLT.Auto.ParametricIntegralContDiff
+public import LeanPool.CarlesonLT.Auto.HardyLittlewoodMaximal
+public import LeanPool.CarlesonLT.Auto.ClassicalCarleson
+public import LeanPool.CarlesonLT.Defs
+public import LeanPool.CarlesonLT.Theorems
+
+/-!
+# Anisotropic Carleson bounds and almost-everywhere Fourier convergence
+
+Source: arxiv:1710.10962, doi:10.1007/s00041-018-09657-7, url:https://github.com/roos-j/lean-lt-carleson
+Authors: Joris Roos
+Status: verified
+Main declarations: `CarlesonLT.anisotropic_carleson`, `CarlesonLT.classical_carleson`
+Tags: harmonic-analysis, fourier-series, time-frequency-analysis, maximal-operators
+MSC: 42A20, 42B20, 42B25
+-/
diff --git a/LeanPool/CarlesonLT/Auto/AnisotropicCarleson.lean b/LeanPool/CarlesonLT/Auto/AnisotropicCarleson.lean
new file mode 100644
index 0000000000..feae0d4125
--- /dev/null
+++ b/LeanPool/CarlesonLT/Auto/AnisotropicCarleson.lean
@@ -0,0 +1,4311 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Proofs generated by Claude under Joris Roos’s supervision; adapted for Lean Pool. -/
+
+public import LeanPool.CarlesonLT.Auto.ModelOperator
+public import LeanPool.CarlesonLT.Defs
+public import Mathlib.Analysis.Real.Pi.Bounds
+public import Mathlib.Analysis.SpecialFunctions.Log.Base
+
+/-!
+# Bounds for anisotropic Carleson operators: proof of Theorem 1.1
+
+Part of the formalization of Theorem 1.1 of
+
+* J. Roos, *Bounds for anisotropic Carleson operators*, arXiv:1710.10962v1 (2017),
+  J. Fourier Anal. Appl. (doi:10.1007/s00041-018-09657-7).
+
+This file contains the reduction of Theorem 1.1 to the bound for the model operator
+(Theorem 3.2, `Auto.thm_3_2` in `LeanPool/CarlesonLT/Auto/ModelOperator.lean`):
+the averaging procedure and
+Lemma 3.3 (Section 3), and the proof of Theorem 1.1 itself (cone decomposition, reflections,
+averaging and weak type bounds). The main results are `Auto.thm_1_1` and
+`Auto.anisotropic_carleson`, the latter in the formulation of `LeanPool/CarlesonLT/Defs.lean`.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open MeasureTheory Real Complex UnitAddTorus
+open scoped NNReal ENNReal InnerProductSpace SchwartzMap ComplexConjugate
+
+namespace CarlesonLT.Auto
+
+variable {n : ℕ}
+
+/-! ### Fourier series on a box and the fixed-scale identity (paper, Lemma 3.3, texline~233) -/
+
+section TorusParseval
+
+/-- The Haar probability measure on the unit circle, as in
+    `Mathlib.Analysis.Fourier.AddCircleMulti`. -/
+local instance unitCircleMeasureSpace : MeasureSpace UnitAddCircle := ⟨AddCircle.haarAddCircle⟩
+
+local instance unitCircleProbabilityMeasure :
+    IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+/-- The exponential `e^{-2πi⟨ℓ, x⟩}` on `ℝⁿ = Fin n → ℝ`. -/
+def expLat (ℓ : Fin n → ℤ) (x : Fin n → ℝ) : ℂ :=
+  Complex.exp (-(2 * π * Complex.I * ∑ i, (ℓ i : ℂ) * (x i : ℂ)))
+
+theorem mFourier_neg_coe (ℓ : Fin n → ℤ) (x : Fin n → ℝ) :
+    mFourier (-ℓ) (fun i => (x i : UnitAddCircle)) = expLat ℓ x := by
+  simp only [mFourier, ContinuousMap.coe_mk, Pi.neg_apply, fourier_coe_apply, expLat]
+  rw [← Complex.exp_sum]
+  congr 1
+  rw [Finset.mul_sum, ← Finset.sum_neg_distrib]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  push_cast
+  ring
+
+/-- The fundamental domain `∏ᵢ (bᵢ, bᵢ + 1]`. -/
+def boxIoc (b : Fin n → ℝ) : Set (Fin n → ℝ) := {x | ∀ i, x i ∈ Set.Ioc (b i) (b i + 1)}
+
+/-- The lift of the torus to the fundamental domain `∏ᵢ (bᵢ, bᵢ + 1]`. -/
+def liftT (b : Fin n → ℝ) (t : UnitAddTorus (Fin n)) : Fin n → ℝ :=
+  fun i => (AddCircle.equivIoc 1 (b i) (t i) : ℝ)
+
+theorem liftT_coe (b : Fin n → ℝ) {x : Fin n → ℝ} (hx : x ∈ boxIoc b) :
+    liftT b (fun i => (x i : UnitAddCircle)) = x := by
+  funext i
+  simp only [liftT]
+  rw [AddCircle.equivIoc_coe_of_mem (hx i)]
+
+theorem measurable_liftT (b : Fin n → ℝ) : Measurable (liftT b) := by
+  have : liftT b = Subtype.val ∘ (measurableEquivPiIoc b) := by
+    funext t; rfl
+  rw [this]
+  exact measurable_subtype_coe.comp (measurableEquivPiIoc b).measurable
+
+theorem measurableSet_boxIoc (b : Fin n → ℝ) : MeasurableSet (boxIoc b) := by
+  have : boxIoc b = Set.pi Set.univ fun i => Set.Ioc (b i) (b i + 1) := by
+    ext x; simp [boxIoc]
+  rw [this]
+  exact MeasurableSet.univ_pi fun i => measurableSet_Ioc
+
+/-- Parseval's identity for bounded measurable functions supported in a fundamental domain of
+`ℤⁿ` (a consequence of Mathlib's Parseval identity on `UnitAddTorus`):
+`∑_{ℓ ∈ ℤⁿ} conj(Ghat(ℓ)) Hhat(ℓ) = ∫_B conj(G) H`, with `Ghat(ℓ) = ∫_B e^{-2πi⟨ℓ,x⟩} G(x) dx`. -/
+theorem hasSum_parseval_box (b : Fin n → ℝ) {G H : (Fin n → ℝ) → ℂ} (hGm : Measurable G)
+    (hHm : Measurable H) {CG CH : ℝ} (hGb : ∀ x, ‖G x‖ ≤ CG) (hHb : ∀ x, ‖H x‖ ≤ CH) :
+    HasSum (fun ℓ : Fin n → ℤ => conj (∫ x in boxIoc b, expLat ℓ x * G x) *
+        ∫ x in boxIoc b, expLat ℓ x * H x)
+      (∫ x in boxIoc b, conj (G x) * H x) := by
+  set GT : UnitAddTorus (Fin n) → ℂ := G ∘ liftT b
+  set HT : UnitAddTorus (Fin n) → ℂ := H ∘ liftT b
+  have hG2 : MemLp GT 2 := MemLp.of_bound (hGm.comp (measurable_liftT b)).aestronglyMeasurable CG
+    (Filter.Eventually.of_forall fun t => hGb _)
+  have hH2 : MemLp HT 2 := MemLp.of_bound (hHm.comp (measurable_liftT b)).aestronglyMeasurable CH
+    (Filter.Eventually.of_forall fun t => hHb _)
+  have h := hasSum_prod_mFourierCoeff (hG2.toLp GT) (hH2.toLp HT)
+  have hcoef : ∀ (F : (Fin n → ℝ) → ℂ) (hF : MemLp (F ∘ liftT b) 2 (volume : Measure
+      (UnitAddTorus (Fin n))))
+      (ℓ : Fin n → ℤ), mFourierCoeff (hF.toLp (F ∘ liftT b)) ℓ = ∫ x in boxIoc b, expLat ℓ x * F
+          x := by
+    intro F hF ℓ
+    have h1 : mFourierCoeff (hF.toLp (F ∘ liftT b)) ℓ = mFourierCoeff (F ∘ liftT b) ℓ := by
+      unfold mFourierCoeff
+      refine integral_congr_ae ?_
+      filter_upwards [hF.coeFn_toLp] with t ht
+      rw [ht]
+    rw [h1, mFourierCoeff_eq_integral _ ℓ b]
+    refine setIntegral_congr_fun (measurableSet_boxIoc b) fun x hx => ?_
+    simp only [Function.comp_apply, smul_eq_mul]
+    rw [mFourier_neg_coe, liftT_coe b hx]
+  have hrhs : (∫ t, conj ((hG2.toLp GT) t) * (hH2.toLp HT) t) = ∫ x in boxIoc b, conj (G x) * H
+      x := by
+    have h1 : (∫ t, conj ((hG2.toLp GT) t) * (hH2.toLp HT) t) = ∫ t, conj (GT t) * HT t := by
+      refine integral_congr_ae ?_
+      filter_upwards [hG2.coeFn_toLp, hH2.coeFn_toLp] with t h1 h2
+      rw [h1, h2]
+    rw [h1, integral_preimage _ b]
+    refine setIntegral_congr_fun (measurableSet_boxIoc b) fun x hx => ?_
+    simp only [GT, HT, Function.comp_apply]
+    rw [liftT_coe b hx]
+  rw [hrhs] at h
+  convert h using 1
+  funext ℓ
+  rw [hcoef G hG2 ℓ, hcoef H hH2 ℓ]
+
+/-- The affine change of variables `v ↦ c₀ + δ_{2^{-k}}(2π v)` from `Fin n → ℝ` to `ℝⁿ`. -/
+def psiMap (α : Fin n → ℕ) (k : ℤ) (c0 : Rn n) (v : Fin n → ℝ) : Rn n :=
+  c0 + dil α ((2 : ℝ) ^ k)⁻¹ ((2 * π) • WithLp.toLp 2 v)
+
+theorem continuous_psiMap (α : Fin n → ℕ) (k : ℤ) (c0 : Rn n) : Continuous (psiMap α k c0) := by
+  unfold psiMap
+  fun_prop
+
+/-- Change of variables along `psiMap`:
+`∫ F(ξ) dξ = (2π)^n 2^{-k|α|} ∫ F(c₀ + δ_{2^{-k}}(2π v)) dv`. -/
+theorem integral_eq_integral_psiMap (α : Fin n → ℕ) (k : ℤ) (c0 : Rn n) (F : Rn n → ℂ) :
+    ∫ ξ, F ξ = ((2 * π) ^ n * ((2 : ℝ) ^ k)⁻¹ ^ absA α : ℝ) •
+      ∫ v : Fin n → ℝ, F (psiMap α k c0 v) := by
+  set t : ℝ := (2 : ℝ) ^ k
+  have ht : 0 < t := by positivity
+  have h1 : ∫ ξ, F ξ = ∫ y, F (c0 + y) := (integral_add_left_eq_self F c0).symm
+  have h2 : ∫ y, F (c0 + y) = (t⁻¹ ^ absA α) • ∫ y, F (c0 + dil α t⁻¹ y) := by
+    rw [integral_comp_dil α (inv_pos.mpr ht) (fun y => F (c0 + y)), smul_smul,
+      mul_inv_cancel₀ (by positivity), one_smul]
+  have h3 : ∫ y, F (c0 + dil α t⁻¹ y) =
+      (2 * π) ^ n • ∫ y : Rn n, F (c0 + dil α t⁻¹ ((2 * π) • y)) := by
+    rw [Measure.integral_comp_smul volume (fun y => F (c0 + dil α t⁻¹ y)) (2 * π),
+      finrank_euclideanSpace_fin, smul_smul, abs_inv, abs_pow,
+      abs_of_pos (by positivity : (0 : ℝ) < 2 * π), mul_inv_cancel₀ (by positivity), one_smul]
+  have h4 : ∫ y : Rn n, F (c0 + dil α t⁻¹ ((2 * π) • y)) =
+      ∫ v : Fin n → ℝ, F (psiMap α k c0 v) := by
+    have hmp := (EuclideanSpace.volume_preserving_symm_measurableEquiv_toLp (Fin n)).symm
+    exact (hmp.integral_comp' (fun y : Rn n => F (c0 + dil α t⁻¹ ((2 * π) • y)))).symm
+  rw [h1, h2, h3, h4, smul_smul]
+  congr 1
+  ring
+
+theorem inner_cI_psiMap (α : Fin n → ℕ) (P : Tile n) (v : Fin n → ℝ) :
+    ⟪P.cI α, psiMap α P.k (P.cω0 α) v - P.cω0 α⟫_ℝ = 2 * π * ∑ i, ((P.ℓ i : ℝ) + 1 / 2) * v i := by
+  simp only [psiMap, add_sub_cancel_left, PiLp.inner_apply, RCLike.inner_apply, conj_trivial,
+    dil_apply, PiLp.smul_apply, Tile.cI, smul_eq_mul, Finset.mul_sum]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  have hs : ((2 : ℝ) ^ P.k)⁻¹ ^ α i * side α P.k i = 1 := by
+    rw [side, zpow_mul, zpow_natCast, inv_pow, inv_mul_cancel₀ (by positivity)]
+  calc ((2 : ℝ) ^ P.k)⁻¹ ^ α i * (2 * π * v i) * (side α P.k i * (P.ℓ i + 1 / 2))
+      = (((2 : ℝ) ^ P.k)⁻¹ ^ α i * side α P.k i) * (2 * π * ((P.ℓ i + 1 / 2) * v i)) := by ring
+    _ = _ := by rw [hs, one_mul]
+
+theorem dil_psiMap_sub (α : Fin n → ℕ) (k : ℤ) (c0 : Rn n) (v : Fin n → ℝ) :
+    dil α ((2 : ℝ) ^ k) (psiMap α k c0 v - c0) = (2 * π) • WithLp.toLp 2 v := by
+  simp only [psiMap, add_sub_cancel_left, dil_dil, mul_inv_cancel₀ (by positivity : (2 : ℝ) ^ k
+      ≠ 0),
+    dil_one]
+
+/-- The unit box `(-1/2, 1/2]ⁿ`. -/
+def halfBox (n : ℕ) : Fin n → ℝ := fun _ => -(1 / 2)
+
+theorem phiHat_two_pi_eq_zero {v : Fin n → ℝ} (hv : v ∉ boxIoc (halfBox n)) :
+    phiHat ((2 * π) • WithLp.toLp 2 v : Rn n) = 0 := by
+  simp only [boxIoc, halfBox, Set.mem_ofPred_eq, not_forall, Set.mem_Ioc, not_and_or,
+    not_lt, not_le] at hv
+  obtain ⟨i, hi⟩ := hv
+  apply phiHat_eq_zero_of_lt (i := i)
+  simp only [PiLp.smul_apply, smul_eq_mul, abs_mul,
+    abs_of_pos (by positivity : (0 : ℝ) < 2 * π)]
+  have hπ := Real.pi_gt_three
+  norm_num [b0]
+  rcases hi with hi | hi
+  · have : 1 / 2 ≤ |v i| := by rw [abs_of_neg (by linarith)]; linarith
+    nlinarith
+  · have : 1 / 2 ≤ |v i| := by rw [abs_of_pos (by linarith)]; linarith
+    nlinarith
+
+/-- `Φ_P(ξ) = φ̂(δ_{2^{k_P}}(ξ - c(ω_{P(0)})))`; it depends only on `k_P` and `u_P`. -/
+def PhiP (α : Fin n → ℕ) (P : Tile n) (ξ : Rn n) : ℂ :=
+  phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α))
+
+theorem conj_phiHat (ζ : Rn n) : conj (phiHat ζ) = phiHat ζ := by
+  rw [(phiHat_re_mem ζ).1, Complex.conj_ofReal]
+
+/-- The phase `e^{-πi ∑ vᵢ}` coming from the half-integer centers `c(I_P) = δ_{2^k}(ℓ + 1/2)`. -/
+def halfPhase (v : Fin n → ℝ) : ℂ := Complex.exp (-(π * Complex.I * ∑ i, (v i : ℂ)))
+
+theorem norm_halfPhase (v : Fin n → ℝ) : ‖halfPhase v‖ = 1 := by
+  rw [halfPhase, show -(π * Complex.I * ∑ i, (v i : ℂ)) = ((-(π * ∑ i, v i) : ℝ) : ℂ) * Complex.I by
+    push_cast; ring, Complex.norm_exp_ofReal_mul_I]
+
+theorem exp_phase_psiMap (α : Fin n → ℕ) (P : Tile n) (v : Fin n → ℝ) :
+    Complex.exp (Complex.I * (⟪P.cI α, psiMap α P.k (P.cω0 α) v - P.cω0 α⟫_ℝ : ℂ)) =
+      conj (expLat P.ℓ v * halfPhase v) := by
+  rw [inner_cI_psiMap, map_mul, expLat, halfPhase, ← Complex.exp_conj, ← Complex.exp_conj,
+    ← Complex.exp_add]
+  have h1 : conj (-(2 * π * Complex.I * ∑ i, (P.ℓ i : ℂ) * (v i : ℂ))) =
+      Complex.I * ((2 * π * ∑ i, (P.ℓ i : ℝ) * v i : ℝ) : ℂ) := by
+    simp only [map_neg, map_mul, map_sum, Complex.conj_I, Complex.conj_ofReal, map_intCast,
+      map_ofNat]
+    push_cast
+    ring
+  have h2 : conj (-(π * Complex.I * ∑ i, (v i : ℂ))) =
+      Complex.I * ((π * ∑ i, v i : ℝ) : ℂ) := by
+    simp only [map_neg, map_mul, map_sum, Complex.conj_I, Complex.conj_ofReal]
+    push_cast
+    ring
+  rw [h1, h2, ← mul_add, ← Complex.ofReal_add]
+  congr 3
+  rw [Finset.mul_sum, Finset.mul_sum, Finset.mul_sum, ← Finset.sum_add_distrib]
+  refine Finset.sum_congr rfl fun i _ => ?_
+  ring
+
+/-- The rescaled frequency profile `Gcheck(v) = conj(ĝ(Ψ v) φ̂(2πv)) e^{-πi∑vᵢ}` of a function on
+the unit box (for the tile scale and frequency position of `P`). -/
+def gCheck (α : Fin n → ℕ) (P : Tile n) (G : Rn n → ℂ) (v : Fin n → ℝ) : ℂ :=
+  conj (G (psiMap α P.k (P.cω0 α) v) * phiHat ((2 * π) • WithLp.toLp 2 v : Rn n)) * halfPhase v
+
+theorem gCheck_eq_zero (α : Fin n → ℕ) (P : Tile n) (G : Rn n → ℂ) {v : Fin n → ℝ}
+    (hv : v ∉ boxIoc (halfBox n)) : gCheck α P G v = 0 := by
+  simp [gCheck, phiHat_two_pi_eq_zero hv]
+
+/-- Box representation of the coefficient `⟨g, φ_P⟩`:
+`⟨g, φ_P⟩ = 2^{-k_P|α|/2} conj(∫_B e^{-2πi⟨ℓ_P, v⟩} Gcheck(v) dv)` with `Gcheck = gCheck α P ĝ`. -/
+theorem pairing_wavePhi_eq_box (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {g : Rn n → ℂ}
+    (hg : Integrable g) (P : Tile n) :
+    pairing g (wavePhi α P) = ((((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+      conj (∫ v in boxIoc (halfBox n), expLat P.ℓ v * gCheck α P (fhat g) v) := by
+  set t : ℝ := (2 : ℝ) ^ P.k
+  have ht : 0 < t := by positivity
+  rw [pairing_eq_fhat hg (continuous_wavePhi α P) (integrable_wavePhi α hα P)
+    (integrable_fhat_wavePhi α P), integral_eq_integral_psiMap α P.k (P.cω0 α)]
+  have hint : ∀ v : Fin n → ℝ, fhat g (psiMap α P.k (P.cω0 α) v) *
+      conj (fhat (wavePhi α P) (psiMap α P.k (P.cω0 α) v)) =
+      ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * conj (expLat P.ℓ v * gCheck α P (fhat g) v) := by
+    intro v
+    rw [fhat_wavePhi, dil_psiMap_sub]
+    simp only [gCheck, map_mul, conj_phiHat, Complex.conj_ofReal, RCLike.conj_conj]
+    rw [← Complex.exp_conj, map_neg, map_mul, Complex.conj_I, Complex.conj_ofReal, neg_mul, neg_neg,
+      exp_phase_psiMap]
+    simp only [map_mul]
+    ring
+  simp_rw [hint]
+  rw [integral_const_mul, ← setIntegral_eq_integral_of_forall_compl_eq_zero (s := boxIoc
+      (halfBox n))
+    (fun v hv => by simp [gCheck_eq_zero α P _ hv]), integral_conj, Complex.real_smul]
+  have hreal : ((2 * π) ^ n)⁻¹ * ((2 * π) ^ n * t⁻¹ ^ absA α) * t ^ ((absA α : ℝ) / 2) =
+      t ^ (-(absA α : ℝ) / 2) := by
+    have h2π : (2 * π) ^ n ≠ 0 := by positivity
+    rw [← mul_assoc, inv_mul_cancel₀ h2π, one_mul, inv_pow, ← Real.rpow_natCast,
+      ← Real.rpow_neg ht.le, ← Real.rpow_add ht]
+    congr 1; ring
+  calc _ = ((((2 * π) ^ n)⁻¹ * ((2 * π) ^ n * t⁻¹ ^ absA α) * t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        conj (∫ v in boxIoc (halfBox n), expLat P.ℓ v * gCheck α P (fhat g) v) := by
+        simp only [t]; push_cast; ring
+    _ = _ := by rw [hreal]
+
+/-- The rescaled profile `B_check(v) = m(Ψ v - N) φ̂(2πv) e^{i⟨z, Ψ v⟩} e^{-πi∑vᵢ}` for
+`ψ^N_P(z)`. -/
+def psiCheck (α : Fin n → ℕ) (P : Tile n) (m : Rn n → ℂ) (N z : Rn n) (v : Fin n → ℝ) : ℂ :=
+  m (psiMap α P.k (P.cω0 α) v - N) * phiHat ((2 * π) • WithLp.toLp 2 v : Rn n) *
+    Complex.exp (Complex.I * (⟪z, psiMap α P.k (P.cω0 α) v⟫_ℝ : ℂ)) * halfPhase v
+
+theorem psiCheck_eq_zero (α : Fin n → ℕ) (P : Tile n) (m : Rn n → ℂ) (N z : Rn n)
+    {v : Fin n → ℝ} (hv : v ∉ boxIoc (halfBox n)) : psiCheck α P m N z v = 0 := by
+  simp [psiCheck, phiHat_two_pi_eq_zero hv]
+
+/-- Box representation of `ψ^N_P(z) = 2^{-k_P|α|/2} ∫_B e^{-2πi⟨ℓ_P, v⟩} B_check(v) dv`. -/
+theorem wavePsi_eq_box (α : Fin n → ℕ) (m : Rn n → ℂ) (N : Rn n) (P : Tile n) (z : Rn n) :
+    wavePsi α m N P z = ((((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+      ∫ v in boxIoc (halfBox n), expLat P.ℓ v * psiCheck α P m N z v := by
+  set t : ℝ := (2 : ℝ) ^ P.k
+  have ht : 0 < t := by positivity
+  unfold wavePsi
+  rw [integral_eq_integral_psiMap α P.k (P.cω0 α)]
+  have hint : ∀ v : Fin n → ℝ, m (psiMap α P.k (P.cω0 α) v - N) *
+      fhat (wavePhi α P) (psiMap α P.k (P.cω0 α) v) *
+        Complex.exp (Complex.I * (⟪z, psiMap α P.k (P.cω0 α) v⟫_ℝ : ℂ)) =
+      ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * (expLat P.ℓ v * psiCheck α P m N z v) := by
+    intro v
+    rw [fhat_wavePhi, dil_psiMap_sub]
+    have h := exp_phase_psiMap α P v
+    have h' : Complex.exp (-(Complex.I * (⟪P.cI α, psiMap α P.k (P.cω0 α) v - P.cω0 α⟫_ℝ : ℂ))) =
+        expLat P.ℓ v * halfPhase v := by
+      have := congrArg (starRingEnd ℂ) h
+      rw [RCLike.conj_conj, ← Complex.exp_conj, map_mul,
+        Complex.conj_I, Complex.conj_ofReal] at this
+      rw [← this]
+      congr 1
+      ring
+    rw [h']
+    simp only [psiCheck]
+    ring
+  simp_rw [hint]
+  rw [integral_const_mul, ← setIntegral_eq_integral_of_forall_compl_eq_zero (s := boxIoc
+      (halfBox n))
+    (fun v hv => by simp [psiCheck_eq_zero α P m N z hv]), Complex.real_smul]
+  have hreal : ((2 * π) ^ n)⁻¹ * ((2 * π) ^ n * t⁻¹ ^ absA α) * t ^ ((absA α : ℝ) / 2) =
+      t ^ (-(absA α : ℝ) / 2) := by
+    have h2π : (2 * π) ^ n ≠ 0 := by positivity
+    rw [← mul_assoc, inv_mul_cancel₀ h2π, one_mul, inv_pow, ← Real.rpow_natCast,
+      ← Real.rpow_neg ht.le, ← Real.rpow_add ht]
+    congr 1; ring
+  calc _ = ((((2 * π) ^ n)⁻¹ * ((2 * π) ^ n * t⁻¹ ^ absA α) * t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        ∫ v in boxIoc (halfBox n), expLat P.ℓ v * psiCheck α P m N z v := by
+        simp only [t]; push_cast; ring
+    _ = _ := by rw [hreal]
+
+theorem phiHat_two_pi_eq_PhiP (α : Fin n → ℕ) (P : Tile n) (v : Fin n → ℝ) :
+    phiHat ((2 * π) • WithLp.toLp 2 v : Rn n) = PhiP α P (psiMap α P.k (P.cω0 α) v) := by
+  rw [PhiP, dil_psiMap_sub]
+
+theorem continuous_halfPhase : Continuous (halfPhase : (Fin n → ℝ) → ℂ) := by
+  unfold halfPhase
+  fun_prop
+
+theorem gCheck_tile (α : Fin n → ℕ) (k : ℤ) (ℓ u : Fin n → ℤ) (G : Rn n → ℂ) :
+    gCheck α ⟨k, ℓ, u⟩ G = gCheck α ⟨k, 0, u⟩ G := rfl
+
+theorem psiCheck_tile (α : Fin n → ℕ) (k : ℤ) (ℓ u : Fin n → ℤ) (m : Rn n → ℂ) (N z : Rn n) :
+    psiCheck α ⟨k, ℓ, u⟩ m N z = psiCheck α ⟨k, 0, u⟩ m N z := rfl
+
+theorem continuous_gCheck (α : Fin n → ℕ) (P : Tile n) {G : Rn n → ℂ} (hG : Continuous G) :
+    Continuous (gCheck α P G) := by
+  unfold gCheck
+  have h1 := continuous_psiMap α P.k (P.cω0 α)
+  have h2 : Continuous fun v : Fin n → ℝ => phiHat ((2 * π) • WithLp.toLp 2 v : Rn n) := by
+    fun_prop
+  exact (Complex.continuous_conj.comp ((hG.comp h1).mul h2)).mul continuous_halfPhase
+
+theorem measurable_psiCheck (α : Fin n → ℕ) (P : Tile n) {m : Rn n → ℂ} (hm : Measurable m)
+    (N z : Rn n) : Measurable (psiCheck α P m N z) := by
+  unfold psiCheck
+  have h1 := continuous_psiMap α P.k (P.cω0 α)
+  have h2 : Continuous fun v : Fin n → ℝ => phiHat ((2 * π) • WithLp.toLp 2 v : Rn n) := by
+    fun_prop
+  have h3 : Continuous fun v : Fin n → ℝ =>
+      Complex.exp (Complex.I * (⟪z, psiMap α P.k (P.cω0 α) v⟫_ℝ : ℂ)) := by
+    fun_prop
+  exact (((hm.comp (h1.measurable.sub_const N)).mul h2.measurable).mul h3.measurable).mul
+    continuous_halfPhase.measurable
+
+/-- The fixed-scale identity behind the paper's "Poisson summation in `u`" (Lemma 3.3,
+texline~233–240): for fixed scale `k` and frequency position `u`,
+`∑_ℓ ⟨g, φ_P⟩ ψ^N_P(z) = (2π)^{-n} ∫ ĝ(ξ) m(ξ - N) e^{i z ξ} Φ_P(ξ)² dξ`,
+the sum over the spatial positions `ℓ` of `P = (k, ℓ, u)`. -/
+theorem hasSum_fixedScale (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {m : Rn n → ℂ}
+    (hmeas : Measurable m) {Cm : ℝ} (hmb : ∀ ξ, ‖m ξ‖ ≤ Cm) {g : Rn n → ℂ} (hg : Integrable g)
+    (hGc : Continuous (fhat g)) {CG : ℝ} (hGb : ∀ ξ, ‖fhat g ξ‖ ≤ CG) (k : ℤ) (u : Fin n → ℤ)
+    (N z : Rn n) :
+    HasSum (fun ℓ : Fin n → ℤ => pairing g (wavePhi α ⟨k, ℓ, u⟩) * wavePsi α m N ⟨k, ℓ, u⟩ z)
+      ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, fhat g ξ * m (ξ - N) *
+        Complex.exp (Complex.I * (⟪z, ξ⟫_ℝ : ℂ)) * PhiP α ⟨k, 0, u⟩ ξ ^ 2) := by
+  set P0 : Tile n := ⟨k, 0, u⟩
+  set t : ℝ := (2 : ℝ) ^ k
+  have ht : 0 < t := by positivity
+  set Gc := gCheck α P0 (fhat g)
+  set Hc := psiCheck α P0 m N z
+  have hGcm : Measurable Gc := (continuous_gCheck α P0 hGc).measurable
+  have hHcm : Measurable Hc := measurable_psiCheck α P0 hmeas N z
+  have hGcb : ∀ v, ‖Gc v‖ ≤ CG := by
+    intro v
+    simp only [Gc, gCheck, norm_mul, RCLike.norm_conj, norm_halfPhase, mul_one]
+    calc ‖fhat g (psiMap α P0.k (P0.cω0 α) v)‖ * ‖phiHat ((2 * π) • WithLp.toLp 2 v : Rn n)‖
+        ≤ CG * 1 := mul_le_mul (hGb _) (norm_phiHat_le_one _) (norm_nonneg _)
+          ((norm_nonneg _).trans (hGb 0))
+      _ = CG := mul_one _
+  have hHcb : ∀ v, ‖Hc v‖ ≤ Cm := by
+    intro v
+    simp only [Hc, psiCheck, norm_mul, norm_halfPhase, norm_cexp_I_mul, mul_one]
+    calc ‖m (psiMap α P0.k (P0.cω0 α) v - N)‖ * ‖phiHat ((2 * π) • WithLp.toLp 2 v : Rn n)‖
+        ≤ Cm * 1 := mul_le_mul (hmb _) (norm_phiHat_le_one _) (norm_nonneg _)
+          ((norm_nonneg _).trans (hmb 0))
+      _ = Cm := mul_one _
+  have hpars := (hasSum_parseval_box (halfBox n) hGcm hHcm hGcb hHcb).mul_left
+    (((t ^ (-(absA α : ℝ)) : ℝ) : ℂ))
+  -- identify the terms
+  have hterm : ∀ ℓ : Fin n → ℤ, pairing g (wavePhi α ⟨k, ℓ, u⟩) * wavePsi α m N ⟨k, ℓ, u⟩ z =
+      ((t ^ (-(absA α : ℝ)) : ℝ) : ℂ) * (conj (∫ v in boxIoc (halfBox n), expLat ℓ v * Gc v) *
+        ∫ v in boxIoc (halfBox n), expLat ℓ v * Hc v) := by
+    intro ℓ
+    rw [pairing_wavePhi_eq_box α hα hg, wavePsi_eq_box, gCheck_tile, psiCheck_tile]
+    have hpow : ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) * ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) =
+        ((t ^ (-(absA α : ℝ)) : ℝ) : ℂ) := by
+      rw [← Complex.ofReal_mul, ← Real.rpow_add ht]
+      congr 2; ring
+    calc _ = ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) * ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+          (conj (∫ v in boxIoc (halfBox n), expLat ℓ v * Gc v) *
+            ∫ v in boxIoc (halfBox n), expLat ℓ v * Hc v) := by
+          simp only [Gc, Hc, P0, t]; ring
+      _ = _ := by rw [hpow]
+  -- identify the sum
+  have hsum : ((t ^ (-(absA α : ℝ)) : ℝ) : ℂ) * ∫ v in boxIoc (halfBox n), conj (Gc v) * Hc v =
+      (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, fhat g ξ * m (ξ - N) *
+        Complex.exp (Complex.I * (⟪z, ξ⟫_ℝ : ℂ)) * PhiP α ⟨k, 0, u⟩ ξ ^ 2 := by
+    set F : Rn n → ℂ := fun ξ => fhat g ξ * m (ξ - N) *
+      Complex.exp (Complex.I * (⟪z, ξ⟫_ℝ : ℂ)) * PhiP α ⟨k, 0, u⟩ ξ ^ 2
+    have hpt : ∀ v, conj (Gc v) * Hc v = F (psiMap α k (P0.cω0 α) v) := by
+      intro v
+      have hh : conj (halfPhase v) * halfPhase v = 1 := by
+        rw [mul_comm, Complex.mul_conj, Complex.normSq_eq_norm_sq, norm_halfPhase]; simp
+      simp only [Gc, Hc, gCheck, psiCheck, F, map_mul, RCLike.conj_conj,
+        phiHat_two_pi_eq_PhiP α P0 v]
+      calc _ = fhat g (psiMap α P0.k (P0.cω0 α) v) * m (psiMap α P0.k (P0.cω0 α) v - N) *
+            Complex.exp (Complex.I * (⟪z, psiMap α P0.k (P0.cω0 α) v⟫_ℝ : ℂ)) *
+              PhiP α P0 (psiMap α P0.k (P0.cω0 α) v) ^ 2 * (conj (halfPhase v) * halfPhase v) := by
+            ring
+        _ = _ := by rw [hh, mul_one]
+    have hbox : (∫ v in boxIoc (halfBox n), conj (Gc v) * Hc v) =
+        ∫ v : Fin n → ℝ, F (psiMap α k (P0.cω0 α) v) := by
+      rw [setIntegral_eq_integral_of_forall_compl_eq_zero fun v hv => by
+        simp [Gc, gCheck_eq_zero α P0 _ hv]]
+      exact integral_congr_ae (Filter.Eventually.of_forall hpt)
+    rw [hbox]
+    have hcv := integral_eq_integral_psiMap α k (P0.cω0 α) F
+    have hne : ((2 * π) ^ n * t⁻¹ ^ absA α : ℝ) ≠ 0 := by positivity
+    have : ∫ v : Fin n → ℝ, F (psiMap α k (P0.cω0 α) v) =
+        (((2 * π) ^ n * t⁻¹ ^ absA α : ℝ)⁻¹ : ℝ) • ∫ ξ, F ξ := by
+      rw [hcv, smul_smul, inv_mul_cancel₀ hne, one_smul]
+    rw [this, Complex.real_smul]
+    have hreal : t ^ (-(absA α : ℝ)) * ((2 * π) ^ n * t⁻¹ ^ absA α)⁻¹ = ((2 * π) ^ n)⁻¹ := by
+      rw [mul_inv, inv_pow, inv_inv, Real.rpow_neg ht.le, Real.rpow_natCast]
+      field_simp
+    calc _ = ((t ^ (-(absA α : ℝ)) * ((2 * π) ^ n * t⁻¹ ^ absA α)⁻¹ : ℝ) : ℂ) * ∫ ξ, F ξ := by
+          push_cast; ring
+      _ = _ := by rw [hreal]; push_cast; ring
+  rw [← hsum]
+  exact hpars.congr_fun fun ℓ => hterm ℓ
+
+end TorusParseval
+
+/-! ## Section 3: the averaging procedure and Lemma 3.3 -/
+
+/-- The anisotropic ball `𝓑_s = {x : ρ(x) ≤ s}` (paper, §3, texline~210). -/
+def ballA (α : Fin n → ℕ) (s : ℝ) : Set (Rn n) := {x | rho α x ≤ s}
+
+/-- An anisotropic cone (paper, §3, texline~207): a proper subset of `ℝⁿ` of the form
+`{δ_t ξ : t > 0, ξ ∈ Q}` for a (closed) cube `Q`. -/
+def IsAnisoCone (α : Fin n → ℕ) (Θ : Set (Rn n)) : Prop :=
+  Θ ≠ Set.univ ∧ ∃ (a : Rn n) (h : ℝ), 0 < h ∧
+    Θ = {ζ | ∃ t : ℝ, 0 < t ∧ ∃ ξ ∈ rectIcc a (a + WithLp.toLp 2 (fun _ => h)), ζ = dil α t ξ}
+
+/-- The integrand of the averaging procedure (paper, §3, (3.5)):
+`M_{-η} T_{-y} D²_{2^{-s}} A^{r,m}_{2^{-s}η} D²_{2^s} T_y M_η f`, evaluated at `x`. -/
+def avgIntegrand (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ)
+    (x η y : Rn n) (s : ℝ) : ℂ :=
+  modul (-η) (transl (-y) (dilOp α 2 ((2 : ℝ) ^ (-s))
+    (modelOp α r m (dil α ((2 : ℝ) ^ (-s)) η)
+      (dilOp α 2 ((2 : ℝ) ^ s) (transl y (modul η f)))))) x
+
+/-- The averages `R^{-2|α|} ∫_{𝓑_R} ∫_{𝓑_R} ∫_0^1 (…) ds dy dη` of (3.5). -/
+def avgR (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ) (x : Rn n)
+    (R : ℝ) : ℂ :=
+  ((R ^ (-(2 * absA α : ℝ)) : ℝ) : ℂ) *
+    ∫ η in ballA α R, ∫ y in ballA α R, ∫ s in (0 : ℝ)..1, avgIntegrand α r m f x η y s
+
+/-- The averaged operator `𝐀^{r,m} f(x) = lim_{R → ∞} R^{-2|α|} ∫_{𝓑_R} ∫_{𝓑_R} ∫_0^1 (…)`
+(paper, §3, (3.5)). -/
+def avgOp (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ) (x : Rn n) : ℂ :=
+  Filter.limUnder Filter.atTop (avgR α r m f x)
+
+/-- The Fourier transform of `D²_λ T_y M_η f`:
+`(D²_λ T_y M_η f)^(ξ) = λ^{|α|/2} e^{-i⟨y, δ_λ ξ⟩} f̂(δ_λ ξ - η)`. -/
+theorem fhat_dilOp_transl_modul (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n)
+    (f : Rn n → ℂ) (ξ : Rn n) :
+    fhat (dilOp α 2 t (transl y (modul η f))) ξ =
+      ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) * fhat f (dil α t ξ - η) := by
+  simp only [fhat, dilOp, transl, modul]
+  set c : ℂ := ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ)
+  set G : Rn n → ℂ := fun w => Complex.exp (-(Complex.I * (⟪dil α t w, ξ⟫_ℝ : ℂ))) *
+    (c * (Complex.exp (Complex.I * (⟪w - y, η⟫_ℝ : ℂ)) * f (w - y)))
+  have h1 : ∀ x : Rn n, Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) *
+      (c * (Complex.exp (Complex.I * (⟪dil α t⁻¹ x - y, η⟫_ℝ : ℂ)) * f (dil α t⁻¹ x - y))) =
+      G (dil α t⁻¹ x) := by
+    intro x
+    simp only [G, dil_dil, mul_inv_cancel₀ ht.ne', dil_one]
+  calc (∫ x, Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) *
+        (c * (Complex.exp (Complex.I * (⟪dil α t⁻¹ x - y, η⟫_ℝ : ℂ)) * f (dil α t⁻¹ x - y))))
+      = ∫ x, G (dil α t⁻¹ x) := by congr 1; ext x; exact h1 x
+    _ = (t⁻¹ ^ absA α)⁻¹ • ∫ w, G w := integral_comp_dil α (inv_pos.mpr ht) G
+    _ = (t⁻¹ ^ absA α)⁻¹ • ∫ w, G (w + y) := by rw [integral_add_right_eq_self]
+    _ = _ := by
+        rw [Complex.real_smul]
+        have hG : ∀ w, G (w + y) = c * Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) *
+            (Complex.exp (-(Complex.I * (⟪w, dil α t ξ - η⟫_ℝ : ℂ))) * f w) := by
+          intro w
+          simp only [G, add_sub_cancel_right, inner_add_left, inner_sub_right,
+            inner_dil_left]
+          rw [show Complex.exp (-(Complex.I * ((⟪w, dil α t ξ⟫_ℝ + ⟪y, dil α t ξ⟫_ℝ : ℝ) : ℂ))) =
+            Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) *
+              Complex.exp (-(Complex.I * (⟪w, dil α t ξ⟫_ℝ : ℂ))) by
+            rw [← Complex.exp_add]; congr 1; push_cast; ring]
+          have : Complex.exp (-(Complex.I * (⟪w, dil α t ξ⟫_ℝ : ℂ))) *
+              Complex.exp (Complex.I * (⟪w, η⟫_ℝ : ℂ)) =
+              Complex.exp (-(Complex.I * ((⟪w, dil α t ξ⟫_ℝ - ⟪w, η⟫_ℝ : ℝ) : ℂ))) := by
+            rw [← Complex.exp_add]; congr 1; push_cast; ring
+          calc _ = c * Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) *
+                (Complex.exp (-(Complex.I * (⟪w, dil α t ξ⟫_ℝ : ℂ))) *
+                  Complex.exp (Complex.I * (⟪w, η⟫_ℝ : ℂ)) * f w) := by ring
+            _ = _ := by rw [this]
+        simp_rw [hG]
+        rw [integral_const_mul]
+        have hpow : ((t⁻¹ ^ absA α)⁻¹ : ℝ) * t ^ (-(absA α : ℝ) / 2) = t ^ ((absA α : ℝ) / 2) := by
+          rw [inv_pow, inv_inv, ← Real.rpow_natCast, ← Real.rpow_add ht]
+          congr 1; ring
+        calc _ = (((t⁻¹ ^ absA α)⁻¹ * t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+              Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) *
+              ∫ w, Complex.exp (-(Complex.I * (⟪w, dil α t ξ - η⟫_ℝ : ℂ))) * f w := by
+              simp only [c]; push_cast; ring
+          _ = _ := by rw [hpow]
+
+theorem PhiP_eq_zero_of_notMem (α : Fin n → ℕ) (P : Tile n) {ξ : Rn n}
+    (hξ : ξ ∉ suppBox α P) : PhiP α P ξ = 0 := by
+  by_contra hne
+  apply hξ
+  intro i
+  have hi : |dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α) i| < b0 / 2 := by
+    by_contra hcon
+    exact hne (phiHat_eq_zero_of_lt (not_lt.mp hcon))
+  rw [dil_zpow_apply, abs_mul, abs_of_pos (side_pos α P.k i)] at hi
+  have hs : side α (-P.k) i * side α P.k i = 1 := by
+    rw [← side_add]; simp [side]
+  have := mul_lt_mul_of_pos_left hi (side_pos α (-P.k) i)
+  rwa [← mul_assoc, hs, one_mul] at this
+
+theorem norm_PhiP_sq_le (α : Fin n → ℕ) (P : Tile n) (ξ : Rn n) :
+    ‖PhiP α P ξ ^ 2‖ ≤ (suppBox α P).indicator (fun _ => (1 : ℝ)) ξ := by
+  by_cases hξ : ξ ∈ suppBox α P
+  · rw [Set.indicator_of_mem hξ, norm_pow]
+    have := norm_phiHat_le_one (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α))
+    calc ‖PhiP α P ξ‖ ^ 2 ≤ 1 ^ 2 := by gcongr; exact this
+      _ = 1 := one_pow 2
+  · rw [Set.indicator_of_notMem hξ, PhiP_eq_zero_of_notMem α P hξ]
+    simp
+
+/-- The multiplier `Ξ_r(ζ, η, s) = ∑_{k,u} 1_{ω_{P(r)}}(δ_{2^{-s}}η) Φ_P(δ_{2^{-s}}(ζ + η))²`,
+`P = (k, ·, u)`, which appears after the fixed-scale identity (Lemma 3.3, texline~239). -/
+def XiR (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ η : Rn n) (s : ℝ) : ℂ :=
+  ∑' ku : ℤ × (Fin n → ℤ),
+    ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α ((2 : ℝ) ^ (-s)) η) *
+      PhiP α ⟨ku.1, 0, ku.2⟩ (dil α ((2 : ℝ) ^ (-s)) (ζ + η)) ^ 2
+
+theorem tsum_enorm_XiR_terms_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (N w : Rn n) :
+    ∑' ku : ℤ × (Fin n → ℤ), ‖((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator
+      (fun _ => (1 : ℂ)) N * PhiP α ⟨ku.1, 0, ku.2⟩ w ^ 2‖ₑ ≤ 4 := by
+  rw [ENNReal.tsum_prod']
+  refine le_trans (ENNReal.tsum_le_tsum fun k => ENNReal.tsum_le_tsum fun u => ?_)
+    (tsum_ind_suppBox_le α hα hr N w)
+  rw [enorm_mul]
+  gcongr
+  · by_cases hN : N ∈ (⟨k, 0, u⟩ : Tile n).semi α r
+    · simp [Set.indicator_of_mem hN]
+    · simp [Set.indicator_of_notMem hN]
+  · have := norm_PhiP_sq_le α ⟨k, 0, u⟩ w
+    rw [← ofReal_norm]
+    by_cases hw : w ∈ suppBox α ⟨k, 0, u⟩
+    · rw [Set.indicator_of_mem hw] at this ⊢
+      exact ENNReal.ofReal_le_one.mpr this
+    · rw [Set.indicator_of_notMem hw] at this ⊢
+      rw [le_antisymm this (norm_nonneg _)]
+      simp
+
+theorem summable_XiR_terms (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (N w : Rn n) :
+    Summable (fun ku : ℤ × (Fin n → ℤ) => ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator
+      (fun _ => (1 : ℂ)) N * PhiP α ⟨ku.1, 0, ku.2⟩ w ^ 2) := by
+  have h := tsum_enorm_XiR_terms_le α hα hr N w
+  have hfin : ∑' ku : ℤ × (Fin n → ℤ), ‖((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator
+      (fun _ => (1 : ℂ)) N * PhiP α ⟨ku.1, 0, ku.2⟩ w ^ 2‖ₑ ≠ ⊤ :=
+    ne_top_of_le_ne_top (by norm_num) h
+  have := ENNReal.summable_toReal hfin
+  exact Summable.of_norm (by simpa [toReal_enorm] using this)
+
+theorem norm_XiR_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ζ η : Rn n) (s : ℝ) : ‖XiR α r ζ η s‖ ≤ 4 := by
+  have h := tsum_enorm_XiR_terms_le α hα hr (dil α ((2 : ℝ) ^ (-s)) η)
+    (dil α ((2 : ℝ) ^ (-s)) (ζ + η))
+  have hfin := ne_top_of_le_ne_top (by norm_num : (4 : ℝ≥0∞) ≠ ⊤) h
+  have hsn := ENNReal.summable_toReal hfin
+  calc ‖XiR α r ζ η s‖ ≤ ∑' ku : ℤ × (Fin n → ℤ), ‖((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator
+        (fun _ => (1 : ℂ)) (dil α ((2 : ℝ) ^ (-s)) η) *
+          PhiP α ⟨ku.1, 0, ku.2⟩ (dil α ((2 : ℝ) ^ (-s)) (ζ + η)) ^ 2‖ :=
+        norm_tsum_le_tsum_norm (by simpa [toReal_enorm] using hsn)
+    _ = (∑' ku : ℤ × (Fin n → ℤ), ‖((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator
+        (fun _ => (1 : ℂ)) (dil α ((2 : ℝ) ^ (-s)) η) *
+          PhiP α ⟨ku.1, 0, ku.2⟩ (dil α ((2 : ℝ) ^ (-s)) (ζ + η)) ^ 2‖ₑ).toReal := by
+        rw [ENNReal.tsum_toReal_eq (fun _ => enorm_ne_top)]
+        simp [toReal_enorm]
+    _ ≤ (4 : ℝ≥0∞).toReal := ENNReal.toReal_mono (by norm_num) h
+    _ = 4 := by norm_num
+
+theorem ClassM.homogeneous' {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (w : Rn n) {t : ℝ} (ht : 0 < t) : m (dil α t w) = m w := by
+  by_cases hw : w = 0
+  · rw [hw, dil_zero]
+  · exact hm.homogeneous w hw t ht
+
+theorem continuous_fhat_schwartz (f : 𝓢(Rn n, ℂ)) : Continuous (fhat (f : Rn n → ℂ)) := by
+  have : fhat (f : Rn n → ℂ) = fun ξ => (FourierTransform.fourier f : 𝓢(Rn n, ℂ)) ((2 * π)⁻¹ •
+      ξ) := by
+    funext ξ; rw [fhat_eq_fourier, SchwartzMap.fourier_coe]
+  rw [this]
+  exact (SchwartzMap.continuous _).comp (continuous_const_smul _)
+
+theorem norm_fhat_le (f : Rn n → ℂ) (ξ : Rn n) : ‖fhat f ξ‖ ≤ ∫ x, ‖f x‖ := by
+  unfold fhat
+  refine (norm_integral_le_integral_norm _).trans (le_of_eq ?_)
+  congr 1; ext x
+  rw [norm_mul, norm_cexp_neg_I_mul, one_mul]
+
+theorem integrable_dilOp_transl_modul (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n)
+    {f : Rn n → ℂ} (hf : Integrable f) : Integrable (dilOp α 2 t (transl y (modul η f))) := by
+  have h1 : Integrable (fun w : Rn n => modul η f (w - y)) := by
+    have : Integrable (modul η f) := by
+      refine hf.norm.mono' ?_ (Filter.Eventually.of_forall fun w => ?_)
+      · exact (by fun_prop : Continuous fun w : Rn n =>
+          Complex.exp (Complex.I * (⟪w, η⟫_ℝ : ℂ))).aestronglyMeasurable.mul hf.aestronglyMeasurable
+      · simp only [modul, norm_mul, norm_cexp_I_mul, one_mul, le_refl]
+    exact this.comp_sub_right y
+  have h2 : Integrable ((fun w : Rn n => modul η f (w - y)) ∘ dil α t⁻¹) := by
+    rw [← (dil_measurableEmbedding α (inv_pos.mpr ht)).integrable_map_iff,
+      map_dil_volume α (inv_pos.mpr ht)]
+    exact h1.smul_measure ENNReal.ofReal_ne_top
+  exact h2.const_mul _
+
+theorem fhat_conj_facts (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    Continuous (fhat (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ))))) ∧
+    (∀ ξ, ‖fhat (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ)))) ξ‖ ≤
+      t ^ ((absA α : ℝ) / 2) * ∫ x, ‖(f : Rn n → ℂ) x‖) ∧
+    Integrable (fhat (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ))))) := by
+  have hform := fhat_dilOp_transl_modul α ht y η (f : Rn n → ℂ)
+  have hF : fhat (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ)))) = fun ξ =>
+      ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) * fhat f (dil α t ξ - η) :=
+    funext hform
+  have hc := continuous_fhat_schwartz f
+  refine ⟨?_, ?_, ?_⟩
+  · rw [hF]
+    have := continuous_dil α t
+    fun_prop
+  · intro ξ
+    rw [hform, norm_mul, norm_mul, norm_cexp_neg_I_mul, mul_one, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos (by positivity)]
+    gcongr
+    exact norm_fhat_le _ _
+  · have h1 : Integrable (fun ξ : Rn n => fhat (f : Rn n → ℂ) (dil α t ξ - η)) := by
+      have h0 : Integrable ((fun w => fhat (f : Rn n → ℂ) (w - η)) ∘ dil α t) := by
+        rw [← (dil_measurableEmbedding α ht).integrable_map_iff, map_dil_volume α ht]
+        exact ((integrable_fhat_schwartz f).comp_sub_right η).smul_measure ENNReal.ofReal_ne_top
+      exact h0
+    have h2 := h1.const_mul (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ))
+    refine h2.norm.mono' ?_ (Filter.Eventually.of_forall fun ξ => ?_)
+    · rw [hF]
+      have := continuous_dil α t
+      exact (by fun_prop : Continuous fun ξ => ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (-(Complex.I * (⟪y, dil α t ξ⟫_ℝ : ℂ))) *
+          fhat (f : Rn n → ℂ) (dil α t ξ - η)).aestronglyMeasurable
+    · rw [hform, norm_mul, norm_mul, norm_cexp_neg_I_mul, mul_one, norm_mul]
+
+/-- Reindexing tiles as ((scale, frequency position), spatial position). -/
+def tileEquiv' : Tile n ≃ (ℤ × (Fin n → ℤ)) × (Fin n → ℤ) where
+  toFun P := ((P.k, P.u), P.ℓ)
+  invFun t := ⟨t.1.1, t.2, t.1.2⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+theorem semi_tile (α : Fin n → ℕ) (k : ℤ) (ℓ u : Fin n → ℤ) (r : Fin n → Fin 2) :
+    (⟨k, ℓ, u⟩ : Tile n).semi α r = (⟨k, 0, u⟩ : Tile n).semi α r := rfl
+
+/-- Decomposition of the model sum over `(k, u)`, with the fixed-scale identity applied to the
+sum over the spatial positions (paper, Lemma 3.3, texline~233–240). -/
+theorem modelOp_eq_tsum_fixedScale (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) {g : Rn n → ℂ}
+    (hg : Integrable g) (hGc : Continuous (fhat g)) {CG : ℝ} (hGb : ∀ ξ, ‖fhat g ξ‖ ≤ CG)
+    (hGi : Integrable (fhat g)) (N z : Rn n) :
+    modelOp α r m N g z = ∑' ku : ℤ × (Fin n → ℤ),
+      ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) N *
+        ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, fhat g ξ * m (ξ - N) *
+          Complex.exp (Complex.I * (⟪z, ξ⟫_ℝ : ℂ)) * PhiP α ⟨ku.1, 0, ku.2⟩ ξ ^ 2) := by
+  obtain ⟨C, hC, hsb⟩ := modelOp_summable_bound α hα hr
+  obtain ⟨hsum, -⟩ := hsb m hm g hg hGi N z
+  obtain ⟨Cm, -, hmb⟩ := hm.bounded'
+  set term : Tile n → ℂ := fun P => pairing g (wavePhi α P) * wavePsi α m N P z *
+    (P.semi α r).indicator (fun _ => (1 : ℂ)) N
+  have hsum' : Summable (term ∘ tileEquiv'.symm) := (tileEquiv'.symm.summable_iff).mpr hsum
+  have h1 : ∑' P, term P = ∑' c, term (tileEquiv'.symm c) := (tileEquiv'.symm.tsum_eq term).symm
+  have h2 : ∑' c, term (tileEquiv'.symm c) =
+      ∑' ku, ∑' ℓ, term (tileEquiv'.symm (ku, ℓ)) :=
+    hsum'.tsum_prod' (fun ku => hsum'.prod_factor ku)
+  change ∑' P, term P = _
+  rw [h1, h2]
+  congr 1
+  ext ku
+  have hfix := hasSum_fixedScale α hα hm.measurable hmb hg hGc hGb ku.1 ku.2 N z
+  have hterm : ∀ ℓ, term (tileEquiv'.symm (ku, ℓ)) =
+      pairing g (wavePhi α ⟨ku.1, ℓ, ku.2⟩) * wavePsi α m N ⟨ku.1, ℓ, ku.2⟩ z *
+        ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) N := fun ℓ => rfl
+  rw [tsum_congr hterm, tsum_mul_right, hfix.tsum_eq]
+  ring
+
+/-- Rescaling of a fixed-scale integral under the conjugation `D²_t T_y M_η`
+(paper, Lemma 3.3, texline~225–239): the variable `y` drops out. -/
+theorem integral_fixedScale_rescale (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    {t : ℝ} (ht : 0 < t) (f : Rn n → ℂ) (x y η : Rn n) (P : Tile n) :
+    ∫ ξ, fhat (dilOp α 2 t (transl y (modul η f))) ξ * m (ξ - dil α t⁻¹ η) *
+        Complex.exp (Complex.I * (⟪dil α t (x + y), ξ⟫_ℝ : ℂ)) * PhiP α P ξ ^ 2 =
+      ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) * Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) *
+        ∫ ζ, fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+          PhiP α P (dil α t⁻¹ (ζ + η)) ^ 2 := by
+  set H : Rn n → ℂ := fun ξ => fhat (dilOp α 2 t (transl y (modul η f))) ξ * m (ξ - dil α t⁻¹ η) *
+    Complex.exp (Complex.I * (⟪dil α t (x + y), ξ⟫_ℝ : ℂ)) * PhiP α P ξ ^ 2
+  set K : Rn n → ℂ := fun ζ => fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+    PhiP α P (dil α t⁻¹ (ζ + η)) ^ 2
+  have hHK : ∀ w, H (dil α t⁻¹ w) = ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+      Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) * K (w - η) := by
+    intro w
+    simp only [H, K, fhat_dilOp_transl_modul α ht, dil_dil, mul_inv_cancel₀ ht.ne', dil_one,
+      sub_add_cancel]
+    rw [← dil_sub, hm.homogeneous' _ (inv_pos.mpr ht), inner_dil_left, dil_dil,
+      mul_inv_cancel₀ ht.ne', dil_one]
+    have hexp : Complex.exp (-(Complex.I * (⟪y, w⟫_ℝ : ℂ))) *
+        Complex.exp (Complex.I * (⟪x + y, w⟫_ℝ : ℂ)) =
+        Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) *
+          Complex.exp (Complex.I * (⟪x, w - η⟫_ℝ : ℂ)) := by
+      rw [← Complex.exp_add, ← Complex.exp_add]
+      congr 1
+      simp only [inner_add_left, inner_sub_right]
+      push_cast
+      ring
+    calc _ = ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * fhat f (w - η) * m (w - η) *
+          (Complex.exp (-(Complex.I * (⟪y, w⟫_ℝ : ℂ))) *
+            Complex.exp (Complex.I * (⟪x + y, w⟫_ℝ : ℂ))) *
+          PhiP α P (dil α t⁻¹ w) ^ 2 := by ring
+      _ = _ := by rw [hexp]; ring
+  have h1 : ∫ ξ, H ξ = (t⁻¹ ^ absA α) • ∫ w, H (dil α t⁻¹ w) := by
+    rw [integral_comp_dil α (inv_pos.mpr ht) H, smul_smul, mul_inv_cancel₀ (by positivity),
+      one_smul]
+  have h2 : ∫ w, K (w - η) = ∫ ζ, K ζ := integral_sub_right_eq_self K η
+  change ∫ ξ, H ξ = _
+  rw [h1]
+  simp_rw [hHK]
+  rw [integral_const_mul, h2, Complex.real_smul]
+  have hpow : (t⁻¹ ^ absA α : ℝ) * t ^ ((absA α : ℝ) / 2) = t ^ (-(absA α : ℝ) / 2) := by
+    rw [inv_pow, ← Real.rpow_natCast, ← Real.rpow_neg ht.le, ← Real.rpow_add ht]
+    congr 1; ring
+  calc _ = (((t⁻¹ ^ absA α : ℝ) * t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) * ∫ ζ, K ζ := by push_cast; ring
+    _ = _ := by rw [hpow]
+
+theorem continuous_PhiP (α : Fin n → ℕ) (P : Tile n) : Continuous (PhiP α P) := by
+  unfold PhiP
+  have := continuous_dil α ((2 : ℝ) ^ P.k)
+  fun_prop
+
+/-- The averaged integrand of (3.5) as a Fourier multiplier (paper, Lemma 3.3,
+texline~225–240): for Schwartz `f`,
+`[M_{-η} T_{-y} D²_{2^{-s}} A^{r,m}_{2^{-s}η} D²_{2^s} T_y M_η f](x)
+  = (2π)^{-n} ∫ f̂(ζ) m(ζ) e^{i x ζ} Ξ_r(ζ, η, s) dζ`, independently of `y`. -/
+theorem avgIntegrand_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x η y : Rn n) (s : ℝ) :
+    avgIntegrand α r m f x η y s = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) * XiR α r ζ η s := by
+  set t : ℝ := (2 : ℝ) ^ s
+  have ht : 0 < t := by positivity
+  have htinv : (2 : ℝ) ^ (-s) = t⁻¹ := Real.rpow_neg (by norm_num) s
+  have ht_def : (2 : ℝ) ^ s = t := rfl
+  obtain ⟨hGc, hGb, hGi⟩ := fhat_conj_facts α ht y η f
+  have hg : Integrable (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ)))) :=
+    integrable_dilOp_transl_modul α ht y η (SchwartzMap.integrable f)
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  -- unfold the conjugations
+  have hunf : avgIntegrand α r m f x η y s =
+      Complex.exp (-(Complex.I * (⟪x, η⟫_ℝ : ℂ))) * ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        modelOp α r m (dil α t⁻¹ η) (dilOp α 2 t (transl y (modul η (f : Rn n → ℂ))))
+          (dil α t (x + y)) := by
+    simp only [avgIntegrand, htinv, ht_def]
+    simp only [modul, transl, dilOp, inv_inv, sub_neg_eq_add]
+    rw [inner_neg_right]
+    have : (t⁻¹ : ℝ) ^ (-(absA α : ℝ) / 2) = t ^ ((absA α : ℝ) / 2) := by
+      rw [Real.inv_rpow ht.le, ← Real.rpow_neg ht.le]; congr 1; ring
+    rw [this]
+    push_cast
+    ring_nf
+  rw [hunf, modelOp_eq_tsum_fixedScale α hα hr hm hg hGc hGb hGi]
+  simp_rw [integral_fixedScale_rescale α hm ht (f : Rn n → ℂ) x y η]
+  -- collect constants
+  set F : ℤ × (Fin n → ℤ) → Rn n → ℂ := fun ku ζ =>
+    ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α t⁻¹ η) *
+      (fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+        PhiP α ⟨ku.1, 0, ku.2⟩ (dil α t⁻¹ (ζ + η)) ^ 2)
+  have hconst : ∀ ku : ℤ × (Fin n → ℤ),
+      ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α t⁻¹ η) *
+        ((((2 * π) ^ n)⁻¹ : ℂ) * (((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+          Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) *
+          ∫ ζ, fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+            PhiP α ⟨ku.1, 0, ku.2⟩ (dil α t⁻¹ (ζ + η)) ^ 2)) =
+      ((((2 * π) ^ n)⁻¹ : ℂ) * (((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+          Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)))) * ∫ ζ, F ku ζ := by
+    intro ku
+    simp only [F]
+    rw [integral_const_mul]
+    ring
+  rw [tsum_congr hconst, tsum_mul_left]
+  -- interchange sum and integral
+  have hfm : Integrable (fun ζ => fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))) := by
+    refine ((integrable_fhat_schwartz f).norm.const_mul Cm).mono' ?_
+      (Filter.Eventually.of_forall fun ζ => ?_)
+    · exact (((continuous_fhat_schwartz f).aestronglyMeasurable.mul
+        hm.measurable.aestronglyMeasurable).mul
+        (by fun_prop : Continuous fun ζ : Rn n =>
+          Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))).aestronglyMeasurable)
+    · rw [norm_mul, norm_mul, norm_cexp_I_mul, mul_one, mul_comm]
+      exact mul_le_mul_of_nonneg_right (hmb ζ) (norm_nonneg _)
+  have hFmeas : ∀ ku, AEStronglyMeasurable (F ku) := by
+    intro ku
+    simp only [F]
+    exact aestronglyMeasurable_const.mul (hfm.aestronglyMeasurable.mul
+      (((continuous_PhiP α _).comp ((continuous_dil α t⁻¹).comp
+        (continuous_id.add continuous_const))).pow 2).aestronglyMeasurable)
+  have hsumint : ∑' ku, ∫⁻ ζ, ‖F ku ζ‖ₑ ≠ ⊤ := by
+    have hle : ∑' ku, ∫⁻ ζ, ‖F ku ζ‖ₑ ≤ ∫⁻ ζ, 4 * ‖fhat f ζ * m ζ *
+        Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))‖ₑ := by
+      rw [← lintegral_tsum fun ku => (hFmeas ku).enorm]
+      refine lintegral_mono fun ζ => ?_
+      have hb := tsum_enorm_XiR_terms_le α hα hr (dil α t⁻¹ η) (dil α t⁻¹ (ζ + η))
+      set c := ‖fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))‖ₑ
+      set w : ℤ × (Fin n → ℤ) → ℝ≥0∞ := fun ku =>
+        ‖((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α t⁻¹ η) *
+          PhiP α ⟨ku.1, 0, ku.2⟩ (dil α t⁻¹ (ζ + η)) ^ 2‖ₑ with hw
+      have hF : ∀ ku, ‖F ku ζ‖ₑ = w ku * c := by
+        intro ku
+        simp only [F, hw, c, enorm_mul]
+        ring
+      calc ∑' ku, ‖F ku ζ‖ₑ = ∑' ku, w ku * c := tsum_congr hF
+        _ = (∑' ku, w ku) * c := ENNReal.tsum_mul_right
+        _ ≤ 4 * c := by gcongr
+    refine ne_top_of_le_ne_top ?_ hle
+    rw [lintegral_const_mul' _ _ (by norm_num)]
+    exact ENNReal.mul_ne_top (by norm_num) hfm.hasFiniteIntegral.ne
+  rw [← integral_tsum hFmeas hsumint]
+  have hXi : ∀ ζ, ∑' ku, F ku ζ = fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+      XiR α r ζ η s := by
+    intro ζ
+    simp only [F, XiR, htinv]
+    rw [← tsum_mul_left]
+    congr 1; ext ku
+    rw [dil_add]
+    ring
+  simp_rw [hXi]
+  have hexp : Complex.exp (-(Complex.I * (⟪x, η⟫_ℝ : ℂ))) *
+      Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) = 1 := by
+    rw [← Complex.exp_add, neg_add_cancel, Complex.exp_zero]
+  have htt : ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) = 1 := by
+    rw [← Complex.ofReal_mul, ← Real.rpow_add ht, show (absA α : ℝ) / 2 + -(absA α : ℝ) / 2 = 0
+        by ring,
+      Real.rpow_zero, Complex.ofReal_one]
+  calc _ = (Complex.exp (-(Complex.I * (⟪x, η⟫_ℝ : ℂ))) *
+        Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ))) *
+        (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ)) *
+        ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ζ, fhat f ζ * m ζ *
+          Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) * XiR α r ζ η s) := by ring
+    _ = _ := by rw [hexp, htt, one_mul, one_mul]
+
+/-! ### Lemma 3.3: the limit `R → ∞` -/
+
+/-- Averaging over the scales `2^{k-s}`, `k ∈ ℤ`, `s ∈ (0, 1]` (paper, Lemma 3.3, texline~244–247,
+in the variable `v = log₂ t`): `∫_{(0,1]} ∑_k F(k - s) ds = ∫_ℝ F(v) dv`. -/
+theorem lintegral_Ioc_tsum_sub (F : ℝ → ℝ≥0∞) (hF : Measurable F) :
+    ∫⁻ s in Set.Ioc (0 : ℝ) 1, ∑' k : ℤ, F (k - s) = ∫⁻ v, F v := by
+  have hmeas : ∀ k : ℤ, Measurable fun s : ℝ => F (k - s) :=
+    fun k => hF.comp (measurable_const.sub measurable_id)
+  rw [lintegral_tsum fun k => (hmeas k).aemeasurable]
+  have hk : ∀ k : ℤ, ∫⁻ s in Set.Ioc (0 : ℝ) 1, F (k - s) =
+      ∫⁻ v, (Set.Ico ((k : ℝ) - 1) k).indicator F v := by
+    intro k
+    rw [← lintegral_indicator measurableSet_Ioc]
+    have : (fun s : ℝ => (Set.Ioc (0 : ℝ) 1).indicator (fun s => F (k - s)) s) =
+        fun s => (fun v => (Set.Ico ((k : ℝ) - 1) k).indicator F v) (k - s) := by
+      funext s
+      dsimp only
+      by_cases hs : s ∈ Set.Ioc (0 : ℝ) 1
+      · rw [Set.indicator_of_mem hs, Set.indicator_of_mem]
+        simp only [Set.mem_Ico, Set.mem_Ioc] at hs ⊢
+        constructor <;> linarith [hs.1, hs.2]
+      · rw [Set.indicator_of_notMem hs, Set.indicator_of_notMem]
+        simp only [Set.mem_Ico, Set.mem_Ioc, not_and_or, not_lt, not_le] at hs ⊢
+        rcases hs with hs | hs
+        · right; linarith
+        · left; linarith
+    rw [this, lintegral_sub_left_eq_self (fun v => (Set.Ico ((k : ℝ) - 1) k).indicator F v) (k : ℝ)]
+  simp_rw [hk]
+  rw [← lintegral_tsum fun k => (hF.indicator measurableSet_Ico).aemeasurable]
+  congr 1
+  ext v
+  rw [tsum_eq_single (⌊v⌋ + 1)]
+  · rw [Set.indicator_of_mem]
+    simp only [Int.cast_add, Int.cast_one, add_sub_cancel_right, Set.mem_Ico]
+    exact ⟨Int.floor_le v, Int.lt_floor_add_one v⟩
+  · intro k hk
+    rw [Set.indicator_of_notMem]
+    simp only [Set.mem_Ico, not_and_or, not_le, not_lt]
+    by_contra hcon
+    push Not at hcon
+    apply hk
+    have h1 : ((k : ℝ) - 1) ≤ v := hcon.1
+    have h2 : v < k := hcon.2
+    have : ⌊v⌋ = k - 1 := by
+      rw [Int.floor_eq_iff]; push_cast; constructor <;> linarith
+    omega
+
+/-- The real part of `φ̂` (which is real-valued with values in `[0, 1]`). -/
+def phiR (ζ : Rn n) : ℝ := (phiHat ζ).re
+
+theorem phiHat_eq_phiR (ζ : Rn n) : phiHat ζ = (phiR ζ : ℂ) := (phiHat_re_mem ζ).1
+
+theorem phiR_nonneg (ζ : Rn n) : 0 ≤ phiR ζ := (phiHat_re_mem ζ).2.1
+
+theorem phiR_le_one (ζ : Rn n) : phiR ζ ≤ 1 := (phiHat_re_mem ζ).2.2
+
+theorem continuous_phiR : Continuous (phiR : Rn n → ℝ) :=
+  Complex.continuous_re.comp continuous_phiHat
+
+/-- The quarter vector `(1/4, …, 1/4)`. -/
+def quarterVec (n : ℕ) : Rn n := WithLp.toLp 2 (fun _ => (1 / 4 : ℝ))
+
+/-- `χ(w) = |φ̂|²(w - 1/4)` (paper, Lemma 3.3, texline~255), as an extended nonnegative real. -/
+def chiE (w : Rn n) : ℝ≥0∞ := ENNReal.ofReal (phiR (w - quarterVec n) ^ 2)
+
+/-- The closed box `Q_r = [r/2, (r+1)/2]` (paper, Lemma 3.3, texline~248). -/
+def boxQ (r : Fin n → Fin 2) : Set (Rn n) :=
+  {w | ∀ i, ((r i : ℕ) : ℝ) / 2 ≤ w i ∧ w i ≤ (((r i : ℕ) : ℝ) + 1) / 2}
+
+theorem measurableSet_boxQ (r : Fin n → Fin 2) : MeasurableSet (boxQ r : Set (Rn n)) := by
+  have : (boxQ r : Set (Rn n)) = ⋂ i, {w : Rn n | ((r i : ℕ) : ℝ) / 2 ≤ w i ∧
+      w i ≤ (((r i : ℕ) : ℝ) + 1) / 2} := by
+    ext w; simp [boxQ]
+  rw [this]
+  refine MeasurableSet.iInter fun i => ?_
+  have hc : Measurable fun w : Rn n => w i :=
+    ((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)).measurable
+  exact (measurableSet_le measurable_const hc).inter (measurableSet_le hc measurable_const)
+
+/-- `G_t(ζ, η) = ∑_u 1_{Q_r}(δ_t η - u) χ(δ_t(ζ + η) - u)` (paper, Lemma 3.3, texline~243). -/
+def Gsum (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ η : Rn n) (t : ℝ) : ℝ≥0∞ :=
+  ∑' u : Fin n → ℤ, (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (dil α t η - latticePt u) *
+    chiE (dil α t (ζ + η) - latticePt u)
+
+/-- The multiplier `Ξ_r` as an extended nonnegative real:
+`Ξ_r(ζ, η, s) = ∑_k G_{2^{k-s}}(ζ, η)`. -/
+def XiE (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ η : Rn n) (s : ℝ) : ℝ≥0∞ :=
+  ∑' k : ℤ, Gsum α r ζ η ((2 : ℝ) ^ ((k : ℝ) - s))
+
+theorem mem_semi_iff_boxQ (α : Fin n → ℕ) (k : ℤ) (u : Fin n → ℤ)
+    (r : Fin n → Fin 2) (N : Rn n) :
+    N ∈ (⟨k, 0, u⟩ : Tile n).semi α r ↔ dil α ((2 : ℝ) ^ k) N - latticePt u ∈ boxQ r := by
+  simp only [Tile.semi, boxQ, Set.mem_ofPred_eq, PiLp.sub_apply, dil_zpow_apply, latticePt_apply]
+  refine forall_congr' fun i => ?_
+  have hs := side_pos α (-k) i
+  have hs' : side α k i * side α (-k) i = 1 := by rw [← side_add]; simp [side]
+  constructor
+  · rintro ⟨h1, h2⟩
+    constructor
+    · have := mul_le_mul_of_nonneg_left h1 (side_pos α k i).le
+      rw [← mul_assoc, hs', one_mul] at this
+      linarith
+    · have := mul_le_mul_of_nonneg_left h2 (side_pos α k i).le
+      rw [← mul_assoc, hs', one_mul] at this
+      linarith
+  · rintro ⟨h1, h2⟩
+    have hN : side α (-k) i * (side α k i * N i) = N i := by
+      rw [← mul_assoc, mul_comm (side α (-k) i), hs', one_mul]
+    constructor
+    · calc side α (-k) i * ((u i : ℝ) + ((r i : ℕ) : ℝ) / 2)
+          ≤ side α (-k) i * (side α k i * N i) := by gcongr; linarith
+        _ = N i := hN
+    · calc N i = side α (-k) i * (side α k i * N i) := hN.symm
+        _ ≤ side α (-k) i * ((u i : ℝ) + (((r i : ℕ) : ℝ) + 1) / 2) := by gcongr; linarith
+
+theorem PhiP_eq_phiR (α : Fin n → ℕ) (k : ℤ) (u : Fin n → ℤ) (w : Rn n) :
+    PhiP α ⟨k, 0, u⟩ w = (phiR (dil α ((2 : ℝ) ^ k) w - latticePt u - quarterVec n) : ℂ) := by
+  rw [PhiP, phiHat_eq_phiR]
+  congr 2
+  ext i
+  simp only [dil_zpow_apply, Tile.cω0, PiLp.sub_apply, latticePt_apply, quarterVec]
+  have hs' : side α k i * side α (-k) i = 1 := by rw [← side_add]; simp [side]
+  rw [mul_sub, ← mul_assoc, hs', one_mul]
+  ring
+
+theorem dil_dil_zpow_rpow (α : Fin n → ℕ) (k : ℤ) (s : ℝ) (w : Rn n) :
+    dil α ((2 : ℝ) ^ k) (dil α ((2 : ℝ) ^ (-s)) w) = dil α ((2 : ℝ) ^ ((k : ℝ) - s)) w := by
+  rw [dil_dil]
+  congr 1
+  rw [sub_eq_add_neg, Real.rpow_add (by norm_num), Real.rpow_intCast]
+
+/-- The terms of `Ξ_r`, as extended nonnegative reals. -/
+theorem enorm_XiR_term (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ η : Rn n)
+    (s : ℝ) (k : ℤ) (u : Fin n → ℤ) :
+    ‖((⟨k, 0, u⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α ((2 : ℝ) ^ (-s)) η) *
+        PhiP α ⟨k, 0, u⟩ (dil α ((2 : ℝ) ^ (-s)) (ζ + η)) ^ 2‖ₑ =
+      (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (dil α ((2 : ℝ) ^ ((k : ℝ) - s)) η - latticePt u) *
+        chiE (dil α ((2 : ℝ) ^ ((k : ℝ) - s)) (ζ + η) - latticePt u) := by
+  rw [PhiP_eq_phiR, dil_dil_zpow_rpow, enorm_mul]
+  congr 1
+  · by_cases hN : dil α ((2 : ℝ) ^ (-s)) η ∈ (⟨k, 0, u⟩ : Tile n).semi α r
+    · have hQ := (mem_semi_iff_boxQ α k u r _).mp hN
+      rw [dil_dil_zpow_rpow] at hQ
+      simp [Set.indicator_of_mem hN, Set.indicator_of_mem hQ]
+    · have hQ : dil α ((2 : ℝ) ^ ((k : ℝ) - s)) η - latticePt u ∉ boxQ r := by
+        rw [← dil_dil_zpow_rpow]
+        exact fun h => hN ((mem_semi_iff_boxQ α k u r _).mpr h)
+      simp [Set.indicator_of_notMem hN, Set.indicator_of_notMem hQ]
+  · rw [chiE, ← Complex.ofReal_pow, ← ofReal_norm, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg (by positivity)]
+
+theorem XiE_le_four (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ζ η : Rn n) (s : ℝ) : XiE α r ζ η s ≤ 4 := by
+  have h := tsum_enorm_XiR_terms_le α hα hr (dil α ((2 : ℝ) ^ (-s)) η)
+    (dil α ((2 : ℝ) ^ (-s)) (ζ + η))
+  rw [ENNReal.tsum_prod'] at h
+  simp_rw [enorm_XiR_term α r ζ η s] at h
+  exact h
+
+/-- `Ξ_r` is the real number underlying `Ξ^E_r`. -/
+theorem XiR_eq_toReal (α : Fin n → ℕ) (r : Fin n → Fin 2)
+    (ζ η : Rn n) (s : ℝ) : XiR α r ζ η s = ((XiE α r ζ η s).toReal : ℂ) := by
+  have hreal : ∀ ku : ℤ × (Fin n → ℤ),
+      ((⟨ku.1, 0, ku.2⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℂ)) (dil α ((2 : ℝ) ^ (-s))
+          η) *
+        PhiP α ⟨ku.1, 0, ku.2⟩ (dil α ((2 : ℝ) ^ (-s)) (ζ + η)) ^ 2 =
+      (((boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+          (dil α ((2 : ℝ) ^ ((ku.1 : ℝ) - s)) η - latticePt ku.2) *
+        chiE (dil α ((2 : ℝ) ^ ((ku.1 : ℝ) - s)) (ζ + η) - latticePt ku.2)).toReal : ℂ) := by
+    intro ku
+    rw [← enorm_XiR_term α r ζ η s ku.1 ku.2, toReal_enorm]
+    -- the term is a nonnegative real
+    rw [PhiP_eq_phiR]
+    by_cases hN : dil α ((2 : ℝ) ^ (-s)) η ∈ (⟨ku.1, 0, ku.2⟩ : Tile n).semi α r
+    · rw [Set.indicator_of_mem hN, one_mul, ← Complex.ofReal_pow, Complex.norm_real,
+        Real.norm_eq_abs, abs_of_nonneg (by positivity)]
+    · rw [Set.indicator_of_notMem hN, zero_mul, norm_zero, Complex.ofReal_zero]
+  have hfin : ∀ ku : ℤ × (Fin n → ℤ), (boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+      (dil α ((2 : ℝ) ^ ((ku.1 : ℝ) - s)) η - latticePt ku.2) *
+        chiE (dil α ((2 : ℝ) ^ ((ku.1 : ℝ) - s)) (ζ + η) - latticePt ku.2) ≠ ⊤ := by
+    intro ku
+    refine ENNReal.mul_ne_top ?_ ENNReal.ofReal_ne_top
+    by_cases h : dil α ((2 : ℝ) ^ ((ku.1 : ℝ) - s)) η - latticePt ku.2 ∈ boxQ r
+    · simp [Set.indicator_of_mem h]
+    · simp [Set.indicator_of_notMem h]
+  unfold XiR
+  rw [tsum_congr hreal, ← Complex.ofReal_tsum, ← ENNReal.tsum_toReal_eq hfin, XiE]
+  congr 2
+  rw [ENNReal.tsum_prod']
+  rfl
+
+/-- The lattice count `#{u ∈ ℤⁿ : ρ(p + u) ≤ T}`. -/
+def latCount (α : Fin n → ℕ) (p : Rn n) (T : ℝ) : ℝ≥0∞ :=
+  ∑' u : Fin n → ℤ, (ballA α T).indicator (fun _ => (1 : ℝ≥0∞)) (p + latticePt u)
+
+theorem indicator_ballA_dil (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t) (R : ℝ)
+    (p : Rn n) :
+    (ballA α R).indicator (fun _ => (1 : ℝ≥0∞)) (dil α t⁻¹ p) =
+      (ballA α (t * R)).indicator (fun _ => (1 : ℝ≥0∞)) p := by
+  have h : dil α t⁻¹ p ∈ ballA α R ↔ p ∈ ballA α (t * R) := by
+    simp only [ballA, Set.mem_ofPred_eq, rho_dil α hα (inv_pos.mpr ht)]
+    rw [inv_mul_le_iff₀ ht]
+  by_cases hp : p ∈ ballA α (t * R)
+  · rw [Set.indicator_of_mem hp, Set.indicator_of_mem (h.mpr hp)]
+  · rw [Set.indicator_of_notMem hp, Set.indicator_of_notMem (fun h' => hp (h.mp h'))]
+
+theorem measurableSet_ballA (α : Fin n → ℕ) (T : ℝ) : MeasurableSet (ballA α T) :=
+  measurableSet_le (continuous_rho α).measurable measurable_const
+
+theorem measurable_chiE : Measurable (chiE : Rn n → ℝ≥0∞) :=
+  ENNReal.measurable_ofReal.comp ((continuous_phiR.comp
+    (continuous_id.sub continuous_const)).pow 2).measurable
+
+/-- The change of variables (3.7) (paper, Lemma 3.3, texline~248–253), for a fixed scale `t`:
+`∫_{𝓑_R} G_t(ζ, η) dη = t^{-|α|} ∫ χ(w) 1_{Q_r}(w - δ_t ζ) #{u : ρ(w - δ_t ζ + u) ≤ tR} dw`. -/
+theorem lintegral_ballA_Gsum (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (r : Fin n → Fin 2) (ζ : Rn n)
+    {t : ℝ} (ht : 0 < t) (R : ℝ) :
+    ∫⁻ η in ballA α R, Gsum α r ζ η t = ENNReal.ofReal ((t ^ absA α)⁻¹) *
+      ∫⁻ w, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α t ζ) *
+        latCount α (w - dil α t ζ) (t * R) := by
+  have hQ := measurableSet_boxQ r (n := n)
+  have hB := measurableSet_ballA α R
+  have hmeasu : ∀ u : Fin n → ℤ, Measurable fun η : Rn n =>
+      (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (dil α t η - latticePt u) *
+        chiE (dil α t (ζ + η) - latticePt u) := by
+    intro u
+    refine (measurable_const.indicator hQ).comp ((continuous_dil α t).measurable.sub_const _) |>.mul
+      (measurable_chiE.comp ((continuous_dil α t).measurable.comp
+        (measurable_const.add measurable_id) |>.sub_const _))
+  unfold Gsum
+  rw [lintegral_tsum fun u => (hmeasu u).aemeasurable]
+  have hu : ∀ u : Fin n → ℤ, ∫⁻ η in ballA α R, (boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+      (dil α t η - latticePt u) * chiE (dil α t (ζ + η) - latticePt u) =
+      ENNReal.ofReal ((t ^ absA α)⁻¹) * ∫⁻ w, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+        (w - dil α t ζ) * (ballA α (t * R)).indicator (fun _ => (1 : ℝ≥0∞))
+          (w - dil α t ζ + latticePt u) := by
+    intro u
+    rw [← lintegral_indicator hB]
+    set H : Rn n → ℝ≥0∞ := (ballA α R).indicator fun η =>
+      (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (dil α t η - latticePt u) *
+        chiE (dil α t (ζ + η) - latticePt u)
+    have h1 : ∫⁻ η, H η = ENNReal.ofReal ((t ^ absA α)⁻¹) * ∫⁻ v, H (dil α t⁻¹ v) := by
+      rw [lintegral_comp_dil α (inv_pos.mpr ht), ← mul_assoc, ← ENNReal.ofReal_mul (by positivity)]
+      rw [show (t ^ absA α)⁻¹ * ((t⁻¹) ^ absA α)⁻¹ = 1 by
+        rw [inv_pow, inv_inv, inv_mul_cancel₀ (by positivity)]]
+      simp
+    have h2 : ∫⁻ v, H (dil α t⁻¹ v) = ∫⁻ w, H (dil α t⁻¹ (w - dil α t ζ + latticePt u)) :=
+      (lintegral_add_right_eq_self (fun v => H (dil α t⁻¹ v)) (latticePt u - dil α t ζ)).symm.trans
+        (by congr 1; ext w; congr 2; abel)
+    rw [h1, h2]
+    congr 1
+    congr 1
+    ext w
+    simp only [H]
+    have hdd : dil α t (dil α t⁻¹ (w - dil α t ζ + latticePt u)) = w - dil α t ζ + latticePt u := by
+      rw [dil_dil, mul_inv_cancel₀ ht.ne', dil_one]
+    have hmem := indicator_ballA_dil α hα ht R (w - dil α t ζ + latticePt u)
+    by_cases hb : dil α t⁻¹ (w - dil α t ζ + latticePt u) ∈ ballA α R
+    · rw [Set.indicator_of_mem hb, ← hmem, Set.indicator_of_mem hb, mul_one, hdd, dil_add, hdd]
+      have e1 : w - dil α t ζ + latticePt u - latticePt u = w - dil α t ζ := by abel
+      have e2 : dil α t ζ + (w - dil α t ζ + latticePt u) - latticePt u = w := by abel
+      rw [e1, e2, mul_comm]
+    · rw [Set.indicator_of_notMem hb, ← hmem, Set.indicator_of_notMem hb, mul_zero]
+  simp_rw [hu]
+  rw [ENNReal.tsum_mul_left]
+  congr 1
+  have hmw : ∀ u : Fin n → ℤ, Measurable fun w : Rn n => chiE w *
+      (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α t ζ) *
+        (ballA α (t * R)).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α t ζ + latticePt u) := by
+    intro u
+    exact (measurable_chiE.mul ((measurable_const.indicator hQ).comp
+      (measurable_id.sub_const _))).mul ((measurable_const.indicator
+        (measurableSet_ballA α (t * R))).comp ((measurable_id.sub_const _).add_const _))
+  rw [← lintegral_tsum fun u => (hmw u).aemeasurable]
+  congr 1
+  ext w
+  unfold latCount
+  rw [ENNReal.tsum_mul_left]
+
+/-- The one-dimensional count `#{m ∈ ℤ : |x + m| ≤ L}` (for `L ≥ 0`). -/
+def cnt1 (x L : ℝ) : ℕ := (⌊-x + L⌋ - ⌈-x - L⌉ + 1).toNat
+
+theorem cnt1_bounds {x L : ℝ} (hL : 0 ≤ L) :
+    2 * L - 1 ≤ (cnt1 x L : ℝ) ∧ (cnt1 x L : ℝ) ≤ 2 * L + 1 := by
+  have h1 := Int.floor_le (-x + L)
+  have h2 := Int.lt_floor_add_one (-x + L)
+  have h3 := Int.le_ceil (-x - L)
+  have h4 := Int.ceil_lt_add_one (-x - L)
+  have hnn : 0 ≤ ⌊-x + L⌋ - ⌈-x - L⌉ + 1 := by
+    have : (⌈-x - L⌉ : ℝ) < ⌊-x + L⌋ + 2 := by linarith
+    have : ⌈-x - L⌉ < ⌊-x + L⌋ + 2 := by exact_mod_cast this
+    omega
+  have hc : (cnt1 x L : ℝ) = ((⌊-x + L⌋ : ℝ) - ⌈-x - L⌉ + 1) := by
+    unfold cnt1
+    rw [show ((⌊-x + L⌋ - ⌈-x - L⌉ + 1).toNat : ℝ) = ((⌊-x + L⌋ - ⌈-x - L⌉ + 1 : ℤ) : ℝ) by
+      rw [← Int.cast_natCast, Int.toNat_of_nonneg hnn]]
+    push_cast; ring
+  rw [hc]
+  constructor <;> linarith
+
+theorem mem_ballA_add_iff (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {T : ℝ} (hT : 0 ≤ T) (p : Rn n)
+    (u : Fin n → ℤ) :
+    p + latticePt u ∈ ballA α T ↔
+      ∀ i, u i ∈ Finset.Icc (⌈-p i - T ^ α i⌉) (⌊-p i + T ^ α i⌋) := by
+  have hρ : p + latticePt u ∈ ballA α T ↔ ∀ i, |p i + u i| ≤ T ^ α i := by
+    simp only [ballA, Set.mem_ofPred_eq]
+    constructor
+    · intro h i
+      have h1 := abs_coord_rpow_le_rho α (p + latticePt u) i
+      simp only [PiLp.add_apply, latticePt_apply] at h1
+      have hαi : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+      have h2 : |p i + u i| ^ ((α i : ℝ)⁻¹) ≤ T := h1.trans h
+      have := Real.rpow_le_rpow (by positivity) h2 (Nat.cast_nonneg (α i))
+      rwa [← Real.rpow_mul (abs_nonneg _), inv_mul_cancel₀ hαi, Real.rpow_one,
+        Real.rpow_natCast] at this
+    · intro h
+      have : rhoNN α (p + latticePt u) ≤ T.toNNReal := by
+        rw [rhoNN_le_iff]
+        intro i
+        rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ hT]
+        simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs, PiLp.add_apply, latticePt_apply]
+        have hαi : (0 : ℝ) < α i := by have := hα i; positivity
+        calc |p i + u i| ^ ((α i : ℝ)⁻¹) ≤ (T ^ α i) ^ ((α i : ℝ)⁻¹) :=
+              Real.rpow_le_rpow (abs_nonneg _) (h i) (by positivity)
+          _ = T := by
+              rw [← Real.rpow_natCast, ← Real.rpow_mul hT, mul_inv_cancel₀ hαi.ne', Real.rpow_one]
+      have := NNReal.coe_le_coe.mpr this
+      rwa [Real.coe_toNNReal _ hT] at this
+  rw [hρ]
+  refine forall_congr' fun i => ?_
+  rw [Finset.mem_Icc, Int.ceil_le, Int.le_floor, abs_le]
+  constructor <;> rintro ⟨h1, h2⟩ <;> constructor <;> linarith
+
+/-- The lattice count is a product of one-dimensional counts. -/
+theorem latCount_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {T : ℝ} (hT : 0 ≤ T) (p : Rn n) :
+    latCount α p T = ∏ i, (cnt1 (p i) (T ^ α i) : ℝ≥0∞) := by
+  set S : Finset (Fin n → ℤ) :=
+    Fintype.piFinset fun i => Finset.Icc (⌈-p i - T ^ α i⌉) (⌊-p i + T ^ α i⌋)
+  have hind : ∀ u : Fin n → ℤ, (ballA α T).indicator (fun _ => (1 : ℝ≥0∞)) (p + latticePt u) =
+      if u ∈ S then 1 else 0 := by
+    intro u
+    have h := mem_ballA_add_iff α hα hT p u
+    by_cases hu : u ∈ S
+    · simp only [hu, ↓reduceIte]
+      exact Set.indicator_of_mem (h.mpr (Fintype.mem_piFinset.mp hu)) _
+    · simp only [hu, ↓reduceIte]
+      exact Set.indicator_of_notMem (fun h' => hu (Fintype.mem_piFinset.mpr (h.mp h'))) _
+  unfold latCount
+  simp_rw [hind]
+  rw [tsum_eq_sum (s := S) fun u hu => by simp [hu], Finset.sum_boole]
+  rw [Finset.filter_mem_eq_inter, Finset.inter_self, Fintype.card_piFinset]
+  push_cast
+  refine Finset.prod_congr rfl fun i _ => ?_
+  rw [Int.card_Icc, cnt1]
+  congr 3
+  ring_nf
+
+theorem tendsto_cnt1_div (x : ℝ) {a : ℕ} (ha : 1 ≤ a) :
+    Filter.Tendsto (fun T : ℝ => (cnt1 x (T ^ a) : ℝ) / T ^ a) Filter.atTop (nhds 2) := by
+  have hTa : Filter.Tendsto (fun T : ℝ => (T ^ a)⁻¹) Filter.atTop (nhds 0) :=
+    tendsto_inv_atTop_zero.comp (Filter.tendsto_pow_atTop (by omega))
+  have hlo : Filter.Tendsto (fun T : ℝ => 2 - (T ^ a)⁻¹) Filter.atTop (nhds 2) := by
+    simpa using tendsto_const_nhds.sub hTa
+  have hhi : Filter.Tendsto (fun T : ℝ => 2 + (T ^ a)⁻¹) Filter.atTop (nhds 2) := by
+    simpa using tendsto_const_nhds.add hTa
+  refine tendsto_of_tendsto_of_tendsto_of_le_of_le' hlo hhi ?_ ?_
+  · filter_upwards [Filter.eventually_gt_atTop 0] with T hT
+    have hb := (cnt1_bounds (x := x) (L := T ^ a) (by positivity)).1
+    have hpos : 0 < T ^ a := by positivity
+    rw [le_div_iff₀ hpos, sub_mul, inv_mul_cancel₀ hpos.ne']
+    linarith
+  · filter_upwards [Filter.eventually_gt_atTop 0] with T hT
+    have hb := (cnt1_bounds (x := x) (L := T ^ a) (by positivity)).2
+    have hpos : 0 < T ^ a := by positivity
+    rw [div_le_iff₀ hpos, add_mul, inv_mul_cancel₀ hpos.ne']
+    linarith
+
+theorem latCount_mul_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {T : ℝ} (hT : 0 < T) (p : Rn n) :
+    latCount α p T * ENNReal.ofReal ((T ^ absA α)⁻¹) =
+      ENNReal.ofReal (∏ i, (cnt1 (p i) (T ^ α i) : ℝ) / T ^ α i) := by
+  rw [latCount_eq α hα hT.le, ENNReal.ofReal_prod_of_nonneg (fun i _ => by positivity)]
+  have hprod : ((T ^ absA α)⁻¹ : ℝ) = ∏ i, (T ^ α i)⁻¹ := by
+    rw [absA, ← Finset.prod_pow_eq_pow_sum, Finset.prod_inv_distrib]
+  rw [hprod, ENNReal.ofReal_prod_of_nonneg (fun i _ => by positivity), ← Finset.prod_mul_distrib]
+  refine Finset.prod_congr rfl fun i _ => ?_
+  rw [div_eq_mul_inv, ENNReal.ofReal_mul (Nat.cast_nonneg _), ENNReal.ofReal_natCast]
+
+/-- Lattice count asymptotics (paper, Lemma 3.3, texline~257–259):
+`#{u : ρ(p + u) ≤ T} / T^{|α|} → 2ⁿ` as `T → ∞`. -/
+theorem tendsto_latCount (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (p : Rn n) :
+    Filter.Tendsto (fun T : ℝ => latCount α p T * ENNReal.ofReal ((T ^ absA α)⁻¹))
+      Filter.atTop (nhds (2 ^ n)) := by
+  have h1 : Filter.Tendsto (fun T : ℝ => ∏ i, (cnt1 (p i) (T ^ α i) : ℝ) / T ^ α i)
+      Filter.atTop (nhds (∏ _i : Fin n, (2 : ℝ))) :=
+    tendsto_finsetProd _ fun i _ => tendsto_cnt1_div (p i) (hα i)
+  rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin] at h1
+  have h2 := (ENNReal.tendsto_ofReal h1)
+  rw [show ENNReal.ofReal (2 ^ n) = 2 ^ n by rw [ENNReal.ofReal_pow (by norm_num)]; simp] at h2
+  refine h2.congr' ?_
+  filter_upwards [Filter.eventually_gt_atTop 0] with T hT
+  rw [latCount_mul_eq α hα hT]
+
+theorem latCount_mul_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {T : ℝ} (hT : 1 ≤ T) (p : Rn n) :
+    latCount α p T * ENNReal.ofReal ((T ^ absA α)⁻¹) ≤ 3 ^ n := by
+  rw [latCount_mul_eq α hα (by linarith)]
+  calc ENNReal.ofReal (∏ i, (cnt1 (p i) (T ^ α i) : ℝ) / T ^ α i)
+      ≤ ENNReal.ofReal (∏ _i : Fin n, (3 : ℝ)) := by
+        apply ENNReal.ofReal_le_ofReal
+        refine Finset.prod_le_prod₀ (fun i _ => by positivity) fun i _ => ?_
+        have hpos : 0 < T ^ α i := by positivity
+        have h1 : 1 ≤ T ^ α i := one_le_pow₀ hT
+        have hb := (cnt1_bounds (x := p i) (L := T ^ α i) hpos.le).2
+        rw [div_le_iff₀ hpos]
+        linarith
+    _ = 3 ^ n := by
+        rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin, ENNReal.ofReal_pow (by norm_num)]
+        simp
+
+theorem chiE_eq_zero {w : Rn n} (hw : ∃ i, b0 / 2 ≤ |w i - 1 / 4|) : chiE w = 0 := by
+  obtain ⟨i, hi⟩ := hw
+  have : phiR (w - quarterVec n) = 0 := by
+    have h := phiHat_eq_zero_of_lt (ξ := w - quarterVec n) (i := i) (by simpa [quarterVec] using hi)
+    rw [phiHat_eq_phiR] at h
+    exact_mod_cast h
+  simp [chiE, this]
+
+theorem chiE_le_one (w : Rn n) : chiE w ≤ 1 := by
+  rw [chiE, ENNReal.ofReal_le_one]
+  have h0 := phiR_nonneg (w - quarterVec n)
+  have h1 := phiR_le_one (w - quarterVec n)
+  nlinarith
+
+theorem continuous_dil_param (α : Fin n → ℕ) (ζ : Rn n) :
+    Continuous fun t : ℝ => dil α t ζ := by
+  have : (fun t : ℝ => dil α t ζ) = fun t => WithLp.toLp 2 (fun i => t ^ α i * ζ i) := rfl
+  rw [this]
+  exact (PiLp.continuous_toLp 2 _).comp (continuous_pi fun i => by fun_prop)
+
+/-- Support of the `(v, w)`-integrand: if `χ(w) ≠ 0` and `w - δ_{2^v}ζ ∈ Q_r` then, for every `j`
+with `r_j = 1`, `2^{v α_j} |ζ_j| ≥ 1/5`, and for every `i`, `2^{v αᵢ} |ζᵢ| ≤ 2`. -/
+theorem support_bounds (α : Fin n → ℕ) {r : Fin n → Fin 2} {ζ w : Rn n} {t : ℝ}
+    (hχ : chiE w ≠ 0) (hQ : w - dil α t ζ ∈ boxQ r) :
+    (∀ j, r j = 1 → 1 / 5 ≤ |t ^ α j * ζ j|) ∧ (∀ i, |t ^ α i * ζ i| ≤ 2) := by
+  have hw : ∀ i, |w i - 1 / 4| < b0 / 2 := by
+    by_contra h
+    push Not at h
+    exact hχ (chiE_eq_zero h)
+  constructor
+  · intro j hj
+    have hQj := (hQ j).1
+    rw [hj] at hQj
+    simp only [Fin.val_one, Nat.cast_one, PiLp.sub_apply, dil_apply] at hQj
+    have hwj := hw j
+    rw [abs_lt] at hwj
+    norm_num [b0] at hwj
+    rw [le_abs]
+    right
+    linarith
+  · intro i
+    have hQi := hQ i
+    simp only [PiLp.sub_apply, dil_apply] at hQi
+    have hri : ((r i : ℕ) : ℝ) ≤ 1 := by exact_mod_cast Nat.lt_succ_iff.mp (r i).2
+    have hri0 : (0 : ℝ) ≤ ((r i : ℕ) : ℝ) := Nat.cast_nonneg _
+    have hwi := hw i
+    rw [abs_lt] at hwi
+    norm_num [b0] at hwi
+    rw [abs_le]
+    constructor <;> linarith [hQi.1, hQi.2]
+
+/-- `Θ(ζ) = ∫_ℝ ∫ χ(w) 1_{Q_r}(w - δ_{2^v} ζ) dw dv`, so that `θ_r = 4ⁿ Θ` (paper, Lemma 3.3, (3.8),
+in the variable `t = 2^v`). -/
+def ThetaE (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) : ℝ≥0∞ :=
+  ∫⁻ v : ℝ, ∫⁻ w : Rn n, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+    (w - dil α ((2 : ℝ) ^ v) ζ)
+
+/-- The multiplier `θ_r(ζ) = 4ⁿ Θ(ζ)` of Lemma 3.3 ((3.8)). -/
+def thetaR (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) : ℝ := 4 ^ n * (ThetaE α r ζ).toReal
+
+theorem continuous_dil_two_rpow (α : Fin n → ℕ) (ζ : Rn n) :
+    Continuous fun v : ℝ => dil α ((2 : ℝ) ^ v) ζ :=
+  (continuous_dil_param α ζ).comp (Real.continuous_const_rpow (by norm_num))
+
+theorem measurable_latCount_param (α : Fin n → ℕ) (ζ : Rn n) (R : ℝ) :
+    Measurable fun q : ℝ × Rn n =>
+      latCount α (q.2 - dil α ((2 : ℝ) ^ q.1) ζ) ((2 : ℝ) ^ q.1 * R) := by
+  unfold latCount
+  refine Measurable.tsum fun u => ?_
+  have hset : MeasurableSet {q : ℝ × Rn n |
+      q.2 - dil α ((2 : ℝ) ^ q.1) ζ + latticePt u ∈ ballA α ((2 : ℝ) ^ q.1 * R)} := by
+    simp only [ballA, Set.mem_ofPred_eq]
+    refine measurableSet_le ?_ ?_
+    · exact (continuous_rho α).measurable.comp
+        ((measurable_snd.sub ((continuous_dil_two_rpow α ζ).measurable.comp
+            measurable_fst)).add_const _)
+    · exact ((Real.continuous_const_rpow (by norm_num)).measurable.comp measurable_fst).mul_const _
+  have : (fun q : ℝ × Rn n => (ballA α ((2 : ℝ) ^ q.1 * R)).indicator (fun _ => (1 : ℝ≥0∞))
+      (q.2 - dil α ((2 : ℝ) ^ q.1) ζ + latticePt u)) =
+      {q : ℝ × Rn n | q.2 - dil α ((2 : ℝ) ^ q.1) ζ + latticePt u ∈
+        ballA α ((2 : ℝ) ^ q.1 * R)}.indicator (fun _ => 1) := by
+    funext q
+    by_cases h : q.2 - dil α ((2 : ℝ) ^ q.1) ζ + latticePt u ∈ ballA α ((2 : ℝ) ^ q.1 * R)
+    · rw [Set.indicator_of_mem h, Set.indicator_of_mem (by exact h)]
+    · rw [Set.indicator_of_notMem h, Set.indicator_of_notMem (by exact h)]
+  rw [this]
+  exact measurable_const.indicator hset
+
+theorem measurable_chiQ_param (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) :
+    Measurable fun q : ℝ × Rn n => chiE q.2 *
+      (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (q.2 - dil α ((2 : ℝ) ^ q.1) ζ) :=
+  (measurable_chiE.comp measurable_snd).mul ((measurable_const.indicator (measurableSet_boxQ
+      r)).comp
+    (measurable_snd.sub ((continuous_dil_two_rpow α ζ).measurable.comp measurable_fst)))
+
+/-- The box `{w : |wᵢ - 1/4| ≤ b₀/2}` containing the support of `χ`. -/
+def chiBox (n : ℕ) : Set (Rn n) := {w | ∀ i, |w i - 1 / 4| ≤ b0 / 2}
+
+theorem chiE_le_indicator (w : Rn n) :
+    chiE w ≤ (chiBox n).indicator (fun _ => (1 : ℝ≥0∞)) w := by
+  by_cases hw : w ∈ chiBox n
+  · rw [Set.indicator_of_mem hw]; exact chiE_le_one w
+  · rw [Set.indicator_of_notMem hw]
+    simp only [chiBox, Set.mem_ofPred_eq, not_forall, not_le] at hw
+    obtain ⟨i, hi⟩ := hw
+    rw [chiE_eq_zero ⟨i, hi.le⟩]
+
+theorem volume_chiBox_lt_top : volume (chiBox n) < ⊤ := by
+  have : chiBox n = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun _ => Set.Icc (1 / 4 - b0 / 2) (1 / 4 + b0 / 2) := by
+    ext w
+    constructor
+    · intro h
+      refine ⟨WithLp.ofLp w, fun i _ => ?_, by simp⟩
+      have := abs_le.mp (h i)
+      constructor <;> linarith [this.1, this.2]
+    · rintro ⟨v, hv, rfl⟩ i
+      have := hv i (Set.mem_univ i)
+      rw [abs_le]
+      constructor <;> simp <;> linarith [this.1, this.2]
+  rw [this]
+  exact ((isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)).measure_lt_top
+
+theorem measurableSet_chiBox : MeasurableSet (chiBox n) := by
+  have : chiBox n = ⋂ i, {w : Rn n | |w i - 1 / 4| ≤ b0 / 2} := by ext w; simp [chiBox]
+  rw [this]
+  refine MeasurableSet.iInter fun i => measurableSet_le ?_ measurable_const
+  exact (((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)).sub continuous_const).abs.measurable
+
+/-- The inner integral `∫ χ(w) 1_{Q_r}(w - δ_{2^v} ζ) dw` vanishes outside a compact range of
+`v` when `ζ ≠ 0`, and is bounded by `|chiBox|`. -/
+theorem innerTheta_bounds (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ζ : Rn n} (hζ : ζ ≠ 0) :
+    ∃ v1 v2 : ℝ, ∀ v : ℝ, ∀ w : Rn n,
+      chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α ((2 : ℝ) ^ v) ζ) ≠ 0 →
+        v ∈ Set.Icc v1 v2 := by
+  obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+  obtain ⟨i, hi⟩ : ∃ i, ζ i ≠ 0 := by
+    by_contra h
+    push Not at h
+    exact hζ (by ext i; simp [h i])
+  by_cases hζj : ζ j = 0
+  · refine ⟨0, 0, fun v w hne => ?_⟩
+    exfalso
+    have hχ : chiE w ≠ 0 := left_ne_zero_of_mul hne
+    have hQ : w - dil α ((2 : ℝ) ^ v) ζ ∈ boxQ r := by
+      by_contra hQ
+      rw [Set.indicator_of_notMem hQ, mul_zero] at hne
+      exact hne rfl
+    have := (support_bounds α hχ hQ).1 j hj
+    rw [hζj, mul_zero, abs_zero] at this
+    norm_num at this
+  · -- lower bound from `j`, upper bound from `i`
+    have hαj : (0 : ℝ) < α j := by have := hα j; positivity
+    have hαi : (0 : ℝ) < α i := by have := hα i; positivity
+    set v1 := Real.logb 2 ((1 / (5 * |ζ j|)) ^ ((α j : ℝ)⁻¹))
+    set v2 := Real.logb 2 ((2 / |ζ i|) ^ ((α i : ℝ)⁻¹))
+    refine ⟨v1, v2, fun v w hne => ?_⟩
+    have hχ : chiE w ≠ 0 := left_ne_zero_of_mul hne
+    have hQ : w - dil α ((2 : ℝ) ^ v) ζ ∈ boxQ r := by
+      by_contra hQ
+      rw [Set.indicator_of_notMem hQ, mul_zero] at hne
+      exact hne rfl
+    obtain ⟨hlo, hhi⟩ := support_bounds α hχ hQ
+    have hlo' := hlo j hj
+    have hhi' := hhi i
+    have h2v : (0 : ℝ) < 2 ^ v := by positivity
+    rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < (2 ^ v) ^ α j)] at hlo'
+    rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < (2 ^ v) ^ α i)] at hhi'
+    have hzj : 0 < |ζ j| := abs_pos.mpr hζj
+    have hzi : 0 < |ζ i| := abs_pos.mpr hi
+    constructor
+    · -- `(2^v)^{α_j} ≥ 1/(5|ζ_j|)`
+      have h1 : 1 / (5 * |ζ j|) ≤ (2 ^ v) ^ α j := by
+        rw [div_le_iff₀ (by positivity)]; nlinarith
+      have h2 : (1 / (5 * |ζ j|)) ^ ((α j : ℝ)⁻¹) ≤ 2 ^ v := by
+        calc (1 / (5 * |ζ j|)) ^ ((α j : ℝ)⁻¹) ≤ ((2 ^ v) ^ α j) ^ ((α j : ℝ)⁻¹) :=
+              Real.rpow_le_rpow (by positivity) h1 (by positivity)
+          _ = 2 ^ v := by
+              rw [← Real.rpow_natCast, ← Real.rpow_mul h2v.le, mul_inv_cancel₀ hαj.ne',
+                Real.rpow_one]
+      have := Real.logb_le_logb_of_le (b := 2) (by norm_num) (by positivity) h2
+      rwa [Real.logb_rpow (by norm_num) (by norm_num)] at this
+    · have h1 : (2 ^ v) ^ α i ≤ 2 / |ζ i| := by
+        rw [le_div_iff₀ hzi]; exact hhi'
+      have h2 : 2 ^ v ≤ (2 / |ζ i|) ^ ((α i : ℝ)⁻¹) := by
+        calc (2 : ℝ) ^ v = ((2 ^ v) ^ α i) ^ ((α i : ℝ)⁻¹) := by
+              rw [← Real.rpow_natCast, ← Real.rpow_mul h2v.le, mul_inv_cancel₀ hαi.ne',
+                Real.rpow_one]
+          _ ≤ _ := Real.rpow_le_rpow (by positivity) h1 (by positivity)
+      have := Real.logb_le_logb_of_le (b := 2) (by norm_num) h2v h2
+      rwa [Real.logb_rpow (by norm_num) (by norm_num)] at this
+
+theorem ThetaE_lt_top (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ζ : Rn n} (hζ : ζ ≠ 0) : ThetaE α r ζ < ⊤ := by
+  obtain ⟨v1, v2, hv⟩ := innerTheta_bounds α hα hr hζ
+  have hle : ∀ v, ∫⁻ w : Rn n, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞))
+      (w - dil α ((2 : ℝ) ^ v) ζ) ≤ (Set.Icc v1 v2).indicator (fun _ => volume (chiBox n)) v := by
+    intro v
+    by_cases hvI : v ∈ Set.Icc v1 v2
+    · rw [Set.indicator_of_mem hvI]
+      calc _ ≤ ∫⁻ w : Rn n, (chiBox n).indicator (fun _ => (1 : ℝ≥0∞)) w := by
+            refine lintegral_mono fun w => ?_
+            calc _ ≤ chiE w * 1 := by
+                  gcongr
+                  by_cases h : w - dil α ((2 : ℝ) ^ v) ζ ∈ boxQ r
+                  · simp [Set.indicator_of_mem h]
+                  · simp [Set.indicator_of_notMem h]
+              _ ≤ _ := by rw [mul_one]; exact chiE_le_indicator w
+        _ = volume (chiBox n) := by
+            rw [lintegral_indicator measurableSet_chiBox, setLIntegral_const, one_mul]
+    · rw [Set.indicator_of_notMem hvI]
+      refine le_of_eq (lintegral_eq_zero_of_ae_eq_zero ?_)  -- dummy, replaced below
+      exact Filter.Eventually.of_forall fun w => by
+        by_contra hne
+        exact hvI (hv v w hne)
+  calc ThetaE α r ζ ≤ ∫⁻ v : ℝ, (Set.Icc v1 v2).indicator (fun _ => volume (chiBox n)) v :=
+        lintegral_mono hle
+    _ = volume (chiBox n) * volume (Set.Icc v1 v2) := by
+        rw [lintegral_indicator measurableSet_Icc, setLIntegral_const]
+    _ < ⊤ := ENNReal.mul_lt_top volume_chiBox_lt_top (by simp)
+
+theorem continuous_dil_joint (α : Fin n → ℕ) : Continuous fun p : ℝ × Rn n => dil α p.1 p.2 := by
+  have : (fun p : ℝ × Rn n => dil α p.1 p.2) =
+      fun p => WithLp.toLp 2 (fun i => p.1 ^ α i * p.2 i) := rfl
+  rw [this]
+  refine (PiLp.continuous_toLp 2 _).comp (continuous_pi fun i => ?_)
+  exact (continuous_fst.pow _).mul ((continuous_apply i).comp
+    ((PiLp.continuous_ofLp 2 _).comp continuous_snd))
+
+theorem measurable_Gsum_param (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) :
+    Measurable fun q : Rn n × ℝ => Gsum α r ζ q.1 ((2 : ℝ) ^ q.2) := by
+  unfold Gsum
+  refine Measurable.tsum fun u => ?_
+  have hd1 : Measurable fun q : Rn n × ℝ => dil α ((2 : ℝ) ^ q.2) q.1 :=
+    (continuous_dil_joint α).measurable.comp
+      (((Real.continuous_const_rpow (by norm_num)).measurable.comp measurable_snd).prodMk
+          measurable_fst)
+  have hd2 : Measurable fun q : Rn n × ℝ => dil α ((2 : ℝ) ^ q.2) (ζ + q.1) :=
+    (continuous_dil_joint α).measurable.comp
+      (((Real.continuous_const_rpow (by norm_num)).measurable.comp measurable_snd).prodMk
+        (measurable_const.add measurable_fst))
+  exact ((measurable_const.indicator (measurableSet_boxQ r)).comp (hd1.sub_const _)).mul
+    (measurable_chiE.comp (hd2.sub_const _))
+
+theorem measurable_Gsum_v (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ η : Rn n) :
+    Measurable fun v : ℝ => Gsum α r ζ η ((2 : ℝ) ^ v) := by
+  unfold Gsum
+  refine Measurable.tsum fun u => ?_
+  have hd1 : Measurable fun v : ℝ => dil α ((2 : ℝ) ^ v) η :=
+    (continuous_dil_two_rpow α η).measurable
+  have hd2 : Measurable fun v : ℝ => dil α ((2 : ℝ) ^ v) (ζ + η) :=
+    (continuous_dil_two_rpow α (ζ + η)).measurable
+  exact ((measurable_const.indicator (measurableSet_boxQ r)).comp (hd1.sub_const _)).mul
+    (measurable_chiE.comp (hd2.sub_const _))
+
+/-- The `(v, w)`-profile `χ(w) 1_{Q_r}(w - δ_{2^v} ζ)`. -/
+def cQfun (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (v : ℝ) (w : Rn n) : ℝ≥0∞ :=
+  chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α ((2 : ℝ) ^ v) ζ)
+
+/-- The rescaled integrand `χ(w) 1_{Q_r}(w - δ_{2^v}ζ) #{…}/(2^v R)^{|α|}` of (3.7). -/
+def Ifun (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R v : ℝ) (w : Rn n) : ℝ≥0∞ :=
+  cQfun α r ζ v w * (latCount α (w - dil α ((2 : ℝ) ^ v) ζ) ((2 : ℝ) ^ v * R) *
+    ENNReal.ofReal ((((2 : ℝ) ^ v * R) ^ absA α)⁻¹))
+
+theorem measurable_cQfun (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) :
+    Measurable fun q : ℝ × Rn n => cQfun α r ζ q.1 q.2 := measurable_chiQ_param α r ζ
+
+theorem measurable_cQfun_v (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (v : ℝ) :
+    Measurable (cQfun α r ζ v) :=
+  measurable_chiE.mul ((measurable_const.indicator (measurableSet_boxQ r)).comp
+    (measurable_id.sub_const _))
+
+theorem measurable_Ifun (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R : ℝ) :
+    Measurable fun q : ℝ × Rn n => Ifun α r ζ R q.1 q.2 := by
+  refine (measurable_cQfun α r ζ).mul ((measurable_latCount_param α ζ R).mul ?_)
+  exact ENNReal.measurable_ofReal.comp ((((Real.continuous_const_rpow (by norm_num)).measurable.comp
+    measurable_fst).mul_const R).pow_const _).inv
+
+theorem measurable_latCount_w (α : Fin n → ℕ) (c : Rn n) (T : ℝ) :
+    Measurable fun w : Rn n => latCount α (w - c) T := by
+  unfold latCount
+  exact Measurable.tsum fun u => (measurable_const.indicator (measurableSet_ballA α T)).comp
+    ((measurable_id.sub_const c).add_const _)
+
+theorem measurable_Ifun_v (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R v : ℝ) :
+    Measurable (Ifun α r ζ R v) := by
+  unfold Ifun
+  exact (measurable_cQfun_v α r ζ v).mul ((measurable_latCount_w α _ _).mul measurable_const)
+
+theorem ThetaE_eq (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) :
+    ThetaE α r ζ = ∫⁻ v : ℝ, ∫⁻ w, cQfun α r ζ v w := rfl
+
+/-- Step A of the limit (paper, Lemma 3.3, texline~244–256): the averages of `Ξ_r` in terms of the
+rescaled lattice counts. -/
+theorem avg_XiE_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (r : Fin n → Fin 2) (ζ : Rn n) {R : ℝ}
+    (hR : 0 < R) :
+    ENNReal.ofReal ((R ^ absA α)⁻¹) * ∫⁻ η in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s =
+      ∫⁻ v : ℝ, ∫⁻ w, Ifun α r ζ R v w := by
+  have h1 : ∀ η, ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s =
+      ∫⁻ v : ℝ, Gsum α r ζ η ((2 : ℝ) ^ v) := by
+    intro η
+    have h := lintegral_Ioc_tsum_sub (fun v => Gsum α r ζ η ((2 : ℝ) ^ v)) (measurable_Gsum_v α
+        r ζ η)
+    beta_reduce at h
+    unfold XiE
+    exact h
+  simp_rw [h1]
+  rw [lintegral_lintegral_swap ((measurable_Gsum_param α r ζ).aemeasurable)]
+  have hB : ∀ v : ℝ, ∫⁻ η in ballA α R, Gsum α r ζ η ((2 : ℝ) ^ v) =
+      ENNReal.ofReal ((((2 : ℝ) ^ v) ^ absA α)⁻¹) *
+        ∫⁻ w, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α ((2 : ℝ) ^ v) ζ) *
+          latCount α (w - dil α ((2 : ℝ) ^ v) ζ) ((2 : ℝ) ^ v * R) :=
+    fun v => lintegral_ballA_Gsum α hα r ζ (by positivity) R
+  simp_rw [hB]
+  rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+  refine lintegral_congr fun v => ?_
+  rw [← mul_assoc, ← ENNReal.ofReal_mul (by positivity),
+    ← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+  refine lintegral_congr fun w => ?_
+  have hc : (R ^ absA α)⁻¹ * (((2 : ℝ) ^ v) ^ absA α)⁻¹ = (((2 : ℝ) ^ v * R) ^ absA α)⁻¹ := by
+    rw [mul_pow, mul_inv, mul_comm]
+  rw [hc, Ifun, cQfun]
+  ring
+
+/-- Domination for the rescaled integrand, for `R` large (depending on `ζ`). -/
+theorem Ifun_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0) (ζ : Rn n) :
+    ∃ R0 : ℝ, 0 < R0 ∧ ∀ R, R0 ≤ R → ∀ v w, Ifun α r ζ R v w ≤ 3 ^ n * cQfun α r ζ v w := by
+  obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+  refine ⟨max ((5 * |ζ j|) ^ ((α j : ℝ)⁻¹)) 1, by positivity, fun R hR v w => ?_⟩
+  by_cases hcq : cQfun α r ζ v w = 0
+  · simp [Ifun, hcq]
+  · have hχ : chiE w ≠ 0 := left_ne_zero_of_mul hcq
+    have hQ : w - dil α ((2 : ℝ) ^ v) ζ ∈ boxQ r := by
+      by_contra hQ
+      apply hcq
+      simp [cQfun, Set.indicator_of_notMem hQ]
+    have hlo := (support_bounds α hχ hQ).1 j hj
+    have h2v : (0 : ℝ) < 2 ^ v := by positivity
+    rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < (2 ^ v) ^ α j)] at hlo
+    have hzj : 0 < |ζ j| := by
+      by_contra h
+      push Not at h
+      have : |ζ j| = 0 := le_antisymm h (abs_nonneg _)
+      rw [this, mul_zero] at hlo
+      norm_num at hlo
+    have hαj : (0 : ℝ) < α j := by have := hα j; positivity
+    have hT : 1 ≤ (2 : ℝ) ^ v * R := by
+      have h1 : 1 ≤ (2 ^ v) ^ α j * (5 * |ζ j|) := by nlinarith
+      have h2 : 1 ≤ 2 ^ v * (5 * |ζ j|) ^ ((α j : ℝ)⁻¹) := by
+        have := Real.rpow_le_rpow (by norm_num) h1 (by positivity : (0 : ℝ) ≤ (α j : ℝ)⁻¹)
+        rwa [Real.one_rpow, Real.mul_rpow (by positivity) (by positivity), ← Real.rpow_natCast,
+          ← Real.rpow_mul h2v.le, mul_inv_cancel₀ hαj.ne', Real.rpow_one] at this
+      calc (1 : ℝ) ≤ 2 ^ v * (5 * |ζ j|) ^ ((α j : ℝ)⁻¹) := h2
+        _ ≤ 2 ^ v * R := by gcongr; exact (le_max_left _ _).trans hR
+    calc Ifun α r ζ R v w = cQfun α r ζ v w * (latCount α (w - dil α ((2 : ℝ) ^ v) ζ)
+          ((2 : ℝ) ^ v * R) * ENNReal.ofReal ((((2 : ℝ) ^ v * R) ^ absA α)⁻¹)) := rfl
+      _ ≤ cQfun α r ζ v w * 3 ^ n := by gcongr; exact latCount_mul_le α hα hT _
+      _ = 3 ^ n * cQfun α r ζ v w := mul_comm _ _
+
+theorem cQfun_le_indicator (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (v : ℝ) (w : Rn n) :
+    cQfun α r ζ v w ≤ (chiBox n).indicator (fun _ => (1 : ℝ≥0∞)) w := by
+  calc cQfun α r ζ v w ≤ chiE w * 1 := by
+        unfold cQfun
+        gcongr
+        by_cases h : w - dil α ((2 : ℝ) ^ v) ζ ∈ boxQ r
+        · simp [Set.indicator_of_mem h]
+        · simp [Set.indicator_of_notMem h]
+    _ ≤ _ := by rw [mul_one]; exact chiE_le_indicator w
+
+theorem lintegral_cQfun_le (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (v : ℝ) :
+    ∫⁻ w, cQfun α r ζ v w ≤ volume (chiBox n) := by
+  calc ∫⁻ w, cQfun α r ζ v w ≤ ∫⁻ w : Rn n, (chiBox n).indicator (fun _ => (1 : ℝ≥0∞)) w :=
+        lintegral_mono fun w => cQfun_le_indicator α r ζ v w
+    _ = volume (chiBox n) := by
+        rw [lintegral_indicator measurableSet_chiBox, setLIntegral_const, one_mul]
+
+theorem tendsto_Ifun (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (r : Fin n → Fin 2) (ζ : Rn n) (v : ℝ)
+    (w : Rn n) :
+    Filter.Tendsto (fun R => Ifun α r ζ R v w) Filter.atTop (nhds (2 ^ n * cQfun α r ζ v w)) := by
+  rw [mul_comm (2 ^ n)]
+  have hT : Filter.Tendsto (fun R : ℝ => (2 : ℝ) ^ v * R) Filter.atTop Filter.atTop :=
+    Filter.tendsto_id.const_mul_atTop (by positivity)
+  have hfin : cQfun α r ζ v w ≠ ⊤ :=
+    ne_top_of_le_ne_top ENNReal.one_ne_top ((cQfun_le_indicator α r ζ v w).trans
+      (Set.indicator_le_self' (fun _ _ => zero_le_one) w))
+  exact ENNReal.Tendsto.const_mul ((tendsto_latCount α hα _).comp hT) (Or.inr hfin)
+
+/-- The pointwise limit of the averages of `Ξ_r` (paper, Lemma 3.3, texline~257–262): for
+`ζ ≠ 0`, `R^{-|α|} ∫_{𝓑_R} ∫_0^1 Ξ_r(ζ, η, s) ds dη → 2ⁿ Θ(ζ)`. -/
+theorem tendsto_avg_XiE (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ζ : Rn n} (hζ : ζ ≠ 0) :
+    Filter.Tendsto (fun R : ℝ => ENNReal.ofReal ((R ^ absA α)⁻¹) *
+      ∫⁻ η in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s) Filter.atTop
+      (nhds (2 ^ n * ThetaE α r ζ)) := by
+  obtain ⟨R0, hR0, hbound⟩ := Ifun_le α hα hr ζ
+  have hlim : Filter.Tendsto (fun R => ∫⁻ v : ℝ, ∫⁻ w, Ifun α r ζ R v w) Filter.atTop
+      (nhds (∫⁻ v : ℝ, 2 ^ n * ∫⁻ w, cQfun α r ζ v w)) := by
+    refine tendsto_lintegral_filter_of_dominated_convergence
+      (fun v => 3 ^ n * ∫⁻ w, cQfun α r ζ v w)
+      (Filter.Eventually.of_forall fun R => (measurable_Ifun α r ζ R).lintegral_prod_right') ?_
+          ?_ ?_
+    · filter_upwards [Filter.eventually_ge_atTop R0] with R hR
+      refine Filter.Eventually.of_forall fun v => ?_
+      rw [← lintegral_const_mul _ (measurable_cQfun_v α r ζ v)]
+      exact lintegral_mono fun w => hbound R hR v w
+    · rw [lintegral_const_mul _ (measurable_cQfun α r ζ).lintegral_prod_right', ← ThetaE_eq]
+      exact ENNReal.mul_ne_top (by simp) (ThetaE_lt_top α hα hr hζ).ne
+    · refine Filter.Eventually.of_forall fun v => ?_
+      rw [← lintegral_const_mul _ (measurable_cQfun_v α r ζ v)]
+      refine tendsto_lintegral_filter_of_dominated_convergence (fun w => 3 ^ n * cQfun α r ζ v w)
+        (Filter.Eventually.of_forall fun R => measurable_Ifun_v α r ζ R v) ?_ ?_ ?_
+      · filter_upwards [Filter.eventually_ge_atTop R0] with R hR
+        exact Filter.Eventually.of_forall fun w => hbound R hR v w
+      · rw [lintegral_const_mul _ (measurable_cQfun_v α r ζ v)]
+        exact ENNReal.mul_ne_top (by simp)
+          (ne_top_of_le_ne_top volume_chiBox_lt_top.ne (lintegral_cQfun_le α r ζ v))
+      · exact Filter.Eventually.of_forall fun w => tendsto_Ifun α hα r ζ v w
+  rw [lintegral_const_mul _ (measurable_cQfun α r ζ).lintegral_prod_right', ← ThetaE_eq] at hlim
+  refine hlim.congr' ?_
+  filter_upwards [Filter.eventually_gt_atTop 0] with R hR
+  exact (avg_XiE_eq α hα r ζ hR).symm
+
+theorem measurable_XiE (α : Fin n → ℕ) (r : Fin n → Fin 2) :
+    Measurable fun p : Rn n × Rn n × ℝ => XiE α r p.1 p.2.1 p.2.2 := by
+  unfold XiE Gsum
+  refine Measurable.tsum fun k => Measurable.tsum fun u => ?_
+  have ht : Measurable fun p : Rn n × Rn n × ℝ => (2 : ℝ) ^ ((k : ℝ) - p.2.2) :=
+    (Real.continuous_const_rpow (by norm_num)).measurable.comp
+      (measurable_const.sub (measurable_snd.comp measurable_snd))
+  have hd1 : Measurable fun p : Rn n × Rn n × ℝ => dil α ((2 : ℝ) ^ ((k : ℝ) - p.2.2)) p.2.1 :=
+    (continuous_dil_joint α).measurable.comp (ht.prodMk (measurable_fst.comp measurable_snd))
+  have hd2 : Measurable fun p : Rn n × Rn n × ℝ =>
+      dil α ((2 : ℝ) ^ ((k : ℝ) - p.2.2)) (p.1 + p.2.1) :=
+    (continuous_dil_joint α).measurable.comp
+      (ht.prodMk (measurable_fst.add (measurable_fst.comp measurable_snd)))
+  exact ((measurable_const.indicator (measurableSet_boxQ r)).comp (hd1.sub_const _)).mul
+    (measurable_chiE.comp (hd2.sub_const _))
+
+theorem ballA_eq_image (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {R : ℝ} (hR : 0 ≤ R) :
+    ballA α R = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun i => Set.Icc (-(R ^ α i)) (R ^ α i) := by
+  ext x
+  have h0 := mem_ballA_add_iff α hα hR x 0
+  simp only [latticePt, Pi.zero_apply, Int.cast_zero] at h0
+  have hlat : (WithLp.toLp 2 (fun _ : Fin n => (0 : ℝ)) : Rn n) = 0 := rfl
+  rw [hlat, add_zero] at h0
+  constructor
+  · intro hx
+    refine ⟨WithLp.ofLp x, fun i _ => ?_, by simp⟩
+    have := (h0.mp hx) i
+    rw [Finset.mem_Icc, Int.ceil_le, Int.le_floor] at this
+    push_cast at this
+    constructor <;> linarith [this.1, this.2]
+  · rintro ⟨v, hv, rfl⟩
+    refine h0.mpr fun i => ?_
+    have := hv i (Set.mem_univ i)
+    rw [Finset.mem_Icc, Int.ceil_le, Int.le_floor]
+    push_cast
+    constructor <;> linarith [this.1, this.2]
+
+/-- `|𝓑_R| = 2ⁿ R^{|α|}`. -/
+theorem volume_ballA (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {R : ℝ} (hR : 0 ≤ R) :
+    volume (ballA α R) = ENNReal.ofReal (2 ^ n * R ^ absA α) := by
+  rw [ballA_eq_image α hα hR, ← (PiLp.volume_preserving_toLp (Fin n)).map_eq,
+    Measure.map_apply_of_aemeasurable (PiLp.volume_preserving_toLp (Fin n)).measurable.aemeasurable]
+  · rw [show (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ⁻¹' ((WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+        Set.pi Set.univ fun i => Set.Icc (-(R ^ α i)) (R ^ α i)) =
+        Set.pi Set.univ fun i => Set.Icc (-(R ^ α i)) (R ^ α i) from
+      Set.preimage_image_eq _ (fun a b h => by simpa using h)]
+    rw [show (Set.pi Set.univ fun i => Set.Icc (-(R ^ α i)) (R ^ α i)) =
+      Set.Icc (fun i => -(R ^ α i)) (fun i => R ^ α i) from Set.pi_univ_Icc _ _, Real.volume_Icc_pi]
+    rw [← ENNReal.ofReal_prod_of_nonneg (fun i _ => by have := pow_nonneg hR (α i); linarith)]
+    congr 1
+    have : ∀ i, R ^ α i - -R ^ α i = 2 * R ^ α i := fun i => by ring
+    simp only [this, Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin,
+      absA, Finset.prod_pow_eq_pow_sum]
+  · have := ballA_eq_image α hα hR
+    rw [← this]
+    exact measurableSet_ballA α R
+
+/-- The frequency-side integrand `f̂(ζ) m(ζ) e^{i x ζ}`. -/
+def Fint (m : Rn n → ℂ) (f : Rn n → ℂ) (x ζ : Rn n) : ℂ :=
+  fhat f ζ * m ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))
+
+theorem integrable_Fint {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (f : 𝓢(Rn n, ℂ)) (x : Rn n) : Integrable (Fint m (f : Rn n → ℂ) x) := by
+  obtain ⟨Cm, -, hmb⟩ := hm.bounded'
+  refine ((integrable_fhat_schwartz f).norm.const_mul Cm).mono' ?_
+    (Filter.Eventually.of_forall fun ζ => ?_)
+  · exact (((continuous_fhat_schwartz f).aestronglyMeasurable.mul
+      hm.measurable.aestronglyMeasurable).mul
+      (by fun_prop : Continuous fun ζ : Rn n =>
+        Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))).aestronglyMeasurable)
+  · rw [Fint, norm_mul, norm_mul, norm_cexp_I_mul, mul_one, mul_comm]
+    exact mul_le_mul_of_nonneg_right (hmb ζ) (norm_nonneg _)
+
+/-- The averaged `Ξ`-integral `J_R(ζ) = ∫_{𝓑_R} ∫_0^1 Ξ_r(ζ, η, s) ds dη`. -/
+def JR (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R : ℝ) : ℝ≥0∞ :=
+  ∫⁻ η in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s
+
+theorem JR_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0) (ζ : Rn n)
+    {R : ℝ} (hR : 0 ≤ R) : JR α r ζ R ≤ 4 * ENNReal.ofReal (2 ^ n * R ^ absA α) := by
+  unfold JR
+  calc ∫⁻ η in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s
+      ≤ ∫⁻ η in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1, (4 : ℝ≥0∞) :=
+        lintegral_mono fun η => lintegral_mono fun s => XiE_le_four α hα hr ζ η s
+    _ = 4 * ENNReal.ofReal (2 ^ n * R ^ absA α) := by
+        simp [volume_ballA α hα hR, mul_comm]
+
+/-- The averaged multiplier `K_R(ζ) = 2ⁿ R^{-|α|} J_R(ζ)`. -/
+def KR (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R : ℝ) : ℝ :=
+  2 ^ n * (ENNReal.ofReal ((R ^ absA α)⁻¹) * JR α r ζ R).toReal
+
+theorem KR_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0) (ζ : Rn n)
+    {R : ℝ} (hR : 0 < R) : KR α r ζ R ≤ 4 * 4 ^ n := by
+  unfold KR
+  have h := JR_le α hα hr ζ hR.le
+  have h2 : ENNReal.ofReal ((R ^ absA α)⁻¹) * JR α r ζ R ≤ ENNReal.ofReal (4 * 2 ^ n) := by
+    calc _ ≤ ENNReal.ofReal ((R ^ absA α)⁻¹) * (4 * ENNReal.ofReal (2 ^ n * R ^ absA α)) := by
+          gcongr
+      _ = ENNReal.ofReal (4 * 2 ^ n) := by
+          rw [show (4 : ℝ≥0∞) = ENNReal.ofReal 4 by simp, ← ENNReal.ofReal_mul (by norm_num),
+            ← ENNReal.ofReal_mul (by positivity)]
+          congr 1
+          field_simp
+  have h3 := ENNReal.toReal_mono ENNReal.ofReal_ne_top h2
+  rw [ENNReal.toReal_ofReal (by positivity)] at h3
+  calc 2 ^ n * (ENNReal.ofReal ((R ^ absA α)⁻¹) * JR α r ζ R).toReal ≤ 2 ^ n * (4 * 2 ^ n) := by
+        gcongr
+    _ = 4 * 4 ^ n := by rw [show (4 : ℝ) ^ n = 2 ^ n * 2 ^ n by rw [← mul_pow]; norm_num]; ring
+
+theorem KR_nonneg (α : Fin n → ℕ) (r : Fin n → Fin 2) (ζ : Rn n) (R : ℝ) : 0 ≤ KR α r ζ R := by
+  unfold KR; positivity
+
+theorem tendsto_KR (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ζ : Rn n} (hζ : ζ ≠ 0) :
+    Filter.Tendsto (fun R => KR α r ζ R) Filter.atTop (nhds (thetaR α r ζ)) := by
+  have h := tendsto_avg_XiE α hα hr hζ
+  have hfin : 2 ^ n * ThetaE α r ζ ≠ ⊤ :=
+    ENNReal.mul_ne_top (by simp) (ThetaE_lt_top α hα hr hζ).ne
+  have h2 := (ENNReal.tendsto_toReal hfin).comp h
+  have h3 := h2.const_mul (2 ^ n : ℝ)
+  have hval : (2 : ℝ) ^ n * (2 ^ n * ThetaE α r ζ).toReal = thetaR α r ζ := by
+    unfold thetaR
+    rw [ENNReal.toReal_mul, ENNReal.toReal_pow, ENNReal.toReal_ofNat,
+      show (4 : ℝ) ^ n = 2 ^ n * 2 ^ n by rw [← mul_pow]; norm_num]
+    ring
+  rw [← hval]
+  exact h3.congr fun R => rfl
+
+theorem measurable_XiE_gen (α : Fin n → ℕ) (r : Fin n → Fin 2) {X : Type*} [MeasurableSpace X]
+    {a b : X → Rn n} {c : X → ℝ} (ha : Measurable a) (hb : Measurable b) (hc : Measurable c) :
+    Measurable fun p => XiE α r (a p) (b p) (c p) := by
+  unfold XiE Gsum
+  refine Measurable.tsum fun k => Measurable.tsum fun u => ?_
+  have ht : Measurable fun p => (2 : ℝ) ^ ((k : ℝ) - c p) :=
+    (Real.continuous_const_rpow (by norm_num)).measurable.comp (measurable_const.sub hc)
+  have hd1 : Measurable fun p => dil α ((2 : ℝ) ^ ((k : ℝ) - c p)) (b p) :=
+    (continuous_dil_joint α).measurable.comp (ht.prodMk hb)
+  have hd2 : Measurable fun p => dil α ((2 : ℝ) ^ ((k : ℝ) - c p)) (a p + b p) :=
+    (continuous_dil_joint α).measurable.comp (ht.prodMk (ha.add hb))
+  exact ((measurable_const.indicator (measurableSet_boxQ r)).comp (hd1.sub_const _)).mul
+    (measurable_chiE.comp (hd2.sub_const _))
+
+theorem measurable_lintegral_XiE_gen (α : Fin n → ℕ) (r : Fin n → Fin 2) {X : Type*}
+    [MeasurableSpace X] {a b : X → Rn n} (ha : Measurable a) (hb : Measurable b) :
+    Measurable fun p => ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r (a p) (b p) s :=
+  (measurable_XiE_gen α r (ha.comp measurable_fst) (hb.comp measurable_fst)
+    measurable_snd).lintegral_prod_right'
+
+theorem measurable_JR (α : Fin n → ℕ) (r : Fin n → Fin 2) (R : ℝ) :
+    Measurable fun ζ : Rn n => JR α r ζ R := by
+  unfold JR
+  exact (measurable_lintegral_XiE_gen α r measurable_fst measurable_snd).lintegral_prod_right'
+
+theorem measurable_KR (α : Fin n → ℕ) (r : Fin n → Fin 2) (R : ℝ) :
+    Measurable fun ζ : Rn n => KR α r ζ R := by
+  unfold KR
+  exact measurable_const.mul ((measurable_const.mul (measurable_JR α r R)).ennreal_toReal)
+
+theorem lintegral_XiE_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ζ η : Rn n) : ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s ≤ 4 := by
+  calc _ ≤ ∫⁻ s in Set.Ioc (0 : ℝ) 1, (4 : ℝ≥0∞) :=
+        lintegral_mono fun s => XiE_le_four α hα hr ζ η s
+    _ = 4 := by simp
+
+theorem avgIntegrand_eq' (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x η y : Rn n) (s : ℝ) :
+    avgIntegrand α r m f x η y s = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (((XiE α r ζ η s).toReal : ℝ) : ℂ) := by
+  rw [avgIntegrand_eq α hα hr hm f x η y s]
+  simp_rw [XiR_eq_toReal α r]
+  rfl
+
+/-- Fubini/Tonelli rearrangement of the averages (paper, Lemma 3.3, texline~241–247):
+`avgR = (2π)^{-n} ∫ f̂(ζ) m(ζ) e^{i x ζ} K_R(ζ) dζ` with `K_R = 2ⁿ R^{-|α|} J_R`. -/
+theorem avgR_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x : Rn n) {R : ℝ}
+    (hR : 0 < R) :
+    avgR α r m f x R = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (KR α r ζ R : ℂ) := by
+  have hF : Integrable (Fint m (f : Rn n → ℂ) x) := integrable_Fint hm f x
+  have hB : volume (ballA α R) = ENNReal.ofReal (2 ^ n * R ^ absA α) := volume_ballA α hα hR.le
+  -- Step (a): the `s`-integral
+  have ha : ∀ η y : Rn n, ∫ s in (0 : ℝ)..1, avgIntegrand α r m f x η y s =
+      (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ζ, Fint m (f : Rn n → ℂ) x ζ *
+        (((∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s).toReal : ℝ) : ℂ) := by
+    intro η y
+    rw [intervalIntegral.integral_of_le zero_le_one]
+    simp_rw [avgIntegrand_eq' α hα hr hm f x η y]
+    rw [integral_const_mul]
+    congr 1
+    have hK : Integrable (Function.uncurry fun (s : ℝ) (ζ : Rn n) =>
+        Fint m (f : Rn n → ℂ) x ζ * (((XiE α r ζ η s).toReal : ℝ) : ℂ))
+        ((volume.restrict (Set.Ioc (0 : ℝ) 1)).prod volume) := by
+      have hbd : Integrable (fun q : ℝ × Rn n => (4 : ℝ) * ‖Fint m (f : Rn n → ℂ) x q.2‖)
+          ((volume.restrict (Set.Ioc (0 : ℝ) 1)).prod volume) :=
+        (integrable_const (4 : ℝ)).mul_prod hF.norm
+      refine hbd.mono' ?_ (Filter.Eventually.of_forall fun q => ?_)
+      · exact hF.aestronglyMeasurable.comp_snd.mul
+          (Complex.continuous_ofReal.comp_aestronglyMeasurable
+            ((measurable_XiE_gen α r measurable_snd measurable_const
+              measurable_fst).ennreal_toReal.aestronglyMeasurable))
+      · simp only [Function.uncurry, norm_mul, Complex.norm_real, Real.norm_eq_abs,
+          abs_of_nonneg ENNReal.toReal_nonneg]
+        have h4 : (XiE α r q.2 η q.1).toReal ≤ 4 := by
+          have := ENNReal.toReal_mono (by norm_num) (XiE_le_four α hα hr q.2 η q.1)
+          simpa using this
+        nlinarith [norm_nonneg (Fint m (f : Rn n → ℂ) x q.2),
+          ENNReal.toReal_nonneg (a := XiE α r q.2 η q.1)]
+    rw [integral_integral_swap hK]
+    refine integral_congr_ae (Filter.Eventually.of_forall fun ζ => ?_)
+    simp only
+    rw [integral_const_mul, integral_complex_ofReal, integral_toReal (f := fun s => XiE α r ζ η s)
+      (measurable_XiE_gen α r measurable_const measurable_const measurable_id).aemeasurable
+      (Filter.Eventually.of_forall fun s => (XiE_le_four α hα hr ζ η s).trans_lt (by norm_num))]
+  -- Step (b): the `y`-integral of a constant
+  have hb : ∀ η : Rn n, ∫ y in ballA α R, ∫ s in (0 : ℝ)..1, avgIntegrand α r m f x η y s =
+      ((2 ^ n * R ^ absA α : ℝ) : ℂ) * ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ζ, Fint m (f : Rn n → ℂ) x ζ *
+        (((∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s).toReal : ℝ) : ℂ)) := by
+    intro η
+    simp_rw [ha η]
+    rw [setIntegral_const, measureReal_def, hB, ENNReal.toReal_ofReal (by positivity),
+      Complex.real_smul]
+  -- Step (c): the `η`-integral
+  have hc : ∫ η in ballA α R, ∫ ζ, Fint m (f : Rn n → ℂ) x ζ *
+      (((∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s).toReal : ℝ) : ℂ) =
+      ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (((JR α r ζ R).toReal : ℝ) : ℂ) := by
+    have : IsFiniteMeasure (volume.restrict (ballA α R)) :=
+      ⟨by rw [Measure.restrict_apply_univ, hB]; exact ENNReal.ofReal_lt_top⟩
+    have hK : Integrable (Function.uncurry fun (η : Rn n) (ζ : Rn n) =>
+        Fint m (f : Rn n → ℂ) x ζ * (((∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r ζ η s).toReal : ℝ) : ℂ))
+        ((volume.restrict (ballA α R)).prod volume) := by
+      have hbd : Integrable (fun q : Rn n × Rn n => (4 : ℝ) * ‖Fint m (f : Rn n → ℂ) x q.2‖)
+          ((volume.restrict (ballA α R)).prod volume) :=
+        (integrable_const (4 : ℝ)).mul_prod hF.norm
+      refine hbd.mono' ?_ (Filter.Eventually.of_forall fun q => ?_)
+      · exact hF.aestronglyMeasurable.comp_snd.mul
+          (Complex.continuous_ofReal.comp_aestronglyMeasurable
+            ((measurable_lintegral_XiE_gen α r measurable_snd
+              measurable_fst).ennreal_toReal.aestronglyMeasurable))
+      · simp only [Function.uncurry, norm_mul, Complex.norm_real, Real.norm_eq_abs,
+          abs_of_nonneg ENNReal.toReal_nonneg]
+        have h4 : (∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r q.2 q.1 s).toReal ≤ 4 := by
+          have := ENNReal.toReal_mono (by norm_num) (lintegral_XiE_le α hα hr q.2 q.1)
+          simpa using this
+        nlinarith [norm_nonneg (Fint m (f : Rn n → ℂ) x q.2),
+          ENNReal.toReal_nonneg (a := ∫⁻ s in Set.Ioc (0 : ℝ) 1, XiE α r q.2 q.1 s)]
+    rw [integral_integral_swap hK]
+    refine integral_congr_ae (Filter.Eventually.of_forall fun ζ => ?_)
+    simp only
+    rw [integral_const_mul, integral_complex_ofReal, integral_toReal]
+    · rfl
+    · exact (measurable_lintegral_XiE_gen α r measurable_const measurable_id).aemeasurable
+    · exact Filter.Eventually.of_forall fun η =>
+        (lintegral_XiE_le α hα hr ζ η).trans_lt (by norm_num)
+  unfold avgR
+  simp_rw [hb]
+  rw [integral_const_mul, integral_const_mul, hc, ← integral_const_mul, ← integral_const_mul,
+    ← integral_const_mul, ← integral_const_mul]
+  congr 1
+  funext ζ
+  unfold KR
+  rw [ENNReal.toReal_mul, ENNReal.toReal_ofReal (by positivity)]
+  have hRR : R ^ (-(2 * absA α : ℝ)) * R ^ absA α = (R ^ absA α)⁻¹ := by
+    rw [← Real.rpow_natCast, ← Real.rpow_add hR, ← Real.rpow_neg hR.le]
+    congr 1; ring
+  calc _ = (((2 * π) ^ n)⁻¹ : ℂ) * Fint m (f : Rn n → ℂ) x ζ *
+        ((((R ^ (-(2 * absA α : ℝ)) * R ^ absA α) * 2 ^ n * (JR α r ζ R).toReal) : ℝ) : ℂ) := by
+        push_cast; ring
+    _ = _ := by rw [hRR]; push_cast; ring
+
+theorem nontrivial_of_ne_zero {r : Fin n → Fin 2} (hr : r ≠ 0) : Nontrivial (Rn n) := by
+  obtain ⟨j, -⟩ := exists_eq_one_of_ne_zero hr
+  refine ⟨⟨EuclideanSpace.single j 1, 0, fun h => ?_⟩⟩
+  have := congrArg (fun v : Rn n => v j) h
+  simp at this
+
+/-- **Lemma 3.3** (the averaging identity, paper, (3.5) and (3.8)): for `r ≠ 0`, `m ∈ 𝓜^{|α|+1}` and
+a Schwartz function `f`, the averages of (3.5) converge, and
+`𝐀^{r,m} f(x) = (2π)^{-n} ∫ θ_r(ξ) m(ξ) f̂(ξ) e^{i x ξ} dξ`, i.e. `𝐀^{r,m}` is the Fourier
+multiplier `θ_r m`, with `θ_r` independent of `m` (see `thetaR`). -/
+theorem tendsto_avgR (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x : Rn n) :
+    Filter.Tendsto (avgR α r m f x) Filter.atTop (nhds ((((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, thetaR α r ζ * m ζ * fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)))) := by
+  have := nontrivial_of_ne_zero hr
+  have hF : Integrable (Fint m (f : Rn n → ℂ) x) := integrable_Fint hm f x
+  have hlim : Filter.Tendsto (fun R => ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (KR α r ζ R : ℂ))
+      Filter.atTop (nhds (∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (thetaR α r ζ : ℂ))) := by
+    refine tendsto_integral_filter_of_dominated_convergence
+      (fun ζ => 4 * 4 ^ n * ‖Fint m (f : Rn n → ℂ) x ζ‖) ?_ ?_ ?_ ?_
+    · exact Filter.Eventually.of_forall fun R => hF.aestronglyMeasurable.mul
+        (Complex.continuous_ofReal.comp_aestronglyMeasurable (measurable_KR α r
+            R).aestronglyMeasurable)
+    · filter_upwards [Filter.eventually_gt_atTop 0] with R hR
+      refine Filter.Eventually.of_forall fun ζ => ?_
+      rw [norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (KR_nonneg α r ζ R),
+          mul_comm]
+      exact mul_le_mul_of_nonneg_right (KR_le α hα hr ζ hR) (norm_nonneg _)
+    · exact hF.norm.const_mul _
+    · have hae : ∀ᵐ ζ : Rn n, ζ ≠ 0 := by
+        rw [ae_iff]
+        simp
+      filter_upwards [hae] with ζ hζ
+      exact tendsto_const_nhds.mul (Complex.continuous_ofReal.continuousAt.tendsto.comp
+        (tendsto_KR α hα hr hζ))
+  have h2 := hlim.const_mul (((2 * π) ^ n)⁻¹ : ℂ)
+  have hval : ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (thetaR α r ζ : ℂ) =
+      ∫ ζ, thetaR α r ζ * m ζ * fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) := by
+    refine integral_congr_ae (Filter.Eventually.of_forall fun ζ => ?_)
+    simp only [Fint]
+    ring
+  rw [hval] at h2
+  refine h2.congr' ?_
+  filter_upwards [Filter.eventually_gt_atTop 0] with R hR
+  exact (avgR_eq α hα hr hm f x hR).symm
+
+/-- The averaged operator is the Fourier multiplier `θ_r m` (paper, Lemma 3.3). -/
+theorem avgOp_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x : Rn n) :
+    avgOp α r m f x = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, thetaR α r ζ * m ζ * fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) :=
+  (tendsto_avgR α hα hr hm f x).limUnder_eq
+
+/-! ### Lemma 3.3: properties of `θ_r` -/
+
+/-- `χ(w) = φ̂(w - 1/4)²` as a real function. -/
+def chiR (w : Rn n) : ℝ := phiR (w - quarterVec n) ^ 2
+
+theorem chiE_eq_ofReal (w : Rn n) : chiE w = ENNReal.ofReal (chiR w) := rfl
+
+theorem chiR_nonneg (w : Rn n) : 0 ≤ chiR w := sq_nonneg _
+
+theorem continuous_chiR : Continuous (chiR : Rn n → ℝ) :=
+  (continuous_phiR.comp (continuous_id.sub continuous_const)).pow 2
+
+theorem chiR_le_indicator (w : Rn n) : chiR w ≤ (chiBox n).indicator (fun _ => (1 : ℝ)) w := by
+  have h := chiE_le_indicator w
+  by_cases hw : w ∈ chiBox n
+  · rw [Set.indicator_of_mem hw] at h ⊢
+    rwa [chiE_eq_ofReal, ENNReal.ofReal_le_one] at h
+  · rw [Set.indicator_of_notMem hw] at h ⊢
+    rw [chiE_eq_ofReal, nonpos_iff_eq_zero, ENNReal.ofReal_eq_zero] at h
+    exact h
+
+theorem hasCompactSupport_chiR : HasCompactSupport (chiR : Rn n → ℝ) := by
+  have hK : IsCompact (chiBox n) := by
+    have : chiBox n = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+        Set.pi Set.univ fun _ => Set.Icc (1 / 4 - b0 / 2) (1 / 4 + b0 / 2) := by
+      ext w
+      constructor
+      · intro h
+        refine ⟨WithLp.ofLp w, fun i _ => ?_, by simp⟩
+        have := abs_le.mp (h i)
+        constructor <;> linarith [this.1, this.2]
+      · rintro ⟨v, hv, rfl⟩ i
+        have := hv i (Set.mem_univ i)
+        rw [abs_le]
+        constructor <;> simp <;> linarith [this.1, this.2]
+    rw [this]
+    exact (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+  refine HasCompactSupport.intro hK fun w hw => ?_
+  have := chiR_le_indicator w
+  rw [Set.indicator_of_notMem hw] at this
+  exact le_antisymm this (chiR_nonneg w)
+
+theorem contDiff_phiR : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (phiR : Rn n → ℝ) :=
+  Complex.reCLM.contDiff.comp contDiff_phiHat
+
+theorem contDiff_chiR : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (chiR : Rn n → ℝ) :=
+  (contDiff_phiR.comp (contDiff_id.sub contDiff_const)).pow 2
+
+/-- `g_r(y) = ∫ χ(w) 1_{Q_r}(w - y) dw`, so that `θ_r(ξ) = 4ⁿ ∫_ℝ g_r(δ_{2^v} ξ) dv`. -/
+def gQ (r : Fin n → Fin 2) (y : Rn n) : ℝ :=
+  ∫ w, chiR w * (boxQ r).indicator (fun _ => (1 : ℝ)) (w - y)
+
+theorem integrable_chiR_mul_indicator (r : Fin n → Fin 2) (y : Rn n) :
+    Integrable fun w : Rn n => chiR w * (boxQ r).indicator (fun _ => (1 : ℝ)) (w - y) := by
+  have hc : Integrable (chiR : Rn n → ℝ) :=
+    continuous_chiR.integrable_of_hasCompactSupport hasCompactSupport_chiR
+  refine hc.mono' ?_ (Filter.Eventually.of_forall fun w => ?_)
+  · exact hc.aestronglyMeasurable.mul (((measurable_const.indicator (measurableSet_boxQ r)).comp
+      (measurable_id.sub_const y)).aestronglyMeasurable)
+  · rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (chiR_nonneg w)]
+    calc chiR w * |(boxQ r).indicator (fun _ => (1 : ℝ)) (w - y)| ≤ chiR w * 1 := by
+          gcongr
+          · exact chiR_nonneg w
+          · by_cases h : w - y ∈ boxQ r
+            · simp [Set.indicator_of_mem h]
+            · simp [Set.indicator_of_notMem h]
+      _ = chiR w := mul_one _
+
+theorem gQ_nonneg (r : Fin n → Fin 2) (y : Rn n) : 0 ≤ gQ r y :=
+  integral_nonneg fun w => mul_nonneg (chiR_nonneg w)
+    (Set.indicator_nonneg (fun _ _ => zero_le_one) _)
+
+theorem lintegral_chiE_eq (r : Fin n → Fin 2) (y : Rn n) :
+    ∫⁻ w, chiE w * (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - y) = ENNReal.ofReal (gQ r y) := by
+  rw [gQ, ofReal_integral_eq_lintegral_ofReal (integrable_chiR_mul_indicator r y)
+    (Filter.Eventually.of_forall fun w => mul_nonneg (chiR_nonneg w)
+      (Set.indicator_nonneg (fun _ _ => zero_le_one) _))]
+  refine lintegral_congr fun w => ?_
+  rw [chiE_eq_ofReal, ENNReal.ofReal_mul (chiR_nonneg w)]
+  congr 1
+  by_cases h : w - y ∈ boxQ r
+  · simp [Set.indicator_of_mem h]
+  · simp [Set.indicator_of_notMem h]
+
+theorem ThetaE_eq_gQ (α : Fin n → ℕ) (r : Fin n → Fin 2) (ξ : Rn n) :
+    ThetaE α r ξ = ∫⁻ v : ℝ, ENNReal.ofReal (gQ r (dil α ((2 : ℝ) ^ v) ξ)) := by
+  unfold ThetaE
+  simp_rw [lintegral_chiE_eq]
+
+theorem isCompact_boxQ (r : Fin n → Fin 2) : IsCompact (boxQ r : Set (Rn n)) := by
+  have : (boxQ r : Set (Rn n)) = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun i => Set.Icc (((r i : ℕ) : ℝ) / 2) ((((r i : ℕ) : ℝ) + 1) / 2) := by
+    ext w
+    constructor
+    · intro h
+      exact ⟨WithLp.ofLp w, fun i _ => h i, by simp⟩
+    · rintro ⟨v, hv, rfl⟩ i
+      exact hv i (Set.mem_univ i)
+  rw [this]
+  exact (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+
+theorem gQ_eq_convolution (r : Fin n → Fin 2) : gQ r = fun y => convolution chiR
+    (fun z : Rn n => (boxQ r).indicator (fun _ => (1 : ℝ)) (-z))
+    (ContinuousLinearMap.lsmul ℝ ℝ) volume y := by
+  funext y
+  simp only [gQ, convolution, ContinuousLinearMap.lsmul_apply, smul_eq_mul, neg_sub]
+
+theorem locallyIntegrable_indicator_neg (r : Fin n → Fin 2) :
+    LocallyIntegrable (fun z : Rn n => (boxQ r).indicator (fun _ => (1 : ℝ)) (-z)) := by
+  have hset : MeasurableSet (Neg.neg ⁻¹' (boxQ r : Set (Rn n))) :=
+    measurable_neg (measurableSet_boxQ r)
+  have heq : (fun z : Rn n => (boxQ r).indicator (fun _ => (1 : ℝ)) (-z)) =
+      (Neg.neg ⁻¹' (boxQ r : Set (Rn n))).indicator (fun _ => 1) := by
+    funext z
+    by_cases h : -z ∈ boxQ r
+    · rw [Set.indicator_of_mem h, Set.indicator_of_mem (by exact h)]
+    · rw [Set.indicator_of_notMem h, Set.indicator_of_notMem (by exact h)]
+  rw [heq]
+  have hfin : volume (Neg.neg ⁻¹' (boxQ r : Set (Rn n))) < ⊤ := by
+    rw [Measure.measure_preimage_neg]
+    exact (isCompact_boxQ r).measure_lt_top
+  exact ((integrableOn_const hfin.ne enorm_ne_top).integrable_indicator hset).locallyIntegrable
+
+theorem continuous_gQ (r : Fin n → Fin 2) : Continuous (gQ r : Rn n → ℝ) := by
+  rw [gQ_eq_convolution]
+  exact hasCompactSupport_chiR.continuous_convolution_left _ continuous_chiR
+    (locallyIntegrable_indicator_neg r)
+
+/-- Homogeneity of `θ_r` (paper, Lemma 3.3, texline~263): `θ_r(δ_t ξ) = θ_r(ξ)` for `t > 0`. -/
+theorem thetaR_dil (α : Fin n → ℕ) (r : Fin n → Fin 2) (ξ : Rn n) {t : ℝ} (ht : 0 < t) :
+    thetaR α r (dil α t ξ) = thetaR α r ξ := by
+  unfold thetaR
+  congr 2
+  unfold ThetaE
+  have h : ∀ v : ℝ, dil α ((2 : ℝ) ^ v) (dil α t ξ) = dil α ((2 : ℝ) ^ (v + Real.logb 2 t)) ξ := by
+    intro v
+    rw [dil_dil, Real.rpow_add (by norm_num), Real.rpow_logb (by norm_num) (by norm_num) ht]
+  simp_rw [h]
+  exact lintegral_add_right_eq_self (fun v : ℝ => ∫⁻ w : Rn n, chiE w *
+    (boxQ r).indicator (fun _ => (1 : ℝ≥0∞)) (w - dil α ((2 : ℝ) ^ v) ξ)) (Real.logb 2 t)
+
+theorem contDiff_gQ (r : Fin n → Fin 2) : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (gQ r : Rn n → ℝ) := by
+  rw [gQ_eq_convolution]
+  exact hasCompactSupport_chiR.contDiff_convolution_left _ contDiff_chiR
+    (locallyIntegrable_indicator_neg r)
+
+/-- Support of `g_r`: if `g_r(y) ≠ 0` then `|yᵢ| ≤ 2` for all `i`, and `y_j ≤ -1/5` whenever
+`r_j = 1`. -/
+theorem gQ_support (r : Fin n → Fin 2) {y : Rn n} (hy : gQ r y ≠ 0) :
+    (∀ i, |y i| ≤ 2) ∧ (∀ j, r j = 1 → y j ≤ -1 / 5) := by
+  obtain ⟨w, hw⟩ : ∃ w, chiR w * (boxQ r).indicator (fun _ => (1 : ℝ)) (w - y) ≠ 0 := by
+    by_contra h
+    push Not at h
+    apply hy
+    simp [gQ, h]
+  have hχ : chiR w ≠ 0 := left_ne_zero_of_mul hw
+  have hQ : w - y ∈ boxQ r := by
+    by_contra hQ
+    rw [Set.indicator_of_notMem hQ, mul_zero] at hw
+    exact hw rfl
+  have hwb : w ∈ chiBox n := by
+    by_contra hwb
+    have := chiR_le_indicator w
+    rw [Set.indicator_of_notMem hwb] at this
+    exact hχ (le_antisymm this (chiR_nonneg w))
+  constructor
+  · intro i
+    have h1 := hQ i
+    have h2 := abs_le.mp (hwb i)
+    simp only [PiLp.sub_apply] at h1
+    have hri : ((r i : ℕ) : ℝ) ≤ 1 := by exact_mod_cast Nat.lt_succ_iff.mp (r i).2
+    have hri0 : (0 : ℝ) ≤ ((r i : ℕ) : ℝ) := Nat.cast_nonneg _
+    norm_num [b0] at h2
+    rw [abs_le]
+    constructor <;> linarith [h1.1, h1.2, h2.1, h2.2]
+  · intro j hj
+    have h1 := (hQ j).1
+    rw [hj] at h1
+    simp only [Fin.val_one, Nat.cast_one, PiLp.sub_apply] at h1
+    have h2 := abs_le.mp (hwb j)
+    norm_num [b0] at h2
+    linarith [h2.2]
+
+theorem contDiff_two_rpow : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (fun v : ℝ => (2 : ℝ) ^ v) := by
+  have : (fun v : ℝ => (2 : ℝ) ^ v) = fun v => Real.exp (Real.log 2 * v) := by
+    funext v; rw [Real.rpow_def_of_pos (by norm_num)]
+  rw [this]
+  exact Real.contDiff_exp.comp (contDiff_const.mul contDiff_id)
+
+theorem contDiff_dil_joint (α : Fin n → ℕ) :
+    ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (fun p : Rn n × ℝ => dil α ((2 : ℝ) ^ p.2) p.1) := by
+  have : (fun p : Rn n × ℝ => dil α ((2 : ℝ) ^ p.2) p.1) =
+      fun p => (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin n => ℝ)).symm
+        (fun i => ((2 : ℝ) ^ p.2) ^ α i * p.1 i) := by
+    funext p; rfl
+  rw [this]
+  refine (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin n => ℝ)).symm.contDiff.comp ?_
+  refine contDiff_pi.mpr fun i => ?_
+  exact ((contDiff_two_rpow.comp contDiff_snd).pow _).mul
+    ((EuclideanSpace.proj i : Rn n →L[ℝ] ℝ).contDiff.comp contDiff_fst)
+
+theorem thetaR_eq_integral (α : Fin n → ℕ) (r : Fin n → Fin 2) (ξ : Rn n) :
+    thetaR α r ξ = 4 ^ n * ∫ v : ℝ, gQ r (dil α ((2 : ℝ) ^ v) ξ) := by
+  unfold thetaR
+  rw [ThetaE_eq_gQ, integral_eq_lintegral_of_nonneg_ae
+    (Filter.Eventually.of_forall fun v => gQ_nonneg r _)]
+  exact ((continuous_gQ r).comp ((continuous_dil_param α ξ).comp
+    (Real.continuous_const_rpow (by norm_num)))).aestronglyMeasurable
+
+/-- Locally uniform compactness of the scale range: near `ξ₀ ≠ 0`, `g_r(δ_{2^v} ξ) ≠ 0` forces
+`v` into a fixed compact interval. -/
+theorem local_scale_range (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ξ₀ : Rn n} (hξ₀ : ξ₀ ≠ 0) :
+    ∃ ε > 0, ∃ a b : ℝ, ∀ ξ ∈ Metric.ball ξ₀ ε, ∀ v : ℝ,
+      gQ r (dil α ((2 : ℝ) ^ v) ξ) ≠ 0 → v ∈ Set.Icc a b := by
+  obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+  obtain ⟨i, hi⟩ : ∃ i, ξ₀ i ≠ 0 := by
+    by_contra h
+    push Not at h
+    exact hξ₀ (by ext i; simp [h i])
+  have hzi : 0 < |ξ₀ i| := abs_pos.mpr hi
+  set ε := |ξ₀ i| / 2
+  have hαi : (0 : ℝ) < α i := by have := hα i; positivity
+  have hαj : (0 : ℝ) < α j := by have := hα j; positivity
+  refine ⟨ε, by positivity, Real.logb 2 ((1 / (5 * (|ξ₀ j| + ε))) ^ ((α j : ℝ)⁻¹)),
+    Real.logb 2 ((4 / |ξ₀ i|) ^ ((α i : ℝ)⁻¹)), fun ξ hξ v hv => ?_⟩
+  have hsupp := gQ_support r hv
+  have hcoord : ∀ k, |ξ k - ξ₀ k| < ε := fun k =>
+    lt_of_le_of_lt (by simpa [Real.norm_eq_abs] using PiLp.norm_apply_le (ξ - ξ₀) k)
+      (by rwa [Metric.mem_ball, dist_eq_norm] at hξ)
+  have h2v : (0 : ℝ) < 2 ^ v := by positivity
+  constructor
+  · have hy := hsupp.2 j hj
+    simp only [dil_apply] at hy
+    have hξj : |ξ j| ≤ |ξ₀ j| + ε := by
+      have := hcoord j
+      calc |ξ j| = |(ξ j - ξ₀ j) + ξ₀ j| := by ring_nf
+        _ ≤ |ξ j - ξ₀ j| + |ξ₀ j| := abs_add_le _ _
+        _ ≤ _ := by linarith
+    have hpos : (0 : ℝ) < (2 ^ v) ^ α j := by positivity
+    have h1 : 1 / 5 ≤ (2 ^ v) ^ α j * |ξ j| := by
+      have : (2 ^ v) ^ α j * ξ j ≤ -1 / 5 := hy
+      have habs : -((2 ^ v) ^ α j * |ξ j|) ≤ (2 ^ v) ^ α j * ξ j := by
+        rw [← mul_neg]; exact mul_le_mul_of_nonneg_left (neg_abs_le _) hpos.le
+      linarith
+    have h2 : 1 / (5 * (|ξ₀ j| + ε)) ≤ (2 ^ v) ^ α j := by
+      rw [div_le_iff₀ (by positivity)]
+      nlinarith
+    have h3 : (1 / (5 * (|ξ₀ j| + ε))) ^ ((α j : ℝ)⁻¹) ≤ 2 ^ v := by
+      calc (1 / (5 * (|ξ₀ j| + ε))) ^ ((α j : ℝ)⁻¹) ≤ ((2 ^ v) ^ α j) ^ ((α j : ℝ)⁻¹) :=
+            Real.rpow_le_rpow (by positivity) h2 (by positivity)
+        _ = 2 ^ v := by
+            rw [← Real.rpow_natCast, ← Real.rpow_mul h2v.le, mul_inv_cancel₀ hαj.ne', Real.rpow_one]
+    have := Real.logb_le_logb_of_le (b := 2) (by norm_num) (by positivity) h3
+    rwa [Real.logb_rpow (by norm_num) (by norm_num)] at this
+  · have hy := hsupp.1 i
+    simp only [dil_apply] at hy
+    rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < (2 ^ v) ^ α i)] at hy
+    have hξi : |ξ₀ i| / 2 ≤ |ξ i| := by
+      have hc := hcoord i
+      have hεdef : ε = |ξ₀ i| / 2 := rfl
+      have htri : |ξ₀ i| ≤ |ξ₀ i - ξ i| + |ξ i| := by
+        calc |ξ₀ i| = |(ξ₀ i - ξ i) + ξ i| := by ring_nf
+          _ ≤ _ := abs_add_le _ _
+      rw [abs_sub_comm] at htri
+      linarith
+    have h1 : (2 ^ v) ^ α i ≤ 4 / |ξ₀ i| := by
+      rw [le_div_iff₀ hzi]
+      nlinarith [(by positivity : (0 : ℝ) ≤ (2 ^ v) ^ α i)]
+    have h2 : 2 ^ v ≤ (4 / |ξ₀ i|) ^ ((α i : ℝ)⁻¹) := by
+      calc (2 : ℝ) ^ v = ((2 ^ v) ^ α i) ^ ((α i : ℝ)⁻¹) := by
+            rw [← Real.rpow_natCast, ← Real.rpow_mul h2v.le, mul_inv_cancel₀ hαi.ne', Real.rpow_one]
+        _ ≤ _ := Real.rpow_le_rpow (by positivity) h1 (by positivity)
+    have := Real.logb_le_logb_of_le (b := 2) (by norm_num) h2v h2
+    rwa [Real.logb_rpow (by norm_num) (by norm_num)] at this
+
+/-- Smoothness of `θ_r` away from the origin (paper, Lemma 3.3, texline~216 and ~263). -/
+theorem contDiffAt_thetaR (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {ξ₀ : Rn n} (hξ₀ : ξ₀ ≠ 0) :
+    ContDiffAt ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (thetaR α r) ξ₀ := by
+  obtain ⟨ε, hε, a, b, hab⟩ := local_scale_range α hα hr hξ₀
+  -- a smooth cutoff in `v`, equal to `1` on `[a, b]`
+  set ψ : ContDiffBump ((a + b) / 2) :=
+    ⟨|b - a| / 2 + 1, |b - a| / 2 + 2, by positivity, by linarith⟩
+  set Φ : Rn n × ℝ → ℝ := fun p => ψ p.2 * gQ r (dil α ((2 : ℝ) ^ p.2) p.1)
+  have hΦ : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) Φ :=
+    (ψ.contDiff.comp contDiff_snd).mul ((contDiff_gQ r).comp (contDiff_dil_joint α))
+  have hK : IsCompact (Metric.closedBall ((a + b) / 2) (|b - a| / 2 + 2)) :=
+      isCompact_closedBall _ _
+  have hsupp : ∀ ξ v, v ∉ Metric.closedBall ((a + b) / 2) (|b - a| / 2 + 2) → Φ (ξ, v) = 0 := by
+    intro ξ v hv
+    have : ψ v = 0 := by
+      rw [← Function.notMem_support, ψ.support_eq]
+      exact fun h => hv (Metric.ball_subset_closedBall h)
+    simp [Φ, this]
+  have hsmooth := contDiff_integral_of_vanish hΦ hK hsupp
+  have heq : thetaR α r =ᶠ[nhds ξ₀] fun ξ => 4 ^ n * ∫ v, Φ (ξ, v) := by
+    filter_upwards [Metric.ball_mem_nhds ξ₀ hε] with ξ hξ
+    rw [thetaR_eq_integral]
+    congr 1
+    refine integral_congr_ae (Filter.Eventually.of_forall fun v => ?_)
+    simp only [Φ]
+    by_cases hv : gQ r (dil α ((2 : ℝ) ^ v) ξ) = 0
+    · rw [hv, mul_zero]
+    · have hvab := hab ξ hξ v hv
+      have : ψ v = 1 := by
+        apply ψ.one_of_mem_closedBall
+        rw [Metric.mem_closedBall, Real.dist_eq, abs_le]
+        have hrIn : ψ.rIn = |b - a| / 2 + 1 := rfl
+        rw [hrIn]
+        rcases abs_cases (b - a) with ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> rw [h1] <;>
+          constructor <;> linarith [hvab.1, hvab.2]
+      rw [this, one_mul]
+  exact (contDiff_const.mul hsmooth).contDiffAt.congr_of_eventuallyEq heq
+
+/-- Lower corners of the cubes generating the cones `Θ_r`: `-7/10` in the directions with
+`r_i = 1` and `-6/25` in the directions with `r_i = 0`; the cubes have side `12/25`. -/
+def coneLo (r : Fin n → Fin 2) : Rn n :=
+  WithLp.toLp 2 (fun i => if r i = 1 then -(7 / 10 : ℝ) else -(6 / 25 : ℝ))
+
+/-- The cube `B_r = [coneLo r, coneLo r + 12/25]` generating `Θ_r`. -/
+def coneCube (r : Fin n → Fin 2) : Set (Rn n) :=
+  rectIcc (coneLo r) (coneLo r + WithLp.toLp 2 (fun _ => (12 / 25 : ℝ)))
+
+/-- The anisotropic cone `Θ_r = {δ_t ξ : t > 0, ξ ∈ B_r}` (paper, Lemma 3.3, texline~266). -/
+def coneR (α : Fin n → ℕ) (r : Fin n → Fin 2) : Set (Rn n) :=
+  {ζ | ∃ t : ℝ, 0 < t ∧ ∃ ξ ∈ coneCube r, ζ = dil α t ξ}
+
+theorem mem_coneCube_iff (r : Fin n → Fin 2) (ξ : Rn n) :
+    ξ ∈ coneCube r ↔ ∀ i, (r i = 1 → -(7 / 10) ≤ ξ i ∧ ξ i ≤ -(11 / 50)) ∧
+      (r i = 0 → -(6 / 25) ≤ ξ i ∧ ξ i ≤ 6 / 25) := by
+  simp only [coneCube, rectIcc, coneLo, Set.mem_ofPred_eq, PiLp.add_apply, PiLp.toLp_apply]
+  refine forall_congr' fun i => ?_
+  have h01 : r i = 0 ∨ r i = 1 := by
+    rcases Fin.exists_fin_two.mp ⟨r i, rfl⟩ with h | h <;> simp [h]
+  rcases h01 with h | h
+  · simp only [h, zero_ne_one, ↓reduceIte, false_implies, true_and, forall_const]
+    constructor <;> rintro ⟨h1, h2⟩ <;> constructor <;> linarith
+  · simp only [h, ↓reduceIte, one_ne_zero, false_implies, and_true, forall_const]
+    constructor <;> rintro ⟨h1, h2⟩ <;> constructor <;> linarith
+
+theorem isCompact_coneCube (r : Fin n → Fin 2) : IsCompact (coneCube r : Set (Rn n)) := by
+  have : coneCube r = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun i => Set.Icc (coneLo r i) (coneLo r i + 12 / 25) := by
+    ext w
+    constructor
+    · intro h
+      exact ⟨WithLp.ofLp w, fun i _ => by simpa using h i, by simp⟩
+    · rintro ⟨v, hv, rfl⟩ i
+      simpa using hv i (Set.mem_univ i)
+  rw [this]
+  exact (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+
+theorem ne_zero_of_mem_coneCube {r : Fin n → Fin 2} (hr : r ≠ 0) {ξ : Rn n}
+    (hξ : ξ ∈ coneCube r) : ξ ≠ 0 := by
+  obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+  intro h0
+  have := ((mem_coneCube_iff r ξ).mp hξ j).1 hj
+  rw [h0] at this
+  simp at this
+  linarith [this.2]
+
+/-- `g_r > 0` on the cube `B_r`. -/
+theorem gQ_pos_of_mem_coneCube (r : Fin n → Fin 2) {ξ : Rn n} (hξ : ξ ∈ coneCube r) :
+    0 < gQ r ξ := by
+  have hmem := (mem_coneCube_iff r ξ).mp hξ
+  set L : Fin n → ℝ := fun i => max (1 / 4 - b1 / 2) (ξ i + ((r i : ℕ) : ℝ) / 2)
+  set U : Fin n → ℝ := fun i => min (1 / 4 + b1 / 2) (ξ i + (((r i : ℕ) : ℝ) + 1) / 2)
+  have hLU : ∀ i, L i < U i := by
+    intro i
+    have h01 : r i = 0 ∨ r i = 1 := by
+      rcases Fin.exists_fin_two.mp ⟨r i, rfl⟩ with h | h <;> simp [h]
+    simp only [L, U, max_lt_iff, lt_min_iff]
+    rcases h01 with h | h
+    · obtain ⟨h1, h2⟩ := (hmem i).2 h
+      simp only [h, Fin.val_zero, Nat.cast_zero]
+      refine ⟨⟨?_, ?_⟩, ?_, ?_⟩ <;> norm_num [b1] <;> linarith
+    · obtain ⟨h1, h2⟩ := (hmem i).1 h
+      simp only [h, Fin.val_one, Nat.cast_one]
+      refine ⟨⟨?_, ?_⟩, ?_, ?_⟩ <;> norm_num [b1] <;> linarith
+  set S : Set (Rn n) := {w | ∀ i, L i < w i ∧ w i < U i}
+  have hSopen : IsOpen S := by
+    have : S = ⋂ i, {w : Rn n | L i < w i ∧ w i < U i} := by ext w; simp [S]
+    rw [this]
+    refine isOpen_iInter_of_finite fun i => ?_
+    have hc : Continuous fun w : Rn n => w i := (continuous_apply i).comp (PiLp.continuous_ofLp 2 _)
+    exact (isOpen_lt continuous_const hc).inter (isOpen_lt hc continuous_const)
+  have hSne : S.Nonempty := ⟨WithLp.toLp 2 (fun i => (L i + U i) / 2), fun i => by
+    simp only; constructor <;> linarith [hLU i]⟩
+  have hSpos : 0 < volume S := hSopen.measure_pos volume hSne
+  have hint := integrable_chiR_mul_indicator r ξ
+  have hnn : 0 ≤ fun w : Rn n => chiR w * (boxQ r).indicator (fun _ => (1 : ℝ)) (w - ξ) :=
+    fun w => mul_nonneg (chiR_nonneg w) (Set.indicator_nonneg (fun _ _ => zero_le_one) _)
+  rw [gQ, integral_pos_iff_support_of_nonneg hnn hint]
+  refine lt_of_lt_of_le hSpos (measure_mono fun w hw => ?_)
+  rw [Function.mem_support]
+  have hQ : w - ξ ∈ boxQ r := by
+    intro i
+    simp only [PiLp.sub_apply]
+    have := hw i
+    simp only [L, U, max_lt_iff, lt_min_iff] at this
+    constructor <;> linarith [this.1.2, this.2.2]
+  have hχ : chiR w = 1 := by
+    have h1 : phiHat (w - quarterVec n) = 1 := by
+      apply phiHat_eq_one
+      intro i
+      have := hw i
+      simp only [L, U, max_lt_iff, lt_min_iff] at this
+      simp only [PiLp.sub_apply, quarterVec]
+      rw [abs_le]
+      constructor <;> linarith [this.1.1, this.2.1]
+    have : phiR (w - quarterVec n) = 1 := by
+      rw [phiR, h1, Complex.one_re]
+    simp [chiR, this]
+  rw [Set.indicator_of_mem hQ, hχ]
+  norm_num
+
+/-- `θ_r > 0` on the cube `B_r`. -/
+theorem thetaR_pos_of_mem_coneCube (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) {ξ : Rn n} (hξ : ξ ∈ coneCube r) : 0 < thetaR α r ξ := by
+  have hξ0 := ne_zero_of_mem_coneCube hr hξ
+  rw [thetaR_eq_integral]
+  refine mul_pos (by positivity) ?_
+  set G : ℝ → ℝ := fun v => gQ r (dil α ((2 : ℝ) ^ v) ξ)
+  have hGc : Continuous G := (continuous_gQ r).comp ((continuous_dil_param α ξ).comp
+    (Real.continuous_const_rpow (by norm_num)))
+  obtain ⟨ε, hε, a, b, hab⟩ := local_scale_range α hα hr hξ0
+  have hGsupp : HasCompactSupport G := HasCompactSupport.intro isCompact_Icc fun v hv => by
+    by_contra h
+    exact hv (hab ξ (Metric.mem_ball_self hε) v h)
+  have hGint : Integrable G := hGc.integrable_of_hasCompactSupport hGsupp
+  have hnn : 0 ≤ G := fun v => gQ_nonneg r _
+  rw [integral_pos_iff_support_of_nonneg hnn hGint]
+  have h0 : G 0 ≠ 0 := by
+    simp only [G, Real.rpow_zero, dil_one]
+    exact (gQ_pos_of_mem_coneCube r hξ).ne'
+  have hopen : IsOpen (Function.support G) := hGc.isOpen_support
+  exact hopen.measure_pos volume ⟨0, h0⟩
+
+/-- A uniform positive lower bound for `θ_r` on `B_r`, by compactness. -/
+theorem exists_thetaR_lower (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) : ∃ ε > 0, ∀ ξ ∈ coneCube r, ε ≤ thetaR α r ξ := by
+  have hne : (coneCube r : Set (Rn n)).Nonempty :=
+    ⟨coneLo r, fun i => by simp [coneLo]; norm_num⟩
+  have hcont : ContinuousOn (thetaR α r) (coneCube r) := fun ξ hξ =>
+    (contDiffAt_thetaR α hα hr (ne_zero_of_mem_coneCube hr hξ)).continuousAt.continuousWithinAt
+  obtain ⟨ξm, hξm, hmin⟩ := (isCompact_coneCube r).exists_isMinOn hne hcont
+  exact ⟨thetaR α r ξm, thetaR_pos_of_mem_coneCube α hα hr hξm, fun ξ hξ => hmin hξ⟩
+
+theorem isAnisoCone_coneR (α : Fin n → ℕ) {r : Fin n → Fin 2} (hr : r ≠ 0) :
+    IsAnisoCone α (coneR α r) := by
+  refine ⟨fun h => ?_, coneLo r, 12 / 25, by norm_num, rfl⟩
+  have h0 : (0 : Rn n) ∈ coneR α r := h ▸ Set.mem_univ _
+  obtain ⟨t, ht, ξ, hξ, h0'⟩ := h0
+  have : ξ = 0 := by
+    have := congrArg (dil α t⁻¹) h0'
+    rwa [dil_zero, dil_dil, inv_mul_cancel₀ ht.ne', dil_one, eq_comm] at this
+  exact ne_zero_of_mem_coneCube hr hξ this
+
+theorem rho_pos_of_ne_zero (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ζ : Rn n} (hζ : ζ ≠ 0) :
+    0 < rho α ζ := by
+  rcases (rho_nonneg α ζ).lt_or_eq with h | h
+  · exact h
+  · exfalso
+    apply hζ
+    ext i
+    have h1 := abs_coord_rpow_le_rho α ζ i
+    rw [← h] at h1
+    have hq : 0 < (α i : ℝ)⁻¹ := by have := hα i; positivity
+    have h2 : |ζ i| ^ ((α i : ℝ)⁻¹) = 0 := le_antisymm h1 (by positivity)
+    rw [Real.rpow_eq_zero (abs_nonneg _) hq.ne'] at h2
+    simpa using h2
+
+theorem abs_coord_le_one_of_rho (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ξ : Rn n}
+    (hξ : rho α ξ = 1) (i : Fin n) : |ξ i| ≤ 1 := by
+  have h1 := abs_coord_rpow_le_rho α ξ i
+  rw [hξ] at h1
+  have hq : 0 < (α i : ℝ)⁻¹ := by have := hα i; positivity
+  by_contra h
+  push Not at h
+  have := Real.one_lt_rpow h hq
+  linarith
+
+/-- Covering of a dilation-invariant neighbourhood of the closed negative quadrant by the cones
+`Θ_r`, `r ≠ 0` (paper, Lemma 3.3, (3.6), interpreted as a dilation-invariant covering). -/
+theorem cone_covering (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ζ : Rn n} (hζ : ζ ≠ 0)
+    (hq : ∀ i, ζ i ≤ (1 / 8) * rho α ζ ^ α i) : ∃ r : Fin n → Fin 2, r ≠ 0 ∧ ζ ∈ coneR α r := by
+  set ρ0 := rho α ζ
+  have hρ0 : 0 < ρ0 := rho_pos_of_ne_zero α hα hζ
+  set ξ' := dil α ρ0⁻¹ ζ
+  have hξ'ρ : rho α ξ' = 1 := by rw [rho_dil α hα (inv_pos.mpr hρ0)]; exact inv_mul_cancel₀ hρ0.ne'
+  have hξ'le : ∀ i, ξ' i ≤ 1 / 8 := by
+    intro i
+    simp only [ξ', dil_apply]
+    have := hq i
+    have hp : 0 < ρ0⁻¹ ^ α i := by positivity
+    calc ρ0⁻¹ ^ α i * ζ i ≤ ρ0⁻¹ ^ α i * ((1 / 8) * ρ0 ^ α i) := by gcongr
+      _ = 1 / 8 := by rw [inv_pow]; field_simp
+  have hξ'abs := abs_coord_le_one_of_rho α hα hξ'ρ
+  obtain ⟨j, hj⟩ := exists_coord_eq_rho α hα (by rw [hξ'ρ]; norm_num : (0 : ℝ) < rho α ξ')
+  rw [hξ'ρ, one_pow] at hj
+  have hξ'j : ξ' j = -1 := by
+    rcases abs_eq (zero_le_one' ℝ) |>.mp hj with h | h
+    · have := hξ'le j; rw [h] at this; norm_num at this
+    · exact h
+  have hne : (Finset.univ : Finset (Fin n)).Nonempty := ⟨j, Finset.mem_univ j⟩
+  set f : ℝ → ℝ := fun l => Finset.univ.inf' hne fun i => l ^ α i * ξ' i
+  have hfc : Continuous f :=
+    Continuous.finset_inf'_apply hne fun i _ => (continuous_pow _).mul continuous_const
+  have hf0 : f 0 = 0 := by
+    simp only [f]
+    have : ∀ i, (0 : ℝ) ^ α i * ξ' i = 0 := fun i => by
+      rw [zero_pow (by have := hα i; omega), zero_mul]
+    simp [this]
+  have hf1 : f 1 ≤ -1 := by
+    have := Finset.inf'_le (fun i => (1 : ℝ) ^ α i * ξ' i) (Finset.mem_univ j)
+    simp only [one_pow, one_mul] at this
+    simp only [f, one_pow, one_mul]
+    rw [← hξ'j]; exact this
+  obtain ⟨l, hl, hfl⟩ : ∃ l ∈ Set.Icc (0 : ℝ) 1, f l = -1 / 2 := by
+    have := intermediate_value_Icc' (zero_le_one' ℝ) hfc.continuousOn
+    exact this ⟨by linarith, by rw [hf0]; norm_num⟩
+  have hl0 : 0 < l := by
+    rcases hl.1.lt_or_eq with h | h
+    · exact h
+    · rw [← h, hf0] at hfl; norm_num at hfl
+  set η := dil α l ξ'
+  have hηge : ∀ i, -1 / 2 ≤ η i := by
+    intro i
+    rw [← hfl]
+    exact Finset.inf'_le (fun i => l ^ α i * ξ' i) (Finset.mem_univ i)
+  have hηle : ∀ i, η i ≤ 1 / 8 := by
+    intro i
+    simp only [η, dil_apply]
+    have hp : 0 ≤ l ^ α i := by positivity
+    have hp1 : l ^ α i ≤ 1 := pow_le_one₀ hl0.le hl.2
+    calc l ^ α i * ξ' i ≤ l ^ α i * (1 / 8) := by gcongr; exact hξ'le i
+      _ ≤ 1 * (1 / 8) := by gcongr
+      _ = 1 / 8 := one_mul _
+  obtain ⟨i1, -, hi1⟩ := Finset.exists_mem_eq_inf' hne fun i => l ^ α i * ξ' i
+  have hηi1 : η i1 = -1 / 2 := by
+    simp only [η, dil_apply]; rw [← hi1]; exact hfl
+  set r : Fin n → Fin 2 := fun i => if η i < -(23 / 100) then 1 else 0
+  have hr : r ≠ 0 := by
+    intro h
+    have := congrFun h i1
+    simp only [r, hηi1, Pi.zero_apply] at this
+    norm_num at this
+  refine ⟨r, hr, ρ0 / l, by positivity, η, ?_, ?_⟩
+  · rw [mem_coneCube_iff]
+    intro i
+    constructor
+    · intro hri
+      have : η i < -(23 / 100) := by
+        by_contra hc
+        simp only [r, hc, ↓reduceIte] at hri
+        exact zero_ne_one hri
+      constructor <;> linarith [hηge i]
+    · intro hri
+      have : ¬ η i < -(23 / 100) := by
+        intro hc
+        simp only [r, hc, ↓reduceIte] at hri
+        exact one_ne_zero hri
+      push Not at this
+      constructor <;> linarith [hηle i]
+  · simp only [η, ξ', dil_dil]
+    rw [show ρ0 / l * (l * ρ0⁻¹) = 1 by field_simp, dil_one]
+
+/-- **Lemma 3.3, cone part** (paper, texline~216–221): there are `ε₀ > 0` and anisotropic cones
+`Θ_r` (`r ≠ 0`) with `θ_r > ε₀` on `Θ_r`, covering the dilation-invariant neighbourhood
+`{ξ ≠ 0 : ξᵢ ≤ ε₀ ρ(ξ)^{αᵢ}}` of the closed negative quadrant ((3.6), intended reading). -/
+theorem lemma_3_3_cones (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    ∃ ε₀ > 0, (∀ r : Fin n → Fin 2, r ≠ 0 → IsAnisoCone α (coneR α r) ∧
+        ∀ ζ ∈ coneR α r, ε₀ < thetaR α r ζ) ∧
+      ∀ ζ : Rn n, ζ ≠ 0 → (∀ i, ζ i ≤ ε₀ * rho α ζ ^ α i) →
+        ∃ r : Fin n → Fin 2, r ≠ 0 ∧ ζ ∈ coneR α r := by
+  have hlow : ∀ r : Fin n → Fin 2, ∃ e > 0, r ≠ 0 → ∀ ξ ∈ coneCube r, 2 * e ≤ thetaR α r ξ := by
+    intro r
+    by_cases hr : r = 0
+    · exact ⟨1, one_pos, fun h => absurd hr h⟩
+    · obtain ⟨ε, hε, h⟩ := exists_thetaR_lower α hα hr
+      exact ⟨ε / 2, by positivity, fun _ ξ hξ => by linarith [h ξ hξ]⟩
+  choose e he hle using hlow
+  have hne : (Finset.univ : Finset (Fin n → Fin 2)).Nonempty := ⟨0, Finset.mem_univ _⟩
+  set e0 := Finset.univ.inf' hne e
+  have he0 : 0 < e0 := (Finset.lt_inf'_iff hne).mpr fun r _ => he r
+  refine ⟨min (1 / 8) e0, by positivity, fun r hr => ⟨isAnisoCone_coneR α hr, ?_⟩, ?_⟩
+  · rintro ζ ⟨t, ht, ξ, hξ, rfl⟩
+    rw [thetaR_dil α r ξ ht]
+    have h1 := hle r hr ξ hξ
+    have h2 : e0 ≤ e r := Finset.inf'_le e (Finset.mem_univ r)
+    have h3 : min (1 / 8) e0 ≤ e0 := min_le_right _ _
+    linarith [he r]
+  · intro ζ hζ hq
+    apply cone_covering α hα hζ
+    intro i
+    refine (hq i).trans ?_
+    gcongr
+    · exact pow_nonneg (rho_nonneg α ζ) _
+    · exact min_le_left _ _
+
+/-! ### Half-open versus closed semi-tiles in the averaged operator -/
+
+/-- The dyadic grid hyperplanes `{ξ : ξᵢ ∈ 2^{-kαᵢ} ℤ / 2}`, off which closed and half-open
+semi-tiles agree. -/
+def gridBd (α : Fin n → ℕ) : Set (Rn n) :=
+  {ξ | ∃ (k : ℤ) (i : Fin n) (z : ℤ), ξ i = side α (-k) i * ((z : ℝ) / 2)}
+
+theorem mem_semi_iff_mem_semiHO (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) {N : Rn n}
+    (hN : N ∉ gridBd α) : N ∈ P.semi α r ↔ N ∈ P.semiHO α r := by
+  refine ⟨fun h i => ⟨(h i).1, lt_of_le_of_ne (h i).2 fun heq => hN ?_⟩,
+    fun h => P.semiHO_subset_semi α r h⟩
+  refine ⟨P.k, i, 2 * P.u i + (r i : ℤ) + 1, ?_⟩
+  rw [heq]
+  push_cast
+  ring
+
+theorem indicator_semi_eq_semiHO (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) {N : Rn n}
+    (hN : N ∉ gridBd α) : (P.semi α r).indicator (fun _ => (1 : ℂ)) N =
+      (P.semiHO α r).indicator (fun _ => (1 : ℂ)) N := by
+  by_cases h : N ∈ P.semi α r
+  · rw [Set.indicator_of_mem h, Set.indicator_of_mem ((mem_semi_iff_mem_semiHO α P r hN).mp h)]
+  · rw [Set.indicator_of_notMem h, Set.indicator_of_notMem
+      (fun h' => h ((mem_semi_iff_mem_semiHO α P r hN).mpr h'))]
+
+theorem modelOp_eq_modelOpHO (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) {N : Rn n}
+    (hN : N ∉ gridBd α) (f : Rn n → ℂ) : modelOp α r m N f = modelOpHO α r m N f := by
+  ext x
+  unfold modelOp modelOpHO
+  congr 1; ext P
+  rw [indicator_semi_eq_semiHO α P r hN]
+
+/-- For `η` with nonzero coordinates, `δ_{2^{-s}} η` lies on the grid hyperplanes only for
+countably many `s`. -/
+theorem countable_bad_scales (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {η : Rn n}
+    (hη : ∀ i, η i ≠ 0) : {s : ℝ | dil α ((2 : ℝ) ^ (-s)) η ∈ gridBd α}.Countable := by
+  have hsub : {s : ℝ | dil α ((2 : ℝ) ^ (-s)) η ∈ gridBd α} ⊆
+      ⋃ (k : ℤ) (i : Fin n) (z : ℤ), {s : ℝ | ((2 : ℝ) ^ (-s)) ^ α i * η i =
+        side α (-k) i * ((z : ℝ) / 2)} := by
+    rintro s ⟨k, i, z, h⟩
+    simp only [Set.mem_iUnion]
+    exact ⟨k, i, z, by simpa [dil_apply] using h⟩
+  refine Set.Countable.mono hsub (Set.countable_iUnion fun k => Set.countable_iUnion fun i =>
+    Set.countable_iUnion fun z => (Set.Subsingleton.countable ?_))
+  intro s hs s' hs'
+  simp only [Set.mem_ofPred_eq] at hs hs'
+  have h1 : ((2 : ℝ) ^ (-s)) ^ α i = ((2 : ℝ) ^ (-s')) ^ α i := by
+    have := hs.trans hs'.symm
+    exact mul_right_cancel₀ (hη i) this
+  rw [← Real.rpow_natCast, ← Real.rpow_natCast, ← Real.rpow_mul (by norm_num),
+    ← Real.rpow_mul (by norm_num)] at h1
+  have hai : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+  have h2 := congrArg (Real.logb 2) h1
+  rw [Real.logb_rpow (by norm_num) (by norm_num), Real.logb_rpow (by norm_num) (by norm_num)] at h2
+  have := mul_right_cancel₀ hai h2
+  linarith
+
+theorem volume_coord_eq (i : Fin n) (c : ℝ) : volume {η : Rn n | η i = c} = 0 := by
+  have hset : {η : Rn n | η i = c} = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹'
+      Set.pi Set.univ (Function.update (fun _ => Set.univ) i {c}) := by
+    ext η
+    simp only [Set.mem_ofPred_eq, Set.mem_preimage, Set.mem_pi, Set.mem_univ, true_implies]
+    constructor
+    · intro h j
+      by_cases hj : j = i
+      · subst hj; simp [h]
+      · simp [Function.update_of_ne hj]
+    · intro h
+      simpa using h i
+  rw [hset, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun j => by
+      by_cases hj : j = i
+      · subst hj; simp
+      · simp [Function.update_of_ne hj]).nullMeasurableSet, volume_pi_pi]
+  exact Finset.prod_eq_zero (Finset.mem_univ i) (by simp)
+
+/-- The averaging integrand with half-open semi-tiles. -/
+def avgIntegrandHO (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ)
+    (x η y : Rn n) (s : ℝ) : ℂ :=
+  modul (-η) (transl (-y) (dilOp α 2 ((2 : ℝ) ^ (-s))
+    (modelOpHO α r m (dil α ((2 : ℝ) ^ (-s)) η)
+      (dilOp α 2 ((2 : ℝ) ^ s) (transl y (modul η f)))))) x
+
+/-- The averages of (3.5) with half-open semi-tiles. -/
+def avgRHO (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ) (x : Rn n)
+    (R : ℝ) : ℂ :=
+  ((R ^ (-(2 * absA α : ℝ)) : ℝ) : ℂ) *
+    ∫ η in ballA α R, ∫ y in ballA α R, ∫ s in (0 : ℝ)..1, avgIntegrandHO α r m f x η y s
+
+/-- The averages with closed and with half-open semi-tiles coincide: the two model operators
+differ only when `δ_{2^{-s}} η` lies on a grid hyperplane, a null set of parameters. -/
+theorem avgR_eq_avgRHO (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (r : Fin n → Fin 2) (m : Rn n → ℂ)
+    (f : Rn n → ℂ) (x : Rn n) (R : ℝ) : avgR α r m f x R = avgRHO α r m f x R := by
+  unfold avgR avgRHO
+  congr 1
+  refine integral_congr_ae (ae_restrict_of_ae ?_)
+  have hae : ∀ᵐ η : Rn n ∂volume, ∀ i, η i ≠ 0 := by
+    rw [ae_all_iff]
+    intro i
+    rw [ae_iff]
+    simpa using volume_coord_eq (n := n) i 0
+  filter_upwards [hae] with η hη
+  refine integral_congr_ae (Filter.Eventually.of_forall fun y => ?_)
+  refine intervalIntegral.integral_congr_ae ?_
+  have hnull := (countable_bad_scales α hα hη).measure_zero volume
+  have : ∀ᵐ s : ℝ ∂volume, dil α ((2 : ℝ) ^ (-s)) η ∉ gridBd α :=
+    measure_eq_zero_iff_ae_notMem.mp hnull
+  filter_upwards [this] with s hs _
+  unfold avgIntegrand avgIntegrandHO
+  rw [modelOp_eq_modelOpHO α r m hs]
+
+/-- **Lemma 3.3** for the model operator with half-open semi-tiles. -/
+theorem tendsto_avgRHO (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) (x : Rn n) :
+    Filter.Tendsto (avgRHO α r m f x) Filter.atTop (nhds ((((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, thetaR α r ζ * m ζ * fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)))) := by
+  have h := tendsto_avgR α hα hr hm f x
+  have e : avgRHO α r m f x = avgR α r m f x := funext fun R => (avgR_eq_avgRHO α hα r m f x R).symm
+  rw [e]
+  exact h
+
+/-! ## Proof of Theorem 1.1 (paper, §3, texline~275–282) -/
+
+/-! ### Schwartz functions under modulation, translation and dilation -/
+
+/-- The dilation `δ_t` as a continuous linear equivalence. -/
+def dilCLE (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) : Rn n ≃L[ℝ] Rn n :=
+  (LinearEquiv.ofLinearMap (dilLin α t) (dilLin α t⁻¹)
+    (LinearMap.ext fun x => by
+      simp only [LinearMap.comp_apply, dilLin_apply, dil_dil, mul_inv_cancel₀ ht.ne', dil_one,
+        LinearMap.id_apply])
+    (LinearMap.ext fun x => by
+      simp only [LinearMap.comp_apply, dilLin_apply, dil_dil, inv_mul_cancel₀ ht.ne', dil_one,
+        LinearMap.id_apply])).toContinuousLinearEquiv
+
+@[simp]
+theorem dilCLE_apply (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (x : Rn n) :
+    dilCLE α ht x = dil α t x := dilLin_apply α t x
+
+theorem hasTemperateGrowth_char (η : Rn n) :
+    Function.HasTemperateGrowth fun x : Rn n => Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ)) := by
+  have h1 : Function.HasTemperateGrowth fun x : Rn n => ⟪x, η⟫_ℝ := by
+    have e : (fun x : Rn n => ⟪x, η⟫_ℝ) = ⇑(innerSL ℝ η) := by
+      funext x; simp [real_inner_comm]
+    rw [e]; exact (innerSL ℝ η).hasTemperateGrowth
+  have e : (fun x : Rn n => Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ))) =
+      (fun t : ℝ => Complex.exp (t * Complex.I)) ∘ fun x : Rn n => ⟪x, η⟫_ℝ := by
+    funext x; simp [Function.comp, mul_comm]
+  rw [e]
+  exact Complex.hasTemperateGrowth_exp_mul_I.comp h1
+
+/-- `M_η f` as a Schwartz function. -/
+def schwartzModul (η : Rn n) (f : 𝓢(Rn n, ℂ)) : 𝓢(Rn n, ℂ) :=
+  SchwartzMap.smulLeftCLM ℂ (fun x : Rn n => Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ))) f
+
+@[simp]
+theorem coe_schwartzModul (η : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    (schwartzModul η f : Rn n → ℂ) = modul η f := by
+  funext x
+  simp [schwartzModul, SchwartzMap.smulLeftCLM_apply_apply (hasTemperateGrowth_char η), modul]
+
+/-- `T_y f` as a Schwartz function. -/
+def schwartzTransl (y : Rn n) (f : 𝓢(Rn n, ℂ)) : 𝓢(Rn n, ℂ) :=
+  SchwartzMap.compSubConstCLM ℂ y f
+
+@[simp]
+theorem coe_schwartzTransl (y : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    (schwartzTransl y f : Rn n → ℂ) = transl y f := rfl
+
+/-- `D²_t f` as a Schwartz function. -/
+def schwartzDil (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (f : 𝓢(Rn n, ℂ)) : 𝓢(Rn n, ℂ) :=
+  (((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ)) •
+    SchwartzMap.compCLMOfContinuousLinearEquiv ℂ (dilCLE α (inv_pos.mpr ht)) f
+
+@[simp]
+theorem coe_schwartzDil (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (f : 𝓢(Rn n, ℂ)) :
+    (schwartzDil α ht f : Rn n → ℂ) = dilOp α 2 t f := by
+  funext x
+  simp [schwartzDil, dilOp]
+
+/-- The function `D²_t T_y M_η f` as a Schwartz function. -/
+def schwartzDTM (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    𝓢(Rn n, ℂ) :=
+  schwartzDil α ht (schwartzTransl y (schwartzModul η f))
+
+@[simp]
+theorem coe_schwartzDTM (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    (schwartzDTM α ht y η f : Rn n → ℂ) = dilOp α 2 t (transl y (modul η f)) := by
+  simp [schwartzDTM]
+
+/-! ### The averages and modulations -/
+
+theorem modul_modul (ξ ξ' : Rn n) (f : Rn n → ℂ) : modul ξ (modul ξ' f) = modul (ξ + ξ') f := by
+  funext x
+  simp only [modul, inner_add_right, Complex.ofReal_add, mul_add, Complex.exp_add]
+  ring
+
+theorem norm_modul (ξ : Rn n) (f : Rn n → ℂ) (x : Rn n) : ‖modul ξ f x‖ = ‖f x‖ := by
+  simp only [modul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, one_mul]
+
+/-- The norm of the averages is bounded by the average of the norms (no integrability needed). -/
+theorem enorm_avgR_le (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (f : Rn n → ℂ)
+    (x : Rn n) {R : ℝ} (hR : 0 < R) :
+    ‖avgR α r m f x R‖ₑ ≤ ENNReal.ofReal (R ^ (-(2 * absA α : ℝ))) *
+      ∫⁻ η in ballA α R, ∫⁻ y in ballA α R, ∫⁻ s in Set.Ioc (0 : ℝ) 1,
+        ‖avgIntegrand α r m f x η y s‖ₑ := by
+  unfold avgR
+  rw [enorm_mul, ← ofReal_norm, Complex.norm_real, Real.norm_of_nonneg (by positivity)]
+  gcongr
+  refine (enorm_integral_le_lintegral_enorm _).trans (lintegral_mono fun η => ?_)
+  refine (enorm_integral_le_lintegral_enorm _).trans (lintegral_mono fun y => ?_)
+  rw [intervalIntegral.integral_of_le zero_le_one]
+  exact enorm_integral_le_lintegral_enorm _
+
+/-- Shifting the modulation into the frequency parameter: the integrand for `M_{-N} f` at `η + N`
+has the same modulus as the conjugated model operator at frequency `δ_{2^{-s}}(η + N)` applied to
+`D²_{2^s} T_y M_η f`. -/
+theorem enorm_avgIntegrand_modul (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ)
+    (f : Rn n → ℂ) (N x η y : Rn n) (s : ℝ) :
+    ‖avgIntegrand α r m (modul (-N) f) x (η + N) y s‖ₑ =
+      ‖transl (-y) (dilOp α 2 ((2 : ℝ) ^ (-s)) (modelOp α r m (dil α ((2 : ℝ) ^ (-s)) (η + N))
+        (dilOp α 2 ((2 : ℝ) ^ s) (transl y (modul η f))))) x‖ₑ := by
+  unfold avgIntegrand
+  rw [modul_modul, show η + N + -N = η by abel, ← ofReal_norm, ← ofReal_norm, norm_modul]
+
+theorem finset_sup_ofReal {ι : Type*} {s : Finset ι} (hs : s.Nonempty) (a : ι → ℝ) :
+    s.sup (fun i => ENNReal.ofReal (a i)) = ENNReal.ofReal (s.sup' hs a) := by
+  apply le_antisymm
+  · exact Finset.sup_le fun i hi => ENNReal.ofReal_le_ofReal (Finset.le_sup' a hi)
+  · obtain ⟨i, hi, hmax⟩ := Finset.exists_mem_eq_sup' hs a
+    rw [hmax]
+    exact Finset.le_sup (f := fun i => ENNReal.ofReal (a i)) hi
+
+/-- Change of variables `z = δ_t(x + y)` in a set integral. -/
+theorem setLIntegral_comp_dil_add (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y : Rn n)
+    {E : Set (Rn n)} (hE : MeasurableSet E) (φ : Rn n → ℝ≥0∞) :
+    ∫⁻ x in E, φ (dil α t (x + y)) =
+      ENNReal.ofReal ((t ^ absA α)⁻¹) * ∫⁻ z in {z | dil α t⁻¹ z - y ∈ E}, φ z := by
+  have hE' : MeasurableSet {z : Rn n | dil α t⁻¹ z - y ∈ E} :=
+    hE.preimage ((continuous_dil α t⁻¹).measurable.sub_const y)
+  rw [← lintegral_indicator hE, ← lintegral_indicator hE']
+  have h1 : ∀ x, E.indicator (fun x => φ (dil α t (x + y))) x =
+      (fun w => {z | dil α t⁻¹ z - y ∈ E}.indicator φ (dil α t w)) (x + y) := by
+    intro x
+    have hmem : dil α t (x + y) ∈ {z | dil α t⁻¹ z - y ∈ E} ↔ x ∈ E := by
+      change dil α t⁻¹ (dil α t (x + y)) - y ∈ E ↔ x ∈ E
+      rw [dil_dil, inv_mul_cancel₀ ht.ne', dil_one, add_sub_cancel_right]
+    change E.indicator (fun x => φ (dil α t (x + y))) x =
+      {z | dil α t⁻¹ z - y ∈ E}.indicator φ (dil α t (x + y))
+    by_cases hx : x ∈ E
+    · rw [Set.indicator_of_mem hx, Set.indicator_of_mem (hmem.mpr hx)]
+    · rw [Set.indicator_of_notMem hx, Set.indicator_of_notMem (fun h => hx (hmem.mp h))]
+  simp_rw [h1]
+  rw [lintegral_add_right_eq_self (fun w => {z | dil α t⁻¹ z - y ∈ E}.indicator φ (dil α t w)) y,
+    lintegral_comp_dil α ht]
+
+theorem eLpNorm_modul (η : Rn n) {f : Rn n → ℂ} (hf : AEStronglyMeasurable f volume)
+    (p : ℝ≥0∞) : eLpNorm (modul η f) p volume = eLpNorm f p volume :=
+  eLpNorm_congr_norm_ae (((by fun_prop : Continuous fun x : Rn n =>
+    Complex.exp (Complex.I * (⟪x, η⟫_ℝ : ℂ))).aestronglyMeasurable).mul hf) hf
+    (Filter.Eventually.of_forall fun x => norm_modul η f x)
+
+theorem eLpNorm_transl (y : Rn n) {f : Rn n → ℂ} (hf : AEStronglyMeasurable f volume)
+    (p : ℝ≥0∞) : eLpNorm (transl y f) p volume = eLpNorm f p volume :=
+  eLpNorm_comp_measurePreserving (f := fun x : Rn n => x - y) hf
+    (measurePreserving_sub_right volume y)
+
+theorem eLpNorm_dilOp_two (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) {f : Rn n → ℂ}
+    (hf : Continuous f) : eLpNorm (dilOp α 2 t f) 2 volume = eLpNorm f 2 volume := by
+  have hti : 0 < t⁻¹ := inv_pos.mpr ht
+  have e : dilOp α 2 t f = ((((t ^ (-(absA α : ℝ) / 2) : ℝ)) : ℂ)) • (f ∘ dil α t⁻¹) := by
+    funext x; simp [dilOp]
+  rw [e, eLpNorm_const_smul, ← eLpNorm_map_measure hf.aestronglyMeasurable
+    (continuous_dil α t⁻¹).measurable.aemeasurable, map_dil_volume α hti,
+    eLpNorm_smul_measure_of_ne_top (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) _ _ hf.aestronglyMeasurable,
+    smul_eq_mul, ← mul_assoc]
+  convert one_mul _
+  rw [← ofReal_norm, Complex.norm_real, Real.norm_of_nonneg (by positivity),
+    ENNReal.ofReal_rpow_of_nonneg (by positivity) (by norm_num), ← ENNReal.ofReal_mul (by
+        positivity)]
+  rw [inv_pow, inv_inv]
+  have h12 : ((1 : ℝ≥0∞) / 2).toReal = 1 / 2 := by norm_num
+  rw [h12, ← Real.rpow_natCast, ← Real.rpow_mul ht.le, ← Real.rpow_add ht,
+    show -(absA α : ℝ) / 2 + (absA α : ℝ) * (1 / 2) = 0 by ring, Real.rpow_zero, ENNReal.ofReal_one]
+
+theorem eLpNorm_schwartzDTM (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (y η : Rn n) (f : 𝓢(Rn n, ℂ)) :
+    eLpNorm (schwartzDTM α ht y η f : Rn n → ℂ) 2 volume = eLpNorm (f : Rn n → ℂ) 2 volume := by
+  have h1 : Continuous (transl y (modul η (f : Rn n → ℂ))) := by
+    simpa using (schwartzTransl y (schwartzModul η f)).continuous
+  have h2 : Continuous (modul η (f : Rn n → ℂ)) := by
+    simpa using (schwartzModul η f).continuous
+  rw [coe_schwartzDTM, eLpNorm_dilOp_two α ht h1, eLpNorm_transl y h2.aestronglyMeasurable,
+    eLpNorm_modul η f.continuous.aestronglyMeasurable]
+
+theorem sup'_const_mul {ι : Type*} {s : Finset ι} (hs : s.Nonempty) (b : ι → ℝ) {c : ℝ}
+    (hc : 0 ≤ c) : s.sup' hs (fun i => c * b i) = c * s.sup' hs b := by
+  apply le_antisymm
+  · exact Finset.sup'_le hs _ fun i hi => mul_le_mul_of_nonneg_left (Finset.le_sup' b hi) hc
+  · obtain ⟨i, hi, hmax⟩ := Finset.exists_mem_eq_sup' hs b
+    rw [hmax]
+    exact Finset.le_sup' (fun i => c * b i) hi
+
+theorem measurable_finset_sup' {ι : Type*} {s : Finset ι} (hs : s.Nonempty) {b : ι → Rn n → ℝ}
+    (hb : ∀ i ∈ s, Measurable (b i)) : Measurable fun z => s.sup' hs fun i => b i z := by
+  have e : (fun z => s.sup' hs fun i => b i z) = s.sup' hs b :=
+    funext fun z => (Finset.sup'_apply hs b z).symm
+  rw [e]
+  exact Finset.measurable_sup' hs hb
+
+/-- **The conjugated model operators obey the bound of Theorem 3.2** (used in texline~279–281):
+    for a
+parameter `(η, y, s)` for which all frequencies `δ_{2^{-s}}(η + N)`, `N ∈ F`, avoid the grid
+hyperplanes, `∫_E max_{N∈F} |T_{-y} D²_{2^{-s}} A_{δ_{2^{-s}}(η+N)} D²_{2^s} T_y M_η f| ≤
+    C‖m‖|E|^{1/2}‖f‖₂`. -/
+theorem conj_modelOp_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : 𝓢(Rn n, ℂ)) (F : Finset (Rn n)),
+      F.Nonempty → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (η y : Rn n) (s : ℝ), (∀ N ∈ F, dil α ((2 : ℝ) ^ (-s)) (η + N) ∉ gridBd α) →
+      ∫⁻ x in E, F.sup (fun N => ‖transl (-y) (dilOp α 2 ((2 : ℝ) ^ (-s))
+        (modelOp α r m (dil α ((2 : ℝ) ^ (-s)) (η + N))
+          (dilOp α 2 ((2 : ℝ) ^ s) (transl y (modul η f))))) x‖ₑ) ≤
+        ENNReal.ofReal (C * (normM α ν m).toReal * Real.sqrt (volume E).toReal *
+          (eLpNorm (f : Rn n → ℂ) 2 volume).toReal) := by
+  classical
+  obtain ⟨C, hC, h32⟩ := thm_3_2 α hα hn hr ν hν
+  refine ⟨C, hC, fun m hm f F hF E hE hEfin η y s hgood => ?_⟩
+  have hm' : ClassM α (absA α + 1) m := hm.mono (by omega)
+  obtain ⟨C0, hC0, hbd⟩ := modelOpHO_summable_bound α hα hr
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  have hts : (2 : ℝ) ^ (-s) = ((2 : ℝ) ^ s)⁻¹ := Real.rpow_neg (by norm_num) s
+  have ht : 0 < (2 : ℝ) ^ s := by positivity
+  rw [hts]
+  simp only [hts] at hgood
+  generalize (2 : ℝ) ^ s = t at ht hgood ⊢
+  set g := schwartzDTM α ht y η f
+  have hg : (g : Rn n → ℂ) = dilOp α 2 t (transl y (modul η f)) := coe_schwartzDTM α ht y η f
+  set a : Rn n → Rn n := fun N => dil α t⁻¹ (η + N)
+  set u : ℝ := t ^ ((absA α : ℝ) / 2)
+  have hu : 0 < u := by positivity
+  have huu : u * u = t ^ absA α := by
+    rw [← Real.rpow_add ht, ← Real.rpow_natCast]; congr 1; ring
+  set H : Rn n → ℝ := fun z => F.sup' hF (fun N => ‖modelOpHO α r m (a N) g z‖)
+  -- the pointwise identity
+  have hpt : ∀ x, F.sup (fun N => ‖transl (-y) (dilOp α 2 t⁻¹
+      (modelOp α r m (dil α t⁻¹ (η + N))
+        (dilOp α 2 t (transl y (modul η f))))) x‖ₑ) =
+      ENNReal.ofReal (u * H (dil α t (x + y))) := by
+    intro x
+    have hterm : ∀ N ∈ F, ‖transl (-y) (dilOp α 2 t⁻¹
+        (modelOp α r m (dil α t⁻¹ (η + N))
+          (dilOp α 2 t (transl y (modul η f))))) x‖ₑ =
+        ENNReal.ofReal (u * ‖modelOpHO α r m (a N) g (dil α t (x + y))‖) := by
+      intro N hN
+      have hN' := hgood N hN
+      rw [← hg, modelOp_eq_modelOpHO α r m hN']
+      simp only [transl, dilOp, sub_neg_eq_add, inv_inv]
+      rw [enorm_mul, ← ofReal_norm, ← ofReal_norm, Complex.norm_real,
+        Real.norm_of_nonneg (by positivity), ← ENNReal.ofReal_mul (by positivity)]
+      congr 2
+      rw [Real.inv_rpow ht.le, ← Real.rpow_neg ht.le]
+      congr 1; ring
+    rw [Finset.sup_congr rfl hterm, finset_sup_ofReal hF, sup'_const_mul hF _ hu.le]
+  refine (lintegral_congr fun x => hpt x).trans_le ?_
+  -- change of variables
+  set E' := {z : Rn n | dil α t⁻¹ z - y ∈ E}
+  have hE' : MeasurableSet E' := hE.preimage ((continuous_dil α t⁻¹).measurable.sub_const y)
+  rw [setLIntegral_comp_dil_add α ht y hE (fun z => ENNReal.ofReal (u * H z))]
+  have hvol : volume E' = ENNReal.ofReal (t ^ absA α) * volume E := by
+    have h1 := setLIntegral_comp_dil_add α ht y hE (fun _ => 1)
+    simp only [setLIntegral_one] at h1
+    rw [h1, ← mul_assoc, ← ENNReal.ofReal_mul (by positivity), mul_inv_cancel₀ (by positivity),
+      ENNReal.ofReal_one, one_mul]
+  have hE'fin : volume E' < ⊤ := by
+    rw [hvol]; exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top hEfin
+  -- integrability of `H` on `E'`
+  have hmeasH : Measurable H := measurable_finset_sup' hF fun N _ =>
+    (measurable_Tlin α hα hr hm' g (measurable_const : Measurable fun _ : Rn n => a N)).norm
+  set Cb := C0 * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat (g : Rn n → ℂ) ξ‖
+  have hHb : ∀ z, ‖H z‖ ≤ Cb := by
+    intro z
+    have hH0 : 0 ≤ H z := by
+      obtain ⟨N, hN⟩ := hF
+      exact (norm_nonneg _).trans (Finset.le_sup' (fun N => ‖modelOpHO α r m (a N) g z‖) hN)
+    rw [Real.norm_of_nonneg hH0]
+    exact Finset.sup'_le hF _ fun N _ =>
+      (hbd m hm' g g.integrable (integrable_fhat_schwartz g) (a N) z).2
+  have hHint : IntegrableOn H E' volume := by
+    have : IsFiniteMeasure (volume.restrict E') :=
+      ⟨by rw [Measure.restrict_apply_univ]; exact hE'fin⟩
+    exact (integrable_const Cb).mono' hmeasH.aestronglyMeasurable
+      (Filter.Eventually.of_forall hHb)
+  have hH0 : ∀ z, 0 ≤ H z := fun z => by
+    obtain ⟨N, hN⟩ := hF
+    exact (norm_nonneg _).trans (Finset.le_sup' (fun N => ‖modelOpHO α r m (a N) g z‖) hN)
+  have hlin : ∫⁻ z in E', ENNReal.ofReal (u * H z) = ENNReal.ofReal (u * ∫ z in E', H z) := by
+    rw [← integral_const_mul, ofReal_integral_eq_lintegral_ofReal (hHint.const_mul u)
+      (Filter.Eventually.of_forall fun z => mul_nonneg hu.le (hH0 z))]
+  rw [hlin]
+  -- Theorem 3.2 on `E'`
+  have hF' : (F.image a).Nonempty := hF.image a
+  have hT := h32 m hm g (F.image a) hF' E' hE' hE'fin
+  have hsup : ∀ z, (F.image a).sup' hF' (fun N => ‖modelOpHO α r m N g z‖) = H z := by
+    intro z
+    rw [Finset.sup'_image]
+    rfl
+  simp_rw [hsup] at hT
+  rw [eLpNorm_schwartzDTM, hvol, ENNReal.toReal_mul, ENNReal.toReal_ofReal (by positivity)] at hT
+  rw [← ENNReal.ofReal_mul (by positivity)]
+  refine ENNReal.ofReal_le_ofReal ?_
+  have hsq : Real.sqrt (t ^ absA α * (volume E).toReal) = u * Real.sqrt (volume E).toReal := by
+    rw [Real.sqrt_mul (by positivity), ← huu, Real.sqrt_mul_self hu.le]
+  rw [hsq] at hT
+  have hti : (t ^ absA α)⁻¹ * u * u = 1 := by
+    rw [mul_assoc, huu, inv_mul_cancel₀ (by positivity)]
+  calc (t ^ absA α)⁻¹ * (u * ∫ z in E', H z)
+      ≤ (t ^ absA α)⁻¹ * (u * (C * Nm * (u * Real.sqrt (volume E).toReal) *
+          (eLpNorm (f : Rn n → ℂ) 2 volume).toReal)) := by gcongr
+    _ = ((t ^ absA α)⁻¹ * u * u) * (C * Nm * Real.sqrt (volume E).toReal *
+          (eLpNorm (f : Rn n → ℂ) 2 volume).toReal) := by ring
+    _ = _ := by rw [hti, one_mul]
+
+/-! ### Joint measurability of the averaging integrand -/
+
+theorem measurable_dil_scale (α : Fin n → ℕ) :
+    Measurable fun p : ℝ × Rn n => dil α ((2 : ℝ) ^ (-p.1)) p.2 :=
+  ((continuous_dil_joint α).comp (((Real.continuous_const_rpow (by norm_num)).comp
+    continuous_fst.neg).prodMk continuous_snd)).measurable
+
+theorem measurable_XiR (α : Fin n → ℕ) (r : Fin n → Fin 2) :
+    Measurable fun q : Rn n × Rn n × ℝ => XiR α r q.1 q.2.1 q.2.2 := by
+  unfold XiR
+  refine Measurable.tsum fun ku => ?_
+  have h1 : Measurable fun q : Rn n × Rn n × ℝ => dil α ((2 : ℝ) ^ (-q.2.2)) q.2.1 :=
+    (measurable_dil_scale α).comp (measurable_snd.snd.prodMk measurable_snd.fst)
+  have h2 : Measurable fun q : Rn n × Rn n × ℝ => dil α ((2 : ℝ) ^ (-q.2.2)) (q.1 + q.2.1) :=
+    (measurable_dil_scale α).comp (measurable_snd.snd.prodMk (measurable_fst.add
+        measurable_snd.fst))
+  exact ((measurable_const.indicator (measurable_semi_indicator α _ r)).comp h1).mul
+    (((continuous_PhiP α _).measurable.comp h2).pow_const 2)
+
+/-- The averaging integrand of a Schwartz function is jointly measurable in `(x, η, y, s)`
+(via the Fourier formula `Auto.avgIntegrand_eq`). -/
+theorem measurable_avgIntegrand (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) :
+    Measurable fun p : Rn n × Rn n × Rn n × ℝ =>
+      avgIntegrand α r m f p.1 p.2.1 p.2.2.1 p.2.2.2 := by
+  have e : (fun p : Rn n × Rn n × Rn n × ℝ => avgIntegrand α r m f p.1 p.2.1 p.2.2.1 p.2.2.2) =
+      fun p => (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ζ, fhat f ζ * m ζ *
+        Complex.exp (Complex.I * (⟪p.1, ζ⟫_ℝ : ℂ)) * XiR α r ζ p.2.1 p.2.2.2 :=
+    funext fun p => avgIntegrand_eq α hα hr hm f _ _ _ _
+  rw [e]
+  refine measurable_const.mul ?_
+  have hK : Measurable fun q : (Rn n × Rn n × Rn n × ℝ) × Rn n => fhat f q.2 * m q.2 *
+      Complex.exp (Complex.I * (⟪q.1.1, q.2⟫_ℝ : ℂ)) * XiR α r q.2 q.1.2.1 q.1.2.2.2 := by
+    refine ((((continuous_fhat_schwartz f).measurable.comp measurable_snd).mul
+      (hm.measurable.comp measurable_snd)).mul ?_).mul ?_
+    · exact (by fun_prop : Continuous fun q : (Rn n × Rn n × Rn n × ℝ) × Rn n =>
+        Complex.exp (Complex.I * (⟪q.1.1, q.2⟫_ℝ : ℂ))).measurable
+    · have hg : Measurable fun q : (Rn n × Rn n × Rn n × ℝ) × Rn n => (q.2, q.1.2.1, q.1.2.2.2) :=
+        measurable_snd.prodMk (measurable_fst.snd.fst.prodMk measurable_fst.snd.snd.snd)
+      simpa only [Function.comp_def] using (measurable_XiR α r).comp hg
+  exact hK.stronglyMeasurable.integral_prod_right'.measurable
+
+/-- Tonelli for four variables: moving the outermost integral innermost. -/
+theorem lintegral_swap4 {X Y Z W : Type*} [MeasurableSpace X] [MeasurableSpace Y]
+    [MeasurableSpace Z] [MeasurableSpace W] {μ₁ : Measure X} {μ₂ : Measure Y} {μ₃ : Measure Z}
+    {μ₄ : Measure W} [SFinite μ₁] [SFinite μ₂] [SFinite μ₃] [SFinite μ₄]
+    (G : X → Y → Z → W → ℝ≥0∞)
+    (hG : Measurable fun p : X × Y × Z × W => G p.1 p.2.1 p.2.2.1 p.2.2.2) :
+    ∫⁻ x, (∫⁻ η, (∫⁻ y, (∫⁻ s, G x η y s ∂μ₄) ∂μ₃) ∂μ₂) ∂μ₁ =
+      ∫⁻ η, (∫⁻ y, (∫⁻ s, (∫⁻ x, G x η y s ∂μ₁) ∂μ₄) ∂μ₃) ∂μ₂ := by
+  have m1 : Measurable (Function.uncurry fun x η => ∫⁻ y, (∫⁻ s, G x η y s ∂μ₄) ∂μ₃) := by
+    have h3 : Measurable fun q : ((X × Y) × Z) × W => G q.1.1.1 q.1.1.2 q.1.2 q.2 :=
+      hG.comp (measurable_fst.fst.fst.prodMk (measurable_fst.fst.snd.prodMk
+        (measurable_fst.snd.prodMk measurable_snd)))
+    exact h3.lintegral_prod_right'.lintegral_prod_right'
+  rw [lintegral_lintegral_swap m1.aemeasurable]
+  refine lintegral_congr fun η => ?_
+  have m2 : Measurable (Function.uncurry fun x y => ∫⁻ s, G x η y s ∂μ₄) :=
+    (hG.comp (measurable_fst.fst.prodMk (measurable_const.prodMk
+      (measurable_fst.snd.prodMk measurable_snd)))).lintegral_prod_right'
+  rw [lintegral_lintegral_swap m2.aemeasurable]
+  refine lintegral_congr fun y => ?_
+  have m3 : Measurable (Function.uncurry fun x s => G x η y s) :=
+    hG.comp (measurable_fst.prodMk (measurable_const.prodMk (measurable_const.prodMk
+      measurable_snd)))
+  exact lintegral_lintegral_swap m3.aemeasurable
+
+/-- For a.e. `η`, all shifted frequencies `η + N`, `N ∈ F`, have nonzero coordinates. -/
+theorem ae_shift_coord_ne_zero (F : Finset (Rn n)) :
+    ∀ᵐ η : Rn n ∂volume, ∀ N ∈ F, ∀ i, (η + N) i ≠ 0 := by
+  rw [Filter.eventually_all_finset]
+  intro N _
+  rw [ae_all_iff]
+  intro i
+  rw [ae_iff]
+  have : {η : Rn n | ¬ (η + N) i ≠ 0} = {η : Rn n | η i = -N i} := by
+    ext η
+    simp only [ne_eq, not_not, Set.mem_ofPred_eq, PiLp.add_apply]
+    constructor <;> intro h <;> linarith
+  rw [this]
+  exact volume_coord_eq i _
+
+/-- **Averaged form of Theorem 3.2** (texline~279–281): the averages `avgR` of the modulated
+functions `M_{-N} f`, maximized over a finite frequency set `F ⊆ 𝓑_c`, satisfy
+`∫_E max_N |avgR(M_{-N} f)| ≤ R^{-2|α|} |𝓑_{R+c}| |𝓑_R| C‖m‖|E|^{1/2}‖f‖₂`. -/
+theorem lintegral_sup_avgR_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : 𝓢(Rn n, ℂ)) (F : Finset (Rn n)),
+      F.Nonempty → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (R : ℝ), 0 < R → ∀ (c : ℝ), (∀ N ∈ F, rho α N ≤ c) →
+      ∫⁻ x in E, F.sup (fun N => ‖avgR α r m (modul (-N) f) x R‖ₑ) ≤
+        ENNReal.ofReal (R ^ (-(2 * absA α : ℝ))) * volume (ballA α (R + c)) *
+          volume (ballA α R) * ENNReal.ofReal (C * (normM α ν m).toReal *
+            Real.sqrt (volume E).toReal * (eLpNorm (f : Rn n → ℂ) 2 volume).toReal) := by
+  classical
+  obtain ⟨C, hC, hconj⟩ := conj_modelOp_le α hα hn hr ν hν
+  refine ⟨C, hC, fun m hm f F hF E hE hEfin R hR c hc => ?_⟩
+  have hm' : ClassM α (absA α + 1) m := hm.mono (by omega)
+  set K := ENNReal.ofReal (C * (normM α ν m).toReal * Real.sqrt (volume E).toReal *
+    (eLpNorm (f : Rn n → ℂ) 2 volume).toReal)
+  set G : Rn n → Rn n → Rn n → ℝ → ℝ≥0∞ := fun x η y s =>
+    F.sup fun N => ‖avgIntegrand α r m (modul (-N) f) x (η + N) y s‖ₑ
+  have hGm : Measurable fun p : Rn n × Rn n × Rn n × ℝ => G p.1 p.2.1 p.2.2.1 p.2.2.2 := by
+    have hN : ∀ N ∈ F, Measurable fun p : Rn n × Rn n × Rn n × ℝ =>
+        ‖avgIntegrand α r m (modul (-N) f) p.1 (p.2.1 + N) p.2.2.1 p.2.2.2‖ₑ := by
+      intro N _
+      have h := measurable_avgIntegrand α hα hr hm' (schwartzModul (-N) f)
+      rw [coe_schwartzModul] at h
+      exact (h.comp (measurable_fst.prodMk ((measurable_snd.fst.add_const N).prodMk
+        measurable_snd.snd))).enorm
+    have e : (fun p : Rn n × Rn n × Rn n × ℝ => G p.1 p.2.1 p.2.2.1 p.2.2.2) =
+        F.sup' hF (fun N p => ‖avgIntegrand α r m (modul (-N) f) p.1 (p.2.1 + N) p.2.2.1
+          p.2.2.2‖ₑ) := by
+      funext p
+      simp only [G]
+      rw [Finset.sup'_apply, Finset.sup'_eq_sup]
+    rw [e]
+    exact Finset.measurable_sup' hF hN
+  set c0 := ENNReal.ofReal (R ^ (-(2 * absA α : ℝ)))
+  set B' := ballA α (R + c)
+  set B := ballA α R
+  set I := Set.Ioc (0 : ℝ) 1
+  -- pointwise bound by the average of `G`
+  have hx : ∀ x, F.sup (fun N => ‖avgR α r m (modul (-N) f) x R‖ₑ) ≤
+      c0 * ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, G x η y s := by
+    intro x
+    refine Finset.sup_le fun N hN => (enorm_avgR_le α r m _ x hR).trans ?_
+    refine mul_le_mul' le_rfl ?_
+    rw [← lintegral_indicator (measurableSet_ballA α R),
+      ← lintegral_indicator (measurableSet_ballA α (R + c)),
+      ← lintegral_add_right_eq_self _ N]
+    refine lintegral_mono fun η => ?_
+    by_cases hη : η + N ∈ B
+    · have hη' : η ∈ B' := by
+        have h1 := rho_add_le α hα (η + N) (-N)
+        rw [add_neg_cancel_right, rho_neg] at h1
+        have h2 : rho α (η + N) ≤ R := hη
+        change rho α η ≤ R + c
+        linarith [hc N hN]
+      rw [Set.indicator_of_mem hη, Set.indicator_of_mem hη']
+      refine lintegral_mono fun y => lintegral_mono fun s => ?_
+      exact Finset.le_sup (f := fun N => ‖avgIntegrand α r m (modul (-N) f) x (η + N) y s‖ₑ) hN
+    · rw [Set.indicator_of_notMem hη]
+      exact bot_le
+  -- Tonelli
+  have hswap : ∫⁻ x in E, ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, G x η y s =
+      ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, ∫⁻ x in E, G x η y s := by
+    exact lintegral_swap4 G hGm
+  -- the bound for good parameters
+  have hgood : ∀ᵐ η ∂(volume.restrict B'), ∫⁻ y in B, ∫⁻ s in I, ∫⁻ x in E, G x η y s ≤
+      ∫⁻ y in B, ∫⁻ s in I, K := by
+    refine ae_restrict_of_ae ?_
+    filter_upwards [ae_shift_coord_ne_zero F] with η hη
+    refine lintegral_mono fun y => lintegral_mono_ae ?_
+    have hcount : {s : ℝ | ∃ N ∈ F, dil α ((2 : ℝ) ^ (-s)) (η + N) ∈ gridBd α}.Countable := by
+      have : {s : ℝ | ∃ N ∈ F, dil α ((2 : ℝ) ^ (-s)) (η + N) ∈ gridBd α} =
+          ⋃ N ∈ (F : Set (Rn n)), {s : ℝ | dil α ((2 : ℝ) ^ (-s)) (η + N) ∈ gridBd α} := by
+        ext s; simp
+      rw [this]
+      exact F.countable_toSet.biUnion fun N hN => countable_bad_scales α hα (hη N hN)
+    have hae : ∀ᵐ s : ℝ ∂volume, s ∉ {s : ℝ | ∃ N ∈ F, dil α ((2 : ℝ) ^ (-s)) (η + N) ∈ gridBd α} :=
+      measure_eq_zero_iff_ae_notMem.mp (hcount.measure_zero volume)
+    filter_upwards [ae_restrict_of_ae hae] with s hs
+    have hs' : ∀ N ∈ F, dil α ((2 : ℝ) ^ (-s)) (η + N) ∉ gridBd α := fun N hN h => hs ⟨N, hN, h⟩
+    have h := hconj m hm f F hF E hE hEfin η y s hs'
+    refine le_trans (le_of_eq ?_) h
+    refine lintegral_congr fun x => ?_
+    simp only [G]
+    exact Finset.sup_congr rfl fun N _ => enorm_avgIntegrand_modul α r m f N x η y s
+  calc ∫⁻ x in E, F.sup (fun N => ‖avgR α r m (modul (-N) f) x R‖ₑ)
+      ≤ ∫⁻ x in E, c0 * ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, G x η y s := lintegral_mono hx
+    _ = c0 * ∫⁻ x in E, ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, G x η y s :=
+        lintegral_const_mul' _ _ ENNReal.ofReal_ne_top
+    _ = c0 * ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, ∫⁻ x in E, G x η y s := by rw [hswap]
+    _ ≤ c0 * ∫⁻ η in B', ∫⁻ y in B, ∫⁻ s in I, K := mul_le_mul' le_rfl (lintegral_mono_ae hgood)
+    _ = _ := by
+        simp only [lintegral_const, Measure.restrict_apply_univ, I, Real.volume_Ioc, sub_zero,
+          ENNReal.ofReal_one]
+        ring
+
+theorem measurable_avgR (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (f : 𝓢(Rn n, ℂ)) {R : ℝ} (hR : 0 < R) :
+    Measurable fun x => avgR α r m f x R := by
+  have e : (fun x => avgR α r m f x R) = fun x => (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ζ, Fint m (f : Rn n → ℂ) x ζ * (KR α r ζ R : ℂ) :=
+    funext fun x => avgR_eq α hα hr hm f x hR
+  rw [e]
+  refine measurable_const.mul ?_
+  have hK : Measurable fun q : Rn n × Rn n => Fint m (f : Rn n → ℂ) q.1 q.2 * (KR α r q.2 R : ℂ)
+      := by
+    unfold Fint
+    refine ((((continuous_fhat_schwartz f).measurable.comp measurable_snd).mul
+      (hm.measurable.comp measurable_snd)).mul ?_).mul
+      (Complex.measurable_ofReal.comp ((measurable_KR α r R).comp measurable_snd))
+    exact (by fun_prop : Continuous fun q : Rn n × Rn n =>
+      Complex.exp (Complex.I * (⟪q.1, q.2⟫_ℝ : ℂ))).measurable
+  exact hK.stronglyMeasurable.integral_prod_right'.measurable
+
+theorem tendsto_ball_ratio (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {c : ℝ} (hc : 0 ≤ c) :
+    Filter.Tendsto (fun k : ℕ => ENNReal.ofReal (((k : ℝ) + 1) ^ (-(2 * absA α : ℝ))) *
+      volume (ballA α ((k : ℝ) + 1 + c)) * volume (ballA α ((k : ℝ) + 1)))
+      Filter.atTop (nhds (ENNReal.ofReal (4 ^ n))) := by
+  have e : ∀ k : ℕ, ENNReal.ofReal (((k : ℝ) + 1) ^ (-(2 * absA α : ℝ))) *
+      volume (ballA α ((k : ℝ) + 1 + c)) * volume (ballA α ((k : ℝ) + 1)) =
+      ENNReal.ofReal (4 ^ n * (1 + c / ((k : ℝ) + 1)) ^ absA α) := by
+    intro k
+    have hk : (0 : ℝ) < (k : ℝ) + 1 := by positivity
+    rw [volume_ballA α hα (by positivity), volume_ballA α hα hk.le,
+      ← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_mul (by positivity)]
+    congr 1
+    have hcast : (2 * absA α : ℝ) = ((2 * absA α : ℕ) : ℝ) := by push_cast; ring
+    rw [show (1 + c / ((k : ℝ) + 1)) = ((k : ℝ) + 1 + c) / ((k : ℝ) + 1) by field_simp,
+      div_pow, Real.rpow_neg hk.le, hcast, Real.rpow_natCast, pow_mul]
+    field_simp
+    have h4 : (4 : ℝ) ^ n = (2 ^ n) ^ 2 := by rw [← pow_mul, mul_comm, pow_mul]; norm_num
+    rw [h4, ← pow_mul ((k : ℝ) + 1) (absA α) 2, ← pow_mul ((k : ℝ) + 1) 2 (absA α),
+      mul_comm (absA α) 2]
+    ring
+  simp_rw [e]
+  refine ENNReal.tendsto_ofReal ?_
+  have h1 : Filter.Tendsto (fun k : ℕ => c / ((k : ℝ) + 1)) Filter.atTop (nhds 0) := by
+    have := tendsto_one_div_add_atTop_nhds_zero_nat.const_mul c
+    simp only [mul_zero] at this
+    refine this.congr fun k => ?_
+    rw [mul_one_div]
+  have h2 := ((h1.const_add 1).pow (absA α)).const_mul ((4 : ℝ) ^ n)
+  simpa using h2
+
+theorem enorm_twoPi_inv : ‖(((2 * π) ^ n)⁻¹ : ℂ)‖ₑ = ENNReal.ofReal (((2 * π) ^ n)⁻¹) := by
+  rw [← ofReal_norm, norm_inv, norm_pow, Complex.norm_mul, Complex.norm_ofNat, Complex.norm_real,
+    Real.norm_eq_abs, abs_of_pos Real.pi_pos]
+
+/-- **Weak form of Theorem 3.2 for the averaged operator** (texline~277–281): with
+`𝐀^{r,m} g = (2π)^{-n} (θ_r m ĝ)_check` (Lemma 3.3), for finite `F`,
+`∫_E max_{N∈F} |∫ θ_r m (M_{-N} f)^∧ e^{ix·}| ≤ C ‖m‖ |E|^{1/2} ‖f‖₂`. -/
+theorem lintegral_sup_theta_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : 𝓢(Rn n, ℂ)) (F : Finset (Rn n)),
+      F.Nonempty → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∫⁻ x in E, F.sup (fun N => ‖∫ ζ, (thetaR α r ζ : ℂ) * m ζ * fhat (modul (-N) f) ζ *
+        Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))‖ₑ) ≤
+        ENNReal.ofReal (C * (normM α ν m).toReal * Real.sqrt (volume E).toReal *
+          (eLpNorm (f : Rn n → ℂ) 2 volume).toReal) := by
+  classical
+  obtain ⟨C, hC, hA⟩ := lintegral_sup_avgR_le α hα hn hr ν hν
+  refine ⟨(2 * π) ^ n * 4 ^ n * C, by positivity, fun m hm f F hF E hE hEfin => ?_⟩
+  have hm' : ClassM α (absA α + 1) m := hm.mono (by omega)
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set c := F.sup' hF (rho α)
+  have hc : ∀ N ∈ F, rho α N ≤ c := fun N hN => Finset.le_sup' (rho α) hN
+  have hc0 : 0 ≤ c := by
+    obtain ⟨N, hN⟩ := hF
+    exact (rho_nonneg α N).trans (hc N hN)
+  set K := ENNReal.ofReal (C * Nm * Real.sqrt (volume E).toReal *
+    (eLpNorm (f : Rn n → ℂ) 2 volume).toReal)
+  set I : Rn n → Rn n → ℂ := fun N x => ∫ ζ, (thetaR α r ζ : ℂ) * m ζ * fhat (modul (-N) f) ζ *
+    Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))
+  set κ := ENNReal.ofReal (((2 * π) ^ n)⁻¹)
+  set g : ℕ → Rn n → ℝ≥0∞ := fun k x =>
+    F.sup fun N => ‖avgR α r m (modul (-N) f) x ((k : ℝ) + 1)‖ₑ
+  have hR : Filter.Tendsto (fun k : ℕ => (k : ℝ) + 1) Filter.atTop Filter.atTop :=
+    tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds
+  have hlim : ∀ N x, Filter.Tendsto (fun k : ℕ => ‖avgR α r m (modul (-N) f) x ((k : ℝ) + 1)‖ₑ)
+      Filter.atTop (nhds (κ * ‖I N x‖ₑ)) := by
+    intro N x
+    have h := tendsto_avgRHO α hα hr hm' (schwartzModul (-N) f) x
+    rw [coe_schwartzModul] at h
+    have e : avgRHO α r m (modul (-N) f) x = avgR α r m (modul (-N) f) x :=
+      funext fun R => (avgR_eq_avgRHO α hα r m _ x R).symm
+    rw [e] at h
+    have h' := (continuous_enorm.tendsto _).comp (h.comp hR)
+    rw [enorm_mul, enorm_twoPi_inv] at h'
+    exact h'
+  -- pointwise: `κ ‖I N x‖ₑ ≤ liminf g`
+  have hpt : ∀ x, F.sup (fun N => ‖I N x‖ₑ) ≤ κ⁻¹ * Filter.liminf (fun k => g k x) Filter.atTop
+      := by
+    intro x
+    refine Finset.sup_le fun N hN => ?_
+    have h1 : κ * ‖I N x‖ₑ ≤ Filter.liminf (fun k => g k x) Filter.atTop := by
+      rw [← (hlim N x).liminf_eq]
+      exact Filter.liminf_le_liminf (Filter.Eventually.of_forall fun k =>
+        Finset.le_sup (f := fun N => ‖avgR α r m (modul (-N) f) x ((k : ℝ) + 1)‖ₑ) hN)
+    have hκ0 : κ ≠ 0 := by
+      simp only [κ, ne_eq, ENNReal.ofReal_eq_zero, not_le]; positivity
+    calc ‖I N x‖ₑ = κ⁻¹ * (κ * ‖I N x‖ₑ) := by
+          rw [← mul_assoc, ENNReal.inv_mul_cancel hκ0 ENNReal.ofReal_ne_top, one_mul]
+      _ ≤ _ := mul_le_mul' le_rfl h1
+  -- measurability of `g k`
+  have hgm : ∀ k, Measurable (g k) := by
+    intro k
+    have hN : ∀ N ∈ F, Measurable fun x => ‖avgR α r m (modul (-N) f) x ((k : ℝ) + 1)‖ₑ := by
+      intro N _
+      have h := measurable_avgR α hα hr hm' (schwartzModul (-N) f) (R := (k : ℝ) + 1)
+        (by positivity)
+      rw [coe_schwartzModul] at h
+      exact h.enorm
+    have e : g k = F.sup' hF (fun N x => ‖avgR α r m (modul (-N) f) x ((k : ℝ) + 1)‖ₑ) := by
+      funext x
+      simp only [g]
+      rw [Finset.sup'_apply, Finset.sup'_eq_sup]
+    rw [e]
+    exact Finset.measurable_sup' hF hN
+  have hbound : ∀ k : ℕ, ∫⁻ x in E, g k x ≤
+      ENNReal.ofReal (((k : ℝ) + 1) ^ (-(2 * absA α : ℝ))) *
+        volume (ballA α ((k : ℝ) + 1 + c)) * volume (ballA α ((k : ℝ) + 1)) * K :=
+    fun k => hA m hm f F hF E hE hEfin ((k : ℝ) + 1) (by positivity) c hc
+  have htend := ENNReal.Tendsto.mul_const (tendsto_ball_ratio α hα hc0) (b := K)
+    (Or.inr ENNReal.ofReal_ne_top)
+  have hκinv : κ⁻¹ = ENNReal.ofReal ((2 * π) ^ n) := by
+    have hp : (0 : ℝ) < (2 * π) ^ n := by positivity
+    simp only [κ]
+    rw [ENNReal.ofReal_inv_of_pos hp, inv_inv]
+  calc ∫⁻ x in E, F.sup (fun N => ‖I N x‖ₑ)
+      ≤ ∫⁻ x in E, κ⁻¹ * Filter.liminf (fun k => g k x) Filter.atTop := lintegral_mono hpt
+    _ = κ⁻¹ * ∫⁻ x in E, Filter.liminf (fun k => g k x) Filter.atTop := by
+        rw [lintegral_const_mul' _ _ (by rw [hκinv]; exact ENNReal.ofReal_ne_top)]
+    _ ≤ κ⁻¹ * Filter.liminf (fun k => ∫⁻ x in E, g k x) Filter.atTop :=
+        mul_le_mul' le_rfl (lintegral_liminf_le' fun k => (hgm k).aemeasurable)
+    _ ≤ κ⁻¹ * (ENNReal.ofReal (4 ^ n) * K) := by
+        refine mul_le_mul' le_rfl ?_
+        rw [← htend.liminf_eq]
+        exact Filter.liminf_le_liminf (Filter.Eventually.of_forall hbound)
+    _ = _ := by
+        rw [hκinv, ← mul_assoc, ← ENNReal.ofReal_mul (by positivity),
+          ← ENNReal.ofReal_mul (by positivity)]
+        congr 1
+        ring
+
+/-! ### The Carleson operator of `θ_r m` (paper, texline~277–279) -/
+
+/-- A function homogeneous of degree `0` for the anisotropic dilations and continuous away from the
+origin is bounded. -/
+theorem bounded_of_homogeneous (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {q : Rn n → ℂ}
+    (hq : ContinuousOn q {0}ᶜ) (hhom : ∀ ξ : Rn n, ξ ≠ 0 → ∀ t : ℝ, 0 < t → q (dil α t ξ) = q ξ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ ξ, ‖q ξ‖ ≤ C := by
+  have hsub : {ξ : Rn n | rho α ξ = 1} ⊆ {0}ᶜ := fun ξ hξ h0 => by
+    simp only [Set.mem_ofPred_eq] at hξ
+    rw [Set.mem_singleton_iff.mp h0, rho_zero α hα] at hξ
+    exact zero_ne_one hξ
+  obtain ⟨C, hC⟩ := (isCompact_rho_eq_one α hα).exists_bound_of_continuousOn (hq.mono hsub)
+  refine ⟨max C ‖q 0‖ ⊔ 0, le_sup_right, fun ξ => ?_⟩
+  by_cases h0 : ξ = 0
+  · rw [h0]; exact (le_max_right _ _).trans le_sup_left
+  · have hρ : 0 < rho α ξ := rho_pos_of_ne_zero α hα h0
+    have h1 : rho α (dil α (rho α ξ)⁻¹ ξ) = 1 := by
+      rw [rho_dil α hα (inv_pos.mpr hρ), inv_mul_cancel₀ hρ.ne']
+    rw [← hhom ξ h0 _ (inv_pos.mpr hρ)]
+    exact ((hC _ h1).trans (le_max_left _ _)).trans le_sup_left
+
+theorem continuousOn_thetaR (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0) :
+    ContinuousOn (fun ξ => (thetaR α r ξ : ℂ)) {0}ᶜ := fun _ hξ =>
+  (Complex.continuous_ofReal.continuousAt.comp
+    (contDiffAt_thetaR α hα hr hξ).continuousAt).continuousWithinAt
+
+theorem fhat_modul (ξ₀ : Rn n) (f : Rn n → ℂ) (ζ : Rn n) :
+    fhat (modul ξ₀ f) ζ = fhat f (ζ - ξ₀) := by
+  unfold fhat modul
+  congr 1
+  funext x
+  rw [← mul_assoc, ← Complex.exp_add, inner_sub_right, Complex.ofReal_sub]
+  congr 2
+  ring
+
+/-- The frequency-shifted integrand of the Carleson operator: the modulus of
+`∫ f̂(ξ) e^{ixξ} M(ξ − N) dξ` is that of `∫ M(ζ) (M_{-N} f)^∧(ζ) e^{ixζ} dζ`. -/
+theorem enorm_carlesonIntegrand_eq (M : Rn n → ℂ) (f : Rn n → ℂ) (x N : Rn n) :
+    ‖∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * M (ξ - N)‖ₑ =
+      ‖∫ ζ, M ζ * fhat (modul (-N) f) ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))‖ₑ := by
+  rw [← integral_add_right_eq_self
+    (fun ξ => fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * M (ξ - N)) N]
+  have e : ∀ ζ, fhat f (ζ + N) * Complex.exp (Complex.I * (⟪x, ζ + N⟫_ℝ : ℂ)) * M (ζ + N - N) =
+      Complex.exp (Complex.I * (⟪x, N⟫_ℝ : ℂ)) *
+        (M ζ * fhat (modul (-N) f) ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))) := by
+    intro ζ
+    rw [fhat_modul, sub_neg_eq_add, add_sub_cancel_right, inner_add_right, Complex.ofReal_add,
+      mul_add, Complex.exp_add]
+    ring
+  simp_rw [e]
+  rw [integral_const_mul, enorm_mul, ← ofReal_norm (Complex.exp _), mul_comm Complex.I,
+    Complex.norm_exp_ofReal_mul_I, ENNReal.ofReal_one, one_mul]
+
+/-- The Carleson integrand is continuous in the frequency `N`, for a bounded multiplier continuous
+away from the origin. -/
+theorem continuous_carlesonIntegrand (hn : 0 < n) {M : Rn n → ℂ} {B : ℝ} (hMb : ∀ ξ, ‖M ξ‖ ≤ B)
+    (hMc : ContinuousOn M {0}ᶜ) (f : 𝓢(Rn n, ℂ)) (x : Rn n) :
+    Continuous fun N => ∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * M (ξ - N) := by
+  have hMm : Measurable M := measurable_of_continuousOn_compl_singleton 0 hMc
+  rw [continuous_iff_continuousAt]
+  intro N₀
+  refine continuousAt_of_dominated (bound := fun ξ => ‖fhat (f : Rn n → ℂ) ξ‖ * B) ?_ ?_ ?_ ?_
+  · refine Filter.Eventually.of_forall fun N => ?_
+    exact (((continuous_fhat_schwartz f).mul (by fun_prop)).measurable.mul
+      (hMm.comp (measurable_id.sub_const N))).aestronglyMeasurable
+  · refine Filter.Eventually.of_forall fun N => Filter.Eventually.of_forall fun ξ => ?_
+    rw [norm_mul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, mul_one]
+    exact mul_le_mul_of_nonneg_left (hMb _) (norm_nonneg _)
+  · exact (integrable_fhat_schwartz f).norm.mul_const B
+  · have hnull : ∀ᵐ ξ ∂(volume : Measure (Rn n)), ξ ≠ N₀ := by
+      rw [ae_iff]
+      simp only [ne_eq, not_not]
+      refine measure_mono_null (fun ξ (h : ξ = N₀) => ?_) (volume_coord_eq ⟨0, hn⟩ (N₀ ⟨0, hn⟩))
+      simp [h]
+    filter_upwards [hnull] with ξ hξ
+    have hne : ξ - N₀ ≠ 0 := sub_ne_zero.mpr hξ
+    have h1 : ContinuousAt (fun N => M (ξ - N)) N₀ :=
+      (hMc.continuousAt (isOpen_compl_singleton.mem_nhds hne)).comp
+        (continuous_const.sub continuous_id).continuousAt
+    exact continuousAt_const.mul h1
+
+/-- The Fourier integral `∫ M ĝ e^{ix·}` is continuous in `x`. -/
+theorem continuous_fourierMult {M : Rn n → ℂ} {B : ℝ} (hMb : ∀ ξ, ‖M ξ‖ ≤ B) (hMm : Measurable M)
+    (g : 𝓢(Rn n, ℂ)) :
+    Continuous fun x => ∫ ζ, M ζ * fhat g ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) := by
+  refine continuous_of_dominated (bound := fun ζ => B * ‖fhat (g : Rn n → ℂ) ζ‖) ?_ ?_ ?_ ?_
+  · intro x
+    exact ((hMm.mul (continuous_fhat_schwartz g).measurable).mul
+      (by fun_prop : Continuous fun ζ : Rn n =>
+        Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))).measurable).aestronglyMeasurable
+  · intro x
+    refine Filter.Eventually.of_forall fun ζ => ?_
+    rw [norm_mul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, mul_one]
+    exact mul_le_mul_of_nonneg_right (hMb _) (norm_nonneg _)
+  · exact (integrable_fhat_schwartz g).norm.const_mul B
+  · exact Filter.Eventually.of_forall fun ζ => continuous_const.mul (by fun_prop)
+
+theorem iSup_eq_iSup_dense {g : Rn n → ℝ≥0∞} (hg : Continuous g) {D : Set (Rn n)} (hD : Dense D) :
+    ⨆ N, g N = ⨆ N ∈ D, g N := by
+  refine le_antisymm (iSup_le fun N => ?_) (iSup₂_le fun N _ => le_iSup g N)
+  have hcl : IsClosed {N | g N ≤ ⨆ N ∈ D, g N} := isClosed_le hg continuous_const
+  have hsub : D ⊆ {N | g N ≤ ⨆ N ∈ D, g N} := fun N hN => le_iSup₂ (f := fun N (_ : N ∈ D) => g
+      N) N hN
+  have := hcl.closure_subset_iff.mpr hsub
+  rw [hD.closure_eq] at this
+  exact this (Set.mem_univ N)
+
+theorem le_sq_of_mul_le_sqrt {t a K : ℝ} (ht : 0 < t) (ha : 0 ≤ a) (hK : 0 ≤ K)
+    (h : t * a ≤ K * Real.sqrt a) : a ≤ (K / t) ^ 2 := by
+  rcases ha.eq_or_lt with h0 | hpos
+  · rw [← h0]; positivity
+  · have hs : 0 < Real.sqrt a := Real.sqrt_pos.mpr hpos
+    have h1 : t * Real.sqrt a ≤ K := by
+      have := Real.mul_self_sqrt ha
+      nlinarith
+    have h2 : Real.sqrt a ≤ K / t := by rw [le_div_iff₀ ht]; linarith
+    calc a = Real.sqrt a ^ 2 := (Real.sq_sqrt ha).symm
+      _ ≤ (K / t) ^ 2 := by gcongr
+
+/-- **Weak `(2,2)` bound for `𝒞_{θ_r m}`** (texline~277–281): for `ν ≥ 3|α| + 2`,
+`|{𝒞_{θ_r m} f > t}| ≤ (C ‖m‖ ‖f‖₂ / t)²`. -/
+theorem carleson_theta_weak (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : 𝓢(Rn n, ℂ)) (t : ℝ), 0 < t →
+      volume {x | ENNReal.ofReal t < carleson (fun ξ => (thetaR α r ξ : ℂ) * m ξ) f x} ≤
+        ENNReal.ofReal ((C * (normM α ν m).toReal * (eLpNorm (f : Rn n → ℂ) 2 volume).toReal /
+          t) ^ 2) := by
+  classical
+  obtain ⟨C, hC, hL⟩ := lintegral_sup_theta_le α hα hn hr ν hν
+  refine ⟨C, hC, fun m hm f t ht => ?_⟩
+  set Nm := (normM α ν m).toReal
+  set Kf := C * Nm * (eLpNorm (f : Rn n → ℂ) 2 volume).toReal
+  have hKf : 0 ≤ Kf := by positivity
+  set M : Rn n → ℂ := fun ξ => (thetaR α r ξ : ℂ) * m ξ
+  obtain ⟨Bθ, hBθ0, hBθ⟩ := bounded_of_homogeneous α hα (continuousOn_thetaR α hα hr)
+    (fun ξ _ t ht => by simp only [thetaR_dil α r ξ ht])
+  obtain ⟨Bm, hBm0, hBm⟩ := hm.bounded'
+  have hMb : ∀ ξ, ‖M ξ‖ ≤ Bθ * Bm := fun ξ => by
+    rw [norm_mul]; exact mul_le_mul (hBθ ξ) (hBm ξ) (norm_nonneg _) hBθ0
+  have hMc : ContinuousOn M {0}ᶜ :=
+    (continuousOn_thetaR α hα hr).mul (hm.contDiffOn.continuousOn)
+  have hMm : Measurable M := measurable_of_continuousOn_compl_singleton 0 hMc
+  set g : Rn n → Rn n → ℝ≥0∞ := fun N x =>
+    ‖∫ ζ, M ζ * fhat (modul (-N) f) ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ))‖ₑ
+  have hgN : ∀ x, Continuous fun N => g N x := by
+    intro x
+    have e : (fun N => g N x) = fun N => ‖∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) *
+        M (ξ - N)‖ₑ := funext fun N => (enorm_carlesonIntegrand_eq M f x N).symm
+    rw [e]
+    exact continuous_enorm.comp (continuous_carlesonIntegrand hn hMb hMc f x)
+  have hgx : ∀ N, Measurable (g N) := by
+    intro N
+    have h := continuous_fourierMult hMb hMm (schwartzModul (-N) f)
+    rw [coe_schwartzModul] at h
+    exact (continuous_enorm.comp h).measurable
+  obtain ⟨D, hDc, hDd⟩ := TopologicalSpace.exists_countable_dense (Rn n)
+  have hDne : D.Nonempty := hDd.nonempty
+  obtain ⟨e, he⟩ := hDc.exists_eq_range hDne
+  set Fk : ℕ → Finset (Rn n) := fun k => (Finset.range (k + 1)).image e
+  have hFk : ∀ k, (Fk k).Nonempty := fun k => Finset.Nonempty.image ⟨0, Finset.mem_range.mpr
+      (Nat.succ_pos k)⟩ e
+  set U : ℕ → Set (Rn n) := fun k => {x | ENNReal.ofReal t < (Fk k).sup fun N => g N x}
+  -- the level set is the increasing union of the `U k`
+  have hcarl : ∀ x, carleson M f x = ⨆ k, (Fk k).sup fun N => g N x := by
+    intro x
+    unfold carleson
+    have e1 : (⨆ N, ‖∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * M (ξ - N)‖ₑ) =
+        ⨆ N, g N x := iSup_congr fun N => enorm_carlesonIntegrand_eq M f x N
+    rw [e1, iSup_eq_iSup_dense (hgN x) hDd]
+    apply le_antisymm
+    · refine iSup₂_le fun N hN => ?_
+      rw [he] at hN
+      obtain ⟨j, rfl⟩ := hN
+      exact le_iSup_of_le j (Finset.le_sup (f := fun N => g N x)
+        (Finset.mem_image.mpr ⟨j, Finset.mem_range.mpr (Nat.lt_succ_self j), rfl⟩))
+    · refine iSup_le fun k => Finset.sup_le fun N hN => ?_
+      obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hN
+      exact le_iSup₂ (f := fun N (_ : N ∈ D) => g N x) (e j) (by rw [he]; exact ⟨j, rfl⟩)
+  have hset : {x | ENNReal.ofReal t < carleson M f x} = ⋃ k, U k := by
+    ext x
+    simp only [Set.mem_ofPred_eq, Set.mem_iUnion, U, hcarl x, lt_iSup_iff]
+  have hmono : Monotone U := by
+    intro k l hkl x (hx : ENNReal.ofReal t < _)
+    change ENNReal.ofReal t < _
+    refine lt_of_lt_of_le hx (Finset.sup_mono ?_)
+    exact Finset.image_subset_image (Finset.range_subset_range.mpr (by omega))
+  have hUm : ∀ k, MeasurableSet (U k) := by
+    intro k
+    have hmeas : Measurable fun x => (Fk k).sup fun N => g N x := by
+      have e1 : (fun x => (Fk k).sup fun N => g N x) = (Fk k).sup' (hFk k) (fun N => g N) := by
+        funext x; rw [Finset.sup'_apply, Finset.sup'_eq_sup]
+      rw [e1]
+      exact Finset.measurable_sup' (hFk k) fun N _ => hgx N
+    exact measurableSet_lt measurable_const hmeas
+  -- each `U k` has small measure
+  have hU : ∀ k, volume (U k) ≤ ENNReal.ofReal ((Kf / t) ^ 2) := by
+    intro k
+    set A : ℕ → Set (Rn n) := fun j => U k ∩ Metric.closedBall 0 j
+    have hAm : Monotone A := fun i j hij => Set.inter_subset_inter_right _
+      (Metric.closedBall_subset_closedBall (by exact_mod_cast hij))
+    have hUA : U k = ⋃ j, A j := by
+      ext x
+      simp only [Set.mem_iUnion, Set.mem_inter_iff, A, Metric.mem_closedBall, dist_zero_right]
+      constructor
+      · intro hx
+        obtain ⟨j, hj⟩ := exists_nat_ge ‖x‖
+        exact ⟨j, hx, hj⟩
+      · rintro ⟨j, hx, -⟩; exact hx
+    rw [hUA, hAm.measure_iUnion]
+    refine iSup_le fun j => ?_
+    have hAmeas : MeasurableSet (A j) := (hUm k).inter Metric.isClosed_closedBall.measurableSet
+    have hAfin : volume (A j) < ⊤ :=
+      (measure_mono Set.inter_subset_right).trans_lt measure_closedBall_lt_top
+    have h1 : ENNReal.ofReal t * volume (A j) ≤ ∫⁻ x in A j, (Fk k).sup fun N => g N x := by
+      rw [← setLIntegral_const]
+      exact setLIntegral_mono' hAmeas fun x hx => hx.1.le
+    have h2 := hL m hm f (Fk k) (hFk k) (A j) hAmeas hAfin
+    have h3 : ENNReal.ofReal t * volume (A j) ≤
+        ENNReal.ofReal (Kf * Real.sqrt (volume (A j)).toReal) := by
+      refine h1.trans (le_trans (le_of_eq ?_) (h2.trans (le_of_eq ?_)))
+      · rfl
+      · congr 1; simp only [Kf]; ring
+    have hv : volume (A j) = ENNReal.ofReal (volume (A j)).toReal :=
+      (ENNReal.ofReal_toReal hAfin.ne).symm
+    conv_lhs at h3 => rw [hv]
+    rw [← ENNReal.ofReal_mul ht.le, ENNReal.ofReal_le_ofReal_iff (by positivity)] at h3
+    rw [← ENNReal.ofReal_toReal hAfin.ne]
+    exact ENNReal.ofReal_le_ofReal (le_sq_of_mul_le_sqrt ht ENNReal.toReal_nonneg hKf h3)
+  rw [hset, hmono.measure_iUnion]
+  exact iSup_le hU
+
+/-! ### Coordinate reflections (reduction to the quadrant, texline~275) -/
+
+/-- The reflection `S_s` changing the sign of the coordinates `i` with `s i = true`. -/
+def refl (s : Fin n → Bool) : Rn n ≃ₗᵢ[ℝ] Rn n :=
+  LinearIsometryEquiv.piLpCongrRight 2
+    (fun i => if s i then LinearIsometryEquiv.neg ℝ else LinearIsometryEquiv.refl ℝ ℝ)
+
+theorem refl_apply (s : Fin n → Bool) (x : Rn n) (i : Fin n) :
+    refl s x i = if s i then -x i else x i := by
+  simp only [refl, LinearIsometryEquiv.piLpCongrRight_apply, PiLp.toLp_apply]
+  split_ifs <;> simp
+
+theorem refl_refl (s : Fin n → Bool) (x : Rn n) : refl s (refl s x) = x := by
+  ext i
+  simp only [refl_apply]
+  split_ifs <;> simp
+
+theorem dil_refl (α : Fin n → ℕ) (s : Fin n → Bool) (t : ℝ) (x : Rn n) :
+    dil α t (refl s x) = refl s (dil α t x) := by
+  ext i
+  simp only [dil, PiLp.toLp_apply, refl_apply]
+  split_ifs <;> ring
+
+theorem rho_refl (α : Fin n → ℕ) (s : Fin n → Bool) (x : Rn n) : rho α (refl s x) = rho α x := by
+  unfold rho rhoNN
+  congr 2
+  funext i
+  simp only [refl_apply]
+  split_ifs <;> simp [nnnorm_neg]
+
+theorem exists_refl_nonpos (ξ : Rn n) : ∃ s : Fin n → Bool, ∀ i, refl s ξ i ≤ 0 := by
+  refine ⟨fun i => decide (0 < ξ i), fun i => ?_⟩
+  rw [refl_apply]
+  by_cases h : 0 < ξ i
+  · simp only [h, decide_true, ite_true]; linarith
+  · simp only [h, decide_false]; simp only [Bool.false_eq_true, ite_false]; linarith
+
+theorem inner_refl (s : Fin n → Bool) (x ξ : Rn n) : ⟪refl s x, refl s ξ⟫_ℝ = ⟪x, ξ⟫_ℝ :=
+  (refl s).inner_map_map x ξ
+
+theorem fhat_comp_refl (s : Fin n → Bool) (f : Rn n → ℂ) (ξ : Rn n) :
+    fhat (f ∘ refl s) ξ = fhat f (refl s ξ) := by
+  unfold fhat
+  have h := ((refl s).measurePreserving).integral_comp (refl s).toHomeomorph.measurableEmbedding
+    (fun y => Complex.exp (-(Complex.I * (⟪y, refl s ξ⟫_ℝ : ℂ))) * f y)
+  rw [← h]
+  congr 1
+  funext x
+  simp only [Function.comp, inner_refl]
+
+/-- The Carleson operator commutes with reflections:
+`𝒞_{M ∘ S}(f ∘ S)(x) = 𝒞_M f(S x)`. -/
+theorem carleson_comp_refl (s : Fin n → Bool) (M : Rn n → ℂ) (f : Rn n → ℂ) (x : Rn n) :
+    carleson (M ∘ refl s) (f ∘ refl s) x = carleson M f (refl s x) := by
+  unfold carleson
+  have h1 : ∀ N, ∫ ξ, fhat (f ∘ refl s) ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) *
+      (M ∘ refl s) (ξ - N) = ∫ ζ, fhat f ζ * Complex.exp (Complex.I * (⟪refl s x, ζ⟫_ℝ : ℂ)) *
+        M (ζ - refl s N) := by
+    intro N
+    have h := ((refl s).measurePreserving).integral_comp (refl s).toHomeomorph.measurableEmbedding
+      (fun ζ => fhat f ζ * Complex.exp (Complex.I * (⟪refl s x, ζ⟫_ℝ : ℂ)) * M (ζ - refl s N))
+    rw [← h]
+    congr 1
+    funext ξ
+    simp only [Function.comp, fhat_comp_refl, inner_refl,
+      LinearIsometryEquiv.map_sub]
+  simp_rw [h1]
+  exact (refl s).toEquiv.iSup_comp (g := fun N => ‖∫ ζ, fhat f ζ *
+    Complex.exp (Complex.I * (⟪refl s x, ζ⟫_ℝ : ℂ)) * M (ζ - N)‖ₑ)
+
+/-- `f ∘ S` as a Schwartz function. -/
+def schwartzRefl (s : Fin n → Bool) (f : 𝓢(Rn n, ℂ)) : 𝓢(Rn n, ℂ) :=
+  SchwartzMap.compCLMOfContinuousLinearEquiv ℂ (refl s).toContinuousLinearEquiv f
+
+@[simp]
+theorem coe_schwartzRefl (s : Fin n → Bool) (f : 𝓢(Rn n, ℂ)) :
+    (schwartzRefl s f : Rn n → ℂ) = f ∘ refl s := rfl
+
+theorem eLpNorm_schwartzRefl (s : Fin n → Bool) (f : 𝓢(Rn n, ℂ)) :
+    eLpNorm (schwartzRefl s f : Rn n → ℂ) 2 volume = eLpNorm (f : Rn n → ℂ) 2 volume := by
+  rw [coe_schwartzRefl]
+  exact eLpNorm_comp_measurePreserving f.continuous.aestronglyMeasurable (refl s).measurePreserving
+
+/-! ### The symbol norm under reflections and products (texline~281–282) -/
+
+theorem normM_le_of_iteratedFDeriv (α : Fin n → ℕ) (ν : ℕ) (m' : Rn n → ℂ) {B : ℝ}
+    (h : ∀ k ≤ ν, ∀ ξ : Rn n, rho α ξ = 1 → ‖iteratedFDeriv ℝ k m' ξ‖ ≤ B) :
+    normM α ν m' ≤ ENNReal.ofReal B := by
+  classical
+  unfold normM
+  refine iSup₂_le fun k hk => iSup_le fun i => iSup₂_le fun ξ hξ => ?_
+  rw [iterPartial, ← ofReal_norm]
+  refine ENNReal.ofReal_le_ofReal (((iteratedFDeriv ℝ k m' ξ).le_opNorm _).trans ?_)
+  have : ∏ j, ‖EuclideanSpace.single (i j) (1 : ℝ)‖ = 1 := by
+    simp
+  rw [this, mul_one]
+  exact h k hk ξ hξ
+
+theorem norm_iteratedFDeriv_le_normM (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) {k : ℕ} (hk : k ≤ ν) {ξ : Rn n} (hξ : rho α ξ = 1) :
+    ‖iteratedFDeriv ℝ k m ξ‖ ≤ (n : ℝ) ^ ν * (normM α ν m).toReal := by
+  have h := enorm_iteratedFDeriv_le α hα hm hk one_pos le_rfl hξ.ge
+  simp only [Real.one_rpow, mul_one] at h
+  rw [← ofReal_norm, ← ENNReal.ofReal_toReal (normM_lt_top α hα hm).ne,
+    ← ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_le_ofReal_iff (by positivity)] at h
+  refine h.trans (mul_le_mul_of_nonneg_right ?_ ENNReal.toReal_nonneg)
+  exact pow_le_pow_right₀ (by exact_mod_cast hn) hk
+
+theorem ClassM.comp_refl {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (s : Fin n → Bool) : ClassM α ν (m ∘ refl s) := by
+  obtain ⟨C, hC⟩ := hm.bounded
+  refine ⟨⟨C, fun ξ => hC _⟩, ?_, fun ξ hξ t ht => ?_⟩
+  · refine hm.contDiffOn.comp (refl s).toContinuousLinearEquiv.contDiff.contDiffOn ?_
+    intro ξ hξ h0
+    apply hξ
+    have : refl s (refl s ξ) = refl s 0 := congrArg (refl s) h0
+    rwa [refl_refl, map_zero] at this
+  · simp only [Function.comp]
+    rw [← dil_refl]
+    refine hm.homogeneous _ ?_ t ht
+    intro h0
+    apply hξ
+    have : refl s (refl s ξ) = refl s 0 := congrArg (refl s) h0
+    rwa [refl_refl, map_zero] at this
+
+theorem normM_comp_refl_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) (s : Fin n → Bool) :
+    (normM α ν (m ∘ refl s)).toReal ≤ (n : ℝ) ^ ν * (normM α ν m).toReal := by
+  have h := normM_le_of_iteratedFDeriv α ν (m ∘ refl s) (B := (n : ℝ) ^ ν * (normM α ν m).toReal)
+    (fun k hk ξ hξ => by
+      rw [LinearIsometryEquiv.norm_iteratedFDeriv_comp_right]
+      exact norm_iteratedFDeriv_le_normM α hα hn hm hk (by rw [rho_refl]; exact hξ))
+  exact (ENNReal.toReal_le_of_le_ofReal (by positivity) h)
+
+/-- Multiplying by a fixed function smooth away from the origin costs a constant in the symbol
+    norm. -/
+theorem normM_mul_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (ν : ℕ) {q : Rn n → ℂ}
+    (hq : ContDiffOn ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) q {0}ᶜ) :
+    ∃ Cq : ℝ, 0 ≤ Cq ∧ ∀ m : Rn n → ℂ, ClassM α ν m →
+      (normM α ν (fun ξ => q ξ * m ξ)).toReal ≤ Cq * (normM α ν m).toReal := by
+  have hsub : {ξ : Rn n | rho α ξ = 1} ⊆ {0}ᶜ := fun ξ hξ h0 => by
+    simp only [Set.mem_ofPred_eq] at hξ
+    rw [Set.mem_singleton_iff.mp h0, rho_zero α hα] at hξ
+    exact zero_ne_one hξ
+  have hopen : IsOpen ({0}ᶜ : Set (Rn n)) := isOpen_compl_singleton
+  have hbd : ∀ j : ℕ, ∃ C : ℝ, ∀ ξ ∈ {ξ : Rn n | rho α ξ = 1}, ‖iteratedFDeriv ℝ j q ξ‖ ≤ C := by
+    intro j
+    have hc : ContinuousOn (fun ξ => iteratedFDeriv ℝ j q ξ) {0}ᶜ :=
+      (hq.continuousOn_iteratedFDerivWithin (by exact_mod_cast le_top) hopen.uniqueDiffOn).congr
+        (fun ξ hξ => (iteratedFDerivWithin_of_isOpen j hopen hξ).symm)
+    obtain ⟨C, hC⟩ := (isCompact_rho_eq_one α hα).exists_bound_of_continuousOn (hc.mono hsub)
+    exact ⟨C, hC⟩
+  choose C hC using hbd
+  set Bq : ℝ := ∑ j ∈ Finset.range (ν + 1), |C j|
+  have hBq : 0 ≤ Bq := Finset.sum_nonneg fun j _ => abs_nonneg _
+  have hCB : ∀ j ≤ ν, ∀ ξ, rho α ξ = 1 → ‖iteratedFDeriv ℝ j q ξ‖ ≤ Bq := fun j hj ξ hξ =>
+    (hC j ξ hξ).trans ((le_abs_self _).trans (Finset.single_le_sum (f := fun j => |C j|)
+      (fun j _ => abs_nonneg _) (Finset.mem_range.mpr (by omega))))
+  refine ⟨2 ^ ν * Bq * (n : ℝ) ^ ν, by positivity, fun m hm => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  have h := normM_le_of_iteratedFDeriv α ν (fun ξ => q ξ * m ξ)
+    (B := 2 ^ ν * Bq * (n : ℝ) ^ ν * Nm) (fun k hk ξ hξ => by
+      have hξ0 : ξ ∈ ({0}ᶜ : Set (Rn n)) := hsub hξ
+      rw [← iteratedFDerivWithin_of_isOpen k hopen hξ0]
+      refine (norm_iteratedFDerivWithin_mul_le (hq.of_le (by exact_mod_cast le_top))
+        hm.contDiffOn hopen.uniqueDiffOn hξ0 (n := k) (by exact_mod_cast hk)).trans ?_
+      calc ∑ i ∈ Finset.range (k + 1), (k.choose i : ℝ) * ‖iteratedFDerivWithin ℝ i q {0}ᶜ ξ‖ *
+            ‖iteratedFDerivWithin ℝ (k - i) m {0}ᶜ ξ‖
+          ≤ ∑ i ∈ Finset.range (k + 1), (k.choose i : ℝ) * Bq * ((n : ℝ) ^ ν * Nm) := by
+            refine Finset.sum_le_sum fun i hi => ?_
+            have hi' : i ≤ k := Nat.lt_succ_iff.mp (Finset.mem_range.mp hi)
+            rw [iteratedFDerivWithin_of_isOpen i hopen hξ0,
+              iteratedFDerivWithin_of_isOpen (k - i) hopen hξ0]
+            gcongr
+            · exact hCB i (by omega) ξ hξ
+            · exact norm_iteratedFDeriv_le_normM α hα hn hm (by omega) hξ
+        _ = (2 : ℝ) ^ k * Bq * ((n : ℝ) ^ ν * Nm) := by
+            rw [← Finset.sum_mul, ← Finset.sum_mul]
+            congr 2
+            exact_mod_cast Nat.sum_range_choose k
+        _ ≤ _ := by
+            have : (2 : ℝ) ^ k ≤ 2 ^ ν := pow_le_pow_right₀ (by norm_num) hk
+            have : 0 ≤ Bq * ((n : ℝ) ^ ν * Nm) := by positivity
+            nlinarith)
+  exact ENNReal.toReal_le_of_le_ofReal (by positivity) h
+
+/-! ### The homogeneous partition subordinate to the reflected cones (texline~275–276) -/
+
+/-- The index set: a reflection `s` and a nonzero `r`. -/
+def coneIdx (n : ℕ) : Finset ((Fin n → Bool) × (Fin n → Fin 2)) :=
+  Finset.univ.filter fun p => p.2 ≠ 0
+
+/-- The reflected multipliers `θ_r(S_s ξ)`. -/
+def thetaS (α : Fin n → ℕ) (p : (Fin n → Bool) × (Fin n → Fin 2)) (ξ : Rn n) : ℝ :=
+  thetaR α p.2 (refl p.1 ξ)
+
+/-- `D(ξ) = ∑_{s, r ≠ 0} θ_r(S_s ξ)²`. -/
+def Dsum (α : Fin n → ℕ) (ξ : Rn n) : ℝ := ∑ p ∈ coneIdx n, thetaS α p ξ ^ 2
+
+/-- The partition functions `q_{s,r} = θ_r(S_s ·) / D`. -/
+def qPart (α : Fin n → ℕ) (p : (Fin n → Bool) × (Fin n → Fin 2)) (ξ : Rn n) : ℂ :=
+  ((thetaS α p ξ / Dsum α ξ : ℝ) : ℂ)
+
+theorem refl_ne_zero {s : Fin n → Bool} {ξ : Rn n} (hξ : ξ ≠ 0) : refl s ξ ≠ 0 := by
+  intro h
+  apply hξ
+  have : refl s (refl s ξ) = refl s 0 := congrArg (refl s) h
+  rwa [refl_refl, map_zero] at this
+
+theorem Dsum_lower (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    ∃ ε₀ > 0, ∀ ξ : Rn n, ξ ≠ 0 → ε₀ ^ 2 ≤ Dsum α ξ := by
+  obtain ⟨ε₀, hε₀, hcones, hcov⟩ := lemma_3_3_cones α hα
+  refine ⟨ε₀, hε₀, fun ξ hξ => ?_⟩
+  obtain ⟨s, hs⟩ := exists_refl_nonpos ξ
+  have hSξ := refl_ne_zero (s := s) hξ
+  obtain ⟨r, hr, hmem⟩ := hcov (refl s ξ) hSξ fun i =>
+    (hs i).trans (by have := rho_nonneg α (refl s ξ); positivity)
+  have hθ := (hcones r hr).2 _ hmem
+  have hp : (s, r) ∈ coneIdx n := Finset.mem_filter.mpr ⟨Finset.mem_univ _, hr⟩
+  calc ε₀ ^ 2 ≤ thetaS α (s, r) ξ ^ 2 := by
+        unfold thetaS; exact pow_le_pow_left₀ hε₀.le hθ.le 2
+    _ ≤ Dsum α ξ := Finset.single_le_sum (f := fun p => thetaS α p ξ ^ 2)
+        (fun p _ => sq_nonneg _) hp
+
+theorem contDiffAt_thetaS (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i)
+    {p : (Fin n → Bool) × (Fin n → Fin 2)} (hp : p ∈ coneIdx n) {ξ : Rn n} (hξ : ξ ≠ 0) :
+    ContDiffAt ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (thetaS α p) ξ := by
+  have hr : p.2 ≠ 0 := (Finset.mem_filter.mp hp).2
+  exact (contDiffAt_thetaR α hα hr (refl_ne_zero hξ)).comp ξ
+    (refl p.1).toContinuousLinearEquiv.contDiff.contDiffAt
+
+theorem contDiffAt_Dsum (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ξ : Rn n} (hξ : ξ ≠ 0) :
+    ContDiffAt ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (Dsum α) ξ := by
+  have : Dsum α = fun ξ => ∑ p ∈ coneIdx n, thetaS α p ξ ^ 2 := rfl
+  rw [this]
+  exact ContDiffAt.sum fun p hp => (contDiffAt_thetaS α hα hp hξ).pow 2
+
+theorem contDiffOn_qPart (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i)
+    {p : (Fin n → Bool) × (Fin n → Fin 2)} (hp : p ∈ coneIdx n) :
+    ContDiffOn ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (qPart α p) {0}ᶜ := by
+  obtain ⟨ε₀, hε₀, hD⟩ := Dsum_lower α hα
+  intro ξ hξ
+  have hξ' : ξ ≠ 0 := hξ
+  have hD0 : Dsum α ξ ≠ 0 := (lt_of_lt_of_le (by positivity) (hD ξ hξ')).ne'
+  have h := ((contDiffAt_thetaS α hα hp hξ').div (contDiffAt_Dsum α hα hξ') hD0)
+  exact (Complex.ofRealCLM.contDiff.contDiffAt.comp ξ h).contDiffWithinAt
+
+theorem thetaS_dil (α : Fin n → ℕ) (p : (Fin n → Bool) × (Fin n → Fin 2)) (ξ : Rn n) {t : ℝ}
+    (ht : 0 < t) : thetaS α p (dil α t ξ) = thetaS α p ξ := by
+  unfold thetaS
+  rw [← dil_refl, thetaR_dil α p.2 _ ht]
+
+theorem qPart_dil (α : Fin n → ℕ) (p : (Fin n → Bool) × (Fin n → Fin 2)) (ξ : Rn n) {t : ℝ}
+    (ht : 0 < t) : qPart α p (dil α t ξ) = qPart α p ξ := by
+  unfold qPart Dsum
+  simp only [thetaS_dil α _ ξ ht]
+
+theorem sum_thetaS_qPart (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ξ : Rn n} (hξ : ξ ≠ 0) :
+    ∑ p ∈ coneIdx n, (thetaS α p ξ : ℂ) * qPart α p ξ = 1 := by
+  obtain ⟨ε₀, hε₀, hD⟩ := Dsum_lower α hα
+  have hD0 : Dsum α ξ ≠ 0 := (lt_of_lt_of_le (by positivity) (hD ξ hξ)).ne'
+  unfold qPart
+  push_cast
+  have hD0' : (Dsum α ξ : ℂ) ≠ 0 := by exact_mod_cast hD0
+  have e : ∀ p ∈ coneIdx n, (thetaS α p ξ : ℂ) * ((thetaS α p ξ : ℂ) / (Dsum α ξ : ℂ)) =
+      (thetaS α p ξ : ℂ) ^ 2 / (Dsum α ξ : ℂ) := fun p _ => by ring
+  rw [Finset.sum_congr rfl e, ← Finset.sum_div, div_eq_one_iff_eq hD0']
+  unfold Dsum
+  push_cast
+  rfl
+
+theorem ClassM.qPart_mul (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {p : (Fin n → Bool) × (Fin n → Fin 2)} (hp : p ∈ coneIdx n) :
+    ClassM α ν (fun ξ => qPart α p ξ * m ξ) := by
+  obtain ⟨Bq, _, hBq⟩ := bounded_of_homogeneous α hα
+    ((contDiffOn_qPart α hα hp).continuousOn) (fun ξ _ t ht => qPart_dil α p ξ ht)
+  obtain ⟨Bm, _, hBm⟩ := hm.bounded'
+  refine ⟨⟨Bq * Bm, fun ξ => ?_⟩, ?_, fun ξ hξ t ht => ?_⟩
+  · rw [norm_mul]
+    exact mul_le_mul (hBq ξ) (hBm ξ) (norm_nonneg _) ((norm_nonneg _).trans (hBq ξ))
+  · exact ((contDiffOn_qPart α hα hp).of_le (by exact_mod_cast le_top)).mul hm.contDiffOn
+  · simp only [qPart_dil α p ξ ht, hm.homogeneous ξ hξ t ht]
+
+/-! ### Proof of Theorem 1.1 -/
+
+theorem ae_ne_point (hn : 0 < n) (N₀ : Rn n) : ∀ᵐ ξ ∂(volume : Measure (Rn n)), ξ ≠ N₀ := by
+  rw [ae_iff]
+  simp only [ne_eq, not_not]
+  refine measure_mono_null (fun ξ (h : ξ = N₀) => ?_) (volume_coord_eq ⟨0, hn⟩ (N₀ ⟨0, hn⟩))
+  simp [h]
+
+/-- Sublinearity of the Carleson operator in the multiplier (texline~277). -/
+theorem carleson_le_sum (hn : 0 < n) {ι : Type*} (s : Finset ι) (P : ι → Rn n → ℂ)
+    (m : Rn n → ℂ) (hP : ∀ i ∈ s, ∃ B, ∀ ξ, ‖P i ξ‖ ≤ B) (hPm : ∀ i ∈ s, Measurable (P i))
+    (hsum : ∀ ξ, ξ ≠ 0 → m ξ = ∑ i ∈ s, P i ξ) (f : 𝓢(Rn n, ℂ)) (x : Rn n) :
+    carleson m f x ≤ ∑ i ∈ s, carleson (P i) f x := by
+  unfold carleson
+  refine iSup_le fun N => ?_
+  have hint : ∀ i ∈ s, Integrable fun ξ => fhat f ξ *
+      Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * P i (ξ - N) := by
+    intro i hi
+    obtain ⟨B, hB⟩ := hP i hi
+    refine ((integrable_fhat_schwartz f).norm.mul_const B).mono'
+      ((((continuous_fhat_schwartz f).mul (by fun_prop)).measurable.mul
+        ((hPm i hi).comp (measurable_id.sub_const N))).aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun ξ => ?_)
+    rw [norm_mul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, mul_one]
+    exact mul_le_mul_of_nonneg_left (hB _) (norm_nonneg _)
+  have e : ∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * m (ξ - N) =
+      ∑ i ∈ s, ∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * P i (ξ - N) := by
+    rw [← integral_finsetSum _ hint]
+    refine integral_congr_ae ?_
+    filter_upwards [ae_ne_point hn N] with ξ hξ
+    rw [hsum _ (sub_ne_zero.mpr hξ), Finset.mul_sum]
+  rw [e]
+  refine (enorm_sum_le _ _).trans (Finset.sum_le_sum fun i _ => ?_)
+  exact le_iSup (fun N => ‖∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) *
+    P i (ξ - N)‖ₑ) N
+
+/-- The level sets of `𝒞_P f` and of `𝒞_{P ∘ S}(f ∘ S)` have the same measure. -/
+theorem volume_carleson_refl (s : Fin n → Bool) (P : Rn n → ℂ) (f : Rn n → ℂ) (τ : ℝ≥0∞) :
+    volume {x | τ < carleson P f x} = volume {y | τ < carleson (P ∘ refl s) (f ∘ refl s) y} := by
+  have hset : {x | τ < carleson P f x} =
+      refl s ⁻¹' {y | τ < carleson (P ∘ refl s) (f ∘ refl s) y} := by
+    ext x
+    simp only [Set.mem_ofPred_eq, Set.mem_preimage]
+    have h := carleson_comp_refl s (P ∘ refl s) (f ∘ refl s) x
+    have e1 : (P ∘ refl s) ∘ refl s = P := funext fun ξ => by simp [refl_refl]
+    have e2 : (f ∘ refl s) ∘ refl s = f := funext fun ξ => by simp [refl_refl]
+    rw [e1, e2] at h
+    rw [h]
+  rw [hset]
+  have hmp : MeasurePreserving ((refl s).toHomeomorph.toMeasurableEquiv) volume volume :=
+    (refl s).measurePreserving
+  exact hmp.measure_preimage_equiv _
+
+/-- **Theorem 1.1** (paper, (1.2), texline~69): for `ν₀ ≥ 3|α| + 2` there is `C`, depending only
+on `α` and `ν₀`, such that for all `m ∈ 𝓜^{ν₀}`, all Schwartz functions `f` and all `t > 0`,
+`t |{x : 𝒞_m f(x) > t}|^{1/2} ≤ C ‖m‖_{𝓜^{ν₀}} ‖f‖₂`, i.e. `‖𝒞_m f‖_{L^{2,∞}} ≤ C ‖m‖_{𝓜^{ν₀}}
+    ‖f‖₂`.
+(The normalization `α₁ = 1` of the paper is not needed.) -/
+theorem thm_1_1 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (ν₀ : ℕ)
+    (hν₀ : 3 * absA α + 2 ≤ ν₀) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν₀ m → ∀ (f : 𝓢(Rn n, ℂ)) (t : ℝ), 0 < t →
+      ENNReal.ofReal t * volume {x | ENNReal.ofReal t < carleson m f x} ^ (1 / 2 : ℝ) ≤
+        ENNReal.ofReal (C * (normM α ν₀ m).toReal * (eLpNorm (f : Rn n → ℂ) 2 volume).toReal) := by
+  classical
+  -- constants for each cone
+  have hCr : ∀ r : Fin n → Fin 2, ∃ C : ℝ, 0 ≤ C ∧ (r ≠ 0 → ∀ (m : Rn n → ℂ), ClassM α ν₀ m →
+      ∀ (f : 𝓢(Rn n, ℂ)) (t : ℝ), 0 < t →
+      volume {x | ENNReal.ofReal t < carleson (fun ξ => (thetaR α r ξ : ℂ) * m ξ) f x} ≤
+        ENNReal.ofReal ((C * (normM α ν₀ m).toReal * (eLpNorm (f : Rn n → ℂ) 2 volume).toReal /
+          t) ^ 2)) := by
+    intro r
+    by_cases hr : r = 0
+    · exact ⟨0, le_rfl, fun h => absurd hr h⟩
+    · obtain ⟨C, hC, h⟩ := carleson_theta_weak α hα hn hr ν₀ hν₀
+      exact ⟨C, hC, fun _ => h⟩
+  choose Cθ hCθ0 hCθ using hCr
+  have hCq : ∀ p : (Fin n → Bool) × (Fin n → Fin 2), ∃ Cq : ℝ, 0 ≤ Cq ∧ (p ∈ coneIdx n →
+      ∀ m : Rn n → ℂ, ClassM α ν₀ m →
+        (normM α ν₀ (fun ξ => qPart α p ξ * m ξ)).toReal ≤ Cq * (normM α ν₀ m).toReal) := by
+    intro p
+    by_cases hp : p ∈ coneIdx n
+    · obtain ⟨Cq, hCq, h⟩ := normM_mul_le α hα hn ν₀ (contDiffOn_qPart α hα hp)
+      exact ⟨Cq, hCq, fun _ => h⟩
+    · exact ⟨0, le_rfl, fun h => absurd h hp⟩
+  choose Cq hCq0 hCq using hCq
+  set J : ℕ := (coneIdx n).card
+  have hJ : 0 < J := by
+    refine Finset.card_pos.mpr ⟨(fun _ => false, fun _ => 1), ?_⟩
+    refine Finset.mem_filter.mpr ⟨Finset.mem_univ _, fun h => ?_⟩
+    have := congrFun h ⟨0, hn⟩
+    simp at this
+  set K : ℝ := ∑ p ∈ coneIdx n, Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p)
+  have hK : 0 ≤ K := Finset.sum_nonneg fun p _ => by
+    have := hCθ0 p.2; have := hCq0 p; positivity
+  refine ⟨Real.sqrt J * J * K, by positivity, fun m hm f t ht => ?_⟩
+  set Nm := (normM α ν₀ m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set Ff := (eLpNorm (f : Rn n → ℂ) 2 volume).toReal
+  have hFf : 0 ≤ Ff := ENNReal.toReal_nonneg
+  -- the pieces
+  set P : (Fin n → Bool) × (Fin n → Fin 2) → Rn n → ℂ := fun p ξ =>
+    (thetaS α p ξ : ℂ) * (qPart α p ξ * m ξ)
+  have hPb : ∀ p ∈ coneIdx n, ∃ B, ∀ ξ, ‖P p ξ‖ ≤ B := by
+    intro p hp
+    have hr : p.2 ≠ 0 := (Finset.mem_filter.mp hp).2
+    obtain ⟨Bθ, _, hBθ⟩ := bounded_of_homogeneous α hα (continuousOn_thetaR α hα hr)
+      (fun ξ _ t ht => by simp only [thetaR_dil α p.2 ξ ht])
+    obtain ⟨Bm, _, hBm⟩ := (hm.qPart_mul α hα hp).bounded'
+    refine ⟨Bθ * Bm, fun ξ => ?_⟩
+    rw [norm_mul]
+    exact mul_le_mul (by simpa [thetaS] using hBθ (refl p.1 ξ)) (hBm ξ) (norm_nonneg _)
+      (by linarith [hBθ 0, norm_nonneg ((thetaR α p.2 0 : ℂ))])
+  have hPm : ∀ p ∈ coneIdx n, Measurable (P p) := by
+    intro p hp
+    have h1 : ContinuousOn (fun ξ => (thetaS α p ξ : ℂ)) {0}ᶜ := fun ξ hξ =>
+      (Complex.continuous_ofReal.continuousAt.comp
+        (contDiffAt_thetaS α hα hp hξ).continuousAt).continuousWithinAt
+    exact measurable_of_continuousOn_compl_singleton 0
+      (h1.mul ((hm.qPart_mul α hα hp).contDiffOn.continuousOn))
+  have hsum : ∀ ξ, ξ ≠ 0 → m ξ = ∑ p ∈ coneIdx n, P p ξ := by
+    intro ξ hξ
+    have h := sum_thetaS_qPart α hα hξ
+    calc m ξ = (∑ p ∈ coneIdx n, (thetaS α p ξ : ℂ) * qPart α p ξ) * m ξ := by rw [h, one_mul]
+      _ = _ := by rw [Finset.sum_mul]; exact Finset.sum_congr rfl fun p _ => by ring
+  -- weak bound for each piece
+  have hpiece : ∀ p ∈ coneIdx n, volume {x | ENNReal.ofReal (t / J) < carleson (P p) f x} ≤
+      ENNReal.ofReal ((Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p) * Nm * Ff / (t / J)) ^ 2) := by
+    intro p hp
+    have hr : p.2 ≠ 0 := (Finset.mem_filter.mp hp).2
+    set m'' := (fun ξ => qPart α p ξ * m ξ) ∘ refl p.1
+    have hm'' : ClassM α ν₀ m'' := (hm.qPart_mul α hα hp).comp_refl p.1
+    have e : P p ∘ refl p.1 = fun ξ => (thetaR α p.2 ξ : ℂ) * m'' ξ := by
+      funext ξ; simp [P, m'', thetaS, refl_refl]
+    rw [volume_carleson_refl p.1, e, ← coe_schwartzRefl]
+    refine (hCθ p.2 hr m'' hm'' (schwartzRefl p.1 f) (t / J) (by positivity)).trans ?_
+    rw [eLpNorm_schwartzRefl]
+    refine ENNReal.ofReal_le_ofReal (pow_le_pow_left₀ (by have := hCθ0 p.2; positivity) ?_ 2)
+    refine div_le_div_of_nonneg_right ?_ (by positivity)
+    have h1 : (normM α ν₀ m'').toReal ≤ (n : ℝ) ^ ν₀ * (Cq p * Nm) :=
+      (normM_comp_refl_le α hα hn (hm.qPart_mul α hα hp) p.1).trans
+        (mul_le_mul_of_nonneg_left (hCq p hp m hm) (by positivity))
+    have := hCθ0 p.2
+    calc Cθ p.2 * (normM α ν₀ m'').toReal * Ff ≤ Cθ p.2 * ((n : ℝ) ^ ν₀ * (Cq p * Nm)) * Ff := by
+          gcongr
+      _ = _ := by ring
+  -- the union bound
+  have hsub : {x | ENNReal.ofReal t < carleson m f x} ⊆
+      ⋃ p ∈ coneIdx n, {x | ENNReal.ofReal (t / J) < carleson (P p) f x} := by
+    intro x hx
+    simp only [Set.mem_ofPred_eq] at hx
+    by_contra hcon
+    simp only [Set.mem_iUnion, Set.mem_ofPred_eq, not_exists, not_lt] at hcon
+    have h1 := carleson_le_sum hn (coneIdx n) P m hPb hPm hsum f x
+    have h2 : ∑ p ∈ coneIdx n, carleson (P p) f x ≤ ∑ _p ∈ coneIdx n, ENNReal.ofReal (t / J) :=
+      Finset.sum_le_sum fun p hp => hcon p hp
+    rw [Finset.sum_const, nsmul_eq_mul] at h2
+    have h3 : (J : ℝ≥0∞) * ENNReal.ofReal (t / J) = ENNReal.ofReal t := by
+      rw [← ENNReal.ofReal_natCast, ← ENNReal.ofReal_mul (by positivity)]
+      congr 1
+      field_simp
+    rw [h3] at h2
+    exact absurd (h1.trans h2) (not_le.mpr hx)
+  have hvol : volume {x | ENNReal.ofReal t < carleson m f x} ≤
+      ENNReal.ofReal ((Real.sqrt J * J * K * Nm * Ff / t) ^ 2) := by
+    refine (measure_mono hsub).trans ((measure_biUnion_finset_le _ _).trans ?_)
+    refine (Finset.sum_le_sum hpiece).trans ?_
+    rw [← ENNReal.ofReal_sum_of_nonneg (fun p _ => by positivity)]
+    refine ENNReal.ofReal_le_ofReal ?_
+    have hterm : ∀ p ∈ coneIdx n, (Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p) * Nm * Ff / (t / J)) ^ 2 ≤
+        (K * Nm * Ff * J / t) ^ 2 := by
+      intro p hp
+      refine pow_le_pow_left₀ (by have := hCθ0 p.2; have := hCq0 p; positivity) ?_ 2
+      rw [div_div_eq_mul_div]
+      refine div_le_div_of_nonneg_right ?_ ht.le
+      have hle : Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p) ≤ K :=
+        Finset.single_le_sum (f := fun p => Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p))
+          (fun p _ => by have := hCθ0 p.2; have := hCq0 p; positivity) hp
+      have : 0 ≤ Nm * Ff * J := by positivity
+      nlinarith
+    calc ∑ p ∈ coneIdx n, (Cθ p.2 * ((n : ℝ) ^ ν₀ * Cq p) * Nm * Ff / (t / J)) ^ 2
+        ≤ ∑ _p ∈ coneIdx n, (K * Nm * Ff * J / t) ^ 2 := Finset.sum_le_sum hterm
+      _ = J * (K * Nm * Ff * J / t) ^ 2 := by rw [Finset.sum_const, nsmul_eq_mul]
+      _ = (Real.sqrt J * J * K * Nm * Ff / t) ^ 2 := by
+          have hs : Real.sqrt (J : ℝ) ^ 2 = J := Real.sq_sqrt (by positivity)
+          calc (J : ℝ) * (K * Nm * Ff * J / t) ^ 2 =
+              Real.sqrt (J : ℝ) ^ 2 * (K * Nm * Ff * J / t) ^ 2 := by rw [hs]
+            _ = _ := by ring
+  -- conclusion
+  have hroot : volume {x | ENNReal.ofReal t < carleson m f x} ^ (1 / 2 : ℝ) ≤
+      ENNReal.ofReal (Real.sqrt J * J * K * Nm * Ff / t) := by
+    refine (ENNReal.rpow_le_rpow hvol (by norm_num)).trans (le_of_eq ?_)
+    rw [ENNReal.ofReal_rpow_of_nonneg (by positivity) (by norm_num), ← Real.sqrt_eq_rpow,
+      Real.sqrt_sq (by positivity)]
+  calc ENNReal.ofReal t * volume {x | ENNReal.ofReal t < carleson m f x} ^ (1 / 2 : ℝ)
+      ≤ ENNReal.ofReal t * ENNReal.ofReal (Real.sqrt J * J * K * Nm * Ff / t) :=
+        mul_le_mul' le_rfl hroot
+    _ = _ := by
+        rw [← ENNReal.ofReal_mul ht.le]
+        congr 1
+        field_simp
+
+section
+
+open scoped CarlesonLT FourierTransform
+
+/-! ### Theorem 1.1 in the formulation of `LeanPool/CarlesonLT/Defs.lean` -/
+
+theorem anisoNorm_eq_rho (α : Fin n → ℕ) (x : ℝ^n) : CarlesonLT.anisoNorm α x = rho α x := by
+  unfold CarlesonLT.anisoNorm rho rhoNN
+  rw [Finset.sup_univ_eq_ciSup, NNReal.coe_iSup]
+  congr 1
+
+theorem multiplierNorm_eq_normM (α : Fin n → ℕ) (ν : ℕ) (m : ℝ^n → ℂ) :
+    CarlesonLT.multiplierNorm α ν m = normM α ν m := by
+  unfold CarlesonLT.multiplierNorm normM iterPartial
+  simp_rw [anisoNorm_eq_rho]
+
+theorem classM_of_multiplierClass' {α : Fin n → ℕ} {ν : ℕ} {m : ℝ^n → ℂ}
+    (h : CarlesonLT.MultiplierClass α ν m) : ClassM α ν m :=
+  ⟨h.bounded, h.contDiffOn, h.homogeneous⟩
+
+/-- The rescaling `x ↦ c • x` as a continuous linear equivalence. -/
+def smulCLE (c : ℝ) (hc : c ≠ 0) : ℝ^n ≃L[ℝ] ℝ^n :=
+  (LinearEquiv.smulOfNeZero ℝ (ℝ^n) c hc).toContinuousLinearEquiv
+
+@[simp] theorem smulCLE_apply (c : ℝ) (hc : c ≠ 0) (x : ℝ^n) : smulCLE c hc x = c • x := rfl
+
+theorem ClassM.comp_smul {α : Fin n → ℕ} {ν : ℕ} {m : ℝ^n → ℂ} (hm : ClassM α ν m) {c : ℝ}
+    (hc : 0 < c) : ClassM α ν (fun ξ => m (c • ξ)) := by
+  obtain ⟨C, hC⟩ := hm.bounded
+  refine ⟨⟨C, fun ξ => hC _⟩, ?_, fun ξ hξ t ht => ?_⟩
+  · refine hm.contDiffOn.comp (smulCLE c hc.ne').contDiff.contDiffOn fun ξ hξ h0 => hξ ?_
+    simpa [smul_eq_zero, hc.ne'] using h0
+  · have e : c • dil α t ξ = dil α t (c • ξ) := by
+      ext i; simp only [dil, PiLp.toLp_apply, PiLp.smul_apply, smul_eq_mul]; ring
+    simp only [e]
+    exact hm.homogeneous _ (smul_ne_zero hc.ne' hξ) t ht
+
+theorem rho_smul_ge (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {c : ℝ} (hc : 0 < c) (hc1 : c ≤ 1)
+    (x : ℝ^n) : c * rho α x ≤ rho α (c • x) := by
+  rcases (rho_nonneg α x).eq_or_lt with h0 | hpos
+  · rw [← h0, mul_zero]; exact rho_nonneg α _
+  obtain ⟨j, hj⟩ := exists_coord_eq_rho α hα hpos
+  have hαj : (0 : ℝ) < α j := by have := hα j; positivity
+  have h1 := coord_rpow_le_rhoNN α (c • x) j
+  have h2 : ((‖(c • x) j‖₊ ^ ((α j : ℝ)⁻¹) : ℝ≥0) : ℝ) = c ^ ((α j : ℝ)⁻¹) * rho α x := by
+    rw [NNReal.coe_rpow, coe_nnnorm, PiLp.smul_apply, smul_eq_mul, Real.norm_eq_abs, abs_mul,
+      abs_of_pos hc, Real.mul_rpow hc.le (abs_nonneg _), hj, ← Real.rpow_natCast,
+      ← Real.rpow_mul (rho_nonneg α x), mul_inv_cancel₀ hαj.ne', Real.rpow_one]
+  have h3 : c ≤ c ^ ((α j : ℝ)⁻¹) := by
+    calc c = c ^ (1 : ℝ) := (Real.rpow_one c).symm
+      _ ≤ c ^ ((α j : ℝ)⁻¹) := Real.rpow_le_rpow_of_exponent_ge hc hc1
+          (inv_le_one_of_one_le₀ (by exact_mod_cast hα j))
+  have h4 : (c ^ ((α j : ℝ)⁻¹) * rho α x : ℝ) ≤ rho α (c • x) := by
+    rw [← h2]; exact_mod_cast h1
+  calc c * rho α x ≤ c ^ ((α j : ℝ)⁻¹) * rho α x := mul_le_mul_of_nonneg_right h3 hpos.le
+    _ ≤ _ := h4
+
+/-- `‖m(c ·)‖_{𝓜^ν} ≤ n^ν c^{-ν|α|} ‖m‖_{𝓜^ν}` for `0 < c ≤ 1`. -/
+theorem normM_comp_smul_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {ν : ℕ}
+    {m : ℝ^n → ℂ} (hm : ClassM α ν m) {c : ℝ} (hc : 0 < c) (hc1 : c ≤ 1) :
+    (normM α ν (fun ξ => m (c • ξ))).toReal ≤
+      (n : ℝ) ^ ν * c ^ (-((ν * absA α : ℕ) : ℝ)) * (normM α ν m).toReal := by
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  have htop := (normM_lt_top α hα hm).ne
+  refine ENNReal.toReal_le_of_le_ofReal (by positivity) (normM_le_of_iteratedFDeriv α ν _ ?_)
+  intro k hk ξ hξ
+  have hcomp : iteratedFDeriv ℝ k (fun ξ => m (c • ξ)) ξ =
+      (iteratedFDeriv ℝ k m (c • ξ)).compContinuousLinearMap
+        fun _ => ((smulCLE (n := n) c hc.ne' : ℝ^n ≃L[ℝ] ℝ^n) : ℝ^n →L[ℝ] ℝ^n) := by
+    have := (smulCLE (n := n) c hc.ne').iteratedFDerivWithin_comp_right m uniqueDiffOn_univ
+      (Set.mem_univ (smulCLE c hc.ne' ξ)) k
+    rw [Set.preimage_univ, iteratedFDerivWithin_univ, iteratedFDerivWithin_univ] at this
+    exact this
+  have hg : ‖(smulCLE (n := n) c hc.ne' : ℝ^n →L[ℝ] ℝ^n)‖ ≤ 1 := by
+    refine ContinuousLinearMap.opNorm_le_bound _ zero_le_one fun x => ?_
+    simp only [ContinuousLinearEquiv.coe_coe, smulCLE_apply, norm_smul, Real.norm_eq_abs,
+      abs_of_pos hc, one_mul]
+    exact mul_le_of_le_one_left (norm_nonneg _) hc1
+  have hρ : c ≤ rho α (c • ξ) := by
+    have := rho_smul_ge α hα hc hc1 ξ; rwa [hξ, mul_one] at this
+  have hD := enorm_iteratedFDeriv_le α hα hm hk hc hc1 hρ
+  rw [← ofReal_norm, ← ENNReal.ofReal_toReal htop, ← ENNReal.ofReal_mul (by positivity),
+    ENNReal.ofReal_le_ofReal_iff (by positivity)] at hD
+  rw [hcomp]
+  refine (ContinuousMultilinearMap.norm_compContinuousLinearMap_le _ _).trans ?_
+  have hprod : ∏ _i : Fin k, ‖(smulCLE (n := n) c hc.ne' : ℝ^n →L[ℝ] ℝ^n)‖ ≤ 1 :=
+    by rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin]; exact pow_le_one₀
+        (norm_nonneg _) hg
+  have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
+  have hpow1 : (n : ℝ) ^ k ≤ (n : ℝ) ^ ν := pow_le_pow_right₀ hn1 hk
+  have hpow2 : c ^ (-((k * absA α : ℕ) : ℝ)) ≤ c ^ (-((ν * absA α : ℕ) : ℝ)) := by
+    refine Real.rpow_le_rpow_of_exponent_ge hc hc1 ?_
+    have : (k * absA α : ℕ) ≤ ν * absA α := Nat.mul_le_mul_right _ hk
+    have : ((k * absA α : ℕ) : ℝ) ≤ ((ν * absA α : ℕ) : ℝ) := by exact_mod_cast this
+    linarith
+  calc ‖iteratedFDeriv ℝ k m (c • ξ)‖ * ∏ _i : Fin k, ‖(smulCLE (n := n) c hc.ne' : ℝ^n →L[ℝ] ℝ^n)‖
+      ≤ ‖iteratedFDeriv ℝ k m (c • ξ)‖ * 1 := mul_le_mul_of_nonneg_left hprod (norm_nonneg _)
+    _ ≤ (n : ℝ) ^ k * c ^ (-((k * absA α : ℕ) : ℝ)) * Nm := by rw [mul_one]; exact hD
+    _ ≤ _ := by gcongr
+
+/-- Mathlib's Fourier normalization versus the paper's: `𝒞_m f ≤ 𝒞^{paper}_{m(·/2π)} f`. -/
+theorem carlesonOperator_le (m : ℝ^n → ℂ) (f : ℝ^n → ℂ) (x : ℝ^n) :
+    CarlesonLT.carlesonOperator m f x ≤
+      carleson (fun ζ => m ((2 * π)⁻¹ • ζ)) f x := by
+  refine iSup_le fun N => ?_
+  have hπ : (0 : ℝ) < 2 * π := by positivity
+  set F : ℝ^n → ℂ := fun ξ => 𝓕 f ξ * 𝐞 (⟪x, ξ⟫_ℝ) * m (ξ - N)
+  have hsub := Measure.integral_comp_inv_smul (μ := (volume : Measure (ℝ^n))) F (2 * π)
+  rw [abs_of_pos (by positivity), finrank_euclideanSpace_fin] at hsub
+  have hG : ∀ ζ, F ((2 * π)⁻¹ • ζ) =
+      fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) * m ((2 * π)⁻¹ • (ζ - (2 * π) • N)) := by
+    intro ζ
+    simp only [F]
+    rw [smul_sub, smul_smul, inv_mul_cancel₀ hπ.ne', one_smul]
+    congr 2
+    · rw [Real.fourier_eq', fhat]
+      congr 1; funext y
+      rw [smul_eq_mul, inner_smul_right]
+      congr 2; push_cast; field_simp
+    · rw [Real.fourierChar_apply, inner_smul_right]
+      congr 1; push_cast; field_simp
+  simp_rw [hG] at hsub
+  have hle : ‖∫ ξ, F ξ‖ₑ ≤ ‖∫ ζ, fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+      m ((2 * π)⁻¹ • (ζ - (2 * π) • N))‖ₑ := by
+    rw [hsub, enorm_smul]
+    refine le_trans (le_of_eq ?_) (le_mul_of_one_le_left bot_le ?_)
+    · rfl
+    · rw [← ofReal_norm, Real.norm_eq_abs, abs_of_pos (by positivity)]
+      exact ENNReal.one_le_ofReal.mpr (one_le_pow₀ (by nlinarith [Real.pi_gt_three]))
+  exact hle.trans (le_iSup (fun N' => ‖∫ ζ, fhat f ζ * Complex.exp (Complex.I * (⟪x, ζ⟫_ℝ : ℂ)) *
+    m ((2 * π)⁻¹ • (ζ - N'))‖ₑ) ((2 * π) • N))
+
+/-- **Theorem 1.1** (Roos, arXiv:1710.10962), in the formulation of
+`LeanPool/CarlesonLT/Theorems.lean`. -/
+theorem anisotropic_carleson (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (ν₀ : ℕ)
+    (hν₀ : 3 * (∑ i, α i) + 2 ≤ ν₀) :
+      ∃ C : ℝ, 0 < C ∧ ∀ (m : ℝ^n → ℂ), CarlesonLT.MultiplierClass α ν₀ m → ∀ f : 𝓢(ℝ^n, ℂ),
+        CarlesonLT.weakL2Norm volume (CarlesonLT.carlesonOperator m f) ≤
+          ENNReal.ofReal C * (CarlesonLT.multiplierNorm α ν₀ m) * eLpNorm f 2 volume := by
+  obtain ⟨C₀, hC₀, h⟩ := thm_1_1 α hα hn ν₀ hν₀
+  set c : ℝ := (2 * π)⁻¹
+  have hc : 0 < c := by positivity
+  have hc1 : c ≤ 1 := inv_le_one_of_one_le₀ (by nlinarith [Real.pi_gt_three])
+  set K : ℝ := (n : ℝ) ^ ν₀ * c ^ (-((ν₀ * absA α : ℕ) : ℝ))
+  have hK : 0 ≤ K := by positivity
+  refine ⟨C₀ * K + 1, by positivity, fun m hm f => ?_⟩
+  have hmA := classM_of_multiplierClass' hm
+  have hm' : ClassM α ν₀ (fun ζ => m (c • ζ)) := hmA.comp_smul hc
+  have hnorm := normM_comp_smul_le α hα hn hmA hc hc1
+  rw [multiplierNorm_eq_normM]
+  set Nm := (normM α ν₀ m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set Ff := (eLpNorm (f : ℝ^n → ℂ) 2 volume).toReal
+  have hRHS : ENNReal.ofReal (C₀ * K + 1) * normM α ν₀ m * eLpNorm (f : ℝ^n → ℂ) 2 volume =
+      ENNReal.ofReal ((C₀ * K + 1) * Nm * Ff) := by
+    have hfin : eLpNorm (f : ℝ^n → ℂ) 2 volume ≠ ⊤ := (f.memLp 2).eLpNorm_ne_top
+    rw [← ENNReal.ofReal_toReal (normM_lt_top α hα hmA).ne, ← ENNReal.ofReal_toReal hfin,
+      ← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_mul (by positivity)]
+  rw [hRHS]
+  refine iSup_le fun t => ?_
+  rcases eq_or_ne t ⊤ with rfl | htop
+  · have : {x | (⊤ : ℝ≥0∞) < CarlesonLT.carlesonOperator m f x} = ∅ := by
+      ext x; simp
+    rw [this, measure_empty, ENNReal.zero_rpow_of_pos (by norm_num), mul_zero]
+    exact bot_le
+  rcases eq_or_ne t 0 with rfl | h0
+  · rw [zero_mul]; exact bot_le
+  have htr : 0 < t.toReal := ENNReal.toReal_pos h0 htop
+  have hset : {x | t < CarlesonLT.carlesonOperator m f x} ⊆
+      {x | ENNReal.ofReal t.toReal < carleson (fun ζ => m (c • ζ)) f x} := by
+    intro x hx
+    rw [Set.mem_ofPred_eq, ENNReal.ofReal_toReal htop]
+    exact lt_of_lt_of_le hx (carlesonOperator_le m f x)
+  have hbound := h _ hm' f t.toReal htr
+  rw [ENNReal.ofReal_toReal htop] at hbound
+  refine (mul_le_mul' le_rfl (ENNReal.rpow_le_rpow (measure_mono hset) (by norm_num))).trans ?_
+  rw [show (2⁻¹ : ℝ) = 1 / 2 by norm_num, ENNReal.ofReal_toReal htop]
+  refine hbound.trans (ENNReal.ofReal_le_ofReal ?_)
+  have h1 : (normM α ν₀ fun ζ => m (c • ζ)).toReal ≤ K * Nm := hnorm
+  calc C₀ * (normM α ν₀ fun ζ => m (c • ζ)).toReal * Ff ≤ C₀ * (K * Nm) * Ff := by gcongr
+    _ ≤ (C₀ * K + 1) * Nm * Ff := by nlinarith [mul_nonneg hNm (ENNReal.toReal_nonneg (a :=
+        eLpNorm (f : ℝ^n → ℂ) 2 volume))]
+
+end
+
+end CarlesonLT.Auto
diff --git a/LeanPool/CarlesonLT/Auto/ClassicalCarleson.lean b/LeanPool/CarlesonLT/Auto/ClassicalCarleson.lean
new file mode 100644
index 0000000000..d17f824a7f
--- /dev/null
+++ b/LeanPool/CarlesonLT/Auto/ClassicalCarleson.lean
@@ -0,0 +1,1059 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Proofs generated by Claude under Joris Roos’s supervision; adapted for Lean Pool. -/
+
+public import LeanPool.CarlesonLT.Auto.AnisotropicCarleson
+public import Mathlib.Analysis.Fourier.RiemannLebesgueLemma
+public import Mathlib.Analysis.Normed.Lp.SmoothApprox
+
+/-!
+# The classical Carleson theorems
+
+Derived from the anisotropic Carleson theorem `Auto.thm_1_1` (J. Roos, arXiv:1710.10962, Theorem
+    1.1)
+in dimension `n = 1` with the multiplier `m = 1_{(0,∞)}`.
+
+* `Auto.carleson_real_line`: for `f ∈ L²(ℝ)` (as `MemLp f 2`), the partial Fourier integrals
+  `S_R f(x) = ∫ f(y) sin(2πR(x−y))/(π(x−y)) dy` converge to `f(x)` for almost every `x`;
+  `Auto.carleson_fourierIntegral`: for `f ∈ L¹ ∩ L²`, `∫_{-R}^{R} 𝓕f(ξ) e^{2πixξ} dξ → f(x)` a.e.
+* `Auto.carleson_fourierSeries`: **Carleson's theorem** (L. Carleson, *On convergence and growth of
+  partial sums of Fourier series*, Acta Math. 116 (1966), 135–157): for a `1`-periodic `f` with
+  `MemLp f 2` on `(0,1]`, the symmetric partial sums of its Fourier series converge to `f(x)` for
+  almost every `x`. `Auto.classical_carleson` states it for `2π`-periodic `f` with `MemLp f 2` on
+  `[0, 2π)`, using Mathlib's Fourier coefficients `fourierCoeffOn` and characters `fourier`.
+
+The proof of the real-line result is the standard one: the maximal partial Fourier integral is
+dominated by the Carleson operator, hence of weak type `(2,2)` on Schwartz functions, hence on
+`L²` by approximation; a.e. convergence follows from Fourier inversion on a dense class. The
+periodic result follows by comparing the Dirichlet kernel with the real-line kernel on a window and
+the Riemann–Lebesgue lemma.
+-/
+
+@[expose] public section
+
+open MeasureTheory Real Complex Filter
+open scoped InnerProductSpace NNReal ENNReal SchwartzMap ComplexConjugate FourierTransform Topology
+
+noncomputable section
+
+namespace CarlesonLT.Auto
+
+/-! ### Step 1: the one-dimensional Carleson operator -/
+
+/-- The isometry `ℝ ≃ ℝ¹`, `t ↦ t e₀`. -/
+def toR1 : ℝ ≃ₗᵢ[ℝ] Rn 1 :=
+  LinearIsometry.toLinearIsometryEquiv
+    { toLinearMap := LinearMap.toSpanSingleton ℝ (Rn 1) (EuclideanSpace.single 0 1)
+      norm_map' := fun t => by simp [norm_smul] }
+    (by simp)
+
+@[simp]
+theorem toR1_apply_zero (t : ℝ) : toR1 t 0 = t := by
+  simp [toR1]
+
+theorem inner_toR1 (a b : ℝ) : ⟪toR1 a, toR1 b⟫_ℝ = a * b := by
+  rw [toR1.inner_map_map, real_inner_eq_re_inner, RCLike.inner_apply, conj_trivial]
+  simp [mul_comm]
+
+/-- The exponent vector `α = (1)`. -/
+def alpha1 : Fin 1 → ℕ := fun _ => 1
+
+theorem alpha1_pos : ∀ i, 1 ≤ alpha1 i := fun _ => le_rfl
+
+theorem absA_alpha1 : absA alpha1 = 1 := by simp [absA, alpha1]
+
+/-- The multiplier `1_{(0,∞)}` on `ℝ¹`. -/
+def mHalf : Rn 1 → ℂ := fun ξ => if 0 < ξ 0 then 1 else 0
+
+theorem classM_mHalf (ν : ℕ) : ClassM alpha1 ν mHalf := by
+  refine ⟨⟨1, fun ξ => ?_⟩, ?_, fun ξ hξ t ht => ?_⟩
+  · unfold mHalf; split_ifs <;> simp
+  · intro ξ hξ
+    have hξ0 : ξ 0 ≠ 0 := by
+      intro h; apply hξ
+      ext i; fin_cases i; simpa using h
+    have hc : Continuous fun ζ : Rn 1 => ζ 0 :=
+      (continuous_apply 0).comp (PiLp.continuous_ofLp 2 _)
+    refine (contDiffAt_const (c := mHalf ξ)).congr_of_eventuallyEq ?_ |>.contDiffWithinAt
+    rcases lt_or_gt_of_ne hξ0 with h | h
+    · filter_upwards [hc.continuousAt.eventually (gt_mem_nhds h)] with ζ hζ
+      simp [mHalf, not_lt.mpr hζ.le, not_lt.mpr h.le]
+    · filter_upwards [hc.continuousAt.eventually (lt_mem_nhds h)] with ζ hζ
+      simp [mHalf, hζ, h]
+  · simp only [mHalf, dil, alpha1, pow_one, PiLp.toLp_apply]
+    by_cases h : 0 < ξ 0
+    · simp [h, mul_pos ht h]
+    · have : ¬ 0 < t * ξ 0 := fun h' => h (pos_of_mul_pos_right h' ht.le)
+      simp [h, this]
+
+theorem le_sq_of_mul_rpow_half_le {t : ℝ} (ht : 0 < t) {v : ℝ≥0∞} {K : ℝ} (hK : 0 ≤ K)
+    (h : ENNReal.ofReal t * v ^ (1 / 2 : ℝ) ≤ ENNReal.ofReal K) :
+    v ≤ ENNReal.ofReal ((K / t) ^ 2) := by
+  have h1 : v ^ (1 / 2 : ℝ) ≤ ENNReal.ofReal (K / t) := by
+    rw [ENNReal.ofReal_div_of_pos ht, ENNReal.le_div_iff_mul_le (by simp [ht]) (by simp),
+      mul_comm]
+    exact h
+  have h2 : v = (v ^ (1 / 2 : ℝ)) ^ 2 := by
+    rw [← ENNReal.rpow_natCast, ← ENNReal.rpow_mul]; norm_num
+  rw [h2, ENNReal.ofReal_pow (by positivity)]
+  exact pow_le_pow_left₀ bot_le h1 2
+
+/-- **Weak `(2,2)` bound for the one-dimensional Carleson operator** (Theorem 1.1 with `n = 1`,
+`m = 1_{(0,∞)}`). -/
+theorem carleson_mHalf_weak :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (G : 𝓢(Rn 1, ℂ)) (t : ℝ), 0 < t →
+      volume {y | ENNReal.ofReal t < carleson mHalf G y} ≤
+        ENNReal.ofReal ((C * (eLpNorm (G : Rn 1 → ℂ) 2 volume).toReal / t) ^ 2) := by
+  obtain ⟨C, hC, h⟩ := thm_1_1 alpha1 alpha1_pos one_pos 5 (by rw [absA_alpha1])
+  refine ⟨C * (normM alpha1 5 mHalf).toReal, by positivity, fun G t ht => ?_⟩
+  have h1 := h mHalf (classM_mHalf 5) G t ht
+  rw [mul_assoc] at h1
+  exact le_sq_of_mul_rpow_half_le ht (by positivity) (by rw [mul_assoc]; exact h1)
+
+/-! ### Step 2: the Dirichlet kernel of the real line -/
+
+/-- The kernel `D_R(z) = sin(2πRz)/(πz)` (with `D_R(0) = 2R`) of the partial Fourier integrals
+`∫_{-R}^{R} f̂(ξ) e^{2πixξ} dξ = ∫ f(y) D_R(x − y) dy`. -/
+def dirichletKernel (R z : ℝ) : ℂ :=
+  if z = 0 then ((2 * R : ℝ) : ℂ) else ((Real.sin (2 * π * R * z) / (π * z) : ℝ) : ℂ)
+
+theorem dirichletKernel_eq_integral (R z : ℝ) :
+    dirichletKernel R z = ∫ ξ in -R..R, Complex.exp (↑(2 * π * (ξ * z)) * Complex.I) := by
+  unfold dirichletKernel
+  split_ifs with hz
+  · subst hz; simp; ring
+  · set c : ℂ := ↑(2 * π * z) * Complex.I
+    have hc : c ≠ 0 := by
+      simp [c, Real.pi_ne_zero, hz]
+    have e : ∀ ξ : ℝ, Complex.exp (↑(2 * π * (ξ * z)) * Complex.I) = Complex.exp (c * ξ) := by
+      intro ξ; congr 1; simp only [c]; push_cast; ring
+    simp_rw [e]
+    rw [integral_exp_mul_complex hc]
+    simp only [c]
+    push_cast
+    rw [Complex.sin]
+    have hz' : (z : ℂ) ≠ 0 := by exact_mod_cast hz
+    have hπ : (π : ℂ) ≠ 0 := by exact_mod_cast Real.pi_ne_zero
+    field_simp
+    ring_nf
+    rw [Complex.I_sq]
+    ring_nf
+
+/-- The partial Fourier integral `S_R f(x) = ∫ f(y) D_R(x − y) dy`. -/
+def partialFourierIntegral (f : ℝ → ℂ) (R x : ℝ) : ℂ := ∫ y, f y * dirichletKernel R (x - y)
+
+/-- For integrable `f`, `S_R f(x) = ∫_{-R}^{R} 𝓕f(ξ) e^{2πixξ} dξ` (Fubini). -/
+theorem integral_fourier_eq_partialFourierIntegral {f : ℝ → ℂ} (hf : Integrable f) {R : ℝ}
+    (hR : 0 ≤ R) (x : ℝ) :
+    ∫ ξ in -R..R, 𝐞 (ξ * x) • 𝓕 f ξ = partialFourierIntegral f R x := by
+  rw [intervalIntegral.integral_of_le (by linarith)]
+  unfold partialFourierIntegral
+  have h1 : ∀ ξ, 𝐞 (ξ * x) • 𝓕 f ξ = ∫ y, Complex.exp (↑(2 * π * (ξ * (x - y))) * Complex.I) * f
+      y := by
+    intro ξ
+    rw [Real.fourier_real_eq_integral_exp_smul, Circle.smul_def, smul_eq_mul,
+      Real.fourierChar_apply, ← integral_const_mul]
+    congr 1; funext y
+    rw [smul_eq_mul, ← mul_assoc, ← Complex.exp_add]
+    congr 2; push_cast; ring
+  simp_rw [h1]
+  have hint : Integrable (Function.uncurry fun ξ y =>
+      Complex.exp (↑(2 * π * (ξ * (x - y))) * Complex.I) * f y)
+      ((volume.restrict (Set.Ioc (-R) R)).prod volume) := by
+    have hm : AEStronglyMeasurable (Function.uncurry fun ξ y =>
+        Complex.exp (↑(2 * π * (ξ * (x - y))) * Complex.I) * f y)
+        ((volume.restrict (Set.Ioc (-R) R)).prod volume) := by
+      refine AEStronglyMeasurable.mul ?_ ?_
+      · exact (by fun_prop : Continuous fun p : ℝ × ℝ =>
+          Complex.exp (↑(2 * π * (p.1 * (x - p.2))) * Complex.I)).aestronglyMeasurable
+      · exact hf.aestronglyMeasurable.comp_snd
+    refine ((integrable_const (1 : ℝ)).mul_prod hf.norm).mono' hm
+      (Filter.Eventually.of_forall fun p => ?_)
+    simp only [Function.uncurry, norm_mul, one_mul]
+    rw [Complex.norm_exp_ofReal_mul_I, one_mul]
+  rw [integral_integral_swap hint]
+  congr 1; funext y
+  rw [dirichletKernel_eq_integral, intervalIntegral.integral_of_le (by linarith),
+    ← integral_const_mul]
+  congr 1; funext ξ; ring
+
+/-! ### Step 3: the partial Fourier integrals of Schwartz functions -/
+
+/-- `g ∘ toR1⁻¹` as a Schwartz function on `ℝ¹`. -/
+def schwartzToR1 (g : 𝓢(ℝ, ℂ)) : 𝓢(Rn 1, ℂ) :=
+  SchwartzMap.compCLMOfContinuousLinearEquiv ℂ toR1.symm.toContinuousLinearEquiv g
+
+@[simp]
+theorem coe_schwartzToR1 (g : 𝓢(ℝ, ℂ)) : (schwartzToR1 g : Rn 1 → ℂ) = g ∘ toR1.symm := rfl
+
+theorem integral_toR1 (h : Rn 1 → ℂ) : ∫ w, h w = ∫ ζ : ℝ, h (toR1 ζ) :=
+  (toR1.measurePreserving.integral_comp toR1.toHomeomorph.measurableEmbedding h).symm
+
+theorem mHalf_toR1 (u : ℝ) : mHalf (toR1 u) = if 0 < u then 1 else 0 := by
+  simp [mHalf]
+
+theorem fhat_schwartzToR1 (g : 𝓢(ℝ, ℂ)) (ζ : ℝ) :
+    fhat (schwartzToR1 g) (toR1 ζ) =
+      ∫ y : ℝ, Complex.exp (-(Complex.I * ((y * ζ : ℝ) : ℂ))) * g y := by
+  unfold fhat
+  rw [integral_toR1]
+  congr 1; funext y
+  rw [coe_schwartzToR1, Function.comp_apply, LinearIsometryEquiv.symm_apply_apply, inner_toR1]
+
+/-- The frequency cut-off integral `J(N) = ∫_{ξ > N} 𝓕g(ξ) e^{2πixξ} dξ`. -/
+def cutoffIntegral (g : ℝ → ℂ) (x N : ℝ) : ℂ :=
+  ∫ ξ, (Set.Ioi N).indicator (fun ξ => 𝐞 (ξ * x) • 𝓕 g ξ) ξ
+
+theorem integrable_fourier_schwartz (g : 𝓢(ℝ, ℂ)) : Integrable (𝓕 (g : ℝ → ℂ)) := by
+  rw [← SchwartzMap.fourier_coe]; exact (𝓕 g).integrable
+
+theorem integrable_char_fourier (g : 𝓢(ℝ, ℂ)) (x : ℝ) :
+    Integrable fun ξ => 𝐞 (ξ * x) • 𝓕 (g : ℝ → ℂ) ξ := by
+  refine (integrable_fourier_schwartz g).norm.mono' ?_ (Filter.Eventually.of_forall fun ξ => ?_)
+  · exact ((Real.continuous_fourierChar.comp (continuous_id.mul continuous_const)).smul
+      (SchwartzMap.fourier_coe g ▸ (𝓕 g).continuous)).aestronglyMeasurable
+  · rw [Circle.norm_smul]
+
+/-- The Carleson integrand of `mHalf` at the frequency `2πN` is `2π J(N)`. -/
+theorem carlesonIntegrand_mHalf (g : 𝓢(ℝ, ℂ)) (x N : ℝ) :
+    ∫ w, fhat (schwartzToR1 g) w * Complex.exp (Complex.I * (⟪toR1 x, w⟫_ℝ : ℂ)) *
+      mHalf (w - toR1 (2 * π * N)) = (2 * π : ℂ) * cutoffIntegral g x N := by
+  rw [integral_toR1]
+  set h : ℝ → ℂ := fun ζ => fhat (schwartzToR1 g) (toR1 ζ) *
+    Complex.exp (Complex.I * (⟪toR1 x, toR1 ζ⟫_ℝ : ℂ)) * mHalf (toR1 ζ - toR1 (2 * π * N))
+  have hsub := Measure.integral_comp_mul_left h (2 * π)
+  have hpos : (0 : ℝ) < 2 * π := by positivity
+  rw [abs_of_pos (inv_pos.mpr hpos)] at hsub
+  have e : ∫ ζ, h ζ = (2 * π : ℂ) * ∫ ξ, h (2 * π * ξ) := by
+    rw [hsub, Complex.real_smul, ← mul_assoc]
+    push_cast
+    rw [mul_inv_cancel₀ (by exact_mod_cast hpos.ne'), one_mul]
+  rw [show (∫ ζ, fhat (schwartzToR1 g) (toR1 ζ) *
+      Complex.exp (Complex.I * (⟪toR1 x, toR1 ζ⟫_ℝ : ℂ)) * mHalf (toR1 ζ - toR1 (2 * π * N))) =
+      ∫ ζ, h ζ from rfl, e]
+  congr 1
+  unfold cutoffIntegral
+  congr 1; funext ξ
+  simp only [h]
+  rw [← map_sub, mHalf_toR1, fhat_schwartzToR1, inner_toR1, Set.indicator_apply]
+  by_cases hξ : N < ξ
+  · have h1 : 0 < 2 * π * ξ - 2 * π * N := by nlinarith
+    rw [ite_eq_left h1, ite_eq_left (Set.mem_Ioi.mpr hξ), mul_one,
+        Real.fourier_real_eq_integral_exp_smul,
+      Circle.smul_def, smul_eq_mul, Real.fourierChar_apply]
+    refine (mul_comm _ _).trans ?_
+    congr 1
+    · congr 1; push_cast; ring
+    · congr 1; funext y; rw [smul_eq_mul]; congr 2; push_cast; ring
+  · have h1 : ¬ 0 < 2 * π * ξ - 2 * π * N := by
+      intro h'; apply hξ; nlinarith
+    rw [ite_eq_right h1, ite_eq_right (fun h' => hξ (Set.mem_Ioi.mp h')), mul_zero]
+
+theorem enorm_cutoffIntegral_le (g : 𝓢(ℝ, ℂ)) (x N : ℝ) :
+    ‖cutoffIntegral g x N‖ₑ ≤ ENNReal.ofReal (2 * π)⁻¹ * carleson mHalf (schwartzToR1 g) (toR1
+        x) := by
+  have h := carlesonIntegrand_mHalf g x N
+  have hle : ‖(2 * π : ℂ) * cutoffIntegral g x N‖ₑ ≤ carleson mHalf (schwartzToR1 g) (toR1 x) := by
+    rw [← h]
+    exact le_iSup (fun N' => ‖∫ w, fhat (schwartzToR1 g) w *
+      Complex.exp (Complex.I * (⟪toR1 x, w⟫_ℝ : ℂ)) * mHalf (w - N')‖ₑ) (toR1 (2 * π * N))
+  have hpos : (0 : ℝ) < 2 * π := by positivity
+  rw [enorm_mul, show ‖(2 * π : ℂ)‖ₑ = ENNReal.ofReal (2 * π) by
+    rw [← ofReal_norm]; congr 1; simp [abs_of_pos Real.pi_pos]] at hle
+  calc ‖cutoffIntegral g x N‖ₑ = (ENNReal.ofReal (2 * π))⁻¹ *
+        (ENNReal.ofReal (2 * π) * ‖cutoffIntegral g x N‖ₑ) := by
+        rw [← mul_assoc, ENNReal.inv_mul_cancel (by simp [Real.pi_pos]) ENNReal.ofReal_ne_top,
+            one_mul]
+    _ ≤ _ := by
+        rw [ENNReal.ofReal_inv_of_pos hpos]
+        exact mul_le_mul' le_rfl hle
+
+/-- `|S_R g(x)| ≤ 𝒞_m G(x)` for Schwartz `g` (`G = g ∘ toR1⁻¹`, `m = 1_{(0,∞)}`). -/
+theorem enorm_partialFourierIntegral_le (g : 𝓢(ℝ, ℂ)) {R : ℝ} (hR : 0 ≤ R) (x : ℝ) :
+    ‖partialFourierIntegral g R x‖ₑ ≤ carleson mHalf (schwartzToR1 g) (toR1 x) := by
+  rw [← integral_fourier_eq_partialFourierIntegral g.integrable hR,
+    intervalIntegral.integral_of_le (by linarith), ← integral_indicator measurableSet_Ioc]
+  have hi := integrable_char_fourier g x
+  have e : (Set.Ioc (-R) R).indicator (fun ξ => 𝐞 (ξ * x) • 𝓕 (g : ℝ → ℂ) ξ) =
+      fun ξ => (Set.Ioi (-R)).indicator (fun ξ => 𝐞 (ξ * x) • 𝓕 (g : ℝ → ℂ) ξ) ξ -
+        (Set.Ioi R).indicator (fun ξ => 𝐞 (ξ * x) • 𝓕 (g : ℝ → ℂ) ξ) ξ := by
+    funext ξ
+    simp only [Set.indicator_apply, Set.mem_Ioc, Set.mem_Ioi]
+    by_cases h1 : -R < ξ <;> by_cases h2 : R < ξ <;> simp [h1, h2]; linarith
+  rw [e, integral_sub (hi.indicator measurableSet_Ioi) (hi.indicator measurableSet_Ioi)]
+  refine (enorm_sub_le).trans ?_
+  have h1 := enorm_cutoffIntegral_le g x (-R)
+  have h2 := enorm_cutoffIntegral_le g x R
+  unfold cutoffIntegral at h1 h2
+  refine (add_le_add h1 h2).trans ?_
+  rw [← add_mul, ← two_mul]
+  have h21 : 2 * ENNReal.ofReal (2 * π)⁻¹ ≤ 1 := by
+    rw [← ENNReal.ofReal_ofNat, ← ENNReal.ofReal_mul (by norm_num), ENNReal.ofReal_le_one,
+      inv_eq_one_div, mul_one_div, div_le_one (by positivity)]
+    nlinarith [Real.pi_gt_three]
+  calc 2 * ENNReal.ofReal (2 * π)⁻¹ * carleson mHalf (schwartzToR1 g) (toR1 x)
+      ≤ 1 * carleson mHalf (schwartzToR1 g) (toR1 x) := mul_le_mul' h21 le_rfl
+    _ = _ := one_mul _
+
+/-- The maximal partial Fourier integral of a Schwartz function satisfies the weak `(2,2)` bound. -/
+theorem partialFourier_weak_schwartz :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (g : 𝓢(ℝ, ℂ)) (t : ℝ), 0 < t →
+      volume {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal t < ‖partialFourierIntegral g R x‖ₑ} ≤
+        ENNReal.ofReal ((C * (eLpNorm (g : ℝ → ℂ) 2 volume).toReal / t) ^ 2) := by
+  obtain ⟨C, hC, h⟩ := carleson_mHalf_weak
+  refine ⟨C, hC, fun g t ht => ?_⟩
+  have hsub : {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal t < ‖partialFourierIntegral g R x‖ₑ} ⊆
+      toR1 ⁻¹' {y | ENNReal.ofReal t < carleson mHalf (schwartzToR1 g) y} := by
+    rintro x ⟨R, hR, hx⟩
+    exact lt_of_lt_of_le hx (enorm_partialFourierIntegral_le g hR x)
+  have hmp : MeasurePreserving (toR1.toHomeomorph.toMeasurableEquiv) volume volume :=
+    toR1.measurePreserving
+  have hvol := hmp.measure_preimage_equiv {y | ENNReal.ofReal t < carleson mHalf (schwartzToR1 g) y}
+  have hnorm : eLpNorm (schwartzToR1 g : Rn 1 → ℂ) 2 volume = eLpNorm (g : ℝ → ℂ) 2 volume := by
+    rw [coe_schwartzToR1]
+    exact eLpNorm_comp_measurePreserving g.continuous.aestronglyMeasurable
+      toR1.symm.measurePreserving
+  refine (measure_mono hsub).trans (le_of_eq_of_le hvol ?_)
+  have := h (schwartzToR1 g) t ht
+  rwa [hnorm] at this
+
+/-! ### Step 4: the partial Fourier integrals of `L²` functions -/
+
+theorem norm_dirichletKernel_le {R : ℝ} (hR : 0 ≤ R) (z : ℝ) :
+    ‖dirichletKernel R z‖ ≤ (4 * R + 2) * (1 + |z|)⁻¹ := by
+  have hz1 : 0 < 1 + |z| := by positivity
+  rw [← div_eq_mul_inv, le_div_iff₀ hz1]
+  unfold dirichletKernel
+  split_ifs with hz
+  · subst hz; simp [abs_of_nonneg hR]; linarith
+  · rw [Complex.norm_real, Real.norm_eq_abs, abs_div, abs_mul, abs_of_pos Real.pi_pos]
+    have hzp : 0 < |z| := abs_pos.mpr hz
+    rw [div_mul_eq_mul_div, div_le_iff₀ (by positivity)]
+    rcases le_or_gt |z| 1 with h1 | h1
+    · have hs : |Real.sin (2 * π * R * z)| ≤ 2 * π * R * |z| := by
+        have := Real.abs_sin_le_abs (x := 2 * π * R * z)
+        rwa [abs_mul, abs_of_nonneg (by positivity : (0 : ℝ) ≤ 2 * π * R)] at this
+      calc |Real.sin (2 * π * R * z)| * (1 + |z|) ≤ (2 * π * R * |z|) * 2 :=
+            mul_le_mul hs (by linarith) (by positivity) (by positivity)
+        _ ≤ (4 * R + 2) * (π * |z|) := by nlinarith [Real.pi_pos, abs_nonneg z]
+    · have hs := Real.abs_sin_le_one (2 * π * R * z)
+      calc |Real.sin (2 * π * R * z)| * (1 + |z|) ≤ 1 * (1 + |z|) :=
+            mul_le_mul_of_nonneg_right hs (by positivity)
+        _ ≤ 2 * (π * |z|) := by nlinarith [Real.pi_gt_three]
+        _ ≤ (4 * R + 2) * (π * |z|) := by
+            have : 0 ≤ π * |z| := by positivity
+            nlinarith
+
+theorem measurable_dirichletKernel (R : ℝ) : Measurable (dirichletKernel R) := by
+  unfold dirichletKernel
+  refine Measurable.ite (measurableSet_singleton 0) measurable_const ?_
+  exact Complex.measurable_ofReal.comp (by fun_prop)
+
+theorem memLp_dirichletKernel {R : ℝ} (hR : 0 ≤ R) (x : ℝ) :
+    MemLp (fun y => dirichletKernel R (x - y)) 2 volume := by
+  have hw : MemLp (fun y : ℝ => (1 + |x - y|)⁻¹) 2 volume := by
+    have hm : AEStronglyMeasurable (fun y : ℝ => (1 + |x - y|)⁻¹) volume :=
+      (by fun_prop : Measurable fun y : ℝ => (1 + |x - y|)⁻¹).aestronglyMeasurable
+    rw [memLp_two_iff_integrable_sq hm]
+    have h := (integrable_one_add_norm (E := ℝ) (μ := volume) (r := 2) (by
+        norm_num)).comp_sub_left x
+    refine h.congr (Filter.Eventually.of_forall fun y => ?_)
+    simp only [Real.norm_eq_abs]
+    rw [Real.rpow_neg (by positivity), inv_pow, Real.rpow_two]
+  refine (hw.const_mul (4 * R + 2)).of_le
+    ((measurable_dirichletKernel R).comp (measurable_const.sub measurable_id)).aestronglyMeasurable
+    (Filter.Eventually.of_forall fun y => ?_)
+  rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (by positivity : (0 : ℝ) ≤ 4 * R + 2),
+    abs_of_pos (by positivity : (0 : ℝ) < (1 + |x - y|)⁻¹)]
+  exact norm_dirichletKernel_le hR _
+
+theorem integrable_mul_dirichletKernel {f : ℝ → ℂ} (hf : MemLp f 2 volume) {R : ℝ} (hR : 0 ≤ R)
+    (x : ℝ) : Integrable fun y => f y * dirichletKernel R (x - y) :=
+  hf.integrable_mul (memLp_dirichletKernel hR x)
+
+theorem partialFourierIntegral_sub {f g : ℝ → ℂ} (hf : MemLp f 2 volume) (hg : MemLp g 2 volume)
+    {R : ℝ} (hR : 0 ≤ R) (x : ℝ) :
+    partialFourierIntegral (f - g) R x = partialFourierIntegral f R x - partialFourierIntegral g
+        R x := by
+  unfold partialFourierIntegral
+  rw [← integral_sub (integrable_mul_dirichletKernel hf hR x) (integrable_mul_dirichletKernel hg
+      hR x)]
+  congr 1; funext y; simp only [Pi.sub_apply]; ring
+
+/-- Cauchy–Schwarz for the pairing. -/
+theorem enorm_integral_mul_le {u v : ℝ → ℂ} (hu : MemLp u 2 volume) (hv : MemLp v 2 volume) :
+    ‖∫ y, u y * v y‖ₑ ≤ eLpNorm u 2 volume * eLpNorm v 2 volume := by
+  refine (enorm_integral_le_lintegral_enorm _).trans ?_
+  simp_rw [enorm_mul]
+  have h := ENNReal.lintegral_mul_le_Lp_mul_Lq volume Real.HolderConjugate.two_two
+    hu.aestronglyMeasurable.enorm hv.aestronglyMeasurable.enorm
+  rw [eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num) hu.aestronglyMeasurable,
+    eLpNorm_eq_lintegral_rpow_enorm_toReal (by norm_num) (by norm_num) hv.aestronglyMeasurable]
+  simpa using h
+
+/-- `S_R f(x)` depends continuously on `f ∈ L²`. -/
+theorem enorm_partialFourierIntegral_sub_le {f g : ℝ → ℂ} (hf : MemLp f 2 volume)
+    (hg : MemLp g 2 volume) {R : ℝ} (hR : 0 ≤ R) (x : ℝ) :
+    ‖partialFourierIntegral f R x - partialFourierIntegral g R x‖ₑ ≤
+      eLpNorm (f - g) 2 volume * eLpNorm (fun y => dirichletKernel R (x - y)) 2 volume := by
+  rw [← partialFourierIntegral_sub hf hg hR]
+  exact enorm_integral_mul_le (hf.sub hg) (memLp_dirichletKernel hR x)
+
+/-- Smooth compactly supported approximation of `L²` functions, as Schwartz functions. -/
+theorem exists_schwartz_eLpNorm_sub_le {f : ℝ → ℂ} (hf : MemLp f 2 volume) {ε : ℝ} (hε : 0 < ε) :
+    ∃ g : 𝓢(ℝ, ℂ), eLpNorm (f - (g : ℝ → ℂ)) 2 volume ≤ ENNReal.ofReal ε := by
+  obtain ⟨g, hg1, hg2, hg3⟩ := hf.exist_eLpNorm_sub_le (by norm_num) (by norm_num) hε
+  exact ⟨hg1.toSchwartzMap hg2, hg3⟩
+
+theorem toReal_eLpNorm_le_add {f g : ℝ → ℂ} (hf : MemLp f 2 volume) (hg : MemLp g 2 volume) :
+    (eLpNorm g 2 volume).toReal ≤ (eLpNorm f 2 volume).toReal + (eLpNorm (f - g) 2
+        volume).toReal := by
+  have h : eLpNorm g 2 volume ≤ eLpNorm f 2 volume + eLpNorm (f - g) 2 volume := by
+    have e : g = f - (f - g) := by abel
+    calc eLpNorm g 2 volume = eLpNorm (f - (f - g)) 2 volume := by rw [← e]
+      _ ≤ _ := eLpNorm_sub_le (by norm_num)
+  rw [← ENNReal.toReal_add hf.eLpNorm_ne_top (hf.sub hg).eLpNorm_ne_top]
+  exact ENNReal.toReal_mono (ENNReal.add_ne_top.mpr ⟨hf.eLpNorm_ne_top, (hf.sub
+      hg).eLpNorm_ne_top⟩) h
+
+/-- **The maximal partial Fourier integral is of weak type `(2,2)` on `L²(ℝ)`.** -/
+theorem partialFourier_weak :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (f : ℝ → ℂ), MemLp f 2 volume → ∀ (t : ℝ), 0 < t →
+      volume {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal t < ‖partialFourierIntegral f R x‖ₑ} ≤
+        ENNReal.ofReal ((C * (eLpNorm f 2 volume).toReal / t) ^ 2) := by
+  obtain ⟨C, hC, hS⟩ := partialFourier_weak_schwartz
+  refine ⟨C, hC, fun f hf t ht => ?_⟩
+  have happ : ∀ j : ℕ, ∃ g : 𝓢(ℝ, ℂ), eLpNorm (f - (g : ℝ → ℂ)) 2 volume ≤
+      ENNReal.ofReal (1 / ((j : ℝ) + 1)) := fun j => exists_schwartz_eLpNorm_sub_le hf (by
+          positivity)
+  choose g hg using happ
+  set B : ℕ → Set ℝ := fun j =>
+    {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal t < ‖partialFourierIntegral (g j) R x‖ₑ}
+  set bnd : ℕ → ℝ≥0∞ := fun j => ENNReal.ofReal ((C * ((eLpNorm f 2 volume).toReal +
+    1 / ((j : ℝ) + 1)) / t) ^ 2)
+  have hB : ∀ j, volume (B j) ≤ bnd j := by
+    intro j
+    refine (hS (g j) t ht).trans (ENNReal.ofReal_le_ofReal ?_)
+    refine pow_le_pow_left₀ (by positivity) (div_le_div_of_nonneg_right ?_ ht.le) 2
+    refine mul_le_mul_of_nonneg_left ?_ hC
+    refine (toReal_eLpNorm_le_add hf ((g j).memLp 2)).trans (add_le_add le_rfl ?_)
+    exact ENNReal.toReal_le_of_le_ofReal (by positivity) (hg j)
+  have hbnd : Tendsto bnd atTop (𝓝 (ENNReal.ofReal ((C * (eLpNorm f 2 volume).toReal / t) ^ 2)))
+      := by
+    refine ENNReal.tendsto_ofReal ?_
+    have h1 : Tendsto (fun j : ℕ => 1 / ((j : ℝ) + 1)) atTop (𝓝 0) :=
+        tendsto_one_div_add_atTop_nhds_zero_nat
+    have h2 := ((((h1.const_add ((eLpNorm f 2 volume).toReal)).const_mul C).div_const t).pow 2)
+    simpa using h2
+  -- the level set is in the lower limit of the `B j`
+  have hsub : {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal t < ‖partialFourierIntegral f R x‖ₑ} ⊆
+      ⋃ k, ⋂ j ∈ Set.Ici k, B j := by
+    rintro x ⟨R, hR, hx⟩
+    set K := eLpNorm (fun y => dirichletKernel R (x - y)) 2 volume
+    have hK : K ≠ ⊤ := (memLp_dirichletKernel hR x).eLpNorm_ne_top
+    have hconv : Tendsto (fun j => partialFourierIntegral (g j) R x) atTop
+        (𝓝 (partialFourierIntegral f R x)) := by
+      rw [tendsto_iff_norm_sub_tendsto_zero]
+      refine squeeze_zero (fun j => norm_nonneg _) (fun j => ?_)
+        ((tendsto_one_div_add_atTop_nhds_zero_nat.mul_const K.toReal).trans (by simp))
+      have h1 := enorm_partialFourierIntegral_sub_le ((g j).memLp 2) hf hR x
+      rw [← eLpNorm_neg, neg_sub] at h1
+      have h2 : ‖partialFourierIntegral (g j) R x - partialFourierIntegral f R x‖ₑ ≤
+          ENNReal.ofReal (1 / ((j : ℝ) + 1)) * K := h1.trans (mul_le_mul' (hg j) le_rfl)
+      rw [← ofReal_norm, ← ENNReal.ofReal_toReal hK, ← ENNReal.ofReal_mul (by positivity),
+        ENNReal.ofReal_le_ofReal_iff (by positivity)] at h2
+      exact h2
+    have hev := ((continuous_enorm.tendsto _).comp hconv).eventually (lt_mem_nhds hx)
+    obtain ⟨k, hk⟩ := Filter.eventually_atTop.mp hev
+    exact Set.mem_iUnion.mpr ⟨k, Set.mem_iInter₂.mpr fun j hj => ⟨R, hR, hk j hj⟩⟩
+  have hmono : Monotone fun k => ⋂ j ∈ Set.Ici k, B j := fun k l hkl =>
+    Set.biInter_subset_biInter_left fun j (hj : l ≤ j) => (show k ≤ j from hkl.trans hj)
+  refine (measure_mono hsub).trans ?_
+  rw [hmono.measure_iUnion]
+  refine iSup_le fun k => ?_
+  refine ge_of_tendsto hbnd (Filter.eventually_atTop.mpr ⟨k, fun j hj => ?_⟩)
+  exact (measure_mono (Set.biInter_subset_of_mem (show j ∈ Set.Ici k from hj))).trans (hB j)
+
+/-! ### Step 5: almost everywhere convergence on the real line -/
+
+theorem tendsto_partialFourierIntegral_schwartz (g : 𝓢(ℝ, ℂ)) (x : ℝ) :
+    Tendsto (fun R => partialFourierIntegral g R x) atTop (𝓝 (g x)) := by
+  have hi := integrable_char_fourier g x
+  have h1 := intervalIntegral_tendsto_integral hi tendsto_neg_atTop_atBot tendsto_id
+  have hinv : ∫ ξ, 𝐞 (ξ * x) • 𝓕 (g : ℝ → ℂ) ξ = g x := by
+    have := congrFun (Continuous.fourierInv_fourier_eq g.continuous g.integrable
+      (integrable_fourier_schwartz g)) x
+    rw [fourierInv_eq] at this
+    rw [← this]
+    congr 1; funext ξ
+    congr 2
+    simp [mul_comm]
+  rw [hinv] at h1
+  refine h1.congr' ?_
+  filter_upwards [Filter.eventually_ge_atTop 0] with R hR
+  exact integral_fourier_eq_partialFourierIntegral g.integrable hR x
+
+/-- The exceptional set for the precision `ε`. -/
+theorem volume_bad_eq_zero {f : ℝ → ℂ} (hf : MemLp f 2 volume) {ε : ℝ} (hε : 0 < ε) :
+    volume {x | ¬ ∀ᶠ R in atTop, ‖partialFourierIntegral f R x - f x‖ < ε} = 0 := by
+  obtain ⟨C, hC, hW⟩ := partialFourier_weak
+  set Bad := {x | ¬ ∀ᶠ R in atTop, ‖partialFourierIntegral f R x - f x‖ < ε}
+  set K : ℝ := (3 * C / ε) ^ 2 + (3 / ε) ^ 2
+  have hδ : ∀ δ : ℝ, 0 < δ → volume Bad ≤ ENNReal.ofReal (K * δ ^ 2) := by
+    intro δ hδ
+    obtain ⟨g, hg⟩ := exists_schwartz_eLpNorm_sub_le hf hδ
+    set h := f - (g : ℝ → ℂ)
+    have hh : MemLp h 2 volume := hf.sub (g.memLp 2)
+    have hsub : Bad ⊆ {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal (ε / 3) < ‖partialFourierIntegral h R x‖ₑ} ∪
+        {x | ENNReal.ofReal (ε / 3) ≤ ‖h x‖ₑ} := by
+      intro x hx
+      by_contra hcon
+      simp only [Set.mem_union, Set.mem_ofPred_eq, not_or, not_exists, not_and, not_lt] at hcon
+      obtain ⟨h1, h2⟩ := hcon
+      apply hx
+      have hg' := (tendsto_partialFourierIntegral_schwartz g x)
+      rw [tendsto_iff_norm_sub_tendsto_zero] at hg'
+      filter_upwards [hg'.eventually (gt_mem_nhds (by positivity : (0 : ℝ) < ε / 3)),
+        Filter.eventually_ge_atTop 0] with R hR hR0
+      have e : partialFourierIntegral f R x - f x = partialFourierIntegral h R x +
+          (partialFourierIntegral g R x - g x) - h x := by
+        rw [partialFourierIntegral_sub hf (g.memLp 2) hR0]
+        simp only [h, Pi.sub_apply]; ring
+      have n1 : ‖partialFourierIntegral h R x‖ ≤ ε / 3 := by
+        have := h1 R hR0
+        rwa [← ofReal_norm, ENNReal.ofReal_le_ofReal_iff (by positivity)] at this
+      have n2 : ‖h x‖ < ε / 3 := by
+        have := h2
+        rw [← ofReal_norm] at this
+        exact (ENNReal.ofReal_lt_ofReal_iff (by positivity)).mp (not_le.mp this)
+      rw [e]
+      calc ‖partialFourierIntegral h R x + (partialFourierIntegral g R x - g x) - h x‖
+          ≤ ‖partialFourierIntegral h R x‖ + ‖partialFourierIntegral g R x - g x‖ + ‖h x‖ :=
+            (norm_sub_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl)
+        _ < ε := by linarith
+    have hnorm : (eLpNorm h 2 volume).toReal ≤ δ := ENNReal.toReal_le_of_le_ofReal hδ.le hg
+    have b1 := hW h hh (ε / 3) (by positivity)
+    have b2 := meas_ge_le_mul_pow_eLpNorm_enorm volume (p := 2) (by norm_num) (by norm_num)
+      (f := h) (ε := ENNReal.ofReal (ε / 3)) (by simp [hε]) (by simp)
+    refine (measure_mono hsub).trans ((measure_union_le _ _).trans ?_)
+    have b2' : volume {x | ENNReal.ofReal (ε / 3) ≤ ‖h x‖ₑ} ≤ ENNReal.ofReal ((3 / ε) ^ 2 * δ ^
+        2) := by
+      refine b2.trans ?_
+      rw [ENNReal.toReal_ofNat, ENNReal.rpow_two, ENNReal.rpow_two,
+        ← ENNReal.ofReal_inv_of_pos (by positivity), ← ENNReal.ofReal_pow (by positivity),
+        ← ENNReal.ofReal_toReal hh.eLpNorm_ne_top, ← ENNReal.ofReal_pow ENNReal.toReal_nonneg,
+        ← ENNReal.ofReal_mul (by positivity)]
+      refine ENNReal.ofReal_le_ofReal ?_
+      rw [show (ε / 3)⁻¹ = 3 / ε by field_simp]
+      gcongr
+    have b1' : volume {x | ∃ R, 0 ≤ R ∧ ENNReal.ofReal (ε / 3) < ‖partialFourierIntegral h R x‖ₑ} ≤
+        ENNReal.ofReal ((3 * C / ε) ^ 2 * δ ^ 2) := by
+      refine b1.trans (ENNReal.ofReal_le_ofReal ?_)
+      rw [← mul_pow]
+      refine pow_le_pow_left₀ (by positivity) ?_ 2
+      rw [div_div_eq_mul_div, div_mul_eq_mul_div]
+      refine div_le_div_of_nonneg_right ?_ hε.le
+      nlinarith [ENNReal.toReal_nonneg (a := eLpNorm h 2 volume)]
+    refine (add_le_add b1' b2').trans (le_of_eq ?_)
+    rw [← ENNReal.ofReal_add (by positivity) (by positivity)]
+    congr 1; ring
+  have hlim : Tendsto (fun j : ℕ => ENNReal.ofReal (K * (1 / ((j : ℝ) + 1)) ^ 2)) atTop (𝓝 0) := by
+    rw [← ENNReal.ofReal_zero]
+    refine ENNReal.tendsto_ofReal ?_
+    have := (tendsto_one_div_add_atTop_nhds_zero_nat.pow 2).const_mul K
+    simpa using this
+  exact le_antisymm (ge_of_tendsto hlim (Filter.Eventually.of_forall fun j => hδ _ (by positivity)))
+    bot_le
+
+/-- **Carleson's theorem on the real line (kernel form)**: for `f ∈ L²(ℝ)`, the partial Fourier
+integrals `S_R f(x) = ∫ f(y) sin(2πR(x−y))/(π(x−y)) dy` converge to `f(x)` for almost every `x`. -/
+theorem carleson_real_line {f : ℝ → ℂ} (hf : MemLp f 2 volume) :
+    ∀ᵐ x, Tendsto (fun R => partialFourierIntegral f R x) atTop (𝓝 (f x)) := by
+  have h : ∀ k : ℕ, ∀ᵐ x, ∀ᶠ R in atTop,
+      ‖partialFourierIntegral f R x - f x‖ < 1 / ((k : ℝ) + 1) := by
+    intro k
+    rw [ae_iff]
+    exact volume_bad_eq_zero hf (by positivity)
+  rw [← ae_all_iff] at h
+  filter_upwards [h] with x hx
+  rw [tendsto_iff_norm_sub_tendsto_zero]
+  refine Metric.tendsto_nhds.mpr fun ε hε => ?_
+  obtain ⟨k, hk⟩ := exists_nat_one_div_lt hε
+  filter_upwards [hx k] with R hR
+  rw [dist_zero_right, norm_norm]
+  exact hR.trans hk
+
+/-- **Carleson's theorem on the real line (Fourier integral form)**: for integrable `f ∈ L²(ℝ)`,
+`∫_{-R}^{R} 𝓕f(ξ) e^{2πixξ} dξ → f(x)` as `R → ∞` for almost every `x`. -/
+theorem carleson_fourierIntegral {f : ℝ → ℂ} (hf1 : Integrable f) (hf : MemLp f 2 volume) :
+    ∀ᵐ x, Tendsto (fun R => ∫ ξ in -R..R, 𝐞 (ξ * x) • 𝓕 f ξ) atTop (𝓝 (f x)) := by
+  filter_upwards [carleson_real_line hf] with x hx
+  refine hx.congr' ?_
+  filter_upwards [Filter.eventually_ge_atTop 0] with R hR
+  exact (integral_fourier_eq_partialFourierIntegral hf1 hR x).symm
+
+/-! ### Step 6: the Dirichlet kernel of the circle -/
+
+/-- The Fourier coefficients `f̂(k) = ∫_0^1 f(y) e^{-2πiky} dy` of a `1`-periodic function. -/
+def fourierCoeff1 (f : ℝ → ℂ) (k : ℤ) : ℂ :=
+  ∫ y in (0 : ℝ)..1, Complex.exp (-(2 * π * Complex.I * k * y)) * f y
+
+/-- The symmetric partial sums `S_N f(x) = ∑_{|k| ≤ N} f̂(k) e^{2πikx}` of the Fourier series. -/
+def fourierPartialSum1 (f : ℝ → ℂ) (N : ℕ) (x : ℝ) : ℂ :=
+  ∑ k ∈ Finset.Icc (-(N : ℤ)) N, fourierCoeff1 f k * Complex.exp (2 * π * Complex.I * k * x)
+
+/-- The Dirichlet kernel `D_N(z) = ∑_{|k| ≤ N} e^{2πikz}`. -/
+def dirichletPer (N : ℕ) (z : ℝ) : ℂ :=
+  ∑ k ∈ Finset.Icc (-(N : ℤ)) N, Complex.exp (2 * π * Complex.I * k * z)
+
+theorem Icc_succ_eq (N : ℕ) : Finset.Icc (-((N + 1 : ℕ) : ℤ)) ((N + 1 : ℕ) : ℤ) =
+    insert (-((N + 1 : ℕ) : ℤ)) (insert ((N + 1 : ℕ) : ℤ) (Finset.Icc (-(N : ℤ)) N)) := by
+  ext k; simp only [Finset.mem_Icc, Finset.mem_insert]; push_cast; omega
+
+theorem zpow_sum_mul (w : ℂ) (hw : w ≠ 0) (N : ℕ) :
+    (∑ k ∈ Finset.Icc (-(N : ℤ)) N, w ^ (2 * k)) * (w - w⁻¹) =
+      w ^ (2 * (N : ℤ) + 1) - w ^ (-(2 * (N : ℤ) + 1)) := by
+  induction N with
+  | zero => simp [zpow_neg]
+  | succ N ih =>
+    rw [Icc_succ_eq, Finset.sum_insert (by simp; omega), Finset.sum_insert (by simp),
+      add_mul, add_mul, ih]
+    push_cast
+    have e1 : w ^ (2 * -((N : ℤ) + 1)) = w ^ (-(2 * (N : ℤ) + 1)) * w⁻¹ := by
+      rw [← zpow_neg_one, ← zpow_add₀ hw]; ring_nf
+    have e2 : w ^ (2 * ((N : ℤ) + 1)) = w ^ (2 * (N : ℤ) + 1) * w := by
+      rw [← zpow_add_one₀ hw]; ring_nf
+    have e3 : w ^ (2 * ((N : ℤ) + 1) + 1) = w ^ (2 * (N : ℤ) + 1) * w * w := by
+      rw [zpow_add_one₀ hw, e2]
+    have e4 : w ^ (-(2 * ((N : ℤ) + 1) + 1)) = w ^ (-(2 * (N : ℤ) + 1)) * w⁻¹ * w⁻¹ := by
+      rw [← zpow_neg_one, ← zpow_add₀ hw, ← zpow_add₀ hw]; ring_nf
+    rw [e1, e2, e3, e4]
+    field_simp
+    ring
+
+/-- `D_N(z) sin(πz) = sin((2N+1)πz)`. -/
+theorem dirichletPer_mul_sin (N : ℕ) (z : ℝ) :
+    dirichletPer N z * (Real.sin (π * z) : ℂ) = (Real.sin ((2 * N + 1) * π * z) : ℂ) := by
+  set w := Complex.exp (π * Complex.I * z)
+  have hw : w ≠ 0 := Complex.exp_ne_zero _
+  have hk : ∀ k : ℤ, Complex.exp (2 * π * Complex.I * k * z) = w ^ (2 * k) := by
+    intro k
+    rw [← Complex.exp_int_mul]; congr 1; push_cast; ring
+  have hw1 : Complex.exp (↑(π * z) * Complex.I) = w := by simp only [w]; congr 1; push_cast; ring
+  have hw2 : Complex.exp (-↑(π * z) * Complex.I) = w⁻¹ := by
+    simp only [w]; rw [← Complex.exp_neg]; congr 1; push_cast; ring
+  have hw3 : Complex.exp (↑((2 * N + 1) * π * z) * Complex.I) = w ^ (2 * (N : ℤ) + 1) := by
+    simp only [w]; rw [← Complex.exp_int_mul]; congr 1; push_cast; ring
+  have hw4 : Complex.exp (-↑((2 * N + 1) * π * z) * Complex.I) = w ^ (-(2 * (N : ℤ) + 1)) := by
+    simp only [w]; rw [← Complex.exp_int_mul]; congr 1; push_cast; ring
+  unfold dirichletPer
+  simp_rw [hk]
+  rw [Complex.ofReal_sin, Complex.ofReal_sin, Complex.sin, Complex.sin, hw1, hw2, hw3, hw4]
+  linear_combination (-(Complex.I / 2)) * zpow_sum_mul w hw N
+
+/-- The correction `φ(z) = 1/sin(πz) − 1/(πz)` (with `φ(0) = 0`). -/
+def corrPhi (z : ℝ) : ℝ := if z = 0 then 0 else 1 / Real.sin (π * z) - 1 / (π * z)
+
+theorem corr_bound_pos {u : ℝ} (hu : 0 < u) (hu' : u ≤ π / 2) :
+    0 ≤ 1 / Real.sin u - 1 / u ∧ 1 / Real.sin u - 1 / u ≤ 1 := by
+  have hs : 0 < Real.sin u := Real.sin_pos_of_pos_of_lt_pi hu (by linarith [Real.pi_pos])
+  have hsu : Real.sin u ≤ u := Real.sin_le hu.le
+  have hj : 2 / π * u ≤ Real.sin u := Real.mul_le_sin hu.le hu'
+  have hc : u - u ^ 3 / 6 < Real.sin u := Real.sin_gt_sub_cube hu
+  have hπ := Real.pi_gt_three
+  have hπ' := Real.pi_lt_four
+  rw [div_sub_div _ _ hs.ne' hu.ne']
+  constructor
+  · apply div_nonneg <;> nlinarith
+  · rw [div_le_one (by positivity)]
+    have h1 : u * (2 / π * u) ≤ u * Real.sin u := mul_le_mul_of_nonneg_left hj hu.le
+    have h2 : u ^ 3 / 6 ≤ u * (2 / π * u) := by
+      rw [show u * (2 / π * u) = u ^ 2 * (2 / π) by ring]
+      have : u ≤ 12 / π := by
+        rw [le_div_iff₀ (by positivity)]; nlinarith
+      have h3 : u / 6 ≤ 2 / π := by
+        rw [div_le_div_iff₀ (by norm_num) (by positivity)]
+        rw [le_div_iff₀ (by positivity)] at this; linarith
+      nlinarith [sq_nonneg u]
+    nlinarith
+
+theorem abs_corrPhi_le {z : ℝ} (hz : |z| ≤ 1 / 2) : |corrPhi z| ≤ 1 := by
+  unfold corrPhi
+  split_ifs with h0
+  · simp
+  · rcases lt_or_gt_of_ne h0 with hneg | hpos
+    · have h := corr_bound_pos (u := π * -z) (by nlinarith [Real.pi_pos])
+        (by rw [abs_of_neg hneg] at hz; nlinarith [Real.pi_pos])
+      have e : 1 / Real.sin (π * z) - 1 / (π * z) = -(1 / Real.sin (π * -z) - 1 / (π * -z)) := by
+        rw [mul_neg, Real.sin_neg]; ring
+      rw [e, abs_neg, abs_of_nonneg h.1]; exact h.2
+    · have h := corr_bound_pos (u := π * z) (by positivity)
+        (by rw [abs_of_pos hpos] at hz; nlinarith [Real.pi_pos])
+      rw [abs_of_nonneg h.1]; exact h.2
+
+/-- `ψ = φ` on `[−1/2, 1/2)` and `−1/(πz)` outside. -/
+def corrPsi (z : ℝ) : ℝ := if z ∈ Set.Ico (-1 / 2 : ℝ) (1 / 2) then corrPhi z else -(1 / (π * z))
+
+theorem abs_corrPsi_le (z : ℝ) : |corrPsi z| ≤ 1 := by
+  unfold corrPsi
+  split_ifs with h
+  · exact abs_corrPhi_le (abs_le.mpr ⟨by linarith [h.1], h.2.le⟩)
+  · have hz : 1 / 2 ≤ |z| := by
+      simp only [Set.mem_Ico, not_and_or, not_le, not_lt] at h
+      rcases h with h | h
+      · rw [abs_of_neg (by linarith)]; linarith
+      · rw [abs_of_pos (by linarith)]; linarith
+    rw [abs_neg, abs_div, abs_one, abs_mul, abs_of_pos Real.pi_pos, div_le_one (by positivity)]
+    nlinarith [Real.pi_gt_three]
+
+theorem measurable_corrPsi : Measurable corrPsi := by
+  unfold corrPsi corrPhi
+  refine Measurable.ite measurableSet_Ico ?_ (by fun_prop)
+  exact Measurable.ite (measurableSet_singleton 0) measurable_const (by fun_prop)
+
+theorem dirichletPer_zero (N : ℕ) : dirichletPer N 0 = 2 * N + 1 := by
+  unfold dirichletPer
+  simp only [Complex.ofReal_zero, mul_zero, Complex.exp_zero, Finset.sum_const, Int.card_Icc,
+    nsmul_eq_mul, mul_one]
+  rw [show ((N : ℤ) + 1 - -(N : ℤ)) = ((2 * N + 1 : ℕ) : ℤ) by push_cast; ring, Int.toNat_natCast]
+  push_cast; ring
+
+/-- The kernel comparison: `1_{[−1/2,1/2)} D_N = D_{N+1/2} + ψ · sin((2N+1)π ·)`. -/
+theorem indicator_dirichletPer_eq (N : ℕ) (z : ℝ) :
+    (Set.Ico (-1 / 2 : ℝ) (1 / 2)).indicator (dirichletPer N) z =
+      dirichletKernel (N + 1 / 2) z + (corrPsi z : ℂ) * (Real.sin ((2 * N + 1) * π * z) : ℂ) := by
+  by_cases hz : z ∈ Set.Ico (-1 / 2 : ℝ) (1 / 2)
+  · rw [Set.indicator_of_mem hz]
+    simp only [corrPsi, ite_eq_left hz, corrPhi]
+    by_cases h0 : z = 0
+    · subst h0
+      simp [dirichletPer_zero, dirichletKernel]; ring
+    · rw [ite_eq_right h0]
+      have hs : Real.sin (π * z) ≠ 0 := by
+        have habs : |π * z| ≤ π / 2 := by
+          rw [abs_mul, abs_of_pos Real.pi_pos]
+          have : |z| ≤ 1 / 2 := abs_le.mpr ⟨by linarith [hz.1], hz.2.le⟩
+          nlinarith [Real.pi_pos]
+        intro h
+        rw [Real.sin_eq_zero_iff_of_lt_of_lt (by
+          rw [abs_le] at habs; linarith [Real.pi_pos]) (by
+          rw [abs_le] at habs; linarith [Real.pi_pos])] at h
+        exact h0 (by
+          rcases mul_eq_zero.mp h with h | h
+          · exact absurd h Real.pi_ne_zero
+          · exact h)
+      have hD := dirichletPer_mul_sin N z
+      have hsC : (Real.sin (π * z) : ℂ) ≠ 0 := by exact_mod_cast hs
+      have hDz : dirichletPer N z = (Real.sin ((2 * N + 1) * π * z) : ℂ) / (Real.sin (π * z) :
+          ℂ) := by
+        rw [eq_div_iff hsC, hD]
+      rw [hDz]
+      unfold dirichletKernel
+      rw [ite_eq_right h0, show (2 * π * ((N : ℝ) + 1 / 2) * z : ℝ) = (2 * N + 1) * π * z by ring]
+      generalize Real.sin ((2 * N + 1) * π * z) = a at *
+      generalize Real.sin (π * z) = b at *
+      have hπz : (π : ℂ) * z ≠ 0 := by exact_mod_cast mul_ne_zero Real.pi_ne_zero h0
+      push_cast
+      field_simp
+      ring
+  · rw [Set.indicator_of_notMem hz]
+    have h0 : z ≠ 0 := by rintro rfl; exact hz ⟨by norm_num, by norm_num⟩
+    simp only [corrPsi, ite_eq_right hz, dirichletKernel, ite_eq_right h0]
+    rw [show (2 * π * ((N : ℝ) + 1 / 2) * z : ℝ) = (2 * N + 1) * π * z by ring]
+    generalize Real.sin ((2 * N + 1) * π * z) = a
+    push_cast
+    have hπz : (π : ℂ) * z ≠ 0 := by exact_mod_cast mul_ne_zero Real.pi_ne_zero h0
+    field_simp
+    ring
+
+/-! ### Step 7: localization -/
+
+/-- The window `F_a = 1_{(a−1, a+2]} f`. -/
+def window (f : ℝ → ℂ) (a : ℤ) : ℝ → ℂ := (Set.Ioc ((a : ℝ) - 1) (a + 2)).indicator f
+
+theorem memLp_Ioc_shift {f : ℝ → ℂ} (hper : Function.Periodic f 1)
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) (k : ℤ) :
+    MemLp ((Set.Ioc (k : ℝ) (k + 1)).indicator f) 2 volume := by
+  have h0 : MemLp ((Set.Ioc (0 : ℝ) 1).indicator f) 2 volume :=
+    (memLp_indicator_iff_restrict measurableSet_Ioc).mpr hf
+  have h1 := h0.comp_measurePreserving (measurePreserving_sub_right volume (k : ℝ))
+  refine h1.ae_eq (Filter.Eventually.of_forall fun x => ?_)
+  simp only [Function.comp, Set.indicator_apply, Set.mem_Ioc]
+  have hfx : f (x - k) = f x := by
+    have := hper.sub_int_mul_eq (n := k) (x := x)
+    simpa using this
+  by_cases h : k < x ∧ x ≤ k + 1
+  · rw [ite_eq_left ⟨by linarith [h.1], by linarith [h.2]⟩, ite_eq_left h, hfx]
+  · rw [ite_eq_right (fun h' => h ⟨by linarith [h'.1], by linarith [h'.2]⟩), ite_eq_right h]
+
+theorem memLp_window {f : ℝ → ℂ} (hper : Function.Periodic f 1)
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) (a : ℤ) : MemLp (window f a) 2 volume := by
+  have hA : MemLp ((Set.Ioc ((a : ℝ) - 1) a).indicator f) 2 volume := by
+    have := memLp_Ioc_shift hper hf (a - 1)
+    push_cast at this; rwa [sub_add_cancel] at this
+  have hB := memLp_Ioc_shift hper hf a
+  have hC : MemLp ((Set.Ioc ((a : ℝ) + 1) (a + 2)).indicator f) 2 volume := by
+    have := memLp_Ioc_shift hper hf (a + 1)
+    push_cast at this; rwa [add_assoc, one_add_one_eq_two] at this
+  have e1 : Set.Ioc ((a : ℝ) - 1) (a + 2) = Set.Ioc ((a : ℝ) - 1) (a + 1) ∪ Set.Ioc ((a : ℝ) +
+      1) (a + 2) :=
+    (Set.Ioc_union_Ioc_eq_Ioc (by linarith) (by linarith)).symm
+  have e2 : Set.Ioc ((a : ℝ) - 1) (a + 1) = Set.Ioc ((a : ℝ) - 1) a ∪ Set.Ioc (a : ℝ) (a + 1) :=
+    (Set.Ioc_union_Ioc_eq_Ioc (by linarith) (by linarith)).symm
+  unfold window
+  rw [e1, Set.indicator_union_of_disjoint (Set.Ioc_disjoint_Ioc_of_le le_rfl), e2,
+    Set.indicator_union_of_disjoint (Set.Ioc_disjoint_Ioc_of_le le_rfl)]
+  exact (hA.add hB).add hC
+
+theorem integrable_window {f : ℝ → ℂ} (hper : Function.Periodic f 1)
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) (a : ℤ) : Integrable (window f a) := by
+  have h := (memLp_indicator_iff_restrict (measurableSet_Ioc (a := (a : ℝ) - 1) (b := a + 2))).mp
+    (memLp_window hper hf a)
+  have : IsFiniteMeasure (volume.restrict (Set.Ioc ((a : ℝ) - 1) (a + 2))) :=
+    ⟨by simp⟩
+  exact (integrable_indicator_iff measurableSet_Ioc).mpr (h.integrable (by norm_num))
+
+theorem dirichletPer_sub_one (N : ℕ) (z : ℝ) : dirichletPer N (z - 1) = dirichletPer N z := by
+  unfold dirichletPer
+  refine Finset.sum_congr rfl fun k _ => ?_
+  have : Complex.exp (2 * π * Complex.I * k * ↑(z - 1)) =
+      Complex.exp (2 * π * Complex.I * k * z) * Complex.exp (-(k * (2 * π * Complex.I))) := by
+    rw [← Complex.exp_add]; congr 1; push_cast; ring
+  rw [this, Complex.exp_neg, Complex.exp_int_mul_two_pi_mul_I, inv_one, mul_one]
+
+theorem intervalIntegrable_mul_dirichletPer {f : ℝ → ℂ}
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) (N : ℕ) (x : ℝ) :
+    IntervalIntegrable (fun y => f y * dirichletPer N (x - y)) volume 0 1 := by
+  have : IsFiniteMeasure (volume.restrict (Set.Ioc (0 : ℝ) 1)) := ⟨by simp⟩
+  have hi : IntervalIntegrable f volume 0 1 :=
+    (intervalIntegrable_iff_integrableOn_Ioc_of_le zero_le_one).mpr (hf.integrable (by norm_num))
+  refine hi.mul_continuousOn ?_
+  unfold dirichletPer
+  exact (continuous_finsetSum _ fun k _ => by fun_prop).continuousOn
+
+/-- `S_N f(x) = ∫_0^1 f(y) D_N(x − y) dy`. -/
+theorem fourierPartialSum1_eq {f : ℝ → ℂ} (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1)))
+    (N : ℕ) (x : ℝ) : fourierPartialSum1 f N x = ∫ y in (0 : ℝ)..1, f y * dirichletPer N (x - y)
+        := by
+  unfold fourierPartialSum1 fourierCoeff1 dirichletPer
+  simp_rw [Finset.mul_sum]
+  have : IsFiniteMeasure (volume.restrict (Set.Ioc (0 : ℝ) 1)) := ⟨by simp⟩
+  have hi : IntervalIntegrable f volume 0 1 :=
+    (intervalIntegrable_iff_integrableOn_Ioc_of_le zero_le_one).mpr (hf.integrable (by norm_num))
+  rw [intervalIntegral.integral_finsetSum (fun k _ => hi.mul_continuousOn (by fun_prop))]
+  refine Finset.sum_congr rfl fun k _ => ?_
+  rw [← intervalIntegral.integral_mul_const]
+  congr 1; funext y
+  rw [mul_comm (Complex.exp _) (f y), mul_assoc, ← Complex.exp_add]
+  congr 2; push_cast; ring
+
+/-- Localization: on the window around `x ∈ (a, a+1)`,
+`S_N f(x) = S_{N+1/2} F_a(x) + ∫ F_a(y) ψ(x−y) sin((2N+1)π(x−y)) dy`. -/
+theorem fourierPartialSum1_eq_local {f : ℝ → ℂ} (hper : Function.Periodic f 1)
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) (a : ℤ) {x : ℝ}
+    (hx : x ∈ Set.Ioo (a : ℝ) (a + 1)) (N : ℕ) :
+    fourierPartialSum1 f N x = partialFourierIntegral (window f a) (N + 1 / 2) x +
+      ∫ y, window f a y * ((corrPsi (x - y) : ℂ) * (Real.sin ((2 * N + 1) * π * (x - y)) : ℂ)) := by
+  rw [fourierPartialSum1_eq hf]
+  have hperφ : Function.Periodic (fun y => f y * dirichletPer N (x - y)) 1 := by
+    intro y
+    simp only
+    rw [hper y, show x - (y + 1) = x - y - 1 by ring, dirichletPer_sub_one]
+  have h1 := hperφ.intervalIntegral_add_eq 0 (x - 1 / 2)
+  rw [zero_add] at h1
+  rw [h1, intervalIntegral.integral_of_le (by linarith), ← integral_indicator measurableSet_Ioc]
+  have hpt : ∀ y, (Set.Ioc (x - 1 / 2) (x - 1 / 2 + 1)).indicator
+      (fun y => f y * dirichletPer N (x - y)) y =
+      window f a y * dirichletKernel (N + 1 / 2) (x - y) +
+        window f a y * ((corrPsi (x - y) : ℂ) * (Real.sin ((2 * N + 1) * π * (x - y)) : ℂ)) := by
+    intro y
+    rw [← mul_add, ← indicator_dirichletPer_eq]
+    simp only [window, Set.indicator_apply, Set.mem_Ioc, Set.mem_Ico]
+    by_cases hy : x - 1 / 2 < y ∧ y ≤ x - 1 / 2 + 1
+    · have hw : (a : ℝ) - 1 < y ∧ y ≤ a + 2 := ⟨by linarith [hx.1, hy.1], by linarith [hx.2, hy.2]⟩
+      rw [ite_eq_left hy, ite_eq_left hw, ite_eq_left ⟨by linarith [hy.2], by linarith [hy.1]⟩]
+    · rw [ite_eq_right hy, ite_eq_right (show ¬(-1 / 2 ≤ x - y ∧ x - y < 1 / 2) from
+        fun h => hy ⟨by linarith [h.2], by linarith [h.1]⟩), mul_zero]
+  simp_rw [hpt]
+  have hint2 : Integrable fun y => window f a y *
+      ((corrPsi (x - y) : ℂ) * (Real.sin ((2 * N + 1) * π * (x - y)) : ℂ)) := by
+    refine (integrable_window hper hf a).mul_bdd (c := 1) ?_ (Filter.Eventually.of_forall fun y
+        => ?_)
+    · exact ((Complex.measurable_ofReal.comp (measurable_corrPsi.comp
+        (measurable_const.sub measurable_id))).mul (by fun_prop)).aestronglyMeasurable
+    · rw [norm_mul, Complex.norm_real, Complex.norm_real, Real.norm_eq_abs, Real.norm_eq_abs]
+      exact (mul_le_mul (abs_corrPsi_le _) (Real.abs_sin_le_one _) (abs_nonneg _) zero_le_one).trans
+        (by norm_num)
+  rw [integral_add (integrable_mul_dirichletKernel (memLp_window hper hf a) (by positivity) x)
+      hint2]
+  rfl
+
+/-- Riemann–Lebesgue: `∫ H(y) sin((2N+1)π(x−y)) dy → 0`. -/
+theorem tendsto_integral_mul_sin {H : ℝ → ℂ} (hH : Integrable H) (x : ℝ) :
+    Tendsto (fun N : ℕ => ∫ y, H y * (Real.sin ((2 * N + 1) * π * (x - y)) : ℂ)) atTop (𝓝 0) := by
+  set A : ℝ → ℂ := fun w => ∫ y, 𝐞 (-(y * w)) • H y
+  have hRL : Tendsto A (Filter.cocompact ℝ) (𝓝 0) := Real.tendsto_integral_exp_smul_cocompact H
+  have hw : Tendsto (fun N : ℕ => (N : ℝ) + 1 / 2) atTop atTop :=
+    tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds
+  have h1 : Tendsto (fun N : ℕ => A ((N : ℝ) + 1 / 2)) atTop (𝓝 0) :=
+    hRL.comp (hw.mono_right atTop_le_cocompact)
+  have h2 : Tendsto (fun N : ℕ => A (-((N : ℝ) + 1 / 2))) atTop (𝓝 0) :=
+    hRL.comp ((tendsto_neg_atTop_atBot.comp hw).mono_right atBot_le_cocompact)
+  have hchar : ∀ w, Integrable fun y => 𝐞 (-(y * w)) • H y := fun w =>
+    hH.norm.mono' ((by fun_prop : Continuous fun y : ℝ => 𝐞 (-(y * w))).aestronglyMeasurable.smul
+      hH.aestronglyMeasurable) (Filter.Eventually.of_forall fun y => by rw [Circle.norm_smul])
+  have key : ∀ N : ℕ, ∫ y, H y * (Real.sin ((2 * N + 1) * π * (x - y)) : ℂ) =
+      Complex.I / 2 * (Complex.exp (-(↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I)) *
+          A (-((N : ℝ) + 1 / 2)) -
+        Complex.exp (↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I) * A ((N : ℝ) + 1 / 2)) := by
+    intro N
+    simp only [A]
+    rw [← integral_const_mul, ← integral_const_mul, ← integral_sub
+      ((hchar _).const_mul _) ((hchar _).const_mul _), ← integral_const_mul]
+    congr 1; funext y
+    rw [Complex.ofReal_sin, Complex.sin, Circle.smul_def, Circle.smul_def, smul_eq_mul, smul_eq_mul,
+      Real.fourierChar_apply, Real.fourierChar_apply]
+    have e1 : Complex.exp (-↑((2 * N + 1) * π * (x - y)) * Complex.I) =
+        Complex.exp (-(↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I)) *
+          Complex.exp (↑(2 * π * -(y * -((N : ℝ) + 1 / 2))) * Complex.I) := by
+      rw [← Complex.exp_add]; congr 1; push_cast; ring
+    have e2 : Complex.exp (↑((2 * N + 1) * π * (x - y)) * Complex.I) =
+        Complex.exp (↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I) *
+          Complex.exp (↑(2 * π * -(y * ((N : ℝ) + 1 / 2))) * Complex.I) := by
+      rw [← Complex.exp_add]; congr 1; push_cast; ring
+    rw [e1, e2]
+    ring
+  simp_rw [key]
+  refine squeeze_zero_norm (fun N => ?_) ((h2.norm.add h1.norm).trans (by simp))
+  have ha : ‖Complex.exp (-(↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I))‖ = 1 := by
+    rw [show -(↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I) =
+      ↑(-(2 * π * ((N : ℝ) + 1 / 2) * x)) * Complex.I by push_cast; ring,
+      Complex.norm_exp_ofReal_mul_I]
+  have hb : ‖Complex.exp (↑(2 * π * ((N : ℝ) + 1 / 2) * x) * Complex.I)‖ = 1 :=
+    Complex.norm_exp_ofReal_mul_I _
+  have hI : ‖Complex.I / 2‖ ≤ 1 := by simp; norm_num
+  rw [norm_mul]
+  refine (mul_le_of_le_one_left (norm_nonneg _) hI).trans ?_
+  refine (norm_sub_le _ _).trans (le_of_eq ?_)
+  rw [norm_mul, norm_mul, ha, hb, one_mul, one_mul]
+
+/-- **Carleson's theorem** (1966): for a `1`-periodic `f : ℝ → ℂ` that is square integrable on a
+period (`MemLp f 2` on `(0,1]`), the symmetric partial sums `∑_{|k|≤N} f̂(k) e^{2πikx}` of its
+    Fourier
+series converge to `f(x)` for almost every `x ∈ ℝ`. -/
+theorem carleson_fourierSeries {f : ℝ → ℂ} (hper : Function.Periodic f 1)
+    (hf : MemLp f 2 (volume.restrict (Set.Ioc 0 1))) :
+    ∀ᵐ x, Tendsto (fun N => fourierPartialSum1 f N x) atTop (𝓝 (f x)) := by
+  have hA : ∀ a : ℤ, ∀ᵐ x, Tendsto (fun R => partialFourierIntegral (window f a) R x) atTop
+      (𝓝 (window f a x)) := fun a => carleson_real_line (memLp_window hper hf a)
+  rw [← ae_all_iff] at hA
+  have hZ : ∀ᵐ x : ℝ, x ∉ Set.range (Int.cast : ℤ → ℝ) := (Set.countable_range _).ae_notMem volume
+  filter_upwards [hA, hZ] with x hx hxZ
+  set a := ⌊x⌋
+  have hax : (a : ℝ) < x := lt_of_le_of_ne (Int.floor_le x) (fun h => hxZ ⟨a, h⟩)
+  have hxa : x ∈ Set.Ioo (a : ℝ) (a + 1) := ⟨hax, Int.lt_floor_add_one x⟩
+  have hwin : window f a x = f x :=
+    Set.indicator_of_mem (show x ∈ Set.Ioc ((a : ℝ) - 1) (a + 2) from
+      ⟨by linarith [hxa.1], by linarith [hxa.2]⟩) f
+  have hR : Tendsto (fun N : ℕ => (N : ℝ) + 1 / 2) atTop atTop :=
+    tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds
+  have h1 := (hx a).comp hR
+  rw [hwin] at h1
+  set H : ℝ → ℂ := fun y => window f a y * (corrPsi (x - y) : ℂ)
+  have hH : Integrable H := by
+    refine (integrable_window hper hf a).mul_bdd (c := 1) ?_ (Filter.Eventually.of_forall fun y
+        => ?_)
+    · exact (Complex.measurable_ofReal.comp (measurable_corrPsi.comp
+        (measurable_const.sub measurable_id))).aestronglyMeasurable
+    · rw [Complex.norm_real, Real.norm_eq_abs]; exact abs_corrPsi_le _
+  have h2 := tendsto_integral_mul_sin hH x
+  have h3 := h1.add h2
+  rw [add_zero] at h3
+  refine h3.congr fun N => ?_
+  rw [fourierPartialSum1_eq_local hper hf a hxa N]
+  simp only [Function.comp, H, mul_assoc]
+
+/-! ### Carleson's theorem for `2π`-periodic functions (Mathlib's Fourier coefficients) -/
+
+theorem memLp_comp_mul_left {φ : ℝ → ℂ} (hφ : MemLp φ 2 volume) {c : ℝ} (hc : c ≠ 0) :
+    MemLp (fun x => φ (c * x)) 2 volume := by
+  have h1 : MemLp φ 2 (Measure.map (c * ·) volume) := by
+    rw [Real.map_volume_mul_left hc]; exact hφ.smul_measure ENNReal.ofReal_ne_top
+  exact (memLp_map_measure_iff h1.aestronglyMeasurable
+    (measurable_const_mul c).aemeasurable).mp h1
+
+/-- The rescaling `t ↦ f(2πt)` of `f ∈ L²[0, 2π)` is square integrable on `(0, 1]`. -/
+theorem memLp_rescale {f : ℝ → ℂ} (hf : MemLp f 2 (volume.restrict (Set.Ico 0 (2 * π)))) :
+    MemLp (fun t => f (2 * π * t)) 2 (volume.restrict (Set.Ioc 0 1)) := by
+  have hπ : (0 : ℝ) < 2 * π := by positivity
+  have h0 : MemLp ((Set.Ico 0 (2 * π)).indicator f) 2 volume :=
+    (memLp_indicator_iff_restrict measurableSet_Ico).mpr hf
+  have hG : MemLp ((Set.Ico (0 : ℝ) 1).indicator fun t => f (2 * π * t)) 2 volume := by
+    refine (memLp_comp_mul_left h0 hπ.ne').ae_eq (Eventually.of_forall fun t => ?_)
+    have e1 : 0 ≤ 2 * π * t ↔ 0 ≤ t := by
+      constructor <;> intro h <;> nlinarith [Real.pi_pos]
+    have e2 : 2 * π * t < 2 * π ↔ t < 1 := by
+      constructor <;> intro h <;> nlinarith [Real.pi_pos]
+    simp only [Set.indicator_apply, Set.mem_Ico, e1, e2]
+  rw [← Measure.restrict_congr_set Ico_ae_eq_Ioc]
+  exact (memLp_indicator_iff_restrict measurableSet_Ico).mp hG
+
+/-- Mathlib's Fourier coefficients on `[0, 2π]` are those of the rescaled function. -/
+theorem fourierCoeffOn_eq_fourierCoeff1 (f : ℝ → ℂ) (n : ℤ) :
+    fourierCoeffOn Real.two_pi_pos f n = fourierCoeff1 (fun t => f (2 * π * t)) n := by
+  have hπ : (2 * π : ℝ) ≠ 0 := by positivity
+  have hπC : (2 * π : ℂ) ≠ 0 := by exact_mod_cast hπ
+  rw [fourierCoeffOn_eq_integral]
+  unfold fourierCoeff1
+  have h1 : (∫ y in (0 : ℝ)..1, Complex.exp (-(2 * π * Complex.I * n * y)) * f (2 * π * y)) =
+      ∫ y in (0 : ℝ)..1,
+        (fun u : ℝ => Complex.exp (-(Complex.I * n * u)) * f u) (2 * π * y) := by
+    congr 1; funext y; simp only; congr 2; push_cast; ring
+  rw [h1, intervalIntegral.integral_comp_mul_left
+    (f := fun u : ℝ => Complex.exp (-(Complex.I * n * u)) * f u) hπ, mul_zero, mul_one, sub_zero]
+  simp_rw [fourier_coe_apply, smul_eq_mul]
+  rw [Complex.real_smul, Complex.real_smul]
+  congr 1
+  · push_cast; ring
+  · congr 1; funext x; congr 2; push_cast; field_simp
+
+theorem fourierPartialSum_eq_fourierPartialSum1 (f : ℝ → ℂ) (N : ℕ) (x : ℝ) :
+    ∑ n ∈ Finset.Icc (-(N : ℤ)) N,
+        fourierCoeffOn Real.two_pi_pos f n * fourier n (x : AddCircle (2 * π)) =
+      fourierPartialSum1 (fun t => f (2 * π * t)) N ((2 * π)⁻¹ * x) := by
+  have hπC : (2 * π : ℂ) ≠ 0 := by exact_mod_cast (by positivity : (2 * π : ℝ) ≠ 0)
+  unfold fourierPartialSum1
+  refine Finset.sum_congr rfl fun n _ => ?_
+  rw [fourierCoeffOn_eq_fourierCoeff1, fourier_coe_apply]
+  congr 2
+  push_cast
+  field_simp
+
+/-- **Carleson's theorem** (Carleson 1966): the Fourier series of a `2π`-periodic function on `ℝ`
+that is square integrable on `[0, 2π)` converges to it almost everywhere. -/
+theorem classical_carleson (f : ℝ → ℂ) (hper : Function.Periodic f (2 * π))
+    (hf : MemLp f 2 (volume.restrict (Set.Ico 0 (2 * π)))) :
+    ∀ᵐ x : ℝ, Tendsto (fun N : ℕ => ∑ n ∈ Finset.Icc (-(N : ℤ)) N,
+      fourierCoeffOn Real.two_pi_pos f n * fourier n (x : AddCircle (2 * π))) atTop (𝓝 (f x)) := by
+  have hπ : (2 * π : ℝ) ≠ 0 := by positivity
+  set g : ℝ → ℂ := fun t => f (2 * π * t)
+  have hgper : Function.Periodic g 1 := fun t => by
+    simp only [g]; rw [mul_add, mul_one, hper]
+  have h := carleson_fourierSeries hgper (memLp_rescale hf)
+  rw [ae_iff] at h ⊢
+  have hset : {x : ℝ | ¬ Tendsto (fun N : ℕ => ∑ n ∈ Finset.Icc (-(N : ℤ)) N,
+      fourierCoeffOn Real.two_pi_pos f n * fourier n (x : AddCircle (2 * π))) atTop (𝓝 (f x))} =
+      (fun x => (2 * π)⁻¹ * x) ⁻¹'
+        {t | ¬ Tendsto (fun N => fourierPartialSum1 g N t) atTop (𝓝 (g t))} := by
+    ext x
+    simp only [Set.mem_ofPred_eq, Set.mem_preimage, g]
+    rw [mul_inv_cancel_left₀ hπ]
+    simp_rw [fourierPartialSum_eq_fourierPartialSum1]
+  rw [hset, Real.volume_preimage_mul_left (inv_ne_zero hπ), h, mul_zero]
+
+end CarlesonLT.Auto
diff --git a/LeanPool/CarlesonLT/Auto/HardyLittlewoodMaximal.lean b/LeanPool/CarlesonLT/Auto/HardyLittlewoodMaximal.lean
new file mode 100644
index 0000000000..5203c6c56d
--- /dev/null
+++ b/LeanPool/CarlesonLT/Auto/HardyLittlewoodMaximal.lean
@@ -0,0 +1,786 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Proofs generated by Claude under Joris Roos’s supervision; adapted for Lean Pool. -/
+
+public import Mathlib.Analysis.SpecialFunctions.Pow.Integral
+public import Mathlib.MeasureTheory.Covering.Vitali
+public import Mathlib.MeasureTheory.Group.LIntegral
+public import Mathlib.MeasureTheory.Integral.Layercake
+public import Mathlib.MeasureTheory.Measure.Haar.Basic
+
+/-!
+# The Hardy–Littlewood maximal theorem for a homogeneous gauge
+
+Let `E` be a topological additive group carrying a translation-invariant measure `μ`, and let
+`ρ : E → ℝ` be a *homogeneous gauge*: a continuous, nonnegative, symmetric and subadditive function
+with `ρ(0) = 0`
+whose balls `{ρ ≤ r}` have measure `r^D μ{ρ ≤ 1}` for some `D > 0` (for instance an anisotropic
+norm on `ℝⁿ` with Lebesgue measure, where `D` is the homogeneous dimension). For
+`g : E → [0, ∞]` and `λ ≥ 0` the (centered, restricted) maximal function is
+`M_λ g(x) = sup_{r ≥ λ} μ(B(x,r))⁻¹ ∫_{B(x,r)} g`, `B(x,r) = {y : ρ(x - y) ≤ r}`
+(the supremum is taken over rational radii, which gives the same value).
+
+**Theorem (Hardy–Littlewood maximal theorem).**
+* (weak type `(1,1)`) `μ{M_0 g > t} ≤ 3^D t⁻¹ ∫ g` for every `t > 0`;
+* (strong type `(2,2)`) `∫ (M_0 g)² ≤ C ∫ g²` with `C` depending only on `D`.
+
+**Theorem (majorization of approximate identities).** If `W : ℝ → [0, ∞]` is antitone and
+constant on `[0, λ]`, then `∫ g(x - y) W(ρ(y)) dy ≤ (∫ W(ρ(y)) dy) M_λ g(x)`.
+
+The weak type bound follows from the Vitali covering lemma (Mathlib's
+`Vitali.exists_disjoint_subfamily_covering_enlargement`) and the doubling property
+`μ(B(x,3r)) = 3^D μ(B(x,r))`. The `L²` bound follows from the weak type bound by the layer cake
+formula (Marcinkiewicz interpolation). The majorization follows from the layer cake decomposition
+of `W ∘ ρ` into gauge balls.
+
+## References
+
+* E. M. Stein, *Harmonic Analysis: Real-Variable Methods, Orthogonality, and Oscillatory
+  Integrals*, Princeton University Press, 1993, Chapter I (maximal functions on spaces of
+  homogeneous type).
+* L. Grafakos, *Classical Fourier Analysis*, 3rd ed., Graduate Texts in Mathematics 249,
+  Springer, 2014, Section 2.1 (the Hardy–Littlewood maximal operator and control of approximate
+  identities by it).
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open MeasureTheory Set
+open scoped ENNReal NNReal
+
+namespace CarlesonLT.Auto
+
+/-- A homogeneous gauge on an additive group with measure `μ`: a continuous, nonnegative, symmetric,
+subadditive function whose balls have measure `r^D μ{ρ ≤ 1}`. -/
+structure HomGauge (E : Type*) [AddCommGroup E] [TopologicalSpace E] [MeasurableSpace E]
+    (μ : Measure E) where
+  /-- The gauge. -/
+  ρ : E → ℝ
+  continuous : Continuous ρ
+  nonneg : ∀ x, 0 ≤ ρ x
+  zero : ρ 0 = 0
+  neg : ∀ x, ρ (-x) = ρ x
+  add_le : ∀ x y, ρ (x + y) ≤ ρ x + ρ y
+  /-- The homogeneous dimension. -/
+  D : ℝ
+  D_pos : 0 < D
+  vol : ∀ r : ℝ, 0 < r → μ {y | ρ y ≤ r} = ENNReal.ofReal (r ^ D) * μ {y | ρ y ≤ 1}
+  vol_pos : 0 < μ {y | ρ y ≤ 1}
+  vol_lt_top : μ {y | ρ y ≤ 1} < ⊤
+
+namespace HomGauge
+
+variable {E : Type*} [AddCommGroup E] [TopologicalSpace E] [IsTopologicalAddGroup E]
+  [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E]
+  {μ : Measure E} [μ.IsAddLeftInvariant] [SFinite μ] (G : HomGauge E μ)
+
+/-- The closed gauge ball `B(x, r) = {y : ρ(x - y) ≤ r}`. -/
+def ball (x : E) (r : ℝ) : Set E := {y | G.ρ (x - y) ≤ r}
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem ball_eq_preimage (x : E) (r : ℝ) :
+    G.ball x r = (fun y => -x + y) ⁻¹' {z | G.ρ z ≤ r} := by
+  ext y
+  simp only [ball, mem_ofPred_eq, mem_preimage]
+  rw [← G.neg (x - y), neg_sub, sub_eq_neg_add]
+
+omit [SecondCountableTopology E] [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem measurableSet_ball (x : E) (r : ℝ) : MeasurableSet (G.ball x r) :=
+  (isClosed_le (G.continuous.comp (continuous_const.sub continuous_id))
+      continuous_const).measurableSet
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball (x : E) (r : ℝ) : μ (G.ball x r) = μ {z | G.ρ z ≤ r} := by
+  rw [ball_eq_preimage, measure_preimage_add]
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball_eq (x : E) {r : ℝ} (hr : 0 < r) :
+    μ (G.ball x r) = ENNReal.ofReal (r ^ G.D) * μ {y | G.ρ y ≤ 1} := by
+  rw [measure_ball, G.vol r hr]
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball_pos (x : E) {r : ℝ} (hr : 0 < r) : 0 < μ (G.ball x r) := by
+  rw [G.measure_ball_eq x hr]
+  exact ENNReal.mul_pos (by simpa using Real.rpow_pos_of_pos hr G.D) G.vol_pos.ne'
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball_lt_top (x : E) {r : ℝ} (hr : 0 < r) : μ (G.ball x r) < ⊤ := by
+  rw [G.measure_ball_eq x hr]
+  exact ENNReal.mul_lt_top ENNReal.ofReal_lt_top G.vol_lt_top
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball_mul (x : E) {c r : ℝ} (hc : 0 < c) (hr : 0 < r) :
+    μ (G.ball x (c * r)) = ENNReal.ofReal (c ^ G.D) * μ (G.ball x r) := by
+  rw [G.measure_ball_eq x (mul_pos hc hr), G.measure_ball_eq x hr, ← mul_assoc,
+    ← ENNReal.ofReal_mul (by positivity), Real.mul_rpow hc.le hr.le]
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem ball_mono (x : E) {r s : ℝ} (h : r ≤ s) : G.ball x r ⊆ G.ball x s :=
+  fun _ hy => le_trans hy h
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem mem_ball_self (x : E) {r : ℝ} (hr : 0 ≤ r) : x ∈ G.ball x r := by
+  simp [ball, G.zero, hr]
+
+/-- The maximal function `M_λ g(x) = sup_{q ≥ λ, q > 0 rational} μ(B(x,q))⁻¹ ∫_{B(x,q)} g`. -/
+def maximal (lam : ℝ) (g : E → ℝ≥0∞) (x : E) : ℝ≥0∞ :=
+  ⨆ (q : ℚ) (_ : lam ≤ q) (_ : 0 < q), (μ (G.ball 0 q))⁻¹ * ∫⁻ y in G.ball x q, g y ∂μ
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_ball_zero (x : E) (r : ℝ) : μ (G.ball x r) = μ (G.ball 0 r) := by
+  rw [G.measure_ball, G.measure_ball]
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem le_maximal (lam : ℝ) (g : E → ℝ≥0∞) (x : E) {q : ℚ} (hlq : lam ≤ q) (hq : 0 < q) :
+    (μ (G.ball x q))⁻¹ * ∫⁻ y in G.ball x q, g y ∂μ ≤ G.maximal lam g x := by
+  rw [G.measure_ball_zero x]
+  exact le_iSup₂_of_le q hlq (le_iSup_of_le hq le_rfl)
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem maximal_anti (g : E → ℝ≥0∞) (x : E) {lam lam' : ℝ} (h : lam ≤ lam') :
+    G.maximal lam' g x ≤ G.maximal lam g x :=
+  iSup₂_le fun q hq => iSup_le fun hq0 => G.le_maximal lam g x (h.trans hq) hq0 |>.trans'
+    (by rw [G.measure_ball_zero x])
+
+omit [μ.IsAddLeftInvariant] in
+theorem measurable_maximal (lam : ℝ) {g : E → ℝ≥0∞} (hg : Measurable g) :
+    Measurable (G.maximal lam g) := by
+  refine Measurable.iSup fun q => Measurable.iSup fun _ => Measurable.iSup fun _ => ?_
+  refine Measurable.const_mul ?_ _
+  have hS : MeasurableSet {p : E × E | G.ρ (p.1 - p.2) ≤ q} :=
+    (isClosed_le (G.continuous.comp (continuous_fst.sub continuous_snd))
+      continuous_const).measurableSet
+  have hF : Measurable (fun p : E × E => {p : E × E | G.ρ (p.1 - p.2) ≤ q}.indicator
+      (fun p => g p.2) p) := (hg.comp measurable_snd).indicator hS
+  have := hF.lintegral_prod_right' (ν := μ)
+  have e : (fun x => ∫⁻ y in G.ball x q, g y ∂μ) = fun x => ∫⁻ y,
+      {p : E × E | G.ρ (p.1 - p.2) ≤ q}.indicator (fun p => g p.2) (x, y) ∂μ := by
+    funext x
+    rw [← lintegral_indicator (G.measurableSet_ball x q)]
+    rfl
+  rw [e]
+  exact this
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem mem_ball_comm {x y : E} {r : ℝ} : y ∈ G.ball x r ↔ x ∈ G.ball y r := by
+  simp only [ball, mem_ofPred_eq]
+  rw [← G.neg (x - y), neg_sub]
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem ball_subset_of_inter (a b : E) {qa qb : ℝ} (h : (G.ball a qa ∩ G.ball b qb).Nonempty) :
+    a ∈ G.ball b (qa + qb) := by
+  obtain ⟨z, hza, hzb⟩ := h
+  simp only [ball, mem_ofPred_eq] at hza hzb ⊢
+  have h1 := G.add_le (b - z) (z - a)
+  rw [sub_add_sub_cancel] at h1
+  have h2 : G.ρ (z - a) = G.ρ (a - z) := by rw [← G.neg (a - z), neg_sub]
+  linarith
+
+omit [SecondCountableTopology E] in
+/-- **Weak type `(1,1)` of the maximal function**: `μ{M_0 g > t} ≤ 3^D t⁻¹ ∫ g`. -/
+theorem measure_maximal_gt_le (g : E → ℝ≥0∞) {t : ℝ≥0∞} (ht0 : t ≠ 0) :
+    μ {x | t < G.maximal 0 g x} ≤ ENNReal.ofReal (3 ^ G.D) / t * ∫⁻ y, g y ∂μ := by
+  by_cases htop : t = ⊤
+  · subst htop; simp
+  by_cases hint : ∫⁻ y, g y ∂μ = ⊤
+  · rw [hint, ENNReal.mul_top]
+    · exact le_top
+    · exact (ENNReal.div_pos (by simpa using Real.rpow_pos_of_pos (by norm_num : (0 : ℝ) < 3) G.D)
+        htop).ne'
+  set A := {x | t < G.maximal 0 g x}
+  -- choose a good radius for each point of `A`
+  have hex : ∀ x ∈ A, ∃ q : ℚ, 0 < q ∧
+      t < (μ (G.ball x q))⁻¹ * ∫⁻ y in G.ball x q, g y ∂μ := by
+    intro x hx
+    simp only [A, mem_ofPred_eq, maximal, lt_iSup_iff] at hx
+    obtain ⟨q, -, hq, h⟩ := hx
+    exact ⟨q, hq, by rwa [G.measure_ball_zero x]⟩
+  choose! qx hqpos hqgood using hex
+  have hball : ∀ x ∈ A, t * μ (G.ball x (qx x)) ≤ ∫⁻ y in G.ball x (qx x), g y ∂μ := by
+    intro x hx
+    have hpos := G.measure_ball_pos x (by exact_mod_cast hqpos x hx : (0 : ℝ) < qx x)
+    have hfin := G.measure_ball_lt_top x (by exact_mod_cast hqpos x hx : (0 : ℝ) < qx x)
+    have h := (hqgood x hx).le
+    rw [← ENNReal.div_eq_inv_mul, ENNReal.le_div_iff_mul_le (Or.inl hpos.ne') (Or.inl hfin.ne)] at h
+    exact h
+  -- the radii are bounded
+  set v := μ {y | G.ρ y ≤ 1}
+  set K : ℝ := ((∫⁻ y, g y ∂μ) / (t * v)).toReal
+  have hqR : ∀ x ∈ A, (qx x : ℝ) ≤ (K + 1) ^ (1 / G.D) := by
+    intro x hx
+    have hq : (0 : ℝ) < qx x := by exact_mod_cast hqpos x hx
+    have h1 := (hball x hx).trans (setLIntegral_le_lintegral _ _)
+    rw [G.measure_ball_eq x hq] at h1
+    have htv : t * v ≠ 0 := mul_ne_zero ht0 G.vol_pos.ne'
+    have htv' : t * v ≠ ⊤ := ENNReal.mul_ne_top htop G.vol_lt_top.ne
+    have h2 : ENNReal.ofReal ((qx x : ℝ) ^ G.D) ≤ (∫⁻ y, g y ∂μ) / (t * v) := by
+      rw [ENNReal.le_div_iff_mul_le (Or.inl htv) (Or.inl htv')]
+      calc ENNReal.ofReal ((qx x : ℝ) ^ G.D) * (t * v)
+          = t * (ENNReal.ofReal ((qx x : ℝ) ^ G.D) * v) := by ring
+        _ ≤ _ := h1
+    have hfin : (∫⁻ y, g y ∂μ) / (t * v) ≠ ⊤ := ENNReal.div_ne_top hint htv
+    have h3 : (qx x : ℝ) ^ G.D ≤ K := by
+      rw [← ENNReal.ofReal_le_iff_le_toReal hfin]; exact h2
+    calc (qx x : ℝ) = ((qx x : ℝ) ^ G.D) ^ (1 / G.D) := by
+          rw [← Real.rpow_mul hq.le, mul_one_div_cancel G.D_pos.ne', Real.rpow_one]
+      _ ≤ (K + 1) ^ (1 / G.D) := Real.rpow_le_rpow (by positivity) (by linarith)
+          (by have := G.D_pos; positivity)
+  -- Vitali
+  obtain ⟨u, huA, hud, hcov⟩ := Vitali.exists_disjoint_subfamily_covering_enlargement
+    (fun x => G.ball x (qx x)) A (fun x => (qx x : ℝ)) 2 (by norm_num)
+    (fun x hx => by exact_mod_cast (hqpos x hx).le) _ hqR
+    (fun x hx => ⟨x, G.mem_ball_self x (by exact_mod_cast (hqpos x hx).le)⟩)
+  have hcount : u.Countable := by
+    have h := Measure.countable_meas_pos_of_disjoint_iUnion (μ := μ)
+      (As := fun b : u => G.ball b (qx b)) (fun b => G.measurableSet_ball _ _)
+      (fun b b' hbb' => hud b.2 b'.2 (fun h => hbb' (Subtype.ext h)))
+    have : {b : u | 0 < μ (G.ball b (qx b))} = univ := by
+      ext b
+      simp only [mem_ofPred_eq, mem_univ, iff_true]
+      exact G.measure_ball_pos _ (by exact_mod_cast hqpos b (huA b.2))
+    rw [this] at h
+    exact Set.countable_coe_iff.mp (countable_univ_iff.mp h)
+  have hsubset : A ⊆ ⋃ b ∈ u, G.ball b (3 * qx b) := by
+    intro a ha
+    obtain ⟨b, hbu, hinter, hle⟩ := hcov a ha
+    refine mem_biUnion hbu ?_
+    have := G.ball_subset_of_inter a b hinter
+    exact G.ball_mono b (by linarith) this
+  have := hcount.to_subtype
+  calc μ A ≤ μ (⋃ b ∈ u, G.ball b (3 * qx b)) := measure_mono hsubset
+    _ ≤ ∑' b : u, μ (G.ball b (3 * qx b)) := measure_biUnion_le _ hcount _
+    _ = ∑' b : u, ENNReal.ofReal (3 ^ G.D) * μ (G.ball b (qx b)) := by
+        congr 1; ext b
+        exact G.measure_ball_mul _ (by norm_num) (by exact_mod_cast hqpos b (huA b.2))
+    _ ≤ ∑' b : u, ENNReal.ofReal (3 ^ G.D) / t * ∫⁻ y in G.ball b (qx b), g y ∂μ := by
+        refine ENNReal.tsum_le_tsum fun b => ?_
+        have h := hball b (huA b.2)
+        have hB : μ (G.ball b (qx b)) ≤ (∫⁻ y in G.ball b (qx b), g y ∂μ) / t :=
+          (ENNReal.le_div_iff_mul_le (Or.inl ht0) (Or.inl htop)).mpr (by rwa [mul_comm])
+        calc ENNReal.ofReal (3 ^ G.D) * μ (G.ball b (qx b))
+            ≤ ENNReal.ofReal (3 ^ G.D) * ((∫⁻ y in G.ball b (qx b), g y ∂μ) / t) :=
+              mul_le_mul_right hB _
+          _ = _ := by rw [ENNReal.div_eq_inv_mul, ENNReal.div_eq_inv_mul]; ring
+    _ = ENNReal.ofReal (3 ^ G.D) / t * ∫⁻ y in ⋃ b : u, G.ball b (qx b), g y ∂μ := by
+        rw [ENNReal.tsum_mul_left, lintegral_iUnion (s := fun b : u => G.ball (b : E) (qx b))
+          (fun b => G.measurableSet_ball _ _)
+          (fun b b' hbb' => hud b.2 b'.2 (fun h => hbb' (Subtype.ext h)))]
+    _ ≤ _ := mul_le_mul_right (setLIntegral_le_lintegral _ _) _
+
+end HomGauge
+
+theorem lintegral_Ioi_indicator_two_mul (a : ℝ≥0∞) :
+    ∫⁻ t in Ioi (0 : ℝ), {t : ℝ | ENNReal.ofReal t < a}.indicator
+      (fun t => ENNReal.ofReal (2 * t)) t = a ^ 2 := by
+  have hmeas : MeasurableSet {t : ℝ | ENNReal.ofReal t < a} :=
+    measurableSet_lt ENNReal.measurable_ofReal measurable_const
+  rw [lintegral_indicator hmeas, Measure.restrict_restrict hmeas]
+  rcases eq_or_ne a ⊤ with rfl | ha
+  · have : {t : ℝ | ENNReal.ofReal t < ⊤} ∩ Ioi 0 = Ioi 0 := by ext t; simp
+    rw [this, ENNReal.top_pow two_ne_zero, eq_top_iff]
+    calc (⊤ : ℝ≥0∞) = ∫⁻ t in Ioi (1 : ℝ), 2 ∂volume := by
+          rw [setLIntegral_const, Real.volume_Ioi, ENNReal.mul_top two_ne_zero]
+      _ ≤ ∫⁻ t in Ioi (0 : ℝ), ENNReal.ofReal (2 * t) := by
+          refine le_trans (setLIntegral_mono' measurableSet_Ioi fun t ht => ?_)
+            (lintegral_mono_set (Ioi_subset_Ioi zero_le_one))
+          have : (1 : ℝ) < t := ht
+          rw [show (2 : ℝ≥0∞) = ENNReal.ofReal 2 by simp]
+          exact ENNReal.ofReal_le_ofReal (by linarith)
+  · have hset : {t : ℝ | ENNReal.ofReal t < a} ∩ Ioi 0 = Ioo 0 a.toReal := by
+      ext t
+      simp only [mem_inter_iff, mem_ofPred_eq, mem_Ioi, mem_Ioo]
+      constructor
+      · rintro ⟨h1, h2⟩
+        exact ⟨h2, (ENNReal.ofReal_lt_iff_lt_toReal h2.le ha).mp h1⟩
+      · rintro ⟨h1, h2⟩
+        exact ⟨(ENNReal.ofReal_lt_iff_lt_toReal h1.le ha).mpr h2, h1⟩
+    rw [hset, ← ofReal_integral_eq_lintegral_ofReal]
+    · rw [← integral_Ioc_eq_integral_Ioo, ← intervalIntegral.integral_of_le ENNReal.toReal_nonneg]
+      rw [intervalIntegral.integral_const_mul, integral_id]
+      rw [← ENNReal.ofReal_toReal ha, ← ENNReal.ofReal_pow ENNReal.toReal_nonneg,
+        ENNReal.toReal_ofReal ENNReal.toReal_nonneg]
+      congr 1; ring
+    · exact (continuous_const.mul continuous_id).integrableOn_Icc.mono_set Ioo_subset_Icc_self
+    · exact (ae_restrict_iff' measurableSet_Ioo).mpr (Filter.Eventually.of_forall fun t ht => by
+        have : 0 < t := ht.1
+        simp only [Pi.zero_apply]; linarith)
+
+theorem lintegral_Ioi_indicator_half (b : ℝ≥0∞) :
+    ∫⁻ t in Ioi (0 : ℝ), {t : ℝ | ENNReal.ofReal (t / 2) < b}.indicator 1 t = 2 * b := by
+  have hmeas : MeasurableSet {t : ℝ | ENNReal.ofReal (t / 2) < b} :=
+    measurableSet_lt (ENNReal.measurable_ofReal.comp (measurable_id.div_const 2)) measurable_const
+  rw [lintegral_indicator hmeas, Measure.restrict_restrict hmeas]
+  simp only [Pi.one_apply, lintegral_const, Measure.restrict_apply MeasurableSet.univ,
+    univ_inter, one_mul]
+  rcases eq_or_ne b ⊤ with rfl | hb
+  · have : {t : ℝ | ENNReal.ofReal (t / 2) < ⊤} ∩ Ioi 0 = Ioi 0 := by ext t; simp
+    rw [this, Real.volume_Ioi, ENNReal.mul_top two_ne_zero]
+  · have hset : {t : ℝ | ENNReal.ofReal (t / 2) < b} ∩ Ioi 0 = Ioo 0 (2 * b.toReal) := by
+      ext t
+      simp only [mem_inter_iff, mem_ofPred_eq, mem_Ioi, mem_Ioo]
+      constructor
+      · rintro ⟨h1, h2⟩
+        refine ⟨h2, ?_⟩
+        have := (ENNReal.ofReal_lt_iff_lt_toReal (by linarith) hb).mp h1
+        linarith
+      · rintro ⟨h1, h2⟩
+        exact ⟨(ENNReal.ofReal_lt_iff_lt_toReal (by linarith) hb).mpr (by linarith), h1⟩
+    rw [hset, Real.volume_Ioo, sub_zero, ENNReal.ofReal_mul (by norm_num), ENNReal.ofReal_toReal hb]
+    simp
+
+namespace HomGauge
+
+variable {E : Type*} [AddCommGroup E] [TopologicalSpace E] [IsTopologicalAddGroup E]
+  [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E]
+  {μ : Measure E} [μ.IsAddLeftInvariant] [SFinite μ] (G : HomGauge E μ)
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem maximal_le_add (g : E → ℝ≥0∞) (s : ℝ≥0∞) (x : E) :
+    G.maximal 0 g x ≤ G.maximal 0 ({y | s < g y}.indicator g) x + s := by
+  refine iSup₂_le fun q _ => iSup_le fun hq => ?_
+  have hq' : (0 : ℝ) < q := by exact_mod_cast hq
+  have hpos := G.measure_ball_pos (0 : E) hq'
+  have hfin := G.measure_ball_lt_top (0 : E) hq'
+  have hpt : ∀ y, g y ≤ {y | s < g y}.indicator g y + s := by
+    intro y
+    by_cases h : s < g y
+    · rw [indicator_of_mem (show y ∈ {y | s < g y} from h)]; exact le_self_add
+    · rw [indicator_of_notMem (show y ∉ {y | s < g y} from h), zero_add]; exact not_lt.mp h
+  calc (μ (G.ball 0 q))⁻¹ * ∫⁻ y in G.ball x q, g y ∂μ
+      ≤ (μ (G.ball 0 q))⁻¹ * ∫⁻ y in G.ball x q, ({y | s < g y}.indicator g y + s) ∂μ := by
+        gcongr with y; exact hpt y
+    _ = (μ (G.ball 0 q))⁻¹ * ∫⁻ y in G.ball x q, {y | s < g y}.indicator g y ∂μ +
+          (μ (G.ball 0 q))⁻¹ * (s * μ (G.ball x q)) := by
+        rw [lintegral_add_right _ measurable_const, setLIntegral_const, mul_add]
+    _ ≤ G.maximal 0 ({y | s < g y}.indicator g) x + s := by
+        gcongr
+        · rw [← G.measure_ball_zero x]
+          exact G.le_maximal 0 _ x (by exact_mod_cast hq.le) hq
+        · rw [G.measure_ball_zero x, mul_comm s, ← mul_assoc, ENNReal.inv_mul_cancel hpos.ne'
+            hfin.ne, one_mul]
+
+/-- **Strong type `(2,2)` of the maximal function**: `∫ (M_0 g)² ≤ 8·3^D ∫ g²`. -/
+theorem lintegral_maximal_sq_le (g : E → ℝ≥0∞) (hg : Measurable g) :
+    ∫⁻ x, G.maximal 0 g x ^ 2 ∂μ ≤ ENNReal.ofReal (8 * 3 ^ G.D) * ∫⁻ x, g x ^ 2 ∂μ := by
+  have hM := G.measurable_maximal 0 hg
+  set c : ℝ≥0∞ := ENNReal.ofReal (3 ^ G.D)
+  -- layer cake in `x`
+  have h1 : ∫⁻ x, G.maximal 0 g x ^ 2 ∂μ = ∫⁻ t in Ioi (0 : ℝ),
+      ENNReal.ofReal (2 * t) * μ {x | ENNReal.ofReal t < G.maximal 0 g x} := by
+    have hF : Measurable (fun p : E × ℝ => if ENNReal.ofReal p.2 < G.maximal 0 g p.1 then
+        ENNReal.ofReal (2 * p.2) else 0) :=
+      Measurable.ite (measurableSet_lt (ENNReal.measurable_ofReal.comp measurable_snd)
+        (hM.comp measurable_fst)) (ENNReal.measurable_ofReal.comp
+          (measurable_const.mul measurable_snd)) measurable_const
+    have e1 : ∀ x, G.maximal 0 g x ^ 2 = ∫⁻ t in Ioi (0 : ℝ),
+        (if ENNReal.ofReal t < G.maximal 0 g x then ENNReal.ofReal (2 * t) else 0) := by
+      intro x
+      rw [← lintegral_Ioi_indicator_two_mul]
+      refine lintegral_congr fun t => ?_
+      by_cases h : ENNReal.ofReal t < G.maximal 0 g x <;> simp [indicator, h]
+    simp_rw [e1]
+    rw [lintegral_lintegral_swap hF.aemeasurable]
+    refine lintegral_congr fun t => ?_
+    have hS : MeasurableSet {x | ENNReal.ofReal t < G.maximal 0 g x} :=
+      measurableSet_lt measurable_const hM
+    rw [← lintegral_indicator_const hS]
+    refine lintegral_congr fun x => ?_
+    by_cases h : ENNReal.ofReal t < G.maximal 0 g x <;> simp [indicator, h]
+  -- the level set estimate
+  have h2 : ∀ t : ℝ, 0 < t → ENNReal.ofReal (2 * t) * μ {x | ENNReal.ofReal t < G.maximal 0 g x} ≤
+      4 * c * ∫⁻ x, {y | ENNReal.ofReal (t / 2) < g y}.indicator g x ∂μ := by
+    intro t ht
+    set s := ENNReal.ofReal (t / 2)
+    have hs0 : s ≠ 0 := by simpa [s] using ht
+    have hsub : {x | ENNReal.ofReal t < G.maximal 0 g x} ⊆
+        {x | s < G.maximal 0 ({y | s < g y}.indicator g) x} := by
+      intro x hx
+      simp only [mem_ofPred_eq] at hx ⊢
+      by_contra hle
+      push Not at hle
+      have := (G.maximal_le_add g s x).trans (add_le_add hle le_rfl)
+      rw [← ENNReal.ofReal_add (by linarith) (by linarith), add_halves] at this
+      exact absurd hx (not_lt.mpr this)
+    have hw := G.measure_maximal_gt_le ({y | s < g y}.indicator g) hs0
+    calc ENNReal.ofReal (2 * t) * μ {x | ENNReal.ofReal t < G.maximal 0 g x}
+        ≤ ENNReal.ofReal (2 * t) * (c / s * ∫⁻ x, {y | s < g y}.indicator g x ∂μ) := by
+          gcongr; exact (measure_mono hsub).trans hw
+      _ = (ENNReal.ofReal (2 * t) / s) * c * ∫⁻ x, {y | s < g y}.indicator g x ∂μ := by
+          rw [ENNReal.div_eq_inv_mul, ENNReal.div_eq_inv_mul]; ring
+      _ = 4 * c * ∫⁻ x, {y | s < g y}.indicator g x ∂μ := by
+          congr 2
+          rw [← ENNReal.ofReal_div_of_pos (by linarith)]
+          rw [show 2 * t / (t / 2) = 4 by field_simp; ring]
+          simp
+  -- layer cake in `t`
+  have hG : Measurable (fun p : ℝ × E => if ENNReal.ofReal (p.1 / 2) < g p.2 then g p.2 else 0) :=
+    Measurable.ite (measurableSet_lt (ENNReal.measurable_ofReal.comp
+      (measurable_fst.div_const 2)) (hg.comp measurable_snd)) (hg.comp measurable_snd)
+      measurable_const
+  calc ∫⁻ x, G.maximal 0 g x ^ 2 ∂μ
+      ≤ ∫⁻ t in Ioi (0 : ℝ), 4 * c * ∫⁻ x, {y | ENNReal.ofReal (t / 2) < g y}.indicator g x ∂μ := by
+        rw [h1]
+        exact setLIntegral_mono' measurableSet_Ioi fun t ht => h2 t ht
+    _ = 4 * c * ∫⁻ x, g x * (∫⁻ t in Ioi (0 : ℝ),
+          {t : ℝ | ENNReal.ofReal (t / 2) < g x}.indicator 1 t) ∂μ := by
+        rw [lintegral_const_mul' _ _ (ENNReal.mul_ne_top (by simp) ENNReal.ofReal_ne_top)]
+        congr 1
+        have e2 : ∀ t : ℝ, ∫⁻ x, {y | ENNReal.ofReal (t / 2) < g y}.indicator g x ∂μ =
+            ∫⁻ x, (if ENNReal.ofReal (t / 2) < g x then g x else 0) ∂μ := fun t =>
+          lintegral_congr fun x => by
+            by_cases h : ENNReal.ofReal (t / 2) < g x <;> simp [indicator, h]
+        simp_rw [e2]
+        rw [lintegral_lintegral_swap hG.aemeasurable]
+        refine lintegral_congr fun x => ?_
+        have hmI : Measurable (fun t : ℝ => {t : ℝ | ENNReal.ofReal (t / 2) < g x}.indicator
+            (1 : ℝ → ℝ≥0∞) t) := measurable_one.indicator (measurableSet_lt
+              (ENNReal.measurable_ofReal.comp (measurable_id.div_const 2)) measurable_const)
+        rw [← lintegral_const_mul (g x) hmI]
+        refine lintegral_congr fun t => ?_
+        simp only [indicator, mem_ofPred_eq, Pi.one_apply]
+        split_ifs <;> simp
+    _ = 8 * c * ∫⁻ x, g x ^ 2 ∂μ := by
+        simp_rw [lintegral_Ioi_indicator_half]
+        rw [show (fun x => g x * (2 * g x)) = fun x => 2 * g x ^ 2 by ext x; ring,
+          lintegral_const_mul' _ _ (by simp)]
+        ring
+    _ = _ := by
+        rw [ENNReal.ofReal_mul (by norm_num), ENNReal.ofReal_ofNat]
+
+omit [IsTopologicalAddGroup E] [BorelSpace E] [SecondCountableTopology E]
+  [μ.IsAddLeftInvariant] [SFinite μ] in
+theorem measure_lt_eq (r : ℝ) (hr : 0 < r) :
+    μ {y | G.ρ y < r} = ENNReal.ofReal (r ^ G.D) * μ {y | G.ρ y ≤ 1} := by
+  -- continuity from below along `r - 1/(k+1)`
+  have hU : {y | G.ρ y < r} = ⋃ k : ℕ, {y | G.ρ y ≤ r - r / (k + 2)} := by
+    ext y
+    simp only [mem_ofPred_eq, mem_iUnion]
+    constructor
+    · intro h
+      obtain ⟨k, hk⟩ := exists_nat_gt (r / (r - G.ρ y))
+      refine ⟨k, ?_⟩
+      have hpos : 0 < r - G.ρ y := by linarith
+      rw [div_lt_iff₀ hpos] at hk
+      have : r / (k + 2) ≤ r - G.ρ y := by
+        rw [div_le_iff₀ (by positivity)]; nlinarith
+      linarith
+    · rintro ⟨k, hk⟩
+      have : 0 < r / (k + 2) := by positivity
+      linarith
+  have hmono : Monotone fun k : ℕ => {y | G.ρ y ≤ r - r / (k + 2)} := by
+    intro a b hab y hy
+    simp only [mem_ofPred_eq] at hy ⊢
+    have : r / (b + 2) ≤ r / (a + 2) :=
+      div_le_div_of_nonneg_left hr.le (by positivity) (by exact_mod_cast (by omega : a + 2 ≤ b + 2))
+    linarith
+  rw [hU, hmono.measure_iUnion]
+  have hval : ∀ k : ℕ, μ {y | G.ρ y ≤ r - r / (k + 2)} =
+      ENNReal.ofReal ((r - r / (k + 2)) ^ G.D) * μ {y | G.ρ y ≤ 1} := by
+    intro k
+    refine G.vol _ ?_
+    have : r / (k + 2) < r := div_lt_self hr (by linarith [(Nat.cast_nonneg k : (0 : ℝ) ≤ k)])
+    linarith
+  simp_rw [hval]
+  rw [← ENNReal.iSup_mul]
+  congr 1
+  refine le_antisymm (iSup_le fun k => ENNReal.ofReal_le_ofReal
+    (Real.rpow_le_rpow (by
+      have : r / (k + 2) < r := div_lt_self hr (by linarith [(Nat.cast_nonneg k : (0 : ℝ) ≤ k)])
+      linarith) (by have : 0 < r / (k + 2) := by positivity
+                    linarith) G.D_pos.le)) ?_
+  -- the supremum reaches `r^D`
+  have hlim : Filter.Tendsto (fun k : ℕ => ENNReal.ofReal ((r - r / (k + 2)) ^ G.D))
+      Filter.atTop (nhds (ENNReal.ofReal (r ^ G.D))) := by
+    refine ENNReal.tendsto_ofReal ?_
+    have h1 : Filter.Tendsto (fun k : ℕ => r - r / ((k : ℝ) + 2)) Filter.atTop (nhds (r - 0)) := by
+      refine tendsto_const_nhds.sub ?_
+      refine Filter.Tendsto.div_atTop tendsto_const_nhds ?_
+      exact Filter.tendsto_atTop_add_const_right _ 2 tendsto_natCast_atTop_atTop
+    rw [sub_zero] at h1
+    exact (Real.continuousAt_rpow_const r G.D (Or.inl hr.ne')).tendsto.comp h1
+  exact le_of_tendsto' hlim fun k => le_iSup (fun k : ℕ => ENNReal.ofReal
+    ((r - r / (k + 2)) ^ G.D)) k
+
+omit [SecondCountableTopology E] [SFinite μ] in
+theorem measure_lt_eq_ball (r : ℝ) (hr : 0 < r) : μ {y | G.ρ y < r} = μ (G.ball 0 r) := by
+  rw [G.measure_lt_eq r hr, G.measure_ball_eq 0 hr]
+
+omit [SecondCountableTopology E] [SFinite μ] in
+/-- The integral over a gauge ball of real radius `R ≥ λ` is controlled by `M_λ`. -/
+theorem setLIntegral_ball_le (lam : ℝ) (g : E → ℝ≥0∞) (x : E) {R : ℝ} (hR : 0 < R)
+    (hlR : lam ≤ R) :
+    ∫⁻ y in G.ball x R, g y ∂μ ≤ μ (G.ball 0 R) * G.maximal lam g x := by
+  -- approximate `R` from above by rationals
+  have hq : ∀ k : ℕ, ∃ q : ℚ, R < q ∧ (q : ℝ) < R + 1 / (k + 1) := fun k =>
+    exists_rat_btwn (by have : (0 : ℝ) < 1 / (k + 1) := by positivity
+                        linarith)
+  choose q hq1 hq2 using hq
+  have hbound : ∀ k, ∫⁻ y in G.ball x R, g y ∂μ ≤ μ (G.ball 0 (q k)) * G.maximal lam g x := by
+    intro k
+    have hqpos : (0 : ℝ) < q k := hR.trans (hq1 k)
+    have hle := G.le_maximal lam g x (hlR.trans (hq1 k).le) (by exact_mod_cast hqpos)
+    have hpos := G.measure_ball_pos x hqpos
+    have hfin := G.measure_ball_lt_top x hqpos
+    calc ∫⁻ y in G.ball x R, g y ∂μ ≤ ∫⁻ y in G.ball x (q k), g y ∂μ :=
+          lintegral_mono_set (G.ball_mono x (hq1 k).le)
+      _ = μ (G.ball x (q k)) * ((μ (G.ball x (q k)))⁻¹ * ∫⁻ y in G.ball x (q k), g y ∂μ) := by
+          rw [← mul_assoc, ENNReal.mul_inv_cancel hpos.ne' hfin.ne, one_mul]
+      _ ≤ μ (G.ball 0 (q k)) * G.maximal lam g x := by
+          rw [G.measure_ball_zero x] at hle ⊢
+          exact mul_le_mul_right hle _
+  have hlim : Filter.Tendsto (fun k => μ (G.ball 0 (q k)) * G.maximal lam g x) Filter.atTop
+      (nhds (μ (G.ball 0 R) * G.maximal lam g x)) := by
+    by_cases hM : G.maximal lam g x = ⊤
+    · have : ∀ k, μ (G.ball 0 (q k)) * G.maximal lam g x = ⊤ := fun k => by
+        rw [hM, ENNReal.mul_top (G.measure_ball_pos 0 (hR.trans (hq1 k))).ne']
+      simp_rw [this]
+      rw [hM, ENNReal.mul_top (G.measure_ball_pos 0 hR).ne']
+      exact tendsto_const_nhds
+    refine ENNReal.Tendsto.mul_const ?_ (Or.inr hM)
+    have hqlim : Filter.Tendsto (fun k => (q k : ℝ)) Filter.atTop (nhds R) := by
+      refine tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds ?_ (fun k => (hq1 k).le)
+        (fun k => (hq2 k).le)
+      have := tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)
+      simpa using (tendsto_const_nhds (x := R)).add this
+    have e : ∀ k, μ (G.ball 0 (q k)) = ENNReal.ofReal ((q k : ℝ) ^ G.D) * μ {y | G.ρ y ≤ 1} :=
+      fun k => G.measure_ball_eq 0 (hR.trans (hq1 k))
+    simp_rw [e]
+    rw [G.measure_ball_eq 0 hR]
+    refine ENNReal.Tendsto.mul_const ?_ (Or.inr G.vol_lt_top.ne)
+    exact ENNReal.tendsto_ofReal ((Real.continuousAt_rpow_const R G.D (Or.inl hR.ne')).tendsto.comp
+      hqlim)
+  exact ge_of_tendsto' hlim hbound
+
+end HomGauge
+
+theorem lintegral_Ioi_indicator_lt (a : ℝ≥0∞) :
+    ∫⁻ s in Ioi (0 : ℝ), {s : ℝ | ENNReal.ofReal s < a}.indicator 1 s = a := by
+  have hmeas : MeasurableSet {s : ℝ | ENNReal.ofReal s < a} :=
+    measurableSet_lt ENNReal.measurable_ofReal measurable_const
+  rw [lintegral_indicator hmeas, Measure.restrict_restrict hmeas]
+  simp only [Pi.one_apply, lintegral_const, Measure.restrict_apply MeasurableSet.univ,
+    univ_inter, one_mul]
+  rcases eq_or_ne a ⊤ with rfl | ha
+  · have : {s : ℝ | ENNReal.ofReal s < ⊤} ∩ Ioi 0 = Ioi 0 := by ext s; simp
+    rw [this, Real.volume_Ioi]
+  · have hset : {s : ℝ | ENNReal.ofReal s < a} ∩ Ioi 0 = Ioo 0 a.toReal := by
+      ext s
+      simp only [mem_inter_iff, mem_ofPred_eq, mem_Ioi, mem_Ioo]
+      constructor
+      · rintro ⟨h1, h2⟩
+        exact ⟨h2, (ENNReal.ofReal_lt_iff_lt_toReal h2.le ha).mp h1⟩
+      · rintro ⟨h1, h2⟩
+        exact ⟨(ENNReal.ofReal_lt_iff_lt_toReal h1.le ha).mpr h2, h1⟩
+    rw [hset, Real.volume_Ioo, sub_zero, ENNReal.ofReal_toReal ha]
+
+namespace HomGauge
+
+variable {E : Type*} [AddCommGroup E] [TopologicalSpace E] [IsTopologicalAddGroup E]
+  [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E]
+  {μ : Measure E} [μ.IsAddLeftInvariant] [SFinite μ] (G : HomGauge E μ)
+
+/-- **Majorization of approximate identities by the maximal function** (paper, Lemma 7.2): if
+`W` is antitone and constant on `[0, λ]`, then `∫ g(x - y) W(ρ(y)) dy ≤ (∫ W ∘ ρ) M_λ g(x)`. -/
+theorem lintegral_mul_gauge_le [μ.IsNegInvariant] {lam : ℝ} (hlam : 0 < lam) (W : ℝ → ℝ≥0∞)
+    (hW : Antitone W) (hWc : ∀ t ∈ Icc 0 lam, W t = W 0) {g : E → ℝ≥0∞} (hg : Measurable g)
+    (x : E) :
+    ∫⁻ y, g (x - y) * W (G.ρ y) ∂μ ≤ (∫⁻ y, W (G.ρ y) ∂μ) * G.maximal lam g x := by
+  set M := G.maximal lam g x
+  have hV : Measurable fun y => W (G.ρ y) := hW.measurable.comp G.continuous.measurable
+  have hgx : Measurable fun y => g (x - y) := hg.comp (measurable_const.sub measurable_id)
+  -- the degenerate case `M = 0`
+  by_cases hM0 : M = 0
+  · have hball0 : ∀ q : ℚ, lam ≤ q → ∫⁻ y in G.ball x q, g y ∂μ = 0 := by
+      intro q hq
+      have hqpos : (0 : ℝ) < q := hlam.trans_le hq
+      have h := G.le_maximal lam g x hq (by exact_mod_cast hqpos)
+      rw [show G.maximal lam g x = 0 from hM0, nonpos_iff_eq_zero, mul_eq_zero] at h
+      rcases h with h | h
+      · exact absurd h (ENNReal.inv_ne_zero.mpr (G.measure_ball_lt_top x hqpos).ne)
+      · exact h
+    have hcover : (univ : Set E) ⊆ ⋃ q : {q : ℚ // lam ≤ q}, G.ball x q := by
+      intro y _
+      obtain ⟨q, hq⟩ := exists_rat_gt (max lam (G.ρ (x - y)))
+      exact mem_iUnion.mpr ⟨⟨q, (le_max_left _ _).trans hq.le⟩, (le_max_right _ _).trans hq.le⟩
+    have hg0 : ∫⁻ y, g y ∂μ = 0 := by
+      rw [← setLIntegral_univ]
+      refine le_antisymm ((lintegral_mono_set hcover).trans ((lintegral_iUnion_le _ _).trans ?_))
+        bot_le
+      exact le_of_eq (ENNReal.tsum_eq_zero.mpr fun q => hball0 q q.2)
+    have hae : g =ᵐ[μ] 0 := (lintegral_eq_zero_iff hg).mp hg0
+    have := lintegral_sub_left_eq_self (μ := μ) (fun z => g z * W (G.ρ (x - z))) x
+    simp only [sub_sub_cancel] at this
+    have hL : ∫⁻ y, g (x - y) * W (G.ρ y) ∂μ = 0 := by
+      rw [this]
+      refine (lintegral_congr_ae ?_).trans lintegral_zero
+      filter_upwards [hae] with z hz
+      simp [hz]
+    rw [hL]
+    exact bot_le
+  -- layer cake
+  have hlayer : ∀ a : ℝ≥0∞, a = ∫⁻ s in Ioi (0 : ℝ), {s : ℝ | ENNReal.ofReal s < a}.indicator 1 s :=
+    fun a => (lintegral_Ioi_indicator_lt a).symm
+  have hF : Measurable (fun p : E × ℝ => g (x - p.1) *
+      {s : ℝ | ENNReal.ofReal s < W (G.ρ p.1)}.indicator 1 p.2) := by
+    refine (hgx.comp measurable_fst).mul ?_
+    have : (fun p : E × ℝ => {s : ℝ | ENNReal.ofReal s < W (G.ρ p.1)}.indicator (1 : ℝ → ℝ≥0∞) p.2)
+        = fun p => if ENNReal.ofReal p.2 < W (G.ρ p.1) then 1 else 0 := by
+      ext p; by_cases h : ENNReal.ofReal p.2 < W (G.ρ p.1) <;> simp [indicator, h]
+    rw [this]
+    exact Measurable.ite (measurableSet_lt (ENNReal.measurable_ofReal.comp measurable_snd)
+      (hV.comp measurable_fst)) measurable_const measurable_const
+  have hLHS : ∫⁻ y, g (x - y) * W (G.ρ y) ∂μ = ∫⁻ s in Ioi (0 : ℝ),
+      ∫⁻ y, g (x - y) * {s : ℝ | ENNReal.ofReal s < W (G.ρ y)}.indicator 1 s ∂μ := by
+    have e : ∀ y, g (x - y) * W (G.ρ y) = ∫⁻ s in Ioi (0 : ℝ),
+        g (x - y) * {s : ℝ | ENNReal.ofReal s < W (G.ρ y)}.indicator 1 s := by
+      intro y
+      rw [lintegral_const_mul _ (measurable_one.indicator (measurableSet_lt
+        ENNReal.measurable_ofReal measurable_const)), ← hlayer]
+    simp_rw [e]
+    exact lintegral_lintegral_swap hF.aemeasurable
+  have hRHS : ∫⁻ y, W (G.ρ y) ∂μ = ∫⁻ s in Ioi (0 : ℝ), μ {y | ENNReal.ofReal s < W (G.ρ y)} := by
+    have hF' : Measurable (fun p : E × ℝ =>
+        {s : ℝ | ENNReal.ofReal s < W (G.ρ p.1)}.indicator (1 : ℝ → ℝ≥0∞) p.2) := by
+      have : (fun p : E × ℝ => {s : ℝ | ENNReal.ofReal s < W (G.ρ p.1)}.indicator
+          (1 : ℝ → ℝ≥0∞) p.2) = fun p => if ENNReal.ofReal p.2 < W (G.ρ p.1) then 1 else 0 := by
+        ext p; by_cases h : ENNReal.ofReal p.2 < W (G.ρ p.1) <;> simp [indicator, h]
+      rw [this]
+      exact Measurable.ite (measurableSet_lt (ENNReal.measurable_ofReal.comp measurable_snd)
+        (hV.comp measurable_fst)) measurable_const measurable_const
+    conv_lhs => arg 2; ext y; rw [hlayer (W (G.ρ y))]
+    rw [lintegral_lintegral_swap hF'.aemeasurable]
+    refine lintegral_congr fun s => ?_
+    rw [← lintegral_indicator_one (measurableSet_lt measurable_const hV)]
+    refine lintegral_congr fun y => ?_
+    by_cases h : ENNReal.ofReal s < W (G.ρ y) <;> simp [indicator, h]
+  -- the level sets
+  have hlevel : ∀ s : ℝ, 0 < s → ∫⁻ y, g (x - y) *
+      {s : ℝ | ENNReal.ofReal s < W (G.ρ y)}.indicator 1 s ∂μ ≤
+      μ {y | ENNReal.ofReal s < W (G.ρ y)} * M := by
+    intro s hs
+    set S := {y | ENNReal.ofReal s < W (G.ρ y)}
+    have hSm : MeasurableSet S := measurableSet_lt measurable_const hV
+    have hLS : ∫⁻ y, g (x - y) * {s : ℝ | ENNReal.ofReal s < W (G.ρ y)}.indicator 1 s ∂μ =
+        ∫⁻ y in S, g (x - y) ∂μ := by
+      rw [← lintegral_indicator hSm]
+      refine lintegral_congr fun y => ?_
+      by_cases h : ENNReal.ofReal s < W (G.ρ y) <;> simp [indicator, h, S]
+    rw [hLS]
+    by_cases hs0 : ENNReal.ofReal s < W 0
+    · -- `S` contains the ball of radius `λ`
+      have hball : {y | G.ρ y ≤ lam} ⊆ S := fun y hy => by
+        simp only [S, mem_ofPred_eq]
+        rw [hWc (G.ρ y) ⟨G.nonneg y, hy⟩]; exact hs0
+      have h0S : (0 : E) ∈ S := hball (by simp [G.zero, hlam.le])
+      by_cases hbdd : BddAbove (G.ρ '' S)
+      · set R₀ := sSup (G.ρ '' S)
+        set R := max R₀ lam
+        have hlR : lam ≤ R := le_max_right _ _
+        have hRpos : 0 < R := hlam.trans_le hlR
+        have hSR : S ⊆ {y | G.ρ y ≤ R} := fun y hy =>
+          (le_csSup hbdd (mem_image_of_mem _ hy)).trans (le_max_left _ _)
+        have hRS : {y | G.ρ y < R} ⊆ S := by
+          intro y hy
+          simp only [mem_ofPred_eq] at hy
+          rcases le_total lam R₀ with hl | hl
+          · have hy' : G.ρ y < R₀ := by
+              rwa [show R = max R₀ lam from rfl, max_eq_left hl] at hy
+            obtain ⟨_, ⟨y', hy'', rfl⟩, hlt⟩ := exists_lt_of_lt_csSup
+              ⟨G.ρ 0, mem_image_of_mem _ h0S⟩ hy'
+            simp only [S, mem_ofPred_eq] at hy'' ⊢
+            exact hy''.trans_le (hW hlt.le)
+          · rw [show R = max R₀ lam from rfl, max_eq_right hl] at hy
+            exact hball hy.le
+        calc ∫⁻ y in S, g (x - y) ∂μ ≤ ∫⁻ y in {y | G.ρ y ≤ R}, g (x - y) ∂μ :=
+              lintegral_mono_set hSR
+          _ = ∫⁻ z in G.ball x R, g z ∂μ := by
+              rw [← lintegral_indicator (measurableSet_le G.continuous.measurable measurable_const),
+                ← lintegral_indicator (G.measurableSet_ball x R)]
+              have := lintegral_sub_left_eq_self (μ := μ)
+                (fun z => (G.ball x R).indicator g z) x
+              rw [← this]
+              refine lintegral_congr fun y => ?_
+              simp only [indicator, ball, mem_ofPred_eq, sub_sub_cancel]
+          _ ≤ μ (G.ball 0 R) * M := G.setLIntegral_ball_le lam g x hRpos hlR
+          _ = μ {y | G.ρ y < R} * M := by rw [G.measure_lt_eq_ball R hRpos]
+          _ ≤ μ S * M := by gcongr
+      · -- unbounded level set: infinite measure
+        have hinf : μ S = ⊤ := by
+          have hge : ∀ r : ℝ, 0 < r → ENNReal.ofReal (r ^ G.D) * μ {y | G.ρ y ≤ 1} ≤ μ S := by
+            intro r hr
+            rw [← G.measure_lt_eq r hr]
+            refine measure_mono fun z hz => ?_
+            simp only [mem_ofPred_eq] at hz
+            obtain ⟨_, ⟨y, hy, rfl⟩, hlt⟩ := not_bddAbove_iff.mp hbdd r
+            simp only [S, mem_ofPred_eq] at hy ⊢
+            exact hy.trans_le (hW (hz.trans hlt).le)
+          have hlim : Filter.Tendsto (fun r : ℝ => ENNReal.ofReal (r ^ G.D) * μ {y | G.ρ y ≤ 1})
+              Filter.atTop (nhds ⊤) := by
+            rw [← ENNReal.top_mul G.vol_pos.ne']
+            exact ENNReal.Tendsto.mul_const (ENNReal.tendsto_ofReal_atTop.comp
+              (tendsto_rpow_atTop G.D_pos)) (Or.inl ENNReal.top_ne_zero)
+          exact top_le_iff.mp (le_of_tendsto hlim (Filter.eventually_atTop.mpr ⟨1, fun r hr =>
+            hge r (by linarith)⟩))
+        rw [hinf, ENNReal.top_mul hM0]
+        exact le_top
+    · -- `S` is empty
+      have hS : S = ∅ := by
+        ext y
+        simp only [S, mem_ofPred_eq, mem_empty_iff_false, iff_false, not_lt]
+        exact (hW (G.nonneg y)).trans (not_lt.mp hs0)
+      rw [hS, Measure.restrict_empty, lintegral_zero_measure]
+      exact bot_le
+  have hanti : Antitone fun s : ℝ => μ {y | ENNReal.ofReal s < W (G.ρ y)} := by
+    intro a b hab
+    refine measure_mono fun y hy => ?_
+    simp only [mem_ofPred_eq] at hy ⊢
+    exact (ENNReal.ofReal_le_ofReal hab).trans_lt hy
+  rw [hLHS, hRHS, ← lintegral_mul_const _ hanti.measurable]
+  exact setLIntegral_mono' measurableSet_Ioi fun s hs => hlevel s hs
+
+omit [SecondCountableTopology E] [SFinite μ] in
+/-- Comparison of maximal functions at nearby points: if `ρ(x − y) ≤ λ`, then
+`M_λ g(x) ≤ 2^D M_0 g(y)`. -/
+theorem maximal_le_of_rho_sub_le (g : E → ℝ≥0∞) {x y : E} {lam : ℝ}
+    (hxy : G.ρ (x - y) ≤ lam) :
+    G.maximal lam g x ≤ ENNReal.ofReal (2 ^ G.D) * G.maximal 0 g y := by
+  refine iSup₂_le fun q hq => iSup_le fun hq0 => ?_
+  have hq' : (0 : ℝ) < q := by exact_mod_cast hq0
+  have hsub : G.ball x q ⊆ G.ball y (2 * q) := by
+    intro w hw
+    simp only [ball, Set.mem_ofPred_eq] at hw ⊢
+    have := G.add_le (y - x) (x - w)
+    rw [sub_add_sub_cancel] at this
+    have h2 : G.ρ (y - x) = G.ρ (x - y) := by rw [← G.neg (x - y), neg_sub]
+    linarith
+  have hpos := G.measure_ball_pos (0 : E) hq'
+  have hfin := G.measure_ball_lt_top (0 : E) hq'
+  have hmul := G.measure_ball_mul (0 : E) (c := 2) (by norm_num) hq'
+  have h2q : ((2 * q : ℚ) : ℝ) = 2 * (q : ℝ) := by push_cast; ring
+  have hle := G.le_maximal 0 g y (q := 2 * q) (by positivity) (by positivity)
+  rw [h2q, G.measure_ball_zero y] at hle
+  calc (μ (G.ball 0 q))⁻¹ * ∫⁻ w in G.ball x q, g w ∂μ
+      ≤ (μ (G.ball 0 q))⁻¹ * ∫⁻ w in G.ball y (2 * q), g w ∂μ := by
+        gcongr
+    _ = ENNReal.ofReal (2 ^ G.D) * ((μ (G.ball 0 (2 * q)))⁻¹ *
+          ∫⁻ w in G.ball y (2 * q), g w ∂μ) := by
+        rw [hmul, ENNReal.mul_inv (Or.inr hfin.ne) (Or.inr hpos.ne'), ← mul_assoc, ← mul_assoc,
+          ENNReal.mul_inv_cancel (by simp [Real.rpow_pos_of_pos (by norm_num : (0:ℝ) < 2)])
+            ENNReal.ofReal_ne_top, one_mul]
+    _ ≤ _ := by gcongr
+
+end HomGauge
+
+end CarlesonLT.Auto
diff --git a/LeanPool/CarlesonLT/Auto/ModelOperator.lean b/LeanPool/CarlesonLT/Auto/ModelOperator.lean
new file mode 100644
index 0000000000..e1f336fca9
--- /dev/null
+++ b/LeanPool/CarlesonLT/Auto/ModelOperator.lean
@@ -0,0 +1,8503 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Proofs generated by Claude under Joris Roos’s supervision; adapted for Lean Pool. -/
+
+public import Mathlib.Analysis.Distribution.SchwartzSpace.Fourier
+public import Mathlib.Algebra.Order.Ring.Finset
+public import Mathlib.Algebra.Order.Field.GeomSum
+public import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension
+public import Mathlib.Analysis.Calculus.ContDiff.Bounds
+public import Mathlib.Data.Int.Log
+public import Mathlib.Data.List.GetD
+public import Mathlib.Analysis.Fourier.AddCircleMulti
+public import Mathlib.Analysis.Fourier.PoissonSummation
+public import Mathlib.Analysis.InnerProductSpace.PiL2
+public import Mathlib.MeasureTheory.Integral.Prod
+public meta import Mathlib.Tactic.Abel
+public meta import Mathlib.Tactic.ByContra
+public meta import Mathlib.Tactic.Choose
+public meta import Mathlib.Tactic.Convert
+public meta import Mathlib.Tactic.FieldSimp
+public meta import Mathlib.Tactic.FunProp
+public meta import Mathlib.Tactic.GCongr
+public meta import Mathlib.Tactic.Linarith
+public meta import Mathlib.Tactic.LinearCombination
+public meta import Mathlib.Tactic.NormNum
+public meta import Mathlib.Tactic.Positivity
+public meta import Mathlib.Tactic.Push
+public meta import Mathlib.Tactic.Ring
+public meta import Mathlib.Tactic.SplitIfs
+public meta import Mathlib.Tactic.WLOG
+public import LeanPool.CarlesonLT.Auto.ParametricIntegralContDiff
+public import LeanPool.CarlesonLT.Auto.HardyLittlewoodMaximal
+
+/-!
+# Bounds for anisotropic Carleson operators: the model operator (Theorem 3.2)
+
+Part of the formalization of Theorem 1.1 of
+
+* J. Roos, *Bounds for anisotropic Carleson operators*, arXiv:1710.10962v1 (2017),
+  J. Fourier Anal. Appl. (doi:10.1007/s00041-018-09657-7).
+
+This file contains the time-frequency analysis of the dyadic model operator (Sections 1 and 3-8 of
+the paper, except the averaging procedure): anisotropic dilations and multiplier classes, tiles and
+wave packets with the estimates of Sections 4 and 8, convergence of the model sum, the reduction of
+Theorem 3.2 to the key estimate (4.1), the mass lemma (Section 5), the energy lemma (Section 6),
+the tree estimate (Section 7) and the iteration (4.10)-(4.12). The main result is `Auto.thm_3_2`.
+The reduction of Theorem 1.1 to Theorem 3.2 (Lemma 3.3 and the proof of Theorem 1.1) is in
+`LeanPool/CarlesonLT/Auto/AnisotropicCarleson.lean`.
+
+## Conventions
+
+* `ℝⁿ` is `EuclideanSpace ℝ (Fin n)`, abbreviated `Rn n`.
+* The exponent vector `α : Fin n → ℕ` has positive integer entries (the paper's standing assumption,
+  §1); the normalization `α₁ = 1` is not needed.
+* The Fourier transform is `f̂(ξ) = ∫ f(x) e^{-i x·ξ} dx` (see `Auto.fhat`).
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open MeasureTheory Real Complex UnitAddTorus
+open scoped NNReal ENNReal InnerProductSpace SchwartzMap ComplexConjugate
+
+namespace CarlesonLT.Auto
+
+/-- The Euclidean space `ℝⁿ`, on which all functions in the paper live. -/
+abbrev Rn (n : ℕ) : Type := EuclideanSpace ℝ (Fin n)
+
+variable {n : ℕ}
+
+/-! ## Section 1: anisotropic dilations, the anisotropic norm, multiplier classes -/
+
+/-- The anisotropic dilation `δ_t(x) = (t^{α₁} x₁, …, t^{αₙ} xₙ)`
+(paper, §1, equation (1.1)). -/
+def dil (α : Fin n → ℕ) (t : ℝ) (x : Rn n) : Rn n :=
+  WithLp.toLp 2 (fun i => t ^ α i * x i)
+
+@[simp]
+theorem dil_apply (α : Fin n → ℕ) (t : ℝ) (x : Rn n) (i : Fin n) :
+    dil α t x i = t ^ α i * x i := rfl
+
+/-- The dilations form a multiplicative group action: `δ_s ∘ δ_t = δ_{st}` (paper, §1, (1.1)). -/
+theorem dil_dil (α : Fin n → ℕ) (s t : ℝ) (x : Rn n) :
+    dil α s (dil α t x) = dil α (s * t) x := by
+  ext i
+  simp [mul_pow, mul_assoc]
+
+@[simp]
+theorem dil_one (α : Fin n → ℕ) (x : Rn n) : dil α 1 x = x := by
+  ext i
+  simp
+
+theorem dil_add (α : Fin n → ℕ) (t : ℝ) (x y : Rn n) :
+    dil α t (x + y) = dil α t x + dil α t y := by
+  ext i
+  simp [mul_add]
+
+theorem dil_sub (α : Fin n → ℕ) (t : ℝ) (x y : Rn n) :
+    dil α t (x - y) = dil α t x - dil α t y := by
+  ext i
+  simp [mul_sub]
+
+theorem dil_neg (α : Fin n → ℕ) (t : ℝ) (x : Rn n) :
+    dil α t (-x) = -dil α t x := by
+  ext i
+  simp
+
+@[simp]
+theorem dil_zero (α : Fin n → ℕ) (t : ℝ) : dil α t (0 : Rn n) = 0 := by
+  ext i
+  simp
+
+/-- `|α| = ∑ᵢ αᵢ` (paper, §1). -/
+def absA (α : Fin n → ℕ) : ℕ := ∑ i, α i
+
+/-- The anisotropic norm `ρ(x) = max_i |x_i|^{1/α_i}` (paper, §1), as a nonnegative real. -/
+def rhoNN (α : Fin n → ℕ) (x : Rn n) : ℝ≥0 :=
+  Finset.univ.sup fun i => ‖x i‖₊ ^ ((α i : ℝ)⁻¹)
+
+/-- The anisotropic norm `ρ(x) = max_i |x_i|^{1/α_i}` (paper, §1). -/
+def rho (α : Fin n → ℕ) (x : Rn n) : ℝ := rhoNN α x
+
+theorem rho_nonneg (α : Fin n → ℕ) (x : Rn n) : 0 ≤ rho α x := (rhoNN α x).2
+
+theorem coord_rpow_le_rhoNN (α : Fin n → ℕ) (x : Rn n) (i : Fin n) :
+    ‖x i‖₊ ^ ((α i : ℝ)⁻¹) ≤ rhoNN α x :=
+  Finset.le_sup (f := fun i => ‖x i‖₊ ^ ((α i : ℝ)⁻¹)) (Finset.mem_univ i)
+
+theorem rhoNN_le_iff (α : Fin n → ℕ) (x : Rn n) (c : ℝ≥0) :
+    rhoNN α x ≤ c ↔ ∀ i, ‖x i‖₊ ^ ((α i : ℝ)⁻¹) ≤ c := by
+  simp [rhoNN, Finset.sup_le_iff]
+
+@[simp]
+theorem rhoNN_zero (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) : rhoNN α (0 : Rn n) = 0 := by
+  apply le_antisymm _ bot_le
+  rw [rhoNN_le_iff]
+  intro i
+  have : ((α i : ℝ)⁻¹) ≠ 0 := by
+    have := hα i
+    positivity
+  simp [NNReal.zero_rpow this]
+
+theorem rhoNN_neg (α : Fin n → ℕ) (x : Rn n) : rhoNN α (-x) = rhoNN α x := by
+  simp [rhoNN]
+
+/-- Triangle inequality for the anisotropic norm: `ρ(x + y) ≤ ρ(x) + ρ(y)` (paper, §1; uses
+`α_i ≥ 1`). -/
+theorem rhoNN_add_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (x y : Rn n) :
+    rhoNN α (x + y) ≤ rhoNN α x + rhoNN α y := by
+  rw [rhoNN_le_iff]
+  intro i
+  have h1 : (0 : ℝ) ≤ (α i : ℝ)⁻¹ := by positivity
+  have h2 : (α i : ℝ)⁻¹ ≤ 1 := by
+    have : (1 : ℝ) ≤ α i := by exact_mod_cast hα i
+    exact inv_le_one_of_one_le₀ this
+  calc ‖(x + y) i‖₊ ^ ((α i : ℝ)⁻¹)
+      ≤ (‖x i‖₊ + ‖y i‖₊) ^ ((α i : ℝ)⁻¹) := by
+        gcongr
+        simpa using nnnorm_add_le (x i) (y i)
+    _ ≤ ‖x i‖₊ ^ ((α i : ℝ)⁻¹) + ‖y i‖₊ ^ ((α i : ℝ)⁻¹) :=
+        NNReal.rpow_add_le_add_rpow _ _ h1 h2
+    _ ≤ rhoNN α x + rhoNN α y :=
+        add_le_add (coord_rpow_le_rhoNN α x i) (coord_rpow_le_rhoNN α y i)
+
+/-- Homogeneity of the anisotropic norm: `ρ(δ_t x) = t ρ(x)` for `t > 0` (paper, §1). -/
+theorem rhoNN_dil (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t) (x : Rn n) :
+    rhoNN α (dil α t x) = t.toNNReal * rhoNN α x := by
+  have key : ∀ i, ‖dil α t x i‖₊ ^ ((α i : ℝ)⁻¹) = t.toNNReal * ‖x i‖₊ ^ ((α i : ℝ)⁻¹) := by
+    intro i
+    have hαi : (α i : ℝ) ≠ 0 := by
+      have := hα i
+      positivity
+    rw [dil_apply, nnnorm_mul, NNReal.mul_rpow, nnnorm_pow]
+    congr 1
+    have : ‖t‖₊ = t.toNNReal := by
+      ext
+      simp [abs_of_pos ht, ht.le]
+    rw [this, ← NNReal.rpow_natCast, ← NNReal.rpow_mul, mul_inv_cancel₀ hαi, NNReal.rpow_one]
+  simp only [rhoNN, key]
+  rw [Finset.mul_sup₀]
+
+theorem rho_dil (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t) (x : Rn n) :
+    rho α (dil α t x) = t * rho α x := by
+  simp [rho, rhoNN_dil α hα ht, ht.le]
+
+theorem rho_add_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (x y : Rn n) :
+    rho α (x + y) ≤ rho α x + rho α y := by
+  simp only [rho]
+  exact_mod_cast rhoNN_add_le α hα x y
+
+theorem rho_neg (α : Fin n → ℕ) (x : Rn n) : rho α (-x) = rho α x := by
+  simp [rho, rhoNN_neg]
+
+theorem rho_sub_comm (α : Fin n → ℕ) (x y : Rn n) : rho α (x - y) = rho α (y - x) := by
+  rw [← neg_sub, rho_neg]
+
+/-- The iterated partial derivative `∂_{i₁} ⋯ ∂_{i_k} m(ξ)`, expressed via the `k`-th Fréchet
+derivative applied to the standard basis vectors `e_{i₁}, …, e_{i_k}`. For `m ∈ C^ν` near `ξ` and
+`k ≤ ν` these range exactly over the derivatives `∂^β m(ξ)`, `|β| = k`, of the paper (§1). -/
+def iterPartial (k : ℕ) (m : Rn n → ℂ) (i : Fin k → Fin n) (ξ : Rn n) : ℂ :=
+  iteratedFDeriv ℝ k m ξ (fun j => EuclideanSpace.single (i j) (1 : ℝ))
+
+/-- The multiplier class `𝓜^ν` of the paper (§1): `m` is (a) bounded and `C^ν` on `ℝⁿ ∖ {0}`,
+and (b) invariant under the anisotropic dilations, `m(δ_t ξ) = m(ξ)` for `ξ ≠ 0` and `t > 0`. -/
+structure ClassM (α : Fin n → ℕ) (ν : ℕ) (m : Rn n → ℂ) : Prop where
+  bounded : ∃ C : ℝ, ∀ ξ, ‖m ξ‖ ≤ C
+  contDiffOn : ContDiffOn ℝ ν m {0}ᶜ
+  homogeneous : ∀ ξ : Rn n, ξ ≠ 0 → ∀ t : ℝ, 0 < t → m (dil α t ξ) = m ξ
+
+/-- A multiplier that is continuous away from the origin is measurable. -/
+theorem ClassM.measurable {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m) :
+    Measurable m :=
+  measurable_of_continuousOn_compl_singleton 0 (hm.contDiffOn.continuousOn)
+
+theorem ClassM.bounded' {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ ξ, ‖m ξ‖ ≤ C := by
+  obtain ⟨C, hC⟩ := hm.bounded
+  exact ⟨max C 0, le_max_right _ _, fun ξ => (hC ξ).trans (le_max_left _ _)⟩
+
+/-- The norm `‖m‖_{𝓜^ν} = sup_{|β| ≤ ν} sup_{ρ(ξ)=1} |∂^β m(ξ)|` of the paper (§1), as an
+extended nonnegative real. -/
+def normM (α : Fin n → ℕ) (ν : ℕ) (m : Rn n → ℂ) : ℝ≥0∞ :=
+  ⨆ (k : ℕ) (_ : k ≤ ν) (i : Fin k → Fin n) (ξ : Rn n) (_ : rho α ξ = 1), ‖iterPartial k m i ξ‖ₑ
+
+/-- The Fourier transform in the normalization `f̂(ξ) = ∫ f(x) e^{-i x·ξ} dx`, compatible with the
+inversion kernel `e^{i x ξ}` used in the definition of `𝒞_m` (paper, §1). -/
+def fhat (f : Rn n → ℂ) (ξ : Rn n) : ℂ :=
+  ∫ x, Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) * f x
+
+/-- The Carleson operator associated with the multiplier `m` (paper, §1):
+`𝒞_m f(x) = sup_{N ∈ ℝⁿ} |∫ f̂(ξ) e^{i x ξ} m(ξ - N) dξ|`, with values in `[0, ∞]`. -/
+def carleson (m : Rn n → ℂ) (f : Rn n → ℂ) (x : Rn n) : ℝ≥0∞ :=
+  ⨆ N : Rn n, ‖∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * m (ξ - N)‖ₑ
+
+/-! ### Change of variables under anisotropic dilations -/
+
+/-- The dilation `δ_t` as a linear map (diagonal in the standard basis). -/
+def dilLin (α : Fin n → ℕ) (t : ℝ) : Rn n →ₗ[ℝ] Rn n :=
+  Matrix.toLin (EuclideanSpace.basisFun (Fin n) ℝ).toBasis
+    (EuclideanSpace.basisFun (Fin n) ℝ).toBasis (Matrix.diagonal fun i => t ^ α i)
+
+theorem dilLin_apply (α : Fin n → ℕ) (t : ℝ) (x : Rn n) : dilLin α t x = dil α t x := by
+  ext i
+  simp [dilLin, Matrix.toLin_apply, Matrix.mulVec_diagonal, Pi.single_apply]
+
+theorem det_dilLin (α : Fin n → ℕ) (t : ℝ) : LinearMap.det (dilLin α t) = t ^ absA α := by
+  rw [dilLin, LinearMap.det_toLin, Matrix.det_diagonal, absA, Finset.prod_pow_eq_pow_sum]
+
+theorem continuous_dil (α : Fin n → ℕ) (t : ℝ) : Continuous (dil α t : Rn n → Rn n) := by
+  rw [← funext (dilLin_apply α t)]
+  exact LinearMap.continuous_of_finiteDimensional _
+
+/-- Lebesgue measure transforms under `δ_t` by the Jacobian `t^{|α|}`. -/
+theorem map_dil_volume (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) :
+    Measure.map (dil α t) (volume : Measure (Rn n)) =
+      ENNReal.ofReal ((t ^ absA α)⁻¹) • volume := by
+  have hdet : LinearMap.det (dilLin α t) ≠ 0 := by rw [det_dilLin]; positivity
+  have h := Measure.map_linearMap_addHaar_eq_smul_addHaar (volume : Measure (Rn n)) hdet
+  have hfun : (⇑(dilLin α t) : Rn n → Rn n) = dil α t := funext (dilLin_apply α t)
+  rw [hfun, det_dilLin, abs_of_pos (by positivity)] at h
+  exact h
+
+theorem dil_measurableEmbedding (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) :
+    MeasurableEmbedding (dil α t : Rn n → Rn n) := by
+  have hinv : Function.LeftInverse (dil α t⁻¹) (dil α t) := fun x => by
+    rw [dil_dil, inv_mul_cancel₀ ht.ne', dil_one]
+  exact (continuous_dil α t).measurableEmbedding hinv.injective
+
+/-- Change of variables: `∫ g(δ_t x) dx = t^{-|α|} ∫ g(x) dx` for `t > 0`. -/
+theorem integral_comp_dil {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+    (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (g : Rn n → E) :
+    ∫ x, g (dil α t x) = (t ^ absA α)⁻¹ • ∫ x, g x := by
+  rw [← (dil_measurableEmbedding α ht).integral_map, map_dil_volume α ht,
+    integral_smul_measure, ENNReal.toReal_ofReal (by positivity)]
+
+/-- The dilations are self-adjoint: `⟨δ_t x, y⟩ = ⟨x, δ_t y⟩`. -/
+theorem inner_dil_left (α : Fin n → ℕ) (t : ℝ) (x y : Rn n) :
+    ⟪dil α t x, y⟫_ℝ = ⟪x, dil α t y⟫_ℝ := by
+  simp only [PiLp.inner_apply, dil_apply, RCLike.inner_apply, conj_trivial]
+  exact Finset.sum_congr rfl fun i _ => by ring
+
+/-! ## Section 3: rectangles, anisotropic dyadic cubes, tiles -/
+
+/-- The anisotropic distance `dist_α(A, B) = inf_{x ∈ A, y ∈ B} ρ(x - y)` (paper, §3). -/
+def distA (α : Fin n → ℕ) (A B : Set (Rn n)) : ℝ :=
+  sInf ((fun p : Rn n × Rn n => rho α (p.1 - p.2)) '' (A ×ˢ B))
+
+/-- The closed rectangle `[a, b] = ∏ᵢ [aᵢ, bᵢ]` (paper, §3). -/
+def rectIcc (a b : Rn n) : Set (Rn n) := {x | ∀ i, a i ≤ x i ∧ x i ≤ b i}
+
+/-- The half-open rectangle `[a, b) = ∏ᵢ [aᵢ, bᵢ)` (paper, §3). -/
+def rectIco (a b : Rn n) : Set (Rn n) := {x | ∀ i, a i ≤ x i ∧ x i < b i}
+
+/-- The open rectangle `(a, b) = ∏ᵢ (aᵢ, bᵢ)` (paper, §3). -/
+def rectIoo (a b : Rn n) : Set (Rn n) := {x | ∀ i, a i < x i ∧ x i < b i}
+
+/-- The center `c(I) = (a + b)/2` of a rectangle with corners `a`, `b` (paper, §3). -/
+def rectCenter (a b : Rn n) : Rn n := (2 : ℝ)⁻¹ • (a + b)
+
+/-- A closed anisotropic cube (paper, §3): a rectangle `[a, b]` with `bᵢ - aᵢ = λ^{αᵢ}` for all `i`
+and some `λ > 0`. The paper's maximal function (§7, texline~755) uses these cubes. -/
+def IsAnisoCube (α : Fin n → ℕ) (I : Set (Rn n)) : Prop :=
+  ∃ (a b : Rn n) (t : ℝ), 0 < t ∧ (∀ i, b i - a i = t ^ α i) ∧ I = rectIcc a b
+
+/-- Index data of an anisotropic dyadic cube `[δ_{2^k}(ℓ), δ_{2^k}(ℓ + 1))`, `k ∈ ℤ`, `ℓ ∈ ℤⁿ`
+(paper, §3, the collection `𝒟^α`). -/
+@[ext]
+structure DCube (n : ℕ) where
+  /-- The scale `k`: the cube has side lengths `2^{k αᵢ}`. -/
+  k : ℤ
+  /-- The position `ℓ ∈ ℤⁿ`. -/
+  ℓ : Fin n → ℤ
+
+/-- The side length `2^{k αᵢ}` of a dyadic cube of scale `k` in direction `i`. -/
+def side (α : Fin n → ℕ) (k : ℤ) (i : Fin n) : ℝ := (2 : ℝ) ^ (k * (α i : ℤ))
+
+theorem side_pos (α : Fin n → ℕ) (k : ℤ) (i : Fin n) : 0 < side α k i := by
+  unfold side
+  positivity
+
+theorem side_add (α : Fin n → ℕ) (k j : ℤ) (i : Fin n) :
+    side α (k + j) i = side α k i * side α j i := by
+  unfold side
+  rw [add_mul, zpow_add₀ (by norm_num)]
+
+/-- The point set `[δ_{2^k}(ℓ), δ_{2^k}(ℓ + 1)) = ∏ᵢ [2^{kαᵢ} ℓᵢ, 2^{kαᵢ}(ℓᵢ + 1))` of an
+anisotropic dyadic cube (paper, §3). -/
+def DCube.toSet (α : Fin n → ℕ) (Q : DCube n) : Set (Rn n) :=
+  {x | ∀ i, side α Q.k i * Q.ℓ i ≤ x i ∧ x i < side α Q.k i * (Q.ℓ i + 1)}
+
+theorem DCube.mem_toSet_iff_floor (α : Fin n → ℕ) (Q : DCube n) (x : Rn n) :
+    x ∈ Q.toSet α ↔ ∀ i, ⌊x i / side α Q.k i⌋ = Q.ℓ i := by
+  simp only [DCube.toSet, Set.mem_ofPred_eq, Int.floor_eq_iff]
+  refine forall_congr' fun i => ?_
+  have hs := side_pos α Q.k i
+  rw [le_div_iff₀ hs, div_lt_iff₀ hs, mul_comm (Q.ℓ i : ℝ), mul_comm ((Q.ℓ i : ℝ) + 1)]
+
+/-- The dyadic ancestor index: the unique cube of scale `k + j` (`j ≥ 0`) containing `Q`. -/
+def DCube.ancestor (α : Fin n → ℕ) (Q : DCube n) (j : ℕ) : DCube n :=
+  ⟨Q.k + j, fun i => Q.ℓ i / (2 ^ (j * α i) : ℕ)⟩
+
+theorem side_natCast_eq (α : Fin n → ℕ) (k : ℤ) (j : ℕ) (i : Fin n) :
+    side α (k + j) i = side α k i * ((2 ^ (j * α i) : ℕ) : ℝ) := by
+  rw [side_add]
+  congr 1
+  simp [side, zpow_mul, zpow_natCast, pow_mul]
+
+theorem DCube.toSet_subset_ancestor (α : Fin n → ℕ) (Q : DCube n) (j : ℕ) :
+    Q.toSet α ⊆ (Q.ancestor α j).toSet α := by
+  intro x hx
+  rw [DCube.mem_toSet_iff_floor] at hx ⊢
+  intro i
+  simp only [DCube.ancestor]
+  rw [side_natCast_eq, ← div_div, Int.floor_div_natCast, hx i]
+
+/-- Two anisotropic dyadic cubes are either nested or disjoint (paper, §3, texline~172):
+if `Q` has scale at most that of `Q'` then `Q ⊆ Q'` or `Q ∩ Q' = ∅`. -/
+theorem DCube.subset_or_disjoint (α : Fin n → ℕ) (Q Q' : DCube n) (hk : Q.k ≤ Q'.k) :
+    Q.toSet α ⊆ Q'.toSet α ∨ Disjoint (Q.toSet α) (Q'.toSet α) := by
+  obtain ⟨j, hj⟩ := Int.eq_ofNat_of_zero_le (sub_nonneg.mpr hk)
+  have hQ' : Q'.k = Q.k + j := by omega
+  by_cases h : Q.ancestor α j = Q'
+  · left
+    rw [← h]
+    exact DCube.toSet_subset_ancestor α Q j
+  · right
+    rw [Set.disjoint_left]
+    intro x hx hx'
+    apply h
+    have hxa := DCube.toSet_subset_ancestor α Q j hx
+    rw [DCube.mem_toSet_iff_floor] at hxa hx'
+    ext
+    · simp [DCube.ancestor, hQ']
+    · rename_i i
+      rw [← hxa i, ← hx' i]
+      simp [DCube.ancestor, hQ']
+
+/-- The parent `I⁺` of an anisotropic dyadic cube (paper, §3, texline~172). -/
+def DCube.parent (α : Fin n → ℕ) (Q : DCube n) : DCube n := Q.ancestor α 1
+
+theorem DCube.toSet_subset_parent (α : Fin n → ℕ) (Q : DCube n) :
+    Q.toSet α ⊆ (Q.parent α).toSet α :=
+  DCube.toSet_subset_ancestor α Q 1
+
+theorem DCube.toSet_eq_preimage (α : Fin n → ℕ) (Q : DCube n) :
+    Q.toSet α = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹'
+      Set.pi Set.univ (fun i => Set.Ico (side α Q.k i * Q.ℓ i) (side α Q.k i * (Q.ℓ i + 1))) := by
+  ext x
+  simp [DCube.toSet]
+
+theorem DCube.measurableSet_toSet (α : Fin n → ℕ) (Q : DCube n) : MeasurableSet (Q.toSet α) := by
+  rw [DCube.toSet_eq_preimage]
+  exact (MeasurableSet.univ_pi fun i => measurableSet_Ico).preimage (PiLp.volume_preserving_ofLp
+      _).measurable
+
+/-- The volume of an anisotropic dyadic cube of scale `k` is `2^{k|α|}` (paper, §3). -/
+theorem DCube.volume_toSet (α : Fin n → ℕ) (Q : DCube n) :
+    volume (Q.toSet α) = ENNReal.ofReal ((2 : ℝ) ^ (Q.k * (absA α : ℤ))) := by
+  rw [DCube.toSet_eq_preimage, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun i => measurableSet_Ico).nullMeasurableSet, Real.volume_pi_Ico]
+  have : ∀ i, side α Q.k i * (Q.ℓ i + 1) - side α Q.k i * Q.ℓ i = side α Q.k i := by
+    intro i; ring
+  simp only [this]
+  rw [← ENNReal.ofReal_prod_of_nonneg (fun i _ => (side_pos α Q.k i).le)]
+  congr 1
+  simp only [side, absA, zpow_mul, zpow_natCast]
+  exact Finset.prod_pow_eq_pow_sum _ _ _
+
+/-- The parent has volume `2^{|α|}` times that of the child (paper, §3, texline~172). -/
+theorem DCube.volume_parent (α : Fin n → ℕ) (Q : DCube n) :
+    volume ((Q.parent α).toSet α) = 2 ^ absA α * volume (Q.toSet α) := by
+  rw [DCube.volume_toSet, DCube.volume_toSet]
+  simp only [DCube.parent, DCube.ancestor, Nat.cast_one]
+  rw [add_mul, one_mul, zpow_add₀ (by norm_num), ENNReal.ofReal_mul (by positivity), mul_comm]
+  congr 1
+  simp
+
+/-- A tile (paper, Definition 3.1): a product `P = I_P × ω_P` of anisotropic dyadic cubes with
+`|I_P| · |ω_P| = 1`. Since `|I| = 2^{k|α|}` for a cube of scale `k`, this forces `ω_P` to have
+scale `-k_P`; a tile is therefore given by its scale `k_P` (with `|I_P| = 2^{k_P |α|}`),
+the spatial position `ℓ` and the frequency position `u`. -/
+@[ext]
+structure Tile (n : ℕ) where
+  /-- The scale `k_P`. -/
+  k : ℤ
+  /-- The spatial position: `I_P = [δ_{2^k}(ℓ), δ_{2^k}(ℓ + 1))`. -/
+  ℓ : Fin n → ℤ
+  /-- The frequency position: `ω_P = [δ_{2^{-k}}(u), δ_{2^{-k}}(u + 1))`. -/
+  u : Fin n → ℤ
+
+/-- The spatial cube `I_P` of a tile. -/
+def Tile.I (P : Tile n) : DCube n := ⟨P.k, P.ℓ⟩
+
+/-- The frequency cube `ω_P` of a tile. -/
+def Tile.ω (P : Tile n) : DCube n := ⟨-P.k, P.u⟩
+
+/-- Tiles have area one: `|I_P| · |ω_P| = 1` (paper, Definition 3.1). -/
+theorem Tile.volume_I_mul_volume_ω (α : Fin n → ℕ) (P : Tile n) :
+    volume (P.I.toSet α) * volume (P.ω.toSet α) = 1 := by
+  rw [DCube.volume_toSet, DCube.volume_toSet, ← ENNReal.ofReal_mul (by positivity),
+    ← zpow_add₀ (by norm_num)]
+  simp [Tile.I, Tile.ω]
+
+/-- Conversely, every pair of anisotropic dyadic cubes of area one is a tile
+(paper, Definition 3.1), provided `|α| ≥ 1`. -/
+theorem Tile.exists_of_volume_mul (α : Fin n → ℕ) (hα : 1 ≤ absA α) (I ω : DCube n)
+    (h : volume (I.toSet α) * volume (ω.toSet α) = 1) : ∃ P : Tile n, P.I = I ∧ P.ω = ω := by
+  refine ⟨⟨I.k, I.ℓ, ω.ℓ⟩, rfl, ?_⟩
+  rw [DCube.volume_toSet, DCube.volume_toSet, ← ENNReal.ofReal_mul (by positivity),
+    ← zpow_add₀ (by norm_num), ENNReal.ofReal_eq_one, ← zpow_zero (2 : ℝ)] at h
+  have h2 := zpow_right_injective₀ (a := (2 : ℝ)) (by norm_num) (by norm_num) h
+  have hne : (absA α : ℤ) ≠ 0 := by omega
+  have h3 : (I.k + ω.k) * (absA α : ℤ) = 0 := by rw [← h2]; ring
+  have : ω.k = -I.k := by
+    rcases mul_eq_zero.mp h3 with h4 | h4
+    · omega
+    · exact absurd h4 hne
+  ext
+  · simp [Tile.ω, this]
+  · simp [Tile.ω]
+
+/-- The semi-tile frequency cube `ω_{P(r)}` for `r ∈ {0,1}ⁿ` (paper, Definition 3.1,
+texline~177):
+`ω_{P(r)} = [δ_{2^{-k_P}}(u + r/2), δ_{2^{-k_P}}(u + (r+1)/2)]` (a closed rectangle). -/
+def Tile.semi (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) : Set (Rn n) :=
+  {ξ | ∀ i, side α (-P.k) i * (P.u i + (r i : ℝ) / 2) ≤ ξ i ∧
+    ξ i ≤ side α (-P.k) i * (P.u i + ((r i : ℝ) + 1) / 2)}
+
+/-- The center of the spatial cube, `c(I_P) = δ_{2^{k_P}}(ℓ + 1/2)`. -/
+def Tile.cI (α : Fin n → ℕ) (P : Tile n) : Rn n :=
+  WithLp.toLp 2 (fun i => side α P.k i * (P.ℓ i + 1 / 2))
+
+/-- The center of the lower semi-tile, `c(ω_{P(0)}) = δ_{2^{-k_P}}(u + 1/4)`. -/
+def Tile.cω0 (α : Fin n → ℕ) (P : Tile n) : Rn n :=
+  WithLp.toLp 2 (fun i => side α (-P.k) i * (P.u i + 1 / 4))
+
+/-- The center of the frequency cube, `c(ω_P) = δ_{2^{-k_P}}(u + 1/2)`. -/
+def Tile.cω (α : Fin n → ℕ) (P : Tile n) : Rn n :=
+  WithLp.toLp 2 (fun i => side α (-P.k) i * (P.u i + 1 / 2))
+
+/-- The paper's Fourier transform in terms of Mathlib's: `f̂(ξ) = 𝓕 f(ξ / 2π)`. -/
+theorem fhat_eq_fourier (f : Rn n → ℂ) (ξ : Rn n) :
+    fhat f ξ = FourierTransform.fourier f ((2 * π)⁻¹ • ξ) := by
+  simp only [fhat, Real.fourier_eq]
+  congr 1
+  ext v
+  rw [Circle.smul_def, Real.fourierChar_apply, inner_smul_right]
+  congr 2
+  push_cast
+  field_simp
+
+/-- The constant `b₀ = 1/10` of the paper (§3, texline~179). -/
+def b0 : ℝ := 1 / 10
+
+/-- The constant `b₁ = 9/100` of the paper (§3, texline~179). -/
+def b1 : ℝ := 9 / 100
+
+/-- A one-dimensional smooth bump, equal to `1` on `[-b₁/2, b₁/2]`, supported in
+`(-b₀/2, b₀/2)`, with values in `[0, 1]`. -/
+def eta1 : ContDiffBump (0 : ℝ) := ⟨b1 / 2, b0 / 2, by norm_num [b1], by norm_num [b0, b1]⟩
+
+/-- The prescribed Fourier transform `φ̂(ξ) = ∏ᵢ η(ξᵢ)` of the wave packet generator. -/
+def phiHat (ξ : Rn n) : ℂ := ∏ i, ((eta1 (ξ i) : ℝ) : ℂ)
+
+theorem contDiff_phiHat : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (phiHat : Rn n → ℂ) := by
+  unfold phiHat
+  apply contDiff_prod
+  intro i _
+  exact Complex.ofRealCLM.contDiff.comp
+    (eta1.contDiff.comp (EuclideanSpace.proj i : Rn n →L[ℝ] ℝ).contDiff)
+
+theorem phiHat_eq_zero_of_lt {ξ : Rn n} {i : Fin n} (h : b0 / 2 ≤ |ξ i|) : phiHat ξ = 0 := by
+  unfold phiHat
+  apply Finset.prod_eq_zero (Finset.mem_univ i)
+  have : ξ i ∉ Function.support eta1 := by
+    rw [eta1.support_eq]
+    simpa [Real.norm_eq_abs, eta1] using h
+  simp [Function.notMem_support.mp this]
+
+theorem phiHat_eq_one {ξ : Rn n} (h : ∀ i, |ξ i| ≤ b1 / 2) : phiHat ξ = 1 := by
+  unfold phiHat
+  apply Finset.prod_eq_one
+  intro i _
+  rw [eta1.one_of_mem_closedBall]
+  · simp
+  · simpa [Real.norm_eq_abs, eta1] using h i
+
+theorem phiHat_re_mem (ξ : Rn n) : phiHat ξ = ((phiHat ξ).re : ℂ) ∧ 0 ≤ (phiHat ξ).re ∧
+    (phiHat ξ).re ≤ 1 := by
+  have : phiHat ξ = ((∏ i, eta1 (ξ i) : ℝ) : ℂ) := by simp [phiHat]
+  rw [this, Complex.ofReal_re]
+  exact ⟨rfl, Finset.prod_nonneg fun i _ => eta1.nonneg,
+    Finset.prod_le_one₀ (fun i _ => eta1.nonneg) fun i _ => eta1.le_one⟩
+
+theorem hasCompactSupport_phiHat : HasCompactSupport (phiHat : Rn n → ℂ) := by
+  have hK : IsCompact ((WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun _ => Set.Icc (-(b0 / 2)) (b0 / 2)) :=
+    (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+  apply HasCompactSupport.intro hK
+  intro ξ hξ
+  have : ∃ i, b0 / 2 ≤ |ξ i| := by
+    by_contra hcon
+    simp only [not_exists, not_le] at hcon
+    apply hξ
+    refine ⟨WithLp.ofLp ξ, ?_, by simp⟩
+    intro i _
+    exact abs_le.mp (hcon i).le
+  obtain ⟨i, hi⟩ := this
+  exact phiHat_eq_zero_of_lt hi
+
+/-- The rescaling `η ↦ φ̂(2π η)`, the Mathlib Fourier transform of the generator. -/
+def phiHatScaled : 𝓢(Rn n, ℂ) :=
+  HasCompactSupport.toSchwartzMap (f := fun η : Rn n => phiHat ((2 * π) • η))
+    (hasCompactSupport_phiHat.comp_smul (by positivity))
+    (contDiff_phiHat.comp (contDiff_const_smul _))
+
+/-- The fixed Schwartz function `φ` of the paper (§3, texline~179), defined by prescribing its
+Fourier transform `φ̂ = phiHat`. -/
+def phi : 𝓢(Rn n, ℂ) := FourierTransformInv.fourierInv phiHatScaled
+
+/-- The generator `φ` has the Fourier transform `phiHat` (paper normalization). -/
+theorem fhat_phi (ξ : Rn n) : fhat (phi : Rn n → ℂ) ξ = phiHat ξ := by
+  rw [fhat_eq_fourier, ← SchwartzMap.fourier_coe, phi, FourierInvPair.fourier_fourierInv_eq]
+  change phiHat ((2 * π) • (2 * π)⁻¹ • ξ) = phiHat ξ
+  rw [smul_smul, mul_inv_cancel₀ (by positivity : (2 * π) ≠ 0), one_smul]
+
+/-- Existence of the wave packet generator (paper, §3, texline~179): a Schwartz function `φ` with
+`0 ≤ φ̂ ≤ 1`, `φ̂` supported in `[-b₀/2, b₀/2]ⁿ` and equal to `1` on `[-b₁/2, b₁/2]ⁿ`. -/
+theorem phi_spec :
+    (∀ ξ : Rn n, fhat (phi : Rn n → ℂ) ξ = ((fhat (phi : Rn n → ℂ) ξ).re : ℂ) ∧
+      0 ≤ (fhat (phi : Rn n → ℂ) ξ).re ∧ (fhat (phi : Rn n → ℂ) ξ).re ≤ 1) ∧
+    (∀ ξ : Rn n, (∃ i, b0 / 2 ≤ |ξ i|) → fhat (phi : Rn n → ℂ) ξ = 0) ∧
+    (∀ ξ : Rn n, (∀ i, |ξ i| ≤ b1 / 2) → fhat (phi : Rn n → ℂ) ξ = 1) := by
+  simp only [fhat_phi]
+  exact ⟨phiHat_re_mem, fun ξ ⟨i, hi⟩ => phiHat_eq_zero_of_lt hi, fun ξ h => phiHat_eq_one h⟩
+
+/-- Translation `T_y f(x) = f(x - y)` (paper, §3, texline~181). -/
+def transl (y : Rn n) (f : Rn n → ℂ) : Rn n → ℂ := fun x => f (x - y)
+
+/-- Modulation `M_ξ f(x) = e^{i x ξ} f(x)` (paper, §3, texline~182). -/
+def modul (ξ : Rn n) (f : Rn n → ℂ) : Rn n → ℂ :=
+  fun x => Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) * f x
+
+/-- `L^p`-normalized anisotropic dilation `D^p_t f(x) = t^{-|α|/p} f(δ_{t⁻¹} x)` (paper, §3,
+texline~183). -/
+def dilOp (α : Fin n → ℕ) (p t : ℝ) (f : Rn n → ℂ) : Rn n → ℂ :=
+  fun x => ((t ^ (-(absA α : ℝ) / p) : ℝ) : ℂ) * f (dil α t⁻¹ x)
+
+/-- The wave packet `φ_P = M_{c(ω_{P(0)})} T_{c(I_P)} D²_{2^{k_P}} φ` (paper, §3, (3.1)). -/
+def wavePhi (α : Fin n → ℕ) (P : Tile n) : Rn n → ℂ :=
+  modul (P.cω0 α) (transl (P.cI α) (dilOp α 2 ((2 : ℝ) ^ P.k) (phi : Rn n → ℂ)))
+
+/-- The wave packet `ψ^N_P` (paper, §3, (3.2)), defined by `ψ̂^N_P(ξ) = m(ξ - N) φ̂_P(ξ)`, i.e. by
+Fourier inversion `ψ^N_P(x) = (2π)^{-n} ∫ m(ξ - N) φ̂_P(ξ) e^{i x ξ} dξ` in the paper's
+normalization. -/
+def wavePsi (α : Fin n → ℕ) (m : Rn n → ℂ) (N : Rn n) (P : Tile n) : Rn n → ℂ :=
+  fun x => (((2 * π) ^ n)⁻¹ : ℂ) *
+    ∫ ξ, m (ξ - N) * fhat (wavePhi α P) ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))
+
+/-- The Fourier transform of a modulated, translated and dilated function. -/
+theorem fhat_modul_transl_dilOp (α : Fin n → ℕ) (c a : Rn n) {t : ℝ} (ht : 0 < t)
+    (g : Rn n → ℂ) (ξ : Rn n) :
+    fhat (modul c (transl a (dilOp α 2 t g))) ξ =
+      ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (-(Complex.I * (⟪a, ξ - c⟫_ℝ : ℂ))) * fhat g (dil α t (ξ - c)) := by
+  simp only [fhat, modul, transl, dilOp]
+  set s : ℂ := ((t ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) with hs
+  set G : Rn n → ℂ := fun z =>
+    Complex.exp (-(Complex.I * (⟪dil α t z + a, ξ - c⟫_ℝ : ℂ))) * (s * g z) with hG
+  have h1 : ∀ x : Rn n, Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) *
+      (Complex.exp (Complex.I * (⟪x, c⟫_ℝ : ℂ)) * (s * g (dil α t⁻¹ (x - a)))) =
+      G (dil α t⁻¹ (x - a)) := by
+    intro x
+    simp only [hG, dil_dil, mul_inv_cancel₀ ht.ne', dil_one, sub_add_cancel, inner_sub_right]
+    rw [← mul_assoc, ← Complex.exp_add]
+    congr 2
+    push_cast
+    ring
+  calc (∫ x, Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) *
+        (Complex.exp (Complex.I * (⟪x, c⟫_ℝ : ℂ)) * (s * g (dil α t⁻¹ (x - a)))))
+      = ∫ x, G (dil α t⁻¹ (x - a)) := by
+        congr 1; ext x; exact h1 x
+    _ = ∫ y, G (dil α t⁻¹ y) := integral_sub_right_eq_self (fun y => G (dil α t⁻¹ y)) a
+    _ = (t⁻¹ ^ absA α)⁻¹ • ∫ z, G z := integral_comp_dil α (inv_pos.mpr ht) G
+    _ = _ := by
+      have ht' : (t⁻¹ ^ absA α)⁻¹ = t ^ (absA α : ℝ) := by
+        rw [inv_pow, inv_inv, Real.rpow_natCast]
+      have hpow : t ^ (absA α : ℝ) * t ^ (-(absA α : ℝ) / 2) = t ^ ((absA α : ℝ) / 2) := by
+        rw [← Real.rpow_add ht]
+        congr 1
+        ring
+      rw [ht', Complex.real_smul, ← hpow, ← integral_const_mul, ← integral_const_mul]
+      congr 1
+      ext z
+      simp only [hG, hs, inner_add_left, inner_dil_left]
+      have hexp : Complex.exp (-(Complex.I * ((⟪z, dil α t (ξ - c)⟫_ℝ + ⟪a, ξ - c⟫_ℝ : ℝ) : ℂ))) =
+          Complex.exp (-(Complex.I * (⟪a, ξ - c⟫_ℝ : ℂ))) *
+            Complex.exp (-(Complex.I * (⟪z, dil α t (ξ - c)⟫_ℝ : ℂ))) := by
+        rw [← Complex.exp_add]
+        congr 1
+        push_cast
+        ring
+      rw [hexp]
+      push_cast
+      ring
+
+/-- The Fourier transform of the wave packet (paper, §3, texline~191):
+`φ̂_P(ξ) = 2^{k_P|α|/2} e^{-i c(I_P)(ξ - c(ω_{P(0)}))} φ̂(δ_{2^{k_P}}(ξ - c(ω_{P(0)})))`. -/
+theorem fhat_wavePhi (α : Fin n → ℕ) (P : Tile n) (ξ : Rn n) :
+    fhat (wavePhi α P) ξ =
+      ((((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        Complex.exp (-(Complex.I * (⟪P.cI α, ξ - P.cω0 α⟫_ℝ : ℂ))) *
+          phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α)) := by
+  rw [wavePhi, fhat_modul_transl_dilOp α _ _ (by positivity), fhat_phi]
+
+theorem dil_zpow_apply (α : Fin n → ℕ) (k : ℤ) (x : Rn n) (i : Fin n) :
+    dil α ((2 : ℝ) ^ k) x i = side α k i * x i := by
+  simp [side, zpow_mul, zpow_natCast]
+
+/-- Fourier support of the wave packet (paper, §3, texline~191): `φ̂_P(ξ) ≠ 0` forces
+`|ξᵢ - c(ω_{P(0)})ᵢ| < 2^{-k_P αᵢ} b₀/2` for all `i`. -/
+theorem abs_sub_cω0_lt_of_fhat_wavePhi_ne_zero (α : Fin n → ℕ) (P : Tile n) {ξ : Rn n}
+    (h : fhat (wavePhi α P) ξ ≠ 0) (i : Fin n) :
+    |ξ i - P.cω0 α i| < side α (-P.k) i * (b0 / 2) := by
+  rw [fhat_wavePhi] at h
+  have h' : phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α)) ≠ 0 := right_ne_zero_of_mul h
+  have hi : |dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α) i| < b0 / 2 := by
+    by_contra hcon
+    exact h' (phiHat_eq_zero_of_lt (not_lt.mp hcon))
+  rw [dil_zpow_apply, abs_mul, abs_of_pos (side_pos α P.k i)] at hi
+  have hs : side α (-P.k) i * side α P.k i = 1 := by
+    rw [← side_add]; simp [side]
+  have := mul_lt_mul_of_pos_left hi (side_pos α (-P.k) i)
+  rwa [← mul_assoc, hs, one_mul] at this
+
+/-- The Fourier transform of `φ_P` is supported in the lower semi-tile `ω_{P(0)}` (paper, §3,
+texline~191). -/
+theorem mem_semi_zero_of_fhat_wavePhi_ne_zero (α : Fin n → ℕ) (P : Tile n) {ξ : Rn n}
+    (h : fhat (wavePhi α P) ξ ≠ 0) : ξ ∈ P.semi α 0 := by
+  intro i
+  have hlt := abs_sub_cω0_lt_of_fhat_wavePhi_ne_zero α P h i
+  have hs := side_pos α (-P.k) i
+  simp only [Tile.cω0, PiLp.toLp_apply] at hlt
+  rw [abs_lt] at hlt
+  simp only [Pi.zero_apply, Fin.val_zero, Nat.cast_zero, zero_div, add_zero, zero_add]
+  norm_num [b0] at hlt
+  constructor <;> nlinarith
+
+/-- The `L²` pairing `⟨f, g⟩ = ∫ f gbar`. -/
+def pairing (f g : Rn n → ℂ) : ℂ := ∫ x, f x * (starRingEnd ℂ) (g x)
+
+/-- The dyadic model sum operator (paper, §3, (3.3)):
+`A^{r,m}_N f(x) = ∑_{P ∈ 𝒫_bar} ⟨f, φ_P⟩ ψ^N_P(x) 1_{ω_{P(r)}}(N)`, the sum over all tiles.
+(Convergence of this sum for Schwartz `f` is proved separately; `tsum` is only used where
+summability has been established.) -/
+def modelOp (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (N : Rn n) (f : Rn n → ℂ)
+    (x : Rn n) : ℂ :=
+  ∑' P : Tile n, pairing f (wavePhi α P) * wavePsi α m N P x *
+    (P.semi α r).indicator (fun _ => (1 : ℂ)) N
+
+/-! ## Section 4: auxiliary estimates -/
+
+/-- The dilation `δ_s` as a continuous linear map. -/
+def dilCLM (α : Fin n → ℕ) (s : ℝ) : Rn n →L[ℝ] Rn n :=
+  LinearMap.toContinuousLinearMap (dilLin α s)
+
+theorem dilCLM_apply (α : Fin n → ℕ) (s : ℝ) (x : Rn n) : dilCLM α s x = dil α s x :=
+  dilLin_apply α s x
+
+theorem dil_ne_zero (α : Fin n → ℕ) {s : ℝ} (hs : 0 < s) {x : Rn n} (hx : x ≠ 0) :
+    dil α s x ≠ 0 := by
+  intro h
+  apply hx
+  have := congrArg (dil α s⁻¹) h
+  rwa [dil_dil, inv_mul_cancel₀ hs.ne', dil_one, dil_zero] at this
+
+theorem dil_single (α : Fin n → ℕ) (s : ℝ) (i : Fin n) :
+    dil α s (EuclideanSpace.single i (1 : ℝ)) = s ^ α i • EuclideanSpace.single i (1 : ℝ) := by
+  ext j
+  by_cases h : j = i
+  · subst h; simp
+  · simp [h]
+
+/-- Scaling of the derivatives of a dilation-invariant multiplier: for `s > 0` and `ξ ≠ 0`,
+`∂_{i₁} ⋯ ∂_{i_k} m(ξ) = (∏_j s^{α_{i_j}}) ∂_{i₁} ⋯ ∂_{i_k} m(δ_s ξ)` (used for the symbol
+estimate, paper §4, (4.13)). -/
+theorem iterPartial_eq_prod_mul_iterPartial_dil (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {k : ℕ} (hk : k ≤ ν) (i : Fin k → Fin n) {s : ℝ} (hs : 0 < s)
+    {ξ : Rn n} (hξ : ξ ≠ 0) :
+    iterPartial k m i ξ = (∏ j, s ^ α (i j) : ℝ) • iterPartial k m i (dil α s ξ) := by
+  set L := dilCLM α s
+  have hopen : IsOpen ({0}ᶜ : Set (Rn n)) := isOpen_compl_singleton
+  -- `m ∘ L = m` near `ξ`
+  have heq : (m ∘ L) =ᶠ[nhds ξ] m := by
+    filter_upwards [hopen.mem_nhds hξ] with y hy
+    simp only [Function.comp_apply, L, dilCLM_apply]
+    exact hm.homogeneous y hy s hs
+  have hpre : (L ⁻¹' ({0}ᶜ : Set (Rn n))) = {0}ᶜ := by
+    ext y
+    simp only [Set.mem_preimage, Set.mem_compl_iff, Set.mem_singleton_iff, L, dilCLM_apply]
+    constructor
+    · intro h hy; exact h (by rw [hy, dil_zero])
+    · intro h; exact dil_ne_zero α hs h
+  have hLξ : L ξ ∈ ({0}ᶜ : Set (Rn n)) := by
+    simp only [L, dilCLM_apply]; exact dil_ne_zero α hs hξ
+  have hcomp := L.iteratedFDerivWithin_comp_right hm.contDiffOn hopen.uniqueDiffOn
+    (by rw [hpre]; exact hopen.uniqueDiffOn) hLξ (i := k) (by exact_mod_cast hk)
+  rw [hpre, iteratedFDerivWithin_of_isOpen k hopen hξ,
+    iteratedFDerivWithin_of_isOpen k hopen hLξ] at hcomp
+  unfold iterPartial
+  rw [← (heq.iteratedFDeriv ℝ k).eq_of_nhds, hcomp,
+    ContinuousMultilinearMap.compContinuousLinearMap_apply]
+  simp only [L, dilCLM_apply, dil_single]
+  rw [ContinuousMultilinearMap.map_smul_univ]
+
+/-- Symbol estimate (paper, §4, (4.13)), in the general form for mixed derivatives:
+for `m ∈ 𝓜^ν`, `k ≤ ν` and `ξ ≠ 0`,
+`|∂_{i₁} ⋯ ∂_{i_k} m(ξ)| ≤ ‖m‖_{𝓜^ν} ∏_j ρ(ξ)^{-α_{i_j}}`; in particular
+`|∂_i^k m(ξ)| ≤ ‖m‖_{𝓜^ν} ρ(ξ)^{-k αᵢ}`. -/
+theorem symbol_estimate (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {k : ℕ} (hk : k ≤ ν) (i : Fin k → Fin n) {ξ : Rn n} (hξ : ξ ≠ 0) :
+    ‖iterPartial k m i ξ‖ₑ ≤ normM α ν m * ENNReal.ofReal (∏ j, rho α ξ ^ (-(α (i j) : ℝ))) := by
+  have hρ : 0 < rho α ξ := by
+    rcases (rho_nonneg α ξ).lt_or_eq with h | h
+    · exact h
+    · exfalso
+      apply hξ
+      ext j
+      have h0 : rhoNN α ξ = 0 := NNReal.coe_eq_zero.mp h.symm
+      have := coord_rpow_le_rhoNN α ξ j
+      rw [h0, nonpos_iff_eq_zero] at this
+      have hne : ((α j : ℝ)⁻¹) ≠ 0 := by have := hα j; positivity
+      simpa [NNReal.rpow_eq_zero_iff, hne] using this
+  set s := (rho α ξ)⁻¹
+  have hs : 0 < s := inv_pos.mpr hρ
+  have hunit : rho α (dil α s ξ) = 1 := by
+    rw [rho_dil α hα hs]; exact inv_mul_cancel₀ hρ.ne'
+  rw [iterPartial_eq_prod_mul_iterPartial_dil α hm hk i hs hξ, enorm_smul, mul_comm]
+  have hprod : (∏ j, s ^ α (i j) : ℝ) = ∏ j, rho α ξ ^ (-(α (i j) : ℝ)) := by
+    refine Finset.prod_congr rfl fun j _ => ?_
+    rw [Real.rpow_neg hρ.le, Real.rpow_natCast, inv_pow]
+  have hnn : 0 ≤ (∏ j, s ^ α (i j) : ℝ) := Finset.prod_nonneg fun j _ => by positivity
+  rw [Real.enorm_eq_ofReal hnn, hprod]
+  gcongr
+  exact le_iSup₂_of_le k hk (le_iSup_of_le i (le_iSup₂_of_le (dil α s ξ) hunit le_rfl))
+
+/-- The wave packet `ψ^N_P` in rescaled Fourier form (paper, §8, (8.1)), before using the
+dilation invariance of `m`:
+`ψ^N_P(x) = (2π)^{-n} 2^{-k_P|α|/2} e^{i x c(ω_{P(0)})}
+  ∫ e^{i ζ δ_{2^{-k_P}}(x - c(I_P))} m(c(ω_{P(0)}) - N + δ_{2^{-k_P}} ζ) φ̂(ζ) dζ`. -/
+theorem wavePsi_eq_rescaled (α : Fin n → ℕ) (m : Rn n → ℂ) (N : Rn n) (P : Tile n) (x : Rn n) :
+    wavePsi α m N P x = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ((((2 : ℝ) ^ P.k) ^ (-((absA α : ℝ) / 2)) : ℝ) : ℂ) *
+        Complex.exp (Complex.I * (⟪x, P.cω0 α⟫_ℝ : ℂ)) *
+          ∫ ζ, Complex.exp (Complex.I * (⟪dil α ((2 : ℝ) ^ P.k)⁻¹ (x - P.cI α), ζ⟫_ℝ : ℂ)) *
+            m (P.cω0 α - N + dil α ((2 : ℝ) ^ P.k)⁻¹ ζ) * phiHat ζ := by
+  set t : ℝ := (2 : ℝ) ^ P.k with ht_def
+  have ht : 0 < t := by positivity
+  set c0 := P.cω0 α
+  set a := P.cI α
+  simp only [wavePsi, fhat_wavePhi]
+  rw [mul_assoc, mul_assoc]
+  congr 1
+  set G : Rn n → ℂ := fun ξ' => m (c0 + ξ' - N) *
+      (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) * Complex.exp (-(Complex.I * (⟪a, c0 + ξ' - c0⟫_ℝ : ℂ))) *
+        phiHat (dil α t (c0 + ξ' - c0))) * Complex.exp (Complex.I * (⟪x, c0 + ξ'⟫_ℝ : ℂ)) with hG
+  have h1 : (∫ ξ, m (ξ - N) * (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+      Complex.exp (-(Complex.I * (⟪a, ξ - c0⟫_ℝ : ℂ))) * phiHat (dil α t (ξ - c0))) *
+        Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) = ∫ ξ', G ξ' := by
+    rw [← integral_add_left_eq_self (μ := volume) _ c0]
+  have h2 : (∫ ξ', G ξ') = (t⁻¹ ^ absA α) • ∫ ζ, G (dil α t⁻¹ ζ) := by
+    rw [integral_comp_dil α (inv_pos.mpr ht), smul_smul, mul_inv_cancel₀ (by positivity),
+      one_smul]
+  rw [h1, h2, Complex.real_smul, ← integral_const_mul, ← integral_const_mul,
+    ← integral_const_mul]
+  congr 1
+  ext ζ
+  simp only [hG, add_sub_cancel_left, dil_dil, mul_inv_cancel₀ ht.ne', dil_one, inner_add_right,
+    inner_sub_left, inner_dil_left]
+  have hpow : ((t⁻¹ ^ absA α : ℝ) : ℂ) * ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) =
+      ((t ^ (-((absA α : ℝ) / 2)) : ℝ) : ℂ) := by
+    rw [← Complex.ofReal_mul]
+    congr 1
+    rw [inv_pow, ← Real.rpow_natCast, ← Real.rpow_neg ht.le, ← Real.rpow_add ht]
+    congr 1
+    ring
+  have hexp : Complex.exp (-(Complex.I * (⟪a, dil α t⁻¹ ζ⟫_ℝ : ℂ))) *
+      Complex.exp (Complex.I * ((⟪x, c0⟫_ℝ + ⟪x, dil α t⁻¹ ζ⟫_ℝ : ℝ) : ℂ)) =
+      Complex.exp (Complex.I * (⟪x, c0⟫_ℝ : ℂ)) *
+        Complex.exp (Complex.I * ((⟪dil α t⁻¹ x, ζ⟫_ℝ - ⟪dil α t⁻¹ a, ζ⟫_ℝ : ℝ) : ℂ)) := by
+    rw [← Complex.exp_add, ← Complex.exp_add]
+    congr 1
+    rw [← inner_dil_left, ← inner_dil_left]
+    push_cast
+    ring
+  have hc : c0 - N + dil α t⁻¹ ζ = c0 + dil α t⁻¹ ζ - N := by abel
+  rw [hc]
+  calc _ = ((t⁻¹ ^ absA α : ℝ) : ℂ) * ((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+        (Complex.exp (-(Complex.I * (⟪a, dil α t⁻¹ ζ⟫_ℝ : ℂ))) *
+          Complex.exp (Complex.I * ((⟪x, c0⟫_ℝ + ⟪x, dil α t⁻¹ ζ⟫_ℝ : ℝ) : ℂ))) *
+        (m (c0 + dil α t⁻¹ ζ - N) * phiHat ζ) := by push_cast; ring
+    _ = _ := by rw [hpow, hexp]; simp only [inner_dil_left]; push_cast; ring
+
+/-! ### Tools for the wave packet estimates (paper, §8) -/
+
+theorem eq_sum_single (v : Rn n) : v = ∑ j, v j • EuclideanSpace.single j (1 : ℝ) := by
+  ext i
+  simp [Finset.sum_apply, Pi.single_apply]
+
+theorem sum_abs_coord_le (v : Rn n) : ∑ j, |v j| ≤ n * ‖v‖ := by
+  calc ∑ j, |v j| ≤ ∑ _j : Fin n, ‖v‖ := Finset.sum_le_sum fun j _ => by
+        simpa [Real.norm_eq_abs] using PiLp.norm_apply_le v j
+    _ = n * ‖v‖ := by simp
+
+/-- A continuous multilinear map on `ℝⁿ` is bounded by `n^k` times the maximum of its values on
+tuples of standard basis vectors. -/
+theorem norm_le_of_single_le {k : ℕ} (T : ContinuousMultilinearMap ℝ (fun _ : Fin k => Rn n) ℂ)
+    {M : ℝ} (hM : 0 ≤ M) (h : ∀ i : Fin k → Fin n, ‖T (fun l => EuclideanSpace.single (i l) 1)‖
+        ≤ M) :
+    ‖T‖ ≤ (n : ℝ) ^ k * M := by
+  apply ContinuousMultilinearMap.opNorm_le_bound (by positivity)
+  intro v
+  have hv : v = fun l => ∑ j, v l j • EuclideanSpace.single j (1 : ℝ) := funext fun l =>
+      eq_sum_single (v l)
+  rw [show T v = _ from congrArg T hv, T.map_sum]
+  calc ‖∑ r : Fin k → Fin n, T (fun l => v l (r l) • EuclideanSpace.single (r l) (1 : ℝ))‖
+      ≤ ∑ r : Fin k → Fin n, ‖T (fun l => v l (r l) • EuclideanSpace.single (r l) (1 : ℝ))‖ :=
+        norm_sum_le _ _
+    _ ≤ ∑ r : Fin k → Fin n, (∏ l, |v l (r l)|) * M := by
+        gcongr with r
+        rw [T.map_smul_univ, norm_smul, norm_prod]
+        gcongr
+        · simp [Real.norm_eq_abs]
+        · exact h r
+    _ = M * ∏ l, ∑ j, |v l j| := by
+        rw [Finset.prod_univ_sum, ← Finset.sum_mul, mul_comm, Fintype.piFinset_univ]
+    _ ≤ M * ∏ l, ((n : ℝ) * ‖v l‖) := by
+        apply mul_le_mul_of_nonneg_left _ hM
+        exact Finset.prod_le_prod₀ (fun l _ => Finset.sum_nonneg fun j _ => abs_nonneg _)
+          (fun l _ => sum_abs_coord_le (v l))
+    _ = (n : ℝ) ^ k * M * ∏ l, ‖v l‖ := by
+        rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin]
+        ring
+
+theorem ne_zero_of_rho_pos (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ζ : Rn n} (h : 0 < rho α ζ) :
+    ζ ≠ 0 := by
+  rintro rfl
+  simp [rho, rhoNN_zero α hα] at h
+
+theorem prod_rho_rpow_le (α : Fin n → ℕ) {k : ℕ} (i : Fin k → Fin n) {c : ℝ} (hc : 0 < c)
+    (hc1 : c ≤ 1) {ζ : Rn n} (hζ : c ≤ rho α ζ) :
+    (∏ j, rho α ζ ^ (-(α (i j) : ℝ))) ≤ c ^ (-((k * absA α : ℕ) : ℝ)) := by
+  have hle : ∀ j, rho α ζ ^ (-(α (i j) : ℝ)) ≤ c ^ (-(absA α : ℝ)) := by
+    intro j
+    calc rho α ζ ^ (-(α (i j) : ℝ)) ≤ c ^ (-(α (i j) : ℝ)) :=
+          Real.rpow_le_rpow_of_nonpos hc hζ (by simp)
+      _ ≤ c ^ (-(absA α : ℝ)) := by
+          apply Real.rpow_le_rpow_of_exponent_ge hc hc1
+          have : α (i j) ≤ absA α := Finset.single_le_sum (fun _ _ => Nat.zero_le _)
+              (Finset.mem_univ _)
+          simp only [neg_le_neg_iff]
+          exact_mod_cast this
+  calc (∏ j, rho α ζ ^ (-(α (i j) : ℝ))) ≤ ∏ _j : Fin k, c ^ (-(absA α : ℝ)) :=
+        Finset.prod_le_prod₀ (fun j _ => by
+          have := (hc.trans_le hζ); positivity) fun j _ => hle j
+    _ = c ^ (-((k * absA α : ℕ) : ℝ)) := by
+        rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin, ← Real.rpow_natCast,
+          ← Real.rpow_mul hc.le]
+        congr 1
+        push_cast
+        ring
+
+/-- Full-derivative bound for a multiplier away from the origin (a consequence of (4.13)):
+if `m ∈ 𝓜^ν`, `i ≤ ν`, `0 < c ≤ 1` and `ρ(ζ) ≥ c`, then
+`‖D^i m(ζ)‖ ≤ nⁱ c^{-i|α|} ‖m‖_{𝓜^ν}`. -/
+theorem enorm_iteratedFDeriv_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {k : ℕ} (hk : k ≤ ν) {c : ℝ} (hc : 0 < c) (hc1 : c ≤ 1) {ζ : Rn n}
+    (hζ : c ≤ rho α ζ) :
+    ‖iteratedFDeriv ℝ k m ζ‖ₑ ≤
+      ENNReal.ofReal ((n : ℝ) ^ k * c ^ (-((k * absA α : ℕ) : ℝ))) * normM α ν m := by
+  have hζ0 : ζ ≠ 0 := ne_zero_of_rho_pos α hα (hc.trans_le hζ)
+  by_cases htop : normM α ν m = ⊤
+  · have hn : 0 < n := by
+      rcases Nat.eq_zero_or_pos n with h | h
+      · subst h; exact absurd (Subsingleton.elim ζ 0) hζ0
+      · exact h
+    rw [htop, ENNReal.mul_top]
+    · exact le_top
+    · simp only [ne_eq, ENNReal.ofReal_eq_zero, not_le]
+      have : (0 : ℝ) < n := by exact_mod_cast hn
+      positivity
+  set M := (normM α ν m).toReal
+  have hpart : ∀ i : Fin k → Fin n, ‖iterPartial k m i ζ‖ ≤ M * c ^ (-((k * absA α : ℕ) : ℝ)) := by
+    intro i
+    have h1 := symbol_estimate α hα hm hk i hζ0
+    have h2 := prod_rho_rpow_le α i hc hc1 hζ
+    have h3 : ‖iterPartial k m i ζ‖ₑ ≤ normM α ν m * ENNReal.ofReal (c ^ (-((k * absA α : ℕ) :
+        ℝ))) :=
+      h1.trans (by gcongr)
+    rw [← ofReal_norm, ← ENNReal.ofReal_toReal htop, ← ENNReal.ofReal_mul ENNReal.toReal_nonneg,
+      ENNReal.ofReal_le_ofReal_iff (by positivity)] at h3
+    exact h3
+  have hbound := norm_le_of_single_le (iteratedFDeriv ℝ k m ζ) (by positivity) hpart
+  rw [← ofReal_norm, ← ENNReal.ofReal_toReal htop, ← ENNReal.ofReal_mul (by positivity)]
+  apply ENNReal.ofReal_le_ofReal
+  calc ‖iteratedFDeriv ℝ k m ζ‖ ≤ (n : ℝ) ^ k * (M * c ^ (-((k * absA α : ℕ) : ℝ))) := hbound
+    _ = _ := by ring
+
+theorem norm_fourier_le_integral_norm' {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (F : Rn n → E) (w : Rn n) :
+    ‖FourierTransform.fourier F w‖ ≤ ∫ v, ‖F v‖ := by
+  rw [Real.fourier_eq]
+  refine (norm_integral_le_integral_norm _).trans (le_of_eq ?_)
+  congr 1
+  ext v
+  rw [Circle.norm_smul]
+
+/-- The paper's oscillatory integral as a Mathlib Fourier transform:
+`∫ e^{i⟨y, ζ⟩} g(ζ) dζ = 𝓕 g(-(2π)⁻¹ y)`. -/
+theorem integral_exp_mul_eq_fourier (g : Rn n → ℂ) (y : Rn n) :
+    ∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * g ζ =
+      FourierTransform.fourier g (-((2 * π)⁻¹ • y)) := by
+  rw [Real.fourier_eq]
+  congr 1
+  ext ζ
+  rw [Circle.smul_def, Real.fourierChar_apply, inner_neg_right, inner_smul_right, neg_neg,
+    real_inner_comm]
+  congr 2
+  push_cast
+  field_simp
+
+/-- Integration by parts in the form used in the paper (§8, proof of (4.15)): for a compactly
+supported `C^N` function `g`, `|y_j|^N |∫ e^{i⟨y, ζ⟩} g(ζ) dζ| ≤ ∫ ‖D^N g(ζ)‖ dζ`. -/
+theorem pow_abs_mul_norm_integral_exp_le (g : Rn n → ℂ) {N : ℕ} (hg : ContDiff ℝ N g)
+    (hgc : HasCompactSupport g) (y : Rn n) (j : Fin n) :
+    |y j| ^ N * ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * g ζ‖ ≤
+      ∫ ζ, ‖iteratedFDeriv ℝ N g ζ‖ := by
+  set w : Rn n := -((2 * π)⁻¹ • y)
+  have hint : ∀ k : ℕ, (k : ℕ∞) ≤ (N : ℕ∞) → Integrable (iteratedFDeriv ℝ k g) := by
+    intro k hk
+    have hk' : k ≤ N := by exact_mod_cast hk
+    exact ((hg.continuous_iteratedFDeriv (by exact_mod_cast hk'))).integrable_of_hasCompactSupport
+      (hgc.iteratedFDeriv k)
+  have hF := Real.fourier_iteratedFDeriv (N := (N : ℕ∞)) (by exact_mod_cast hg) hint (le_refl _)
+  have key := congrArg (fun F => F w (fun _ : Fin N => EuclideanSpace.single j (1 : ℝ))) hF
+  simp only [VectorFourier.fourierPowSMulRight_apply, neg_apply, w] at key
+  have hinner : ∀ v e : Rn n, (innerSL ℝ v) e = ⟪v, e⟫_ℝ := fun v e => rfl
+  simp only [hinner, inner_neg_left, inner_smul_left,
+    EuclideanSpace.inner_single_right, neg_neg, Finset.prod_const, Finset.card_univ,
+    Fintype.card_fin, conj_trivial, one_mul] at key
+  rw [integral_exp_mul_eq_fourier]
+  have hnorm := congrArg norm key
+  rw [norm_smul, norm_smul, norm_pow, norm_neg, norm_pow, Real.norm_eq_abs, abs_mul, abs_inv,
+    abs_of_pos (by positivity : (0 : ℝ) < 2 * π)] at hnorm
+  have h2π : ‖(2 * π * Complex.I : ℂ)‖ = 2 * π := by
+    simp [abs_of_pos Real.pi_pos]
+  rw [h2π] at hnorm
+  have hlhs : |y j| ^ N * ‖FourierTransform.fourier g w‖ =
+      (2 * π) ^ N * (((2 * π)⁻¹ * |y j|) ^ N * ‖FourierTransform.fourier g w‖) := by
+    rw [← mul_assoc, ← mul_pow, ← mul_assoc, mul_inv_cancel₀ (by positivity), one_mul]
+  rw [hlhs, show w = -((2 * π)⁻¹ • y) from rfl, ← hnorm]
+  calc ‖(FourierTransform.fourier (iteratedFDeriv ℝ N g) w)
+        (fun _ : Fin N => EuclideanSpace.single j (1 : ℝ))‖
+      ≤ ‖FourierTransform.fourier (iteratedFDeriv ℝ N g) w‖ *
+          ∏ _l : Fin N, ‖EuclideanSpace.single j (1 : ℝ)‖ :=
+        ContinuousMultilinearMap.le_opNorm _ _
+    _ = ‖FourierTransform.fourier (iteratedFDeriv ℝ N g) w‖ := by simp
+    _ ≤ ∫ ζ, ‖iteratedFDeriv ℝ N g ζ‖ := norm_fourier_le_integral_norm' _ w
+
+/-! ### The wave packet estimate (4.15) (paper, §8) -/
+
+/-- `φ̂` as a Schwartz function. -/
+def phiHatSchwartz : 𝓢(Rn n, ℂ) :=
+  hasCompactSupport_phiHat.toSchwartzMap contDiff_phiHat
+
+theorem phiHatSchwartz_apply (ζ : Rn n) : phiHatSchwartz ζ = phiHat ζ := rfl
+
+/-- Bounds `K_k` for the derivatives of `φ̂`. -/
+def phiHatBound (n k : ℕ) : ℝ := SchwartzMap.seminorm ℝ 0 k (phiHatSchwartz : 𝓢(Rn n, ℂ))
+
+theorem norm_iteratedFDeriv_phiHat_le (k : ℕ) (ζ : Rn n) :
+    ‖iteratedFDeriv ℝ k phiHat ζ‖ ≤ phiHatBound n k :=
+  SchwartzMap.norm_iteratedFDeriv_le_seminorm ℝ (phiHatSchwartz : 𝓢(Rn n, ℂ)) k ζ
+
+theorem phiHatBound_nonneg (n k : ℕ) : 0 ≤ phiHatBound n k := apply_nonneg _ _
+
+/-- The closed box `[-b₀/2, b₀/2]ⁿ` containing the support of `φ̂`. -/
+def boxB (n : ℕ) : Set (Rn n) := {ζ | ∀ i, |ζ i| ≤ b0 / 2}
+
+theorem phiHat_eventually_zero {ζ : Rn n} (hζ : ζ ∉ boxB n) : phiHat =ᶠ[nhds ζ] 0 := by
+  simp only [boxB, Set.mem_ofPred_eq, not_forall, not_le] at hζ
+  obtain ⟨i, hi⟩ := hζ
+  have hopen : IsOpen {η : Rn n | b0 / 2 < |η i|} :=
+    isOpen_lt continuous_const ((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)).abs
+  filter_upwards [hopen.mem_nhds hi] with η hη
+  exact phiHat_eq_zero_of_lt hη.le
+
+/-- On the box, `ζ + a` stays away from the origin when some `|a_j| ≥ 1/4`:
+`ρ(ζ + a) ≥ 1/5`. -/
+theorem one_fifth_le_rho_add (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {a ζ : Rn n}
+    (ha : ∃ j, 1 / 4 ≤ |a j|) (hζ : ζ ∈ boxB n) : 1 / 5 ≤ rho α (ζ + a) := by
+  obtain ⟨j, hj⟩ := ha
+  have hζj := hζ j
+  have h1 : 1 / 5 ≤ |(ζ + a) j| := by
+    simp only [PiLp.add_apply]
+    have := abs_add_le (ζ j + a j) (-ζ j)
+    rw [add_neg_cancel_comm, abs_neg] at this
+    norm_num [b0] at hζj
+    linarith
+  have hαj : (1 : ℝ) ≤ α j := by exact_mod_cast hα j
+  have hq : (α j : ℝ)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hαj
+  have hq0 : 0 ≤ (α j : ℝ)⁻¹ := by positivity
+  calc (1 / 5 : ℝ) ≤ (1 / 5 : ℝ) ^ (α j : ℝ)⁻¹ :=
+        Real.self_le_rpow_of_le_one (by norm_num) (by norm_num) hq
+    _ ≤ |(ζ + a) j| ^ (α j : ℝ)⁻¹ := Real.rpow_le_rpow (by norm_num) h1 hq0
+    _ = ((‖(ζ + a) j‖₊ ^ ((α j : ℝ)⁻¹) : ℝ≥0) : ℝ) := by simp [Real.norm_eq_abs]
+    _ ≤ rho α (ζ + a) := by
+        simp only [rho]
+        exact_mod_cast coord_rpow_le_rhoNN α (ζ + a) j
+
+/-- The localized symbol `g(ζ) = m(ζ + a) φ̂(ζ)` appearing in the proof of (4.15). -/
+def gloc (m : Rn n → ℂ) (a : Rn n) : Rn n → ℂ := fun ζ => m (ζ + a) * phiHat ζ
+
+theorem gloc_eventually_zero (m : Rn n → ℂ) (a : Rn n) {ζ : Rn n} (hζ : ζ ∉ boxB n) :
+    gloc m a =ᶠ[nhds ζ] 0 := by
+  filter_upwards [phiHat_eventually_zero hζ] with η hη
+  simp [gloc, hη]
+
+theorem add_ne_zero_of_mem_boxB (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {a ζ : Rn n}
+    (ha : ∃ j, 1 / 4 ≤ |a j|) (hζ : ζ ∈ boxB n) : ζ + a ≠ 0 :=
+  ne_zero_of_rho_pos α hα (by linarith [one_fifth_le_rho_add α hα ha hζ])
+
+theorem contDiff_gloc (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {a : Rn n} (ha : ∃ j, 1 / 4 ≤ |a j|) : ContDiff ℝ ν (gloc m a) := by
+  rw [contDiff_iff_contDiffAt]
+  intro ζ
+  by_cases hζ : ζ ∈ boxB n
+  · have hne := add_ne_zero_of_mem_boxB α hα ha hζ
+    have h1 : ContDiffAt ℝ ν (fun η => m (η + a)) ζ :=
+      (hm.contDiffOn.contDiffAt (isOpen_compl_singleton.mem_nhds hne)).comp ζ
+        (contDiffAt_id.add contDiffAt_const)
+    have h2 : ContDiffAt ℝ ν phiHat ζ :=
+      (contDiff_phiHat.of_le (by exact_mod_cast (le_top : (ν : ℕ∞) ≤ ⊤))).contDiffAt
+    exact h1.mul h2
+  · exact contDiffAt_const.congr_of_eventuallyEq (gloc_eventually_zero m a hζ)
+
+theorem hasCompactSupport_gloc (m : Rn n → ℂ) (a : Rn n) : HasCompactSupport (gloc m a) :=
+  hasCompactSupport_phiHat.mul_left (f := fun ζ => m (ζ + a))
+
+/-- The constants `A_l = ∑_{i ≤ l} C(l,i) nⁱ 5^{i|α|} K_{l-i}` bounding the derivatives of the
+localized symbol. -/
+def gBound (α : Fin n → ℕ) (l : ℕ) : ℝ :=
+  ∑ i ∈ Finset.range (l + 1), (l.choose i : ℝ) *
+    ((n : ℝ) ^ i * (1 / 5 : ℝ) ^ (-((i * absA α : ℕ) : ℝ))) * phiHatBound n (l - i)
+
+theorem gBound_nonneg (α : Fin n → ℕ) (l : ℕ) : 0 ≤ gBound α l :=
+  Finset.sum_nonneg fun i _ => by
+    have := phiHatBound_nonneg n (l - i)
+    positivity
+
+theorem norm_le_of_enorm_le_ofReal_mul {x : ℝ} {r : ℝ} (hr : 0 ≤ r) {M : ℝ≥0∞} (hM : M ≠ ⊤)
+    (h : ENNReal.ofReal x ≤ ENNReal.ofReal r * M) : x ≤ r * M.toReal := by
+  rw [← ENNReal.ofReal_toReal hM, ← ENNReal.ofReal_mul hr,
+    ENNReal.ofReal_le_ofReal_iff (by positivity)] at h
+  exact h
+
+theorem norm_iteratedFDeriv_gloc_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a : Rn n} (ha : ∃ j, 1 / 4 ≤ |a j|)
+    {l : ℕ} (hl : l ≤ ν) (ζ : Rn n) :
+    ‖iteratedFDeriv ℝ l (gloc m a) ζ‖ ≤
+      (boxB n).indicator (fun _ => gBound α l * (normM α ν m).toReal) ζ := by
+  by_cases hζ : ζ ∈ boxB n
+  · rw [Set.indicator_of_mem hζ]
+    set U : Set (Rn n) := {η | η + a ≠ 0}
+    have hU : IsOpen U := isOpen_ne_fun (continuous_id.add continuous_const) continuous_const
+    have hζU : ζ ∈ U := add_ne_zero_of_mem_boxB α hα ha hζ
+    have hf : ContDiffOn ℝ ν (fun η => m (η + a)) U := by
+      intro η hη
+      exact ((hm.contDiffOn.contDiffAt (isOpen_compl_singleton.mem_nhds hη)).comp η
+        (contDiffAt_id.add contDiffAt_const)).contDiffWithinAt
+    have hg : ContDiffOn ℝ ν phiHat U :=
+      (contDiff_phiHat.of_le (by exact_mod_cast (le_top : (ν : ℕ∞) ≤ ⊤))).contDiffOn
+    have hL := norm_iteratedFDerivWithin_mul_le hf hg hU.uniqueDiffOn hζU
+      (n := l) (by exact_mod_cast hl)
+    rw [iteratedFDerivWithin_of_isOpen l hU hζU] at hL
+    have hL' : ‖iteratedFDeriv ℝ l (gloc m a) ζ‖ ≤ ∑ i ∈ Finset.range (l + 1),
+        (l.choose i : ℝ) * ‖iteratedFDeriv ℝ i (fun η => m (η + a)) ζ‖ *
+          ‖iteratedFDeriv ℝ (l - i) phiHat ζ‖ := by
+      refine hL.trans (le_of_eq (Finset.sum_congr rfl fun i _ => ?_))
+      rw [iteratedFDerivWithin_of_isOpen i hU hζU, iteratedFDerivWithin_of_isOpen (l - i) hU hζU]
+    refine hL'.trans ?_
+    rw [gBound, Finset.sum_mul]
+    refine Finset.sum_le_sum fun i hi => ?_
+    have hi' : i ≤ ν := (Nat.lt_succ_iff.mp (Finset.mem_range.mp hi)).trans hl
+    have hA : ‖iteratedFDeriv ℝ i (fun η => m (η + a)) ζ‖ ≤
+        ((n : ℝ) ^ i * (1 / 5 : ℝ) ^ (-((i * absA α : ℕ) : ℝ))) * (normM α ν m).toReal := by
+      rw [iteratedFDeriv_comp_add_right]
+      have h5 := enorm_iteratedFDeriv_le α hα hm hi' (c := 1 / 5) (by norm_num) (by norm_num)
+        (one_fifth_le_rho_add α hα ha hζ)
+      rw [← ofReal_norm] at h5
+      exact norm_le_of_enorm_le_ofReal_mul (by positivity) hfin h5
+    have hB := norm_iteratedFDeriv_phiHat_le (n := n) (l - i) ζ
+    have hK := phiHatBound_nonneg n (l - i)
+    calc (l.choose i : ℝ) * ‖iteratedFDeriv ℝ i (fun η => m (η + a)) ζ‖ *
+          ‖iteratedFDeriv ℝ (l - i) phiHat ζ‖
+        ≤ (l.choose i : ℝ) * (((n : ℝ) ^ i * (1 / 5 : ℝ) ^ (-((i * absA α : ℕ) : ℝ))) *
+            (normM α ν m).toReal) * phiHatBound n (l - i) := by
+          gcongr
+      _ = _ := by ring
+  · have h0 : iteratedFDeriv ℝ l (gloc m a) ζ = 0 := by
+      rw [((gloc_eventually_zero m a hζ).iteratedFDeriv ℝ l).eq_of_nhds]
+      exact congrFun (iteratedFDeriv_fun_zero (𝕜 := ℝ) (E := Rn n) (F := ℂ) (n := l)) ζ
+    rw [Set.indicator_of_notMem hζ, h0, norm_zero]
+
+theorem boxB_eq_image : boxB n = (WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+    Set.pi Set.univ fun _ => Set.Icc (-(b0 / 2)) (b0 / 2) := by
+  ext ζ
+  constructor
+  · intro h
+    exact ⟨WithLp.ofLp ζ, fun i _ => abs_le.mp (h i), by simp⟩
+  · rintro ⟨v, hv, rfl⟩ i
+    exact abs_le.mpr (hv i (Set.mem_univ i))
+
+theorem isCompact_boxB : IsCompact (boxB n) := by
+  rw [boxB_eq_image]
+  exact (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+
+/-- `|B|`, the volume of the box `[-b₀/2, b₀/2]ⁿ`. -/
+def volB (n : ℕ) : ℝ := (volume (boxB n)).toReal
+
+theorem integral_norm_iteratedFDeriv_gloc_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a : Rn n}
+    (ha : ∃ j, 1 / 4 ≤ |a j|) {l : ℕ} (hl : l ≤ ν) :
+    ∫ ζ, ‖iteratedFDeriv ℝ l (gloc m a) ζ‖ ≤ gBound α l * (normM α ν m).toReal * volB n := by
+  have hmeas : MeasurableSet (boxB n) := isCompact_boxB.isClosed.measurableSet
+  have hfinB : volume (boxB n) ≠ ⊤ := isCompact_boxB.measure_lt_top.ne
+  calc ∫ ζ, ‖iteratedFDeriv ℝ l (gloc m a) ζ‖
+      ≤ ∫ ζ, (boxB n).indicator (fun _ => gBound α l * (normM α ν m).toReal) ζ := by
+        apply integral_mono_of_nonneg (Filter.Eventually.of_forall fun ζ => norm_nonneg _)
+        · exact (integrableOn_const hfinB enorm_ne_top).integrable_indicator hmeas
+        · exact Filter.Eventually.of_forall fun ζ =>
+            norm_iteratedFDeriv_gloc_le α hα hm hfin ha hl ζ
+    _ = gBound α l * (normM α ν m).toReal * volB n := by
+        rw [integral_indicator_const _ hmeas, smul_eq_mul, volB, measureReal_def, mul_comm]
+
+/-- A coordinate realizing the anisotropic norm: `ρ(y) = |y_j|^{1/α_j}`, hence `|y_j| =
+    ρ(y)^{α_j}`. -/
+theorem exists_coord_eq_rho (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {y : Rn n} (hy : 0 < rho α y) :
+    ∃ j, |y j| = rho α y ^ α j := by
+  have hn : (Finset.univ : Finset (Fin n)).Nonempty := by
+    rcases Nat.eq_zero_or_pos n with h | h
+    · subst h
+      exfalso
+      have : y = 0 := Subsingleton.elim _ _
+      rw [this] at hy
+      simp [rho, rhoNN_zero α hα] at hy
+    · exact ⟨⟨0, h⟩, Finset.mem_univ _⟩
+  obtain ⟨j, -, hj⟩ := Finset.exists_mem_eq_sup _ hn fun i => ‖y i‖₊ ^ ((α i : ℝ)⁻¹)
+  refine ⟨j, ?_⟩
+  have hαj : (α j : ℝ) ≠ 0 := by have := hα j; positivity
+  have : rho α y = |y j| ^ ((α j : ℝ)⁻¹) := by
+    simp only [rho, rhoNN] at hj ⊢
+    rw [hj]
+    simp [Real.norm_eq_abs]
+  rw [this, ← Real.rpow_natCast, ← Real.rpow_mul (abs_nonneg _), inv_mul_cancel₀ hαj,
+    Real.rpow_one]
+
+theorem rpow_neg_nat_eq (x : ℝ) (hx : 0 < x) (ν : ℕ) : x ^ (-(ν : ℝ)) = (x ^ ν)⁻¹ := by
+  rw [Real.rpow_neg hx.le, Real.rpow_natCast]
+
+/-- Generic decay of oscillatory integrals by integration by parts:
+if `∫ ‖g‖ ≤ B₀` and `∫ ‖D^ν g‖ ≤ B_ν`, then `|∫ e^{i⟨y,ζ⟩} g(ζ) dζ| ≤ (B₀ + B_ν) 2^ν (1 +
+    ρ(y))^{-ν}`. -/
+theorem norm_integral_exp_le_of_bounds (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ}
+    {g : Rn n → ℂ} (hg : ContDiff ℝ ν g) (hgc : HasCompactSupport g) {B₀ Bν : ℝ} (hB₀ : 0 ≤ B₀)
+    (hBν : 0 ≤ Bν) (h0 : ∫ ζ, ‖g ζ‖ ≤ B₀) (hν : ∫ ζ, ‖iteratedFDeriv ℝ ν g ζ‖ ≤ Bν) (y : Rn n) :
+    ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * g ζ‖ ≤
+      (B₀ + Bν) * 2 ^ ν * (1 + rho α y) ^ (-(ν : ℝ)) := by
+  have hρ := rho_nonneg α y
+  set Q := B₀ + Bν
+  have hQ : 0 ≤ Q := by positivity
+  rw [rpow_neg_nat_eq _ (by linarith) ν]
+  rcases lt_or_ge (rho α y) 1 with hlt | hge
+  · have h1 : ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * g ζ‖ ≤ B₀ := by
+      refine (norm_integral_le_integral_norm _).trans (le_trans (le_of_eq ?_) h0)
+      congr 1
+      ext ζ
+      rw [norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, one_mul]
+    have h2 : (1 + rho α y) ^ ν ≤ 2 ^ ν := by gcongr; linarith
+    have h3 : 1 ≤ 2 ^ ν * ((1 + rho α y) ^ ν)⁻¹ := by
+      rw [← div_eq_mul_inv, one_le_div (by positivity)]
+      exact h2
+    calc _ ≤ B₀ := h1
+      _ ≤ Q := by simp only [Q]; linarith
+      _ ≤ Q * (2 ^ ν * ((1 + rho α y) ^ ν)⁻¹) := le_mul_of_one_le_right hQ h3
+      _ = _ := by ring
+  · have hρpos : 0 < rho α y := by linarith
+    obtain ⟨j, hj⟩ := exists_coord_eq_rho α hα hρpos
+    have hyj : rho α y ≤ |y j| := by
+      rw [hj]
+      calc rho α y = rho α y ^ 1 := (pow_one _).symm
+        _ ≤ rho α y ^ α j := pow_le_pow_right₀ hge (hα j)
+    have hibp := pow_abs_mul_norm_integral_exp_le g hg hgc y j
+    set I := ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * g ζ‖
+    have hI : 0 ≤ I := norm_nonneg _
+    have h1 : rho α y ^ ν * I ≤ Q := by
+      calc rho α y ^ ν * I ≤ |y j| ^ ν * I := by gcongr
+        _ ≤ Bν := hibp.trans hν
+        _ ≤ Q := by simp only [Q]; linarith
+    have h2 : (1 + rho α y) ^ ν ≤ 2 ^ ν * rho α y ^ ν := by
+      rw [← mul_pow]; gcongr; linarith
+    have hpos' : 0 < (1 + rho α y) ^ ν := by positivity
+    rw [← div_eq_mul_inv, le_div_iff₀ hpos']
+    calc I * (1 + rho α y) ^ ν ≤ I * (2 ^ ν * rho α y ^ ν) := by gcongr
+      _ = 2 ^ ν * (rho α y ^ ν * I) := by ring
+      _ ≤ 2 ^ ν * Q := by gcongr
+      _ = Q * 2 ^ ν := by ring
+
+/-- Decay of the localized oscillatory integral (the core of the proof of (4.15), §8):
+`|∫ e^{i⟨y,ζ⟩} g(ζ) dζ| ≤ (A₀ + A_ν) ‖m‖ |B| 2^ν (1 + ρ(y))^{-ν}`. -/
+theorem norm_integral_exp_gloc_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a : Rn n}
+    (ha : ∃ j, 1 / 4 ≤ |a j|) (y : Rn n) :
+    ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * gloc m a ζ‖ ≤
+      (gBound α 0 + gBound α ν) * (normM α ν m).toReal * volB n * 2 ^ ν *
+        (1 + rho α y) ^ (-(ν : ℝ)) := by
+  have h0 := integral_norm_iteratedFDeriv_gloc_le α hα hm hfin ha (Nat.zero_le ν)
+  simp only [norm_iteratedFDeriv_zero] at h0
+  have hν := integral_norm_iteratedFDeriv_gloc_le α hα hm hfin ha (le_refl ν)
+  have hA0 := gBound_nonneg α 0
+  have hAν := gBound_nonneg α ν
+  have hM : 0 ≤ (normM α ν m).toReal := ENNReal.toReal_nonneg
+  have hVB : 0 ≤ volB n := ENNReal.toReal_nonneg
+  convert norm_integral_exp_le_of_bounds α hα (contDiff_gloc α hα hm ha)
+    (hasCompactSupport_gloc m a) (by positivity) (by positivity) h0 hν y using 1
+  ring
+
+/-- The weight `w^ν(x) = (1 + ρ(x))^{-ν}` (paper, §4, texline~320). -/
+def wgt (α : Fin n → ℕ) (ν : ℝ) (x : Rn n) : ℝ := (1 + rho α x) ^ (-ν)
+
+/-- The weight `w^ν_P = T_{c(I_P)} D¹_{2^{k_P}} w^ν`, i.e.
+`w^ν_P(x) = 2^{-k_P|α|} (1 + ρ(δ_{2^{-k_P}}(x - c(I_P))))^{-ν}` (paper, §4, texline~318). -/
+def wP (α : Fin n → ℕ) (ν : ℝ) (P : Tile n) (x : Rn n) : ℝ :=
+  ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ)) * wgt α ν (dil α ((2 : ℝ) ^ P.k)⁻¹ (x - P.cI α))
+
+theorem wgt_pos (α : Fin n → ℕ) (ν : ℝ) (x : Rn n) : 0 < wgt α ν x :=
+  Real.rpow_pos_of_pos (by linarith [rho_nonneg α x]) _
+
+theorem wP_pos (α : Fin n → ℕ) (ν : ℝ) (P : Tile n) (x : Rn n) : 0 < wP α ν P x :=
+  mul_pos (by positivity) (wgt_pos α ν _)
+
+/-- The constant in the wave packet estimate (4.15). -/
+def psiConst (α : Fin n → ℕ) (ν : ℕ) : ℝ≥0 :=
+  Real.toNNReal ((((2 * π) ^ n)⁻¹ * ((gBound α 0 + gBound α ν) * volB n * 2 ^ ν))) + 1
+
+/-- Wave packet decay (paper, §4, (4.15), proved in §8): for every integer `ν ≥ 0` there is `C`
+(depending only on `ν`, `α` and `φ`) such that for `m ∈ 𝓜^ν`,
+`|ψ^N_P(x)| ≤ C ‖m‖_{𝓜^ν} |I_P|^{1/2} w^ν_P(x)`.
+The paper assumes `N ∉ ω_{P(0)}`; we only assume that `N` lies outside the interior of the
+cube `ω_{P(0)}` in some coordinate, which also covers `N ∈ ω_{P(r)}`, `r ≠ 0`. -/
+theorem psi_estimate (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ) {m : Rn n → ℂ}
+    (hm : ClassM α ν m) (P : Tile n) (N : Rn n)
+    (hN : ∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) (x : Rn n) :
+    ‖wavePsi α m N P x‖ₑ ≤ psiConst α ν * normM α ν m *
+      ENNReal.ofReal (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * wP α ν P x) := by
+  set t : ℝ := (2 : ℝ) ^ P.k with ht_def
+  have ht : 0 < t := by positivity
+  have hW : 0 < t ^ ((absA α : ℝ) / 2) * wP α ν P x := mul_pos (by positivity) (wP_pos α ν P x)
+  by_cases htop : normM α ν m = ⊤
+  · rw [htop, ENNReal.mul_top (by simp [psiConst]), ENNReal.top_mul (by simpa using hW)]
+    exact le_top
+  set a : Rn n := dil α t (P.cω0 α - N)
+  have ha : ∃ j, 1 / 4 ≤ |a j| := by
+    obtain ⟨j, hj⟩ := hN
+    refine ⟨j, ?_⟩
+    have hs : side α P.k j * side α (-P.k) j = 1 := by rw [← side_add]; simp [side]
+    simp only [a, ht_def, dil_zpow_apply, PiLp.sub_apply, abs_mul, abs_of_pos (side_pos α P.k j)]
+    rw [abs_sub_comm]
+    calc (1 / 4 : ℝ) = side α P.k j * (side α (-P.k) j / 4) := by rw [mul_div_assoc', hs]
+      _ ≤ side α P.k j * |N j - P.cω0 α j| := by gcongr; exact (side_pos α P.k j).le
+  set y : Rn n := dil α t⁻¹ (x - P.cI α)
+  -- the integrand of (8.1) is the localized symbol
+  have hint : (∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) *
+      m (P.cω0 α - N + dil α t⁻¹ ζ) * phiHat ζ) =
+      ∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * gloc m a ζ := by
+    congr 1
+    ext ζ
+    rw [mul_assoc]
+    congr 1
+    simp only [gloc]
+    by_cases hζ : ζ ∈ boxB n
+    · congr 1
+      have hne := add_ne_zero_of_mem_boxB α hα ha hζ
+      have : P.cω0 α - N + dil α t⁻¹ ζ = dil α t⁻¹ (ζ + a) := by
+        simp only [a, dil_add, dil_dil, inv_mul_cancel₀ ht.ne', dil_one]
+        abel
+      rw [this, hm.homogeneous _ hne _ (inv_pos.mpr ht)]
+    · have : phiHat ζ = 0 := by
+        simp only [boxB, Set.mem_ofPred_eq, not_forall, not_le] at hζ
+        obtain ⟨i, hi⟩ := hζ
+        exact phiHat_eq_zero_of_lt hi.le
+      simp [this]
+  have hψ : ‖wavePsi α m N P x‖ ≤ ((2 * π) ^ n)⁻¹ * t ^ (-((absA α : ℝ) / 2)) *
+      ((gBound α 0 + gBound α ν) * (normM α ν m).toReal * volB n * 2 ^ ν *
+        (1 + rho α y) ^ (-(ν : ℝ))) := by
+    rw [wavePsi_eq_rescaled, hint, norm_mul, norm_mul, norm_mul, mul_comm Complex.I,
+      Complex.norm_exp_ofReal_mul_I, mul_one]
+    have h1 : ‖(((2 * π) ^ n)⁻¹ : ℂ)‖ = ((2 * π) ^ n)⁻¹ := by
+      rw [norm_inv, norm_pow, Complex.norm_mul, Complex.norm_ofNat, Complex.norm_real,
+        Real.norm_eq_abs, abs_of_pos Real.pi_pos]
+    have h2 : ‖((t ^ (-((absA α : ℝ) / 2)) : ℝ) : ℂ)‖ = t ^ (-((absA α : ℝ) / 2)) := by
+      rw [Complex.norm_real, Real.norm_eq_abs, abs_of_pos (by positivity)]
+    rw [h1, h2]
+    gcongr
+    exact norm_integral_exp_gloc_le α hα hm htop ha y
+  -- conversion to the stated form
+  have hwP : t ^ ((absA α : ℝ) / 2) * wP α ν P x =
+      t ^ (-((absA α : ℝ) / 2)) * (1 + rho α y) ^ (-(ν : ℝ)) := by
+    simp only [wP, wgt, ← ht_def]
+    rw [← mul_assoc, ← Real.rpow_add ht]
+    congr 2
+    ring
+  rw [← ofReal_norm, hwP]
+  set Creal := ((2 * π) ^ n)⁻¹ * ((gBound α 0 + gBound α ν) * volB n * 2 ^ ν)
+  have hCreal : 0 ≤ Creal := by
+    have := gBound_nonneg α 0; have := gBound_nonneg α ν
+    have : 0 ≤ volB n := ENNReal.toReal_nonneg
+    positivity
+  have hψ' : ‖wavePsi α m N P x‖ ≤ Creal * (normM α ν m).toReal *
+      (t ^ (-((absA α : ℝ) / 2)) * (1 + rho α y) ^ (-(ν : ℝ))) := by
+    refine hψ.trans (le_of_eq ?_)
+    simp only [Creal]
+    ring
+  calc ENNReal.ofReal ‖wavePsi α m N P x‖
+      ≤ ENNReal.ofReal (Creal * (normM α ν m).toReal *
+          (t ^ (-((absA α : ℝ) / 2)) * (1 + rho α y) ^ (-(ν : ℝ)))) := ENNReal.ofReal_le_ofReal hψ'
+    _ = ENNReal.ofReal Creal * normM α ν m *
+          ENNReal.ofReal (t ^ (-((absA α : ℝ) / 2)) * (1 + rho α y) ^ (-(ν : ℝ))) := by
+        rw [ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_mul hCreal,
+          ENNReal.ofReal_toReal htop]
+    _ ≤ psiConst α ν * normM α ν m *
+          ENNReal.ofReal (t ^ (-((absA α : ℝ) / 2)) * (1 + rho α y) ^ (-(ν : ℝ))) := by
+        gcongr
+        simp only [psiConst, Creal]
+        rw [ENNReal.ofReal]
+        exact_mod_cast le_self_add
+
+/-! ### Anisotropic weights and the tile interaction estimate (4.16) (paper, §8) -/
+
+theorem continuous_rhoNN (α : Fin n → ℕ) : Continuous (rhoNN α) := by
+  unfold rhoNN
+  exact Continuous.finset_sup_apply (f := fun i (x : Rn n) => ‖x i‖₊ ^ ((α i : ℝ)⁻¹))
+    fun i _ => (NNReal.continuous_rpow_const (by positivity)).comp
+      (continuous_nnnorm.comp ((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)))
+
+theorem continuous_rho (α : Fin n → ℕ) : Continuous (rho α) :=
+  NNReal.continuous_coe.comp (continuous_rhoNN α)
+
+theorem abs_rpow_inv_le_one_add (a : ℕ) (ha : 1 ≤ a) (x : ℝ) :
+    |x| ^ ((a : ℝ)⁻¹) ≤ 1 + |x| := by
+  have hq0 : 0 ≤ (a : ℝ)⁻¹ := by positivity
+  have hq1 : (a : ℝ)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ (by exact_mod_cast ha)
+  rcases le_total |x| 1 with h | h
+  · have := Real.rpow_le_one (abs_nonneg x) h hq0
+    linarith [abs_nonneg x]
+  · have := Real.rpow_le_rpow_of_exponent_le h hq1
+    rw [Real.rpow_one] at this
+    linarith
+
+/-- `ρ(z) ≤ 1 + ‖z‖`. -/
+theorem rho_le_one_add_norm (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (z : Rn n) :
+    rho α z ≤ 1 + ‖z‖ := by
+  have h : rhoNN α z ≤ Real.toNNReal (1 + ‖z‖) := by
+    rw [rhoNN_le_iff]
+    intro i
+    rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ (by positivity)]
+    have h1 := abs_rpow_inv_le_one_add (α i) (hα i) (z i)
+    have h2 : |z i| ≤ ‖z‖ := by simpa [Real.norm_eq_abs] using PiLp.norm_apply_le z i
+    simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs]
+    linarith
+  have := NNReal.coe_le_coe.mpr h
+  rwa [Real.coe_toNNReal _ (by positivity)] at this
+
+theorem abs_coord_rpow_le_rho (α : Fin n → ℕ) (z : Rn n) (i : Fin n) :
+    |z i| ^ ((α i : ℝ)⁻¹) ≤ rho α z := by
+  have := coord_rpow_le_rhoNN α z i
+  rw [← NNReal.coe_le_coe] at this
+  simpa [rho, Real.norm_eq_abs] using this
+
+/-- Sharp integrability of the anisotropic weight: `∫ (1 + ρ(z))^{-s} dz < ∞` for `s > |α|`. -/
+theorem integrable_wgt (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {s : ℝ} (hs : (absA α : ℝ) < s) :
+    Integrable (fun z : Rn n => (1 + rho α z) ^ (-s)) := by
+  set q : ℝ := s / absA α
+  -- the dominating product function
+  set g : (Fin n → ℝ) → ℝ := fun v => ∏ i, (1 + ‖v i‖) ^ (-q)
+  have hg : Integrable g := by
+    rcases Nat.eq_zero_or_pos n with hn | hn
+    · subst hn
+      exact Integrable.fintype_prod (f := fun (i : Fin 0) (t : ℝ) => (1 + ‖t‖) ^ (-q))
+        (fun i => i.elim0)
+    · have hA : (0 : ℝ) < absA α := by
+        have : α ⟨0, hn⟩ ≤ absA α :=
+          Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ _)
+        have h1 := hα ⟨0, hn⟩
+        exact_mod_cast (show 0 < absA α by omega)
+      have hq : (Module.finrank ℝ ℝ : ℝ) < q := by
+        rw [Module.finrank_self, Nat.cast_one, lt_div_iff₀ hA, one_mul]
+        exact hs
+      exact Integrable.fintype_prod (f := fun (i : Fin n) (t : ℝ) => (1 + ‖t‖) ^ (-q))
+        fun i => integrable_one_add_norm hq
+  have hG : Integrable (g ∘ (WithLp.ofLp : Rn n → (Fin n → ℝ))) :=
+    ((PiLp.volume_preserving_ofLp (Fin n)).integrable_comp_emb
+      (MeasurableEquiv.toLp 2 (Fin n → ℝ)).symm.measurableEmbedding).mpr hg
+  refine hG.mono' ?_ (Filter.Eventually.of_forall fun z => ?_)
+  · exact (Continuous.rpow_const (continuous_const.add (continuous_rho α))
+      fun z => Or.inl (show (0 : ℝ) < 1 + rho α z by
+        linarith [rho_nonneg α z]).ne').aestronglyMeasurable
+  · have hρ := rho_nonneg α z
+    rw [Real.norm_eq_abs, abs_of_pos (Real.rpow_pos_of_pos (by linarith) _)]
+    simp only [Function.comp_apply, g]
+    rcases Nat.eq_zero_or_pos n with hn | hn
+    · subst hn
+      have : rho α z = 0 := by
+        simp [rho, rhoNN]
+      simp [this]
+    · have hA : (0 : ℝ) < absA α := by
+        have : α ⟨0, hn⟩ ≤ absA α :=
+          Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ _)
+        have h1 := hα ⟨0, hn⟩
+        exact_mod_cast (show 0 < absA α by omega)
+      have hsplit : (1 + rho α z) ^ (-s) = ∏ i, (1 + rho α z) ^ (-(α i * q)) := by
+        rw [← Real.rpow_sum_of_pos (by linarith)]
+        congr 1
+        rw [Finset.sum_neg_distrib, ← Finset.sum_mul]
+        have hsum : (∑ i, (α i : ℝ)) = absA α := by simp [absA]
+        rw [hsum]
+        simp only [q]
+        field_simp
+      rw [hsplit]
+      refine Finset.prod_le_prod₀ (fun i _ => by positivity) fun i _ => ?_
+      -- `(1 + |zᵢ|)^{1/αᵢ} ≤ 1 + |zᵢ|^{1/αᵢ} ≤ 1 + ρ(z)`
+      have hαi : (1 : ℝ) ≤ α i := by exact_mod_cast hα i
+      have hq0 : 0 ≤ q := div_nonneg (by linarith) hA.le
+      have h1 : (1 + |z i|) ^ ((α i : ℝ)⁻¹) ≤ 1 + rho α z := by
+        have hsub : (1 + |z i|) ^ ((α i : ℝ)⁻¹) ≤ 1 ^ ((α i : ℝ)⁻¹) + |z i| ^ ((α i : ℝ)⁻¹) := by
+          have := NNReal.rpow_add_le_add_rpow (1 : ℝ≥0) ⟨|z i|, abs_nonneg _⟩ (p := (α i : ℝ)⁻¹)
+            (by positivity) (inv_le_one_of_one_le₀ hαi)
+          rw [← NNReal.coe_le_coe] at this
+          push_cast at this
+          exact this
+        rw [Real.one_rpow] at hsub
+        linarith [abs_coord_rpow_le_rho α z i]
+      calc (1 + rho α z) ^ (-(α i * q)) ≤ ((1 + |z i|) ^ ((α i : ℝ)⁻¹)) ^ (-(α i * q)) :=
+            Real.rpow_le_rpow_of_nonpos (by positivity) h1 (by nlinarith)
+        _ = (1 + ‖WithLp.ofLp z i‖) ^ (-q) := by
+            rw [← Real.rpow_mul (by positivity)]
+            congr 1
+            field_simp
+
+theorem one_add_inv_mul_rho_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t)
+    (z : Rn n) : 1 + t⁻¹ * rho α z = 1 + rho α (dil α t⁻¹ z) := by
+  rw [rho_dil α hα (inv_pos.mpr ht)]
+
+/-- The scaled weight is integrable: `x ↦ (1 + t⁻¹ ρ(x - c))^{-s}` for `s > |α|`, `t > 0`. -/
+theorem integrable_wgt_scaled (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {s : ℝ}
+    (hs : (absA α : ℝ) < s) {t : ℝ} (ht : 0 < t) (c : Rn n) :
+    Integrable (fun x : Rn n => (1 + t⁻¹ * rho α (x - c)) ^ (-s)) := by
+  have h1 : Integrable ((fun z : Rn n => (1 + rho α z) ^ (-s)) ∘ dil α t⁻¹) := by
+    rw [← (dil_measurableEmbedding α (inv_pos.mpr ht)).integrable_map_iff,
+      map_dil_volume α (inv_pos.mpr ht)]
+    exact (integrable_wgt α hα hs).smul_measure ENNReal.ofReal_ne_top
+  have h2 := h1.comp_sub_right c
+  refine h2.congr (Filter.Eventually.of_forall fun x => ?_)
+  simp only [Function.comp_apply]
+  rw [one_add_inv_mul_rho_eq α hα ht]
+
+/-- The integral of the scaled weight:
+`∫ (1 + t⁻¹ ρ(x - c))^{-s} dx = t^{|α|} ∫ (1 + ρ(z))^{-s} dz`. -/
+theorem integral_wgt_scaled (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (s : ℝ) {t : ℝ} (ht : 0 < t)
+    (c : Rn n) :
+    ∫ x : Rn n, (1 + t⁻¹ * rho α (x - c)) ^ (-s) = t ^ absA α * ∫ z : Rn n, (1 + rho α z) ^ (-s)
+        := by
+  simp_rw [one_add_inv_mul_rho_eq α hα ht]
+  rw [integral_sub_right_eq_self (fun y : Rn n => (1 + rho α (dil α t⁻¹ y)) ^ (-s)) c,
+    integral_comp_dil α (inv_pos.mpr ht) (fun z : Rn n => (1 + rho α z) ^ (-s)), smul_eq_mul,
+    inv_pow, inv_inv]
+
+/-- Two-scale product inequality: for `0 ≤ λ ≤ λ'`,
+`1 + λ ρ(u - v) ≤ (1 + λ ρ(u)) (1 + λ' ρ(v))`. -/
+theorem one_add_mul_rho_sub_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {l l' : ℝ} (hl : 0 ≤ l)
+    (hll' : l ≤ l') (u v : Rn n) :
+    1 + l * rho α (u - v) ≤ (1 + l * rho α u) * (1 + l' * rho α v) := by
+  have h1 : rho α (u - v) ≤ rho α u + rho α v := by
+    have := rho_add_le α hα u (-v)
+    rwa [← sub_eq_add_neg, rho_neg] at this
+  have hu := rho_nonneg α u
+  have hv := rho_nonneg α v
+  have h2 : l * rho α v ≤ l' * rho α v := mul_le_mul_of_nonneg_right hll' hv
+  nlinarith [mul_le_mul_of_nonneg_left h1 hl, mul_nonneg (mul_nonneg hl hu) (mul_nonneg
+      (hl.trans hll') hv)]
+
+/-- Schwartz functions decay faster than any power of the anisotropic norm. -/
+theorem schwartz_rho_decay (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (f : 𝓢(Rn n, ℂ)) (M : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ z, ‖f z‖ ≤ C * (1 + rho α z) ^ (-(M : ℝ)) := by
+  set S := (Finset.Iic ((M, 0) : ℕ × ℕ)).sup (fun m => SchwartzMap.seminorm ℝ m.1 m.2) f
+  have hS : 0 ≤ S := apply_nonneg _ _
+  refine ⟨2 ^ M * (2 ^ M * S), by positivity, fun z => ?_⟩
+  have h1 := SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) (m := (M, 0)) (k := M) (n := 0)
+    le_rfl le_rfl f z
+  rw [norm_iteratedFDeriv_zero] at h1
+  have hρ := rho_nonneg α z
+  have h2 : (1 + rho α z) ^ M ≤ 2 ^ M * (1 + ‖z‖) ^ M := by
+    rw [← mul_pow]
+    gcongr
+    linarith [rho_le_one_add_norm α hα z, norm_nonneg z]
+  rw [Real.rpow_neg (by linarith), Real.rpow_natCast, ← div_eq_mul_inv,
+    le_div_iff₀ (by positivity)]
+  calc ‖f z‖ * (1 + rho α z) ^ M ≤ ‖f z‖ * (2 ^ M * (1 + ‖z‖) ^ M) := by gcongr
+    _ = 2 ^ M * ((1 + ‖z‖) ^ M * ‖f z‖) := by ring
+    _ ≤ 2 ^ M * (2 ^ M * S) := by gcongr
+
+theorem norm_wavePhi (α : Fin n → ℕ) (P : Tile n) (x : Rn n) :
+    ‖wavePhi α P x‖ = ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+      ‖(phi : Rn n → ℂ) (dil α ((2 : ℝ) ^ P.k)⁻¹ (x - P.cI α))‖ := by
+  simp only [wavePhi, modul, transl, dilOp, norm_mul, mul_comm Complex.I,
+    Complex.norm_exp_ofReal_mul_I, one_mul, Complex.norm_real, Real.norm_eq_abs]
+  rw [abs_of_pos (by positivity)]
+
+/-- Decay of the wave packets: `|φ_P(x)| ≤ C_M |I_P|^{-1/2} (1 + 2^{-k_P} ρ(x - c(I_P)))^{-M}`. -/
+theorem wavePhi_decay (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (M : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (P : Tile n) (x : Rn n), ‖wavePhi α P x‖ ≤
+      C * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(M : ℝ)) := by
+  obtain ⟨C, hC, hdec⟩ := schwartz_rho_decay α hα (phi : 𝓢(Rn n, ℂ)) M
+  refine ⟨C, hC, fun P x => ?_⟩
+  rw [norm_wavePhi, one_add_inv_mul_rho_eq α hα (by positivity)]
+  calc ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+        ‖(phi : Rn n → ℂ) (dil α ((2 : ℝ) ^ P.k)⁻¹ (x - P.cI α))‖
+      ≤ ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+          (C * (1 + rho α (dil α ((2 : ℝ) ^ P.k)⁻¹ (x - P.cI α))) ^ (-(M : ℝ))) := by
+        gcongr
+        exact hdec _
+    _ = _ := by ring
+
+/-- Pairing bound for two functions with anisotropic decay at ordered spatial scales. -/
+theorem norm_pairing_le_of_rho_decay (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ)
+    {f g : Rn n → ℂ} {t t' : ℝ} (ht : 0 < t) (ht' : 0 < t') (htt' : t' ≤ t)
+    (c c' : Rn n) {C1 C2 : ℝ} (hC1 : 0 ≤ C1) (hC2 : 0 ≤ C2)
+    (h1 : ∀ x, ‖f x‖ ≤ C1 * t ^ (-(absA α : ℝ) / 2) *
+      (1 + t⁻¹ * rho α (x - c)) ^ (-(ν : ℝ)))
+    (h2 : ∀ x, ‖g x‖ ≤ C2 * t' ^ (-(absA α : ℝ) / 2) *
+      (1 + t'⁻¹ * rho α (x - c')) ^ (-((ν + (absA α + 1) : ℕ) : ℝ))) :
+    ‖pairing f g‖ ≤ C1 * C2 * (∫ z : Rn n, (1 + rho α z) ^ (-(absA α + 1 : ℝ))) *
+      t ^ (-(absA α : ℝ) / 2) * t' ^ ((absA α : ℝ) / 2) *
+        (1 + t⁻¹ * rho α (c - c')) ^ (-(ν : ℝ)) := by
+  set s0 : ℝ := absA α + 1
+  set W := ∫ z : Rn n, (1 + rho α z) ^ (-s0)
+  set D := (1 + t⁻¹ * rho α (c - c')) ^ (-(ν : ℝ))
+  have hD : 0 ≤ D := by have := rho_nonneg α (c - c'); positivity
+  -- pointwise bound on the integrand
+  have hpt : ∀ x, ‖f x * (starRingEnd ℂ) (g x)‖ ≤
+      C1 * C2 * t ^ (-(absA α : ℝ) / 2) * t' ^ (-(absA α : ℝ) / 2) * D *
+        (1 + t'⁻¹ * rho α (x - c')) ^ (-s0) := by
+    intro x
+    rw [norm_mul, RCLike.norm_conj]
+    have hu := rho_nonneg α (x - c)
+    have hv := rho_nonneg α (x - c')
+    have hA : 0 < 1 + t⁻¹ * rho α (x - c) := by positivity
+    have hB : 0 < 1 + t'⁻¹ * rho α (x - c') := by positivity
+    have hprod : (1 + t⁻¹ * rho α (x - c)) ^ (-(ν : ℝ)) *
+        (1 + t'⁻¹ * rho α (x - c')) ^ (-(ν : ℝ)) ≤ D := by
+      rw [← Real.mul_rpow hA.le hB.le]
+      apply Real.rpow_le_rpow_of_nonpos (by have := rho_nonneg α (c - c'); positivity)
+          _ (by simp)
+      have := one_add_mul_rho_sub_le α hα (inv_nonneg.mpr ht.le)
+        (inv_anti₀ ht' htt') (x - c) (x - c')
+      rwa [sub_sub_sub_cancel_left, rho_sub_comm] at this
+    have hsplit : (1 + t'⁻¹ * rho α (x - c')) ^ (-((ν + (absA α + 1) : ℕ) : ℝ)) =
+        (1 + t'⁻¹ * rho α (x - c')) ^ (-(ν : ℝ)) *
+          (1 + t'⁻¹ * rho α (x - c')) ^ (-s0) := by
+      rw [← Real.rpow_add hB]
+      congr 1
+      push_cast
+      ring
+    calc ‖f x‖ * ‖g x‖
+        ≤ (C1 * t ^ (-(absA α : ℝ) / 2) * (1 + t⁻¹ * rho α (x - c)) ^ (-(ν : ℝ))) *
+          (C2 * t' ^ (-(absA α : ℝ) / 2) *
+            (1 + t'⁻¹ * rho α (x - c')) ^ (-((ν + (absA α + 1) : ℕ) : ℝ))) :=
+          mul_le_mul (h1 x) (h2 x) (norm_nonneg _) (by positivity)
+      _ = C1 * C2 * t ^ (-(absA α : ℝ) / 2) * t' ^ (-(absA α : ℝ) / 2) *
+          ((1 + t⁻¹ * rho α (x - c)) ^ (-(ν : ℝ)) *
+            (1 + t'⁻¹ * rho α (x - c')) ^ (-(ν : ℝ))) *
+          (1 + t'⁻¹ * rho α (x - c')) ^ (-s0) := by rw [hsplit]; ring
+      _ ≤ _ := by gcongr
+  have hs0 : (absA α : ℝ) < s0 := by simp [s0]
+  have hint := integrable_wgt_scaled α hα hs0 ht' c'
+  calc ‖pairing f g‖
+      ≤ ∫ x, ‖f x * (starRingEnd ℂ) (g x)‖ :=
+        norm_integral_le_integral_norm _
+    _ ≤ ∫ x, C1 * C2 * t ^ (-(absA α : ℝ) / 2) * t' ^ (-(absA α : ℝ) / 2) * D *
+          (1 + t'⁻¹ * rho α (x - c')) ^ (-s0) :=
+        integral_mono_of_nonneg (Filter.Eventually.of_forall fun x => norm_nonneg _)
+          (hint.const_mul _) (Filter.Eventually.of_forall hpt)
+    _ = C1 * C2 * t ^ (-(absA α : ℝ) / 2) * t' ^ (-(absA α : ℝ) / 2) * D * (t' ^ absA α * W) := by
+        rw [integral_const_mul, integral_wgt_scaled α hα s0 ht']
+    _ = C1 * C2 * W * t ^ (-(absA α : ℝ) / 2) * t' ^ ((absA α : ℝ) / 2) * D := by
+        have : t' ^ (-(absA α : ℝ) / 2) * t' ^ absA α = t' ^ ((absA α : ℝ) / 2) := by
+          rw [← Real.rpow_natCast, ← Real.rpow_add ht']
+          congr 1
+          ring
+        calc _ = C1 * C2 * W * t ^ (-(absA α : ℝ) / 2) *
+              (t' ^ (-(absA α : ℝ) / 2) * t' ^ absA α) * D := by ring
+          _ = _ := by rw [this]
+
+/-- Tile interaction estimate (paper, §4, (4.16), proved in §8): for `|I_P| ≥ |I_{P'}|`
+(i.e. `k_{P'} ≤ k_P`) and every integer `ν ≥ 0`,
+`|⟨φ_P, φ_{P'}⟩| ≤ C |I_P|^{-1/2} |I_{P'}|^{1/2} (1 + 2^{-k_P} ρ(c(I_P) - c(I_{P'})))^{-ν}`,
+with `C` depending only on `ν`, `α` and `φ`. -/
+theorem tile_interaction (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ P P' : Tile n, P'.k ≤ P.k →
+      ‖pairing (wavePhi α P) (wavePhi α P')‖ ≤
+        C * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) *
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (P.cI α - P'.cI α)) ^ (-(ν : ℝ)) := by
+  obtain ⟨C1, hC1, h1⟩ := wavePhi_decay α hα ν
+  obtain ⟨C2, hC2, h2⟩ := wavePhi_decay α hα (ν + (absA α + 1))
+  set W := ∫ z : Rn n, (1 + rho α z) ^ (-(absA α + 1 : ℝ))
+  have hW : 0 ≤ W := integral_nonneg fun z => by
+    have := rho_nonneg α z; positivity
+  refine ⟨C1 * C2 * W, by positivity, fun P P' hk => ?_⟩
+  exact norm_pairing_le_of_rho_decay α hα ν (by positivity) (by positivity)
+    (zpow_le_zpow_right₀ (by norm_num) hk) (P.cI α) (P'.cI α) hC1 hC2 (h1 P) (h2 P')
+
+/-! ### Finiteness of `‖m‖_{𝓜^ν}` and the interaction estimate (4.17) (paper, §8) -/
+
+/-- The anisotropic unit sphere `{ρ = 1}` is compact. -/
+theorem isCompact_rho_eq_one (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    IsCompact {ξ : Rn n | rho α ξ = 1} := by
+  have hK : IsCompact ((WithLp.toLp 2 : (Fin n → ℝ) → Rn n) ''
+      Set.pi Set.univ fun _ => Set.Icc (-1 : ℝ) 1) :=
+    (isCompact_univ_pi fun _ => isCompact_Icc).image (PiLp.continuous_toLp 2 _)
+  refine hK.of_isClosed_subset (isClosed_eq (continuous_rho α) continuous_const) ?_
+  intro ξ hξ
+  refine ⟨WithLp.ofLp ξ, fun i _ => ?_, by simp⟩
+  have h1 := abs_coord_rpow_le_rho α ξ i
+  rw [Set.mem_ofPred_eq.mp hξ] at h1
+  have hq : 0 < (α i : ℝ)⁻¹ := by have := hα i; positivity
+  have : |ξ i| ≤ 1 := by
+    by_contra hcon
+    push Not at hcon
+    have := Real.one_lt_rpow hcon hq
+    linarith
+  exact abs_le.mp this
+
+theorem continuousOn_iterPartial (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    {k : ℕ} (hk : k ≤ ν) (i : Fin k → Fin n) :
+    ContinuousOn (iterPartial k m i) {0}ᶜ := by
+  have hopen : IsOpen ({0}ᶜ : Set (Rn n)) := isOpen_compl_singleton
+  have h1 := hm.contDiffOn.continuousOn_iteratedFDerivWithin (m := k) (by exact_mod_cast hk)
+    hopen.uniqueDiffOn
+  have h2 : ContinuousOn (iteratedFDeriv ℝ k m) {0}ᶜ :=
+    h1.congr fun ξ hξ => (iteratedFDerivWithin_of_isOpen k hopen hξ).symm
+  unfold iterPartial
+  exact (ContinuousMultilinearMap.apply ℝ (fun _ : Fin k => Rn n) ℂ
+    (fun j => EuclideanSpace.single (i j) (1 : ℝ))).continuous.comp_continuousOn h2
+
+/-- The norm `‖m‖_{𝓜^ν}` is finite for `m ∈ 𝓜^ν`. -/
+theorem normM_lt_top (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) : normM α ν m < ⊤ := by
+  have hS := isCompact_rho_eq_one α hα
+  have hsub : {ξ : Rn n | rho α ξ = 1} ⊆ {0}ᶜ := fun ξ hξ =>
+    ne_zero_of_rho_pos α hα (by rw [Set.mem_ofPred_eq.mp hξ]; norm_num)
+  have hB : ∀ k : Fin (ν + 1), ∀ i : Fin k → Fin n, ∃ B : ℝ, ∀ ξ ∈ {ξ : Rn n | rho α ξ = 1},
+      ‖iterPartial k m i ξ‖ ≤ B := fun k i =>
+    hS.exists_bound_of_continuousOn
+      ((continuousOn_iterPartial α hm (Nat.lt_succ_iff.mp k.2) i).mono hsub)
+  choose B hB using hB
+  set Btot : ℝ := ∑ k : Fin (ν + 1), ∑ i : Fin k → Fin n, |B k i|
+  refine lt_of_le_of_lt ?_ (ENNReal.ofReal_lt_top (r := Btot))
+  refine iSup₂_le fun k hk => iSup_le fun i => iSup₂_le fun ξ hξ => ?_
+  set k' : Fin (ν + 1) := ⟨k, Nat.lt_succ_of_le hk⟩
+  have h1 : ‖iterPartial k m i ξ‖ ≤ |B k' i| := (hB k' i ξ hξ).trans (le_abs_self _)
+  have h2 : |B k' i| ≤ Btot :=
+    (Finset.single_le_sum (f := fun i => |B k' i|) (fun _ _ => abs_nonneg _) (Finset.mem_univ
+        i)).trans
+      (Finset.single_le_sum (f := fun k : Fin (ν + 1) => ∑ i : Fin k → Fin n, |B k i|)
+        (fun _ _ => Finset.sum_nonneg fun _ _ => abs_nonneg _) (Finset.mem_univ k'))
+  rw [← ofReal_norm]
+  exact ENNReal.ofReal_le_ofReal (h1.trans h2)
+
+/-- Real-valued form of the wave packet estimate (4.15):
+`|ψ^N_P(x)| ≤ C ‖m‖_{𝓜^ν} |I_P|^{-1/2} (1 + 2^{-k_P} ρ(x - c(I_P)))^{-ν}`. -/
+theorem psi_estimate_real (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ) {m : Rn n → ℂ}
+    (hm : ClassM α ν m) (P : Tile n) (N : Rn n)
+    (hN : ∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) (x : Rn n) :
+    ‖wavePsi α m N P x‖ ≤ (psiConst α ν : ℝ) * (normM α ν m).toReal *
+      ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+  have h := psi_estimate α hα ν hm P N hN x
+  set t := (2 : ℝ) ^ P.k
+  have ht : 0 < t := by positivity
+  have hW : t ^ ((absA α : ℝ) / 2) * wP α ν P x =
+      t ^ (-(absA α : ℝ) / 2) * (1 + t⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+    simp only [wP, wgt]
+    rw [one_add_inv_mul_rho_eq α hα ht, ← mul_assoc, ← Real.rpow_add ht]
+    congr 2
+    ring
+  rw [hW] at h
+  have hfin := (normM_lt_top α hα hm).ne
+  rw [← ofReal_norm, ← ENNReal.ofReal_toReal hfin, ← ENNReal.ofReal_coe_nnreal,
+    ← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_mul (by positivity),
+    ENNReal.ofReal_le_ofReal_iff (by have := rho_nonneg α (x - P.cI α); positivity)] at h
+  calc ‖wavePsi α m N P x‖ ≤ _ := h
+    _ = _ := by ring
+
+/-- Tile interaction estimate for the `ψ` wave packets (paper, §4, (4.17), proved in §8): for
+`|I_P| ≥ |I_{P'}|`, `N` outside the interiors of `ω_{P(0)}` and `ω_{P'(0)}`, and integers `ν ≥ 0`,
+`|⟨ψ^N_P, ψ^N_{P'}⟩| ≤ C ‖m‖² |I_P|^{-1/2} |I_{P'}|^{1/2} (1 + 2^{-k_P} ρ(c(I_P) -
+    c(I_{P'})))^{-ν}`.
+The argument needs one factor with decay `ν + |α| + 1`, so the norm is `‖m‖_{𝓜^{ν+|α|+1}}`
+(the paper writes `‖m‖_{𝓜^ν}`). -/
+theorem tile_interaction_psi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (ν + (absA α + 1)) m →
+      ∀ (P P' : Tile n) (N : Rn n), P'.k ≤ P.k →
+      (∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) →
+      (∃ j, side α (-P'.k) j / 4 ≤ |N j - P'.cω0 α j|) →
+      ‖pairing (wavePsi α m N P) (wavePsi α m N P')‖ ≤
+        C * (normM α (ν + (absA α + 1)) m).toReal ^ 2 *
+          ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) *
+            (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (P.cI α - P'.cI α)) ^ (-(ν : ℝ)) := by
+  set ν' := ν + (absA α + 1)
+  set C1 : ℝ := (psiConst α ν' : ℝ)
+  set s0 : ℝ := absA α + 1
+  set W := ∫ z : Rn n, (1 + rho α z) ^ (-s0)
+  have hW : 0 ≤ W := integral_nonneg fun z => by
+    have := rho_nonneg α z; positivity
+  have hC1 : 0 ≤ C1 := NNReal.coe_nonneg _
+  refine ⟨C1 * C1 * W, by positivity, fun m hm P P' N hk hNP hNP' => ?_⟩
+  set M := (normM α ν' m).toReal
+  have hM : 0 ≤ M := ENNReal.toReal_nonneg
+  set t := (2 : ℝ) ^ P.k
+  set t' := (2 : ℝ) ^ P'.k
+  -- lower-order decay for `P` from the higher-order estimate
+  have hP : ∀ x, ‖wavePsi α m N P x‖ ≤ C1 * M * t ^ (-(absA α : ℝ) / 2) *
+      (1 + t⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+    intro x
+    refine (psi_estimate_real α hα ν' hm P N hNP x).trans ?_
+    have hA : 1 ≤ 1 + t⁻¹ * rho α (x - P.cI α) := by
+      have := rho_nonneg α (x - P.cI α); simp only [le_add_iff_nonneg_right]; positivity
+    gcongr
+    omega
+  calc ‖pairing (wavePsi α m N P) (wavePsi α m N P')‖
+      ≤ (C1 * M) * (C1 * M) * W * t ^ (-(absA α : ℝ) / 2) *
+          t' ^ ((absA α : ℝ) / 2) *
+            (1 + t⁻¹ * rho α (P.cI α - P'.cI α)) ^ (-(ν : ℝ)) :=
+        norm_pairing_le_of_rho_decay α hα ν (by positivity) (by positivity)
+          (zpow_le_zpow_right₀ (by norm_num) hk) (P.cI α) (P'.cI α)
+          (mul_nonneg hC1 hM) (mul_nonneg hC1 hM) hP
+          (psi_estimate_real α hα ν' hm P' N hNP')
+    _ = _ := by ring
+
+/-! ### Lattice sums of anisotropic weights -/
+
+/-- The lattice point `ℓ ∈ ℤⁿ ⊂ ℝⁿ`. -/
+def latticePt (ℓ : Fin n → ℤ) : Rn n := WithLp.toLp 2 (fun i => (ℓ i : ℝ))
+
+@[simp] theorem latticePt_apply (ℓ : Fin n → ℤ) (i : Fin n) : latticePt ℓ i = ℓ i := rfl
+
+theorem side_zero (α : Fin n → ℕ) (i : Fin n) : side α 0 i = 1 := by simp [side]
+
+theorem mem_unitCube_iff (α : Fin n → ℕ) (ℓ : Fin n → ℤ) (w : Rn n) :
+    w ∈ (⟨0, ℓ⟩ : DCube n).toSet α ↔ ∀ i, ⌊w i⌋ = ℓ i := by
+  rw [DCube.mem_toSet_iff_floor]
+  simp [side_zero]
+
+theorem rho_sub_latticePt_le_one (α : Fin n → ℕ) (ℓ : Fin n → ℤ) {w : Rn n}
+    (hw : w ∈ (⟨0, ℓ⟩ : DCube n).toSet α) : rho α (w - latticePt ℓ) ≤ 1 := by
+  have h : rhoNN α (w - latticePt ℓ) ≤ 1 := by
+    rw [rhoNN_le_iff]
+    intro i
+    have hi := hw i
+    simp only [side_zero, one_mul] at hi
+    apply NNReal.rpow_le_one _ (by positivity)
+    rw [← NNReal.coe_le_coe]
+    simp only [coe_nnnorm, PiLp.sub_apply, latticePt_apply, Real.norm_eq_abs, NNReal.coe_one]
+    rw [abs_le]
+    constructor <;> linarith [hi.1, hi.2]
+  simpa [rho] using (NNReal.coe_le_coe.mpr h)
+
+theorem pairwise_disjoint_unitCube (α : Fin n → ℕ) :
+    Pairwise (Function.onFun Disjoint fun ℓ : Fin n → ℤ => (⟨0, ℓ⟩ : DCube n).toSet α) := by
+  intro ℓ ℓ' hne
+  rw [Function.onFun, Set.disjoint_left]
+  intro w hw hw'
+  rw [mem_unitCube_iff] at hw hw'
+  exact hne (funext fun i => (hw i).symm.trans (hw' i))
+
+theorem iUnion_unitCube (α : Fin n → ℕ) :
+    (⋃ ℓ : Fin n → ℤ, (⟨0, ℓ⟩ : DCube n).toSet α) = Set.univ := by
+  ext w
+  simp only [Set.mem_iUnion, Set.mem_univ, iff_true]
+  exact ⟨fun i => ⌊w i⌋, (mem_unitCube_iff α _ w).mpr fun i => rfl⟩
+
+theorem volume_unitCube (α : Fin n → ℕ) (ℓ : Fin n → ℤ) :
+    volume ((⟨0, ℓ⟩ : DCube n).toSet α) = 1 := by
+  rw [DCube.volume_toSet]
+  simp
+
+/-- Lattice sums of the anisotropic weight are uniformly bounded (in `ℝ≥0∞` form):
+for `s > |α|` and all `z`, `∑_{ℓ ∈ ℤⁿ} (1 + ρ(z - ℓ))^{-s} ≤ 2^s ∫ (1 + ρ)^{-s}`. -/
+theorem tsum_wgt_lattice_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {s : ℝ}
+    (hs : (absA α : ℝ) < s) (z : Rn n) :
+    ∑' ℓ : Fin n → ℤ, ENNReal.ofReal ((1 + rho α (z - latticePt ℓ)) ^ (-s)) ≤
+      ENNReal.ofReal (2 ^ s * ∫ w : Rn n, (1 + rho α w) ^ (-s)) := by
+  have hs0 : 0 ≤ s := le_trans (Nat.cast_nonneg _) hs.le
+  set F : Rn n → ℝ := fun w => (1 + rho α w) ^ (-s)
+  have hF : Integrable F := integrable_wgt α hα hs
+  have hFnn : ∀ w, 0 ≤ F w := fun w => by have := rho_nonneg α w; positivity
+  -- pointwise comparison on each unit cube
+  have hcmp : ∀ ℓ : Fin n → ℤ, ∀ w ∈ (⟨0, ℓ⟩ : DCube n).toSet α,
+      (1 + rho α (z - latticePt ℓ)) ^ (-s) ≤ 2 ^ s * F (z - w) := by
+    intro ℓ w hw
+    have h1 : rho α (z - w) ≤ rho α (z - latticePt ℓ) + 1 := by
+      have := rho_add_le α hα (z - latticePt ℓ) (latticePt ℓ - w)
+      rw [sub_add_sub_cancel, rho_sub_comm α (latticePt ℓ)] at this
+      linarith [rho_sub_latticePt_le_one α ℓ hw]
+    have hpos : 0 < 1 + rho α (z - w) := by have := rho_nonneg α (z - w); positivity
+    have hpos' : 0 < 1 + rho α (z - latticePt ℓ) := by
+      have := rho_nonneg α (z - latticePt ℓ); positivity
+    have h2 : 1 + rho α (z - w) ≤ 2 * (1 + rho α (z - latticePt ℓ)) := by
+      have := rho_nonneg α (z - latticePt ℓ); linarith
+    have h3 : (2 * (1 + rho α (z - latticePt ℓ))) ^ (-s) ≤ (1 + rho α (z - w)) ^ (-s) :=
+      Real.rpow_le_rpow_of_nonpos hpos h2 (by linarith)
+    rw [Real.mul_rpow (by norm_num) hpos'.le, Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 2)] at h3
+    simp only [F]
+    have h2s : (0 : ℝ) < 2 ^ s := by positivity
+    calc (1 + rho α (z - latticePt ℓ)) ^ (-s)
+        = 2 ^ s * ((2 ^ s)⁻¹ * (1 + rho α (z - latticePt ℓ)) ^ (-s)) := by
+          field_simp
+      _ ≤ 2 ^ s * (1 + rho α (z - w)) ^ (-s) := by gcongr
+  have hmeas : ∀ ℓ : Fin n → ℤ, MeasurableSet ((⟨0, ℓ⟩ : DCube n).toSet α) :=
+    fun ℓ => DCube.measurableSet_toSet α _
+  calc ∑' ℓ : Fin n → ℤ, ENNReal.ofReal ((1 + rho α (z - latticePt ℓ)) ^ (-s))
+      = ∑' ℓ : Fin n → ℤ, ∫⁻ _w in (⟨0, ℓ⟩ : DCube n).toSet α,
+          ENNReal.ofReal ((1 + rho α (z - latticePt ℓ)) ^ (-s)) := by
+        congr 1
+        ext ℓ
+        rw [setLIntegral_const, volume_unitCube, mul_one]
+    _ ≤ ∑' ℓ : Fin n → ℤ, ∫⁻ w in (⟨0, ℓ⟩ : DCube n).toSet α,
+          ENNReal.ofReal (2 ^ s * F (z - w)) := by
+        refine ENNReal.tsum_le_tsum fun ℓ => ?_
+        exact setLIntegral_mono' (hmeas ℓ) fun w hw => ENNReal.ofReal_le_ofReal (hcmp ℓ w hw)
+    _ = ∫⁻ w in ⋃ ℓ : Fin n → ℤ, (⟨0, ℓ⟩ : DCube n).toSet α, ENNReal.ofReal (2 ^ s * F (z - w)) :=
+        (lintegral_iUnion hmeas (pairwise_disjoint_unitCube α) _).symm
+    _ = ∫⁻ w, ENNReal.ofReal (2 ^ s * F (z - w)) := by rw [iUnion_unitCube, Measure.restrict_univ]
+    _ = ENNReal.ofReal (2 ^ s * ∫ w, F w) := by
+        have hint : Integrable (fun w => 2 ^ s * F (z - w)) :=
+          ((hF.comp_sub_left z).const_mul _)
+        rw [← ofReal_integral_eq_lintegral_ofReal hint
+          (Filter.Eventually.of_forall fun w => by have := hFnn (z - w); positivity)]
+        congr 1
+        rw [integral_const_mul, integral_sub_left_eq_self]
+
+/-- Real form of the lattice bound, with summability. -/
+theorem summable_wgt_lattice (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {s : ℝ}
+    (hs : (absA α : ℝ) < s) (z : Rn n) :
+    Summable (fun ℓ : Fin n → ℤ => (1 + rho α (z - latticePt ℓ)) ^ (-s)) ∧
+      ∑' ℓ : Fin n → ℤ, (1 + rho α (z - latticePt ℓ)) ^ (-s) ≤
+        2 ^ s * ∫ w : Rn n, (1 + rho α w) ^ (-s) := by
+  have hnn : ∀ ℓ : Fin n → ℤ, 0 ≤ (1 + rho α (z - latticePt ℓ)) ^ (-s) := fun ℓ => by
+    have := rho_nonneg α (z - latticePt ℓ); positivity
+  have h := tsum_wgt_lattice_le α hα hs z
+  have hfin : ∑' ℓ : Fin n → ℤ, ENNReal.ofReal ((1 + rho α (z - latticePt ℓ)) ^ (-s)) ≠ ⊤ :=
+    ne_top_of_le_ne_top ENNReal.ofReal_ne_top h
+  have hsum : Summable (fun ℓ : Fin n → ℤ => (1 + rho α (z - latticePt ℓ)) ^ (-s)) := by
+    have := ENNReal.summable_toReal hfin
+    simpa [ENNReal.toReal_ofReal (hnn _)] using this
+  refine ⟨hsum, ?_⟩
+  have hI : 0 ≤ 2 ^ s * ∫ w : Rn n, (1 + rho α w) ^ (-s) := by
+    have : 0 ≤ ∫ w : Rn n, (1 + rho α w) ^ (-s) := integral_nonneg fun w => by
+      have := rho_nonneg α w; positivity
+    positivity
+  rw [← ENNReal.ofReal_tsum_of_nonneg hnn hsum] at h
+  exact (ENNReal.ofReal_le_ofReal_iff hI).mp h
+
+/-! ### Fourier inversion and Parseval in the paper's normalization -/
+
+theorem fourier_eq_fhat (f : Rn n → ℂ) (w : Rn n) :
+    FourierTransform.fourier f w = fhat f ((2 * π) • w) := by
+  rw [fhat_eq_fourier, smul_smul, inv_mul_cancel₀ (by positivity), one_smul]
+
+theorem integrable_fourier_of_fhat {f : Rn n → ℂ} (hF : Integrable (fhat f)) :
+    Integrable (FourierTransform.fourier f) := by
+  have : FourierTransform.fourier f = fun w => fhat f ((2 * π) • w) :=
+    funext (fourier_eq_fhat f)
+  rw [this]
+  exact hF.comp_smul (by positivity)
+
+theorem integrable_fhat_of_fourier {f : Rn n → ℂ} (hF : Integrable (FourierTransform.fourier f)) :
+    Integrable (fhat f) := by
+  have : fhat f = fun ξ => FourierTransform.fourier f ((2 * π)⁻¹ • ξ) :=
+    funext (fhat_eq_fourier f)
+  rw [this]
+  exact hF.comp_smul (by positivity)
+
+theorem norm_cexp_I_mul (r : ℝ) : ‖Complex.exp (Complex.I * (r : ℂ))‖ = 1 := by
+  rw [mul_comm, Complex.norm_exp_ofReal_mul_I]
+
+theorem norm_cexp_neg_I_mul (r : ℝ) : ‖Complex.exp (-(Complex.I * (r : ℂ)))‖ = 1 := by
+  rw [← mul_neg, ← Complex.ofReal_neg, norm_cexp_I_mul]
+
+/-- Fourier inversion in the paper's normalization:
+`f(x) = (2π)^{-n} ∫ f̂(ξ) e^{i x ξ} dξ` for continuous integrable `f` with integrable `f̂`. -/
+theorem fhat_inversion {f : Rn n → ℂ} (hc : Continuous f) (hf : Integrable f)
+    (hF : Integrable (fhat f)) (x : Rn n) :
+    f x = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by
+  have hinv := hc.fourierInv_fourier_eq hf (integrable_fourier_of_fhat hF)
+  have hx := congrFun hinv x
+  rw [Real.fourierInv_eq] at hx
+  rw [← hx]
+  set G : Rn n → ℂ := fun ξ => fhat f ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))
+  have hG : ∀ w : Rn n, Real.fourierChar ⟪w, x⟫_ℝ • FourierTransform.fourier f w =
+      G ((2 * π) • w) := by
+    intro w
+    rw [fourier_eq_fhat, Circle.smul_def, Real.fourierChar_apply]
+    simp only [G, inner_smul_right, smul_eq_mul]
+    rw [mul_comm (Complex.exp _) (fhat f _), real_inner_comm x w]
+    congr 1
+    push_cast
+    ring_nf
+  simp_rw [hG]
+  rw [Measure.integral_comp_smul, finrank_euclideanSpace_fin, abs_inv, abs_pow,
+    abs_of_pos (by positivity : (0 : ℝ) < 2 * π), Complex.real_smul]
+  push_cast
+  ring
+
+/-- Parseval's identity in the paper's normalization:
+`⟨g, h⟩ = (2π)^{-n} ∫ ĝ(ξ) conj(hhat(ξ)) dξ` for integrable `g` and continuous integrable `h` with
+integrable `hhat`. -/
+theorem pairing_eq_fhat {g h : Rn n → ℂ} (hg : Integrable g) (hc : Continuous h)
+    (hh : Integrable h) (hH : Integrable (fhat h)) :
+    pairing g h = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ξ, fhat g ξ * (starRingEnd ℂ) (fhat h ξ) := by
+  unfold pairing
+  have hrepr : ∀ x, (starRingEnd ℂ) (h x) = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ξ, (starRingEnd ℂ) (fhat h ξ) * Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+    intro x
+    rw [fhat_inversion hc hh hH x, map_mul, ← integral_conj]
+    congr 1
+    · simp [map_inv₀, map_pow, map_ofNat]
+    · congr 1
+      ext ξ
+      rw [map_mul, ← Complex.exp_conj]
+      congr 2
+      simp [Complex.conj_ofReal]
+  simp_rw [hrepr]
+  -- Fubini
+  set K : Rn n → Rn n → ℂ := fun x ξ =>
+    g x * ((starRingEnd ℂ) (fhat h ξ) * Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))))
+  have hK : Integrable (Function.uncurry K) (volume.prod volume) := by
+    have hprod : Integrable (fun z : Rn n × Rn n => g z.1 * (starRingEnd ℂ) (fhat h z.2))
+        (volume.prod volume) :=
+      hg.mul_prod ((RCLike.conjCLE (K := ℂ)).toContinuousLinearMap.integrable_comp hH)
+    refine hprod.mono ?_ (Filter.Eventually.of_forall fun z => ?_)
+    · exact hg.aestronglyMeasurable.comp_fst.mul
+        ((RCLike.continuous_conj.comp_aestronglyMeasurable hH.aestronglyMeasurable).comp_snd.mul
+          (by fun_prop : Continuous fun a : Rn n × Rn n =>
+            Complex.exp (-(Complex.I * (⟪a.1, a.2⟫_ℝ : ℂ)))).aestronglyMeasurable)
+    · simp only [Function.uncurry, K, norm_mul, norm_cexp_neg_I_mul, mul_one]
+      rfl
+  calc ∫ x, g x * ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, (starRingEnd ℂ) (fhat h ξ) *
+        Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ))))
+      = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ x, ∫ ξ, K x ξ := by
+        rw [← integral_const_mul]
+        refine integral_congr_ae (Filter.Eventually.of_forall fun x => ?_)
+        simp only [K]
+        rw [integral_const_mul]
+        ring
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, ∫ x, K x ξ := by rw [integral_integral_swap hK]
+    _ = _ := by
+        congr 1
+        refine integral_congr_ae (Filter.Eventually.of_forall fun ξ => ?_)
+        simp only [K, fhat]
+        rw [← integral_mul_const]
+        congr 1
+        ext x
+        ring
+
+/-! ### Convergence of the model sum (3.3) -/
+
+attribute [fun_prop] continuous_dil
+
+theorem continuous_wavePhi (α : Fin n → ℕ) (P : Tile n) : Continuous (wavePhi α P) := by
+  have hφ : Continuous (phi : Rn n → ℂ) := (phi : 𝓢(Rn n, ℂ)).continuous
+  unfold wavePhi modul transl dilOp
+  fun_prop
+
+theorem integrable_wavePhi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P : Tile n) :
+    Integrable (wavePhi α P) := by
+  obtain ⟨C, hC, h⟩ := wavePhi_decay α hα (absA α + 1)
+  have hs : (absA α : ℝ) < ((absA α + 1 : ℕ) : ℝ) := by push_cast; linarith
+  have hint := (integrable_wgt_scaled α hα hs (t := (2 : ℝ) ^ P.k) (by positivity) (P.cI
+      α)).const_mul
+    (C * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2))
+  refine hint.mono' (continuous_wavePhi α P).aestronglyMeasurable
+    (Filter.Eventually.of_forall fun x => ?_)
+  exact (h P x).trans (le_of_eq (by ring))
+
+theorem norm_phiHat_le_one (ζ : Rn n) : ‖phiHat ζ‖ ≤ 1 := by
+  obtain ⟨h1, h2, h3⟩ := phiHat_re_mem ζ
+  rw [h1, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg h2]
+  exact h3
+
+@[fun_prop]
+theorem continuous_phiHat : Continuous (phiHat : Rn n → ℂ) := contDiff_phiHat.continuous
+
+theorem integrable_phiHat : Integrable (phiHat : Rn n → ℂ) :=
+  continuous_phiHat.integrable_of_hasCompactSupport hasCompactSupport_phiHat
+
+theorem integrable_fhat_wavePhi (α : Fin n → ℕ) (P : Tile n) : Integrable (fhat (wavePhi α P)) := by
+  set t : ℝ := (2 : ℝ) ^ P.k
+  have ht : 0 < t := by positivity
+  have h1 : Integrable (fun ξ : Rn n => phiHat (dil α t (ξ - P.cω0 α))) := by
+    have h0 : Integrable ((phiHat : Rn n → ℂ) ∘ dil α t) := by
+      rw [← (dil_measurableEmbedding α ht).integrable_map_iff, map_dil_volume α ht]
+      exact integrable_phiHat.smul_measure ENNReal.ofReal_ne_top
+    exact h0.comp_sub_right (P.cω0 α)
+  have h2 := h1.const_mul (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ))
+  have hcont : Continuous (fhat (wavePhi α P)) := by
+    have : fhat (wavePhi α P) = fun ξ => (((t ^ ((absA α : ℝ) / 2) : ℝ) : ℂ)) *
+        Complex.exp (-(Complex.I * (⟪P.cI α, ξ - P.cω0 α⟫_ℝ : ℂ))) *
+          phiHat (dil α t (ξ - P.cω0 α)) := funext (fhat_wavePhi α P)
+    rw [this]
+    fun_prop
+  refine h2.norm.mono' hcont.aestronglyMeasurable (Filter.Eventually.of_forall fun ξ => ?_)
+  rw [fhat_wavePhi, norm_mul, norm_mul, norm_cexp_neg_I_mul, mul_one, norm_mul]
+
+/-- The box `S_P = {ξ : |ξᵢ - c(ω_{P(0)})ᵢ| < 2^{-k_P αᵢ} b₀/2}` containing the support of
+    `φ̂_P`. -/
+def suppBox (α : Fin n → ℕ) (P : Tile n) : Set (Rn n) :=
+  {ξ | ∀ i, |ξ i - P.cω0 α i| < side α (-P.k) i * (b0 / 2)}
+
+theorem measurableSet_suppBox (α : Fin n → ℕ) (P : Tile n) : MeasurableSet (suppBox α P) := by
+  have : suppBox α P = ⋂ i, {ξ : Rn n | |ξ i - P.cω0 α i| < side α (-P.k) i * (b0 / 2)} := by
+    ext ξ; simp [suppBox]
+  rw [this]
+  exact MeasurableSet.iInter fun i => (isOpen_lt (by fun_prop) continuous_const).measurableSet
+
+theorem norm_fhat_wavePhi_le (α : Fin n → ℕ) (P : Tile n) (ξ : Rn n) :
+    ‖fhat (wavePhi α P) ξ‖ ≤ (suppBox α P).indicator
+      (fun _ => ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) ξ := by
+  by_cases hξ : ξ ∈ suppBox α P
+  · rw [Set.indicator_of_mem hξ, fhat_wavePhi, norm_mul, norm_mul, norm_cexp_neg_I_mul, mul_one,
+      Complex.norm_real, Real.norm_eq_abs, abs_of_pos (by positivity)]
+    calc _ ≤ ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * 1 := by
+          gcongr; exact norm_phiHat_le_one _
+      _ = _ := mul_one _
+  · rw [Set.indicator_of_notMem hξ]
+    have : fhat (wavePhi α P) ξ = 0 := by
+      by_contra hne
+      exact hξ fun i => abs_sub_cω0_lt_of_fhat_wavePhi_ne_zero α P hne i
+    rw [this, norm_zero]
+
+/-- One-tile bound: `|⟨g, φ_P⟩| ≤ (2π)^{-n} |I_P|^{1/2} ∫_{S_P} |ĝ|`. -/
+theorem norm_pairing_wavePhi_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {g : Rn n → ℂ}
+    (hg : Integrable g) (hG : Integrable (fhat g)) (P : Tile n) :
+    ‖pairing g (wavePhi α P)‖ ≤ ((2 * π) ^ n)⁻¹ * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) *
+      ∫ ξ in suppBox α P, ‖fhat g ξ‖ := by
+  rw [pairing_eq_fhat hg (continuous_wavePhi α P) (integrable_wavePhi α hα P)
+    (integrable_fhat_wavePhi α P), norm_mul]
+  have h2π : ‖(((2 * π) ^ n)⁻¹ : ℂ)‖ = ((2 * π) ^ n)⁻¹ := by
+    rw [norm_inv, norm_pow, Complex.norm_mul, Complex.norm_ofNat, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos Real.pi_pos]
+  rw [h2π, mul_assoc]
+  gcongr
+  have hmeas := measurableSet_suppBox α P
+  calc ‖∫ ξ, fhat g ξ * (starRingEnd ℂ) (fhat (wavePhi α P) ξ)‖
+      ≤ ∫ ξ, ‖fhat g ξ * (starRingEnd ℂ) (fhat (wavePhi α P) ξ)‖ := norm_integral_le_integral_norm _
+    _ ≤ ∫ ξ, ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * (suppBox α P).indicator (fun ξ => ‖fhat g
+        ξ‖) ξ := by
+        refine integral_mono_of_nonneg (Filter.Eventually.of_forall fun ξ => norm_nonneg _)
+          ((hG.norm.indicator hmeas).const_mul _) (Filter.Eventually.of_forall fun ξ => ?_)
+        dsimp only
+        rw [norm_mul, RCLike.norm_conj]
+        have := norm_fhat_wavePhi_le α P ξ
+        by_cases hξ : ξ ∈ suppBox α P
+        · rw [Set.indicator_of_mem hξ] at this ⊢
+          calc ‖fhat g ξ‖ * ‖fhat (wavePhi α P) ξ‖
+              ≤ ‖fhat g ξ‖ * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := by gcongr
+            _ = _ := mul_comm _ _
+        · rw [Set.indicator_of_notMem hξ] at this ⊢
+          have h0 : ‖fhat (wavePhi α P) ξ‖ = 0 := le_antisymm this (norm_nonneg _)
+          rw [h0, mul_zero, mul_zero]
+    _ = ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ∫ ξ in suppBox α P, ‖fhat g ξ‖ := by
+        rw [integral_const_mul, integral_indicator hmeas]
+
+theorem exists_eq_one_of_ne_zero {r : Fin n → Fin 2} (hr : r ≠ 0) : ∃ j, r j = 1 := by
+  by_contra h
+  push Not at h
+  apply hr
+  funext j
+  apply Fin.ext
+  have h1 := (r j).2
+  have h2 : (r j).val ≠ 1 := fun e => h j (Fin.ext e)
+  simp only [Pi.zero_apply, Fin.val_zero]
+  omega
+
+/-- If `N ∈ ω_{P(r)}` with `r ≠ 0`, then `N` is outside the interior of `ω_{P(0)}` in some
+coordinate (the hypothesis of `psi_estimate`). -/
+theorem exists_far_of_mem_semi (α : Fin n → ℕ) {P : Tile n} {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {N : Rn n} (hN : N ∈ P.semi α r) : ∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j| := by
+  obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+  refine ⟨j, ?_⟩
+  have h := (hN j).1
+  rw [hj] at h
+  simp only [Fin.val_one, Nat.cast_one] at h
+  have hs := side_pos α (-P.k) j
+  simp only [Tile.cω0, PiLp.toLp_apply]
+  rw [le_abs]
+  left
+  nlinarith
+
+theorem side_rpow_inv (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (k : ℤ) (i : Fin n) :
+    side α k i ^ ((α i : ℝ)⁻¹) = (2 : ℝ) ^ k := by
+  have hαi : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+  rw [side, zpow_mul, zpow_natCast, ← Real.rpow_natCast, ← Real.rpow_mul (by positivity),
+    mul_inv_cancel₀ hαi, Real.rpow_one]
+
+/-- For `N ∈ ω_{P(r)}`, `r ≠ 0`, the box `S_P` lies in the anisotropic annulus
+`2^{-k_P}/5 ≤ ρ(ξ - N) ≤ 2^{-k_P}`. -/
+theorem rho_sub_bounds_of_mem_suppBox (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {P : Tile n}
+    {r : Fin n → Fin 2} (hr : r ≠ 0) {N ξ : Rn n} (hN : N ∈ P.semi α r) (hξ : ξ ∈ suppBox α P) :
+    ((2 : ℝ) ^ P.k)⁻¹ / 5 ≤ rho α (ξ - N) ∧ rho α (ξ - N) ≤ ((2 : ℝ) ^ P.k)⁻¹ := by
+  have hkinv : ((2 : ℝ) ^ P.k)⁻¹ = (2 : ℝ) ^ (-P.k) := (zpow_neg _ _).symm
+  constructor
+  · obtain ⟨j, hj⟩ := exists_eq_one_of_ne_zero hr
+    have hNj := (hN j).1
+    rw [hj] at hNj
+    simp only [Fin.val_one, Nat.cast_one] at hNj
+    have hξj := hξ j
+    simp only [Tile.cω0, PiLp.toLp_apply] at hξj
+    rw [abs_lt] at hξj
+    have hs := side_pos α (-P.k) j
+    have h1 : side α (-P.k) j / 5 ≤ |(ξ - N) j| := by
+      simp only [PiLp.sub_apply]
+      rw [abs_sub_comm, le_abs]
+      left
+      norm_num [b0] at hξj
+      nlinarith
+    have hαj : (1 : ℝ) ≤ α j := by exact_mod_cast hα j
+    have hq0 : 0 ≤ (α j : ℝ)⁻¹ := by positivity
+    have hq1 : (α j : ℝ)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hαj
+    calc ((2 : ℝ) ^ P.k)⁻¹ / 5 = (1 / 5) * side α (-P.k) j ^ ((α j : ℝ)⁻¹) := by
+          rw [side_rpow_inv α hα, hkinv]; ring
+      _ ≤ (1 / 5) ^ ((α j : ℝ)⁻¹) * side α (-P.k) j ^ ((α j : ℝ)⁻¹) := by
+          gcongr
+          exact Real.self_le_rpow_of_le_one (by norm_num) (by norm_num) hq1
+      _ = (side α (-P.k) j / 5) ^ ((α j : ℝ)⁻¹) := by
+          rw [← Real.mul_rpow (by norm_num) hs.le]; ring_nf
+      _ ≤ |(ξ - N) j| ^ ((α j : ℝ)⁻¹) := Real.rpow_le_rpow (by positivity) h1 hq0
+      _ ≤ rho α (ξ - N) := abs_coord_rpow_le_rho α _ j
+  · have h : rhoNN α (ξ - N) ≤ Real.toNNReal (((2 : ℝ) ^ P.k)⁻¹) := by
+      rw [rhoNN_le_iff]
+      intro i
+      rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ (by positivity)]
+      simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs]
+      have hs := side_pos α (-P.k) i
+      have hNi := hN i
+      have hξi := hξ i
+      simp only [Tile.cω0, PiLp.toLp_apply] at hξi
+      rw [abs_lt] at hξi
+      have hri : ((r i : ℕ) : ℝ) ≤ 1 := by exact_mod_cast Nat.lt_succ_iff.mp (r i).2
+      have hri0 : (0 : ℝ) ≤ ((r i : ℕ) : ℝ) := Nat.cast_nonneg _
+      have h1 : |(ξ - N) i| ≤ side α (-P.k) i := by
+        simp only [PiLp.sub_apply]
+        rw [abs_le]
+        norm_num [b0] at hξi
+        constructor <;> nlinarith [hNi.1, hNi.2]
+      calc |(ξ - N) i| ^ ((α i : ℝ)⁻¹) ≤ side α (-P.k) i ^ ((α i : ℝ)⁻¹) :=
+            Real.rpow_le_rpow (abs_nonneg _) h1 (by positivity)
+        _ = ((2 : ℝ) ^ P.k)⁻¹ := by rw [side_rpow_inv α hα, hkinv]
+    have := NNReal.coe_le_coe.mpr h
+    rwa [Real.coe_toNNReal _ (by positivity)] at this
+
+/-- At most four dyadic scales `2^{-k}` lie in `[t, 5t]`. -/
+theorem scales_subset_Icc {t : ℝ} (ht : 0 < t) {k : ℤ} (h1 : ((2 : ℝ) ^ k)⁻¹ / 5 ≤ t)
+    (h2 : t ≤ ((2 : ℝ) ^ k)⁻¹) :
+    k ∈ Finset.Icc (-(Int.log 2 t) - 3) (-(Int.log 2 t)) := by
+  set L := Int.log 2 t
+  have hL1 : (2 : ℝ) ^ L ≤ t := Int.zpow_log_le_self (by norm_num) ht
+  have hL2 : t < (2 : ℝ) ^ (L + 1) := Int.lt_zpow_succ_log_self (by norm_num) t
+  rw [← zpow_neg] at h1 h2
+  have ha : L ≤ -k := by
+    by_contra hc
+    push Not at hc
+    have : (2 : ℝ) ^ (-k) < (2 : ℝ) ^ L := zpow_lt_zpow_right₀ (by norm_num) hc
+    linarith
+  have hb : -k < L + 4 := by
+    by_contra hc
+    push Not at hc
+    have : (2 : ℝ) ^ (L + 4) ≤ (2 : ℝ) ^ (-k) := zpow_le_zpow_right₀ (by norm_num) hc
+    have h16 : (2 : ℝ) ^ (L + 4) = 8 * (2 : ℝ) ^ (L + 1) := by
+      rw [show L + 4 = (L + 1) + 3 by ring, zpow_add₀ (by norm_num)]
+      norm_num
+      ring
+    have hpos : (0 : ℝ) < (2 : ℝ) ^ (L + 1) := by positivity
+    linarith
+  rw [Finset.mem_Icc]
+  omega
+
+/-- Reindexing tiles by (scale, frequency position, spatial position). -/
+def tileEquiv : Tile n ≃ ℤ × (Fin n → ℤ) × (Fin n → ℤ) where
+  toFun P := (P.k, P.u, P.ℓ)
+  invFun t := ⟨t.1, t.2.2, t.2.1⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+/-- The frequency position at scale `k` of the dyadic cube containing `ξ`. -/
+def freqPos (α : Fin n → ℕ) (k : ℤ) (ξ : Rn n) : Fin n → ℤ := fun i => ⌊ξ i / side α (-k) i⌋
+
+theorem u_eq_freqPos_of_mem_suppBox (α : Fin n → ℕ) {P : Tile n} {ξ : Rn n}
+    (hξ : ξ ∈ suppBox α P) : P.u = freqPos α P.k ξ := by
+  funext i
+  have hs := side_pos α (-P.k) i
+  have hξi := hξ i
+  simp only [Tile.cω0, PiLp.toLp_apply] at hξi
+  rw [abs_lt] at hξi
+  norm_num [b0] at hξi
+  simp only [freqPos]
+  symm
+  rw [Int.floor_eq_iff, le_div_iff₀ hs, div_lt_iff₀ hs]
+  constructor <;> nlinarith
+
+/-- The half-integer shift `(1/2, …, 1/2)`. -/
+def halfVec (n : ℕ) : Rn n := WithLp.toLp 2 (fun _ => (1 / 2 : ℝ))
+
+theorem one_add_rho_cI_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P : Tile n) (x : Rn n) :
+    1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) =
+      1 + rho α (dil α ((2 : ℝ) ^ P.k)⁻¹ x - halfVec n - latticePt P.ℓ) := by
+  rw [one_add_inv_mul_rho_eq α hα (by positivity)]
+  congr 2
+  ext i
+  simp only [dil_apply, PiLp.sub_apply, Tile.cI, halfVec, latticePt_apply]
+  have hs : ((2 : ℝ) ^ P.k)⁻¹ ^ α i * side α P.k i = 1 := by
+    rw [side, zpow_mul, zpow_natCast, inv_pow, inv_mul_cancel₀ (by positivity)]
+  have : ((2 : ℝ) ^ P.k)⁻¹ ^ α i * (x i - side α P.k i * (P.ℓ i + 1 / 2)) =
+      ((2 : ℝ) ^ P.k)⁻¹ ^ α i * x i -
+        (((2 : ℝ) ^ P.k)⁻¹ ^ α i * side α P.k i) * (P.ℓ i + 1 / 2) := by
+    ring
+  rw [this, hs]
+  ring
+
+/-- Bounded overlap: for `r ≠ 0` and fixed `N, ξ`, at most four pairs `(k, u)` have
+`N ∈ ω_{P(r)}` and `ξ ∈ S_P` (with `P = (k, ·, u)`). -/
+theorem tsum_ind_suppBox_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (N ξ : Rn n) :
+    ∑' k : ℤ, ∑' u : Fin n → ℤ,
+      ((⟨k, 0, u⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℝ≥0∞)) N *
+        (suppBox α ⟨k, 0, u⟩).indicator (fun _ => (1 : ℝ≥0∞)) ξ ≤ 4 := by
+  set K : Finset ℤ :=
+    Finset.Icc (-(Int.log 2 (rho α (ξ - N))) - 3) (-(Int.log 2 (rho α (ξ - N))))
+  have hle : ∀ (k : ℤ) (u : Fin n → ℤ),
+      ((⟨k, 0, u⟩ : Tile n).semi α r).indicator (fun _ => (1 : ℝ≥0∞)) N *
+        (suppBox α ⟨k, 0, u⟩).indicator (fun _ => (1 : ℝ≥0∞)) ξ ≤
+        if k ∈ K then (if u = freqPos α k ξ then 1 else 0) else 0 := by
+    intro k u
+    by_cases hNP : N ∈ (⟨k, 0, u⟩ : Tile n).semi α r
+    · by_cases hξ : ξ ∈ suppBox α ⟨k, 0, u⟩
+      · have hb := rho_sub_bounds_of_mem_suppBox α hα hr hNP hξ
+        have ht0 : 0 < rho α (ξ - N) := lt_of_lt_of_le (by positivity) hb.1
+        have hk : k ∈ K := scales_subset_Icc ht0 hb.1 hb.2
+        have hu : u = freqPos α k ξ := u_eq_freqPos_of_mem_suppBox α hξ
+        rw [Set.indicator_of_mem hNP, Set.indicator_of_mem hξ]
+        simp [hk, hu]
+      · simp [Set.indicator_of_notMem hξ]
+    · simp [Set.indicator_of_notMem hNP]
+  calc _ ≤ ∑' k : ℤ, ∑' u : Fin n → ℤ,
+        (if k ∈ K then (if u = freqPos α k ξ then (1 : ℝ≥0∞) else 0) else 0) :=
+        ENNReal.tsum_le_tsum fun k => ENNReal.tsum_le_tsum fun u => hle k u
+    _ = ∑' k : ℤ, (if k ∈ K then (1 : ℝ≥0∞) else 0) := by
+        congr 1
+        ext k
+        split_ifs with hk
+        · exact tsum_ite_eq (freqPos α k ξ) 1
+        · simp
+    _ = ∑ k ∈ K, (1 : ℝ≥0∞) := by
+        rw [tsum_eq_sum (s := K) fun k hk => by simp [hk]]
+        exact Finset.sum_congr rfl fun k hk => by simp [hk]
+    _ ≤ 4 := by
+        simp only [Finset.sum_const, nsmul_eq_mul, mul_one, K, Int.card_Icc]
+        norm_cast
+        omega
+
+/-- Convergence of the model sum (paper, §3, (3.3)), with a uniform bound: for `r ≠ 0`,
+`∑_P |⟨g, φ_P⟩ ψ^N_P(x) 1_{ω_{P(r)}}(N)| ≤ C ‖m‖_{𝓜^{|α|+1}} ‖ĝ‖₁`, uniformly in `N` and `x`. -/
+theorem tsum_enorm_modelTerm_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (absA α + 1) m → ∀ (g : Rn n → ℂ),
+      Integrable g → Integrable (fhat g) → ∀ N x : Rn n,
+      ∑' P : Tile n, ‖pairing g (wavePhi α P) * wavePsi α m N P x *
+        (P.semi α r).indicator (fun _ => (1 : ℂ)) N‖ₑ ≤
+      ENNReal.ofReal (C * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat g ξ‖) := by
+  set ν1 : ℕ := absA α + 1
+  set s : ℝ := (ν1 : ℝ)
+  have hs : (absA α : ℝ) < s := by simp [s, ν1]
+  set C1 : ℝ := (psiConst α ν1 : ℝ)
+  set Lc : ℝ := 2 ^ s * ∫ w : Rn n, (1 + rho α w) ^ (-s)
+  have hLc : 0 ≤ Lc := by
+    have : 0 ≤ ∫ w : Rn n, (1 + rho α w) ^ (-s) := integral_nonneg fun w => by
+      have := rho_nonneg α w; positivity
+    positivity
+  set c0 : ℝ := ((2 * π) ^ n)⁻¹ * C1
+  have hc0 : 0 ≤ c0 := by have := NNReal.coe_nonneg (psiConst α ν1); positivity
+  refine ⟨4 * c0 * Lc, by positivity, fun m hm g hg hG N x => ?_⟩
+  set M := (normM α ν1 m).toReal
+  have hM : 0 ≤ M := ENNReal.toReal_nonneg
+  set F : Rn n → ℝ := fun ξ => ‖fhat g ξ‖
+  set ind : Tile n → ℝ := fun P => (P.semi α r).indicator (fun _ => (1 : ℝ)) N
+  set I : Tile n → ℝ := fun P => ∫ ξ in suppBox α P, F ξ
+  set w : Tile n → ℝ := fun P => (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-s)
+  have hI : ∀ P, 0 ≤ I P := fun P => setIntegral_nonneg (measurableSet_suppBox α P)
+    fun ξ _ => norm_nonneg _
+  have hind : ∀ P, 0 ≤ ind P := fun P => Set.indicator_nonneg (fun _ _ => zero_le_one) _
+  have hw : ∀ P, 0 ≤ w P := fun P => by have := rho_nonneg α (x - P.cI α); positivity
+  -- Step 1: per-tile bound
+  have hterm : ∀ P : Tile n, ‖pairing g (wavePhi α P) * wavePsi α m N P x *
+      (P.semi α r).indicator (fun _ => (1 : ℂ)) N‖ₑ ≤
+      ENNReal.ofReal (c0 * M * I P * ind P) * ENNReal.ofReal (w P) := by
+    intro P
+    rw [← ENNReal.ofReal_mul (by have := hI P; have := hind P; positivity)]
+    by_cases hNP : N ∈ P.semi α r
+    · rw [Set.indicator_of_mem hNP, mul_one, ← ofReal_norm, norm_mul]
+      apply ENNReal.ofReal_le_ofReal
+      have h1 := norm_pairing_wavePhi_le α hα hg hG P
+      have h2 := psi_estimate_real α hα ν1 hm P N (exists_far_of_mem_semi α hr hNP) x
+      simp only [ind, Set.indicator_of_mem hNP, mul_one]
+      set t := (2 : ℝ) ^ P.k
+      have ht : 0 < t := by positivity
+      have htt : t ^ ((absA α : ℝ) / 2) * t ^ (-(absA α : ℝ) / 2) = 1 := by
+        rw [← Real.rpow_add ht]; ring_nf; exact Real.rpow_zero _
+      calc ‖pairing g (wavePhi α P)‖ * ‖wavePsi α m N P x‖
+          ≤ (((2 * π) ^ n)⁻¹ * t ^ ((absA α : ℝ) / 2) * I P) *
+            (C1 * M * t ^ (-(absA α : ℝ) / 2) * w P) :=
+            mul_le_mul h1 h2 (norm_nonneg _) (by have := hI P; positivity)
+        _ = c0 * M * I P * w P * (t ^ ((absA α : ℝ) / 2) * t ^ (-(absA α : ℝ) / 2)) := by
+            simp only [c0]; ring
+        _ = c0 * M * I P * w P := by rw [htt, mul_one]
+    · rw [Set.indicator_of_notMem hNP, mul_zero, enorm_zero]
+      exact bot_le
+  -- Step 2: the lattice sum in `ℓ`
+  have hlat : ∀ (k : ℤ) (u : Fin n → ℤ),
+      ∑' ℓ : Fin n → ℤ, ENNReal.ofReal (w ⟨k, ℓ, u⟩) ≤ ENNReal.ofReal Lc := by
+    intro k u
+    have := tsum_wgt_lattice_le α hα hs (dil α ((2 : ℝ) ^ k)⁻¹ x - halfVec n)
+    refine le_trans (le_of_eq ?_) this
+    congr 1
+    ext ℓ
+    simp only [w]
+    rw [one_add_rho_cI_eq α hα ⟨k, ℓ, u⟩ x]
+  -- Step 3: bounded overlap of the boxes `S_P`
+  have hcount : ∀ ξ : Rn n, ∑' k : ℤ, ∑' u : Fin n → ℤ,
+      ENNReal.ofReal (ind ⟨k, 0, u⟩) *
+        (suppBox α ⟨k, 0, u⟩).indicator (fun _ => (1 : ℝ≥0∞)) ξ ≤ 4 := by
+    intro ξ
+    have hindENN (P : Tile n) : ENNReal.ofReal (ind P) =
+        (P.semi α r).indicator (fun _ => (1 : ℝ≥0∞)) N := by
+      by_cases hNP : N ∈ P.semi α r
+      · simp only [ind, Set.indicator_of_mem hNP, ENNReal.ofReal_one]
+      · simp only [ind, Set.indicator_of_notMem hNP, ENNReal.ofReal_zero]
+    simpa only [hindENN] using tsum_ind_suppBox_le α hα hr N ξ
+  -- Step 4: assemble
+  have hFint : Integrable F := hG.norm
+  have hFmeas : AEMeasurable (fun ξ => ENNReal.ofReal (F ξ)) := hFint.aemeasurable.ennreal_ofReal
+  calc ∑' P : Tile n, ‖pairing g (wavePhi α P) * wavePsi α m N P x *
+        (P.semi α r).indicator (fun _ => (1 : ℂ)) N‖ₑ
+      ≤ ∑' P : Tile n, ENNReal.ofReal (c0 * M * I P * ind P) * ENNReal.ofReal (w P) :=
+        ENNReal.tsum_le_tsum hterm
+    _ = ∑' k : ℤ, ∑' u : Fin n → ℤ, ∑' ℓ : Fin n → ℤ,
+          ENNReal.ofReal (c0 * M * I ⟨k, 0, u⟩ * ind ⟨k, 0, u⟩) *
+            ENNReal.ofReal (w ⟨k, ℓ, u⟩) := by
+        rw [← tileEquiv.symm.tsum_eq, ENNReal.tsum_prod', tsum_congr fun k =>
+          ENNReal.tsum_prod']
+        rfl
+    _ = ∑' k : ℤ, ∑' u : Fin n → ℤ, ENNReal.ofReal (c0 * M * I ⟨k, 0, u⟩ * ind ⟨k, 0, u⟩) *
+          ∑' ℓ : Fin n → ℤ, ENNReal.ofReal (w ⟨k, ℓ, u⟩) := by
+        congr 1; ext k; congr 1; ext u
+        rw [ENNReal.tsum_mul_left]
+    _ ≤ ∑' k : ℤ, ∑' u : Fin n → ℤ, ENNReal.ofReal (c0 * M * I ⟨k, 0, u⟩ * ind ⟨k, 0, u⟩) *
+          ENNReal.ofReal Lc :=
+        ENNReal.tsum_le_tsum fun k => ENNReal.tsum_le_tsum fun u => by gcongr; exact hlat k u
+    _ = ENNReal.ofReal (c0 * M * Lc) * ∑' k : ℤ, ∑' u : Fin n → ℤ,
+          ENNReal.ofReal (ind ⟨k, 0, u⟩) * ∫⁻ ξ, (suppBox α ⟨k, 0, u⟩).indicator
+            (fun ξ => ENNReal.ofReal (F ξ)) ξ := by
+        rw [← ENNReal.tsum_mul_left]
+        congr 1; ext k
+        rw [← ENNReal.tsum_mul_left]
+        congr 1; ext u
+        rw [lintegral_indicator (measurableSet_suppBox α _),
+          ← ofReal_integral_eq_lintegral_ofReal hFint.integrableOn
+            (Filter.Eventually.of_forall fun ξ => norm_nonneg _)]
+        have h1 := hI ⟨k, 0, u⟩
+        have h2 := hind ⟨k, 0, u⟩
+        rw [← ENNReal.ofReal_mul h2, ← ENNReal.ofReal_mul (by positivity : 0 ≤ c0 * M * Lc),
+          ← ENNReal.ofReal_mul (by positivity : 0 ≤ c0 * M * I ⟨k, 0, u⟩ * ind ⟨k, 0, u⟩)]
+        congr 1
+        simp only [I]
+        ring
+    _ = ENNReal.ofReal (c0 * M * Lc) * ∫⁻ ξ, (∑' k : ℤ, ∑' u : Fin n → ℤ,
+          ENNReal.ofReal (ind ⟨k, 0, u⟩) *
+            (suppBox α ⟨k, 0, u⟩).indicator (fun _ => (1 : ℝ≥0∞)) ξ) * ENNReal.ofReal (F ξ) := by
+        congr 1
+        simp_rw [← ENNReal.tsum_mul_right]
+        rw [lintegral_tsum fun k => ?_]
+        · congr 1; ext k
+          rw [lintegral_tsum fun u => ?_]
+          · congr 1; ext u
+            rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+            congr 1; ext ξ
+            by_cases hξ : ξ ∈ suppBox α ⟨k, 0, u⟩
+            · simp [Set.indicator_of_mem hξ]
+            · simp [Set.indicator_of_notMem hξ]
+          · exact ((aemeasurable_const.indicator (measurableSet_suppBox α _)).const_mul _).mul
+              hFmeas
+        · exact (AEMeasurable.tsum fun u =>
+            ((aemeasurable_const.indicator (measurableSet_suppBox α _)).const_mul _).mul hFmeas)
+    _ ≤ ENNReal.ofReal (c0 * M * Lc) * ∫⁻ ξ, 4 * ENNReal.ofReal (F ξ) := by
+        gcongr with ξ
+        exact hcount ξ
+    _ = ENNReal.ofReal (4 * c0 * Lc * M * ∫ ξ, F ξ) := by
+        rw [lintegral_const_mul' _ _ (by simp),
+          ← ofReal_integral_eq_lintegral_ofReal hFint
+            (Filter.Eventually.of_forall fun ξ => norm_nonneg _),
+          show (4 : ℝ≥0∞) = ENNReal.ofReal 4 by simp, ← ENNReal.ofReal_mul (by norm_num),
+          ← ENNReal.ofReal_mul (by positivity)]
+        congr 1
+        ring
+    _ = _ := by simp only [F]
+
+/-- A finite real bound for the sum of extended norms gives absolute convergence and a sum bound. -/
+theorem summable_and_norm_tsum_le_of_enorm_sum_le {ι E : Type*} [NormedAddCommGroup E]
+    [CompleteSpace E] {f : ι → E} {C : ℝ} (hC : 0 ≤ C)
+    (hb : ∑' i, ‖f i‖ₑ ≤ ENNReal.ofReal C) : Summable f ∧ ‖∑' i, f i‖ ≤ C := by
+  have hfin := ne_top_of_le_ne_top ENNReal.ofReal_ne_top hb
+  refine ⟨(tsum_enorm_ne_top_iff_summable_norm.mp hfin).of_norm, ?_⟩
+  exact (ENNReal.ofReal_le_ofReal_iff hC).mp
+    (by simpa only [ofReal_norm] using enorm_tsum_le_tsum_enorm.trans hb)
+
+/-- The model sum converges absolutely and is uniformly bounded (paper, §3, (3.3)):
+for `r ≠ 0`, integrable `g` with integrable `ĝ`, the series defining `A^{r,m}_N g(x)` is
+summable and `|A^{r,m}_N g(x)| ≤ C ‖m‖_{𝓜^{|α|+1}} ‖ĝ‖₁`. -/
+theorem modelOp_summable_bound (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (absA α + 1) m → ∀ (g : Rn n → ℂ),
+      Integrable g → Integrable (fhat g) → ∀ N x : Rn n,
+      Summable (fun P : Tile n => pairing g (wavePhi α P) * wavePsi α m N P x *
+        (P.semi α r).indicator (fun _ => (1 : ℂ)) N) ∧
+      ‖modelOp α r m N g x‖ ≤ C * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat g ξ‖ := by
+  obtain ⟨C, hC, h⟩ := tsum_enorm_modelTerm_le α hα hr
+  refine ⟨C, hC, fun m hm g hg hG N x => ?_⟩
+  exact summable_and_norm_tsum_le_of_enorm_sum_le
+    (mul_nonneg (mul_nonneg hC ENNReal.toReal_nonneg) (integral_nonneg fun ξ => norm_nonneg _))
+    (h m hm g hg hG N x)
+
+theorem integrable_fhat_schwartz (f : 𝓢(Rn n, ℂ)) : Integrable (fhat (f : Rn n → ℂ)) := by
+  apply integrable_fhat_of_fourier
+  rw [← SchwartzMap.fourier_coe]
+  exact SchwartzMap.integrable _
+
+/-- Change of variables under dilations for `lintegral`: `∫⁻ g(δ_t v) dv = t^{-|α|} ∫⁻ g`. -/
+theorem lintegral_comp_dil (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (g : Rn n → ℝ≥0∞) :
+    ∫⁻ v, g (dil α t v) = ENNReal.ofReal ((t ^ absA α)⁻¹) * ∫⁻ v, g v := by
+  rw [← (dil_measurableEmbedding α ht).lintegral_map, map_dil_volume α ht, lintegral_smul_measure,
+    smul_eq_mul]
+
+/-! ## Section 4: reduction of Theorem 3.2 to the key estimate (4.1) -/
+
+/-- Joint continuity of `(N, x) ↦ ψ^N_P(x)` (used for measurability of the linearized
+operator, paper §4, texline~287). -/
+theorem continuous_wavePsi_joint (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (P : Tile n) : Continuous fun p : Rn n × Rn n => wavePsi α m p.1 P p.2 := by
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  rcases Nat.eq_zero_or_pos n with hn | hn
+  · subst hn
+    have : (fun p : Rn 0 × Rn 0 => wavePsi α m p.1 P p.2) = fun _ => wavePsi α m 0 P 0 := by
+      funext p; rw [Subsingleton.elim p.1 0, Subsingleton.elim p.2 0]
+    rw [this]; exact continuous_const
+  have : Nontrivial (Rn n) := ⟨⟨EuclideanSpace.single ⟨0, hn⟩ 1, 0, fun h => by
+    have := congrArg (fun v : Rn n => v ⟨0, hn⟩) h; simp at this⟩⟩
+  rw [continuous_iff_continuousAt]
+  intro p₀
+  unfold wavePsi
+  refine continuousAt_const.mul ?_
+  refine continuousAt_of_dominated (bound := fun ξ => Cm * ‖fhat (wavePhi α P) ξ‖) ?_ ?_ ?_ ?_
+  · refine Filter.Eventually.of_forall fun p => ?_
+    exact ((hm.measurable.comp (measurable_id.sub_const _)).aestronglyMeasurable.mul
+      (integrable_fhat_wavePhi α P).aestronglyMeasurable).mul
+      (by fun_prop : Continuous fun ξ : Rn n =>
+        Complex.exp (Complex.I * (⟪p.2, ξ⟫_ℝ : ℂ))).aestronglyMeasurable
+  · refine Filter.Eventually.of_forall fun p => Filter.Eventually.of_forall fun ξ => ?_
+    rw [norm_mul, norm_mul, norm_cexp_I_mul, mul_one]
+    exact mul_le_mul_of_nonneg_right (hmb _) (norm_nonneg _)
+  · exact (integrable_fhat_wavePhi α P).norm.const_mul Cm
+  · -- continuity at `p₀` for all `ξ ≠ N₀`
+    have hae : ∀ᵐ ξ : Rn n, ξ ≠ p₀.1 := by
+      rw [ae_iff]; simp
+    filter_upwards [hae] with ξ hξ
+    have hm' : ContinuousAt (fun p : Rn n × Rn n => m (ξ - p.1)) p₀ := by
+      have hne : ξ - p₀.1 ≠ 0 := sub_ne_zero.mpr hξ
+      have h1 : ContinuousAt m (ξ - p₀.1) :=
+        hm.contDiffOn.continuousOn.continuousAt (isOpen_compl_singleton.mem_nhds hne)
+      have h2 : ContinuousAt (fun p : Rn n × Rn n => ξ - p.1) p₀ := by fun_prop
+      exact ContinuousAt.comp (g := m) h1 h2
+    exact (hm'.mul continuousAt_const).mul (by fun_prop)
+
+instance : Countable (Tile n) := (tileEquiv (n := n)).injective.countable
+
+/-- The half-open semi-tile `[δ_{2^{-k_P}}(u + r/2), δ_{2^{-k_P}}(u + (r+1)/2))`. The model operator
+and the key estimate are formulated with half-open semi-tiles, so that `ω_{P(r)} ⊆ ω_P` and
+semi-tiles of the same scale are disjoint. -/
+def Tile.semiHO (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) : Set (Rn n) :=
+  {ξ | ∀ i, side α (-P.k) i * (P.u i + (r i : ℝ) / 2) ≤ ξ i ∧
+    ξ i < side α (-P.k) i * (P.u i + ((r i : ℝ) + 1) / 2)}
+
+theorem Tile.semiHO_subset_semi (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) :
+    P.semiHO α r ⊆ P.semi α r := fun _ hξ i => ⟨(hξ i).1, (hξ i).2.le⟩
+
+theorem Tile.semiHO_subset_ω (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) :
+    P.semiHO α r ⊆ P.ω.toSet α := by
+  intro ξ hξ i
+  have hs := side_pos α (-P.k) i
+  have hr0 : (0 : ℝ) ≤ (r i : ℝ) := Nat.cast_nonneg _
+  have hr1 : (r i : ℝ) ≤ 1 := by exact_mod_cast Nat.le_of_lt_succ (r i).isLt
+  simp only [Tile.ω]
+  constructor
+  · nlinarith [(hξ i).1]
+  · nlinarith [(hξ i).2]
+
+theorem measurableSet_semiHO (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) :
+    MeasurableSet (P.semiHO α r) := by
+  have : P.semiHO α r = ⋂ i, {ξ : Rn n | side α (-P.k) i * (P.u i + (r i : ℝ) / 2) ≤ ξ i ∧
+      ξ i < side α (-P.k) i * (P.u i + ((r i : ℝ) + 1) / 2)} := by
+    ext ξ; simp only [Set.mem_iInter]; exact Iff.rfl
+  rw [this]
+  refine MeasurableSet.iInter fun i => ?_
+  have hc : Measurable fun ξ : Rn n => ξ i :=
+    ((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)).measurable
+  exact (measurableSet_le measurable_const hc).inter (measurableSet_lt hc measurable_const)
+
+/-- The model sum operator with half-open semi-tiles,
+`A^{r,m}_N f(x) = ∑_P ⟨f, φ_P⟩ ψ^N_P(x) 1_{ω_{P(r)}}(N)`. -/
+def modelOpHO (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (N : Rn n) (f : Rn n → ℂ)
+    (x : Rn n) : ℂ :=
+  ∑' P : Tile n, pairing f (wavePhi α P) * wavePsi α m N P x *
+    (P.semiHO α r).indicator (fun _ => (1 : ℂ)) N
+
+theorem enorm_indicator_semiHO_le (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) (N : Rn n)
+    (z : ℂ) : ‖z * (P.semiHO α r).indicator (fun _ => (1 : ℂ)) N‖ₑ ≤
+      ‖z * (P.semi α r).indicator (fun _ => (1 : ℂ)) N‖ₑ := by
+  by_cases h : N ∈ P.semiHO α r
+  · rw [Set.indicator_of_mem h, Set.indicator_of_mem (P.semiHO_subset_semi α r h)]
+  · rw [Set.indicator_of_notMem h]; simp
+
+theorem tsum_enorm_modelTermHO_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (absA α + 1) m → ∀ (g : Rn n → ℂ),
+      Integrable g → Integrable (fhat g) → ∀ N x : Rn n,
+      ∑' P : Tile n, ‖pairing g (wavePhi α P) * wavePsi α m N P x *
+        (P.semiHO α r).indicator (fun _ => (1 : ℂ)) N‖ₑ ≤
+      ENNReal.ofReal (C * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat g ξ‖) := by
+  obtain ⟨C, hC, h⟩ := tsum_enorm_modelTerm_le α hα hr
+  exact ⟨C, hC, fun m hm g hg hG N x => (ENNReal.tsum_le_tsum fun P =>
+    enorm_indicator_semiHO_le α P r N _).trans (h m hm g hg hG N x)⟩
+
+theorem modelOpHO_summable_bound (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (absA α + 1) m → ∀ (g : Rn n → ℂ),
+      Integrable g → Integrable (fhat g) → ∀ N x : Rn n,
+      Summable (fun P : Tile n => pairing g (wavePhi α P) * wavePsi α m N P x *
+        (P.semiHO α r).indicator (fun _ => (1 : ℂ)) N) ∧
+      ‖modelOpHO α r m N g x‖ ≤ C * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat g ξ‖ := by
+  obtain ⟨C, hC, h⟩ := tsum_enorm_modelTermHO_le α hα hr
+  refine ⟨C, hC, fun m hm g hg hG N x => ?_⟩
+  exact summable_and_norm_tsum_le_of_enorm_sum_le
+    (mul_nonneg (mul_nonneg hC ENNReal.toReal_nonneg) (integral_nonneg fun ξ => norm_nonneg _))
+    (h m hm g hg hG N x)
+
+/-- The dual pairing `∫_{E ∩ N⁻¹(ω_{P(r)})} ψ^{N(x)}_P(x) σ(x) dx` appearing in (4.1) (with a
+unimodular weight `σ`; the paper has `σ = 1`). -/
+def dualTerm (α : Fin n → ℕ) (m : Rn n → ℂ) (r : Fin n → Fin 2) (N : Rn n → Rn n)
+    (E : Set (Rn n)) (σ : Rn n → ℂ) (P : Tile n) : ℂ :=
+  ∫ x in E ∩ N ⁻¹' (P.semiHO α r), wavePsi α m (N x) P x * σ x
+
+/-- The key estimate (4.1) in the normalized form proved in Sections 4–7: for every `f ∈ L²`,
+measurable `N`, measurable `E` of finite measure, measurable `σ` with `|σ| ≤ 1` and every finite
+set of tiles `𝒫`,
+`∑_{P ∈ 𝒫} |⟨f, φ_P⟩| |∫_{E ∩ N⁻¹(ω_{P(r)})} ψ^{N(x)}_P(x) σ(x) dx| ≤ K (|E| + ‖f‖₂²)`. -/
+def KeyEstimate (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (K : ℝ) : Prop :=
+  ∀ (f : Rn n → ℂ), MemLp f 2 → ∀ (N : Rn n → Rn n), Measurable N →
+    ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+    ∀ (σ : Rn n → ℂ), Measurable σ → (∀ x, ‖σ x‖ ≤ 1) → ∀ (S : Finset (Tile n)),
+      ∑ P ∈ S, ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ ≤
+        K * ((volume E).toReal + (eLpNorm f 2).toReal ^ 2)
+
+theorem pairing_smul (c : ℂ) (f g : Rn n → ℂ) : pairing (c • f) g = c * pairing f g := by
+  unfold pairing
+  rw [← integral_const_mul]
+  congr 1; ext x
+  simp [mul_assoc]
+
+theorem measurable_semi_indicator (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) :
+    MeasurableSet (P.semi α r) := by
+  have : P.semi α r = ⋂ i, {ξ : Rn n | side α (-P.k) i * (P.u i + ((r i : ℕ) : ℝ) / 2) ≤ ξ i ∧
+      ξ i ≤ side α (-P.k) i * (P.u i + (((r i : ℕ) : ℝ) + 1) / 2)} := by
+    ext ξ; simp [Tile.semi]
+  rw [this]
+  refine MeasurableSet.iInter fun i => ?_
+  have hc : Measurable fun ξ : Rn n => ξ i :=
+    ((continuous_apply i).comp (PiLp.continuous_ofLp 2 _)).measurable
+  exact (measurableSet_le measurable_const hc).inter (measurableSet_le hc measurable_const)
+
+/-- The linearized model operator `T g(x) = A^{r,m}_{N(x)} g(x)` (paper, §4, texline~287). -/
+def Tlin (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (N : Rn n → Rn n) (g : Rn n → ℂ)
+    (x : Rn n) : ℂ :=
+  modelOpHO α r m (N x) g x
+
+/-- The terms of the linearized model sum. -/
+def TlinTerm (α : Fin n → ℕ) (r : Fin n → Fin 2) (m : Rn n → ℂ) (N : Rn n → Rn n)
+    (g : Rn n → ℂ) (P : Tile n) (x : Rn n) : ℂ :=
+  pairing g (wavePhi α P) * wavePsi α m (N x) P x * (P.semiHO α r).indicator (fun _ => (1 : ℂ))
+      (N x)
+
+theorem measurable_TlinTerm (α : Fin n → ℕ) (r : Fin n → Fin 2) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {N : Rn n → Rn n} (hN : Measurable N) (g : Rn n → ℂ) (P : Tile n) :
+    Measurable (TlinTerm α r m N g P) := by
+  unfold TlinTerm
+  refine (measurable_const.mul ((continuous_wavePsi_joint α hm P).measurable.comp
+    (hN.prodMk measurable_id))).mul ?_
+  exact (measurable_const.indicator (measurableSet_semiHO α P r)).comp hN
+
+/-- Interchange of `∫_E` and the tile sum (paper, §4, texline~291–299). -/
+theorem integral_Tlin_mul_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (g : 𝓢(Rn n, ℂ)) {N : Rn n → Rn n}
+    (hN : Measurable N) {E : Set (Rn n)} (hE : MeasurableSet E) (hEfin : volume E < ⊤)
+    {σ : Rn n → ℂ} (hσ : Measurable σ) (hσb : ∀ x, ‖σ x‖ ≤ 1) :
+    HasSum (fun P => pairing g (wavePhi α P) * dualTerm α m r N E σ P)
+      (∫ x in E, Tlin α r m N g x * σ x) := by
+  obtain ⟨C, hC, hb⟩ := tsum_enorm_modelTermHO_le α hα hr
+  set B : ℝ := C * (normM α (absA α + 1) m).toReal * ∫ ξ, ‖fhat (g : Rn n → ℂ) ξ‖
+  have hB : 0 ≤ B := by
+    have : 0 ≤ ∫ ξ, ‖fhat (g : Rn n → ℂ) ξ‖ := integral_nonneg fun ξ => norm_nonneg _
+    have : 0 ≤ (normM α (absA α + 1) m).toReal := ENNReal.toReal_nonneg
+    positivity
+  set h : Tile n → Rn n → ℂ := fun P x => TlinTerm α r m N g P x * σ x
+  have hmeas : ∀ P, AEStronglyMeasurable (h P) (volume.restrict E) := fun P =>
+    ((measurable_TlinTerm α r hm hN g P).mul hσ).aestronglyMeasurable
+  have hpt : ∀ x, ∑' P, ‖h P x‖ₑ ≤ ENNReal.ofReal B := by
+    intro x
+    calc ∑' P, ‖h P x‖ₑ ≤ ∑' P, ‖TlinTerm α r m N g P x‖ₑ := by
+          refine ENNReal.tsum_le_tsum fun P => ?_
+          simp only [h, enorm_mul]
+          calc ‖TlinTerm α r m N g P x‖ₑ * ‖σ x‖ₑ ≤ ‖TlinTerm α r m N g P x‖ₑ * 1 := by
+                gcongr
+                rw [← ofReal_norm]
+                exact ENNReal.ofReal_le_one.mpr (hσb x)
+            _ = _ := mul_one _
+      _ ≤ ENNReal.ofReal B := hb m hm g (SchwartzMap.integrable g)
+          (integrable_fhat_schwartz g) (N x) x
+  have hfin : ∑' P, ∫⁻ x in E, ‖h P x‖ₑ ≠ ⊤ := by
+    rw [← lintegral_tsum fun P => (hmeas P).enorm]
+    refine ne_top_of_le_ne_top (b := ∫⁻ _ in E, ENNReal.ofReal B) ?_ (lintegral_mono hpt)
+    rw [setLIntegral_const]
+    exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top hEfin.ne
+  have hsum := hasSum_integral_of_summable_integral_norm (μ := volume.restrict E)
+    (F := h) (fun P => ?_) ?_
+  · have hTlin : ∀ x, Tlin α r m N g x * σ x = ∑' P, h P x := by
+      intro x
+      simp only [h, Tlin, modelOpHO, TlinTerm]
+      rw [tsum_mul_right]
+    simp_rw [hTlin]
+    refine hsum.congr_fun fun P => ?_
+    simp only [h, TlinTerm, dualTerm]
+    rw [← integral_const_mul, ← setIntegral_indicator (hN (measurableSet_semiHO α P r))]
+    refine setIntegral_congr_fun hE fun x hx => ?_
+    by_cases hNx : N x ∈ P.semiHO α r
+    · rw [Set.indicator_of_mem (show x ∈ N ⁻¹' P.semiHO α r from hNx), Set.indicator_of_mem hNx]
+      ring
+    · rw [Set.indicator_of_notMem (show x ∉ N ⁻¹' P.semiHO α r from hNx),
+        Set.indicator_of_notMem hNx]
+      ring
+  · -- integrability of each term
+    refine Integrable.mono' (g := fun _ => B) ?_ (hmeas P) (Filter.Eventually.of_forall fun x => ?_)
+    · exact integrableOn_const hEfin.ne enorm_ne_top
+    · have := hpt x
+      have h1 : ‖h P x‖ₑ ≤ ENNReal.ofReal B :=
+        (ENNReal.le_tsum (f := fun P => ‖h P x‖ₑ) P).trans this
+      rw [← ofReal_norm] at h1
+      exact (ENNReal.ofReal_le_ofReal_iff hB).mp h1
+  · -- summability of the integral norms
+    have hfin' := hfin
+    have hs := ENNReal.summable_toReal hfin'
+    refine hs.congr fun P => ?_
+    rw [integral_norm_eq_lintegral_enorm (hmeas P)]
+
+instance : Encodable (Tile n) := Encodable.ofEquiv _ (tileEquiv (n := n))
+
+instance : Infinite (Tile n) :=
+  Infinite.of_injective (fun k : ℤ => (⟨k, 0, 0⟩ : Tile n)) fun a b h => by
+    simpa using congrArg Tile.k h
+
+instance : Denumerable (Tile n) := Denumerable.ofEncodableOfInfinite _
+
+/-- Measurability of a pointwise summable tile series of measurable functions. -/
+theorem measurable_tsum_tile {X : Type*} [MeasurableSpace X] {f : Tile n → X → ℂ}
+    (hf : ∀ P, Measurable (f P)) (hs : ∀ x, Summable fun P => f P x) :
+    Measurable fun x => ∑' P, f P x := by
+  set e : ℕ ≃ Tile n := (Denumerable.eqv (Tile n)).symm
+  have hlim : ∀ x, Filter.Tendsto (fun N => ∑ k ∈ Finset.range N, f (e k) x) Filter.atTop
+      (nhds (∑' P, f P x)) := by
+    intro x
+    have h1 : HasSum (fun k => f (e k) x) (∑' P, f P x) :=
+      (e.hasSum_iff (f := fun P => f P x)).mpr (hs x).hasSum
+    exact h1.tendsto_sum_nat
+  exact measurable_of_tendsto_metrizable (fun N => Finset.measurable_sum _ fun k _ => hf (e k))
+    (tendsto_pi_nhds.mpr hlim)
+
+theorem measurable_Tlin (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) (g : 𝓢(Rn n, ℂ)) {N : Rn n → Rn n}
+    (hN : Measurable N) : Measurable (Tlin α r m N g) := by
+  obtain ⟨C, hC, hsb⟩ := modelOpHO_summable_bound α hα hr
+  exact measurable_tsum_tile (fun P => measurable_TlinTerm α r hm hN g P)
+    fun x => (hsb m hm g (SchwartzMap.integrable g) (integrable_fhat_schwartz g) (N x) x).1
+
+/-- The duality step (paper, §4, texline~291–299): the key estimate gives
+`∫_E |T g| ≤ K (|E|/λ + λ ‖g‖₂²)` for every `λ > 0`. -/
+theorem integral_norm_Tlin_le_aux (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) {K : ℝ}
+    (hK : KeyEstimate α r m K) (g : 𝓢(Rn n, ℂ)) {N : Rn n → Rn n} (hN : Measurable N)
+    {E : Set (Rn n)} (hE : MeasurableSet E) (hEfin : volume E < ⊤) {lam : ℝ} (hlam : 0 < lam) :
+    ∫ x in E, ‖Tlin α r m N g x‖ ≤
+      K * ((volume E).toReal / lam + lam * (eLpNorm (g : Rn n → ℂ) 2).toReal ^ 2) := by
+  set T := Tlin α r m N g
+  have hT : Measurable T := measurable_Tlin α hα hr hm g hN
+  set σ : Rn n → ℂ := fun x => if T x = 0 then 0 else (starRingEnd ℂ) (T x) / (‖T x‖ : ℂ)
+  have hσ : Measurable σ := by
+    refine Measurable.ite (measurableSet_eq_fun hT measurable_const) measurable_const ?_
+    exact (Complex.continuous_conj.measurable.comp hT).div
+      (Complex.continuous_ofReal.measurable.comp hT.norm)
+  have hσb : ∀ x, ‖σ x‖ ≤ 1 := by
+    intro x
+    simp only [σ]
+    split_ifs with h
+    · simp
+    · rw [norm_div, RCLike.norm_conj, Complex.norm_real, Real.norm_eq_abs, abs_norm,
+        div_self (norm_ne_zero_iff.mpr h)]
+  have hTσ : ∀ x, T x * σ x = (‖T x‖ : ℂ) := by
+    intro x
+    simp only [σ]
+    split_ifs with h
+    · simp [h]
+    · have hne : (‖T x‖ : ℂ) ≠ 0 := by exact_mod_cast norm_ne_zero_iff.mpr h
+      rw [mul_div_assoc', RCLike.mul_conj]
+      field_simp
+      norm_cast
+  have hsum := integral_Tlin_mul_eq α hα hr hm g hN hE hEfin hσ hσb
+  -- the key estimate applied to `λ g`
+  have hkey : ∀ S : Finset (Tile n), ∑ P ∈ S, ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ *
+      ‖dualTerm α m r N E σ P‖ ≤
+        K * ((volume E).toReal / lam + lam * (eLpNorm (g : Rn n → ℂ) 2).toReal ^ 2) := by
+    intro S
+    have hgL2 : MemLp ((lam : ℂ) • (g : Rn n → ℂ)) 2 := ((g.memLp 2).const_smul _)
+    have h := hK _ hgL2 N hN E hE hEfin σ hσ hσb S
+    have hnorm : (eLpNorm ((lam : ℂ) • (g : Rn n → ℂ)) 2).toReal =
+        lam * (eLpNorm (g : Rn n → ℂ) 2).toReal := by
+      rw [eLpNorm_const_smul, ENNReal.toReal_mul, ← ofReal_norm, Complex.norm_real,
+        Real.norm_of_nonneg hlam.le, ENNReal.toReal_ofReal hlam.le]
+    simp_rw [pairing_smul, norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hlam,
+      hnorm] at h
+    simp_rw [mul_assoc] at h
+    rw [← Finset.mul_sum] at h
+    calc ∑ P ∈ S, ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖
+        = lam⁻¹ * (lam * ∑ P ∈ S, ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ *
+          ‖dualTerm α m r N E σ P‖) := by field_simp
+      _ ≤ lam⁻¹ * (K * ((volume E).toReal + (lam * (eLpNorm (g : Rn n → ℂ) 2).toReal) ^ 2)) := by
+          gcongr
+      _ = _ := by field_simp
+  have hnn : ∀ P, 0 ≤ ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ :=
+    fun P => by positivity
+  have hsummable : Summable fun P => ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ *
+      ‖dualTerm α m r N E σ P‖ := summable_of_sum_le hnn hkey
+  calc ∫ x in E, ‖T x‖ = (∫ x in E, T x * σ x).re := by
+        simp_rw [hTσ]
+        rw [integral_complex_ofReal, Complex.ofReal_re]
+    _ ≤ ‖∫ x in E, T x * σ x‖ := Complex.re_le_norm _
+    _ = ‖∑' P, pairing (g : Rn n → ℂ) (wavePhi α P) * dualTerm α m r N E σ P‖ := by
+        rw [hsum.tsum_eq]
+    _ ≤ ∑' P, ‖pairing (g : Rn n → ℂ) (wavePhi α P) * dualTerm α m r N E σ P‖ :=
+        norm_tsum_le_tsum_norm (by simpa [norm_mul] using hsummable)
+    _ = ∑' P, ‖pairing (g : Rn n → ℂ) (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ := by
+        simp_rw [norm_mul]
+    _ ≤ _ := hsummable.tsum_le_of_sum_le hkey
+
+/-- The duality and homogeneity step (paper, §4, texline~291–299): the key estimate implies
+`∫_E |T g| ≤ 2K |E|^{1/2} ‖g‖₂`. -/
+theorem integral_norm_Tlin_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) {K : ℝ}
+    (hK : KeyEstimate α r m K) (g : 𝓢(Rn n, ℂ)) {N : Rn n → Rn n} (hN : Measurable N)
+    {E : Set (Rn n)} (hE : MeasurableSet E) (hEfin : volume E < ⊤) :
+    ∫ x in E, ‖Tlin α r m N g x‖ ≤
+      2 * K * Real.sqrt (volume E).toReal * (eLpNorm (g : Rn n → ℂ) 2).toReal := by
+  set a := (volume E).toReal
+  set b := (eLpNorm (g : Rn n → ℂ) 2).toReal
+  have ha : 0 ≤ a := ENNReal.toReal_nonneg
+  have hb : 0 ≤ b := ENNReal.toReal_nonneg
+  have haux := fun (lam : ℝ) (hlam : 0 < lam) =>
+    integral_norm_Tlin_le_aux α hα hr hm hK g hN hE hEfin hlam
+  have hI : 0 ≤ ∫ x in E, ‖Tlin α r m N g x‖ := integral_nonneg fun x => norm_nonneg _
+  rcases ha.lt_or_eq with ha' | ha'
+  · rcases hb.lt_or_eq with hb' | hb'
+    · -- choose `λ = √a / b`
+      have hsa : 0 < Real.sqrt a := Real.sqrt_pos.mpr ha'
+      have h := haux (Real.sqrt a / b) (by positivity)
+      have hval : a / (Real.sqrt a / b) + Real.sqrt a / b * b ^ 2 = 2 * Real.sqrt a * b := by
+        have hsq : Real.sqrt a ^ 2 = a := Real.sq_sqrt ha
+        field_simp
+        nlinarith [hsq]
+      rw [hval] at h
+      linarith
+    · -- `‖g‖₂ = 0`
+      have hb0 : (eLpNorm (g : Rn n → ℂ) 2).toReal = 0 := hb'.symm
+      rw [show b = 0 from hb'.symm, mul_zero]
+      refine le_of_forall_pos_le_add fun ε hε => ?_
+      rcases le_or_gt K 0 with hK0 | hK0
+      · have h := haux 1 one_pos
+        rw [hb0] at h
+        have : 0 ≤ (volume E).toReal := ha
+        nlinarith
+      · have h := haux (K * a / ε + 1) (by positivity)
+        rw [hb0] at h
+        simp only [ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, mul_zero,
+          add_zero] at h
+        change _ ≤ K * (a / (K * a / ε + 1)) at h
+        have : K * (a / (K * a / ε + 1)) ≤ ε := by
+          rw [mul_div_assoc', div_le_iff₀ (by positivity)]
+          have he : ε * (K * a / ε + 1) = K * a + ε := by field_simp
+          rw [he]
+          linarith
+        linarith
+  · -- `|E| = 0`
+    have hE0 : volume E = 0 := by
+      rcases (ENNReal.toReal_eq_zero_iff _).mp ha'.symm with h | h
+      · exact h
+      · exact absurd h hEfin.ne
+    rw [Measure.restrict_eq_zero.mpr hE0, integral_zero_measure, ← ha', Real.sqrt_zero]
+    simp
+
+/-- **Theorem 3.2, conditional form** (paper, §3, (3.4), via the reduction of §4, texline~287–299):
+if the key estimate (4.1) holds with constant `K`, then for every Schwartz function `g`, every
+finite set `F` of frequencies and every measurable `E` of finite measure,
+`∫_E max_{N ∈ F} |A^{r,m}_N g(x)| dx ≤ 2K |E|^{1/2} ‖g‖₂`. -/
+theorem thm_3_2_of_key (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    {m : Rn n → ℂ} (hm : ClassM α (absA α + 1) m) {K : ℝ} (hK : KeyEstimate α r m K)
+    (g : 𝓢(Rn n, ℂ)) (F : Finset (Rn n)) (hF : F.Nonempty) {E : Set (Rn n)}
+    (hE : MeasurableSet E) (hEfin : volume E < ⊤) :
+    ∫ x in E, F.sup' hF (fun N => ‖modelOpHO α r m N g x‖) ≤
+      2 * K * Real.sqrt (volume E).toReal * (eLpNorm (g : Rn n → ℂ) 2).toReal := by
+  set l := F.toList
+  set e : ℕ → Rn n := fun k => l.getD k 0
+  set S : Rn n → ℝ := fun x => F.sup' hF (fun N => ‖modelOpHO α r m N g x‖)
+  have hmeasA : ∀ N, Measurable fun x => ‖modelOpHO α r m N g x‖ := fun N =>
+    (measurable_Tlin α hα hr hm g (measurable_const (a := N))).norm
+  have hS : Measurable S := by
+    have := Finset.measurable_sup' hF fun N _ => hmeasA N
+    convert this using 1
+    funext x
+    simp only [S, Finset.sup'_apply]
+  set p : Rn n → ℕ → Prop := fun x k => k < l.length ∧ ‖modelOpHO α r m (e k) g x‖ = S x
+  have hp : ∀ x, ∃ k, p x k := by
+    intro x
+    obtain ⟨N, hNF, hN⟩ := Finset.exists_mem_eq_sup' hF (fun N => ‖modelOpHO α r m N g x‖)
+    have hNl : N ∈ l := Finset.mem_toList.mpr hNF
+    obtain ⟨k, hk⟩ := List.mem_iff_get.mp hNl
+    refine ⟨k, k.2, ?_⟩
+    simp only [e, List.getD_eq_getElem _ _ k.2]
+    rw [show l[(k : ℕ)] = N from hk]
+    exact hN.symm
+  have hpm : ∀ k, MeasurableSet {x | p x k} := by
+    intro k
+    by_cases hk : k < l.length
+    · simp only [p, hk, true_and]
+      exact measurableSet_eq_fun (hmeasA (e k)) hS
+    · simp [p, hk]
+  classical
+  set Nsel : Rn n → Rn n := fun x => e (Nat.find (hp x))
+  have hNsel : Measurable Nsel := (measurable_from_nat (f := e)).comp (measurable_find hp hpm)
+  have hEq : ∀ x, S x = ‖Tlin α r m Nsel g x‖ := fun x => (Nat.find_spec (hp x)).2.symm
+  calc ∫ x in E, S x = ∫ x in E, ‖Tlin α r m Nsel g x‖ := by simp_rw [hEq]
+    _ ≤ _ := integral_norm_Tlin_le α hα hr hm hK g hNsel hE hEfin
+
+/-! ## Section 4: tiles, the tile order and trees -/
+
+/-- The center `c(Q) = δ_{2^k}(ℓ + 1/2)` of an anisotropic dyadic cube. -/
+def DCube.center (α : Fin n → ℕ) (Q : DCube n) : Rn n :=
+  WithLp.toLp 2 (fun i => side α Q.k i * (Q.ℓ i + 1 / 2))
+
+theorem DCube.center_mem (α : Fin n → ℕ) (Q : DCube n) : Q.center α ∈ Q.toSet α := by
+  intro i
+  have hs := side_pos α Q.k i
+  simp only [DCube.center, PiLp.toLp_apply]
+  constructor <;> nlinarith
+
+theorem DCube.eq_of_mem_of_k_eq (α : Fin n → ℕ) {Q Q' : DCube n} (hk : Q.k = Q'.k) {x : Rn n}
+    (hx : x ∈ Q.toSet α) (hx' : x ∈ Q'.toSet α) : Q = Q' := by
+  rw [DCube.mem_toSet_iff_floor] at hx hx'
+  ext
+  · exact hk
+  · rename_i i
+    rw [← hx i, ← hx' i, hk]
+
+theorem absA_pos (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) : 0 < absA α := by
+  have : α ⟨0, hn⟩ ≤ absA α := Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ _)
+  have h1 := hα ⟨0, hn⟩
+  omega
+
+theorem DCube.k_le_of_subset (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {Q Q' : DCube n}
+    (h : Q.toSet α ⊆ Q'.toSet α) : Q.k ≤ Q'.k := by
+  have hv := measure_mono (μ := volume) h
+  rw [DCube.volume_toSet, DCube.volume_toSet,
+    ENNReal.ofReal_le_ofReal_iff (by positivity)] at hv
+  have hA : (0 : ℤ) < absA α := by exact_mod_cast absA_pos α hα hn
+  have := (zpow_le_zpow_iff_right₀ (a := (2 : ℝ)) (by norm_num)).mp hv
+  exact le_of_mul_le_mul_right this hA
+
+/-- Containment of anisotropic dyadic cubes in terms of indices. -/
+theorem DCube.subset_iff (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (Q Q' : DCube n) :
+    Q.toSet α ⊆ Q'.toSet α ↔ Q.k ≤ Q'.k ∧ Q.ancestor α (Q'.k - Q.k).toNat = Q' := by
+  constructor
+  · intro h
+    have hk := DCube.k_le_of_subset α hα hn h
+    refine ⟨hk, ?_⟩
+    have hmem := DCube.toSet_subset_ancestor α Q (Q'.k - Q.k).toNat (DCube.center_mem α Q)
+    refine DCube.eq_of_mem_of_k_eq α ?_ hmem (h (DCube.center_mem α Q))
+    simp only [DCube.ancestor]
+    omega
+  · rintro ⟨-, h⟩
+    rw [← h]
+    exact DCube.toSet_subset_ancestor α Q _
+
+theorem DCube.subset_or_disjoint' (α : Fin n → ℕ) (Q Q' : DCube n) :
+    Q.toSet α ⊆ Q'.toSet α ∨ Q'.toSet α ⊆ Q.toSet α ∨ Disjoint (Q.toSet α) (Q'.toSet α) := by
+  rcases le_total Q.k Q'.k with h | h
+  · rcases DCube.subset_or_disjoint α Q Q' h with h1 | h1
+    · exact Or.inl h1
+    · exact Or.inr (Or.inr h1)
+  · rcases DCube.subset_or_disjoint α Q' Q h with h1 | h1
+    · exact Or.inr (Or.inl h1)
+    · exact Or.inr (Or.inr h1.symm)
+
+/-- The tile order (paper, §4, texline~302): `P ≤ P'` iff `I_P ⊆ I_{P'}` and `c(ω_{P'}) ∈ ω_P`. -/
+def Tile.le (α : Fin n → ℕ) (P P' : Tile n) : Prop :=
+  P.I.toSet α ⊆ P'.I.toSet α ∧ P'.cω α ∈ P.ω.toSet α
+
+theorem Tile.cω_eq_center (α : Fin n → ℕ) (P : Tile n) : P.cω α = P.ω.center α := rfl
+
+theorem Tile.le_refl (α : Fin n → ℕ) (P : Tile n) : Tile.le α P P :=
+  ⟨subset_rfl, DCube.center_mem α P.ω⟩
+
+/-- For `P ≤ P'` the frequency cubes are nested the other way: `ω_{P'} ⊆ ω_P`. -/
+theorem Tile.ω_subset_of_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {P P' : Tile n}
+    (h : Tile.le α P P') : P'.ω.toSet α ⊆ P.ω.toSet α := by
+  have hk : P.k ≤ P'.k := DCube.k_le_of_subset α hα hn h.1
+  have hk' : P'.ω.k ≤ P.ω.k := by simp [Tile.ω]; omega
+  rcases DCube.subset_or_disjoint α P'.ω P.ω hk' with h1 | h1
+  · exact h1
+  · exact absurd (DCube.center_mem α P'.ω) (fun hc => Set.disjoint_left.mp h1 hc h.2)
+
+theorem Tile.le_trans (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {P P' P'' : Tile n}
+    (h1 : Tile.le α P P') (h2 : Tile.le α P' P'') : Tile.le α P P'' :=
+  ⟨h1.1.trans h2.1, Tile.ω_subset_of_le α hα hn h1 h2.2⟩
+
+theorem Tile.le_antisymm (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {P P' : Tile n}
+    (h1 : Tile.le α P P') (h2 : Tile.le α P' P) : P = P' := by
+  have hk : P.k = P'.k := _root_.le_antisymm (DCube.k_le_of_subset α hα hn h1.1)
+    (DCube.k_le_of_subset α hα hn h2.1)
+  have hI : P.I = P'.I := DCube.eq_of_mem_of_k_eq α (by simp [Tile.I, hk])
+    (DCube.center_mem α P.I) (h1.1 (DCube.center_mem α P.I))
+  have hω : P.ω = P'.ω := DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) h1.2
+    (DCube.center_mem α P'.ω)
+  ext
+  · exact hk
+  · rename_i i; have := congrFun (congrArg DCube.ℓ hI) i; simpa [Tile.I] using this
+  · rename_i i; have := congrFun (congrArg DCube.ℓ hω) i; simpa [Tile.ω] using this
+
+/-- The tile as a subset of phase space, `I_P × ω_P`. -/
+def Tile.toSet (α : Fin n → ℕ) (P : Tile n) : Set (Rn n × Rn n) := P.I.toSet α ×ˢ P.ω.toSet α
+
+/-- Two tiles are comparable with respect to `≤` iff they intersect (paper, §4, texline~304). -/
+theorem Tile.comparable_iff_inter (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    (P P' : Tile n) :
+    (Tile.le α P P' ∨ Tile.le α P' P) ↔ (P.toSet α ∩ P'.toSet α).Nonempty := by
+  constructor
+  · rintro (h | h)
+    · exact ⟨(P.I.center α, P'.ω.center α), ⟨h.1 (DCube.center_mem α P.I) |> fun _ =>
+        DCube.center_mem α P.I, Tile.ω_subset_of_le α hα hn h (DCube.center_mem α P'.ω)⟩,
+        ⟨h.1 (DCube.center_mem α P.I), DCube.center_mem α P'.ω⟩⟩
+    · exact ⟨(P'.I.center α, P.ω.center α), ⟨h.1 (DCube.center_mem α P'.I),
+        DCube.center_mem α P.ω⟩, ⟨DCube.center_mem α P'.I,
+        Tile.ω_subset_of_le α hα hn h (DCube.center_mem α P.ω)⟩⟩
+  · rintro ⟨⟨x, ξ⟩, ⟨hx, hξ⟩, ⟨hx', hξ'⟩⟩
+    rcases le_total P.k P'.k with hk | hk
+    · left
+      have hI : P.I.toSet α ⊆ P'.I.toSet α := by
+        rcases DCube.subset_or_disjoint α P.I P'.I hk with h | h
+        · exact h
+        · exact absurd hx' (Set.disjoint_left.mp h hx)
+      have hk' : P'.ω.k ≤ P.ω.k := by simp [Tile.ω]; omega
+      have hω : P'.ω.toSet α ⊆ P.ω.toSet α := by
+        rcases DCube.subset_or_disjoint α P'.ω P.ω hk' with h | h
+        · exact h
+        · exact absurd hξ (Set.disjoint_left.mp h hξ')
+      exact ⟨hI, hω (DCube.center_mem α P'.ω)⟩
+    · right
+      have hI : P'.I.toSet α ⊆ P.I.toSet α := by
+        rcases DCube.subset_or_disjoint α P'.I P.I hk with h | h
+        · exact h
+        · exact absurd hx (Set.disjoint_left.mp h hx')
+      have hk' : P.ω.k ≤ P'.ω.k := by simp [Tile.ω]; omega
+      have hω : P.ω.toSet α ⊆ P'.ω.toSet α := by
+        rcases DCube.subset_or_disjoint α P.ω P'.ω hk' with h | h
+        · exact h
+        · exact absurd hξ' (Set.disjoint_left.mp h hξ)
+      exact ⟨hI, hω (DCube.center_mem α P.ω)⟩
+
+theorem Tile.eq_of_le_of_k_eq (α : Fin n → ℕ) {P P' : Tile n} (h : Tile.le α P P')
+    (hk : P.k = P'.k) : P = P' := by
+  have hI : P.I = P'.I := DCube.eq_of_mem_of_k_eq α (by simp [Tile.I, hk])
+    (DCube.center_mem α P.I) (h.1 (DCube.center_mem α P.I))
+  have hω : P.ω = P'.ω := DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) h.2
+    (DCube.center_mem α P'.ω)
+  ext
+  · exact hk
+  · rename_i i; have := congrFun (congrArg DCube.ℓ hI) i; simpa [Tile.I] using this
+  · rename_i i; have := congrFun (congrArg DCube.ℓ hω) i; simpa [Tile.ω] using this
+
+/-- Trees (paper, Definition 4.1, texline~305): a finite collection `T` of tiles together with a
+designated top tile `top` such that `P ≤ top` for all `P ∈ T`. The top need not belong to `T`. -/
+def IsTree (α : Fin n → ℕ) (top : Tile n) (T : Finset (Tile n)) : Prop :=
+  ∀ P ∈ T, Tile.le α P top
+
+/-- `1`-trees (Definition 4.1): `c(ω_T) ∉ ω_{P(r)}` for all `P ∈ T`. -/
+def Is1Tree (α : Fin n → ℕ) (r : Fin n → Fin 2) (top : Tile n) (T : Finset (Tile n)) : Prop :=
+  IsTree α top T ∧ ∀ P ∈ T, top.cω α ∉ P.semi α r
+
+/-- `2`-trees (Definition 4.1): `c(ω_T) ∈ ω_{P(r)}` for all `P ∈ T`. -/
+def Is2Tree (α : Fin n → ℕ) (r : Fin n → Fin 2) (top : Tile n) (T : Finset (Tile n)) : Prop :=
+  IsTree α top T ∧ ∀ P ∈ T, top.cω α ∈ P.semi α r
+
+/-- The volume `|I_P| = 2^{k_P|α|}` of the spatial cube of a tile, as a real number. -/
+def Tile.vol (α : Fin n → ℕ) (P : Tile n) : ℝ := (2 : ℝ) ^ (P.k * (absA α : ℤ))
+
+theorem Tile.vol_pos (α : Fin n → ℕ) (P : Tile n) : 0 < P.vol α := by
+  unfold Tile.vol; positivity
+
+theorem Tile.volume_I (α : Fin n → ℕ) (P : Tile n) :
+    volume (P.I.toSet α) = ENNReal.ofReal (P.vol α) := DCube.volume_toSet α P.I
+
+/-- The mass of a single tile (paper, (4.2), texline~313):
+`𝓜(P) = sup_{P' ≥ P} ∫_{E ∩ N⁻¹(ω_{P'})} w^ν_{P'}`. -/
+def massTile (α : Fin n → ℕ) (ν : ℝ) (E : Set (Rn n)) (N : Rn n → Rn n) (P : Tile n) : ℝ≥0∞ :=
+  ⨆ (P' : Tile n) (_ : Tile.le α P P'),
+    ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α), ENNReal.ofReal (wP α ν P' x)
+
+/-- The mass of a collection of tiles (paper, (4.3), texline~324). -/
+def mass (α : Fin n → ℕ) (ν : ℝ) (E : Set (Rn n)) (N : Rn n → Rn n) (S : Finset (Tile n)) :
+    ℝ≥0∞ :=
+  ⨆ P ∈ S, massTile α ν E N P
+
+/-- The energy of a collection of tiles (paper, (4.4), texline~330), as a supremum over all
+`2`-trees `T ⊆ S` with arbitrary top:
+`𝓔(S) = sup_T (|I_T|⁻¹ ∑_{P ∈ T} |⟨f, φ_P⟩|²)^{1/2}`. -/
+def energy (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ) (S : Finset (Tile n)) : ℝ≥0∞ :=
+  ⨆ (top : Tile n) (T : Finset (Tile n)) (_ : T ⊆ S) (_ : Is2Tree α r top T),
+    ENNReal.ofReal (Real.sqrt ((top.vol α)⁻¹ * ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ ^ 2))
+
+/-! ### Section 5: the mass lemma -/
+
+/-- The enlarged cube `δ_{2^j}(I_P)` around `c(I_P)` (paper, §5, texline~446), taken open. -/
+def Tile.enl (α : Fin n → ℕ) (P : Tile n) (j : ℕ) : Set (Rn n) :=
+  {x | ∀ i, |x i - P.cI α i| < side α (P.k + j) i / 2}
+
+theorem Tile.enl_eq_preimage (α : Fin n → ℕ) (P : Tile n) (j : ℕ) :
+    P.enl α j = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹'
+      Set.pi Set.univ (fun i => Set.Ioo (P.cI α i - side α (P.k + j) i / 2)
+        (P.cI α i + side α (P.k + j) i / 2)) := by
+  ext x
+  simp only [Tile.enl, Set.mem_ofPred_eq, Set.mem_preimage, Set.mem_pi, Set.mem_univ,
+    Set.mem_Ioo, true_implies, abs_sub_lt_iff]
+  refine forall_congr' fun i => ?_
+  constructor <;> rintro ⟨h1, h2⟩ <;> exact ⟨by linarith, by linarith⟩
+
+theorem Tile.measurableSet_enl (α : Fin n → ℕ) (P : Tile n) (j : ℕ) :
+    MeasurableSet (P.enl α j) := by
+  rw [Tile.enl_eq_preimage]
+  exact (MeasurableSet.univ_pi fun i => measurableSet_Ioo).preimage
+    (PiLp.volume_preserving_ofLp _).measurable
+
+theorem prod_side (α : Fin n → ℕ) (k : ℤ) :
+    ∏ i, side α k i = (2 : ℝ) ^ (k * (absA α : ℤ)) := by
+  simp only [side, absA, zpow_mul, zpow_natCast]
+  exact Finset.prod_pow_eq_pow_sum _ _ _
+
+theorem Tile.volume_enl (α : Fin n → ℕ) (P : Tile n) (j : ℕ) :
+    volume (P.enl α j) = ENNReal.ofReal ((2 : ℝ) ^ ((j : ℤ) * (absA α : ℤ)) * P.vol α) := by
+  rw [Tile.enl_eq_preimage, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun i => measurableSet_Ioo).nullMeasurableSet, Real.volume_pi_Ioo]
+  have : ∀ i, P.cI α i + side α (P.k + j) i / 2 - (P.cI α i - side α (P.k + j) i / 2) =
+      side α (P.k + j) i := by intro i; ring
+  simp only [this]
+  rw [← ENNReal.ofReal_prod_of_nonneg (fun i _ => (side_pos α _ i).le)]
+  congr 1
+  rw [prod_side, Tile.vol, ← zpow_add₀ (by norm_num)]
+  congr 1
+  ring
+
+theorem abs_coord_le_rho_pow (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (z : Rn n) (i : Fin n) :
+    |z i| ≤ rho α z ^ α i := by
+  have h := abs_coord_rpow_le_rho α z i
+  have hai : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+  calc |z i| = (|z i| ^ ((α i : ℝ)⁻¹)) ^ (α i : ℝ) := by
+        rw [← Real.rpow_mul (abs_nonneg _), inv_mul_cancel₀ hai, Real.rpow_one]
+    _ ≤ rho α z ^ (α i : ℝ) := Real.rpow_le_rpow (by positivity) h (by positivity)
+    _ = rho α z ^ α i := Real.rpow_natCast _ _
+
+/-- `|I_P| w^ν_P(x) = (1 + 2^{-k_P} ρ(x - c(I_P)))^{-ν}`. -/
+theorem vol_mul_wP (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℝ) (P : Tile n) (x : Rn n) :
+    P.vol α * wP α ν P x = (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν) := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  simp only [wP, wgt]
+  rw [one_add_inv_mul_rho_eq α hα ht, ← mul_assoc]
+  convert one_mul _
+  simp only [Tile.vol]
+  rw [zpow_mul, ← Real.rpow_intCast ((2 : ℝ) ^ P.k), ← Real.rpow_add ht]
+  simp
+
+/-- Decay of the normalized weight outside the enlarged cube: for `x ∉ δ_{2^j} I_P`,
+`(1 + 2^{-k_P} ρ(x - c(I_P)))^{-ν} ≤ 2^ν 2^{-νj}`. -/
+theorem wnorm_le_of_not_mem_enl (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (hν : 0 ≤ ν)
+    (P : Tile n) (j : ℕ) {x : Rn n} (hx : x ∉ P.enl α j) :
+    (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν) ≤ (2 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν) := by
+  simp only [Tile.enl, Set.mem_ofPred_eq, not_forall, not_lt] at hx
+  obtain ⟨i, hi⟩ := hx
+  have ht : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  -- `ρ(x - c) ≥ 2^{k + j} / 2`
+  have hρ : (2 : ℝ) ^ P.k * (2 : ℝ) ^ j / 2 ≤ rho α (x - P.cI α) := by
+    by_contra hlt
+    push Not at hlt
+    have h1 := abs_coord_le_rho_pow α hα (x - P.cI α) i
+    have hai := hα i
+    have h2 : rho α (x - P.cI α) ^ α i < ((2 : ℝ) ^ P.k * (2 : ℝ) ^ j / 2) ^ α i :=
+      pow_lt_pow_left₀ hlt (rho_nonneg α _) (by omega)
+    have h3 : ((2 : ℝ) ^ P.k * (2 : ℝ) ^ j / 2) ^ α i ≤ side α (P.k + j) i / 2 := by
+      rw [div_pow, side, mul_pow, ← zpow_natCast ((2 : ℝ) ^ P.k), ← zpow_natCast ((2 : ℝ) ^ j),
+        ← zpow_natCast (2 : ℝ) j, ← zpow_mul, ← zpow_mul, ← zpow_add₀ (by norm_num)]
+      have h2a : (2 : ℝ) ≤ 2 ^ α i := by
+        calc (2 : ℝ) = 2 ^ 1 := by norm_num
+          _ ≤ 2 ^ α i := pow_le_pow_right₀ (by norm_num) hai
+      have hpos : (0 : ℝ) < (2 : ℝ) ^ ((P.k * (α i : ℤ)) + ((j : ℤ) * (α i : ℤ))) := by positivity
+      rw [show ((P.k + (j : ℤ)) * (α i : ℤ)) = (P.k * (α i : ℤ)) + ((j : ℤ) * (α i : ℤ)) by ring]
+      exact div_le_div_of_nonneg_left hpos.le (by norm_num) h2a
+    simp only [PiLp.sub_apply] at h1
+    linarith
+  have hb : (2 : ℝ) ^ j / 2 ≤ 1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by
+    have : (2 : ℝ) ^ j / 2 ≤ ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by
+      rw [inv_mul_eq_div, le_div_iff₀ ht]
+      linarith
+    linarith
+  calc (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν) ≤ ((2 : ℝ) ^ j / 2) ^ (-ν) :=
+        Real.rpow_le_rpow_of_nonpos (by positivity) hb (by linarith)
+    _ = (2 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν) := by
+        rw [Real.div_rpow (by positivity) (by norm_num), Real.rpow_neg (by norm_num : (0:ℝ) ≤ 2)]
+        field_simp
+
+theorem side_mono (α : Fin n → ℕ) {k k' : ℤ} (h : k ≤ k') (i : Fin n) :
+    side α k i ≤ side α k' i := by
+  unfold side
+  exact zpow_le_zpow_right₀ (by norm_num) (mul_le_mul_of_nonneg_right h (by positivity))
+
+theorem Tile.enl_mono (α : Fin n → ℕ) (P : Tile n) {j j' : ℕ} (h : j ≤ j') :
+    P.enl α j ⊆ P.enl α j' := fun x hx i =>
+  (hx i).trans_le (by gcongr; exact side_mono α (by omega) i)
+
+theorem exists_mem_enl (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P : Tile n) (x : Rn n) :
+    ∃ j, x ∈ P.enl α j := by
+  have : ∀ i, ∃ j : ℕ, |x i - P.cI α i| < side α (P.k + j) i / 2 := by
+    intro i
+    obtain ⟨j, hj⟩ := pow_unbounded_of_one_lt (2 * |x i - P.cI α i| / side α P.k i)
+      (show (1 : ℝ) < 2 by norm_num)
+    refine ⟨j, ?_⟩
+    have hs := side_pos α P.k i
+    have hsj : (2 : ℝ) ^ j ≤ side α (j : ℤ) i := by
+      unfold side
+      rw [← zpow_natCast]
+      exact zpow_le_zpow_right₀ (by norm_num) (by have := hα i; nlinarith)
+    rw [side_add, lt_div_iff₀ (by norm_num)]
+    rw [div_lt_iff₀ hs] at hj
+    nlinarith
+  choose J hJ using this
+  refine ⟨Finset.univ.sup J, fun i => (hJ i).trans_le ?_⟩
+  gcongr
+  exact side_mono α (by have := Finset.le_sup (f := J) (Finset.mem_univ i); omega) i
+
+/-- The annular decomposition of the normalized weight (paper, §5, (5.3)):
+`(1 + 2^{-k_P} ρ(x - c(I_P)))^{-ν} ≤ ∑_j 4^ν 2^{-νj} 1_{δ_{2^j} I_P}(x)`. -/
+theorem wnorm_le_tsum (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (hν : 0 ≤ ν) (P : Tile n)
+    (x : Rn n) :
+    ENNReal.ofReal ((1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν)) ≤
+      ∑' j : ℕ, ENNReal.ofReal ((4 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν)) *
+        (P.enl α j).indicator 1 x := by
+  classical
+  have hex := exists_mem_enl α hα P x
+  set j0 := Nat.find hex
+  have hj0 : x ∈ P.enl α j0 := Nat.find_spec hex
+  refine le_trans ?_ (ENNReal.le_tsum j0)
+  rw [Set.indicator_of_mem hj0, Pi.one_apply, mul_one]
+  refine ENNReal.ofReal_le_ofReal ?_
+  have h4 : (4 : ℝ) ^ ν = (2 : ℝ) ^ ν * (2 : ℝ) ^ ν := by
+    rw [← Real.mul_rpow (by norm_num) (by norm_num)]; norm_num
+  rcases Nat.eq_zero_or_pos j0 with h0 | hpos
+  · rw [h0, pow_zero, Real.one_rpow, mul_one]
+    have hb : 1 ≤ 1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by
+      have := rho_nonneg α (x - P.cI α); have : (0:ℝ) < (2:ℝ) ^ P.k := by positivity
+      have : 0 ≤ ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by positivity
+      linarith
+    calc _ ≤ (1 : ℝ) := Real.rpow_le_one_of_one_le_of_nonpos hb (by linarith)
+      _ ≤ (4 : ℝ) ^ ν := Real.one_le_rpow (by norm_num) hν
+  · obtain ⟨m, hm⟩ : ∃ m, j0 = m + 1 := ⟨j0 - 1, by omega⟩
+    have hnot : x ∉ P.enl α m := Nat.find_min hex (by omega)
+    have h := wnorm_le_of_not_mem_enl α hα hν P m hnot
+    refine h.trans (le_of_eq ?_)
+    rw [hm, pow_succ, Real.mul_rpow (by positivity) (by norm_num), h4,
+      Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 2)]
+    field_simp
+
+/-- From `∫_{E_P} w_P > λ` one finds a scale `j` with `λ |I_P| 2^{j(ν-1)} < 2·4^ν |E_P ∩ δ_{2^j}
+    I_P|`
+(paper, §5, (5.4)–(5.5)). -/
+theorem exists_scale_of_heavy (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (hν : 0 ≤ ν)
+    (A : Set (Rn n)) (P : Tile n) {lam : ℝ} (hlam : 0 < lam)
+    (h : ENNReal.ofReal lam < ∫⁻ x in A, ENNReal.ofReal (wP α ν P x)) :
+    ∃ j : ℕ, ENNReal.ofReal (lam * P.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) <
+      ENNReal.ofReal (2 * 4 ^ ν) * volume (A ∩ P.enl α j) := by
+  by_contra H
+  push Not at H
+  set c : ℝ := 2 * 4 ^ ν
+  have hc : 0 < c := by positivity
+  have hv := P.vol_pos α
+  have hW : ∀ x, ENNReal.ofReal (P.vol α) * ENNReal.ofReal (wP α ν P x) =
+      ENNReal.ofReal ((1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν)) := by
+    intro x
+    rw [← ENNReal.ofReal_mul hv.le, vol_mul_wP α hα]
+  have hmeas : ∀ j, Measurable ((P.enl α j).indicator (1 : Rn n → ℝ≥0∞)) := fun j =>
+    measurable_one.indicator (P.measurableSet_enl α j)
+  have key : ENNReal.ofReal c * (ENNReal.ofReal (P.vol α) *
+      ∫⁻ x in A, ENNReal.ofReal (wP α ν P x)) ≤ ENNReal.ofReal c * ENNReal.ofReal (lam * P.vol
+          α) := by
+    rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+    simp_rw [hW]
+    calc ENNReal.ofReal c * ∫⁻ x in A, ENNReal.ofReal
+            ((1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν))
+        ≤ ENNReal.ofReal c * ∫⁻ x in A, ∑' j : ℕ, ENNReal.ofReal ((4 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^
+            (-ν)) *
+            (P.enl α j).indicator 1 x := by
+          gcongr with x
+          exact wnorm_le_tsum α hα hν P x
+      _ = ∑' j : ℕ, ENNReal.ofReal ((4 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν)) *
+            (ENNReal.ofReal c * volume (A ∩ P.enl α j)) := by
+          rw [lintegral_tsum fun j => ((hmeas j).const_mul _).aemeasurable, ← ENNReal.tsum_mul_left]
+          congr 1; ext j
+          rw [lintegral_const_mul _ (hmeas j), lintegral_indicator_one (P.measurableSet_enl α j),
+            Measure.restrict_apply (P.measurableSet_enl α j), Set.inter_comm]
+          ring
+      _ ≤ ∑' j : ℕ, ENNReal.ofReal ((4 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν)) *
+            ENNReal.ofReal (lam * P.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) := by
+          gcongr with j
+          exact H j
+      _ = ∑' j : ℕ, ENNReal.ofReal ((4 : ℝ) ^ ν * (lam * P.vol α)) * 2⁻¹ ^ j := by
+          congr 1; ext j
+          rw [← ENNReal.ofReal_mul (by positivity)]
+          have h2 : ((2 : ℝ) ^ j) ^ (-ν) * ((2 : ℝ) ^ j) ^ (ν - 1) = ((2 : ℝ) ^ j)⁻¹ := by
+            rw [← Real.rpow_add (by positivity), show -ν + (ν - 1) = (-1 : ℝ) by ring,
+                Real.rpow_neg_one]
+          rw [show (4 : ℝ) ^ ν * ((2 : ℝ) ^ j) ^ (-ν) * (lam * P.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) =
+            (4 : ℝ) ^ ν * (lam * P.vol α) * (((2 : ℝ) ^ j) ^ (-ν) * ((2 : ℝ) ^ j) ^ (ν - 1)) by
+                ring,
+            h2, ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_inv_of_pos (by positivity),
+            ENNReal.ofReal_pow (by norm_num), ENNReal.ofReal_ofNat, ENNReal.inv_pow]
+      _ = ENNReal.ofReal c * ENNReal.ofReal (lam * P.vol α) := by
+          rw [ENNReal.tsum_mul_left, ENNReal.tsum_geometric, ENNReal.one_sub_inv_two, inv_inv,
+            ← ENNReal.ofReal_ofNat 2, ← ENNReal.ofReal_mul (by positivity),
+            ← ENNReal.ofReal_mul (by positivity)]
+          congr 1
+          simp only [c]; ring
+  have hlt : ENNReal.ofReal c * ENNReal.ofReal (lam * P.vol α) < ENNReal.ofReal c *
+      (ENNReal.ofReal (P.vol α) * ∫⁻ x in A, ENNReal.ofReal (wP α ν P x)) := by
+    rw [ENNReal.ofReal_mul hlam.le, mul_comm (ENNReal.ofReal lam)]
+    have := ENNReal.mul_lt_mul_left (by simpa using hc) ENNReal.ofReal_ne_top
+      (ENNReal.mul_lt_mul_left (by simpa using hv) ENNReal.ofReal_ne_top h)
+    calc _ = _ := by ring
+      _ < _ := this
+      _ = _ := by ring
+  exact absurd key (not_le.mpr hlt)
+
+theorem abs_sub_cI_le_of_mem_I (α : Fin n → ℕ) (P : Tile n) {y : Rn n} (hy : y ∈ P.I.toSet α)
+    (i : Fin n) : |y i - P.cI α i| ≤ side α P.k i / 2 := by
+  have h := hy i
+  simp only [Tile.I] at h
+  rw [abs_le]
+  simp only [Tile.cI, PiLp.toLp_apply]
+  constructor <;> nlinarith [h.1, h.2.le]
+
+theorem Tile.cI_mem_enl (α : Fin n → ℕ) (P : Tile n) (j : ℕ) : P.cI α ∈ P.enl α j := by
+  intro i
+  simp only [sub_self, abs_zero]
+  have := side_pos α (P.k + j) i
+  positivity
+
+/-- The covering step of the mass lemma (paper, §5, (5.6), texline~468–477): if the tiles of `A`
+are pairwise disjoint and each satisfies (5.5) at the scale `j`, then
+`∑_{P ∈ A} |I_P| ≤ 2^{(j+2)|α|} (2·4^ν/λ) 2^{j(1-ν)} |E|`. -/
+theorem sum_vol_le_of_scale (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} {E : Set (Rn n)}
+    (hE : MeasurableSet E) (hEfin : volume E < ⊤) {N : Rn n → Rn n} (hN : Measurable N)
+    (A : Finset (Tile n))
+    (hdisj : ∀ P ∈ A, ∀ Q ∈ A, P ≠ Q →
+      Disjoint (P.I.toSet α) (Q.I.toSet α) ∨ Disjoint (P.ω.toSet α) (Q.ω.toSet α))
+    {lam : ℝ} (hlam : 0 < lam) (j : ℕ)
+    (hA : ∀ P ∈ A, ENNReal.ofReal (lam * P.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) <
+      ENNReal.ofReal (2 * 4 ^ ν) * volume (E ∩ N ⁻¹' (P.ω.toSet α) ∩ P.enl α j)) :
+    ∑ P ∈ A, P.vol α ≤ (2 : ℝ) ^ (((j + 2 : ℕ) : ℤ) * (absA α : ℤ)) * (2 * 4 ^ ν / lam) *
+      ((2 : ℝ) ^ j) ^ (1 - ν) * (volume E).toReal := by
+  classical
+  set B : Tile n → Set (Rn n × Rn n) := fun P => P.enl α j ×ˢ P.ω.toSet α
+  obtain ⟨u, hut, hud, hcov⟩ := Vitali.exists_disjoint_subfamily_covering_enlargement B
+    (A : Set (Tile n)) (fun P => (2 : ℝ) ^ P.k) (3 / 2) (by norm_num) (fun _ _ => by positivity)
+    (∑ P ∈ A, (2 : ℝ) ^ P.k) (fun a ha => Finset.single_le_sum (f := fun P => (2 : ℝ) ^ P.k)
+      (fun _ _ => by positivity) ha)
+    (fun a _ => ⟨(a.cI α, a.ω.center α), a.cI_mem_enl α j, DCube.center_mem α a.ω⟩)
+  choose! g hgu hgB hgδ using hcov
+  have hk : ∀ P ∈ A, P.k ≤ (g P).k := by
+    intro P hP
+    by_contra hlt
+    push Not at hlt
+    have h1 : (2 : ℝ) ^ ((g P).k + 1) ≤ 2 ^ P.k := zpow_le_zpow_right₀ (by norm_num) (by omega)
+    have h2 := hgδ P hP
+    rw [zpow_add₀ (by norm_num), zpow_one] at h1
+    have : (0 : ℝ) < 2 ^ (g P).k := by positivity
+    linarith
+  set U : Finset (Tile n) := ((A : Set (Tile n)).toFinite.subset hut).toFinset
+  have hgU : ∀ P ∈ A, g P ∈ U := fun P hP => by simpa [U] using hgu P hP
+  have hUu : ∀ b ∈ U, b ∈ u := fun b hb => by simpa [U] using hb
+  have hUA : ∀ b ∈ U, b ∈ A := fun b hb => hut (hUu b hb)
+  -- `ω_{g P} ⊆ ω_P`
+  have hω : ∀ P ∈ A, (g P).ω.toSet α ⊆ P.ω.toSet α := by
+    intro P hP
+    obtain ⟨z, ⟨-, hz1⟩, ⟨-, hz2⟩⟩ := hgB P hP
+    have hk' : (g P).ω.k ≤ P.ω.k := by simp [Tile.ω]; linarith [hk P hP]
+    rcases DCube.subset_or_disjoint α (g P).ω P.ω hk' with h | h
+    · exact h
+    · exact absurd hz1 (Set.disjoint_left.mp h hz2)
+  -- claim 1: `I_P ⊆ δ_{2^{j+2}} I_{g P}`
+  have hsub : ∀ P ∈ A, P.I.toSet α ⊆ (g P).enl α (j + 2) := by
+    intro P hP y hy i
+    obtain ⟨z, ⟨hz1, -⟩, ⟨hz2, -⟩⟩ := hgB P hP
+    have h1 := abs_sub_cI_le_of_mem_I α P hy i
+    have h2 := hz1 i
+    have h3 := hz2 i
+    have hkP := hk P hP
+    have s1 : side α P.k i ≤ side α ((g P).k + j) i := side_mono α (by omega) i
+    have s2 : side α (P.k + j) i ≤ side α ((g P).k + j) i := side_mono α (by omega) i
+    have s3 : 4 * side α ((g P).k + j) i ≤ side α ((g P).k + ((j + 2 : ℕ) : ℤ)) i := by
+      rw [show (g P).k + ((j + 2 : ℕ) : ℤ) = ((g P).k + j) + 2 by push_cast; ring, side_add α
+          ((g P).k + j) 2]
+      have h4 : (4 : ℝ) ≤ side α 2 i := by
+        unfold side
+        have := hα i
+        calc (4 : ℝ) = 2 ^ (2 : ℤ) := by norm_num
+          _ ≤ 2 ^ ((2 : ℤ) * (α i : ℤ)) := zpow_le_zpow_right₀ (by norm_num) (by omega)
+      nlinarith [side_pos α ((g P).k + j) i]
+    have t1 := abs_sub_le (y i) (z.1 i) ((g P).cI α i)
+    have t2 := abs_sub_le (y i) (P.cI α i) (z.1 i)
+    rw [abs_sub_comm (P.cI α i)] at t2
+    have hpos := side_pos α ((g P).k + j) i
+    change |y i - (g P).cI α i| < side α ((g P).k + ((j + 2 : ℕ) : ℤ)) i / 2
+    linarith
+  -- claim 2: tiles associated with the same selected tile have disjoint spatial cubes
+  have hdis : ∀ P ∈ A, ∀ Q ∈ A, P ≠ Q → g P = g Q →
+      Disjoint (P.I.toSet α) (Q.I.toSet α) := by
+    intro P hP Q hQ hPQ hg
+    rcases hdisj P hP Q hQ hPQ with h | h
+    · exact h
+    · exfalso
+      have hc := DCube.center_mem α (g P).ω
+      exact Set.disjoint_left.mp h (hω P hP hc) (hω Q hQ (hg ▸ hc))
+  -- the fibre sums
+  set K : ℝ := (2 : ℝ) ^ (((j + 2 : ℕ) : ℤ) * (absA α : ℤ))
+  have hK : 0 ≤ K := by positivity
+  have hfib : ∀ b ∈ U, ∑ P ∈ A with g P = b, P.vol α ≤ K * b.vol α := by
+    intro b hb
+    have hpd : ((A.filter fun P => g P = b : Finset (Tile n)) : Set (Tile n)).PairwiseDisjoint
+        (fun P => P.I.toSet α) := by
+      intro P hP Q hQ hPQ
+      simp only [Finset.coe_filter, Set.mem_ofPred_eq] at hP hQ
+      exact hdis P hP.1 Q hQ.1 hPQ (hP.2.trans hQ.2.symm)
+    have hmeas : volume (⋃ P ∈ A.filter fun P => g P = b, P.I.toSet α) =
+        ∑ P ∈ A with g P = b, volume (P.I.toSet α) :=
+      measure_biUnion_finset hpd fun P _ => DCube.measurableSet_toSet α P.I
+    have hle : volume (⋃ P ∈ A.filter fun P => g P = b, P.I.toSet α) ≤
+        volume (b.enl α (j + 2)) := by
+      refine measure_mono (Set.iUnion₂_subset fun P hP => ?_)
+      simp only [Finset.mem_filter] at hP
+      rw [← hP.2]
+      exact hsub P hP.1
+    rw [hmeas, Tile.volume_enl] at hle
+    simp_rw [Tile.volume_I] at hle
+    rw [← ENNReal.ofReal_sum_of_nonneg (fun P _ => (P.vol_pos α).le),
+      ENNReal.ofReal_le_ofReal_iff (by have := b.vol_pos α; positivity)] at hle
+    exact hle
+  -- the selected tiles
+  set mb : Tile n → ℝ := fun b => (volume (E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j)).toReal
+  have hsel : ∀ b ∈ U, b.vol α ≤ (2 * 4 ^ ν / lam) * ((2 : ℝ) ^ j) ^ (1 - ν) * mb b := by
+    intro b hb
+    have h := hA b (hUA b hb)
+    have hfin : volume (E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j) ≠ ⊤ :=
+      ne_top_of_le_ne_top hEfin.ne (measure_mono (fun x hx => hx.1.1))
+    rw [← ENNReal.ofReal_toReal hfin, ← ENNReal.ofReal_mul (by positivity),
+      ENNReal.ofReal_lt_ofReal_iff'] at h
+    replace h := h.1
+    have h2j : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
+    have hinv : ((2 : ℝ) ^ j) ^ (ν - 1) * ((2 : ℝ) ^ j) ^ (1 - ν) = 1 := by
+      rw [← Real.rpow_add h2j]; simp
+    have hpos : (0 : ℝ) < ((2 : ℝ) ^ j) ^ (1 - ν) := by positivity
+    calc b.vol α = (lam * b.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) * ((2 : ℝ) ^ j) ^ (1 - ν) / lam := by
+          field_simp
+          rw [mul_assoc, hinv, mul_one]
+      _ ≤ (2 * 4 ^ ν * mb b) * ((2 : ℝ) ^ j) ^ (1 - ν) / lam := by gcongr
+      _ = _ := by ring
+  have hEsum : ∑ b ∈ U, mb b ≤ (volume E).toReal := by
+    have hpd : (U : Set (Tile n)).PairwiseDisjoint
+        (fun b => E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j) := by
+      intro b hb b' hb' hbb'
+      refine Set.disjoint_left.mpr fun x hx hx' => ?_
+      have := hud (hUu b hb) (hUu b' hb') hbb'
+      exact Set.disjoint_left.mp this (show (x, N x) ∈ B b from ⟨hx.2, hx.1.2⟩)
+        (show (x, N x) ∈ B b' from ⟨hx'.2, hx'.1.2⟩)
+    have hm := measure_biUnion_finset (μ := volume) hpd fun b _ =>
+      (hE.inter (hN (DCube.measurableSet_toSet α b.ω))).inter (b.measurableSet_enl α j)
+    have hle : volume (⋃ b ∈ U, E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j) ≤ volume E :=
+      measure_mono (Set.iUnion₂_subset fun b _ x hx => hx.1.1)
+    rw [hm] at hle
+    have hfin : ∀ b ∈ U, volume (E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j) ≠ ⊤ := fun b _ =>
+      ne_top_of_le_ne_top hEfin.ne (measure_mono (fun x hx => hx.1.1))
+    calc ∑ b ∈ U, mb b = (∑ b ∈ U, volume (E ∩ N ⁻¹' (b.ω.toSet α) ∩ b.enl α j)).toReal :=
+          (ENNReal.toReal_sum hfin).symm
+      _ ≤ _ := ENNReal.toReal_mono hEfin.ne hle
+  set c' : ℝ := (2 * 4 ^ ν / lam) * ((2 : ℝ) ^ j) ^ (1 - ν)
+  have hc' : 0 ≤ c' := by positivity
+  calc ∑ P ∈ A, P.vol α = ∑ b ∈ U, ∑ P ∈ A with g P = b, P.vol α :=
+        (Finset.sum_fiberwise_of_maps_to hgU _).symm
+    _ ≤ ∑ b ∈ U, K * b.vol α := Finset.sum_le_sum hfib
+    _ ≤ ∑ b ∈ U, K * (c' * mb b) := Finset.sum_le_sum fun b hb => by gcongr; exact hsel b hb
+    _ = K * c' * ∑ b ∈ U, mb b := by rw [Finset.mul_sum]; congr 1; ext b; ring
+    _ ≤ K * c' * (volume E).toReal := by gcongr
+    _ = _ := by ring
+
+theorem scale_const_eq (a : ℕ) (ν : ℝ) (j : ℕ) :
+    (2 : ℝ) ^ (((j + 2 : ℕ) : ℤ) * (a : ℤ)) * ((2 : ℝ) ^ j) ^ (1 - ν) =
+      4 ^ a * ((2 : ℝ) ^ ((a : ℝ) + 1 - ν)) ^ j := by
+  rw [show (((j + 2 : ℕ) : ℤ) * (a : ℤ)) = ((2 * a + j * a : ℕ) : ℤ) by push_cast; ring,
+    zpow_natCast, pow_add, pow_mul, pow_mul', mul_assoc]
+  norm_num
+  rw [← pow_mul, mul_comm a j, pow_mul, ← Real.rpow_natCast ((2 : ℝ) ^ j) a,
+    ← Real.rpow_add (by positivity), ← Real.rpow_natCast (2 : ℝ) j, ← Real.rpow_mul (by norm_num),
+    ← Real.rpow_natCast ((2 : ℝ) ^ ((a : ℝ) + 1 - ν)) j, ← Real.rpow_mul (by norm_num)]
+  congr 1
+  ring
+
+/-- The mass lemma for pairwise disjoint heavy tiles (paper, §5, (5.2)): if the tiles of `A`
+are pairwise disjoint and `∫_{E_P} w^ν_P > λ` for each `P ∈ A`, then `∑_{P ∈ A} |I_P| ≤ C |E| / λ`,
+provided `ν > |α| + 1`. -/
+theorem sum_vol_le_of_heavy (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ}
+    (hν : (absA α : ℝ) + 1 < ν) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (A : Finset (Tile n)),
+      (∀ P ∈ A, ∀ Q ∈ A, P ≠ Q →
+        Disjoint (P.I.toSet α) (Q.I.toSet α) ∨ Disjoint (P.ω.toSet α) (Q.ω.toSet α)) →
+      ∀ (lam : ℝ), 0 < lam →
+      (∀ P ∈ A, ENNReal.ofReal lam <
+        ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (wP α ν P x)) →
+      ∑ P ∈ A, P.vol α ≤ C * (volume E).toReal / lam := by
+  classical
+  set r : ℝ := (2 : ℝ) ^ ((absA α : ℝ) + 1 - ν)
+  have hr0 : 0 < r := by positivity
+  have hr1 : r < 1 := Real.rpow_lt_one_of_one_lt_of_neg (by norm_num) (by linarith)
+  have hν0 : 0 ≤ ν := by have : (0 : ℝ) ≤ absA α := by positivity
+                         linarith
+  set D : ℝ := 4 ^ absA α * (2 * 4 ^ ν)
+  have hD : 0 < D := by positivity
+  refine ⟨D / (1 - r), div_pos hD (by linarith), ?_⟩
+  intro E hE hEfin N hN A hdisj lam hlam hA
+  have hex : ∀ P ∈ A, ∃ j : ℕ, ENNReal.ofReal (lam * P.vol α * ((2 : ℝ) ^ j) ^ (ν - 1)) <
+      ENNReal.ofReal (2 * 4 ^ ν) * volume (E ∩ N ⁻¹' (P.ω.toSet α) ∩ P.enl α j) :=
+    fun P hP => exists_scale_of_heavy α hα hν0 _ P hlam (hA P hP)
+  choose! jP hjP using hex
+  set J := A.image jP
+  have hEr : 0 ≤ (volume E).toReal := ENNReal.toReal_nonneg
+  have hj : ∀ j ∈ J, ∑ P ∈ A with jP P = j, P.vol α ≤ D * r ^ j * (volume E).toReal / lam := by
+    intro j _
+    have h := sum_vol_le_of_scale α hα hE hEfin hN (A.filter fun P => jP P = j)
+      (fun P hP Q hQ hPQ => hdisj P (Finset.mem_filter.mp hP).1 Q (Finset.mem_filter.mp hQ).1 hPQ)
+      hlam j (fun P hP => by
+        obtain ⟨hPA, hPj⟩ := Finset.mem_filter.mp hP
+        rw [← hPj]; exact hjP P hPA)
+    refine h.trans (le_of_eq ?_)
+    rw [show (2 : ℝ) ^ (((j + 2 : ℕ) : ℤ) * (absA α : ℤ)) * (2 * 4 ^ ν / lam) *
+        ((2 : ℝ) ^ j) ^ (1 - ν) * (volume E).toReal =
+        ((2 : ℝ) ^ (((j + 2 : ℕ) : ℤ) * (absA α : ℤ)) * ((2 : ℝ) ^ j) ^ (1 - ν)) *
+          (2 * 4 ^ ν) * (volume E).toReal / lam by ring, scale_const_eq]
+    simp only [D, r]
+    ring
+  calc ∑ P ∈ A, P.vol α = ∑ j ∈ J, ∑ P ∈ A with jP P = j, P.vol α :=
+        (Finset.sum_fiberwise_of_maps_to (fun P hP => Finset.mem_image_of_mem jP hP) _).symm
+    _ ≤ ∑ j ∈ J, D * r ^ j * (volume E).toReal / lam := Finset.sum_le_sum hj
+    _ = D * (volume E).toReal / lam * ∑ j ∈ J, r ^ j := by
+        rw [Finset.mul_sum]; congr 1; ext j; ring
+    _ ≤ D * (volume E).toReal / lam * ∑ j ∈ Finset.range (J.sup id + 1), r ^ j := by
+        refine mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg (fun j hj => ?_)
+          (fun _ _ _ => by positivity)) (by positivity)
+        exact Finset.mem_range.mpr (Nat.lt_succ_of_le (Finset.le_sup (f := id) hj))
+    _ ≤ D * (volume E).toReal / lam * (1 - r)⁻¹ :=
+        mul_le_mul_of_nonneg_left (by
+          rw [Finset.range_eq_Ico]
+          exact (geom_sum_Ico_le_of_lt_one hr0.le hr1).trans (le_of_eq (by simp [div_eq_mul_inv])))
+          (by positivity)
+    _ = D / (1 - r) * (volume E).toReal / lam := by ring
+
+/-- Every element of a finite set of tiles lies below a maximal element of the set. -/
+theorem Tile.exists_maximal_above (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    (Q : Finset (Tile n)) {q : Tile n} (hq : q ∈ Q) :
+    ∃ top ∈ Q, Tile.le α q top ∧ ∀ q' ∈ Q, Tile.le α top q' → q' = top := by
+  classical
+  obtain ⟨top, htop, hmax⟩ := Finset.exists_max_image (Q.filter fun q' => Tile.le α q q')
+    (fun P => P.k) ⟨q, Finset.mem_filter.mpr ⟨hq, Tile.le_refl α q⟩⟩
+  obtain ⟨htopQ, hqtop⟩ := Finset.mem_filter.mp htop
+  refine ⟨top, htopQ, hqtop, fun q' hq' hle => ?_⟩
+  have h1 := hmax q' (Finset.mem_filter.mpr ⟨hq', Tile.le_trans α hα hn hqtop hle⟩)
+  have h2 := DCube.k_le_of_subset α hα hn hle.1
+  exact (Tile.eq_of_le_of_k_eq α hle (_root_.le_antisymm h2 h1)).symm
+
+theorem Tile.disjoint_of_not_comparable (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {P Q : Tile n} (h : ¬ (Tile.le α P Q ∨ Tile.le α Q P)) :
+    Disjoint (P.I.toSet α) (Q.I.toSet α) ∨ Disjoint (P.ω.toSet α) (Q.ω.toSet α) := by
+  rw [Tile.comparable_iff_inter α hα hn, Set.not_nonempty_iff_eq_empty, Tile.toSet, Tile.toSet,
+    Set.prod_inter_prod, Set.prod_eq_empty_iff] at h
+  rcases h with h | h
+  · exact Or.inl (Set.disjoint_iff_inter_eq_empty.mpr h)
+  · exact Or.inr (Set.disjoint_iff_inter_eq_empty.mpr h)
+
+/-- **Mass lemma** (paper, Lemma 4.2, (4.5)–(4.6), proved in §5), threshold form: for
+`ν > |α| + 1` there is `C` such that for every finite set of tiles `S` and every `λ > 0`, the
+tiles `P ∈ S` with `𝓜(P) > λ` are covered by a finite family of trees `T ⊆ S` with
+`∑_T |I_T| ≤ C |E| / λ`. (The remaining tiles have mass `≤ λ`; the paper takes `λ = 𝓜(S)/4`
+and normalizes `|E| ≤ 1`.) -/
+theorem mass_lemma (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {ν : ℝ}
+    (hν : (absA α : ℝ) + 1 < ν) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (S : Finset (Tile n)) (lam : ℝ), 0 < lam →
+      ∃ 𝒯 : Finset (Tile n × Finset (Tile n)),
+        (∀ t ∈ 𝒯, IsTree α t.1 t.2 ∧ t.2 ⊆ S) ∧
+        (∀ P ∈ S, ENNReal.ofReal lam < massTile α ν E N P → ∃ t ∈ 𝒯, P ∈ t.2) ∧
+        ∑ t ∈ 𝒯, t.1.vol α ≤ C * (volume E).toReal / lam := by
+  classical
+  obtain ⟨C, hC, hsum⟩ := sum_vol_le_of_heavy α hα hν
+  refine ⟨C, hC, fun E hE hEfin N hN S lam hlam => ?_⟩
+  set H := S.filter fun P => ENNReal.ofReal lam < massTile α ν E N P
+  have hex : ∀ P ∈ H, ∃ P', Tile.le α P P' ∧ ENNReal.ofReal lam <
+      ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α), ENNReal.ofReal (wP α ν P' x) := by
+    intro P hP
+    have h := (Finset.mem_filter.mp hP).2
+    simp only [massTile, lt_iSup_iff] at h
+    obtain ⟨P', hle, h⟩ := h
+    exact ⟨P', hle, h⟩
+  choose! p hple hpint using hex
+  set Q := H.image p
+  set Q' := Q.filter fun top => ∀ q' ∈ Q, Tile.le α top q' → q' = top
+  set tr : Tile n → Tile n × Finset (Tile n) := fun top => (top, H.filter fun P => Tile.le α P top)
+  refine ⟨Q'.image tr, ?_, ?_, ?_⟩
+  · intro t ht
+    obtain ⟨top, -, rfl⟩ := Finset.mem_image.mp ht
+    refine ⟨fun P hP => (Finset.mem_filter.mp hP).2, fun P hP => ?_⟩
+    exact (Finset.mem_filter.mp (Finset.mem_filter.mp hP).1).1
+  · intro P hPS hPm
+    have hPH : P ∈ H := Finset.mem_filter.mpr ⟨hPS, hPm⟩
+    obtain ⟨top, htopQ, hle, hmax⟩ := Tile.exists_maximal_above α hα hn Q
+      (Finset.mem_image_of_mem p hPH)
+    refine ⟨tr top, Finset.mem_image_of_mem tr (Finset.mem_filter.mpr ⟨htopQ, hmax⟩), ?_⟩
+    exact Finset.mem_filter.mpr ⟨hPH, Tile.le_trans α hα hn (hple P hPH) hle⟩
+  · have hinj : Set.InjOn tr Q' := fun a _ b _ h => congrArg Prod.fst h
+    rw [Finset.sum_image hinj]
+    refine hsum E hE hEfin N hN Q' ?_ lam hlam ?_
+    · intro a ha b hb hab
+      obtain ⟨-, hamax⟩ := Finset.mem_filter.mp ha
+      obtain ⟨hbQ, hbmax⟩ := Finset.mem_filter.mp hb
+      refine Tile.disjoint_of_not_comparable α hα hn fun h => ?_
+      rcases h with h | h
+      · exact hab (hamax b hbQ h).symm
+      · exact hab (hbmax a (Finset.mem_filter.mp ha).1 h)
+    · intro a ha
+      obtain ⟨P, hPH, rfl⟩ := Finset.mem_image.mp (Finset.mem_filter.mp ha).1
+      exact hpint P hPH
+
+/-! ### Section 6: the energy lemma -/
+
+theorem finite_int_Icc_real (a b : ℝ) : {z : ℤ | a ≤ z ∧ (z : ℝ) ≤ b}.Finite := by
+  refine (Set.finite_Icc ⌈a⌉ ⌊b⌋).subset fun z hz => ?_
+  exact ⟨Int.ceil_le.mpr hz.1, Int.le_floor.mpr hz.2⟩
+
+theorem int_le_two_zpow (k : ℤ) : (k : ℝ) ≤ (2 : ℝ) ^ k := by
+  rcases le_or_gt 0 k with hk | hk
+  · obtain ⟨m, rfl⟩ := Int.eq_ofNat_of_zero_le hk
+    rw [zpow_natCast]
+    exact_mod_cast (Nat.lt_two_pow_self).le
+  · have : (0 : ℝ) < 2 ^ k := by positivity
+    have : (k : ℝ) < 0 := by exact_mod_cast hk
+    linarith
+
+/-- For fixed `P` and scale `k`, only finitely many tiles `P' ≥ P` have scale `k`. -/
+theorem finite_tops_above_k (α : Fin n → ℕ) (P : Tile n) (k : ℤ) :
+    {top : Tile n | top.k = k ∧ Tile.le α P top}.Finite := by
+  set a : Fin n → ℝ := fun i => P.cI α i / side α k i - 1
+  set b : Fin n → ℝ := fun i => P.cI α i / side α k i
+  set a' : Fin n → ℝ := fun i => side α (-P.k) i * P.u i / side α (-k) i - 1 / 2
+  set b' : Fin n → ℝ := fun i => side α (-P.k) i * (P.u i + 1) / side α (-k) i
+  have hfin : ((Set.pi Set.univ fun i => {z : ℤ | a i ≤ z ∧ (z : ℝ) ≤ b i}) ×ˢ
+      (Set.pi Set.univ fun i => {z : ℤ | a' i ≤ z ∧ (z : ℝ) ≤ b' i})).Finite :=
+    (Set.Finite.pi fun i => finite_int_Icc_real _ _).prod
+      (Set.Finite.pi fun i => finite_int_Icc_real _ _)
+  refine (hfin.image fun p => (⟨k, p.1, p.2⟩ : Tile n)).subset ?_
+  rintro top ⟨hk, hI, hω⟩
+  refine ⟨(top.ℓ, top.u), ⟨fun i _ => ?_, fun i _ => ?_⟩, by cases top; simp_all⟩
+  · have hc := hI (DCube.center_mem α P.I) i
+    have hs := side_pos α k i
+    simp only [Tile.I, hk, DCube.center, PiLp.toLp_apply] at hc
+    simp only [a, b, Tile.cI, PiLp.toLp_apply, Set.mem_ofPred_eq]
+    constructor
+    · rw [sub_le_iff_le_add, div_le_iff₀ hs]; nlinarith [hc.2]
+    · rw [le_div_iff₀ hs]; nlinarith [hc.1]
+  · have hc := hω i
+    have hs := side_pos α (-k) i
+    simp only [Tile.ω, Tile.cω, PiLp.toLp_apply, hk] at hc
+    simp only [a', b', Set.mem_ofPred_eq]
+    constructor
+    · rw [sub_le_iff_le_add, div_le_iff₀ hs]; nlinarith [hc.1]
+    · rw [le_div_iff₀ hs]; nlinarith [hc.2]
+
+/-- For a fixed tile `P` and `V`, only finitely many tiles `P' ≥ P` have `|I_{P'}| ≤ V`. -/
+theorem finite_tops_above (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (P : Tile n)
+    (V : ℝ) : {top : Tile n | Tile.le α P top ∧ top.vol α ≤ V}.Finite := by
+  have hA : 1 ≤ absA α := absA_pos α hα hn
+  have hk : ∀ top : Tile n, Tile.le α P top → top.vol α ≤ V →
+      top.k ∈ Set.Icc P.k ⌊V⌋ := by
+    intro top hle hV
+    refine ⟨DCube.k_le_of_subset α hα hn hle.1, Int.le_floor.mpr ?_⟩
+    have hv := top.vol_pos α
+    rcases le_or_gt top.k 0 with h0 | h0
+    · have : (top.k : ℝ) ≤ 0 := by exact_mod_cast h0
+      linarith
+    · refine (int_le_two_zpow top.k).trans (le_trans ?_ hV)
+      exact zpow_le_zpow_right₀ (by norm_num) (le_mul_of_one_le_right h0.le (by exact_mod_cast hA))
+  refine ((Set.finite_Icc P.k ⌊V⌋).biUnion fun k _ => finite_tops_above_k α P k).subset ?_
+  intro top ⟨hle, hV⟩
+  exact Set.mem_biUnion (hk top hle hV) ⟨rfl, hle⟩
+
+noncomputable instance Tile.decLe (α : Fin n → ℕ) (P Q : Tile n) : Decidable (Tile.le α P Q) :=
+  Classical.dec _
+
+/-- The greedy tree selection (paper, §6, steps (1)–(4), texline~487–499), in abstract form:
+repeatedly choose a candidate `(top, T)` for the current stock minimizing `key top`, and remove
+all tiles `P ≤ top` from the stock, until no candidate is left. -/
+theorem greedy_selection (α : Fin n → ℕ) (cand : Finset (Tile n) → Set (Tile n × Finset (Tile n)))
+    (hcand : ∀ s, ∀ p ∈ cand s, p.2 ⊆ s ∧ p.2.Nonempty ∧ IsTree α p.1 p.2)
+    (hfin : ∀ s, (cand s).Finite) (key : Tile n → ℝ) (S : Finset (Tile n)) :
+    ∃ (m : ℕ) (sel : ℕ → Tile n × Finset (Tile n)) (st : ℕ → Finset (Tile n)),
+      st 0 = S ∧
+      (∀ i < m, sel i ∈ cand (st i) ∧ (∀ p ∈ cand (st i), key (sel i).1 ≤ key p.1) ∧
+        st (i + 1) = (st i).filter (fun P => ¬ Tile.le α P (sel i).1)) ∧
+      cand (st m) = ∅ := by
+  classical
+  induction h : S.card using Nat.strong_induction_on generalizing S with
+  | _ c ih =>
+  by_cases hne : (cand S).Nonempty
+  · obtain ⟨p0, hp0, hmin⟩ := Set.exists_min_image (cand S) (fun p => key p.1) (hfin S) hne
+    set S' := S.filter fun P => ¬ Tile.le α P p0.1
+    obtain ⟨hsub, ⟨x, hx⟩, htree⟩ := hcand S p0 hp0
+    have hcard : S'.card < c := by
+      rw [← h]
+      refine Finset.card_lt_card (Finset.filter_ssubset.mpr ⟨x, hsub hx, ?_⟩)
+      simpa using htree x hx
+    obtain ⟨m', sel', st', h0, hstep, hend⟩ := ih S'.card hcard S' rfl
+    refine ⟨m' + 1, fun i => if i = 0 then p0 else sel' (i - 1),
+      fun i => if i = 0 then S else st' (i - 1), by simp, fun i hi => ?_, by simpa using hend⟩
+    rcases Nat.eq_zero_or_pos i with rfl | hpos
+    · simp only [↓reduceIte, Nat.zero_add, one_ne_zero, Nat.sub_self, h0]
+      exact ⟨hp0, fun p hp => hmin p hp, rfl⟩
+    · obtain ⟨j, rfl⟩ : ∃ j, i = j + 1 := ⟨i - 1, by omega⟩
+      have := hstep j (by omega)
+      simpa using this
+  · refine ⟨0, fun _ => (⟨0, 0, 0⟩, ∅), fun _ => S, rfl, fun i hi => absurd hi (by omega), ?_⟩
+    exact Set.not_nonempty_iff_eq_empty.mp hne
+
+/-- The half-open lower semi-tile `[δ_{2^{-k}}(u), δ_{2^{-k}}(u + 1/2))`. -/
+def Tile.semiHO0 (α : Fin n → ℕ) (P : Tile n) : Set (Rn n) :=
+  {ξ | ∀ i, side α (-P.k) i * P.u i ≤ ξ i ∧ ξ i < side α (-P.k) i * (P.u i + 1 / 2)}
+
+theorem Tile.semiHO0_subset (α : Fin n → ℕ) (P : Tile n) : P.semiHO0 α ⊆ P.ω.toSet α := by
+  intro ξ hξ i
+  have hs := side_pos α (-P.k) i
+  refine ⟨(hξ i).1, (hξ i).2.trans ?_⟩
+  simp only [Tile.ω]
+  nlinarith
+
+/-- The separation property (6.1) (paper, texline~482): if `r_{i₀} = 1`, then
+`ξ_{i₀} < η_{i₀}` for `ξ` in the (half-open) lower semi-tile and `η ∈ ω_{P(r)}`. -/
+theorem lt_of_mem_semiHO0_of_mem_semi (α : Fin n → ℕ) (P : Tile n) {r : Fin n → Fin 2}
+    {i₀ : Fin n} (hr : r i₀ = 1) {ξ η : Rn n} (hξ : ξ ∈ P.semiHO0 α) (hη : η ∈ P.semi α r) :
+    ξ i₀ < η i₀ := by
+  have h1 := (hξ i₀).2
+  have h2 := (hη i₀).1
+  rw [hr] at h2
+  simp only [Fin.isValue, Fin.val_one, Nat.cast_one] at h2
+  linarith
+
+/-- The candidates of the energy selection: `2`-trees `T ⊆ s` (with arbitrary top) whose energy
+density exceeds `λ²`. -/
+def energyCand (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ) (lam : ℝ)
+    (s : Finset (Tile n)) : Set (Tile n × Finset (Tile n)) :=
+  {p | p.2 ⊆ s ∧ Is2Tree α r p.1 p.2 ∧
+    lam ^ 2 * p.1.vol α < ∑ P ∈ p.2, ‖pairing f (wavePhi α P)‖ ^ 2}
+
+theorem energyCand_mono (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ) (lam : ℝ)
+    {s s' : Finset (Tile n)} (h : s ⊆ s') : energyCand α r f lam s ⊆ energyCand α r f lam s' :=
+  fun _ hp => ⟨hp.1.trans h, hp.2⟩
+
+theorem energyCand_finite (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (r : Fin n → Fin 2)
+    (f : Rn n → ℂ) {lam : ℝ} (hlam : 0 < lam) (s : Finset (Tile n)) :
+    (energyCand α r f lam s).Finite := by
+  classical
+  set V := (∑ P ∈ s, ‖pairing f (wavePhi α P)‖ ^ 2) / lam ^ 2
+  refine (((s.finite_toSet.biUnion fun P _ => finite_tops_above α hα hn P V)).prod
+    (s.powerset.finite_toSet)).subset ?_
+  rintro ⟨top, T⟩ ⟨hTs, ⟨htree, -⟩, hlt⟩
+  have hsum : ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ ^ 2 ≤ ∑ P ∈ s, ‖pairing f (wavePhi α P)‖ ^ 2 :=
+    Finset.sum_le_sum_of_subset_of_nonneg hTs fun _ _ _ => by positivity
+  obtain ⟨P, hP⟩ : T.Nonempty := by
+    by_contra hT
+    rw [Finset.not_nonempty_iff_eq_empty] at hT
+    subst hT
+    have := top.vol_pos α
+    simp at hlt
+    nlinarith
+  refine ⟨Set.mem_biUnion (hTs hP) ⟨htree P hP, ?_⟩, by simpa using hTs⟩
+  simp only [V]
+  rw [le_div_iff₀ (by positivity)]
+  nlinarith
+
+theorem energy_le_of_energyCand_eq_empty (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ)
+    {lam : ℝ} (hlam : 0 < lam) {s : Finset (Tile n)} (h : energyCand α r f lam s = ∅) :
+    energy α r f s ≤ ENNReal.ofReal lam := by
+  refine iSup₂_le fun top T => iSup₂_le fun hTs h2 => ENNReal.ofReal_le_ofReal ?_
+  have hnot : (top, T) ∉ energyCand α r f lam s := by rw [h]; exact id
+  simp only [energyCand, Set.mem_ofPred_eq, not_and, not_lt] at hnot
+  have hle := hnot hTs h2
+  have hv := top.vol_pos α
+  rw [Real.sqrt_le_left hlam.le]
+  rw [inv_mul_le_iff₀ hv]
+  linarith
+
+/-- Lemma 6.1 (paper, texline~505–510) for the output of the greedy selection. -/
+theorem selection_disjoint (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} {i₀ : Fin n} (hr : r i₀ = 1)
+    (cand : Finset (Tile n) → Set (Tile n × Finset (Tile n)))
+    (hcand : ∀ s, ∀ p ∈ cand s, p.2 ⊆ s ∧ Is2Tree α r p.1 p.2)
+    (hmono : ∀ s s', s ⊆ s' → cand s ⊆ cand s')
+    {m : ℕ} {sel : ℕ → Tile n × Finset (Tile n)} {st : ℕ → Finset (Tile n)}
+    (hstep : ∀ i < m, sel i ∈ cand (st i) ∧
+      (∀ p ∈ cand (st i), (sel i).1.cω α i₀ ≤ p.1.cω α i₀) ∧
+      st (i + 1) = (st i).filter (fun P => ¬ Tile.le α P (sel i).1))
+    {i j : ℕ} (hi : i < m) (hj : j < m) (hij : i ≠ j) {P P' : Tile n} (hP : P ∈ (sel i).2)
+    (hP' : P' ∈ (sel j).2) (hω : P.ω.toSet α ⊆ P'.semiHO0 α) :
+    Disjoint (P'.I.toSet α) ((sel i).1.I.toSet α) := by
+  classical
+  have hanti : ∀ a b, a ≤ b → b ≤ m → st b ⊆ st a := by
+    intro a b hab hbm
+    induction b, hab using Nat.le_induction with
+    | base => exact subset_rfl
+    | succ b hab ih =>
+      rw [(hstep b (by omega)).2.2]
+      exact (Finset.filter_subset _ _).trans (ih (by omega))
+  obtain ⟨hseli, hmini, -⟩ := hstep i hi
+  obtain ⟨hselj, hminj, -⟩ := hstep j hj
+  obtain ⟨hTi, htreei, h2i⟩ := hcand _ _ hseli
+  obtain ⟨hTj, htreej, h2j⟩ := hcand _ _ hselj
+  have hcP : (sel i).1.cω α ∈ P.ω.toSet α := (htreei P hP).2
+  have hlt : (sel i).1.cω α i₀ < (sel j).1.cω α i₀ :=
+    lt_of_mem_semiHO0_of_mem_semi α P' hr (hω hcP) (h2j P' hP')
+  rcases lt_or_gt_of_ne hij with hij' | hij'
+  · -- `T₂` was chosen before `T₂'`
+    have hP'st : P' ∈ st (i + 1) := hanti (i + 1) j (by omega) hj.le (hTj hP')
+    rw [(hstep i hi).2.2, Finset.mem_filter] at hP'st
+    refine Set.disjoint_left.mpr fun x hx hx' => hP'st.2 ⟨?_, ?_⟩
+    · have hkP : P'.k ≤ P.k := by
+        have := DCube.k_le_of_subset α hα hn (hω.trans (Tile.semiHO0_subset α P'))
+        simp [Tile.ω] at this; omega
+      have hk : P'.I.k ≤ (sel i).1.I.k := by
+        have := DCube.k_le_of_subset α hα hn (htreei P hP).1
+        simp only [Tile.I] at this ⊢; omega
+      rcases DCube.subset_or_disjoint α P'.I (sel i).1.I hk with h | h
+      · exact h
+      · exact absurd hx' (Set.disjoint_left.mp h hx)
+    · exact Tile.semiHO0_subset α P' (hω hcP)
+  · exfalso
+    have hcand' : sel i ∈ cand (st j) :=
+      hmono _ _ (hanti j i hij'.le hi.le) (hmono _ _ subset_rfl hseli)
+    have := hminj _ hcand'
+    linarith
+
+theorem side_neg_eq_mul (α : Fin n → ℕ) {k k' : ℤ} (h : k' < k) (i : Fin n) (hαi : 1 ≤ α i) :
+    ∃ d : ℕ, 1 ≤ d ∧ side α (-k') i = side α (-k) i * 2 ^ d := by
+  refine ⟨((k - k') * α i).toNat, ?_, ?_⟩
+  · have : 1 ≤ (k - k') * (α i : ℤ) := by nlinarith
+    omega
+  · unfold side
+    rw [← zpow_natCast, ← zpow_add₀ (by norm_num)]
+    congr 1
+    have : 0 ≤ (k - k') * (α i : ℤ) := by nlinarith
+    rw [Int.toNat_of_nonneg this]
+    ring
+
+/-- Grid property for general half-open semi-tiles: a strictly finer frequency cube meeting
+`ω_{P'(r)}` is contained in it. -/
+theorem ω_subset_semiHO (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {P P' : Tile n} (hk : P'.k < P.k)
+    (r : Fin n → Fin 2) {ξ : Rn n} (hξ : ξ ∈ P.ω.toSet α) (hξ' : ξ ∈ P'.semiHO α r) :
+    P.ω.toSet α ⊆ P'.semiHO α r := by
+  intro η hη i
+  obtain ⟨d, hd, hs⟩ := side_neg_eq_mul α hk i (hα i)
+  set s := side α (-P.k) i
+  have hs0 : 0 < s := side_pos α _ i
+  have h1 := hξ i
+  have h2 := hξ' i
+  have h3 := hη i
+  simp only [Tile.ω] at h1 h3
+  rw [hs] at h2 ⊢
+  obtain ⟨e, rfl⟩ : ∃ e, d = e + 1 := ⟨d - 1, by omega⟩
+  set rv : ℤ := ((r i : ℕ) : ℤ)
+  have hrv : ((r i : ℕ) : ℝ) = (rv : ℝ) := by simp [rv]
+  set A : ℤ := 2 ^ (e + 1) * P'.u i + 2 ^ e * rv
+  set B : ℤ := 2 ^ (e + 1) * P'.u i + 2 ^ e * (rv + 1)
+  have eA : s * 2 ^ (e + 1) * (P'.u i + ((r i : ℕ) : ℝ) / 2) = s * (A : ℝ) := by
+    simp only [A]; rw [hrv]; push_cast; rw [pow_succ]; ring
+  have eB : s * 2 ^ (e + 1) * (P'.u i + (((r i : ℕ) : ℝ) + 1) / 2) = s * (B : ℝ) := by
+    simp only [B]; rw [hrv]; push_cast; rw [pow_succ]; ring
+  have h2' : s * (A : ℝ) ≤ ξ i ∧ ξ i < s * (B : ℝ) := by
+    rw [← eA, ← eB]; exact h2
+  have hAu : A ≤ P.u i := by
+    have : (A : ℝ) < P.u i + 1 := by
+      have : s * (A : ℝ) < s * (P.u i + 1) := by linarith [h2'.1, h1.2]
+      exact lt_of_mul_lt_mul_left this hs0.le
+    exact Int.lt_add_one_iff.mp (by exact_mod_cast this)
+  have huB : P.u i + 1 ≤ B := by
+    have : (P.u i : ℝ) < B := by
+      have : s * (P.u i : ℝ) < s * B := by linarith [h1.1, h2'.2]
+      exact lt_of_mul_lt_mul_left this hs0.le
+    exact Int.add_one_le_iff.mpr (by exact_mod_cast this)
+  have hAu' : (A : ℝ) ≤ P.u i := by exact_mod_cast hAu
+  have huB' : (P.u i : ℝ) + 1 ≤ B := by exact_mod_cast huB
+  rw [eA, eB]
+  constructor
+  · nlinarith [h3.1]
+  · nlinarith [h3.2]
+
+/-- Grid property: a strictly finer frequency cube meeting the half-open lower semi-tile of `P'`
+is contained in it. -/
+theorem ω_subset_semiHO0 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {P P' : Tile n} (hk : P'.k < P.k)
+    {ξ : Rn n} (hξ : ξ ∈ P.ω.toSet α) (hξ' : ξ ∈ P'.semiHO0 α) :
+    P.ω.toSet α ⊆ P'.semiHO0 α := by
+  simpa [Tile.semiHO0, Tile.semiHO] using
+    (ω_subset_semiHO α hα hk 0 hξ (by
+      simpa [Tile.semiHO0, Tile.semiHO] using hξ'))
+
+theorem suppBox_subset_semiHO0 (α : Fin n → ℕ) (P : Tile n) : suppBox α P ⊆ P.semiHO0 α := by
+  intro ξ hξ i
+  have h := hξ i
+  have hs := side_pos α (-P.k) i
+  rw [abs_lt] at h
+  simp only [Tile.cω0, PiLp.toLp_apply, b0] at h
+  constructor <;> nlinarith [h.1, h.2]
+
+theorem mem_suppBox_of_fhat_wavePhi_ne_zero (α : Fin n → ℕ) (P : Tile n) {ξ : Rn n}
+    (h : fhat (wavePhi α P) ξ ≠ 0) : ξ ∈ suppBox α P := fun i =>
+  abs_sub_cω0_lt_of_fhat_wavePhi_ne_zero α P h i
+
+/-- Orthogonality of wave packets (paper, texline~533): `⟨φ_P, φ_{P'}⟩ = 0` unless `ω_P = ω_{P'}`,
+or `ω_P ⊆ ω_{P'(0)}` with `k_{P'} < k_P`, or vice versa. -/
+theorem pairing_wavePhi_eq_zero_or (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P P' : Tile n)
+    (h : pairing (wavePhi α P) (wavePhi α P') ≠ 0) :
+    P.ω = P'.ω ∨ (P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α) ∨
+      (P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α) := by
+  rw [pairing_eq_fhat (integrable_wavePhi α hα P) (continuous_wavePhi α P')
+    (integrable_wavePhi α hα P') (integrable_fhat_wavePhi α P')] at h
+  obtain ⟨ξ, hξ⟩ : ∃ ξ, fhat (wavePhi α P) ξ * (starRingEnd ℂ) (fhat (wavePhi α P') ξ) ≠ 0 := by
+    by_contra hall
+    push Not at hall
+    apply h
+    simp [hall]
+  have h1 : fhat (wavePhi α P) ξ ≠ 0 := left_ne_zero_of_mul hξ
+  have h2 : fhat (wavePhi α P') ξ ≠ 0 := by
+    have := right_ne_zero_of_mul hξ
+    simpa using this
+  have hs1 := suppBox_subset_semiHO0 α P (mem_suppBox_of_fhat_wavePhi_ne_zero α P h1)
+  have hs2 := suppBox_subset_semiHO0 α P' (mem_suppBox_of_fhat_wavePhi_ne_zero α P' h2)
+  rcases lt_trichotomy P.k P'.k with hk | hk | hk
+  · exact Or.inr (Or.inr ⟨hk, ω_subset_semiHO0 α hα hk (Tile.semiHO0_subset α P' hs2) hs1⟩)
+  · left
+    exact DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) (Tile.semiHO0_subset α P hs1)
+      (Tile.semiHO0_subset α P' hs2)
+  · exact Or.inr (Or.inl ⟨hk, ω_subset_semiHO0 α hα hk (Tile.semiHO0_subset α P hs1) hs2⟩)
+
+theorem memLp_wavePhi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P : Tile n) :
+    MemLp (wavePhi α P) 2 := by
+  obtain ⟨C, hC, h⟩ := wavePhi_decay α hα 0
+  set B : ℝ := C * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)
+  have hB : ∀ x, ‖wavePhi α P x‖ ≤ B := fun x => by simpa [B] using h P x
+  have hcont := continuous_wavePhi α P
+  rw [memLp_two_iff_integrable_sq_norm hcont.aestronglyMeasurable]
+  refine ((integrable_wavePhi α hα P).norm.const_mul B).mono'
+    (hcont.norm.pow 2).aestronglyMeasurable (Filter.Eventually.of_forall fun x => ?_)
+  rw [Real.norm_eq_abs, abs_of_nonneg (by positivity), sq]
+  exact mul_le_mul_of_nonneg_right (hB x) (norm_nonneg _)
+
+theorem integrable_mul_conj_of_memLp {f g : Rn n → ℂ} (hf : MemLp f 2) (hg : MemLp g 2) :
+    Integrable (fun x => f x * (starRingEnd ℂ) (g x)) := by
+  have hg' : MemLp (fun x => (starRingEnd ℂ) (g x)) 2 :=
+    hg.congr_norm (Complex.continuous_conj.comp_aestronglyMeasurable hg.aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun x => by simp)
+  exact hf.integrable_mul hg'
+
+/-- Expansion of `‖∑ c_P φ_P‖₂²` into pairings. -/
+theorem integral_norm_sq_sum_wavePhi_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i)
+    (U : Finset (Tile n)) (c : Tile n → ℂ) :
+    ∫ x, ‖∑ P ∈ U, c P * wavePhi α P x‖ ^ 2 ≤
+      ∑ P ∈ U, ∑ P' ∈ U, ‖c P‖ * ‖c P'‖ * ‖pairing (wavePhi α P) (wavePhi α P')‖ := by
+  set g : Rn n → ℂ := fun x => ∑ P ∈ U, c P * wavePhi α P x
+  have hφ := memLp_wavePhi α hα
+  have hint : ∀ P P', Integrable (fun x => c P' * wavePhi α P' x *
+      ((starRingEnd ℂ) (c P) * (starRingEnd ℂ) (wavePhi α P x))) := by
+    intro P P'
+    have := (integrable_mul_conj_of_memLp (hφ P') (hφ P)).const_mul (c P' * (starRingEnd ℂ) (c P))
+    refine this.congr (Filter.Eventually.of_forall fun x => ?_)
+    simp only; ring
+  have hgg : ∫ x, g x * (starRingEnd ℂ) (g x) = ∑ P ∈ U, ∑ P' ∈ U,
+      c P' * (starRingEnd ℂ) (c P) * pairing (wavePhi α P') (wavePhi α P) := by
+    simp only [g, map_sum, map_mul, Finset.sum_mul, Finset.mul_sum]
+    rw [integral_finsetSum _ fun P _ => integrable_finsetSum _ fun P' _ => hint P P']
+    refine Finset.sum_congr rfl fun P _ => ?_
+    rw [integral_finsetSum _ fun P' _ => hint P P']
+    refine Finset.sum_congr rfl fun P' _ => ?_
+    have e : (fun x => c P' * wavePhi α P' x * ((starRingEnd ℂ) (c P) *
+        (starRingEnd ℂ) (wavePhi α P x))) = fun x => c P' * (starRingEnd ℂ) (c P) *
+        (wavePhi α P' x * (starRingEnd ℂ) (wavePhi α P x)) := by
+      ext x; ring
+    rw [e, integral_const_mul]
+    rfl
+  have hre : ∫ x, ‖g x‖ ^ 2 = (∫ x, g x * (starRingEnd ℂ) (g x)).re := by
+    have : ∀ x, g x * (starRingEnd ℂ) (g x) = ((‖g x‖ ^ 2 : ℝ) : ℂ) := by
+      intro x
+      rw [Complex.mul_conj, Complex.normSq_eq_norm_sq];
+    simp_rw [this]
+    rw [integral_complex_ofReal, Complex.ofReal_re]
+  rw [hre, hgg, Finset.sum_comm (s := U) (t := U)]
+  refine (Complex.re_le_norm _).trans ((norm_sum_le _ _).trans (Finset.sum_le_sum fun P _ =>
+    (norm_sum_le _ _).trans (Finset.sum_le_sum fun P' _ => le_of_eq ?_)))
+  rw [norm_mul, norm_mul, RCLike.norm_conj]
+
+/-- A Bessel-type inequality for wave packets (paper, (6.4)–(6.7), texline~511–532):
+`∑_{P ∈ U} |⟨f, φ_P⟩|² ≤ ‖f‖₂ (∑_{P, P' ∈ U} |⟨f,φ_P⟩| |⟨f,φ_{P'}⟩| |⟨φ_P, φ_{P'}⟩|)^{1/2}`. -/
+theorem bessel_wavePhi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {f : Rn n → ℂ} (hf : MemLp f 2)
+    (U : Finset (Tile n)) :
+    ∑ P ∈ U, ‖pairing f (wavePhi α P)‖ ^ 2 ≤ (eLpNorm f 2 volume).toReal *
+      Real.sqrt (∑ P ∈ U, ∑ P' ∈ U, ‖pairing f (wavePhi α P)‖ * ‖pairing f (wavePhi α P')‖ *
+        ‖pairing (wavePhi α P) (wavePhi α P')‖) := by
+  set a : Tile n → ℂ := fun P => pairing f (wavePhi α P)
+  set g : Rn n → ℂ := fun x => ∑ P ∈ U, a P * wavePhi α P x
+  have hφ := memLp_wavePhi α hα
+  have hg : MemLp g 2 := memLp_finsetSum U fun P _ => (hφ P).const_mul (a P)
+  -- step 1: `∑ |a_P|² = ⟨f, g⟩`
+  have h1 : pairing f g = ∑ P ∈ U, (starRingEnd ℂ) (a P) * a P := by
+    unfold pairing
+    simp only [g, map_sum, map_mul, Finset.mul_sum]
+    rw [integral_finsetSum _ fun P _ => ?_]
+    · refine Finset.sum_congr rfl fun P _ => ?_
+      calc _ = ∫ x, (starRingEnd ℂ) (a P) * (f x * (starRingEnd ℂ) (wavePhi α P x)) := by
+            congr 1; ext x; ring
+        _ = _ := by rw [integral_const_mul]; rfl
+    · have := (integrable_mul_conj_of_memLp hf (hφ P)).const_mul ((starRingEnd ℂ) (a P))
+      refine this.congr (Filter.Eventually.of_forall fun x => ?_)
+      simp only; ring
+  have h2 : ∑ P ∈ U, ‖a P‖ ^ 2 = ‖pairing f g‖ := by
+    rw [h1]
+    have : ∑ P ∈ U, (starRingEnd ℂ) (a P) * a P = ((∑ P ∈ U, ‖a P‖ ^ 2 : ℝ) : ℂ) := by
+      push_cast
+      refine Finset.sum_congr rfl fun P _ => ?_
+      rw [mul_comm, Complex.mul_conj, Complex.normSq_eq_norm_sq]; push_cast; ring
+    rw [this, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (by positivity)]
+  -- step 2: Cauchy–Schwarz
+  have hfn : MemLp (fun x => ‖f x‖) (ENNReal.ofReal 2) := by simpa using hf.norm
+  have hgn : MemLp (fun x => ‖g x‖) (ENNReal.ofReal 2) := by simpa using hg.norm
+  have hCS := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two
+    (Filter.Eventually.of_forall fun x => norm_nonneg (f x))
+    (Filter.Eventually.of_forall fun x => norm_nonneg (g x)) hfn hgn
+  have hnormf : (eLpNorm f 2 volume).toReal = (∫ x, ‖f x‖ ^ (2 : ℝ)) ^ (1 / (2 : ℝ)) := by
+    rw [hf.eLpNorm_eq_integral_rpow_norm (by norm_num) (by norm_num), ENNReal.toReal_ofReal
+      (by positivity)]
+    norm_num
+  have h3 : ‖pairing f g‖ ≤ (eLpNorm f 2 volume).toReal *
+      (∫ x, ‖g x‖ ^ (2 : ℝ)) ^ (1 / (2 : ℝ)) := by
+    rw [hnormf]
+    refine le_trans (norm_integral_le_integral_norm _) (le_trans (le_of_eq ?_) hCS)
+    congr 1; ext x; simp
+  have h4 : ∫ x, ‖g x‖ ^ (2 : ℝ) ≤ ∑ P ∈ U, ∑ P' ∈ U, ‖a P‖ * ‖a P'‖ *
+      ‖pairing (wavePhi α P) (wavePhi α P')‖ := by
+    simpa only [g, Real.rpow_two] using integral_norm_sq_sum_wavePhi_le α hα U a
+  rw [h2]
+  refine h3.trans (mul_le_mul_of_nonneg_left ?_ ENNReal.toReal_nonneg)
+  rw [← Real.sqrt_eq_rpow]
+  exact Real.sqrt_le_sqrt h4
+
+deriving instance DecidableEq for DCube
+
+theorem norm_pairing_comm (g h : Rn n → ℂ) : ‖pairing g h‖ = ‖pairing h g‖ := by
+  unfold pairing
+  rw [← RCLike.norm_conj, ← integral_conj]
+  congr 2; ext x; simp [mul_comm]
+
+theorem inv_mul_rho_cI_sub_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {P P' : Tile n}
+    (hk : P.k = P'.k) :
+    ((2 : ℝ) ^ P.k)⁻¹ * rho α (P.cI α - P'.cI α) = rho α (latticePt P.ℓ - latticePt P'.ℓ) := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  rw [← rho_dil α hα (inv_pos.mpr ht)]
+  congr 1
+  ext i
+  simp only [dil_apply, PiLp.sub_apply, Tile.cI, latticePt_apply, side, ← hk]
+  rw [show ((2 : ℝ) ^ P.k)⁻¹ ^ α i = ((2 : ℝ) ^ (P.k * (α i : ℤ)))⁻¹ by
+    rw [inv_pow, ← zpow_natCast, ← zpow_mul]]
+  field_simp
+  ring
+
+/-- The diagonal part of (6.7) (paper, (6.8)–(6.9), texline~533–544): pairs of tiles with the
+same frequency cube contribute at most `C ∑_P |a_P|²`. -/
+theorem diag_sum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (U : Finset (Tile n)) (a : Tile n → ℝ), (∀ P, 0 ≤ a P) →
+      ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then a P * a P' *
+        ‖pairing (wavePhi α P) (wavePhi α P')‖ else 0) ≤ C * ∑ P ∈ U, a P ^ 2 := by
+  classical
+  set ν : ℕ := absA α + 1
+  have hν : (absA α : ℝ) < (ν : ℝ) := by simp [ν]
+  obtain ⟨C0, hC0, hint⟩ := tile_interaction α hα ν
+  obtain ⟨-, hsum⟩ := summable_wgt_lattice α hα hν 0
+  set W := 2 ^ (ν : ℝ) * ∫ w : Rn n, (1 + rho α w) ^ (-(ν : ℝ))
+  have hW : 0 ≤ W := by
+    have : 0 ≤ ∫ w : Rn n, (1 + rho α w) ^ (-(ν : ℝ)) := integral_nonneg fun w => by
+      have := rho_nonneg α w; positivity
+    positivity
+  refine ⟨C0 * W, by positivity, fun U a ha => ?_⟩
+  set t : Tile n → Tile n → ℝ := fun P P' => ‖pairing (wavePhi α P) (wavePhi α P')‖
+  have ht : ∀ P P', t P P' = t P' P := fun P P' => norm_pairing_comm _ _
+  -- the inner sums are bounded
+  have hinner : ∀ P, ∑ P' ∈ U, (if P.ω = P'.ω then t P P' else 0) ≤ C0 * W := by
+    intro P
+    set F := U.filter fun P' => P.ω = P'.ω
+    have hF : ∀ P' ∈ F, P'.k = P.k ∧ P'.u = P.u := by
+      intro P' hP'
+      have h := (Finset.mem_filter.mp hP').2
+      have hk : P.k = P'.k := neg_inj.mp (congrArg DCube.k h)
+      have hu : P.u = P'.u := congrArg DCube.ℓ h
+      exact ⟨hk.symm, hu.symm⟩
+    have hbound : ∀ P' ∈ F, t P P' ≤
+        C0 * (1 + rho α (latticePt P.ℓ - latticePt P'.ℓ)) ^ (-(ν : ℝ)) := by
+      intro P' hP'
+      obtain ⟨hk, -⟩ := hF P' hP'
+      have h := hint P P' hk.le
+      rw [inv_mul_rho_cI_sub_eq α hα hk.symm] at h
+      have htt : ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) =
+          1 := by
+        rw [hk, ← Real.rpow_add (by positivity),
+          show -(absA α : ℝ) / 2 + (absA α : ℝ) / 2 = 0 by ring, Real.rpow_zero]
+      calc t P P' ≤ _ := h
+        _ = C0 * (((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2)) *
+            (1 + rho α (latticePt P.ℓ - latticePt P'.ℓ)) ^ (-(ν : ℝ)) := by ring
+        _ = _ := by rw [htt, mul_one]
+    have hinj : Set.InjOn (fun P' : Tile n => P'.ℓ) F := by
+      intro P₁ h₁ P₂ h₂ hℓ
+      obtain ⟨hk₁, hu₁⟩ := hF P₁ h₁
+      obtain ⟨hk₂, hu₂⟩ := hF P₂ h₂
+      exact Tile.ext (hk₁.trans hk₂.symm) hℓ (hu₁.trans hu₂.symm)
+    rw [← Finset.sum_filter]
+    calc ∑ P' ∈ F, t P P' ≤ ∑ P' ∈ F, C0 * (1 + rho α (latticePt P.ℓ - latticePt P'.ℓ)) ^ (-(ν :
+        ℝ)) :=
+          Finset.sum_le_sum hbound
+      _ = C0 * ∑ ℓ ∈ F.image (fun P' : Tile n => P'.ℓ),
+            (1 + rho α (0 - latticePt (ℓ - P.ℓ))) ^ (-(ν : ℝ)) := by
+          rw [Finset.mul_sum, Finset.sum_image hinj]
+          refine Finset.sum_congr rfl fun P' _ => ?_
+          rw [show latticePt P.ℓ - latticePt P'.ℓ = 0 - latticePt (P'.ℓ - P.ℓ) by ext i; simp]
+      _ ≤ C0 * ∑' ℓ : Fin n → ℤ, (1 + rho α (0 - latticePt (ℓ - P.ℓ))) ^ (-(ν : ℝ)) := by
+          gcongr
+          refine Summable.sum_le_tsum _ (fun ℓ _ => by
+            have := rho_nonneg α (0 - latticePt (ℓ - P.ℓ))
+            positivity) ?_
+          have hs := (summable_wgt_lattice α hα hν 0).1
+          exact (Equiv.subRight P.ℓ).summable_iff.mpr hs
+      _ = C0 * ∑' ℓ : Fin n → ℤ, (1 + rho α (0 - latticePt ℓ)) ^ (-(ν : ℝ)) := by
+          congr 1
+          exact (Equiv.subRight P.ℓ).tsum_eq (fun ℓ => (1 + rho α (0 - latticePt ℓ)) ^ (-(ν : ℝ)))
+      _ ≤ C0 * W := by gcongr
+  -- symmetrization
+  have hsym : ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then a P * a P' * t P P' else 0) ≤
+      ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then (a P ^ 2 / 2 + a P' ^ 2 / 2) * t P P' else 0) := by
+    refine Finset.sum_le_sum fun P _ => Finset.sum_le_sum fun P' _ => ?_
+    split_ifs
+    · exact mul_le_mul_of_nonneg_right
+        (by nlinarith only [sq_nonneg (a P - a P')]) (norm_nonneg _)
+    · exact le_rfl
+  have hswap : ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then (a P ^ 2 / 2 + a P' ^ 2 / 2) * t P P' else
+      0) =
+      ∑ P ∈ U, a P ^ 2 * ∑ P' ∈ U, (if P.ω = P'.ω then t P P' else 0) := by
+    have e1 : ∀ P P', (if P.ω = P'.ω then (a P ^ 2 / 2 + a P' ^ 2 / 2) * t P P' else 0) =
+        (if P.ω = P'.ω then a P ^ 2 / 2 * t P P' else 0) +
+          (if P'.ω = P.ω then a P' ^ 2 / 2 * t P' P else 0) := by
+      intro P P'
+      by_cases h : P.ω = P'.ω
+      · simp only [ite_eq_left h, ite_eq_left h.symm, ht P' P]; ring
+      · simp only [ite_eq_right h, ite_eq_right (Ne.symm h)]; ring
+    simp_rw [e1, Finset.sum_add_distrib]
+    rw [Finset.sum_comm (f := fun P P' => if P'.ω = P.ω then a P' ^ 2 / 2 * t P' P else 0)]
+    rw [← two_mul]
+    rw [Finset.mul_sum]
+    refine Finset.sum_congr rfl fun P _ => ?_
+    rw [Finset.mul_sum, Finset.mul_sum]
+    refine Finset.sum_congr rfl fun P' _ => ?_
+    by_cases h : P.ω = P'.ω
+    · simp only [ite_eq_left h]; ring
+    · simp only [ite_eq_right h]; ring
+  calc _ = ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then a P * a P' * t P P' else 0) := rfl
+    _ ≤ _ := hsym
+    _ = _ := hswap
+    _ ≤ ∑ P ∈ U, a P ^ 2 * (C0 * W) :=
+        Finset.sum_le_sum fun P _ => mul_le_mul_of_nonneg_left (hinner P) (sq_nonneg _)
+    _ = C0 * W * ∑ P ∈ U, a P ^ 2 := by rw [Finset.mul_sum]; congr 1; ext P; ring
+
+/-- Points of `I_P` are within anisotropic distance `2^{k_P}` of `c(I_P)`. -/
+theorem rho_sub_cI_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (P : Tile n) {y : Rn n}
+    (hy : y ∈ P.I.toSet α) : rho α (y - P.cI α) ≤ (2 : ℝ) ^ P.k := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  have h : rhoNN α (y - P.cI α) ≤ Real.toNNReal ((2 : ℝ) ^ P.k) := by
+    rw [rhoNN_le_iff]
+    intro i
+    rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ ht.le]
+    simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs, PiLp.sub_apply]
+    have h1 := abs_sub_cI_le_of_mem_I α P hy i
+    have hs := side_pos α P.k i
+    have hai : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+    have h2 : |y i - P.cI α i| ≤ ((2 : ℝ) ^ P.k) ^ (α i : ℝ) := by
+      rw [Real.rpow_natCast, side] at *
+      rw [← zpow_natCast, ← zpow_mul]
+      linarith
+    calc |y i - P.cI α i| ^ ((α i : ℝ)⁻¹) ≤ (((2 : ℝ) ^ P.k) ^ (α i : ℝ)) ^ ((α i : ℝ)⁻¹) :=
+          Real.rpow_le_rpow (abs_nonneg _) h2 (by positivity)
+      _ = (2 : ℝ) ^ P.k := by rw [← Real.rpow_mul ht.le, mul_inv_cancel₀ hai, Real.rpow_one]
+  have := NNReal.coe_le_coe.mpr h
+  rwa [Real.coe_toNNReal _ ht.le] at this
+
+/-- The weight `(1 + t⁻¹ρ(·))^{-ν}` varies by at most `2^ν` under shifts of size `t`. -/
+theorem wgt_shift_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t) {y c : Rn n}
+    (h : rho α (y - c) ≤ t) (z : Rn n) {ν : ℝ} (hν : 0 ≤ ν) :
+    (1 + t⁻¹ * rho α (z - y)) ^ (-ν) ≤ 2 ^ ν * (1 + t⁻¹ * rho α (z - c)) ^ (-ν) := by
+  have h1 := one_add_mul_rho_sub_le α hα (inv_pos.mpr ht).le le_rfl (z - y) (c - y)
+  rw [sub_sub_sub_cancel_right] at h1
+  have h2 : 1 + t⁻¹ * rho α (c - y) ≤ 2 := by
+    rw [rho_sub_comm]
+    have : t⁻¹ * rho α (y - c) ≤ 1 := by rw [inv_mul_le_iff₀ ht]; linarith
+    linarith
+  have hpos : 0 < 1 + t⁻¹ * rho α (z - y) := by
+    have := rho_nonneg α (z - y); positivity
+  have hpos' : 0 < 1 + t⁻¹ * rho α (z - c) := by
+    have := rho_nonneg α (z - c); positivity
+  have h3 : 1 + t⁻¹ * rho α (z - c) ≤ 2 * (1 + t⁻¹ * rho α (z - y)) := by
+    calc _ ≤ (1 + t⁻¹ * rho α (z - y)) * (1 + t⁻¹ * rho α (c - y)) := h1
+      _ ≤ (1 + t⁻¹ * rho α (z - y)) * 2 := by gcongr
+      _ = _ := by ring
+  calc (1 + t⁻¹ * rho α (z - y)) ^ (-ν) = 2 ^ ν * (2 * (1 + t⁻¹ * rho α (z - y))) ^ (-ν) := by
+        rw [Real.mul_rpow (by norm_num) hpos.le, Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 2)]
+        field_simp
+    _ ≤ 2 ^ ν * (1 + t⁻¹ * rho α (z - c)) ^ (-ν) :=
+        mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_nonpos hpos' h3 (by linarith))
+          (by positivity)
+
+theorem volume_box_update (a b : Fin n → ℝ) (hab : ∀ j, a j ≤ b j) (i : Fin n) (lo hi : ℝ)
+    (h : lo ≤ hi) :
+    volume ((WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹' Set.pi Set.univ
+      (Function.update (fun j => Set.Ico (a j) (b j)) i (Set.Ico lo hi))) =
+      ENNReal.ofReal ((hi - lo) * ∏ j ∈ Finset.univ.erase i, (b j - a j)) := by
+  have heq : Function.update (fun j => Set.Ico (a j) (b j)) i (Set.Ico lo hi) =
+      fun j => Set.Ico (Function.update a i lo j) (Function.update b i hi j) := by
+    ext j : 1
+    by_cases hj : j = i
+    · subst hj; simp
+    · simp [Function.update_of_ne hj]
+  rw [heq, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun j => measurableSet_Ico).nullMeasurableSet, Real.volume_pi_Ico,
+    ← ENNReal.ofReal_prod_of_nonneg]
+  · congr 1
+    rw [← Finset.mul_prod_erase Finset.univ _ (Finset.mem_univ i)]
+    simp only [Function.update_self]
+    congr 1
+    refine Finset.prod_congr rfl fun j hj => ?_
+    rw [Function.update_of_ne (Finset.ne_of_mem_erase hj), Function.update_of_ne
+      (Finset.ne_of_mem_erase hj)]
+  · intro j _
+    by_cases hj : j = i
+    · subst hj; simp [h]
+    · simp [Function.update_of_ne hj, hab j]
+
+/-- Translating a dyadic cube by `z` moves out a set of measure at most
+`2 ∑ᵢ |zᵢ| ∏_{j ≠ i} ℓ_j`, where `ℓ_j` are the side lengths. -/
+theorem volume_cube_shift_le (α : Fin n → ℕ) (Q : DCube n) (z : Rn n) :
+    volume {y : Rn n | y ∈ Q.toSet α ∧ y + z ∉ Q.toSet α} ≤
+      ∑ i, 2 * ENNReal.ofReal (|z i| * ∏ j ∈ Finset.univ.erase i, side α Q.k j) := by
+  set lo : Fin n → ℝ := fun j => side α Q.k j * Q.ℓ j
+  set hi : Fin n → ℝ := fun j => side α Q.k j * (Q.ℓ j + 1)
+  have hlh : ∀ j, lo j ≤ hi j := fun j => by
+    have := side_pos α Q.k j; simp only [lo, hi]; nlinarith
+  have hside : ∀ j, hi j - lo j = side α Q.k j := fun j => by simp only [lo, hi]; ring
+  set B : Fin n → ℝ → ℝ → Set (Rn n) := fun i l h => (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹'
+    Set.pi Set.univ (Function.update (fun j => Set.Ico (lo j) (hi j)) i (Set.Ico l h))
+  have hsub : {y : Rn n | y ∈ Q.toSet α ∧ y + z ∉ Q.toSet α} ⊆
+      ⋃ i, (B i (hi i - |z i|) (hi i) ∪ B i (lo i) (lo i + |z i|)) := by
+    rintro y ⟨hy, hyz⟩
+    simp only [DCube.toSet, Set.mem_ofPred_eq, not_forall] at hy hyz
+    obtain ⟨i, hi'⟩ := hyz
+    refine Set.mem_iUnion.mpr ⟨i, ?_⟩
+    have hmem : ∀ l h, (l ≤ y i ∧ y i < h) → y ∈ B i l h := by
+      intro l h hlh' j _
+      by_cases hj : j = i
+      · subst hj; simpa using hlh'
+      · simp only [Function.update_of_ne hj]
+        exact hy j
+    simp only [PiLp.add_apply, not_and_or, not_le, not_lt] at hi'
+    have hyi := hy i
+    rcases hi' with h1 | h1
+    · right
+      refine hmem _ _ ⟨hyi.1, ?_⟩
+      have : z i < 0 := by simp only [lo] at *; linarith
+      rw [abs_of_neg this]; simp only [lo] at *; linarith
+    · left
+      refine hmem _ _ ⟨?_, hyi.2⟩
+      have : 0 < z i := by simp only [hi] at *; linarith
+      rw [abs_of_pos this]; simp only [hi] at *; linarith
+  refine (measure_mono hsub).trans ((measure_iUnion_fintype_le _ _).trans
+    (Finset.sum_le_sum fun i _ => ?_))
+  refine (measure_union_le _ _).trans (le_of_eq ?_)
+  have hz := abs_nonneg (z i)
+  simp only [B]
+  rw [volume_box_update lo hi hlh i _ _ (by linarith), volume_box_update lo hi hlh i _ _
+    (by linarith), two_mul]
+  simp only [hside]
+  ring_nf
+
+/-- The translation–Tonelli identity behind the boundary estimate:
+`∫_{y ∈ Q} ∫_{x ∉ Q} F(x - y) dx dy ≤ ∫ F(z) |{y ∈ Q : y + z ∉ Q}| dz`. -/
+theorem lintegral_cube_compl_le (α : Fin n → ℕ) (Q : DCube n) {F : Rn n → ℝ≥0∞}
+    (hF : Measurable F) :
+    ∫⁻ y in Q.toSet α, ∫⁻ x in (Q.toSet α)ᶜ, F (x - y) ≤
+      ∫⁻ z, F z * volume {y : Rn n | y ∈ Q.toSet α ∧ y + z ∉ Q.toSet α} := by
+  set A := Q.toSet α
+  have hA : MeasurableSet A := DCube.measurableSet_toSet α Q
+  have hinner : ∀ y, ∫⁻ x in Aᶜ, F (x - y) = ∫⁻ z, Aᶜ.indicator 1 (y + z) * F z := by
+    intro y
+    rw [← lintegral_indicator hA.compl]
+    have := lintegral_add_left_eq_self (μ := (volume : Measure (Rn n)))
+      (fun x => Aᶜ.indicator (fun x => F (x - y)) x) y
+    rw [← this]
+    congr 1; ext z
+    by_cases hz : y + z ∈ Aᶜ
+    · simp [Set.indicator_of_mem hz]
+    · simp [Set.indicator_of_notMem hz]
+  simp_rw [hinner]
+  rw [← lintegral_indicator hA]
+  have e1 : ∀ y, A.indicator (fun y => ∫⁻ z, Aᶜ.indicator 1 (y + z) * F z) y =
+      ∫⁻ z, A.indicator 1 y * (Aᶜ.indicator 1 (y + z) * F z) := by
+    intro y
+    by_cases hy : y ∈ A <;> simp [hy]
+  simp_rw [e1]
+  have hmeas : Measurable (Function.uncurry fun y z : Rn n =>
+      A.indicator (1 : Rn n → ℝ≥0∞) y * (Aᶜ.indicator 1 (y + z) * F z)) :=
+    ((measurable_one.indicator hA).comp measurable_fst).mul
+      (((measurable_one.indicator hA.compl).comp measurable_add).mul (hF.comp measurable_snd))
+  rw [lintegral_lintegral_swap hmeas.aemeasurable]
+  refine lintegral_mono fun z => le_of_eq ?_
+  have hS : MeasurableSet {y : Rn n | y ∈ A ∧ y + z ∉ A} :=
+    hA.inter (hA.compl.preimage (measurable_add_const z))
+  calc ∫⁻ y, A.indicator 1 y * (Aᶜ.indicator 1 (y + z) * F z)
+      = ∫⁻ y, F z * {y : Rn n | y ∈ A ∧ y + z ∉ A}.indicator 1 y := by
+        congr 1; ext y
+        by_cases hy : y ∈ A <;> by_cases hyz : y + z ∈ A <;> simp [hy, hyz, Set.indicator]
+    _ = F z * volume {y : Rn n | y ∈ A ∧ y + z ∉ A} := by
+        rw [lintegral_const_mul _ (measurable_one.indicator hS), lintegral_indicator_one hS]
+
+theorem lintegral_wgt_coord_scaled (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {t : ℝ} (ht : 0 < t)
+    (ν : ℝ) (i : Fin n) :
+    ∫⁻ z : Rn n, ENNReal.ofReal ((1 + t⁻¹ * rho α z) ^ (-ν)) * ENNReal.ofReal |z i| =
+      ENNReal.ofReal (t ^ absA α * t ^ α i) *
+        ∫⁻ w : Rn n, ENNReal.ofReal ((1 + rho α w) ^ (-ν)) * ENNReal.ofReal |w i| := by
+  set g : Rn n → ℝ≥0∞ := fun z =>
+    ENNReal.ofReal ((1 + t⁻¹ * rho α z) ^ (-ν)) * ENNReal.ofReal |z i|
+  have h := lintegral_comp_dil α ht g
+  have hg : ∀ v, g (dil α t v) = ENNReal.ofReal (t ^ α i) *
+      (ENNReal.ofReal ((1 + rho α v) ^ (-ν)) * ENNReal.ofReal |v i|) := by
+    intro v
+    simp only [g, dil_apply]
+    rw [rho_dil α hα ht, ← mul_assoc, inv_mul_cancel₀ ht.ne', one_mul, abs_mul,
+      abs_of_pos (by positivity : (0 : ℝ) < t ^ α i), ENNReal.ofReal_mul (by positivity)]
+    ring
+  simp_rw [hg] at h
+  rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] at h
+  have ht' : (0 : ℝ) < t ^ absA α := by positivity
+  calc ∫⁻ z, g z = ENNReal.ofReal (t ^ absA α) * (ENNReal.ofReal ((t ^ absA α)⁻¹) * ∫⁻ z, g z) := by
+        rw [← mul_assoc, ← ENNReal.ofReal_mul ht'.le, mul_inv_cancel₀ ht'.ne', ENNReal.ofReal_one,
+          one_mul]
+    _ = _ := by rw [← h, ← mul_assoc, ← ENNReal.ofReal_mul ht'.le]
+
+theorem lintegral_wgt_coord_lt_top (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (i : Fin n)
+    (hν : (absA α : ℝ) + α i < ν) :
+    ∫⁻ w : Rn n, ENNReal.ofReal ((1 + rho α w) ^ (-ν)) * ENNReal.ofReal |w i| < ⊤ := by
+  have hs : (absA α : ℝ) < ν - α i := by linarith
+  have hint := integrable_wgt α hα hs
+  refine lt_of_le_of_lt (lintegral_mono fun w => ?_) hint.lintegral_lt_top
+  have hρ := rho_nonneg α w
+  have hpos : 0 < 1 + rho α w := by linarith
+  rw [← ENNReal.ofReal_mul (by positivity)]
+  refine ENNReal.ofReal_le_ofReal ?_
+  have h1 : |w i| ≤ (1 + rho α w) ^ (α i : ℝ) := by
+    rw [Real.rpow_natCast]
+    exact (abs_coord_le_rho_pow α hα w i).trans (pow_le_pow_left₀ hρ (by linarith) _)
+  calc (1 + rho α w) ^ (-ν) * |w i| ≤ (1 + rho α w) ^ (-ν) * (1 + rho α w) ^ (α i : ℝ) := by
+        gcongr
+    _ = (1 + rho α w) ^ (-(ν - α i)) := by rw [← Real.rpow_add hpos]; ring_nf
+
+theorem measurable_wgt_scaled_enn (α : Fin n → ℕ) {t : ℝ} (ht : 0 < t) (ν : ℝ) :
+    Measurable fun z : Rn n => ENNReal.ofReal ((1 + t⁻¹ * rho α z) ^ (-ν)) := by
+  refine ENNReal.measurable_ofReal.comp (Continuous.measurable ?_)
+  refine Continuous.rpow_const (continuous_const.add (continuous_const.mul (continuous_rho α)))
+    fun z => Or.inl ?_
+  have := rho_nonneg α z
+  have : 0 ≤ t⁻¹ * rho α z := by positivity
+  linarith
+
+/-- `∑_{k ∈ ks, k ≤ K} 2^{k − K} ≤ 2`. -/
+theorem sum_two_zpow_sub_le (ks : Finset ℤ) (K : ℤ) (hks : ∀ k ∈ ks, k ≤ K) :
+    ∑ k ∈ ks, (2 : ℝ) ^ (k - K) ≤ 2 := by
+  have hinj : Set.InjOn (fun k : ℤ => (K - k).toNat) (ks : Set ℤ) := by
+    intro a ha b hb hab
+    have := hks a ha; have := hks b hb
+    simp only at hab; omega
+  calc ∑ k ∈ ks, (2 : ℝ) ^ (k - K) = ∑ m ∈ ks.image (fun k : ℤ => (K - k).toNat), (1 / 2 : ℝ) ^
+      m := by
+        rw [Finset.sum_image hinj]
+        refine Finset.sum_congr rfl fun k hk => ?_
+        have h1 := hks k hk
+        rw [one_div, inv_pow, ← zpow_natCast, Int.toNat_of_nonneg (by omega), ← zpow_neg]
+        congr 1; ring
+    _ ≤ ∑' m : ℕ, (1 / 2 : ℝ) ^ m :=
+        Summable.sum_le_tsum _ (fun _ _ => by positivity) summable_geometric_two
+    _ = 2 := tsum_geometric_two
+
+/-- The boundary estimate of the energy lemma (paper, (6.12)–(6.13), texline~560–576), proved by
+averaging instead of lattice counting: for a collection `T` of tiles with pairwise distinct
+spatial cubes inside `I_top`,
+`∑_{P ∈ T} ∫_{(I_top)ᶜ} (1 + 2^{-k_P} ρ(x - c(I_P)))^{-ν} dx ≤ C |I_top|`, `ν = 2|α| + 1`. -/
+theorem boundary_sum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (top : Tile n) (T : Finset (Tile n)),
+      (∀ P ∈ T, P.I.toSet α ⊆ top.I.toSet α) → Set.InjOn Tile.I (T : Set (Tile n)) →
+      ∑ P ∈ T, ∫⁻ x in (top.I.toSet α)ᶜ,
+        ENNReal.ofReal ((1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * absA α + 1 : ℝ))) ≤
+        ENNReal.ofReal (C * top.vol α) := by
+  classical
+  set ν : ℝ := 2 * absA α + 1
+  have hν0 : 0 ≤ ν := by positivity
+  set G : Fin n → ℝ≥0∞ := fun i =>
+    ∫⁻ w : Rn n, ENNReal.ofReal ((1 + rho α w) ^ (-ν)) * ENNReal.ofReal |w i|
+  have hG : ∀ i, G i < ⊤ := fun i => lintegral_wgt_coord_lt_top α hα i (by
+    have : (α i : ℝ) ≤ absA α := by
+      exact_mod_cast Finset.single_le_sum (fun j _ => Nat.zero_le (α j)) (Finset.mem_univ i)
+    simp only [ν]; linarith)
+  set Gs : ℝ := ∑ i, (G i).toReal
+  have hGs : 0 ≤ Gs := Finset.sum_nonneg fun i _ => ENNReal.toReal_nonneg
+  refine ⟨2 ^ ν * 4 * Gs, by positivity, fun top T hT hinj => ?_⟩
+  set I := top.I.toSet α
+  set K := top.k
+  set F : ℤ → Rn n → ℝ≥0∞ := fun k z =>
+    ENNReal.ofReal ((1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) ^ (-ν))
+  have hFm : ∀ k, Measurable (F k) := fun k => measurable_wgt_scaled_enn α (by positivity) ν
+  set Φ : ℤ → Rn n → ℝ≥0∞ := fun k y => ∫⁻ x in Iᶜ, F k (x - y)
+  -- step 1: comparison with the average over `I_P`
+  have hstep1 : ∀ P ∈ T, ∫⁻ x in Iᶜ, F P.k (x - P.cI α) ≤
+      ENNReal.ofReal (2 ^ ν / P.vol α) * ∫⁻ y in P.I.toSet α, Φ P.k y := by
+    intro P _
+    have hv := P.vol_pos α
+    have hvol := P.volume_I α
+    have hpt : ∀ y ∈ P.I.toSet α, ∫⁻ x in Iᶜ, F P.k (x - P.cI α) ≤
+        ENNReal.ofReal (2 ^ ν) * Φ P.k y := by
+      intro y hy
+      rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+      refine lintegral_mono fun x => ?_
+      simp only [F]
+      rw [← ENNReal.ofReal_mul (by positivity)]
+      refine ENNReal.ofReal_le_ofReal ?_
+      have hρ : rho α (P.cI α - y) ≤ (2 : ℝ) ^ P.k := by
+        rw [rho_sub_comm]; exact rho_sub_cI_le α hα P hy
+      exact wgt_shift_le α hα (by positivity) hρ x hν0
+    have hmono : ∫⁻ _ in P.I.toSet α, ∫⁻ x in Iᶜ, F P.k (x - P.cI α) ≤
+        ∫⁻ y in P.I.toSet α, ENNReal.ofReal (2 ^ ν) * Φ P.k y :=
+      lintegral_mono_ae ((ae_restrict_iff' (DCube.measurableSet_toSet α P.I)).mpr
+        (Filter.Eventually.of_forall hpt))
+    rw [setLIntegral_const, hvol, lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] at hmono
+    calc ∫⁻ x in Iᶜ, F P.k (x - P.cI α)
+        = ENNReal.ofReal (1 / P.vol α) * ((∫⁻ x in Iᶜ, F P.k (x - P.cI α)) *
+            ENNReal.ofReal (P.vol α)) := by
+          rw [mul_comm _ (ENNReal.ofReal _), ← mul_assoc, ← ENNReal.ofReal_mul (by positivity),
+            one_div_mul_cancel hv.ne', ENNReal.ofReal_one, one_mul]
+      _ ≤ ENNReal.ofReal (1 / P.vol α) * (ENNReal.ofReal (2 ^ ν) *
+            ∫⁻ y in P.I.toSet α, Φ P.k y) := by gcongr
+      _ = _ := by
+          rw [← mul_assoc, ← ENNReal.ofReal_mul (by positivity)]
+          congr 2; ring
+  -- step 2: tiles of the same scale have disjoint cubes inside `I`
+  have hkK : ∀ P ∈ T, P.k ≤ K := fun P hP => by
+    have := DCube.k_le_of_subset α hα hn (hT P hP)
+    simpa [Tile.I] using this
+  have hstep2 : ∀ k : ℤ, ∑ P ∈ T with P.k = k, ∫⁻ y in P.I.toSet α, Φ k y ≤
+      ∫⁻ y in I, Φ k y := by
+    intro k
+    have hpd : ((T.filter fun P => P.k = k : Finset (Tile n)) : Set (Tile n)).PairwiseDisjoint
+        (fun P => P.I.toSet α) := by
+      intro P hP Q hQ hPQ
+      simp only [Finset.coe_filter, Set.mem_ofPred_eq] at hP hQ
+      have hkPQ : P.I.k ≤ Q.I.k := by simp [Tile.I, hP.2, hQ.2]
+      rcases DCube.subset_or_disjoint α P.I Q.I hkPQ with h | h
+      · exfalso
+        apply hPQ
+        refine hinj hP.1 hQ.1 (DCube.eq_of_mem_of_k_eq α (by simp [Tile.I, hP.2, hQ.2])
+          (DCube.center_mem α P.I) (h (DCube.center_mem α P.I)))
+      · exact h
+    rw [← lintegral_biUnion_finset hpd fun P _ => DCube.measurableSet_toSet α P.I]
+    refine lintegral_mono_set (Set.iUnion₂_subset fun P hP => ?_)
+    exact hT P (Finset.mem_filter.mp hP).1
+  -- step 3: the Tonelli bound for `∫_I Φ_k`
+  set p : Fin n → ℝ := fun i => ∏ j ∈ Finset.univ.erase i, side α K j
+  have hp : ∀ i, 0 ≤ p i := fun i => Finset.prod_nonneg fun j _ => (side_pos α K j).le
+  have hstep3 : ∀ k : ℤ, ∫⁻ y in I, Φ k y ≤ ∑ i, ENNReal.ofReal (2 * p i *
+      (((2 : ℝ) ^ k) ^ absA α * ((2 : ℝ) ^ k) ^ α i)) * G i := by
+    intro k
+    refine (lintegral_cube_compl_le α top.I (hFm k)).trans ?_
+    calc ∫⁻ z, F k z * volume {y : Rn n | y ∈ top.I.toSet α ∧ y + z ∉ top.I.toSet α}
+        ≤ ∫⁻ z, F k z * ∑ i, 2 * ENNReal.ofReal (|z i| * p i) := by
+          gcongr with z
+          exact volume_cube_shift_le α top.I z
+      _ = ∫⁻ z, ∑ i, ENNReal.ofReal (2 * p i) * (F k z * ENNReal.ofReal |z i|) := by
+          refine lintegral_congr fun z => ?_
+          rw [Finset.mul_sum]
+          refine Finset.sum_congr rfl fun i _ => ?_
+          rw [ENNReal.ofReal_mul (abs_nonneg _), ENNReal.ofReal_mul (by norm_num),
+            ENNReal.ofReal_ofNat]
+          ring
+      _ = ∑ i, ∫⁻ z, ENNReal.ofReal (2 * p i) * (F k z * ENNReal.ofReal |z i|) := by
+          refine lintegral_finsetSum' _ fun i _ => ?_
+          exact ((hFm k).mul (ENNReal.measurable_ofReal.comp
+              ((continuous_abs.comp ((continuous_apply i).comp
+                (PiLp.continuous_ofLp 2 _))).measurable))).const_mul _ |>.aemeasurable
+      _ = ∑ i, ENNReal.ofReal (2 * p i) * ∫⁻ z, F k z * ENNReal.ofReal |z i| := by
+          refine Finset.sum_congr rfl fun i _ => ?_
+          rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+      _ = ∑ i, ENNReal.ofReal (2 * p i *
+            (((2 : ℝ) ^ k) ^ absA α * ((2 : ℝ) ^ k) ^ α i)) * G i := by
+          refine Finset.sum_congr rfl fun i _ => ?_
+          rw [lintegral_wgt_coord_scaled α hα (by positivity) ν i, ← mul_assoc,
+            ← ENNReal.ofReal_mul (by have := hp i; positivity)]
+  -- step 4: the contribution of each scale
+  have hvolk : ∀ k : ℤ, ((2 : ℝ) ^ k) ^ absA α = (2 : ℝ) ^ (k * (absA α : ℤ)) := fun k => by
+    rw [← zpow_natCast, ← zpow_mul]
+  have hpk : ∀ k ≤ K, ∀ i, p i * ((2 : ℝ) ^ k) ^ α i ≤ top.vol α * (2 : ℝ) ^ (k - K) := by
+    intro k hk i
+    have hvol : top.vol α = side α K i * p i := by
+      rw [Tile.vol, ← prod_side α K, ← Finset.mul_prod_erase Finset.univ _ (Finset.mem_univ i)]
+    have hsk : ((2 : ℝ) ^ k) ^ α i ≤ side α K i * (2 : ℝ) ^ (k - K) := by
+      rw [side, ← zpow_natCast, ← zpow_mul, ← zpow_add₀ (by norm_num)]
+      refine zpow_le_zpow_right₀ (by norm_num) ?_
+      have := hα i
+      nlinarith
+    rw [hvol]
+    calc p i * ((2 : ℝ) ^ k) ^ α i ≤ p i * (side α K i * (2 : ℝ) ^ (k - K)) := by
+          gcongr; exact hp i
+      _ = _ := by ring
+  have hstep4 : ∀ k ≤ K, ∑ P ∈ T with P.k = k, ∫⁻ x in Iᶜ, F P.k (x - P.cI α) ≤
+      ENNReal.ofReal (2 ^ ν * 2 * top.vol α * (2 : ℝ) ^ (k - K)) * ∑ i, G i := by
+    intro k hk
+    have hv : (0 : ℝ) < (2 : ℝ) ^ (k * (absA α : ℤ)) := by positivity
+    calc ∑ P ∈ T with P.k = k, ∫⁻ x in Iᶜ, F P.k (x - P.cI α)
+        ≤ ∑ P ∈ T with P.k = k, ENNReal.ofReal (2 ^ ν / (2 : ℝ) ^ (k * (absA α : ℤ))) *
+            ∫⁻ y in P.I.toSet α, Φ k y := by
+          refine Finset.sum_le_sum fun P hP => ?_
+          obtain ⟨hPT, hPk⟩ := Finset.mem_filter.mp hP
+          have := hstep1 P hPT
+          rw [hPk] at this
+          simpa [Tile.vol, hPk] using this
+      _ = ENNReal.ofReal (2 ^ ν / (2 : ℝ) ^ (k * (absA α : ℤ))) *
+            ∑ P ∈ T with P.k = k, ∫⁻ y in P.I.toSet α, Φ k y := by rw [Finset.mul_sum]
+      _ ≤ ENNReal.ofReal (2 ^ ν / (2 : ℝ) ^ (k * (absA α : ℤ))) * ∫⁻ y in I, Φ k y := by
+          gcongr; exact hstep2 k
+      _ ≤ ENNReal.ofReal (2 ^ ν / (2 : ℝ) ^ (k * (absA α : ℤ))) * ∑ i, ENNReal.ofReal (2 * p i *
+            (((2 : ℝ) ^ k) ^ absA α * ((2 : ℝ) ^ k) ^ α i)) * G i := by
+          gcongr; exact hstep3 k
+      _ = ∑ i, ENNReal.ofReal (2 ^ ν * 2 * (p i * ((2 : ℝ) ^ k) ^ α i)) * G i := by
+          rw [Finset.mul_sum]
+          refine Finset.sum_congr rfl fun i _ => ?_
+          rw [← mul_assoc, ← ENNReal.ofReal_mul (by positivity)]
+          congr 2
+          rw [hvolk]
+          field_simp
+      _ ≤ ∑ i, ENNReal.ofReal (2 ^ ν * 2 * top.vol α * (2 : ℝ) ^ (k - K)) * G i := by
+          refine Finset.sum_le_sum fun i _ => mul_le_mul_left ?_ _
+          refine ENNReal.ofReal_le_ofReal ?_
+          calc 2 ^ ν * 2 * (p i * ((2 : ℝ) ^ k) ^ α i) ≤
+              2 ^ ν * 2 * (top.vol α * (2 : ℝ) ^ (k - K)) :=
+                mul_le_mul_of_nonneg_left (hpk k hk i) (by positivity)
+            _ = _ := by ring
+      _ = _ := by rw [Finset.mul_sum]
+  -- step 5: summing over the scales
+  set ks := T.image Tile.k
+  have hgeom : ∑ k ∈ ks, (2 : ℝ) ^ (k - K) ≤ 2 := by
+    refine sum_two_zpow_sub_le ks K ?_
+    intro k hk
+    obtain ⟨P, hP, rfl⟩ := Finset.mem_image.mp hk
+    exact hkK P hP
+  have hGsum : ∑ i, G i = ENNReal.ofReal Gs := by
+    rw [ENNReal.ofReal_sum_of_nonneg fun i _ => ENNReal.toReal_nonneg]
+    exact Finset.sum_congr rfl fun i _ => (ENNReal.ofReal_toReal (hG i).ne).symm
+  have hv := top.vol_pos α
+  calc ∑ P ∈ T, ∫⁻ x in Iᶜ, F P.k (x - P.cI α)
+      = ∑ k ∈ ks, ∑ P ∈ T with P.k = k, ∫⁻ x in Iᶜ, F P.k (x - P.cI α) :=
+        (Finset.sum_fiberwise_of_maps_to (fun P hP => Finset.mem_image_of_mem _ hP) _).symm
+    _ ≤ ∑ k ∈ ks, ENNReal.ofReal (2 ^ ν * 2 * top.vol α * (2 : ℝ) ^ (k - K)) * ∑ i, G i := by
+        refine Finset.sum_le_sum fun k hk => hstep4 k ?_
+        obtain ⟨P, hP, rfl⟩ := Finset.mem_image.mp hk
+        exact hkK P hP
+    _ = ENNReal.ofReal (2 ^ ν * 2 * top.vol α * ∑ k ∈ ks, (2 : ℝ) ^ (k - K)) *
+          ENNReal.ofReal Gs := by
+        rw [← Finset.sum_mul, hGsum]
+        congr 1
+        rw [Finset.mul_sum, ENNReal.ofReal_sum_of_nonneg fun k _ => by positivity]
+    _ ≤ ENNReal.ofReal (2 ^ ν * 2 * top.vol α * 2) * ENNReal.ofReal Gs := by
+        gcongr
+    _ = ENNReal.ofReal (2 ^ ν * 4 * Gs * top.vol α) := by
+        rw [← ENNReal.ofReal_mul (by positivity)]
+        congr 1; ring
+
+deriving instance DecidableEq for Tile
+
+theorem Tile.ext_I_ω {P Q : Tile n} (hI : P.I = Q.I) (hω : P.ω = Q.ω) : P = Q := by
+  have hk : P.k = Q.k := congrArg DCube.k hI
+  have hℓ : P.ℓ = Q.ℓ := congrArg DCube.ℓ hI
+  have hu : P.u = Q.u := congrArg DCube.ℓ hω
+  cases P; cases Q
+  simp_all
+
+/-- Within a `2`-tree the spatial cubes determine the tiles. -/
+theorem Is2Tree.injOn_I (α : Fin n → ℕ) {r : Fin n → Fin 2} {top : Tile n} {T : Finset (Tile n)}
+    (h : Is2Tree α r top T) : Set.InjOn Tile.I (T : Set (Tile n)) := by
+  intro P hP Q hQ hPQ
+  have hk : P.k = Q.k := congrArg DCube.k hPQ
+  refine Tile.ext_I_ω hPQ (DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) (h.1 P hP).2
+    (h.1 Q hQ).2)
+
+section SelectedTrees
+
+variable (α : Fin n → ℕ) {r : Fin n → Fin 2} {i₀ : Fin n} {m : ℕ} {top : ℕ → Tile n}
+  {T2 : ℕ → Finset (Tile n)}
+
+/-- A tile of a `2`-tree cannot have the top's frequency centre in its lower half. -/
+theorem selected_not_semiHO0 (hr : r i₀ = 1) (h2 : ∀ i < m, Is2Tree α r (top i) (T2 i))
+    {i : ℕ} (hi : i < m) {P' : Tile n} (hP' : P' ∈ T2 i)
+    (hc : (top i).cω α ∈ P'.semiHO0 α) : False := by
+  have := lt_of_mem_semiHO0_of_mem_semi α P' hr hc ((h2 i hi).2 P' hP')
+  exact lt_irrefl _ this
+
+/-- Fact (i) in the proof of (6.10) (paper, texline~559): for `P ∈ T₂` and `P' ∈ 𝒮_P`, the cube
+`I_{P'}` is disjoint from `I_{T₂}`. -/
+theorem selected_disjoint_top (hr : r i₀ = 1) (h2 : ∀ i < m, Is2Tree α r (top i) (T2 i))
+    (h61 : ∀ i < m, ∀ j < m, i ≠ j → ∀ P ∈ T2 i, ∀ P' ∈ T2 j, P.ω.toSet α ⊆ P'.semiHO0 α →
+      Disjoint (P'.I.toSet α) ((top i).I.toSet α))
+    {i : ℕ} (hi : i < m) {P P' : Tile n} (hP : P ∈ T2 i)
+    (hP' : P' ∈ (Finset.range m).biUnion T2) (hω : P.ω.toSet α ⊆ P'.semiHO0 α) :
+    Disjoint (P'.I.toSet α) ((top i).I.toSet α) := by
+  obtain ⟨j, hj, hP'j⟩ := Finset.mem_biUnion.mp hP'
+  rw [Finset.mem_range] at hj
+  by_cases hij : i = j
+  · subst hij
+    exact (selected_not_semiHO0 α hr h2 hi hP'j (hω ((h2 i hi).1 P hP).2)).elim
+  · exact h61 i hi j hj hij P hP P' hP'j hω
+
+theorem selected_disjoint_pair_aux (hα : ∀ i, 1 ≤ α i) (hr : r i₀ = 1)
+    (h2 : ∀ i < m, Is2Tree α r (top i) (T2 i))
+    (h61 : ∀ i < m, ∀ j < m, i ≠ j → ∀ P ∈ T2 i, ∀ P' ∈ T2 j, P.ω.toSet α ⊆ P'.semiHO0 α →
+      Disjoint (P'.I.toSet α) ((top i).I.toSet α))
+    {P P' P'' : Tile n} (hP' : P' ∈ (Finset.range m).biUnion T2)
+    (hP'' : P'' ∈ (Finset.range m).biUnion T2) (hω' : P.ω.toSet α ⊆ P'.semiHO0 α)
+    (hω'' : P.ω.toSet α ⊆ P''.semiHO0 α) (hne : P' ≠ P'') (hk : P'.k ≤ P''.k) :
+    Disjoint (P'.I.toSet α) (P''.I.toSet α) := by
+  obtain ⟨j', hj', hP'j⟩ := Finset.mem_biUnion.mp hP'
+  obtain ⟨j'', hj'', hP''j⟩ := Finset.mem_biUnion.mp hP''
+  rw [Finset.mem_range] at hj' hj''
+  have hc := DCube.center_mem α P.ω
+  rcases hk.lt_or_eq with hlt | heq
+  · -- `ω_{P''} ⊆ ω_{P'(0)}`
+    have hsub : P''.ω.toSet α ⊆ P'.semiHO0 α :=
+      ω_subset_semiHO0 α hα hlt (Tile.semiHO0_subset α P'' (hω'' hc)) (hω' hc)
+    by_cases hj : j'' = j'
+    · subst hj
+      exact (selected_not_semiHO0 α hr h2 hj'' hP'j (hsub ((h2 j'' hj'').1 P'' hP''j).2)).elim
+    · have h := h61 j'' hj'' j' hj' hj P'' hP''j P' hP'j hsub
+      exact h.mono_right ((h2 j'' hj'').1 P'' hP''j).1
+  · -- same scale: equal frequency cubes, hence disjoint spatial cubes
+    have hωeq : P'.ω = P''.ω := DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, heq])
+      (Tile.semiHO0_subset α P' (hω' hc)) (Tile.semiHO0_subset α P'' (hω'' hc))
+    have hkI : P'.I.k ≤ P''.I.k := by simp [Tile.I, heq]
+    rcases DCube.subset_or_disjoint α P'.I P''.I hkI with h | h
+    · exact absurd (Tile.ext_I_ω (DCube.eq_of_mem_of_k_eq α (by simp [Tile.I, heq])
+        (DCube.center_mem α P'.I) (h (DCube.center_mem α P'.I))) hωeq) hne
+    · exact h
+
+/-- Fact (ii) in the proof of (6.10) (paper, texline~559): distinct `P', P'' ∈ 𝒮_P` have disjoint
+spatial cubes. -/
+theorem selected_disjoint_pair (hα : ∀ i, 1 ≤ α i) (hr : r i₀ = 1)
+    (h2 : ∀ i < m, Is2Tree α r (top i) (T2 i))
+    (h61 : ∀ i < m, ∀ j < m, i ≠ j → ∀ P ∈ T2 i, ∀ P' ∈ T2 j, P.ω.toSet α ⊆ P'.semiHO0 α →
+      Disjoint (P'.I.toSet α) ((top i).I.toSet α))
+    {P P' P'' : Tile n} (hP' : P' ∈ (Finset.range m).biUnion T2)
+    (hP'' : P'' ∈ (Finset.range m).biUnion T2) (hω' : P.ω.toSet α ⊆ P'.semiHO0 α)
+    (hω'' : P.ω.toSet α ⊆ P''.semiHO0 α) (hne : P' ≠ P'') :
+    Disjoint (P'.I.toSet α) (P''.I.toSet α) := by
+  rcases le_total P'.k P''.k with hk | hk
+  · exact selected_disjoint_pair_aux α hα hr h2 h61 hP' hP'' hω' hω'' hne hk
+  · exact (selected_disjoint_pair_aux α hα hr h2 h61 hP'' hP' hω'' hω' (Ne.symm hne) hk).symm
+
+end SelectedTrees
+
+theorem sqrt_vol_eq (α : Fin n → ℕ) (P : Tile n) :
+    (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) ^ 2 = P.vol α := by
+  rw [← Real.rpow_natCast, ← Real.rpow_mul (by positivity)]
+  simp only [Nat.cast_ofNat]
+  rw [show (absA α : ℝ) / 2 * 2 = (absA α : ℝ) by ring, Real.rpow_natCast, Tile.vol,
+    ← zpow_natCast, ← zpow_mul]
+
+open Classical in
+/-- The off-diagonal part of (6.7) (paper, (6.10)–(6.13), texline~545–576): for the selected
+`2`-trees, the pairs with `ω_P ⊆ ω_{P'(0)}` contribute at most `C ε² ∑ |I_{T₂}|`, where `ε` bounds
+the singleton energies. -/
+theorem offdiag_sum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    {i₀ : Fin n} (hr : r i₀ = 1) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (f : Rn n → ℂ) (ε : ℝ), 0 ≤ ε → ∀ (m : ℕ) (top : ℕ → Tile n)
+      (T2 : ℕ → Finset (Tile n)),
+      (∀ i < m, Is2Tree α r (top i) (T2 i)) →
+      (∀ i < m, ∀ j < m, i ≠ j → Disjoint (T2 i) (T2 j)) →
+      (∀ i < m, ∀ j < m, i ≠ j → ∀ P ∈ T2 i, ∀ P' ∈ T2 j, P.ω.toSet α ⊆ P'.semiHO0 α →
+        Disjoint (P'.I.toSet α) ((top i).I.toSet α)) →
+      (∀ P ∈ (Finset.range m).biUnion T2, ‖pairing f (wavePhi α P)‖ ^ 2 ≤ ε ^ 2 * P.vol α) →
+      ∑ P ∈ (Finset.range m).biUnion T2, ∑ P' ∈ (Finset.range m).biUnion T2,
+        (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then
+          ‖pairing f (wavePhi α P)‖ * ‖pairing f (wavePhi α P')‖ *
+            ‖pairing (wavePhi α P) (wavePhi α P')‖ else 0) ≤
+        C * ε ^ 2 * ∑ i ∈ Finset.range m, (top i).vol α := by
+  obtain ⟨C0, hC0, hti⟩ := tile_interaction α hα (2 * absA α + 1)
+  obtain ⟨C1, hC1, hbd⟩ := boundary_sum_le α hα hn
+  set ν : ℝ := 2 * absA α + 1
+  have hνcast : (((2 * absA α + 1 : ℕ)) : ℝ) = ν := by simp [ν]
+  have hν0 : 0 ≤ ν := by positivity
+  refine ⟨C0 * 2 ^ ν * C1, by positivity, fun f ε hε m top T2 h2 hdisjT h61 hsing => ?_⟩
+  set U := (Finset.range m).biUnion T2
+  set a : Tile n → ℝ := fun P => ‖pairing f (wavePhi α P)‖
+  set t : Tile n → Tile n → ℝ := fun P P' => ‖pairing (wavePhi α P) (wavePhi α P')‖
+  set W : Tile n → Rn n → ℝ := fun P y => (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (y - P.cI α)) ^ (-ν)
+  have hW0 : ∀ P y, 0 ≤ W P y := fun P y => by
+    have := rho_nonneg α (y - P.cI α); positivity
+  have ha : ∀ P ∈ U, a P ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := by
+    intro P hP
+    have h := hsing P hP
+    rw [← sqrt_vol_eq α P, ← mul_pow] at h
+    exact (pow_le_pow_iff_left₀ (norm_nonneg _) (by positivity) two_ne_zero).mp h
+  -- step A: the individual terms
+  have hA : ∀ P ∈ U, ∀ P' ∈ U, P'.k < P.k → a P * a P' * t P P' ≤
+      C0 * ε ^ 2 * (P'.vol α * W P (P'.cI α)) := by
+    intro P hP P' hP' hk
+    have h := hti P P' hk.le
+    rw [hνcast, rho_sub_comm] at h
+    have hx : 0 ≤ ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := by positivity
+    have hx' : 0 ≤ ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) := by positivity
+    have h1 : ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) = 1 := by
+      rw [← Real.rpow_add (by positivity), show (absA α : ℝ) / 2 + -(absA α : ℝ) / 2 = 0 by ring,
+        Real.rpow_zero]
+    have h2 : ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) =
+        P'.vol α := by rw [← sq, sqrt_vol_eq]
+    calc a P * a P' * t P P' ≤ (ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) *
+          (ε * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2)) *
+          (C0 * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) *
+            W P (P'.cI α)) := by
+          gcongr
+          · exact ha P hP
+          · exact ha P' hP'
+      _ = C0 * ε ^ 2 * ((((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) *
+            ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)) * (((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2) *
+            ((2 : ℝ) ^ P'.k) ^ ((absA α : ℝ) / 2)) * W P (P'.cI α)) := by ring
+      _ = _ := by rw [h1, h2, one_mul]
+  -- step B: the inner sums, via the disjointness of the `I_{P'}`
+  have hB : ∀ i < m, ∀ P ∈ T2 i, ENNReal.ofReal (∑ P' ∈ U,
+      (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then P'.vol α * W P (P'.cI α) else 0)) ≤
+      ENNReal.ofReal (2 ^ ν) * ∫⁻ x in ((top i).I.toSet α)ᶜ, ENNReal.ofReal (W P x) := by
+    intro i hi P hP
+    have hPU : P ∈ U := Finset.mem_biUnion.mpr ⟨i, Finset.mem_range.mpr hi, hP⟩
+    set SP := U.filter fun P' => P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α
+    rw [← Finset.sum_filter, ENNReal.ofReal_sum_of_nonneg fun P' _ =>
+      mul_nonneg (P'.vol_pos α).le (hW0 _ _)]
+    have hpt : ∀ P' ∈ SP, ENNReal.ofReal (P'.vol α * W P (P'.cI α)) ≤
+        ENNReal.ofReal (2 ^ ν) * ∫⁻ x in P'.I.toSet α, ENNReal.ofReal (W P x) := by
+      intro P' hP'
+      obtain ⟨-, hk, -⟩ := Finset.mem_filter.mp hP'
+      rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+      have hconst : ENNReal.ofReal (P'.vol α * W P (P'.cI α)) =
+          ∫⁻ _ in P'.I.toSet α, ENNReal.ofReal (W P (P'.cI α)) := by
+        rw [setLIntegral_const, P'.volume_I α, ← ENNReal.ofReal_mul (hW0 _ _), mul_comm]
+      rw [hconst]
+      refine lintegral_mono_ae ((ae_restrict_iff' (DCube.measurableSet_toSet α P'.I)).mpr
+        (Filter.Eventually.of_forall fun x hx => ?_))
+      rw [← ENNReal.ofReal_mul (by positivity)]
+      refine ENNReal.ofReal_le_ofReal ?_
+      have hρ : rho α (P'.cI α - x) ≤ (2 : ℝ) ^ P.k := by
+        rw [rho_sub_comm]
+        exact (rho_sub_cI_le α hα P' hx).trans (zpow_le_zpow_right₀ (by norm_num) hk.le)
+      have := wgt_shift_le α hα (by positivity : (0 : ℝ) < (2 : ℝ) ^ P.k) hρ (P.cI α) hν0
+      simp only [W]
+      rw [rho_sub_comm α (P'.cI α), rho_sub_comm α x]
+      exact this
+    refine (Finset.sum_le_sum hpt).trans ?_
+    rw [← Finset.mul_sum]
+    gcongr
+    have hpd : (SP : Set (Tile n)).PairwiseDisjoint (fun P' => P'.I.toSet α) := by
+      intro P' hP' P'' hP'' hne
+      obtain ⟨hP'U, -, hω'⟩ := Finset.mem_filter.mp hP'
+      obtain ⟨hP''U, -, hω''⟩ := Finset.mem_filter.mp hP''
+      exact selected_disjoint_pair α hα hr h2 h61 hP'U hP''U hω' hω'' hne
+    rw [← lintegral_biUnion_finset hpd fun P' _ => DCube.measurableSet_toSet α P'.I]
+    refine lintegral_mono_set (Set.iUnion₂_subset fun P' hP' => ?_)
+    obtain ⟨hP'U, -, hω'⟩ := Finset.mem_filter.mp hP'
+    exact Set.subset_compl_iff_disjoint_right.mpr
+      (selected_disjoint_top α hr h2 h61 hi hP hP'U hω')
+  -- step C: the boundary estimate for each selected tree
+  have hC : ∀ i < m, ∑ P ∈ T2 i, ∑ P' ∈ U,
+      (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then P'.vol α * W P (P'.cI α) else 0) ≤
+      2 ^ ν * C1 * (top i).vol α := by
+    intro i hi
+    have hnn : ∀ P, 0 ≤ ∑ P' ∈ U,
+        (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then P'.vol α * W P (P'.cI α) else 0) :=
+      fun P => Finset.sum_nonneg fun P' _ => by
+        split_ifs
+        · exact mul_nonneg (P'.vol_pos α).le (hW0 _ _)
+        · exact le_rfl
+    rw [← ENNReal.ofReal_le_ofReal_iff (by have := (top i).vol_pos α; positivity),
+      ENNReal.ofReal_sum_of_nonneg fun P _ => hnn P]
+    refine (Finset.sum_le_sum fun P hP => hB i hi P hP).trans ?_
+    rw [← Finset.mul_sum]
+    have hb := hbd (top i) (T2 i) (fun P hP => ((h2 i hi).1 P hP).1)
+      (Is2Tree.injOn_I α (h2 i hi))
+    calc ENNReal.ofReal (2 ^ ν) * ∑ P ∈ T2 i, ∫⁻ x in ((top i).I.toSet α)ᶜ, ENNReal.ofReal (W P x)
+        ≤ ENNReal.ofReal (2 ^ ν) * ENNReal.ofReal (C1 * (top i).vol α) := by gcongr
+      _ = _ := by rw [← ENNReal.ofReal_mul (by positivity)]; congr 1; ring
+  -- step D: assembling
+  have hpdT : ((Finset.range m : Finset ℕ) : Set ℕ).PairwiseDisjoint T2 := by
+    intro i hi j hj hij
+    exact hdisjT i (Finset.mem_range.mp hi) j (Finset.mem_range.mp hj) hij
+  calc ∑ P ∈ U, ∑ P' ∈ U, (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then
+          a P * a P' * t P P' else 0)
+      ≤ ∑ P ∈ U, ∑ P' ∈ U, C0 * ε ^ 2 *
+          (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then P'.vol α * W P (P'.cI α) else 0) := by
+        refine Finset.sum_le_sum fun P hP => Finset.sum_le_sum fun P' hP' => ?_
+        split_ifs with hc
+        · exact hA P hP P' hP' hc.1
+        · simp
+    _ = C0 * ε ^ 2 * ∑ i ∈ Finset.range m, ∑ P ∈ T2 i, ∑ P' ∈ U,
+          (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then P'.vol α * W P (P'.cI α) else 0) := by
+        simp_rw [← Finset.mul_sum]
+        rw [Finset.sum_biUnion hpdT]
+    _ ≤ C0 * ε ^ 2 * ∑ i ∈ Finset.range m, 2 ^ ν * C1 * (top i).vol α := by
+        gcongr with i hi
+        exact hC i (Finset.mem_range.mp hi)
+    _ = C0 * 2 ^ ν * C1 * ε ^ 2 * ∑ i ∈ Finset.range m, (top i).vol α := by
+        rw [Finset.mul_sum, Finset.mul_sum]; congr 1; ext i; ring
+
+theorem energyCand_nonempty (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ) {lam : ℝ}
+    {s : Finset (Tile n)} {p : Tile n × Finset (Tile n)} (hp : p ∈ energyCand α r f lam s) :
+    p.2.Nonempty := by
+  by_contra hT
+  rw [Finset.not_nonempty_iff_eq_empty] at hT
+  have h := hp.2.2
+  rw [hT, Finset.sum_empty] at h
+  have := p.1.vol_pos α
+  nlinarith [sq_nonneg lam]
+
+/-- The frequency centre `c(ω_P)` lies in every closed semi-tile `ω_{P(r)}`. -/
+theorem Tile.cω_mem_semi (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) :
+    P.cω α ∈ P.semi α r := by
+  intro i
+  have hs := side_pos α (-P.k) i
+  simp only [Tile.cω, PiLp.toLp_apply]
+  have hr : ((r i : ℕ) : ℝ) = 0 ∨ ((r i : ℕ) : ℝ) = 1 := by
+    rcases Fin.exists_fin_two.mp ⟨r i, rfl⟩ with h | h <;> simp [h]
+  rcases hr with h | h <;> rw [h] <;> constructor <;> nlinarith
+
+theorem Is2Tree.singleton (α : Fin n → ℕ) (r : Fin n → Fin 2) (P : Tile n) :
+    Is2Tree α r P {P} := by
+  refine ⟨fun Q hQ => ?_, fun Q hQ => ?_⟩
+  · rw [Finset.mem_singleton.mp hQ]; exact Tile.le_refl α P
+  · rw [Finset.mem_singleton.mp hQ]; exact Tile.cω_mem_semi α P r
+
+/-- The energy bounds the normalized `ℓ²` sums over all `2`-trees in the collection. -/
+theorem sum_sq_le_of_energy_le (α : Fin n → ℕ) {r : Fin n → Fin 2} {f : Rn n → ℂ}
+    {S : Finset (Tile n)} {ε : ℝ} (hε : 0 ≤ ε) (hE : energy α r f S ≤ ENNReal.ofReal ε)
+    {top : Tile n} {T : Finset (Tile n)} (hTS : T ⊆ S) (h2 : Is2Tree α r top T) :
+    ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ ^ 2 ≤ ε ^ 2 * top.vol α := by
+  have hle : ENNReal.ofReal (Real.sqrt ((top.vol α)⁻¹ *
+      ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ ^ 2)) ≤ ENNReal.ofReal ε := by
+    refine le_trans ?_ hE
+    unfold energy
+    refine le_iSup_of_le top (le_iSup_of_le T (le_iSup_of_le hTS ?_))
+    rw [iSup_pos h2]
+  rw [ENNReal.ofReal_le_ofReal_iff hε, Real.sqrt_le_left hε] at hle
+  have hv := top.vol_pos α
+  rw [inv_mul_le_iff₀ hv] at hle
+  linarith
+
+theorem greedy_anti (α : Fin n → ℕ) {m : ℕ} {sel : ℕ → Tile n × Finset (Tile n)}
+    {st : ℕ → Finset (Tile n)}
+    (hstep : ∀ i < m, st (i + 1) = (st i).filter (fun P => ¬ Tile.le α P (sel i).1))
+    {a b : ℕ} (hab : a ≤ b) (hbm : b ≤ m) : st b ⊆ st a := by
+  induction b, hab using Nat.le_induction with
+  | base => exact subset_rfl
+  | succ b hab ih =>
+    rw [hstep b (by omega)]
+    exact (Finset.filter_subset _ _).trans (ih (by omega))
+
+open Classical in
+/-- **Energy lemma** (paper, Lemma 4.3, (4.7)–(4.8), proved in §6), threshold form: there is `C`
+such that for `f ∈ L²`, every finite set of tiles `S` and every `λ > 0` with `𝓔(S) ≤ 2λ`, the
+collection splits into `S_low ⊆ S` with `𝓔(S_low) ≤ λ` and a finite family of trees `T ⊆ S`
+covering the rest, with `∑_T |I_T| ≤ C ‖f‖₂² / λ²`. -/
+theorem energy_lemma (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) :
+    ∃ C : ℝ, 0 < C ∧ ∀ (f : Rn n → ℂ), MemLp f 2 → ∀ (S : Finset (Tile n)) (lam : ℝ), 0 < lam →
+      energy α r f S ≤ ENNReal.ofReal (2 * lam) →
+      ∃ (𝒯 : Finset (Tile n × Finset (Tile n))) (Slow : Finset (Tile n)),
+        Slow ⊆ S ∧ (∀ t ∈ 𝒯, IsTree α t.1 t.2 ∧ t.2 ⊆ S) ∧
+        (∀ P ∈ S, P ∈ Slow ∨ ∃ t ∈ 𝒯, P ∈ t.2) ∧
+        energy α r f Slow ≤ ENNReal.ofReal lam ∧
+        ∑ t ∈ 𝒯, t.1.vol α ≤ C * (eLpNorm f 2 volume).toReal ^ 2 / lam ^ 2 := by
+  obtain ⟨i₀, hi₀⟩ := exists_eq_one_of_ne_zero hr
+  obtain ⟨Cd, hCd, hdiag⟩ := diag_sum_le α hα
+  obtain ⟨Co, hCo, hoff⟩ := offdiag_sum_le α hα hn hi₀
+  set C' : ℝ := Cd + 2 * Co
+  have hC' : 0 ≤ C' := by positivity
+  refine ⟨4 * C' + 1, by positivity, fun f hf S lam hlam hES => ?_⟩
+  set a : Tile n → ℝ := fun P => ‖pairing f (wavePhi α P)‖
+  set ε : ℝ := 2 * lam
+  have hε : 0 ≤ ε := by positivity
+  -- the greedy selection
+  obtain ⟨m, sel, st, h0, hstep, hend⟩ := greedy_selection α (energyCand α r f lam)
+    (fun s p hp => ⟨hp.1, energyCand_nonempty α r f hp, hp.2.1.1⟩)
+    (energyCand_finite α hα hn r f hlam) (fun top => top.cω α i₀) S
+  set top : ℕ → Tile n := fun i => (sel i).1
+  set T2 : ℕ → Finset (Tile n) := fun i => (sel i).2
+  set T : ℕ → Finset (Tile n) := fun i => (st i).filter fun P => Tile.le α P (top i)
+  have hanti : ∀ a b, a ≤ b → b ≤ m → st b ⊆ st a := fun a b hab hbm =>
+    greedy_anti α (fun i hi => (hstep i hi).2.2) hab hbm
+  have hstS : ∀ j ≤ m, st j ⊆ S := fun j hj => h0 ▸ hanti 0 j (Nat.zero_le j) hj
+  have hcand : ∀ i < m, sel i ∈ energyCand α r f lam (st i) := fun i hi => (hstep i hi).1
+  have hT2st : ∀ i < m, T2 i ⊆ st i := fun i hi => (hcand i hi).1
+  have h2 : ∀ i < m, Is2Tree α r (top i) (T2 i) := fun i hi => (hcand i hi).2.1
+  have hT2T : ∀ i < m, T2 i ⊆ T i := fun i hi P hP =>
+    Finset.mem_filter.mpr ⟨hT2st i hi hP, (h2 i hi).1 P hP⟩
+  have hT2S : ∀ i < m, T2 i ⊆ S := fun i hi => (hT2st i hi).trans (hstS i hi.le)
+  -- disjointness of the selected `2`-trees
+  have hdisj : ∀ i < m, ∀ j < m, i ≠ j → Disjoint (T2 i) (T2 j) := by
+    have key : ∀ i < m, ∀ j < m, i < j → Disjoint (T2 i) (T2 j) := by
+      intro i hi j hj hij
+      refine Finset.disjoint_left.mpr fun P hPi hPj => ?_
+      have h1 : P ∈ st (i + 1) := hanti (i + 1) j hij hj.le (hT2st j hj hPj)
+      rw [(hstep i hi).2.2, Finset.mem_filter] at h1
+      exact h1.2 ((h2 i hi).1 P hPi)
+    intro i hi j hj hij
+    rcases lt_or_gt_of_ne hij with h | h
+    · exact key i hi j hj h
+    · exact (key j hj i hi h).symm
+  -- Lemma 6.1
+  have h61 : ∀ i < m, ∀ j < m, i ≠ j → ∀ P ∈ T2 i, ∀ P' ∈ T2 j, P.ω.toSet α ⊆ P'.semiHO0 α →
+      Disjoint (P'.I.toSet α) ((top i).I.toSet α) := by
+    intro i hi j hj hij P hP P' hP' hω
+    exact selection_disjoint α hα hn hi₀ (energyCand α r f lam) (fun s p hp => ⟨hp.1, hp.2.1⟩)
+      (fun s s' h => energyCand_mono α r f lam h) hstep hi hj hij hP hP' hω
+  -- the output
+  refine ⟨(Finset.range m).image fun i => (top i, T i), st m, hstS m le_rfl, ?_, ?_,
+    energy_le_of_energyCand_eq_empty α r f hlam hend, ?_⟩
+  · intro t ht
+    obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp ht
+    have hi' := Finset.mem_range.mp hi
+    exact ⟨fun P hP => (Finset.mem_filter.mp hP).2,
+      (Finset.filter_subset _ _).trans (hstS i hi'.le)⟩
+  · have hcov : ∀ j ≤ m, ∀ P ∈ S, P ∈ st j ∨ ∃ i < j, P ∈ T i := by
+      intro j hj
+      induction j with
+      | zero => intro P hP; left; rw [h0]; exact hP
+      | succ j ih =>
+        intro P hP
+        rcases ih (by omega) P hP with h | ⟨i, hi, hPi⟩
+        · by_cases hle : Tile.le α P (top j)
+          · exact Or.inr ⟨j, by omega, Finset.mem_filter.mpr ⟨h, hle⟩⟩
+          · left
+            rw [(hstep j (by omega)).2.2, Finset.mem_filter]
+            exact ⟨h, hle⟩
+        · exact Or.inr ⟨i, by omega, hPi⟩
+    intro P hP
+    rcases hcov m le_rfl P hP with h | ⟨i, hi, hPi⟩
+    · exact Or.inl h
+    · exact Or.inr ⟨(top i, T i), Finset.mem_image.mpr ⟨i, Finset.mem_range.mpr hi, rfl⟩, hPi⟩
+  -- the estimate
+  set U := (Finset.range m).biUnion T2
+  set V := ∑ i ∈ Finset.range m, (top i).vol α
+  have hV : 0 ≤ V := Finset.sum_nonneg fun i _ => ((top i).vol_pos α).le
+  have hpdT : ((Finset.range m : Finset ℕ) : Set ℕ).PairwiseDisjoint T2 := by
+    intro i hi j hj hij
+    exact hdisj i (Finset.mem_range.mp hi) j (Finset.mem_range.mp hj) hij
+  set A := ∑ P ∈ U, a P ^ 2
+  have hAsplit : A = ∑ i ∈ Finset.range m, ∑ P ∈ T2 i, a P ^ 2 := Finset.sum_biUnion hpdT
+  have hlamV : lam ^ 2 * V ≤ A := by
+    rw [hAsplit, Finset.mul_sum]
+    exact Finset.sum_le_sum fun i hi => ((hcand i (Finset.mem_range.mp hi)).2.2).le
+  have hAV : A ≤ ε ^ 2 * V := by
+    rw [hAsplit, Finset.mul_sum]
+    exact Finset.sum_le_sum fun i hi =>
+      sum_sq_le_of_energy_le α hε hES (hT2S i (Finset.mem_range.mp hi)) (h2 i
+          (Finset.mem_range.mp hi))
+  have hUS : U ⊆ S := Finset.biUnion_subset.mpr fun i hi => hT2S i (Finset.mem_range.mp hi)
+  have hsing : ∀ P ∈ U, a P ^ 2 ≤ ε ^ 2 * P.vol α := by
+    intro P hP
+    have := sum_sq_le_of_energy_le α hε hES (Finset.singleton_subset_iff.mpr (hUS hP))
+      (Is2Tree.singleton α r P)
+    simpa using this
+  -- the pair sum
+  set t : Tile n → Tile n → ℝ := fun P P' => ‖pairing (wavePhi α P) (wavePhi α P')‖
+  set B := ∑ P ∈ U, ∑ P' ∈ U, a P * a P' * t P P'
+  have hB0 : 0 ≤ B := Finset.sum_nonneg fun P _ => Finset.sum_nonneg fun P' _ => by positivity
+  have hBsplit : B ≤ ∑ P ∈ U, ∑ P' ∈ U, (if P.ω = P'.ω then a P * a P' * t P P' else 0) +
+      2 * ∑ P ∈ U, ∑ P' ∈ U, (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then
+        a P * a P' * t P P' else 0) := by
+    have hpt : ∀ P P', a P * a P' * t P P' ≤ (if P.ω = P'.ω then a P * a P' * t P P' else 0) +
+        (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then a P * a P' * t P P' else 0) +
+        (if P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α then a P' * a P * t P' P else 0) := by
+      intro P P'
+      have hnn : 0 ≤ a P * a P' * t P P' := by positivity
+      have hsymm : a P' * a P * t P' P = a P * a P' * t P P' := by
+        rw [show t P' P = t P P' from norm_pairing_comm _ _]; ring
+      by_cases ht0 : pairing (wavePhi α P) (wavePhi α P') = 0
+      · have : t P P' = 0 := by simp [t, ht0]
+        rw [this, mul_zero]
+        have e1 : (if P.ω = P'.ω then a P * a P' * (0 : ℝ) else 0) = 0 := by split_ifs <;> simp
+        refine add_nonneg (add_nonneg ?_ ?_) ?_ <;> split_ifs <;> positivity
+      · rcases pairing_wavePhi_eq_zero_or α hα P P' ht0 with h | h | h
+        · rw [ite_eq_left h]
+          have h1 : 0 ≤ (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then a P * a P' * t P P'
+              else 0) := by
+            split_ifs <;> positivity
+          have h2 : 0 ≤ (if P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α then a P' * a P * t P' P
+              else 0) := by
+            split_ifs <;> positivity
+          linarith
+        · rw [ite_eq_left h]
+          have h1 : 0 ≤ (if P.ω = P'.ω then a P * a P' * t P P' else 0) := by
+            split_ifs <;> positivity
+          have h2 : 0 ≤ (if P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α then a P' * a P * t P' P
+              else 0) := by
+            split_ifs <;> positivity
+          linarith
+        · rw [ite_eq_left h, hsymm]
+          have h1 : 0 ≤ (if P.ω = P'.ω then a P * a P' * t P P' else 0) := by
+            split_ifs <;> positivity
+          have h2 : 0 ≤ (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then a P * a P' * t P P'
+              else 0) := by
+            split_ifs <;> positivity
+          linarith
+    calc B ≤ ∑ P ∈ U, ∑ P' ∈ U, ((if P.ω = P'.ω then a P * a P' * t P P' else 0) +
+          (if P'.k < P.k ∧ P.ω.toSet α ⊆ P'.semiHO0 α then a P * a P' * t P P' else 0) +
+          (if P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α then a P' * a P * t P' P else 0)) :=
+          Finset.sum_le_sum fun P _ => Finset.sum_le_sum fun P' _ => hpt P P'
+      _ = _ := by
+          simp only [Finset.sum_add_distrib]
+          rw [Finset.sum_comm (f := fun P P' => if P.k < P'.k ∧ P'.ω.toSet α ⊆ P.semiHO0 α then
+            a P' * a P * t P' P else 0)]
+          ring
+  have hBbound : B ≤ C' * ε ^ 2 * V := by
+    have hd := hdiag U a (fun P => norm_nonneg _)
+    have ho := hoff f ε hε m top T2 h2 hdisj h61 hsing
+    calc B ≤ Cd * A + 2 * (Co * ε ^ 2 * V) := by
+          refine hBsplit.trans (add_le_add hd ?_)
+          exact mul_le_mul_of_nonneg_left ho (by norm_num)
+      _ ≤ Cd * (ε ^ 2 * V) + 2 * (Co * ε ^ 2 * V) := by gcongr
+      _ = C' * ε ^ 2 * V := by ring
+  have hbessel := bessel_wavePhi α hα hf U
+  set Nf := (eLpNorm f 2 volume).toReal
+  have hNf : 0 ≤ Nf := ENNReal.toReal_nonneg
+  -- conclusion: `λ⁴ V² ≤ ‖f‖² · 4 C' λ² V`
+  have hAle : A ≤ Nf * Real.sqrt B := hbessel
+  have hkey : lam ^ 2 * V ≤ Nf * Real.sqrt (C' * ε ^ 2 * V) :=
+    hlamV.trans (hAle.trans (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hBbound) hNf))
+  have hVbound : V ≤ 4 * C' * Nf ^ 2 / lam ^ 2 := by
+    rcases hV.lt_or_eq with hVpos | hV0
+    · have hsq : (lam ^ 2 * V) ^ 2 ≤ Nf ^ 2 * (C' * ε ^ 2 * V) := by
+        have h1 := pow_le_pow_left₀ (by positivity) hkey 2
+        rw [mul_pow Nf, Real.sq_sqrt (by positivity)] at h1
+        exact h1
+      rw [le_div_iff₀ (by positivity)]
+      have : lam ^ 4 * V ^ 2 ≤ Nf ^ 2 * (C' * (4 * lam ^ 2) * V) := by
+        have e : (2 * lam) ^ 2 = 4 * lam ^ 2 := by ring
+        simp only [ε, e] at hsq
+        nlinarith only [hsq]
+      have hl : 0 < lam ^ 2 * V := by positivity
+      apply (mul_le_mul_iff_right₀ hl).mp
+      nlinarith only [this]
+    · rw [← hV0]; positivity
+  calc ∑ t ∈ (Finset.range m).image (fun i => (top i, T i)), t.1.vol α
+      ≤ ∑ i ∈ Finset.range m, (top i).vol α :=
+        Finset.sum_image_le_of_nonneg fun t _ => (t.1.vol_pos α).le
+    _ ≤ 4 * C' * Nf ^ 2 / lam ^ 2 := hVbound
+    _ ≤ (4 * C' + 1) * Nf ^ 2 / lam ^ 2 := by gcongr; linarith
+
+/-! ## Section 7: the tree estimate -/
+
+/-! ### The anisotropic maximal function -/
+
+theorem rho_zero (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) : rho α (0 : Rn n) = 0 := by
+  simp [rho, rhoNN_zero α hα]
+
+theorem setOf_rho_le_eq_preimage (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : ℝ} (hr : 0 < r) :
+    {y : Rn n | rho α y ≤ r} = dil α r⁻¹ ⁻¹' {y | rho α y ≤ 1} := by
+  ext y
+  simp only [Set.mem_ofPred_eq, Set.mem_preimage]
+  rw [rho_dil α hα (inv_pos.mpr hr), inv_mul_le_iff₀ hr, mul_one]
+
+theorem volume_rho_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : ℝ} (hr : 0 < r) :
+    volume {y : Rn n | rho α y ≤ r} =
+      ENNReal.ofReal (r ^ (absA α : ℝ)) * volume {y : Rn n | rho α y ≤ 1} := by
+  have hmeas : MeasurableSet {y : Rn n | rho α y ≤ 1} :=
+    measurableSet_le (continuous_rho α).measurable measurable_const
+  rw [setOf_rho_le_eq_preimage α hα hr, ← Measure.map_apply (dil_measurableEmbedding α
+    (inv_pos.mpr hr)).measurable hmeas, map_dil_volume α (inv_pos.mpr hr), Measure.smul_apply,
+    smul_eq_mul, inv_pow, inv_inv, Real.rpow_natCast]
+
+theorem setOf_rho_le_one_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    {y : Rn n | rho α y ≤ 1} = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹'
+      Set.pi Set.univ (fun _ => Set.Icc (-1) 1) := by
+  ext y
+  simp only [Set.mem_ofPred_eq, Set.mem_preimage, Set.mem_pi, Set.mem_univ, true_implies,
+    Set.mem_Icc]
+  constructor
+  · intro h i
+    have h1 := abs_coord_le_rho_pow α hα y i
+    have h2 : rho α y ^ α i ≤ 1 := pow_le_one₀ (rho_nonneg α y) h
+    exact abs_le.mp (h1.trans h2)
+  · intro h
+    have hle : rhoNN α y ≤ 1 := by
+      rw [rhoNN_le_iff]
+      intro i
+      rw [← NNReal.coe_le_coe]
+      simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs, NNReal.coe_one]
+      exact Real.rpow_le_one (abs_nonneg _) (abs_le.mpr (h i)) (by positivity)
+    exact_mod_cast hle
+
+theorem volume_rho_le_one (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    volume {y : Rn n | rho α y ≤ 1} = 2 ^ n := by
+  rw [setOf_rho_le_one_eq α hα, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun _ => measurableSet_Icc).nullMeasurableSet, volume_pi_pi]
+  simp only [Real.volume_Icc, Finset.prod_const, Finset.card_univ, Fintype.card_fin]
+  norm_num
+
+theorem volume_rho_le_one_pos (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    0 < volume {y : Rn n | rho α y ≤ 1} := by
+  rw [volume_rho_le_one α hα]; positivity
+
+theorem volume_rho_le_one_lt_top (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) :
+    volume {y : Rn n | rho α y ≤ 1} < ⊤ := by
+  rw [volume_rho_le_one α hα]; exact ENNReal.pow_lt_top (by norm_num)
+
+/-- The anisotropic norm as a homogeneous gauge for Lebesgue measure (homogeneous dimension
+    `|α|`). -/
+def anisoGauge (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) : HomGauge (Rn n) volume where
+  ρ := rho α
+  continuous := continuous_rho α
+  nonneg := rho_nonneg α
+  zero := rho_zero α hα
+  neg := rho_neg α
+  add_le := rho_add_le α hα
+  D := absA α
+  D_pos := by exact_mod_cast absA_pos α hα hn
+  vol := fun r hr => volume_rho_le α hα hr
+  vol_pos := volume_rho_le_one_pos α hα
+  vol_lt_top := volume_rho_le_one_lt_top α hα
+
+/-! ### The enlarged cubes `J_tilde` and the partition `𝒥` (paper, §7, texline~581–584) -/
+
+/-- The enlarged cube `J_tilde = ∏ᵢ (2^{αᵢ+1} − 1) Jᵢ` (half-open, concentric with `J`). -/
+def DCube.enl3 (α : Fin n → ℕ) (J : DCube n) : Set (Rn n) :=
+  {x | ∀ i, side α J.k i * (J.ℓ i + 1 - 2 ^ α i) ≤ x i ∧ x i < side α J.k i * (J.ℓ i + 2 ^ α i)}
+
+theorem DCube.toSet_subset_enl3 (α : Fin n → ℕ) (J : DCube n) : J.toSet α ⊆ J.enl3 α := by
+  intro x hx i
+  have h := hx i
+  have hs := side_pos α J.k i
+  have hA : (1 : ℝ) ≤ 2 ^ α i := one_le_pow₀ (by norm_num)
+  constructor <;> nlinarith only [h.1, h.2, hs, hA]
+
+/-- Index form of dyadic containment: if `Q ⊆ Q'` with `k ≤ k'`, then `B ℓ' ≤ ℓ ≤ B ℓ' + B − 1`
+coordinatewise, where `B = 2^{(k'−k)αᵢ}`. -/
+theorem DCube.index_bounds_of_subset (α : Fin n → ℕ) {Q Q' : DCube n} (d : ℕ)
+    (hk : Q'.k = Q.k + d) (h : Q.toSet α ⊆ Q'.toSet α) (i : Fin n) :
+    ((2 ^ (d * α i) : ℕ) : ℤ) * Q'.ℓ i ≤ Q.ℓ i ∧
+      Q.ℓ i + 1 ≤ ((2 ^ (d * α i) : ℕ) : ℤ) * (Q'.ℓ i + 1) := by
+  have hc := h (DCube.center_mem α Q) i
+  simp only [DCube.center, PiLp.toLp_apply] at hc
+  rw [hk, side_natCast_eq] at hc
+  have hs := side_pos α Q.k i
+  generalize (2 ^ (d * α i) : ℕ) = Bn at hc ⊢
+  have h1 : ((Bn : ℝ) * Q'.ℓ i : ℝ) < Q.ℓ i + 1 := by
+    have : side α Q.k i * (Bn * Q'.ℓ i) < side α Q.k i * (Q.ℓ i + 1) := by nlinarith [hc.1]
+    exact lt_of_mul_lt_mul_left this hs.le
+  have h2 : (Q.ℓ i : ℝ) < Bn * (Q'.ℓ i + 1) := by
+    have : side α Q.k i * Q.ℓ i < side α Q.k i * (Bn * (Q'.ℓ i + 1)) := by nlinarith [hc.2]
+    exact lt_of_mul_lt_mul_left this hs.le
+  constructor
+  · have : ((((Bn : ℤ)) * Q'.ℓ i : ℤ) : ℝ) < ((Q.ℓ i + 1 : ℤ) : ℝ) := by
+      push_cast; exact h1
+    exact Int.lt_add_one_iff.mp (by exact_mod_cast this)
+  · have : ((Q.ℓ i : ℤ) : ℝ) < ((((Bn : ℤ)) * (Q'.ℓ i + 1) : ℤ) : ℝ) := by
+      push_cast; exact h2
+    exact Int.add_one_le_iff.mpr (by exact_mod_cast this)
+
+/-- Enlargement is monotone under dyadic containment. -/
+theorem DCube.enl3_subset_of_subset (α : Fin n → ℕ) {Q Q' : DCube n} (hk : Q.k ≤ Q'.k)
+    (h : Q.toSet α ⊆ Q'.toSet α) : Q.enl3 α ⊆ Q'.enl3 α := by
+  obtain ⟨d, hd⟩ := Int.eq_ofNat_of_zero_le (sub_nonneg.mpr hk)
+  have hk' : Q'.k = Q.k + d := by omega
+  intro y hy i
+  obtain ⟨hb1, hb2⟩ := DCube.index_bounds_of_subset α d hk' h i
+  have hyi := hy i
+  rw [hk', side_natCast_eq]
+  have hBn1 : 1 ≤ 2 ^ (d * α i) := Nat.one_le_two_pow
+  generalize (2 ^ (d * α i) : ℕ) = Bn at hb1 hb2 hBn1 ⊢
+  set s := side α Q.k i
+  set A : ℝ := (2 : ℝ) ^ α i
+  have hs : 0 < s := side_pos α Q.k i
+  have hB : (1 : ℝ) ≤ Bn := by exact_mod_cast hBn1
+  set B : ℝ := (Bn : ℝ)
+  have hA : 1 ≤ A := one_le_pow₀ (by norm_num)
+  have hb1' : B * Q'.ℓ i ≤ Q.ℓ i := by simp only [B]; exact_mod_cast hb1
+  have hb2' : (Q.ℓ i : ℝ) + 1 ≤ B * (Q'.ℓ i + 1) := by simp only [B]; exact_mod_cast hb2
+  have hBA : 0 ≤ (B - 1) * (A - 1) := mul_nonneg (by linarith) (by linarith)
+  constructor
+  · have : s * B * (Q'.ℓ i + 1 - A) ≤ s * (Q.ℓ i + 1 - A) := by
+      have : B * (Q'.ℓ i + 1 - A) ≤ Q.ℓ i + 1 - A := by
+        nlinarith only [hb1', hBA]
+      simpa only [mul_assoc] using mul_le_mul_of_nonneg_left this hs.le
+    linarith only [hyi.1, this]
+  · have : s * (Q.ℓ i + A) ≤ s * B * (Q'.ℓ i + A) := by
+      have : (Q.ℓ i : ℝ) + A ≤ B * (Q'.ℓ i + A) := by
+        nlinarith only [hb2', hBA]
+      simpa only [mul_assoc] using mul_le_mul_of_nonneg_left this hs.le
+    linarith only [hyi.2, this]
+
+/-- A dyadic cube of scale `≤ k_J` meeting `J_tilde` is contained in `J_tilde`. -/
+theorem DCube.subset_enl3_of_inter (α : Fin n → ℕ) {Q J : DCube n} (hk : Q.k ≤ J.k)
+    (h : (Q.toSet α ∩ J.enl3 α).Nonempty) : Q.toSet α ⊆ J.enl3 α := by
+  obtain ⟨d, hd⟩ := Int.eq_ofNat_of_zero_le (sub_nonneg.mpr hk)
+  have hk' : J.k = Q.k + d := by omega
+  obtain ⟨x, hxQ, hxJ⟩ := h
+  intro y hy i
+  have hx1 := hxQ i
+  have hx2 := hxJ i
+  have hy1 := hy i
+  rw [hk', side_natCast_eq] at hx2 ⊢
+  set s := side α Q.k i
+  set B : ℝ := ((2 ^ (d * α i) : ℕ) : ℝ)
+  have hs : 0 < s := side_pos α Q.k i
+  -- integrality of the endpoints of `J_tilde` on the grid of `Q`
+  have hA : ((2 : ℝ) ^ α i) = ((2 ^ α i : ℕ) : ℝ) := by push_cast; rfl
+  set L1 : ℤ := ((2 ^ (d * α i) : ℕ) : ℤ) * (J.ℓ i + 1 - (2 ^ α i : ℕ))
+  set L2 : ℤ := ((2 ^ (d * α i) : ℕ) : ℤ) * (J.ℓ i + (2 ^ α i : ℕ))
+  have e1 : B * (J.ℓ i + 1 - 2 ^ α i) = (L1 : ℝ) := by simp only [L1, B]; push_cast; ring
+  have e2 : B * (J.ℓ i + 2 ^ α i) = (L2 : ℝ) := by simp only [L2, B]; push_cast; ring
+  have hx2a : s * (L1 : ℝ) ≤ x i := by rw [← e1]; nlinarith [hx2.1]
+  have hx2b : x i < s * (L2 : ℝ) := by rw [← e2]; nlinarith [hx2.2]
+  have hQ1 : L1 ≤ Q.ℓ i := by
+    have : (L1 : ℝ) < Q.ℓ i + 1 := by
+      have : s * (L1 : ℝ) < s * (Q.ℓ i + 1) := by linarith [hx1.2]
+      exact lt_of_mul_lt_mul_left this hs.le
+    exact Int.lt_add_one_iff.mp (by exact_mod_cast this)
+  have hQ2 : Q.ℓ i + 1 ≤ L2 := by
+    have : (Q.ℓ i : ℝ) < L2 := by
+      have : s * (Q.ℓ i : ℝ) < s * L2 := by linarith [hx1.1]
+      exact lt_of_mul_lt_mul_left this hs.le
+    exact Int.add_one_le_iff.mpr (by exact_mod_cast this)
+  have hQ1' : (L1 : ℝ) ≤ Q.ℓ i := by exact_mod_cast hQ1
+  have hQ2' : (Q.ℓ i : ℝ) + 1 ≤ L2 := by exact_mod_cast hQ2
+  constructor
+  · rw [show s * B * (J.ℓ i + 1 - 2 ^ α i) = s * (L1 : ℝ) by rw [← e1]; ring]
+    nlinarith [hy1.1]
+  · rw [show s * B * (J.ℓ i + 2 ^ α i) = s * (L2 : ℝ) by rw [← e2]; ring]
+    nlinarith [hy1.2]
+
+/-- A dyadic cube contained in `J_tilde` has scale at most `k_J + 1`. -/
+theorem DCube.k_le_of_subset_enl3 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {Q J : DCube n} (h : Q.toSet α ⊆ J.enl3 α) : Q.k ≤ J.k + 1 := by
+  by_contra hlt
+  push Not at hlt
+  set i : Fin n := ⟨0, hn⟩
+  set corner : Fin n → ℝ := fun j => side α Q.k j * Q.ℓ j
+  have hcorner : ∀ v : ℝ, side α Q.k i * Q.ℓ i ≤ v → v < side α Q.k i * (Q.ℓ i + 1) →
+      WithLp.toLp 2 (Function.update corner i v) ∈ Q.toSet α := by
+    intro v hv1 hv2 j
+    by_cases hj : j = i
+    · subst hj; simp [hv1, hv2]
+    · have hs := side_pos α Q.k j
+      simp only [Function.update_of_ne hj, corner]
+      constructor <;> nlinarith
+  have hsQ := side_pos α Q.k i
+  have hsJ := side_pos α J.k i
+  have hlo : side α J.k i * (J.ℓ i + 1 - 2 ^ α i) ≤ side α Q.k i * Q.ℓ i := by
+    have := (h (hcorner _ le_rfl (by nlinarith)) i).1
+    simpa using this
+  have hhi : side α Q.k i * (Q.ℓ i + 1) ≤ side α J.k i * (J.ℓ i + 2 ^ α i) := by
+    by_contra hcon
+    push Not at hcon
+    set v := max (side α Q.k i * Q.ℓ i) (side α J.k i * (J.ℓ i + 2 ^ α i))
+    have hv := (h (hcorner v (le_max_left _ _) (max_lt (by nlinarith) hcon)) i).2
+    simp only [Function.update_self] at hv
+    exact absurd (le_max_right _ _) (not_le.mpr hv)
+  have hA : (2 : ℝ) ≤ 2 ^ α i := by
+    calc (2 : ℝ) = 2 ^ 1 := by norm_num
+      _ ≤ 2 ^ α i := pow_le_pow_right₀ (by norm_num) (hα i)
+  have hside : side α J.k i * (2 ^ α i) ^ 2 ≤ side α Q.k i := by
+    have := side_mono α (show J.k + 2 ≤ Q.k by omega) i
+    rw [side_add] at this
+    have e : side α 2 i = (2 ^ α i) ^ 2 := by
+      simp only [side]; rw [← zpow_natCast, ← zpow_natCast, ← zpow_mul]; norm_cast; ring_nf
+    rw [e] at this
+    exact this
+  nlinarith
+
+/-- `J` is admissible for the tree `T` if `J_tilde` contains no `I_P`, `P ∈ T`. -/
+def treeOK (α : Fin n → ℕ) (T : Finset (Tile n)) (J : DCube n) : Prop :=
+  ∀ P ∈ T, ¬ P.I.toSet α ⊆ J.enl3 α
+
+/-- The partition `𝒥` (paper, §7, texline~584): maximal admissible dyadic cubes. -/
+def jSet (α : Fin n → ℕ) (T : Finset (Tile n)) : Set (DCube n) :=
+  {J | treeOK α T J ∧ ¬ treeOK α T (J.parent α)}
+
+/-- The dyadic cube of scale `k` containing `x`. -/
+def DCube.ofPoint (α : Fin n → ℕ) (k : ℤ) (x : Rn n) : DCube n :=
+  ⟨k, fun i => ⌊x i / side α k i⌋⟩
+
+theorem DCube.mem_ofPoint (α : Fin n → ℕ) (k : ℤ) (x : Rn n) :
+    x ∈ (DCube.ofPoint α k x).toSet α := by
+  rw [DCube.mem_toSet_iff_floor]; intro i; rfl
+
+theorem DCube.parent_ofPoint (α : Fin n → ℕ) (k : ℤ) (x : Rn n) :
+    (DCube.ofPoint α k x).parent α = DCube.ofPoint α (k + 1) x :=
+  DCube.eq_of_mem_of_k_eq α (by simp [DCube.parent, DCube.ancestor, DCube.ofPoint])
+    (DCube.toSet_subset_ancestor α _ 1 (DCube.mem_ofPoint α k x)) (DCube.mem_ofPoint α (k + 1) x)
+
+theorem DCube.parent_k (α : Fin n → ℕ) (J : DCube n) : (J.parent α).k = J.k + 1 := by
+  simp [DCube.parent, DCube.ancestor]
+
+theorem DCube.toSet_subset_parent' (α : Fin n → ℕ) (J : DCube n) :
+    J.toSet α ⊆ (J.parent α).toSet α := DCube.toSet_subset_ancestor α J 1
+
+theorem treeOK_of_subset (α : Fin n → ℕ) (T : Finset (Tile n)) {Q Q' : DCube n}
+    (hk : Q.k ≤ Q'.k) (h : Q.toSet α ⊆ Q'.toSet α) (hQ' : treeOK α T Q') : treeOK α T Q :=
+  fun P hP hsub => hQ' P hP (hsub.trans (DCube.enl3_subset_of_subset α hk h))
+
+instance : Countable (DCube n) :=
+  Function.Injective.countable (f := fun J : DCube n => (J.k, J.ℓ)) fun a b h => by
+    cases a; cases b; simp_all
+
+theorem treeOK_ofPoint_small (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    (T : Finset (Tile n)) {k : ℤ} (hk : ∀ P ∈ T, k + 1 < P.k) (x : Rn n) :
+    treeOK α T (DCube.ofPoint α k x) := fun P hP hsub =>
+  absurd (DCube.k_le_of_subset_enl3 α hα hn hsub) (by
+    have := hk P hP; simp only [Tile.I, DCube.ofPoint]; omega)
+
+theorem not_treeOK_ofPoint_large (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (T : Finset (Tile n))
+    {P₀ : Tile n} (hP₀ : P₀ ∈ T) (x : Rn n) : ∃ K : ℤ, ∀ k, K ≤ k →
+      ¬ treeOK α T (DCube.ofPoint α k x) := by
+  -- a bound for the coordinates of `x` and `I_{P₀}`
+  set M : ℝ := ∑ i, (|x i| + |side α P₀.k i * P₀.ℓ i| + |side α P₀.k i * (P₀.ℓ i + 1)|) + 1
+  obtain ⟨K, hK⟩ := pow_unbounded_of_one_lt M (show (1 : ℝ) < 2 by norm_num)
+  refine ⟨(K : ℤ), fun k hk hok => hok P₀ hP₀ fun y hy i => ?_⟩
+  have hyi := hy i
+  simp only [Tile.I] at hyi
+  set s := side α k i
+  have hs : 0 < s := side_pos α k i
+  have hsK : (2 : ℝ) ^ K ≤ s := by
+    rw [← zpow_natCast]
+    refine zpow_le_zpow_right₀ (by norm_num) ?_
+    have := hα i
+    have hk0 : (0 : ℤ) ≤ k := le_trans (Int.natCast_nonneg K) hk
+    nlinarith
+  have hbound : |x i| + |side α P₀.k i * P₀.ℓ i| + |side α P₀.k i * (P₀.ℓ i + 1)| < s := by
+    have : |x i| + |side α P₀.k i * P₀.ℓ i| + |side α P₀.k i * (P₀.ℓ i + 1)| ≤ M - 1 := by
+      have := Finset.single_le_sum (f := fun i => |x i| + |side α P₀.k i * P₀.ℓ i| +
+        |side α P₀.k i * (P₀.ℓ i + 1)|) (fun j _ => by positivity) (Finset.mem_univ i)
+      simp only [M]; linarith
+    linarith
+  have hfl := Int.floor_le (x i / s)
+  have hfl' := Int.lt_floor_add_one (x i / s)
+  rw [le_div_iff₀ hs] at hfl
+  rw [div_lt_iff₀ hs] at hfl'
+  have hA : (2 : ℝ) ≤ 2 ^ α i := by
+    calc (2 : ℝ) = 2 ^ 1 := by norm_num
+      _ ≤ 2 ^ α i := pow_le_pow_right₀ (by norm_num) (hα i)
+  simp only [DCube.ofPoint]
+  constructor
+  · have : x i - s ≤ y i := by
+      have := abs_lt.mp (show |y i - x i| < s by
+        have : |y i| ≤ |side α P₀.k i * P₀.ℓ i| + |side α P₀.k i * (P₀.ℓ i + 1)| := by
+          rw [abs_le]; constructor <;> cases abs_cases (side α P₀.k i * P₀.ℓ i) <;>
+            cases abs_cases (side α P₀.k i * (P₀.ℓ i + 1)) <;> linarith [hyi.1, hyi.2]
+        calc |y i - x i| ≤ |y i| + |x i| := abs_sub _ _
+          _ < s := by linarith)
+      linarith
+    nlinarith only [hs, hfl, hA, this]
+  · have : y i < x i + s := by
+      have : |y i| ≤ |side α P₀.k i * P₀.ℓ i| + |side α P₀.k i * (P₀.ℓ i + 1)| := by
+        rw [abs_le]; constructor <;> cases abs_cases (side α P₀.k i * P₀.ℓ i) <;>
+          cases abs_cases (side α P₀.k i * (P₀.ℓ i + 1)) <;> linarith [hyi.1, hyi.2]
+      have := neg_abs_le (x i)
+      have := le_abs_self (y i)
+      linarith
+    nlinarith only [hs, hfl', hA, this]
+
+theorem exists_mem_jSet (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (T : Finset (Tile n))
+    (hT : T.Nonempty) (x : Rn n) : ∃ J ∈ jSet α T, x ∈ J.toSet α := by
+  classical
+  obtain ⟨P₀, hP₀⟩ := hT
+  obtain ⟨K, hK⟩ := not_treeOK_ofPoint_large α hα T hP₀ x
+  set k₀ : ℤ := T.inf' ⟨P₀, hP₀⟩ (fun P => P.k) - 2
+  have hk₀ : treeOK α T (DCube.ofPoint α k₀ x) :=
+    treeOK_ofPoint_small α hα hn T (fun P hP => by
+      have := Finset.inf'_le (fun P : Tile n => P.k) hP
+      simp only [k₀]; omega) x
+  obtain ⟨k, hk, hmax⟩ := Int.exists_greatest_of_bdd
+    (P := fun k => treeOK α T (DCube.ofPoint α k x))
+    ⟨K, fun z hz => by
+      by_contra h
+      push Not at h
+      exact hK z h.le hz⟩ ⟨k₀, hk₀⟩
+  refine ⟨DCube.ofPoint α k x, ⟨hk, ?_⟩, DCube.mem_ofPoint α k x⟩
+  rw [DCube.parent_ofPoint]
+  intro h
+  have := hmax (k + 1) h
+  omega
+
+theorem jSet_disjoint (α : Fin n → ℕ) (T : Finset (Tile n)) {J J' : DCube n}
+    (hJ : J ∈ jSet α T) (hJ' : J' ∈ jSet α T) (hne : J ≠ J') :
+    Disjoint (J.toSet α) (J'.toSet α) := by
+  by_contra h
+  rw [Set.not_disjoint_iff_nonempty_inter] at h
+  wlog hk : J.k ≤ J'.k generalizing J J'
+  · exact this hJ' hJ (Ne.symm hne) (by rwa [Set.inter_comm]) (le_of_not_ge hk)
+  obtain ⟨x, hxJ, hxJ'⟩ := h
+  rcases DCube.subset_or_disjoint α J J' hk with hsub | hdisj
+  · rcases hk.lt_or_eq with hlt | heq
+    · have hpk : (J.parent α).k ≤ J'.k := by rw [DCube.parent_k]; omega
+      have hpsub : (J.parent α).toSet α ⊆ J'.toSet α := by
+        rcases DCube.subset_or_disjoint α (J.parent α) J' hpk with h1 | h1
+        · exact h1
+        · exact absurd hxJ' (Set.disjoint_left.mp h1 (DCube.toSet_subset_parent' α J hxJ))
+      exact hJ.2 (treeOK_of_subset α T hpk hpsub hJ'.1)
+    · exact hne (DCube.eq_of_mem_of_k_eq α heq hxJ hxJ')
+  · exact Set.disjoint_left.mp hdisj hxJ hxJ'
+
+/-- Integrals decompose along the partition `𝒥`. -/
+theorem lintegral_eq_tsum_jSet (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    (T : Finset (Tile n)) (hT : T.Nonempty) (f : Rn n → ℝ≥0∞) :
+    ∫⁻ x, f x = ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, f x := by
+  have hU : (⋃ J : jSet α T, (J : DCube n).toSet α) = Set.univ := by
+    refine Set.eq_univ_of_forall fun x => ?_
+    obtain ⟨J, hJ, hx⟩ := exists_mem_jSet α hα hn T hT x
+    exact Set.mem_iUnion.mpr ⟨⟨J, hJ⟩, hx⟩
+  rw [← lintegral_iUnion (fun J => DCube.measurableSet_toSet α _)
+    (fun J J' hne => jSet_disjoint α T J.2 J'.2 (fun h => hne (Subtype.ext h))), hU,
+    Measure.restrict_univ]
+
+/-! ### Auxiliary weight estimates for the tree estimate -/
+
+/-- Within a tree the spatial cubes determine the tiles. -/
+theorem IsTree.injOn_I (α : Fin n → ℕ) {top : Tile n} {T : Finset (Tile n)}
+    (h : IsTree α top T) : Set.InjOn Tile.I (T : Set (Tile n)) := by
+  intro P hP Q hQ hPQ
+  have hk : P.k = Q.k := congrArg DCube.k hPQ
+  exact Tile.ext_I_ω hPQ (DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) (h P hP).2 (h Q hQ).2)
+
+/-- Fixed-scale lattice sums over a tree are bounded (paper, (7.3)). -/
+theorem tree_scale_sum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {b : ℝ} (hb : (absA α : ℝ) < b) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (top : Tile n) (T : Finset (Tile n)), IsTree α top T → ∀ (k : ℤ)
+      (x : Rn n), ∑ P ∈ T with P.k = k,
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b) ≤ C := by
+  set W := 2 ^ b * ∫ w : Rn n, (1 + rho α w) ^ (-b)
+  have hW : 0 ≤ W := by
+    have : 0 ≤ ∫ w : Rn n, (1 + rho α w) ^ (-b) := integral_nonneg fun w => by
+      have := rho_nonneg α w; positivity
+    have : (0 : ℝ) ≤ 2 ^ b := by positivity
+    positivity
+  refine ⟨W, hW, fun top T hT k x => ?_⟩
+  set F := T.filter fun P => P.k = k
+  set z : Rn n := dil α ((2 : ℝ) ^ k)⁻¹ x - halfVec n
+  have hinj : Set.InjOn (fun P : Tile n => P.ℓ) (F : Set (Tile n)) := by
+    intro P hP Q hQ hℓ
+    simp only [F, Finset.coe_filter, Set.mem_ofPred_eq] at hP hQ
+    refine hT.injOn_I α hP.1 hQ.1 ?_
+    simp only [Tile.I, hP.2, hQ.2]
+    exact congrArg _ hℓ
+  have hnn : ∀ ℓ : Fin n → ℤ, 0 ≤ (1 + rho α (z - latticePt ℓ)) ^ (-b) := fun ℓ => by
+    have := rho_nonneg α (z - latticePt ℓ); positivity
+  obtain ⟨hs, hle⟩ := summable_wgt_lattice α hα hb z
+  calc ∑ P ∈ F, (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b)
+      = ∑ P ∈ F, (1 + rho α (z - latticePt P.ℓ)) ^ (-b) := by
+        refine Finset.sum_congr rfl fun P hP => ?_
+        have hPk : P.k = k := (Finset.mem_filter.mp hP).2
+        rw [one_add_rho_cI_eq α hα P x, hPk]
+    _ = ∑ ℓ ∈ F.image (fun P : Tile n => P.ℓ), (1 + rho α (z - latticePt ℓ)) ^ (-b) :=
+        (Finset.sum_image (f := fun ℓ => (1 + rho α (z - latticePt ℓ)) ^ (-b)) hinj).symm
+    _ ≤ ∑' ℓ : Fin n → ℤ, (1 + rho α (z - latticePt ℓ)) ^ (-b) :=
+        hs.sum_le_tsum _ fun ℓ _ => hnn ℓ
+    _ ≤ W := hle
+
+/-- Two points of a dyadic cube of scale `k` are at anisotropic distance `≤ 2^k`. -/
+theorem rho_sub_le_of_mem_DCube (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (J : DCube n) {x y : Rn n}
+    (hx : x ∈ J.toSet α) (hy : y ∈ J.toSet α) : rho α (x - y) ≤ (2 : ℝ) ^ J.k := by
+  have hle : rhoNN α (x - y) ≤ Real.toNNReal ((2 : ℝ) ^ J.k) := by
+    rw [rhoNN_le_iff]
+    intro i
+    rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ (by positivity)]
+    simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs, PiLp.sub_apply]
+    have h1 := hx i
+    have h2 := hy i
+    have hs : |x i - y i| ≤ ((2 : ℝ) ^ J.k) ^ (α i : ℝ) := by
+      rw [Real.rpow_natCast, ← zpow_natCast, ← zpow_mul]
+      change |x i - y i| ≤ side α J.k i
+      rw [abs_le]; constructor <;> nlinarith [h1.1, h1.2, h2.1, h2.2]
+    have hai : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+    calc |x i - y i| ^ ((α i : ℝ)⁻¹) ≤ (((2 : ℝ) ^ J.k) ^ (α i : ℝ)) ^ ((α i : ℝ)⁻¹) :=
+          Real.rpow_le_rpow (abs_nonneg _) hs (by positivity)
+      _ = (2 : ℝ) ^ J.k := by
+          rw [← Real.rpow_mul (by positivity), mul_inv_cancel₀ hai, Real.rpow_one]
+  have := NNReal.coe_le_coe.mpr hle
+  rwa [Real.coe_toNNReal _ (by positivity)] at this
+
+/-- Slow variation of `(1 + 2^{-k_P} ρ(· − c(I_P)))` on an admissible cube `J` with
+`k_P ≤ k_J + 1` (the disjointness `I_P ∩ J_tilde = ∅` is used when `k_P ≤ k_J`). -/
+theorem one_add_rho_le_two_mul_of_mem_J (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i)
+    (T : Finset (Tile n)) {J : DCube n} (hJ : treeOK α T J) {P : Tile n} (hP : P ∈ T)
+    (hk : P.k ≤ J.k + 1) {x y : Rn n} (hx : x ∈ J.toSet α) (hy : y ∈ J.toSet α) :
+    1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) ≤
+      2 * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (y - P.cI α)) := by
+  have htP : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  -- `ρ(x - y) ≤ 2^{k_J}`
+  have hxy := rho_sub_le_of_mem_DCube α hα J hx hy
+  have htri : rho α (x - P.cI α) ≤ rho α (x - y) + rho α (y - P.cI α) := by
+    have := rho_add_le α hα (x - y) (y - P.cI α)
+    rwa [sub_add_sub_cancel] at this
+  rcases hk.lt_or_eq with hlt | heq
+  · -- `k_P ≤ k_J`: `c(I_P) ∉ J_tilde`, hence `ρ(y - c(I_P)) ≥ 2^{k_J}`
+    have hdisj : ¬ (P.I.toSet α ∩ J.enl3 α).Nonempty := fun hne =>
+      hJ P hP (DCube.subset_enl3_of_inter α (by simp [Tile.I]; omega) hne)
+    have hcP : P.cI α ∉ J.enl3 α := fun h => hdisj ⟨P.cI α, DCube.center_mem α P.I, h⟩
+    have hyc : (2 : ℝ) ^ J.k ≤ rho α (y - P.cI α) := by
+      simp only [DCube.enl3, Set.mem_ofPred_eq, not_forall, not_and_or, not_le, not_lt] at hcP
+      obtain ⟨i, hi⟩ := hcP
+      have hyi := hy i
+      have hs := side_pos α J.k i
+      have hA : (2 : ℝ) ≤ 2 ^ α i := by
+        calc (2 : ℝ) = 2 ^ 1 := by norm_num
+          _ ≤ 2 ^ α i := pow_le_pow_right₀ (by norm_num) (hα i)
+      have habs : side α J.k i ≤ |y i - P.cI α i| := by
+        rcases hi with hi | hi
+        · rw [abs_of_pos (by nlinarith [hyi.1])]; nlinarith [hyi.1]
+        · rw [abs_of_neg (by nlinarith [hyi.2])]; nlinarith [hyi.2]
+      have h1 := abs_coord_rpow_le_rho α (y - P.cI α) i
+      simp only [PiLp.sub_apply] at h1
+      have hai : (α i : ℝ) ≠ 0 := by have := hα i; positivity
+      calc (2 : ℝ) ^ J.k = (side α J.k i) ^ ((α i : ℝ)⁻¹) := by
+            rw [side, ← Real.rpow_intCast (2 : ℝ) (J.k * (α i : ℤ)), ← Real.rpow_mul (by norm_num),
+              ← Real.rpow_intCast (2 : ℝ) J.k]
+            congr 1
+            push_cast
+            field_simp
+        _ ≤ |y i - P.cI α i| ^ ((α i : ℝ)⁻¹) :=
+            Real.rpow_le_rpow hs.le habs (by positivity)
+        _ ≤ _ := h1
+    have : rho α (x - P.cI α) ≤ 2 * rho α (y - P.cI α) := by linarith
+    have hr := rho_nonneg α (y - P.cI α)
+    have : ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) ≤ 2 * (((2 : ℝ) ^ P.k)⁻¹ * rho α (y - P.cI α))
+        := by
+      have hinv : 0 ≤ ((2 : ℝ) ^ P.k)⁻¹ := by positivity
+      nlinarith
+    linarith
+  · -- `k_P = k_J + 1`: `ρ(x - y) ≤ 2^{k_P}/2`
+    have hJP : (2 : ℝ) ^ J.k = (2 : ℝ) ^ P.k / 2 := by
+      rw [heq, zpow_add_one₀ (by norm_num)]; ring
+    have : ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) ≤
+        1 / 2 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (y - P.cI α) := by
+      have hinv : 0 < ((2 : ℝ) ^ P.k)⁻¹ := by positivity
+      have h1 : ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - y) ≤ 1 / 2 := by
+        rw [inv_mul_le_iff₀ htP]; linarith
+      nlinarith
+    have := rho_nonneg α (y - P.cI α)
+    have : 0 ≤ ((2 : ℝ) ^ P.k)⁻¹ * rho α (y - P.cI α) := by positivity
+    linarith
+
+/-- Comparison with the top of the tree: `1 + 2^{-k_T}ρ(x − c(I_T)) ≤ 2 (1 + 2^{-k_P}ρ(x − c(I_P)))`
+for `P ≤ T`. -/
+theorem one_add_rho_top_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {P top : Tile n}
+    (h : Tile.le α P top) (x : Rn n) :
+    1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α) ≤
+      2 * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) := by
+  have hk : P.k ≤ top.k := by
+    have := DCube.k_le_of_subset α hα hn h.1; simpa [Tile.I] using this
+  have ht : (0 : ℝ) < (2 : ℝ) ^ top.k := by positivity
+  have htP : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  have hcc : rho α (P.cI α - top.cI α) ≤ (2 : ℝ) ^ top.k :=
+    rho_sub_cI_le α hα top (h.1 (DCube.center_mem α P.I))
+  have htri : rho α (x - top.cI α) ≤ rho α (x - P.cI α) + rho α (P.cI α - top.cI α) := by
+    have := rho_add_le α hα (x - P.cI α) (P.cI α - top.cI α)
+    rwa [sub_add_sub_cancel] at this
+  have hmono : ((2 : ℝ) ^ top.k)⁻¹ ≤ ((2 : ℝ) ^ P.k)⁻¹ :=
+    inv_anti₀ htP (zpow_le_zpow_right₀ (by norm_num) hk)
+  have hr := rho_nonneg α (x - P.cI α)
+  have h1 : ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α) ≤
+      ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) + 1 := by
+    calc ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)
+        ≤ ((2 : ℝ) ^ top.k)⁻¹ * (rho α (x - P.cI α) + (2 : ℝ) ^ top.k) := by gcongr; linarith
+      _ = ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - P.cI α) + 1 := by field_simp
+      _ ≤ _ := by gcongr
+  have : 0 ≤ ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by positivity
+  linarith
+
+/-! ### The tail term `𝒦₁` (paper, (7.1)–(7.5), texline~597–636) -/
+
+/-- The exponent `ν₁ = |α| + 4/3` in the definition of the mass (paper, texline~602). -/
+def nu1 (α : Fin n → ℕ) : ℝ := absA α + 4 / 3
+
+theorem psi_bound_on_semiHO (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ν : ℕ) {m : Rn n → ℂ} (hm : ClassM α ν m) (P : Tile n) {N : Rn n}
+    (hN : N ∈ P.semiHO α r) (x : Rn n) :
+    ‖wavePsi α m N P x‖ ≤ (psiConst α ν : ℝ) * (normM α ν m).toReal *
+      ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) :=
+  psi_estimate_real α hα ν hm P N (exists_far_of_mem_semi α hr (P.semiHO_subset_semi α r hN)) x
+
+/-- The contribution of one tile to `𝒦₁` on one cube `J` (paper, (7.1)–(7.2)). -/
+theorem K1_term_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ν : ℕ) (hν : nu1 α ≤ ν) {m : Rn n → ℂ} (hm : ClassM α ν m) {E : Set (Rn n)}
+    (hE : MeasurableSet E) {N : Rn n → Rn n}
+    (hN : Measurable N) (T : Finset (Tile n)) {J : DCube n} (hJ : treeOK α T J)
+    {P : Tile n} (hP : P ∈ T) (hk : P.k ≤ J.k + 1) {c : ℂ} {ε μ : ℝ} (hε : 0 ≤ ε)
+    (hc : ‖c‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2))
+    (hmass : ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P x) ≤ ENNReal.ofReal μ)
+    {x₀ : Rn n} (hx₀ : x₀ ∈ J.toSet α) :
+    ∫⁻ x in J.toSet α, ‖c * wavePsi α m (N x) P x‖ₑ *
+      (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x ≤
+      ENNReal.ofReal (ε * (psiConst α ν : ℝ) * (normM α ν m).toReal * 2 ^ ((ν : ℝ) - nu1 α) * μ *
+        P.vol α * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x₀ - P.cI α)) ^ (-((ν : ℝ) - nu1 α))) := by
+  set a : ℝ := (ν : ℝ) - nu1 α
+  set W : Rn n → ℝ := fun x => 1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)
+  have hW1 : ∀ x, 1 ≤ W x := fun x => by
+    have := rho_nonneg α (x - P.cI α)
+    have : 0 ≤ ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := by positivity
+    simp only [W]; linarith
+  have hWpos : ∀ x, 0 < W x := fun x => lt_of_lt_of_le one_pos (hW1 x)
+  set Cψ : ℝ := (psiConst α ν : ℝ)
+  set Nm : ℝ := (normM α ν m).toReal
+  have hCψ : 0 ≤ Cψ := NNReal.coe_nonneg _
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set K : ℝ := ε * Cψ * Nm * 2 ^ a * W x₀ ^ (-a)
+  have hK : 0 ≤ K := by
+    have := hWpos x₀
+    positivity
+  have hEP : MeasurableSet (E ∩ N ⁻¹' (P.ω.toSet α)) :=
+    hE.inter (hN (DCube.measurableSet_toSet α P.ω))
+  -- pointwise bound on `J`
+  have hpt : ∀ x ∈ J.toSet α, ‖c * wavePsi α m (N x) P x‖ₑ *
+      (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x ≤
+      ENNReal.ofReal K * (E ∩ N ⁻¹' (P.ω.toSet α)).indicator
+        (fun x => ENNReal.ofReal (W x ^ (-nu1 α))) x := by
+    intro x hx
+    by_cases hxE : x ∈ E ∩ N ⁻¹' (P.semiHO α r)
+    · have hxω : x ∈ E ∩ N ⁻¹' (P.ω.toSet α) := ⟨hxE.1, P.semiHO_subset_ω α r hxE.2⟩
+      rw [Set.indicator_of_mem hxE, Set.indicator_of_mem hxω, Pi.one_apply, mul_one,
+        ← ENNReal.ofReal_mul hK, ← ofReal_norm]
+      refine ENNReal.ofReal_le_ofReal ?_
+      have hψ := psi_bound_on_semiHO α hα hr ν hm P hxE.2 x
+      -- slow variation: `W x₀ ≤ 2 W x`
+      have hslow := one_add_rho_le_two_mul_of_mem_J α hα T hJ hP hk hx₀ hx
+      have ha : 0 ≤ a := by simp only [a]; linarith
+      have h2 : W x ^ (-a) ≤ 2 ^ a * W x₀ ^ (-a) := by
+        have hx0a : W x₀ ^ a ≤ 2 ^ a * W x ^ a :=
+          (Real.rpow_le_rpow (hWpos x₀).le hslow ha).trans_eq (Real.mul_rpow (by norm_num)
+            (hWpos x).le)
+        have hp1 := Real.rpow_pos_of_pos (hWpos x) a
+        have hp0 := Real.rpow_pos_of_pos (hWpos x₀) a
+        have h2a : (0 : ℝ) < 2 ^ a := by positivity
+        rw [Real.rpow_neg (hWpos x).le, Real.rpow_neg (hWpos x₀).le]
+        calc (W x ^ a)⁻¹ = 2 ^ a / (2 ^ a * W x ^ a) := by field_simp
+          _ ≤ 2 ^ a / (W x₀ ^ a) := div_le_div_of_nonneg_left h2a.le hp0 hx0a
+          _ = 2 ^ a * (W x₀ ^ a)⁻¹ := by ring
+      have hsplit : W x ^ (-(ν : ℝ)) = W x ^ (-a) * W x ^ (-nu1 α) := by
+        rw [← Real.rpow_add (hWpos x)]; simp only [a]; ring_nf
+      have hpow : ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) =
+          1 := by
+        rw [← Real.rpow_add (by positivity), show (absA α : ℝ) / 2 + -(absA α : ℝ) / 2 = 0 by ring,
+          Real.rpow_zero]
+      rw [norm_mul]
+      calc ‖c‖ * ‖wavePsi α m (N x) P x‖
+          ≤ (ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) *
+            (Cψ * Nm * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) * W x ^ (-(ν : ℝ))) :=
+            mul_le_mul hc hψ (norm_nonneg _) (by positivity)
+        _ = ε * Cψ * Nm * (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) *
+            ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)) * (W x ^ (-a) * W x ^ (-nu1 α)) := by
+            rw [hsplit]; ring
+        _ ≤ ε * Cψ * Nm * 1 * ((2 ^ a * W x₀ ^ (-a)) * W x ^ (-nu1 α)) := by
+            rw [hpow]
+            exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right h2
+              (Real.rpow_nonneg (hWpos x).le _)) (by positivity)
+        _ = K * W x ^ (-nu1 α) := by simp only [K]; ring
+    · rw [Set.indicator_of_notMem hxE, mul_zero]
+      exact bot_le
+  calc ∫⁻ x in J.toSet α, ‖c * wavePsi α m (N x) P x‖ₑ *
+        (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x
+      ≤ ∫⁻ x in J.toSet α, ENNReal.ofReal K * (E ∩ N ⁻¹' (P.ω.toSet α)).indicator
+          (fun x => ENNReal.ofReal (W x ^ (-nu1 α))) x :=
+        lintegral_mono_ae ((ae_restrict_iff' (DCube.measurableSet_toSet α J)).mpr
+          (Filter.Eventually.of_forall hpt))
+    _ ≤ ∫⁻ x, ENNReal.ofReal K * (E ∩ N ⁻¹' (P.ω.toSet α)).indicator
+          (fun x => ENNReal.ofReal (W x ^ (-nu1 α))) x := setLIntegral_le_lintegral _ _
+    _ = ENNReal.ofReal K * ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (W x ^ (-nu1 α)) := by
+        rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top, lintegral_indicator hEP]
+    _ = ENNReal.ofReal K * (ENNReal.ofReal (P.vol α) *
+          ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P x)) := by
+        congr 1
+        rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+        refine lintegral_congr fun x => ?_
+        rw [← ENNReal.ofReal_mul (P.vol_pos α).le, vol_mul_wP α hα]
+    _ ≤ ENNReal.ofReal K * (ENNReal.ofReal (P.vol α) * ENNReal.ofReal μ) := by gcongr
+    _ = _ := by
+        rw [← ENNReal.ofReal_mul (P.vol_pos α).le, ← ENNReal.ofReal_mul hK]
+        congr 1
+        simp only [K, Cψ, Nm, a, W]
+        ring
+
+/-- Geometric sum over distinct scales below `K₀`: `∑_{k ∈ ks, k ≤ K₀} 2^{k|α|} ≤ 2 · 2^{K₀|α|}`. -/
+theorem sum_zpow_scales_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (ks : Finset ℤ)
+    (K₀ : ℤ) (hks : ∀ k ∈ ks, k ≤ K₀) :
+    ∑ k ∈ ks, (2 : ℝ) ^ (k * (absA α : ℤ)) ≤ 2 * (2 : ℝ) ^ (K₀ * (absA α : ℤ)) := by
+  have hA : 1 ≤ absA α := absA_pos α hα hn
+  have hinj : Set.InjOn (fun k : ℤ => (K₀ - k).toNat) (ks : Set ℤ) := by
+    intro a ha b hb hab
+    have := hks a ha; have := hks b hb
+    simp only at hab; omega
+  have hterm : ∀ k ∈ ks, (2 : ℝ) ^ (k * (absA α : ℤ)) ≤
+      (2 : ℝ) ^ (K₀ * (absA α : ℤ)) * (1 / 2 : ℝ) ^ ((K₀ - k).toNat) := by
+    intro k hk
+    have h1 := hks k hk
+    rw [one_div, inv_pow, ← zpow_natCast, Int.toNat_of_nonneg (by omega), ← zpow_neg,
+      ← zpow_add₀ (by norm_num)]
+    refine zpow_le_zpow_right₀ (by norm_num) ?_
+    have : (0 : ℤ) ≤ K₀ - k := by omega
+    have hA' : (1 : ℤ) ≤ absA α := by exact_mod_cast hA
+    nlinarith
+  calc ∑ k ∈ ks, (2 : ℝ) ^ (k * (absA α : ℤ))
+      ≤ ∑ k ∈ ks, (2 : ℝ) ^ (K₀ * (absA α : ℤ)) * (1 / 2 : ℝ) ^ ((K₀ - k).toNat) :=
+        Finset.sum_le_sum hterm
+    _ = (2 : ℝ) ^ (K₀ * (absA α : ℤ)) * ∑ m ∈ ks.image (fun k : ℤ => (K₀ - k).toNat),
+          (1 / 2 : ℝ) ^ m := by
+        rw [Finset.mul_sum, Finset.sum_image (f := fun m => (2 : ℝ) ^ (K₀ * (absA α : ℤ)) *
+          (1 / 2 : ℝ) ^ m) hinj]
+    _ ≤ (2 : ℝ) ^ (K₀ * (absA α : ℤ)) * ∑' m : ℕ, (1 / 2 : ℝ) ^ m := by
+        gcongr
+        exact Summable.sum_le_tsum _ (fun _ _ => by positivity) summable_geometric_two
+    _ = _ := by rw [tsum_geometric_two]; ring
+
+/-- The sum over the tiles of scale `≤ k_J + 1` (paper, (7.2)–(7.4)):
+`∑_{P ∈ T, k_P ≤ k_J+1} |I_P| (1 + 2^{-k_P}ρ(x − c(I_P)))^{-2b} ≲ |J| (1 + 2^{-k_T}ρ(x −
+    c(I_T)))^{-b}`. -/
+theorem K1_sum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {b : ℝ}
+    (hb : (absA α : ℝ) < b) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (top : Tile n) (T : Finset (Tile n)), IsTree α top T → ∀ (J : DCube n)
+      (x : Rn n), ∑ P ∈ T with P.k ≤ J.k + 1, P.vol α *
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b)) ≤
+        C * (2 : ℝ) ^ (J.k * (absA α : ℤ)) *
+          (1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)) ^ (-b) := by
+  obtain ⟨Cl, hCl, hlat⟩ := tree_scale_sum_le α hα hb
+  have hb0 : 0 ≤ b := le_trans (Nat.cast_nonneg _) hb.le
+  refine ⟨2 ^ b * Cl * (2 * 2 ^ absA α), by positivity, fun top T hT J x => ?_⟩
+  set WT := (1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)) ^ (-b)
+  have hWT : 0 ≤ WT := by have := rho_nonneg α (x - top.cI α); positivity
+  set F := T.filter fun P => P.k ≤ J.k + 1
+  set ks := F.image Tile.k
+  have hpos : ∀ P : Tile n, 0 < 1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α) := fun P => by
+    have := rho_nonneg α (x - P.cI α); positivity
+  -- each term: `(1+…)^{-2b} ≤ 2^b WT (1+…)^{-b}`
+  have hterm : ∀ P ∈ T, (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b)) ≤
+      2 ^ b * WT * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b) := by
+    intro P hP
+    have hc := one_add_rho_top_le α hα hn (hT P hP) x
+    have hposT : 0 < 1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α) := by
+      have := rho_nonneg α (x - top.cI α); positivity
+    have h1 : (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b) ≤ 2 ^ b * WT := by
+      simp only [WT]
+      rw [Real.rpow_neg (hpos P).le, Real.rpow_neg hposT.le]
+      have hp1 := Real.rpow_pos_of_pos (hpos P) b
+      have hpT := Real.rpow_pos_of_pos hposT b
+      have hle : (1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)) ^ b ≤
+          2 ^ b * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ b :=
+        (Real.rpow_le_rpow hposT.le hc hb0).trans_eq (Real.mul_rpow (by norm_num) (hpos P).le)
+      have h2b : (0 : ℝ) < 2 ^ b := by positivity
+      calc ((1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ b)⁻¹
+          = 2 ^ b / (2 ^ b * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ b) := by field_simp
+        _ ≤ 2 ^ b / (1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)) ^ b :=
+            div_le_div_of_nonneg_left h2b.le hpT hle
+        _ = _ := by ring
+    rw [show -(2 * b) = -b + -b by ring, Real.rpow_add (hpos P)]
+    exact mul_le_mul_of_nonneg_right h1 (Real.rpow_nonneg (hpos P).le _)
+  have hscale : ∀ k ∈ ks, ∑ P ∈ F with P.k = k, P.vol α *
+      (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b)) ≤
+      (2 : ℝ) ^ (k * (absA α : ℤ)) * (2 ^ b * WT * Cl) := by
+    intro k _
+    calc ∑ P ∈ F with P.k = k, P.vol α * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b))
+        ≤ ∑ P ∈ F with P.k = k, (2 : ℝ) ^ (k * (absA α : ℤ)) *
+            (2 ^ b * WT * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b)) := by
+          refine Finset.sum_le_sum fun P hP => ?_
+          obtain ⟨hPF, hPk⟩ := Finset.mem_filter.mp hP
+          rw [show P.vol α = (2 : ℝ) ^ (k * (absA α : ℤ)) by rw [Tile.vol, hPk]]
+          exact mul_le_mul_of_nonneg_left (hterm P (Finset.mem_filter.mp hPF).1) (by positivity)
+      _ ≤ ∑ P ∈ T with P.k = k, (2 : ℝ) ^ (k * (absA α : ℤ)) *
+            (2 ^ b * WT * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-b)) := by
+          refine Finset.sum_le_sum_of_subset_of_nonneg (fun P hP => ?_) (fun P _ _ => ?_)
+          · obtain ⟨hPF, hPk⟩ := Finset.mem_filter.mp hP
+            exact Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hPF).1, hPk⟩
+          · have := Real.rpow_nonneg (hpos P).le (-b)
+            positivity
+      _ ≤ _ := by
+          rw [← Finset.mul_sum, ← Finset.mul_sum]
+          gcongr
+          exact hlat top T hT k x
+  have hks : ∀ k ∈ ks, k ≤ J.k + 1 := by
+    intro k hk
+    obtain ⟨P, hP, rfl⟩ := Finset.mem_image.mp hk
+    exact (Finset.mem_filter.mp hP).2
+  calc ∑ P ∈ F, P.vol α * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b))
+      = ∑ k ∈ ks, ∑ P ∈ F with P.k = k, P.vol α *
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(2 * b)) :=
+        (Finset.sum_fiberwise_of_maps_to (fun P hP => Finset.mem_image_of_mem _ hP) _).symm
+    _ ≤ ∑ k ∈ ks, (2 : ℝ) ^ (k * (absA α : ℤ)) * (2 ^ b * WT * Cl) := Finset.sum_le_sum hscale
+    _ = (2 ^ b * WT * Cl) * ∑ k ∈ ks, (2 : ℝ) ^ (k * (absA α : ℤ)) := by
+        rw [Finset.mul_sum]; congr 1; ext k; ring
+    _ ≤ (2 ^ b * WT * Cl) * (2 * (2 : ℝ) ^ ((J.k + 1) * (absA α : ℤ))) := by
+        gcongr
+        exact sum_zpow_scales_le α hα hn ks (J.k + 1) hks
+    _ = _ := by
+        rw [add_mul, one_mul, zpow_add₀ (by norm_num), zpow_natCast]
+        ring
+
+/-- **The tail term `𝒦₁`** (paper, (7.1)–(7.5), texline~597–636):
+`∑_J ∑_{P ∈ T, k_P ≤ k_J+1} ‖⟨f,φ_P⟩ ψ_P^{N(·)} 1_{E_{P(r)}}‖_{L¹(J)} ≤ C ‖m‖_{𝓜^{ν₀}} ε μ |I_T|`,
+for `ν₀ ≥ 3|α| + 2`. -/
+theorem K1_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (E : Set (Rn n)), MeasurableSet E →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (top : Tile n) (T : Finset (Tile n)),
+      IsTree α top T → ∀ (c : Tile n → ℂ) (ε μ : ℝ), 0 ≤ ε → 0 ≤ μ →
+      (∀ P ∈ T, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      (∀ P ∈ T, ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P x) ≤
+        ENNReal.ofReal μ) →
+      ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+        ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x ≤
+        ENNReal.ofReal (C * (normM α ν m).toReal * ε * μ * top.vol α) := by
+  set a : ℝ := (ν : ℝ) - nu1 α
+  set b : ℝ := a / 2
+  have hνR : (3 * absA α + 2 : ℝ) ≤ ν := by exact_mod_cast hν
+  have hb : (absA α : ℝ) < b := by simp only [b, a, nu1]; linarith
+  have hν1 : nu1 α ≤ ν := by
+    simp only [nu1]; linarith [(Nat.cast_nonneg (absA α) : (0 : ℝ) ≤ absA α)]
+  have ha2b : -(2 * b) = -a := by simp only [b]; ring
+  obtain ⟨Cs, hCs, hsum⟩ := K1_sum_le α hα hn hb
+  set G : ℝ := ∫ w : Rn n, (1 + rho α w) ^ (-b)
+  have hG : 0 ≤ G := integral_nonneg fun w => by have := rho_nonneg α w; positivity
+  set Cψ : ℝ := (psiConst α ν : ℝ)
+  have hCψ : 0 ≤ Cψ := NNReal.coe_nonneg _
+  refine ⟨Cψ * 2 ^ a * Cs * G, by positivity, fun m hm E hE N hN top T hT c ε μ hε hμ hc hmass
+      => ?_⟩
+  set Nm : ℝ := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set Kc : ℝ := ε * Cψ * Nm * 2 ^ a * μ
+  have hKc : 0 ≤ Kc := by positivity
+  set WT : Rn n → ℝ := fun x => (1 + ((2 : ℝ) ^ top.k)⁻¹ * rho α (x - top.cI α)) ^ (-b)
+  have hWT : ∀ x, 0 ≤ WT x := fun x => by have := rho_nonneg α (x - top.cI α); positivity
+  rcases T.eq_empty_or_nonempty with hTe | hTne
+  · subst hTe; simp
+  -- the bound on each cube of the partition
+  have hJ : ∀ J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+      ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x ≤
+      ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal (Kc * Cs * WT x) := by
+    intro J
+    set L := ∫⁻ x in (J : DCube n).toSet α, ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+      ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x
+    have hpt : ∀ x₀ ∈ (J : DCube n).toSet α,
+        L ≤ ENNReal.ofReal (Kc * Cs * (2 : ℝ) ^ ((J : DCube n).k * (absA α : ℤ)) * WT x₀) := by
+      intro x₀ hx₀
+      have hsumP := hsum top T hT J x₀
+      rw [ha2b] at hsumP
+      calc L = ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1, ∫⁻ x in (J : DCube n).toSet α,
+            ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x := by
+            refine lintegral_finsetSum' _ fun P _ => ?_
+            exact ((measurable_const.mul ((continuous_wavePsi_joint α hm P).measurable.comp
+              (hN.prodMk measurable_id))).enorm.mul (measurable_one.indicator
+                (hE.inter (hN (measurableSet_semiHO α P r))))).aemeasurable
+        _ ≤ ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1, ENNReal.ofReal (Kc * (P.vol α *
+              (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x₀ - P.cI α)) ^ (-a))) := by
+            refine Finset.sum_le_sum fun P hP => ?_
+            obtain ⟨hPT, hPk⟩ := Finset.mem_filter.mp hP
+            have := K1_term_le α hα hr ν hν1 hm hE hN T J.2.1 hPT hPk hε (hc P hPT)
+              (hmass P hPT) hx₀
+            refine this.trans (le_of_eq ?_)
+            congr 1
+            simp only [Kc, Cψ, Nm, a]
+            ring
+        _ = ENNReal.ofReal (Kc * ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1, P.vol α *
+              (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x₀ - P.cI α)) ^ (-a)) := by
+            rw [Finset.mul_sum, ENNReal.ofReal_sum_of_nonneg]
+            intro P _
+            have := rho_nonneg α (x₀ - P.cI α)
+            have := P.vol_pos α
+            positivity
+        _ ≤ ENNReal.ofReal (Kc * (Cs * (2 : ℝ) ^ ((J : DCube n).k * (absA α : ℤ)) * WT x₀)) := by
+            gcongr
+        _ = _ := by congr 1; ring
+    -- average over `J`
+    have hvolJ := DCube.volume_toSet α (J : DCube n)
+    set v : ℝ := (2 : ℝ) ^ ((J : DCube n).k * (absA α : ℤ))
+    have hv : 0 < v := by positivity
+    have hint : L * ENNReal.ofReal v ≤ ENNReal.ofReal v *
+        ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal (Kc * Cs * WT x) := by
+      calc L * ENNReal.ofReal v = ∫⁻ _ in (J : DCube n).toSet α, L := by
+            rw [setLIntegral_const, hvolJ]
+        _ ≤ ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal (Kc * Cs * v * WT x) :=
+            setLIntegral_mono' (DCube.measurableSet_toSet α _) hpt
+        _ = ENNReal.ofReal v * ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal (Kc * Cs * WT x) := by
+            rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
+            refine lintegral_congr fun x => ?_
+            rw [← ENNReal.ofReal_mul hv.le]
+            congr 1; ring
+    rw [mul_comm] at hint
+    exact (ENNReal.mul_le_mul_iff_right (by simpa using hv) ENNReal.ofReal_ne_top).mp hint
+  -- sum over the partition
+  have hWTint : Integrable fun x => Kc * Cs * WT x :=
+    (integrable_wgt_scaled α hα hb (t := (2 : ℝ) ^ top.k) (by positivity) (top.cI α)).const_mul _
+  calc ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+        ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x
+      ≤ ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal (Kc * Cs * WT x) :=
+        ENNReal.tsum_le_tsum hJ
+    _ = ∫⁻ x, ENNReal.ofReal (Kc * Cs * WT x) :=
+        (lintegral_eq_tsum_jSet α hα hn T hTne _).symm
+    _ = ENNReal.ofReal (∫ x, Kc * Cs * WT x) :=
+        (ofReal_integral_eq_lintegral_ofReal hWTint (Filter.Eventually.of_forall fun x => by
+          have := hWT x; positivity)).symm
+    _ = _ := by
+        congr 1
+        rw [integral_const_mul]
+        simp only [WT]
+        rw [integral_wgt_scaled α hα b (by positivity) (top.cI α), Tile.vol, ← zpow_natCast,
+          ← zpow_mul]
+        simp only [Kc, Cψ, Nm, G]
+        ring
+
+/-- Two points of `Q_tilde` are at anisotropic distance `≤ 2 · 2^{k_Q+1}`. -/
+theorem rho_sub_le_of_mem_enl3 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (Q : DCube n) {x y : Rn n}
+    (hx : x ∈ Q.enl3 α) (hy : y ∈ Q.enl3 α) : rho α (x - y) ≤ 2 * (2 : ℝ) ^ (Q.k + 1) := by
+  have ht : (0 : ℝ) < 2 * (2 : ℝ) ^ (Q.k + 1) := by positivity
+  have hle : rhoNN α (x - y) ≤ Real.toNNReal (2 * (2 : ℝ) ^ (Q.k + 1)) := by
+    rw [rhoNN_le_iff]
+    intro i
+    rw [← NNReal.coe_le_coe, Real.coe_toNNReal _ ht.le]
+    simp only [NNReal.coe_rpow, coe_nnnorm, Real.norm_eq_abs, PiLp.sub_apply]
+    have h1 := hx i
+    have h2 := hy i
+    have hs := side_pos α Q.k i
+    have hA : (1 : ℝ) ≤ 2 ^ α i := one_le_pow₀ (by norm_num)
+    have hai : (1 : ℝ) ≤ α i := by exact_mod_cast hα i
+    have hd : |x i - y i| ≤ 2 * ((2 : ℝ) ^ (Q.k + 1)) ^ (α i : ℝ) := by
+      have e : ((2 : ℝ) ^ (Q.k + 1)) ^ (α i : ℝ) = side α Q.k i * 2 ^ α i := by
+        rw [Real.rpow_natCast, side, ← zpow_natCast ((2 : ℝ) ^ (Q.k + 1)), ← zpow_mul,
+          ← zpow_natCast (2 : ℝ) (α i), ← zpow_add₀ (by norm_num)]
+        congr 1; ring
+      rw [e, abs_le]
+      constructor <;> nlinarith [h1.1, h1.2, h2.1, h2.2]
+    calc |x i - y i| ^ ((α i : ℝ)⁻¹) ≤ (2 * ((2 : ℝ) ^ (Q.k + 1)) ^ (α i : ℝ)) ^ ((α i : ℝ)⁻¹) :=
+          Real.rpow_le_rpow (abs_nonneg _) hd (by positivity)
+      _ = 2 ^ ((α i : ℝ)⁻¹) * (2 : ℝ) ^ (Q.k + 1) := by
+          rw [Real.mul_rpow (by norm_num) (by positivity), ← Real.rpow_mul (by positivity),
+            mul_inv_cancel₀ (by positivity), Real.rpow_one]
+      _ ≤ 2 * (2 : ℝ) ^ (Q.k + 1) := by
+          gcongr
+          calc (2 : ℝ) ^ ((α i : ℝ)⁻¹) ≤ 2 ^ (1 : ℝ) :=
+                Real.rpow_le_rpow_of_exponent_le (by norm_num) (inv_le_one_of_one_le₀ hai)
+            _ = 2 := Real.rpow_one 2
+  have := NNReal.coe_le_coe.mpr hle
+  rwa [Real.coe_toNNReal _ ht.le] at this
+
+/-- The auxiliary tile of Lemma 7.1: spatial cube the scale-`k` ancestor of `I_{P₀}`, frequency
+cube the scale-`(−k)` cube containing `ξ`. -/
+def auxTile (α : Fin n → ℕ) (P₀ : Tile n) (k : ℤ) (ξ : Rn n) : Tile n :=
+  ⟨k, (P₀.I.ancestor α (k - P₀.k).toNat).ℓ, (DCube.ofPoint α (-k) ξ).ℓ⟩
+
+theorem auxTile_I (α : Fin n → ℕ) (P₀ : Tile n) {k : ℤ} (hk : P₀.k ≤ k) (ξ : Rn n) :
+    (auxTile α P₀ k ξ).I = P₀.I.ancestor α (k - P₀.k).toNat := by
+  simp only [auxTile, Tile.I, DCube.ancestor]
+  congr 1
+  omega
+
+theorem auxTile_ω (α : Fin n → ℕ) (P₀ : Tile n) (k : ℤ) (ξ : Rn n) :
+    (auxTile α P₀ k ξ).ω = DCube.ofPoint α (-k) ξ := rfl
+
+theorem mem_auxTile_ω (α : Fin n → ℕ) (P₀ : Tile n) (k : ℤ) (ξ : Rn n) :
+    ξ ∈ (auxTile α P₀ k ξ).ω.toSet α := by
+  rw [auxTile_ω]; exact DCube.mem_ofPoint α _ ξ
+
+theorem ω_subset_of_mem_of_k_le (α : Fin n → ℕ) {P Q : Tile n} (hk : Q.k ≤ P.k) {ξ : Rn n}
+    (hP : ξ ∈ P.ω.toSet α) (hQ : ξ ∈ Q.ω.toSet α) : P.ω.toSet α ⊆ Q.ω.toSet α := by
+  have hk' : P.ω.k ≤ Q.ω.k := by simp [Tile.ω]; omega
+  rcases DCube.subset_or_disjoint α P.ω Q.ω hk' with h | h
+  · exact h
+  · exact absurd hQ (Set.disjoint_left.mp h hP)
+
+theorem le_auxTile (α : Fin n → ℕ) (P₀ : Tile n) {k : ℤ} (hk : P₀.k ≤ k) {ξ : Rn n}
+    (hξ : ξ ∈ P₀.ω.toSet α) : Tile.le α P₀ (auxTile α P₀ k ξ) := by
+  refine ⟨?_, ?_⟩
+  · rw [auxTile_I α P₀ hk]; exact DCube.toSet_subset_ancestor α _ _
+  · have hkP : P₀.k ≤ (auxTile α P₀ k ξ).k := hk
+    exact ω_subset_of_mem_of_k_le α hkP (mem_auxTile_ω α P₀ k ξ) hξ (DCube.center_mem α _)
+
+/-- **Lemma 7.1** (paper, (7.6)–(7.7), texline~637–664): `|G_J| ≤ C μ |J|`, where
+`G_J = J ∩ ⋃_{P ∈ T, |I_P| > |J⁺|} E_{P(r)}`. -/
+theorem volume_GJ_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (r : Fin n → Fin 2) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (E : Set (Rn n)), MeasurableSet E → ∀ (N : Rn n → Rn n), Measurable N →
+      ∀ (top : Tile n) (T : Finset (Tile n)), IsTree α top T → ∀ (μ : ℝ), 0 ≤ μ →
+      (∀ P ∈ T, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) → ∀ J ∈ jSet α T,
+      volume (J.toSet α ∩ ⋃ P ∈ T.filter (fun P => J.k + 2 ≤ P.k), E ∩ N ⁻¹' (P.semiHO α r)) ≤
+        ENNReal.ofReal (C * μ * (2 : ℝ) ^ (J.k * (absA α : ℤ))) := by
+  set C : ℝ := 4 ^ nu1 α * 2 ^ (2 * absA α)
+  refine ⟨C, by positivity, fun E hE N hN top T hT μ hμ hmass J hJ => ?_⟩
+  -- the tile `P₀` with `I_{P₀} ⊆ J_tilde⁺`
+  obtain ⟨P₀, hP₀T, hP₀sub⟩ : ∃ P₀ ∈ T, P₀.I.toSet α ⊆ (J.parent α).enl3 α := by
+    by_contra h
+    push Not at h
+    exact hJ.2 h
+  set k := J.k + 2
+  have hP₀k : P₀.k ≤ k := by
+    have := DCube.k_le_of_subset_enl3 α hα hn hP₀sub
+    rw [DCube.parent_k] at this
+    simp only [Tile.I] at this
+    simp only [k]; omega
+  set P' := auxTile α P₀ k (top.cω α)
+  have hP'k : P'.k = k := rfl
+  have hle : Tile.le α P₀ P' := le_auxTile α P₀ hP₀k (hT P₀ hP₀T).2
+  -- the sets `E_{P(r)}` lie in `E_{P'}`
+  have hsub : J.toSet α ∩ ⋃ P ∈ T.filter (fun P => J.k + 2 ≤ P.k), E ∩ N ⁻¹' (P.semiHO α r) ⊆
+      J.toSet α ∩ (E ∩ N ⁻¹' (P'.ω.toSet α)) := by
+    rintro x ⟨hxJ, hxU⟩
+    simp only [Set.mem_iUnion, Finset.mem_filter] at hxU
+    obtain ⟨P, ⟨hPT, hPk⟩, hxE, hxN⟩ := hxU
+    refine ⟨hxJ, hxE, ?_⟩
+    have hω := ω_subset_of_mem_of_k_le α (show P'.k ≤ P.k from hPk) (hT P hPT).2
+      (mem_auxTile_ω α P₀ k (top.cω α))
+    exact hω (P.semiHO_subset_ω α r hxN)
+  -- the weight `w_{P'}` is `≳ |I_{P'}|⁻¹` on `J`
+  have hw : ∀ x ∈ J.toSet α, 1 ≤ 4 ^ nu1 α * P'.vol α * wP α (nu1 α) P' x := by
+    intro x hx
+    have hxQ : x ∈ (J.parent α).enl3 α :=
+      DCube.toSet_subset_enl3 α _ (DCube.toSet_subset_parent' α J hx)
+    have hcQ : P₀.cI α ∈ (J.parent α).enl3 α := hP₀sub (DCube.center_mem α P₀.I)
+    have h1 := rho_sub_le_of_mem_enl3 α hα (J.parent α) hxQ hcQ
+    rw [DCube.parent_k] at h1
+    have h2 : rho α (P₀.cI α - P'.cI α) ≤ (2 : ℝ) ^ P'.k :=
+      rho_sub_cI_le α hα P' (hle.1 (DCube.center_mem α P₀.I))
+    have htri : rho α (x - P'.cI α) ≤ rho α (x - P₀.cI α) + rho α (P₀.cI α - P'.cI α) := by
+      have := rho_add_le α hα (x - P₀.cI α) (P₀.cI α - P'.cI α)
+      rwa [sub_add_sub_cancel] at this
+    have hk2 : (2 : ℝ) ^ (J.k + 1 + 1) = (2 : ℝ) ^ P'.k := by
+      rw [hP'k, show J.k + 1 + 1 = k by simp only [k]; ring]
+    rw [hk2] at h1
+    have ht : (0 : ℝ) < (2 : ℝ) ^ P'.k := by positivity
+    have hW : 1 + ((2 : ℝ) ^ P'.k)⁻¹ * rho α (x - P'.cI α) ≤ 4 := by
+      have : ((2 : ℝ) ^ P'.k)⁻¹ * rho α (x - P'.cI α) ≤ 3 := by
+        rw [inv_mul_le_iff₀ ht]; linarith
+      linarith
+    have hpos : 0 < 1 + ((2 : ℝ) ^ P'.k)⁻¹ * rho α (x - P'.cI α) := by
+      have := rho_nonneg α (x - P'.cI α); positivity
+    rw [mul_assoc, vol_mul_wP α hα]
+    have h4 : (4 : ℝ) ^ (-nu1 α) ≤ (1 + ((2 : ℝ) ^ P'.k)⁻¹ * rho α (x - P'.cI α)) ^ (-nu1 α) :=
+      Real.rpow_le_rpow_of_nonpos hpos hW (by
+        simp only [nu1]; linarith [(Nat.cast_nonneg (absA α) : (0 : ℝ) ≤ absA α)])
+    calc (1 : ℝ) = 4 ^ nu1 α * 4 ^ (-nu1 α) := by
+          rw [← Real.rpow_add (by norm_num)]; simp
+      _ ≤ _ := by gcongr
+  have hEP' : MeasurableSet (E ∩ N ⁻¹' (P'.ω.toSet α)) :=
+    hE.inter (hN (DCube.measurableSet_toSet α P'.ω))
+  have hmassP' : ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P' x) ≤
+      ENNReal.ofReal μ :=
+    le_trans (le_iSup₂_of_le P' hle le_rfl) (hmass P₀ hP₀T)
+  calc volume (J.toSet α ∩ ⋃ P ∈ T.filter (fun P => J.k + 2 ≤ P.k), E ∩ N ⁻¹' (P.semiHO α r))
+      ≤ volume (J.toSet α ∩ (E ∩ N ⁻¹' (P'.ω.toSet α))) := measure_mono hsub
+    _ = ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α), (J.toSet α).indicator 1 x := by
+        rw [lintegral_indicator_one (DCube.measurableSet_toSet α J), Measure.restrict_apply
+          (DCube.measurableSet_toSet α J), Set.inter_comm]
+    _ ≤ ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α),
+          ENNReal.ofReal (4 ^ nu1 α * P'.vol α) * ENNReal.ofReal (wP α (nu1 α) P' x) := by
+        refine lintegral_mono fun x => ?_
+        by_cases hx : x ∈ J.toSet α
+        · rw [Set.indicator_of_mem hx, Pi.one_apply, ← ENNReal.ofReal_mul (by
+            have := P'.vol_pos α; positivity), ← ENNReal.ofReal_one]
+          exact ENNReal.ofReal_le_ofReal (hw x hx)
+        · rw [Set.indicator_of_notMem hx]; exact bot_le
+    _ = ENNReal.ofReal (4 ^ nu1 α * P'.vol α) *
+          ∫⁻ x in E ∩ N ⁻¹' (P'.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P' x) :=
+        lintegral_const_mul' _ _ ENNReal.ofReal_ne_top
+    _ ≤ ENNReal.ofReal (4 ^ nu1 α * P'.vol α) * ENNReal.ofReal μ := by gcongr
+    _ = _ := by
+        rw [← ENNReal.ofReal_mul (by have := P'.vol_pos α; positivity)]
+        congr 1
+        simp only [C, Tile.vol, hP'k, k]
+        rw [show (J.k + 2) * (absA α : ℤ) = J.k * (absA α : ℤ) + ((2 * absA α : ℕ) : ℤ) by
+          push_cast; ring, zpow_add₀ (by norm_num), zpow_natCast]
+        ring
+
+/-- The box `5 I_T` (concentric, five times the side lengths). -/
+def Tile.bigBox (α : Fin n → ℕ) (top : Tile n) : Set (Rn n) :=
+  {x | ∀ i, side α top.k i * top.ℓ i - 2 * side α top.k i ≤ x i ∧
+    x i < side α top.k i * (top.ℓ i + 1) + 2 * side α top.k i}
+
+theorem Tile.volume_bigBox (α : Fin n → ℕ) (top : Tile n) :
+    volume (top.bigBox α) = ENNReal.ofReal (5 ^ n * top.vol α) := by
+  have hset : top.bigBox α = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹' Set.pi Set.univ
+      (fun i => Set.Ico (side α top.k i * top.ℓ i - 2 * side α top.k i)
+        (side α top.k i * (top.ℓ i + 1) + 2 * side α top.k i)) := by
+    ext x; simp [Tile.bigBox]
+  rw [hset, (PiLp.volume_preserving_ofLp _).measure_preimage
+    (MeasurableSet.univ_pi fun i => measurableSet_Ico).nullMeasurableSet, Real.volume_pi_Ico,
+    ← ENNReal.ofReal_prod_of_nonneg (fun i _ => by have := side_pos α top.k i; nlinarith)]
+  congr 1
+  have : ∀ i, side α top.k i * (top.ℓ i + 1) + 2 * side α top.k i -
+      (side α top.k i * top.ℓ i - 2 * side α top.k i) = 5 * side α top.k i := fun i => by ring
+  simp only [this, Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin,
+    prod_side, Tile.vol]
+
+theorem measurableSet_bigBox (α : Fin n → ℕ) (top : Tile n) : MeasurableSet (top.bigBox α) := by
+  have hset : top.bigBox α = (WithLp.ofLp : Rn n → (Fin n → ℝ)) ⁻¹' Set.pi Set.univ
+      (fun i => Set.Ico (side α top.k i * top.ℓ i - 2 * side α top.k i)
+        (side α top.k i * (top.ℓ i + 1) + 2 * side α top.k i)) := by
+    ext x; simp [Tile.bigBox]
+  rw [hset]
+  exact (MeasurableSet.univ_pi fun i => measurableSet_Ico).preimage
+    (PiLp.volume_preserving_ofLp _).measurable
+
+/-- The cubes `J ∈ 𝒥` carrying tiles of scale `≥ k_J + 2` lie in `5 I_T`. -/
+theorem J_subset_bigBox (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {top : Tile n}
+    {T : Finset (Tile n)} (hT : IsTree α top T) {J : DCube n} (hJ : J ∈ jSet α T)
+    (hrel : ∃ P ∈ T, J.k + 2 ≤ P.k) : J.toSet α ⊆ top.bigBox α := by
+  obtain ⟨P₀, hP₀T, hP₀sub⟩ : ∃ P₀ ∈ T, P₀.I.toSet α ⊆ (J.parent α).enl3 α := by
+    by_contra h
+    push Not at h
+    exact hJ.2 h
+  obtain ⟨P, hPT, hPk⟩ := hrel
+  have hPtop : P.k ≤ top.k := by
+    have := DCube.k_le_of_subset α hα hn (hT P hPT).1; simpa [Tile.I] using this
+  intro x hx i
+  have hxQ := DCube.toSet_subset_enl3 α _ (DCube.toSet_subset_parent' α J hx) i
+  have hcmem := DCube.center_mem α P₀.I
+  set c := P₀.I.center α
+  have hcQ := hP₀sub hcmem i
+  have hcT := (hT P₀ hP₀T).1 hcmem i
+  rw [DCube.parent_k] at hxQ hcQ
+  simp only [Tile.I] at hcT
+  set s := side α (J.k + 1) i
+  have hs : 0 < s := side_pos α _ i
+  have hA : (1 : ℝ) ≤ 2 ^ α i := one_le_pow₀ (by norm_num)
+  have hsA : s * 2 ^ α i ≤ side α top.k i := by
+    have h1 : s * 2 ^ α i = side α (J.k + 1 + 1) i := by
+      rw [side_add α (J.k + 1) 1]; congr 1; simp [side]
+    rw [h1]; exact side_mono α (by omega) i
+  have hsT := side_pos α top.k i
+  constructor
+  · linarith [hxQ.1, hcQ.2, hcT.1]
+  · linarith [hxQ.2, hcQ.1, hcT.2]
+
+/-- Only the cubes carrying tiles of scale `≥ k_J + 2` matter, and their total measure is
+`≤ 5ⁿ |I_T|`. -/
+theorem tsum_volume_relevant_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {top : Tile n} {T : Finset (Tile n)} (hT : IsTree α top T) :
+    ∑' J : jSet α T, {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}.indicator
+      (fun J => volume (J.toSet α)) (J : DCube n) ≤ ENNReal.ofReal (5 ^ n * top.vol α) := by
+  classical
+  set S : jSet α T → Set (Rn n) := fun J =>
+    if ∃ P ∈ T, (J : DCube n).k + 2 ≤ P.k then (J : DCube n).toSet α else ∅
+  have hS : ∀ J : jSet α T, {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}.indicator
+      (fun J => volume (J.toSet α)) (J : DCube n) = volume (S J) := by
+    intro J
+    by_cases h : ∃ P ∈ T, (J : DCube n).k + 2 ≤ P.k
+    · simp [S, h]
+    · simp [S, h]
+  simp_rw [hS]
+  have hmeas : ∀ J, MeasurableSet (S J) := fun J => by
+    simp only [S]; split_ifs
+    · exact DCube.measurableSet_toSet α _
+    · exact MeasurableSet.empty
+  have hdisj : Pairwise (Function.onFun Disjoint S) := by
+    intro J J' hne
+    simp only [Function.onFun, S]
+    split_ifs
+    · exact jSet_disjoint α T J.2 J'.2 (fun h => hne (Subtype.ext h))
+    all_goals simp
+  rw [← measure_iUnion hdisj hmeas, ← Tile.volume_bigBox]
+  refine measure_mono (Set.iUnion_subset fun J => ?_)
+  simp only [S]
+  split_ifs with h
+  · exact J_subset_bigBox α hα hn hT J.2 h
+  · exact Set.empty_subset _
+
+/-! ### The case of `1`-trees (paper, §7.1, texline~672–690) -/
+
+/-- In a `1`-tree (half-open sense), two tiles whose semi-tiles contain the same frequency
+have the same frequency cube. -/
+theorem oneTree_ω_eq (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} {top : Tile n}
+    {S : Finset (Tile n)} (hS : IsTree α top S) (hS1 : ∀ P ∈ S, top.cω α ∉ P.semiHO α r)
+    {P Q : Tile n} (hP : P ∈ S) (hQ : Q ∈ S) {ξ : Rn n} (hξP : ξ ∈ P.semiHO α r)
+    (hξQ : ξ ∈ Q.semiHO α r) : P.ω = Q.ω := by
+  rcases lt_trichotomy P.k Q.k with hk | hk | hk
+  · exact absurd ((ω_subset_semiHO α hα hk r (Q.semiHO_subset_ω α r hξQ) hξP) (hS Q hQ).2)
+      (hS1 P hP)
+  · exact DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, hk]) (hS P hP).2 (hS Q hQ).2
+  · exact absurd ((ω_subset_semiHO α hα hk r (P.semiHO_subset_ω α r hξP) hξQ) (hS P hP).2)
+      (hS1 Q hQ)
+
+/-- The pointwise bound in the `1`-tree case (paper, (7.9)–(7.10)):
+`|∑_{P ∈ S} c_P ψ_P^{N(x)}(x) 1_{E_{P(r)}}(x)| ≤ C ‖m‖ ε`. -/
+theorem oneTree_pointwise_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : absA α < ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (top : Tile n) (S : Finset (Tile n)),
+      IsTree α top S → (∀ P ∈ S, top.cω α ∉ P.semiHO α r) → ∀ (c : Tile n → ℂ) (ε : ℝ), 0 ≤ ε →
+      (∀ P ∈ S, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      ∀ (E : Set (Rn n)) (N : Rn n → Rn n) (x : Rn n),
+      ‖∑ P ∈ S, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ ≤
+        C * (normM α ν m).toReal * ε := by
+  classical
+  obtain ⟨Cl, hCl, hlat⟩ := tree_scale_sum_le α hα (b := ν) (by exact_mod_cast hν)
+  set Cψ : ℝ := (psiConst α ν : ℝ)
+  have hCψ : 0 ≤ Cψ := NNReal.coe_nonneg _
+  refine ⟨Cψ * Cl, by positivity, fun m hm top S hS hS1 c ε hε hc E N x => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set U := S.filter fun P => x ∈ E ∩ N ⁻¹' (P.semiHO α r)
+  have hsumU : ∑ P ∈ S, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x =
+      ∑ P ∈ U, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x := by
+    rw [Finset.sum_filter_of_ne]
+    intro P _ hne
+    by_contra h
+    exact hne (by rw [Set.indicator_of_notMem h, mul_zero])
+  rw [hsumU]
+  rcases U.eq_empty_or_nonempty with hU | ⟨P₁, hP₁⟩
+  · rw [hU, Finset.sum_empty, norm_zero]; positivity
+  obtain ⟨hP₁S, hxP₁⟩ := Finset.mem_filter.mp hP₁
+  have hk : ∀ P ∈ U, P.k = P₁.k := by
+    intro P hP
+    obtain ⟨hPS, hxP⟩ := Finset.mem_filter.mp hP
+    have := oneTree_ω_eq α hα hS hS1 hPS hP₁S hxP.2 hxP₁.2
+    have := congrArg DCube.k this
+    simp only [Tile.ω, neg_inj] at this
+    exact this
+  calc ‖∑ P ∈ U, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖
+      ≤ ∑ P ∈ U, ‖c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ :=
+        norm_sum_le _ _
+    _ ≤ ∑ P ∈ U, ε * Cψ * Nm * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+        refine Finset.sum_le_sum fun P hP => ?_
+        obtain ⟨hPS, hxP⟩ := Finset.mem_filter.mp hP
+        rw [Set.indicator_of_mem hxP, Pi.one_apply, mul_one, norm_mul]
+        have hψ := psi_bound_on_semiHO α hα hr ν hm P hxP.2 x
+        have hpow : ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)
+            = 1 := by
+          rw [← Real.rpow_add (by positivity), show (absA α : ℝ) / 2 + -(absA α : ℝ) / 2 = 0 by
+              ring,
+            Real.rpow_zero]
+        calc ‖c P‖ * ‖wavePsi α m (N x) P x‖
+            ≤ (ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) * (Cψ * Nm *
+                ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+                (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ))) :=
+              mul_le_mul (hc P hPS) hψ (norm_nonneg _) (by positivity)
+          _ = ε * Cψ * Nm * (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) *
+                ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)) *
+                (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by ring
+          _ = _ := by rw [hpow, mul_one]
+    _ = ε * Cψ * Nm * ∑ P ∈ U, (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+        rw [Finset.mul_sum]
+    _ ≤ ε * Cψ * Nm * ∑ P ∈ S with P.k = P₁.k,
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+        refine mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg
+          (fun P hP => ?_) (fun P _ _ => ?_)) (by positivity)
+        · exact Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hP).1, hk P hP⟩
+        · have := rho_nonneg α (x - P.cI α); positivity
+    _ ≤ ε * Cψ * Nm * Cl := by gcongr; exact hlat top S hS P₁.k x
+    _ = Cψ * Cl * Nm * ε := by ring
+
+/-- **The term `𝒦₂` for `1`-trees** (paper, §7.1, texline~684–690):
+`∑_J ‖F_J‖_{L¹(J)} ≤ C ‖m‖ ε μ |I_T|`. -/
+theorem K2_oneTree_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : absA α < ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (E : Set (Rn n)), MeasurableSet E →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (top : Tile n) (T : Finset (Tile n)),
+      IsTree α top T → ∀ S ⊆ T, (∀ P ∈ S, top.cω α ∉ P.semiHO α r) →
+      ∀ (c : Tile n → ℂ) (ε μ : ℝ), 0 ≤ ε → 0 ≤ μ →
+      (∀ P ∈ T, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      (∀ P ∈ T, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) →
+      ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+        c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+        ENNReal.ofReal (C * (normM α ν m).toReal * ε * μ * top.vol α) := by
+  classical
+  obtain ⟨C1, hC1, hpt⟩ := oneTree_pointwise_le α hα hr ν hν
+  obtain ⟨C2, hC2, hGJ⟩ := volume_GJ_le α hα hn r
+  refine ⟨C1 * C2 * 5 ^ n, by positivity, fun m hm E hE N hN top T hT S hST hS1 c ε μ hε hμ hc
+    hmass => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set K : ℝ := C1 * Nm * ε
+  have hK : 0 ≤ K := by positivity
+  have hJ : ∀ J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+      c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+      ENNReal.ofReal (K * C2 * μ) * {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}.indicator
+        (fun J => volume (J.toSet α)) (J : DCube n) := by
+    intro J
+    set S' := S.filter fun P => (J : DCube n).k + 2 ≤ P.k
+    have hS'T : IsTree α top S' := fun P hP => hT P (hST (Finset.mem_filter.mp hP).1)
+    have hS'1 : ∀ P ∈ S', top.cω α ∉ P.semiHO α r := fun P hP => hS1 P (Finset.mem_filter.mp hP).1
+    by_cases hrel : ∃ P ∈ T, (J : DCube n).k + 2 ≤ P.k
+    · rw [Set.indicator_of_mem (show (J : DCube n) ∈ {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}
+        from hrel)]
+      set G := (J : DCube n).toSet α ∩ ⋃ P ∈ T.filter (fun P => (J : DCube n).k + 2 ≤ P.k),
+        E ∩ N ⁻¹' (P.semiHO α r)
+      have hGm : MeasurableSet G := (DCube.measurableSet_toSet α _).inter
+        (Finset.measurableSet_biUnion _ fun P _ => hE.inter (hN (measurableSet_semiHO α P r)))
+      have hbound : ∀ x ∈ (J : DCube n).toSet α, ‖∑ P ∈ S', c P * wavePsi α m (N x) P x *
+          (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤ ENNReal.ofReal K * G.indicator 1 x := by
+        intro x hx
+        by_cases hxG : x ∈ G
+        · rw [Set.indicator_of_mem hxG, Pi.one_apply, mul_one, ← ofReal_norm]
+          exact ENNReal.ofReal_le_ofReal (by
+            have := hpt m hm top S' hS'T hS'1 c ε hε (fun P hP =>
+              hc P (hST (Finset.mem_filter.mp hP).1)) E N x
+            simpa [K, mul_comm, mul_left_comm, mul_assoc] using this)
+        · have hzero : ∑ P ∈ S', c P * wavePsi α m (N x) P x *
+              (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x = 0 := by
+            refine Finset.sum_eq_zero fun P hP => ?_
+            have hxP : x ∉ E ∩ N ⁻¹' (P.semiHO α r) := by
+              intro hxP
+              apply hxG
+              refine ⟨hx, Set.mem_biUnion (Finset.mem_filter.mpr ⟨hST (Finset.mem_filter.mp hP).1,
+                (Finset.mem_filter.mp hP).2⟩) hxP⟩
+            rw [Set.indicator_of_notMem hxP, mul_zero]
+          rw [hzero]; simp
+      calc ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S', c P * wavePsi α m (N x) P x *
+            (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ
+          ≤ ∫⁻ x in (J : DCube n).toSet α, ENNReal.ofReal K * G.indicator 1 x :=
+            setLIntegral_mono' (DCube.measurableSet_toSet α _) hbound
+        _ ≤ ∫⁻ x, ENNReal.ofReal K * G.indicator 1 x := setLIntegral_le_lintegral _ _
+        _ = ENNReal.ofReal K * volume G := by
+            rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top, lintegral_indicator_one hGm]
+        _ ≤ ENNReal.ofReal K * ENNReal.ofReal (C2 * μ * (2 : ℝ) ^ ((J : DCube n).k * (absA α :
+            ℤ))) := by
+            gcongr
+            exact hGJ E hE N hN top T hT μ hμ hmass J J.2
+        _ = ENNReal.ofReal (K * C2 * μ) * volume ((J : DCube n).toSet α) := by
+            rw [DCube.volume_toSet, ← ENNReal.ofReal_mul hK, ← ENNReal.ofReal_mul (by positivity)]
+            congr 1; ring
+    · rw [Set.indicator_of_notMem (show (J : DCube n) ∉ {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}
+        from hrel), mul_zero]
+      have hS'e : S' = ∅ := by
+        refine Finset.eq_empty_of_forall_notMem fun P hP => hrel ⟨P, hST (Finset.mem_filter.mp
+            hP).1,
+          (Finset.mem_filter.mp hP).2⟩
+      simp [S', hS'e]
+  calc ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+        c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ
+      ≤ ∑' J : jSet α T, ENNReal.ofReal (K * C2 * μ) *
+          {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}.indicator (fun J => volume (J.toSet α))
+            (J : DCube n) := ENNReal.tsum_le_tsum hJ
+    _ = ENNReal.ofReal (K * C2 * μ) * ∑' J : jSet α T,
+          {J : DCube n | ∃ P ∈ T, J.k + 2 ≤ P.k}.indicator (fun J => volume (J.toSet α))
+            (J : DCube n) := ENNReal.tsum_mul_left
+    _ ≤ ENNReal.ofReal (K * C2 * μ) * ENNReal.ofReal (5 ^ n * top.vol α) := by
+        gcongr
+        exact tsum_volume_relevant_le α hα hn hT
+    _ = _ := by
+        rw [← ENNReal.ofReal_mul (by positivity)]
+        congr 1
+        simp only [K, Nm]
+        ring
+
+/-! ### The case of `2`-trees (paper, §7.2): the difference wave packets -/
+
+theorem mem_segment_coord_le {a a' ζ p : Rn n} {j : Fin n} {c : ℝ} (hj : a j ≤ c) (hj' : a' j ≤ c)
+    (hp : p ∈ segment ℝ (ζ + a') (ζ + a)) : ∃ b : Rn n, p = ζ + b ∧ b j ≤ c := by
+  obtain ⟨s, t, hs, ht, hst, rfl⟩ := hp
+  refine ⟨s • a' + t • a, ?_, ?_⟩
+  · rw [smul_add, smul_add, add_add_add_comm, ← add_smul, hst, one_smul]
+  · simp only [PiLp.add_apply, PiLp.smul_apply, smul_eq_mul]
+    have h1 := mul_le_mul_of_nonneg_left hj' hs
+    have h2 := mul_le_mul_of_nonneg_left hj ht
+    have : s * c + t * c = c := by rw [← add_mul, hst, one_mul]
+    linarith
+
+/-- Mean value bound for the derivatives of a multiplier along a segment away from the origin:
+`‖D^i m(ζ + a) − D^i m(ζ + a')‖ ≤ n^{i+1} 5^{(i+1)|α|} ‖m‖ ‖a − a'‖`. -/
+theorem norm_iteratedFDeriv_sub_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a a' : Rn n} {j : Fin n} (hj : a j ≤ -(1 / 4))
+    (hj' : a' j ≤ -(1 / 4)) {i : ℕ} (hi : i + 1 ≤ ν) {ζ : Rn n} (hζ : ζ ∈ boxB n) :
+    ‖iteratedFDeriv ℝ i m (ζ + a) - iteratedFDeriv ℝ i m (ζ + a')‖ ≤
+      ((n : ℝ) ^ (i + 1) * (1 / 5 : ℝ) ^ (-(((i + 1) * absA α : ℕ) : ℝ))) *
+        (normM α ν m).toReal * ‖a - a'‖ := by
+  set C : ℝ := ((n : ℝ) ^ (i + 1) * (1 / 5 : ℝ) ^ (-(((i + 1) * absA α : ℕ) : ℝ))) *
+    (normM α ν m).toReal
+  have hρ : ∀ p ∈ segment ℝ (ζ + a') (ζ + a), 1 / 5 ≤ rho α p := by
+    intro p hp
+    obtain ⟨b, rfl, hb⟩ := mem_segment_coord_le hj hj' hp
+    exact one_fifth_le_rho_add α hα ⟨j, by rw [abs_of_neg (by linarith)]; linarith⟩ hζ
+  have hdiff : ∀ p ∈ segment ℝ (ζ + a') (ζ + a), DifferentiableAt ℝ (iteratedFDeriv ℝ i m) p := by
+    intro p hp
+    have hp0 : p ≠ 0 := ne_zero_of_rho_pos α hα (by linarith [hρ p hp])
+    exact (hm.contDiffOn.contDiffAt (isOpen_compl_singleton.mem_nhds
+        hp0)).differentiableAt_iteratedFDeriv
+      (by exact_mod_cast (show i < ν by omega))
+  have hbound : ∀ p ∈ segment ℝ (ζ + a') (ζ + a), ‖fderiv ℝ (iteratedFDeriv ℝ i m) p‖ ≤ C := by
+    intro p hp
+    rw [norm_fderiv_iteratedFDeriv]
+    have h5 := enorm_iteratedFDeriv_le α hα hm hi (c := 1 / 5) (by norm_num) (by norm_num) (hρ p hp)
+    rw [← ofReal_norm] at h5
+    exact norm_le_of_enorm_le_ofReal_mul (by positivity) hfin h5
+  have := (convex_segment (ζ + a') (ζ + a)).norm_image_sub_le_of_norm_fderiv_le hdiff hbound
+    (left_mem_segment ℝ _ _) (right_mem_segment ℝ _ _)
+  rwa [add_sub_add_left_eq_sub] at this
+
+/-- The localized difference symbol `(m(ζ + a) − m(ζ + a')) φ̂(ζ)`. -/
+def glocDiff (m : Rn n → ℂ) (a a' : Rn n) : Rn n → ℂ :=
+  fun ζ => (m (ζ + a) - m (ζ + a')) * phiHat ζ
+
+theorem glocDiff_eq (m : Rn n → ℂ) (a a' : Rn n) : glocDiff m a a' = gloc m a - gloc m a' := by
+  ext ζ; simp [glocDiff, gloc, sub_mul]
+
+/-- The constants for the derivatives of the difference symbol. -/
+def gBoundD (α : Fin n → ℕ) (l : ℕ) : ℝ :=
+  ∑ i ∈ Finset.range (l + 1), (l.choose i : ℝ) *
+    ((n : ℝ) ^ (i + 1) * (1 / 5 : ℝ) ^ (-(((i + 1) * absA α : ℕ) : ℝ))) * phiHatBound n (l - i)
+
+theorem gBoundD_nonneg (α : Fin n → ℕ) (l : ℕ) : 0 ≤ gBoundD α l :=
+  Finset.sum_nonneg fun i _ => by
+    have := phiHatBound_nonneg n (l - i)
+    positivity
+
+theorem norm_iteratedFDeriv_glocDiff_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a a' : Rn n} {j : Fin n}
+    (hj : a j ≤ -(1 / 4)) (hj' : a' j ≤ -(1 / 4)) {l : ℕ} (hl : l + 1 ≤ ν) (ζ : Rn n) :
+    ‖iteratedFDeriv ℝ l (glocDiff m a a') ζ‖ ≤
+      (boxB n).indicator (fun _ => gBoundD α l * (normM α ν m).toReal * ‖a - a'‖) ζ := by
+  have ha : ∃ j, 1 / 4 ≤ |a j| := ⟨j, by rw [abs_of_neg (by linarith)]; linarith⟩
+  have ha' : ∃ j, 1 / 4 ≤ |a' j| := ⟨j, by rw [abs_of_neg (by linarith)]; linarith⟩
+  by_cases hζ : ζ ∈ boxB n
+  · rw [Set.indicator_of_mem hζ]
+    set U : Set (Rn n) := {η | η + a ≠ 0} ∩ {η | η + a' ≠ 0}
+    have hU : IsOpen U := (isOpen_ne_fun (continuous_id.add continuous_const)
+        continuous_const).inter
+      (isOpen_ne_fun (continuous_id.add continuous_const) continuous_const)
+    have hζU : ζ ∈ U := ⟨add_ne_zero_of_mem_boxB α hα ha hζ, add_ne_zero_of_mem_boxB α hα ha' hζ⟩
+    have hfa : ContDiffOn ℝ ν (fun η => m (η + a)) U := fun η hη =>
+      ((hm.contDiffOn.contDiffAt (isOpen_compl_singleton.mem_nhds hη.1)).comp η
+        (contDiffAt_id.add contDiffAt_const)).contDiffWithinAt
+    have hfa' : ContDiffOn ℝ ν (fun η => m (η + a')) U := fun η hη =>
+      ((hm.contDiffOn.contDiffAt (isOpen_compl_singleton.mem_nhds hη.2)).comp η
+        (contDiffAt_id.add contDiffAt_const)).contDiffWithinAt
+    have hf : ContDiffOn ℝ ν (fun η => m (η + a) - m (η + a')) U := hfa.sub hfa'
+    have hg : ContDiffOn ℝ ν phiHat U :=
+      (contDiff_phiHat.of_le (by exact_mod_cast (le_top : (ν : ℕ∞) ≤ ⊤))).contDiffOn
+    have hL := norm_iteratedFDerivWithin_mul_le hf hg hU.uniqueDiffOn hζU
+      (n := l) (by exact_mod_cast (show l ≤ ν by omega))
+    rw [show (fun ζ => (m (ζ + a) - m (ζ + a')) * phiHat ζ) = glocDiff m a a' from rfl,
+      iteratedFDerivWithin_of_isOpen l hU hζU] at hL
+    have hL' : ‖iteratedFDeriv ℝ l (glocDiff m a a') ζ‖ ≤ ∑ i ∈ Finset.range (l + 1),
+        (l.choose i : ℝ) * ‖iteratedFDerivWithin ℝ i (fun η => m (η + a) - m (η + a')) U ζ‖ *
+          ‖iteratedFDeriv ℝ (l - i) phiHat ζ‖ := by
+      refine hL.trans (le_of_eq (Finset.sum_congr rfl fun i _ => ?_))
+      rw [iteratedFDerivWithin_of_isOpen (l - i) hU hζU]
+    refine hL'.trans ?_
+    rw [gBoundD, Finset.sum_mul, Finset.sum_mul]
+    refine Finset.sum_le_sum fun i hi => ?_
+    have hi' : i + 1 ≤ ν := by
+      have := Nat.lt_succ_iff.mp (Finset.mem_range.mp hi); omega
+    have hA : ‖iteratedFDerivWithin ℝ i (fun η => m (η + a) - m (η + a')) U ζ‖ ≤
+        ((n : ℝ) ^ (i + 1) * (1 / 5 : ℝ) ^ (-(((i + 1) * absA α : ℕ) : ℝ))) *
+          (normM α ν m).toReal * ‖a - a'‖ := by
+      have hio : ((i : ℕ∞) : WithTop ℕ∞) ≤ ((ν : ℕ∞) : WithTop ℕ∞) := by
+        exact_mod_cast (show i ≤ ν by omega)
+      change ‖iteratedFDerivWithin ℝ i ((fun η => m (η + a)) - (fun η => m (η + a'))) U ζ‖ ≤ _
+      rw [iteratedFDerivWithin_sub_apply ((hfa ζ hζU).of_le hio) ((hfa' ζ hζU).of_le hio)
+        hU.uniqueDiffOn hζU,
+        iteratedFDerivWithin_of_isOpen i hU hζU, iteratedFDerivWithin_of_isOpen i hU hζU,
+        iteratedFDeriv_comp_add_right, iteratedFDeriv_comp_add_right]
+      exact norm_iteratedFDeriv_sub_le α hα hm hfin hj hj' hi' hζ
+    have hB := norm_iteratedFDeriv_phiHat_le (n := n) (l - i) ζ
+    have hK := phiHatBound_nonneg n (l - i)
+    calc (l.choose i : ℝ) * ‖iteratedFDerivWithin ℝ i (fun η => m (η + a) - m (η + a')) U ζ‖ *
+          ‖iteratedFDeriv ℝ (l - i) phiHat ζ‖
+        ≤ (l.choose i : ℝ) * (((n : ℝ) ^ (i + 1) * (1 / 5 : ℝ) ^ (-(((i + 1) * absA α : ℕ) : ℝ))) *
+            (normM α ν m).toReal * ‖a - a'‖) * phiHatBound n (l - i) := by gcongr
+      _ = _ := by ring
+  · have h0 : iteratedFDeriv ℝ l (glocDiff m a a') ζ = 0 := by
+      rw [glocDiff_eq]
+      have e1 := ((gloc_eventually_zero m a hζ).iteratedFDeriv ℝ l).eq_of_nhds
+      have e2 := ((gloc_eventually_zero m a' hζ).iteratedFDeriv ℝ l).eq_of_nhds
+      have hlo : ((l : ℕ∞) : WithTop ℕ∞) ≤ ((ν : ℕ∞) : WithTop ℕ∞) := by
+        exact_mod_cast (show l ≤ ν by omega)
+      rw [iteratedFDeriv_sub_apply ((contDiff_gloc α hα hm ha).contDiffAt.of_le hlo)
+        ((contDiff_gloc α hα hm ha').contDiffAt.of_le hlo), e1, e2, sub_self]
+    rw [Set.indicator_of_notMem hζ, h0, norm_zero]
+
+theorem integral_norm_glocDiff_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ}
+    {m : Rn n → ℂ} (hm : ClassM α ν m) (hfin : normM α ν m ≠ ⊤) {a a' : Rn n} {j : Fin n}
+    (hj : a j ≤ -(1 / 4)) (hj' : a' j ≤ -(1 / 4)) {l : ℕ} (hl : l + 1 ≤ ν) :
+    ∫ ζ, ‖iteratedFDeriv ℝ l (glocDiff m a a') ζ‖ ≤
+      gBoundD α l * (normM α ν m).toReal * ‖a - a'‖ * volB n := by
+  have hmeas : MeasurableSet (boxB n) := isCompact_boxB.isClosed.measurableSet
+  have hfinB : volume (boxB n) ≠ ⊤ := isCompact_boxB.measure_lt_top.ne
+  calc ∫ ζ, ‖iteratedFDeriv ℝ l (glocDiff m a a') ζ‖
+      ≤ ∫ ζ, (boxB n).indicator (fun _ => gBoundD α l * (normM α ν m).toReal * ‖a - a'‖) ζ := by
+        apply integral_mono_of_nonneg (Filter.Eventually.of_forall fun ζ => norm_nonneg _)
+        · exact (integrableOn_const hfinB enorm_ne_top).integrable_indicator hmeas
+        · exact Filter.Eventually.of_forall fun ζ =>
+            norm_iteratedFDeriv_glocDiff_le α hα hm hfin hj hj' hl ζ
+    _ = _ := by
+        rw [integral_indicator_const _ hmeas, smul_eq_mul, volB, measureReal_def, mul_comm]
+
+/-- The difference wave packet estimate: for `N, N'` on the same side of `ω_{P(0)}` in the
+coordinate `j`,
+`|ψ^N_P(x) − ψ^{N'}_P(x)| ≤ C ‖m‖_{𝓜^{ν+1}} ‖δ_{2^{k_P}}(N − N')‖ |I_P|^{-1/2}
+  (1 + 2^{-k_P}ρ(x − c(I_P)))^{-ν}`. -/
+theorem psiDiff_estimate (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (ν : ℕ) {m : Rn n → ℂ}
+    (hm : ClassM α (ν + 1) m) (hfin : normM α (ν + 1) m ≠ ⊤) (P : Tile n) {N N' : Rn n}
+    {j : Fin n} (hN : side α (-P.k) j / 4 ≤ N j - P.cω0 α j)
+    (hN' : side α (-P.k) j / 4 ≤ N' j - P.cω0 α j) (x : Rn n) :
+    ‖wavePsi α m N P x - wavePsi α m N' P x‖ ≤
+      ((2 * π) ^ n)⁻¹ * ((gBoundD α 0 + gBoundD α ν) * volB n * 2 ^ ν) *
+        (normM α (ν + 1) m).toReal * ‖dil α ((2 : ℝ) ^ P.k) (N - N')‖ *
+        ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+  set t : ℝ := (2 : ℝ) ^ P.k with ht_def
+  have ht : 0 < t := by positivity
+  set a : Rn n := dil α t (P.cω0 α - N)
+  set a' : Rn n := dil α t (P.cω0 α - N')
+  have hs : side α P.k j * side α (-P.k) j = 1 := by rw [← side_add]; simp [side]
+  have hsP := side_pos α P.k j
+  have haj : a j ≤ -(1 / 4) := by
+    simp only [a, ht_def, dil_zpow_apply, PiLp.sub_apply]
+    have : side α P.k j * (side α (-P.k) j / 4) = 1 / 4 := by rw [mul_div_assoc', hs]
+    nlinarith
+  have haj' : a' j ≤ -(1 / 4) := by
+    simp only [a', ht_def, dil_zpow_apply, PiLp.sub_apply]
+    have : side α P.k j * (side α (-P.k) j / 4) = 1 / 4 := by rw [mul_div_assoc', hs]
+    nlinarith
+  have ha : ∃ j, 1 / 4 ≤ |a j| := ⟨j, by rw [abs_of_neg (by linarith)]; linarith⟩
+  have ha' : ∃ j, 1 / 4 ≤ |a' j| := ⟨j, by rw [abs_of_neg (by linarith)]; linarith⟩
+  set y : Rn n := dil α t⁻¹ (x - P.cI α)
+  -- the rescaled integrands
+  have hresc : ∀ (N₀ : Rn n) (b : Rn n), b = dil α t (P.cω0 α - N₀) → (∃ j, 1 / 4 ≤ |b j|) →
+      (∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * m (P.cω0 α - N₀ + dil α t⁻¹ ζ) * phiHat ζ) =
+        ∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * gloc m b ζ := by
+    intro N₀ b hb hbj
+    congr 1
+    ext ζ
+    rw [mul_assoc]
+    congr 1
+    simp only [gloc]
+    by_cases hζ : ζ ∈ boxB n
+    · congr 1
+      have hne := add_ne_zero_of_mem_boxB α hα hbj hζ
+      have : P.cω0 α - N₀ + dil α t⁻¹ ζ = dil α t⁻¹ (ζ + b) := by
+        rw [hb]
+        simp only [dil_add, dil_dil, inv_mul_cancel₀ ht.ne', dil_one]
+        abel
+      rw [this, hm.homogeneous _ hne _ (inv_pos.mpr ht)]
+    · have : phiHat ζ = 0 := by
+        simp only [boxB, Set.mem_ofPred_eq, not_forall, not_le] at hζ
+        obtain ⟨i, hi⟩ := hζ
+        exact phiHat_eq_zero_of_lt hi.le
+      simp [this]
+  have hdiff : wavePsi α m N P x - wavePsi α m N' P x = (((2 * π) ^ n)⁻¹ : ℂ) *
+      (((t ^ (-((absA α : ℝ) / 2)) : ℝ) : ℂ)) * Complex.exp (Complex.I * (⟪x, P.cω0 α⟫_ℝ : ℂ)) *
+        ∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * glocDiff m a a' ζ := by
+    rw [wavePsi_eq_rescaled, wavePsi_eq_rescaled, ← ht_def, hresc N a rfl ha, hresc N' a' rfl ha',
+      ← mul_sub, ← integral_sub]
+    · congr 2; ext ζ; rw [glocDiff_eq]; simp only [Pi.sub_apply]; ring
+    · have hce : Continuous fun ζ : Rn n => Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) := by
+        fun_prop
+      exact (hce.mul (contDiff_gloc α hα hm ha).continuous).integrable_of_hasCompactSupport
+        (hasCompactSupport_gloc m a).mul_left
+    · have hce : Continuous fun ζ : Rn n => Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) := by
+        fun_prop
+      exact (hce.mul (contDiff_gloc α hα hm ha').continuous).integrable_of_hasCompactSupport
+        (hasCompactSupport_gloc m a').mul_left
+  -- the oscillatory integral
+  have hcd : ContDiff ℝ ν (glocDiff m a a') := by
+    rw [glocDiff_eq]
+    exact ((contDiff_gloc α hα hm ha).sub (contDiff_gloc α hα hm ha')).of_le
+      (by exact_mod_cast Nat.le_succ ν)
+  have hcs : HasCompactSupport (glocDiff m a a') := by
+    rw [glocDiff_eq]; exact (hasCompactSupport_gloc m a).sub (hasCompactSupport_gloc m a')
+  set M := (normM α (ν + 1) m).toReal
+  have hM : 0 ≤ M := ENNReal.toReal_nonneg
+  have hVB : 0 ≤ volB n := ENNReal.toReal_nonneg
+  have h0 := integral_norm_glocDiff_le α hα hm hfin haj haj' (l := 0) (by omega)
+  simp only [norm_iteratedFDeriv_zero] at h0
+  have hνb := integral_norm_glocDiff_le α hα hm hfin haj haj' (l := ν) le_rfl
+  have hI := norm_integral_exp_le_of_bounds α hα hcd hcs
+    (by have := gBoundD_nonneg α 0; positivity) (by have := gBoundD_nonneg α ν; positivity) h0 hνb y
+  have haa : a - a' = dil α t (N' - N) := by
+    simp only [a, a']; rw [← dil_sub]; congr 1; abel
+  have hnorm : ‖a - a'‖ = ‖dil α t (N - N')‖ := by
+    rw [haa, ← norm_neg, ← dil_neg, neg_sub]
+  rw [hdiff, norm_mul, norm_mul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I,
+    mul_one]
+  have h1 : ‖(((2 * π) ^ n)⁻¹ : ℂ)‖ = ((2 * π) ^ n)⁻¹ := by
+    rw [norm_inv, norm_pow, Complex.norm_mul, Complex.norm_ofNat, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos Real.pi_pos]
+  have h2 : ‖((t ^ (-((absA α : ℝ) / 2)) : ℝ) : ℂ)‖ = t ^ (-((absA α : ℝ) / 2)) := by
+    rw [Complex.norm_real, Real.norm_eq_abs, abs_of_pos (by positivity)]
+  rw [h1, h2]
+  have hy : 1 + rho α y = 1 + t⁻¹ * rho α (x - P.cI α) := (one_add_inv_mul_rho_eq α hα ht _).symm
+  rw [hy, hnorm] at hI
+  have hneg : -((absA α : ℝ) / 2) = -(absA α : ℝ) / 2 := by ring
+  rw [hneg]
+  calc ((2 * π) ^ n)⁻¹ * t ^ (-(absA α : ℝ) / 2) *
+        ‖∫ ζ, Complex.exp (Complex.I * (⟪y, ζ⟫_ℝ : ℂ)) * glocDiff m a a' ζ‖
+      ≤ ((2 * π) ^ n)⁻¹ * t ^ (-(absA α : ℝ) / 2) *
+          ((gBoundD α 0 * M * ‖dil α t (N - N')‖ * volB n +
+            gBoundD α ν * M * ‖dil α t (N - N')‖ * volB n) * 2 ^ ν *
+            (1 + t⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ))) := by gcongr
+    _ = _ := by ring
+
+theorem norm_le_sum_abs_coord (v : Rn n) : ‖v‖ ≤ ∑ j, |v j| := by
+  calc ‖v‖ = ‖∑ j, v j • EuclideanSpace.single j (1 : ℝ)‖ := by rw [← eq_sum_single]
+    _ ≤ ∑ j, ‖v j • EuclideanSpace.single j (1 : ℝ)‖ := norm_sum_le _ _
+    _ = ∑ j, |v j| := by
+        refine Finset.sum_congr rfl fun j _ => ?_
+        rw [norm_smul, PiLp.norm_single, norm_one, mul_one, Real.norm_eq_abs]
+
+/-- In a `2`-tree (half-open sense) the semi-tiles are nested: a frequency in the semi-tile of a
+finer tile lies in the semi-tile of every coarser tile. -/
+theorem twoTree_semiHO_mono (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    {top : Tile n} {S : Finset (Tile n)} (hS : IsTree α top S)
+    (hS2 : ∀ P ∈ S, top.cω α ∈ P.semiHO α r) {P Q : Tile n} (hP : P ∈ S) (hQ : Q ∈ S)
+    (hk : P.k ≤ Q.k) : Q.semiHO α r ⊆ P.semiHO α r := by
+  rcases hk.lt_or_eq with hlt | heq
+  · intro ξ hξ
+    exact ω_subset_semiHO α hα hlt r (hS Q hQ).2 (hS2 P hP) (Q.semiHO_subset_ω α r hξ)
+  · have hω : P.ω = Q.ω := DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, heq]) (hS P hP).2
+      (hS Q hQ).2
+    have hu : P.u = Q.u := congrArg DCube.ℓ hω
+    intro ξ hξ i
+    have := hξ i
+    simp only [heq, hu] at this ⊢
+    exact this
+
+theorem far_of_mem_semiHO (α : Fin n → ℕ) {r : Fin n → Fin 2} {i₀ : Fin n} (hr : r i₀ = 1)
+    (P : Tile n) {ξ : Rn n} (hξ : ξ ∈ P.semiHO α r) :
+    side α (-P.k) i₀ / 4 ≤ ξ i₀ - P.cω0 α i₀ := by
+  have h := (hξ i₀).1
+  rw [hr] at h
+  simp only [Fin.isValue, Fin.val_one, Nat.cast_one] at h
+  have hs := side_pos α (-P.k) i₀
+  simp only [Tile.cω0, PiLp.toLp_apply]
+  nlinarith
+
+/-- **Term 2 in the `2`-tree case**, pointwise: for tiles `A ⊆ S` whose semi-tiles contain `N`,
+`|∑_{P ∈ A} c_P (ψ^N_P(x) − ψ^{ξ₀}_P(x))| ≤ C ‖m‖_{𝓜^{ν+1}} ε`, `ξ₀ = c(ω_T)`. -/
+theorem twoTree_term2_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} (hr : r ≠ 0)
+    (ν : ℕ) (hν : absA α < ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (ν + 1) m → ∀ (top : Tile n)
+      (S : Finset (Tile n)), IsTree α top S → (∀ P ∈ S, top.cω α ∈ P.semiHO α r) →
+      ∀ (c : Tile n → ℂ) (ε : ℝ), 0 ≤ ε →
+      (∀ P ∈ S, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      ∀ (N₀ : Rn n) (A : Finset (Tile n)), A ⊆ S → (∀ P ∈ A, N₀ ∈ P.semiHO α r) → ∀ x : Rn n,
+      ‖∑ P ∈ A, c P * (wavePsi α m N₀ P x - wavePsi α m (top.cω α) P x)‖ ≤
+        C * (normM α (ν + 1) m).toReal * ε := by
+  classical
+  obtain ⟨i₀, hi₀⟩ := exists_eq_one_of_ne_zero hr
+  obtain ⟨Cl, hCl, hlat⟩ := tree_scale_sum_le α hα (b := ν) (by exact_mod_cast hν)
+  set Cd : ℝ := ((2 * π) ^ n)⁻¹ * ((gBoundD α 0 + gBoundD α ν) * volB n * 2 ^ ν)
+  have hCd : 0 ≤ Cd := by
+    have := gBoundD_nonneg α 0; have := gBoundD_nonneg α ν
+    have : 0 ≤ volB n := ENNReal.toReal_nonneg
+    positivity
+  refine ⟨Cd * n * Cl * 2, by positivity, fun m hm top S hS hS2 c ε hε hc N₀ A hAS hAN x => ?_⟩
+  set M := (normM α (ν + 1) m).toReal
+  have hM : 0 ≤ M := ENNReal.toReal_nonneg
+  have htop : normM α (ν + 1) m ≠ ⊤ := (normM_lt_top α hα hm).ne
+  rcases A.eq_empty_or_nonempty with hA | hAne
+  · rw [hA, Finset.sum_empty, norm_zero]; positivity
+  obtain ⟨Pm, hPmA, hPmax⟩ := Finset.exists_max_image A (fun P => P.k) hAne
+  set K := Pm.k
+  have hξ₀ : top.cω α ∈ Pm.semiHO α r := hS2 Pm (hAS hPmA)
+  have hN₀ : N₀ ∈ Pm.semiHO α r := hAN Pm hPmA
+  -- each term
+  have hterm : ∀ P ∈ A, ‖c P * (wavePsi α m N₀ P x - wavePsi α m (top.cω α) P x)‖ ≤
+      ε * Cd * M * (n * (2 : ℝ) ^ (P.k - K)) *
+        (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+    intro P hPA
+    have hPS := hAS hPA
+    have hPK : P.k ≤ K := hPmax P hPA
+    have hd := psiDiff_estimate α hα ν hm htop P (far_of_mem_semiHO α hi₀ P (hAN P hPA))
+      (far_of_mem_semiHO α hi₀ P (hS2 P hPS)) x
+    -- smallness of `δ_{2^{k_P}}(N₀ − ξ₀)`
+    have hsmall : ‖dil α ((2 : ℝ) ^ P.k) (N₀ - top.cω α)‖ ≤ n * (2 : ℝ) ^ (P.k - K) := by
+      refine (norm_le_sum_abs_coord _).trans ?_
+      calc ∑ i, |dil α ((2 : ℝ) ^ P.k) (N₀ - top.cω α) i| ≤ ∑ _i : Fin n, (2 : ℝ) ^ (P.k - K) := by
+            refine Finset.sum_le_sum fun i _ => ?_
+            have h1 := hN₀ i
+            have h2 := hξ₀ i
+            have hs := side_pos α (-K) i
+            have hr0 : (0 : ℝ) ≤ (r i : ℝ) := Nat.cast_nonneg _
+            have hbound : |N₀ i - top.cω α i| ≤ side α (-K) i := by
+              rw [abs_le]; constructor <;> nlinarith [h1.1, h1.2, h2.1, h2.2]
+            rw [dil_apply, PiLp.sub_apply, abs_mul, abs_of_pos (by positivity)]
+            calc ((2 : ℝ) ^ P.k) ^ α i * |N₀ i - top.cω α i| ≤
+                ((2 : ℝ) ^ P.k) ^ α i * side α (-K) i := by gcongr
+              _ = (2 : ℝ) ^ ((P.k - K) * (α i : ℤ)) := by
+                  rw [side, ← zpow_natCast, ← zpow_mul, ← zpow_add₀ (by norm_num)]
+                  congr 1; ring
+              _ ≤ (2 : ℝ) ^ (P.k - K) := by
+                  refine zpow_le_zpow_right₀ (by norm_num) ?_
+                  have := hα i
+                  nlinarith
+        _ = n * (2 : ℝ) ^ (P.k - K) := by simp
+    have hpow : ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) = 1
+        := by
+      rw [← Real.rpow_add (by positivity), show (absA α : ℝ) / 2 + -(absA α : ℝ) / 2 = 0 by ring,
+        Real.rpow_zero]
+    have hW : 0 ≤ (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+      have := rho_nonneg α (x - P.cI α); positivity
+    rw [norm_mul]
+    calc ‖c P‖ * ‖wavePsi α m N₀ P x - wavePsi α m (top.cω α) P x‖
+        ≤ (ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) * (Cd * M *
+            ‖dil α ((2 : ℝ) ^ P.k) (N₀ - top.cω α)‖ * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2) *
+            (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ))) :=
+          mul_le_mul (hc P hPS) hd (norm_nonneg _) (by positivity)
+      _ = ε * Cd * M * ‖dil α ((2 : ℝ) ^ P.k) (N₀ - top.cω α)‖ *
+            (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)) *
+            (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by ring
+      _ ≤ ε * Cd * M * (n * (2 : ℝ) ^ (P.k - K)) * 1 *
+            (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+          rw [hpow]; gcongr
+      _ = _ := by ring
+  -- sum over scales
+  set ks := A.image Tile.k
+  have hks : ∀ k ∈ ks, k ≤ K := by
+    intro k hk
+    obtain ⟨P, hP, rfl⟩ := Finset.mem_image.mp hk
+    exact hPmax P hP
+  calc ‖∑ P ∈ A, c P * (wavePsi α m N₀ P x - wavePsi α m (top.cω α) P x)‖
+      ≤ ∑ P ∈ A, ‖c P * (wavePsi α m N₀ P x - wavePsi α m (top.cω α) P x)‖ := norm_sum_le _ _
+    _ ≤ ∑ P ∈ A, ε * Cd * M * (n * (2 : ℝ) ^ (P.k - K)) *
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := Finset.sum_le_sum hterm
+    _ = ∑ k ∈ ks, ∑ P ∈ A with P.k = k, ε * Cd * M * (n * (2 : ℝ) ^ (P.k - K)) *
+          (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) :=
+        (Finset.sum_fiberwise_of_maps_to (fun P hP => Finset.mem_image_of_mem _ hP) _).symm
+    _ ≤ ∑ k ∈ ks, ε * Cd * M * n * (2 : ℝ) ^ (k - K) * Cl := by
+        refine Finset.sum_le_sum fun k _ => ?_
+        calc ∑ P ∈ A with P.k = k, ε * Cd * M * (n * (2 : ℝ) ^ (P.k - K)) *
+              (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ))
+            = ε * Cd * M * n * (2 : ℝ) ^ (k - K) * ∑ P ∈ A with P.k = k,
+                (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+              rw [Finset.mul_sum]
+              refine Finset.sum_congr rfl fun P hP => ?_
+              rw [(Finset.mem_filter.mp hP).2]; ring
+          _ ≤ ε * Cd * M * n * (2 : ℝ) ^ (k - K) * ∑ P ∈ S with P.k = k,
+                (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(ν : ℝ)) := by
+              refine mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg
+                (fun P hP => ?_) (fun P _ _ => ?_)) (by positivity)
+              · exact Finset.mem_filter.mpr ⟨hAS (Finset.mem_filter.mp hP).1,
+                  (Finset.mem_filter.mp hP).2⟩
+              · have := rho_nonneg α (x - P.cI α); positivity
+          _ ≤ _ := by gcongr; exact hlat top S hS k x
+    _ = ε * Cd * M * n * Cl * ∑ k ∈ ks, (2 : ℝ) ^ (k - K) := by
+        rw [Finset.mul_sum]; congr 1; ext k; ring
+    _ ≤ ε * Cd * M * n * Cl * 2 := by gcongr; exact sum_two_zpow_sub_le ks K hks
+    _ = _ := by ring
+
+/-! ### Frequency cutoffs for the `2`-tree case -/
+
+/-- A Schwartz function with `φ̂_L(ξ) = φ̂(ξ / L)`. -/
+def phiLS (L : ℝ) (hL : L ≠ 0) : 𝓢(Rn n, ℂ) :=
+  FourierTransformInv.fourierInv (HasCompactSupport.toSchwartzMap
+    (f := fun η : Rn n => phiHat (((2 * π) / L) • η))
+    (hasCompactSupport_phiHat.comp_smul (div_ne_zero (by positivity) hL))
+    (contDiff_phiHat.comp (contDiff_const_smul _)))
+
+theorem fhat_phiLS (L : ℝ) (hL : L ≠ 0) (ξ : Rn n) :
+    fhat (phiLS L hL : Rn n → ℂ) ξ = phiHat (L⁻¹ • ξ) := by
+  rw [fhat_eq_fourier, ← SchwartzMap.fourier_coe, phiLS, FourierInvPair.fourier_fourierInv_eq]
+  change phiHat (((2 * π) / L) • (2 * π)⁻¹ • ξ) = phiHat (L⁻¹ • ξ)
+  rw [smul_smul]
+  congr 2
+  field_simp
+
+/-- The frequency cutoff `h` with `hhat(ξ) = φ̂(L⁻¹ δ_{2^k}(ξ − c))`. -/
+def hBump (α : Fin n → ℕ) (L : ℝ) (hL : L ≠ 0) (k : ℤ) (c : Rn n) : Rn n → ℂ :=
+  fun z => ((((2 : ℝ) ^ k) ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+    modul c (transl 0 (dilOp α 2 ((2 : ℝ) ^ k) (phiLS L hL : Rn n → ℂ))) z
+
+theorem fhat_hBump (α : Fin n → ℕ) (L : ℝ) (hL : L ≠ 0) (k : ℤ) (c ξ : Rn n) :
+    fhat (hBump α L hL k c) ξ = phiHat (L⁻¹ • dil α ((2 : ℝ) ^ k) (ξ - c)) := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ k := by positivity
+  have h1 : fhat (hBump α L hL k c) ξ = ((((2 : ℝ) ^ k) ^ (-(absA α : ℝ) / 2) : ℝ) : ℂ) *
+      fhat (modul c (transl 0 (dilOp α 2 ((2 : ℝ) ^ k) (phiLS L hL : Rn n → ℂ)))) ξ := by
+    simp only [fhat, hBump]
+    rw [← integral_const_mul]
+    congr 1; ext x; ring
+  rw [h1, fhat_modul_transl_dilOp α c 0 ht, fhat_phiLS, inner_zero_left]
+  simp only [Complex.ofReal_zero, mul_zero, neg_zero, Complex.exp_zero, mul_one]
+  rw [← mul_assoc, ← Complex.ofReal_mul, ← Real.rpow_add ht,
+    show -(absA α : ℝ) / 2 + (absA α : ℝ) / 2 = 0 by ring, Real.rpow_zero, Complex.ofReal_one,
+    one_mul]
+
+theorem norm_hBump (α : Fin n → ℕ) (L : ℝ) (hL : L ≠ 0) (k : ℤ) (c z : Rn n) :
+    ‖hBump α L hL k c z‖ = ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+      ‖(phiLS L hL : Rn n → ℂ) (dil α ((2 : ℝ) ^ k)⁻¹ z)‖ := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ k := by positivity
+  have hexp : ∀ w : Rn n, ‖Complex.exp (Complex.I * (⟪w, c⟫_ℝ : ℂ))‖ = 1 := fun w => by
+    rw [mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I]
+  simp only [hBump, modul, transl, dilOp, sub_zero, norm_mul, hexp, one_mul, Complex.norm_real,
+    Real.norm_eq_abs]
+  rw [abs_of_pos (by positivity), ← mul_assoc, ← Real.rpow_add ht]
+  congr 2; ring
+
+theorem hBump_decay (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (L : ℝ) (hL : L ≠ 0) (M : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (k : ℤ) (c z : Rn n), ‖hBump α L hL k c z‖ ≤
+      C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+        (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) ^ (-(M : ℝ)) := by
+  obtain ⟨C, hC, hdec⟩ := schwartz_rho_decay α hα (phiLS L hL) M
+  refine ⟨C, hC, fun k c z => ?_⟩
+  have ht : (0 : ℝ) < (2 : ℝ) ^ k := by positivity
+  rw [norm_hBump, one_add_inv_mul_rho_eq α hα ht]
+  calc ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) * ‖(phiLS L hL : Rn n → ℂ) (dil α ((2 : ℝ) ^ k)⁻¹ z)‖
+      ≤ ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) * (C * (1 + rho α (dil α ((2 : ℝ) ^ k)⁻¹ z)) ^ (-(M :
+          ℝ))) := by
+        gcongr; exact hdec _
+    _ = _ := by ring
+
+theorem continuous_hBump (α : Fin n → ℕ) (L : ℝ) (hL : L ≠ 0) (k : ℤ) (c : Rn n) :
+    Continuous (hBump α L hL k c) := by
+  have hφ : Continuous (phiLS L hL : Rn n → ℂ) := (phiLS L hL).continuous
+  unfold hBump modul transl dilOp
+  have : Continuous fun z : Rn n => dil α ((2 : ℝ) ^ k)⁻¹ (z - 0) := by fun_prop
+  fun_prop
+
+theorem integrable_hBump (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (L : ℝ) (hL : L ≠ 0) (k : ℤ)
+    (c : Rn n) : Integrable (hBump α L hL k c) := by
+  obtain ⟨C, hC, hdec⟩ := hBump_decay α hα L hL (absA α + 1)
+  have hs : (absA α : ℝ) < ((absA α + 1 : ℕ) : ℝ) := by push_cast; linarith
+  refine ((integrable_wgt_scaled α hα hs (t := (2 : ℝ) ^ k) (by positivity) 0).const_mul
+    (C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)))).mono' (continuous_hBump α L hL k c).aestronglyMeasurable
+    (Filter.Eventually.of_forall fun z => ?_)
+  simpa [sub_zero, mul_assoc] using hdec k c z
+
+theorem pow_mul_side_neg (α : Fin n → ℕ) (k : ℤ) (i : Fin n) :
+    ((2 : ℝ) ^ k) ^ α i * side α (-k) i = 1 := by
+  rw [side, ← zpow_natCast, ← zpow_mul, ← zpow_add₀ (by norm_num)]
+  simp
+
+theorem fhat_hBump_eq_one (α : Fin n → ℕ) {L : ℝ} (hL : 0 < L) (k : ℤ) (c ξ : Rn n)
+    (h : ∀ i, |ξ i - c i| ≤ L * (b1 / 2) * side α (-k) i) :
+    fhat (hBump α L hL.ne' k c) ξ = 1 := by
+  rw [fhat_hBump]
+  refine phiHat_eq_one fun i => ?_
+  simp only [PiLp.smul_apply, dil_apply, PiLp.sub_apply, smul_eq_mul, abs_mul,
+    abs_of_pos (inv_pos.mpr hL), abs_of_pos (by positivity : (0 : ℝ) < ((2 : ℝ) ^ k) ^ α i)]
+  have hs := side_pos α (-k) i
+  have e := pow_mul_side_neg α k i
+  have hi := h i
+  rw [inv_mul_le_iff₀ hL]
+  calc ((2 : ℝ) ^ k) ^ α i * |ξ i - c i| ≤ ((2 : ℝ) ^ k) ^ α i * (L * (b1 / 2) * side α (-k) i)
+      := by
+        gcongr
+    _ = L * (b1 / 2) * (((2 : ℝ) ^ k) ^ α i * side α (-k) i) := by ring
+    _ = L * (b1 / 2) := by rw [e, mul_one]
+
+theorem fhat_hBump_eq_zero (α : Fin n → ℕ) {L : ℝ} (hL : 0 < L) (k : ℤ) (c ξ : Rn n)
+    (h : ∃ i, L * (b0 / 2) * side α (-k) i ≤ |ξ i - c i|) :
+    fhat (hBump α L hL.ne' k c) ξ = 0 := by
+  rw [fhat_hBump]
+  obtain ⟨i, hi⟩ := h
+  refine phiHat_eq_zero_of_lt (i := i) ?_
+  simp only [PiLp.smul_apply, dil_apply, PiLp.sub_apply, smul_eq_mul, abs_mul,
+    abs_of_pos (inv_pos.mpr hL), abs_of_pos (by positivity : (0 : ℝ) < ((2 : ℝ) ^ k) ^ α i)]
+  have e := pow_mul_side_neg α k i
+  rw [le_inv_mul_iff₀ hL]
+  calc L * (b0 / 2) = L * (b0 / 2) * (((2 : ℝ) ^ k) ^ α i * side α (-k) i) := by rw [e, mul_one]
+    _ = ((2 : ℝ) ^ k) ^ α i * (L * (b0 / 2) * side α (-k) i) := by ring
+    _ ≤ ((2 : ℝ) ^ k) ^ α i * |ξ i - c i| := by gcongr
+
+/-- The centre `δ_{2^{-k_P}}(u + r/2 + 1/4)` of the semi-tile `ω_{P(r)}`. -/
+def Tile.semiCenter (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) : Rn n :=
+  WithLp.toLp 2 (fun i => side α (-P.k) i * (P.u i + (r i : ℝ) / 2 + 1 / 4))
+
+theorem abs_sub_semiCenter_le (α : Fin n → ℕ) (P : Tile n) (r : Fin n → Fin 2) {ξ : Rn n}
+    (hξ : ξ ∈ P.semiHO α r) (i : Fin n) :
+    |ξ i - P.semiCenter α r i| ≤ side α (-P.k) i / 4 := by
+  have h := hξ i
+  have hs := side_pos α (-P.k) i
+  simp only [Tile.semiCenter, PiLp.toLp_apply]
+  rw [abs_le]; constructor <;> nlinarith [h.1, h.2]
+
+theorem suppBox_coord_lt (α : Fin n → ℕ) (P : Tile n) {ξ : Rn n} (hξ : ξ ∈ suppBox α P)
+    (i : Fin n) : ξ i < side α (-P.k) i * (P.u i + 3 / 10) := by
+  have h := hξ i
+  have hs := side_pos α (-P.k) i
+  rw [abs_lt] at h
+  simp only [Tile.cω0, PiLp.toLp_apply, b0] at h
+  nlinarith [h.2]
+
+theorem suppBox_subset_ω (α : Fin n → ℕ) (P : Tile n) : suppBox α P ⊆ P.ω.toSet α :=
+  (suppBox_subset_semiHO0 α P).trans (Tile.semiHO0_subset α P)
+
+theorem suppBox_eq_of_ω_eq {α : Fin n → ℕ} {P Q : Tile n} (h : P.ω = Q.ω) :
+    suppBox α P = suppBox α Q := by
+  have hk : P.k = Q.k := neg_inj.mp (congrArg DCube.k h)
+  have hu : P.u = Q.u := congrArg DCube.ℓ h
+  simp only [suppBox, Tile.cω0, hk, hu]
+
+/-- The frequency window of the `2`-tree case: `χ₊ − χ₋` equals `1` on the Fourier supports of the
+tiles with `k₊ ≤ k_P ≤ k₋` and `0` on those of the other tiles of the `2`-tree. -/
+theorem chi_on_suppBox (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} {i₀ : Fin n}
+    (hr : r i₀ = 1) {top : Tile n} {S : Finset (Tile n)} (hS : IsTree α top S)
+    (hS2 : ∀ P ∈ S, top.cω α ∈ P.semiHO α r) (kp : ℤ) {Pm : Tile n} (hPm : Pm ∈ S)
+    (hkp : kp ≤ Pm.k) {P : Tile n} (hP : P ∈ S) {ξ : Rn n} (hξ : ξ ∈ suppBox α P) :
+    fhat (hBump α 12 (by norm_num) kp ((DCube.ofPoint α (-kp) (top.cω α)).center α)) ξ -
+      fhat (hBump α 6 (by norm_num) Pm.k (Pm.semiCenter α r)) ξ =
+        if kp ≤ P.k ∧ P.k ≤ Pm.k then 1 else 0 := by
+  set ξ₀ := top.cω α
+  set Q := auxTile α top kp ξ₀
+  have hQω : Q.ω = DCube.ofPoint α (-kp) ξ₀ := auxTile_ω α top kp ξ₀
+  have hQk : Q.k = kp := rfl
+  have hξ₀Q : ξ₀ ∈ Q.ω.toSet α := mem_auxTile_ω α top kp ξ₀
+  set ωq := DCube.ofPoint α (-kp) ξ₀ with hωq
+  have hωqk : ωq.k = -kp := rfl
+  set cp := ωq.center α
+  have hcp : ∀ i, cp i = side α (-kp) i * (ωq.ℓ i + 1 / 2) := fun i => by
+    simp only [cp, DCube.center, PiLp.toLp_apply, hωqk]
+  set cm := Pm.semiCenter α r
+  have hb1 : b1 / 2 = 9 / 200 := by norm_num [b1]
+  have hb0 : b0 / 2 = 1 / 20 := by norm_num [b0]
+  -- the `+` cutoff
+  have hplus1 : kp ≤ P.k → fhat (hBump α 12 (by norm_num) kp cp) ξ = 1 := by
+    intro hk
+    refine fhat_hBump_eq_one α (by norm_num) kp cp ξ fun i => ?_
+    have hω : P.ω.toSet α ⊆ Q.ω.toSet α := ω_subset_of_mem_of_k_le α (hQk ▸ hk) (hS P hP).2 hξ₀Q
+    have hmem := hω (suppBox_subset_ω α P hξ) i
+    rw [hQω] at hmem
+    have hmi := hmem
+    rw [hωqk] at hmi
+    have hs := side_pos α (-kp) i
+    rw [hcp, abs_le, hb1]; constructor <;> nlinarith [hmi.1, hmi.2]
+  have hplus0 : P.k < kp → fhat (hBump α 12 (by norm_num) kp cp) ξ = 0 := by
+    intro hk
+    refine fhat_hBump_eq_zero α (by norm_num) kp cp ξ ⟨i₀, ?_⟩
+    have hsub : Q.ω.toSet α ⊆ P.semiHO α r := ω_subset_semiHO α hα (hQk ▸ hk) r hξ₀Q (hS2 P hP)
+    -- the lower corner of `ω_Q` lies in `ω_{P(r)}`
+    have hcorner : WithLp.toLp 2 (fun i => side α (-kp) i * ωq.ℓ i) ∈ Q.ω.toSet α := by
+      rw [hQω, DCube.mem_toSet_iff_floor]; intro i
+      simp only [hωqk]
+      rw [mul_div_cancel_left₀ _ (side_pos α _ i).ne', Int.floor_intCast]
+    have hlow := (hsub hcorner i₀).1
+    rw [hr] at hlow
+    simp only [Fin.isValue, Fin.val_one, Nat.cast_one] at hlow
+    have hξi := suppBox_coord_lt α P hξ i₀
+    have hsP := side_pos α (-P.k) i₀
+    have hsp := side_pos α (-kp) i₀
+    have hside : side α (-kp) i₀ ≤ side α (-P.k) i₀ := side_mono α (by omega) i₀
+    rw [hcp, hb0, abs_sub_comm, abs_of_pos (by nlinarith)]
+    nlinarith
+  -- the `−` cutoff
+  have hminus1 : Pm.k < P.k → fhat (hBump α 6 (by norm_num) Pm.k cm) ξ = 1 := by
+    intro hk
+    refine fhat_hBump_eq_one α (by norm_num) Pm.k cm ξ fun i => ?_
+    have hsub : P.ω.toSet α ⊆ Pm.semiHO α r :=
+      ω_subset_semiHO α hα hk r (hS P hP).2 (hS2 Pm hPm)
+    have h1 := abs_sub_semiCenter_le α Pm r (hsub (suppBox_subset_ω α P hξ)) i
+    have hs := side_pos α (-Pm.k) i
+    rw [hb1]; nlinarith
+  have hminus0 : P.k ≤ Pm.k → fhat (hBump α 6 (by norm_num) Pm.k cm) ξ = 0 := by
+    intro hk
+    refine fhat_hBump_eq_zero α (by norm_num) Pm.k cm ξ ⟨i₀, ?_⟩
+    have hsm := side_pos α (-Pm.k) i₀
+    rw [hb0]
+    rcases hk.lt_or_eq with hlt | heq
+    · have hsub : Pm.ω.toSet α ⊆ P.semiHO α r :=
+        ω_subset_semiHO α hα hlt r (hS Pm hPm).2 (hS2 P hP)
+      -- the lower corner of `ω_{Pm(r)}` lies in `ω_{P(r)}`
+      have hcorner : WithLp.toLp 2 (fun i => side α (-Pm.k) i * (Pm.u i + (r i : ℝ) / 2)) ∈
+          Pm.semiHO α r := by
+        intro i
+        have hs := side_pos α (-Pm.k) i
+        constructor <;> nlinarith
+      have hlow := (hsub (Pm.semiHO_subset_ω α r hcorner) i₀).1
+      simp only [hr, Fin.isValue, Fin.val_one, Nat.cast_one] at hlow
+      have hξi := suppBox_coord_lt α P hξ i₀
+      have hsP := side_pos α (-P.k) i₀
+      have hside : side α (-Pm.k) i₀ ≤ side α (-P.k) i₀ := side_mono α (by omega) i₀
+      simp only [cm, Tile.semiCenter, PiLp.toLp_apply, hr, Fin.isValue, Fin.val_one,
+        Nat.cast_one]
+      rw [abs_sub_comm, abs_of_pos (by nlinarith)]
+      nlinarith
+    · have hω : P.ω = Pm.ω := DCube.eq_of_mem_of_k_eq α (by simp [Tile.ω, heq]) (hS P hP).2
+        (hS Pm hPm).2
+      have hξm : ξ ∈ suppBox α Pm := suppBox_eq_of_ω_eq hω ▸ hξ
+      have hξi := suppBox_coord_lt α Pm hξm i₀
+      simp only [cm, Tile.semiCenter, PiLp.toLp_apply, hr, Fin.isValue, Fin.val_one,
+        Nat.cast_one]
+      rw [abs_sub_comm, abs_of_pos (by nlinarith)]
+      nlinarith
+  by_cases h1 : kp ≤ P.k
+  · by_cases h2 : P.k ≤ Pm.k
+    · rw [ite_eq_left ⟨h1, h2⟩, hplus1 h1, hminus0 h2, sub_zero]
+    · rw [ite_eq_right (fun h => h2 h.2), hplus1 h1, hminus1 (not_le.mp h2), sub_self]
+  · rw [ite_eq_right (fun h => h1 h.1), hplus0 (not_le.mp h1)]
+    by_cases h2 : P.k ≤ Pm.k
+    · rw [hminus0 h2, sub_zero]
+    · exfalso; push Not at h1 h2; omega
+
+/-- Fourier inversion, reverse direction, in the paper's normalization: if
+`ψ(x) = (2π)^{-n} ∫ g(ξ) e^{i x ξ} dξ` with `g` continuous and integrable and `ψ` integrable,
+then `ψ̂ = g`. -/
+theorem fhat_eq_of_inversion {g ψ : Rn n → ℂ} (hgc : Continuous g) (hgi : Integrable g)
+    (hψ : ∀ x, ψ x = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ξ, g ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)))
+    (hψi : Integrable ψ) (ξ : Rn n) : fhat ψ ξ = g ξ := by
+  set g' : Rn n → ℂ := fun v => g ((2 * π) • v)
+  have hinv : FourierTransformInv.fourierInv g' = ψ := by
+    ext x
+    rw [Real.fourierInv_eq, hψ x]
+    set G : Rn n → ℂ := fun ξ => g ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))
+    have hG : ∀ v : Rn n, Real.fourierChar ⟪v, x⟫_ℝ • g' v = G ((2 * π) • v) := by
+      intro v
+      rw [Circle.smul_def, Real.fourierChar_apply]
+      simp only [G, g', inner_smul_right, smul_eq_mul]
+      rw [mul_comm, real_inner_comm x v]
+      congr 1
+      push_cast
+      ring_nf
+    simp_rw [hG]
+    rw [Measure.integral_comp_smul, finrank_euclideanSpace_fin, abs_inv, abs_pow,
+      abs_of_pos (by positivity : (0 : ℝ) < 2 * π), Complex.real_smul]
+    push_cast
+    ring
+  have hg'c : Continuous g' := hgc.comp (continuous_const_smul _)
+  have hg'i : Integrable g' := hgi.comp_smul (by positivity)
+  have hFi : Integrable (FourierTransform.fourier g') := by
+    have : FourierTransform.fourier g' = fun w => ψ (-w) := by
+      ext w
+      rw [← hinv, Real.fourierInv_eq_fourier_neg, neg_neg]
+    rw [this]
+    exact hψi.comp_neg
+  have h := hg'c.fourier_fourierInv_eq hg'i hFi
+  rw [hinv] at h
+  rw [fhat_eq_fourier, h]
+  simp only [g', smul_smul, mul_inv_cancel₀ (by positivity : (2 * π) ≠ 0), one_smul]
+
+theorem continuous_fhat_wavePhi (α : Fin n → ℕ) (P : Tile n) :
+    Continuous (fhat (wavePhi α P)) := by
+  have h : fhat (wavePhi α P) = fun ξ => ((((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) : ℝ) : ℂ) *
+      Complex.exp (-(Complex.I * (⟪P.cI α, ξ - P.cω0 α⟫_ℝ : ℂ))) *
+        phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α)) := funext (fhat_wavePhi α P)
+  rw [h]
+  have hφ : Continuous (phiHat : Rn n → ℂ) := contDiff_phiHat.continuous
+  have hd : Continuous fun ξ : Rn n => dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α) := by fun_prop
+  exact (continuous_const.mul (by fun_prop)).mul (hφ.comp hd)
+
+/-- `φ̂_P` vanishes near any `N` separated from `c(ω_{P(0)})` by `2^{-k_P α_j}/4` in some
+coordinate. -/
+theorem fhat_wavePhi_eventually_zero (α : Fin n → ℕ) (P : Tile n) {N : Rn n} {j : Fin n}
+    (hN : side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) :
+    fhat (wavePhi α P) =ᶠ[nhds N] 0 := by
+  have hs := side_pos α (-P.k) j
+  have hopen : IsOpen {ξ : Rn n | side α (-P.k) j * (b0 / 2) < |ξ j - P.cω0 α j|} :=
+    isOpen_lt continuous_const (by fun_prop)
+  have hmem : N ∈ {ξ : Rn n | side α (-P.k) j * (b0 / 2) < |ξ j - P.cω0 α j|} := by
+    change side α (-P.k) j * (b0 / 2) < |N j - P.cω0 α j|
+    have : side α (-P.k) j * (b0 / 2) < side α (-P.k) j / 4 := by norm_num [b0]; linarith
+    linarith
+  filter_upwards [hopen.mem_nhds hmem] with ξ hξ
+  by_contra hne
+  exact absurd (abs_sub_cω0_lt_of_fhat_wavePhi_ne_zero α P hne j) (not_lt.mpr (le_of_lt hξ))
+
+theorem integrable_wavePsi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {m : Rn n → ℂ}
+    (hm : ClassM α (absA α + 1) m) (P : Tile n) {N : Rn n}
+    (hN : ∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) :
+    Integrable (wavePsi α m N P) := by
+  have hs : (absA α : ℝ) < ((absA α + 1 : ℕ) : ℝ) := by push_cast; linarith
+  have hcont : Continuous fun x => wavePsi α m N P x := by
+    have h1 := continuous_wavePsi_joint α hm P
+    have h2 : Continuous fun x : Rn n => ((N, x) : Rn n × Rn n) :=
+      continuous_const.prodMk continuous_id
+    simpa only [Function.comp_def] using h1.comp h2
+  set K : ℝ := (psiConst α (absA α + 1) : ℝ) * (normM α (absA α + 1) m).toReal *
+      ((2 : ℝ) ^ P.k) ^ (-(absA α : ℝ) / 2)
+  have hb : ∀ x, ‖wavePsi α m N P x‖ ≤ K *
+      (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-(((absA α + 1 : ℕ)) : ℝ)) := fun x =>
+    psi_estimate_real α hα (absA α + 1) hm P N hN x
+  exact ((integrable_wgt_scaled α hα hs (t := (2 : ℝ) ^ P.k) (by positivity) (P.cI α)).const_mul
+    K).mono' hcont.aestronglyMeasurable (Filter.Eventually.of_forall hb)
+
+/-- The Fourier transform of `ψ^N_P` (for `N` away from `ω_{P(0)}`): `ψ̂^N_P = m(· − N) φ̂_P`. -/
+theorem fhat_wavePsi (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {m : Rn n → ℂ}
+    (hm : ClassM α (absA α + 1) m) (P : Tile n) {N : Rn n}
+    (hN : ∃ j, side α (-P.k) j / 4 ≤ |N j - P.cω0 α j|) (ξ : Rn n) :
+    fhat (wavePsi α m N P) ξ = m (ξ - N) * fhat (wavePhi α P) ξ := by
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  obtain ⟨j, hj⟩ := hN
+  have hgi : Integrable fun ξ => m (ξ - N) * fhat (wavePhi α P) ξ :=
+    (integrable_fhat_wavePhi α P).bdd_mul (c := Cm)
+      (hm.measurable.comp (measurable_id.sub_const N)).aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => hmb _)
+  have hgc : Continuous fun ξ => m (ξ - N) * fhat (wavePhi α P) ξ := by
+    rw [continuous_iff_continuousAt]
+    intro ξ
+    by_cases hξ : ξ = N
+    · subst hξ
+      have hz := fhat_wavePhi_eventually_zero α P hj
+      refine (continuousAt_const (y := (0 : ℂ))).congr ?_
+      filter_upwards [hz] with η hη
+      simp [hη]
+    · have h1 : ContinuousAt m (ξ - N) :=
+        (hm.contDiffOn.continuousOn.continuousAt (isOpen_compl_singleton.mem_nhds
+          (sub_ne_zero.mpr hξ)))
+      have h2 : ContinuousAt (fun η : Rn n => η - N) ξ := continuousAt_id.sub continuousAt_const
+      exact (h1.comp (f := fun η : Rn n => η - N) h2).mul
+        (continuous_fhat_wavePhi α P).continuousAt
+  exact fhat_eq_of_inversion hgc hgi (fun x => rfl) (integrable_wavePsi α hα hm P ⟨j, hj⟩) ξ
+
+/-! ### Term 1 of the `2`-tree case as a convolution -/
+
+theorem continuous_fhat {h : Rn n → ℂ} (hh : Integrable h) : Continuous (fhat h) := by
+  refine continuous_of_dominated (bound := fun x => ‖h x‖) (fun ξ => ?_) (fun ξ => ?_) hh.norm ?_
+  · exact ((by fun_prop : Continuous fun x : Rn n => Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ)))
+      ).aestronglyMeasurable.mul hh.aestronglyMeasurable)
+  · exact Filter.Eventually.of_forall fun x => by rw [norm_mul, norm_cexp_neg_I_mul, one_mul]
+  · exact Filter.Eventually.of_forall fun x => by fun_prop
+
+theorem norm_wavePsi_le (α : Fin n → ℕ) {m : Rn n → ℂ} {Cm : ℝ}
+    (hmb : ∀ ξ, ‖m ξ‖ ≤ Cm) (N : Rn n) (P : Tile n) (y : Rn n) :
+    ‖wavePsi α m N P y‖ ≤ ((2 * π) ^ n)⁻¹ * (Cm * ∫ ξ, ‖fhat (wavePhi α P) ξ‖) := by
+  simp only [wavePsi, norm_mul]
+  have h1 : ‖(((2 * π) ^ n)⁻¹ : ℂ)‖ = ((2 * π) ^ n)⁻¹ := by
+    rw [norm_inv, norm_pow, Complex.norm_mul, Complex.norm_ofNat, Complex.norm_real,
+      Real.norm_eq_abs, abs_of_pos Real.pi_pos]
+  rw [h1]
+  gcongr
+  refine (norm_integral_le_integral_norm _).trans ?_
+  rw [← integral_const_mul]
+  refine integral_mono_of_nonneg (Filter.Eventually.of_forall fun ξ => norm_nonneg _)
+    ((integrable_fhat_wavePhi α P).norm.const_mul Cm) (Filter.Eventually.of_forall fun ξ => ?_)
+  change ‖m (ξ - N) * fhat (wavePhi α P) ξ * Complex.exp (Complex.I * (⟪y, ξ⟫_ℝ : ℂ))‖ ≤
+    Cm * ‖fhat (wavePhi α P) ξ‖
+  rw [norm_mul, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I, mul_one]
+  gcongr
+  exact hmb _
+
+/-- Convolution of a `ψ` wave packet with an integrable function (Fubini):
+`∫ ψ^N_P(x − z) h(z) dz = (2π)^{-n} ∫ m(ξ − N) φ̂_P(ξ) hhat(ξ) e^{i x ξ} dξ`. -/
+theorem integral_wavePsi_sub_mul (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (P : Tile n) (N : Rn n) {h : Rn n → ℂ} (hh : Integrable h) (x : Rn n) :
+    ∫ z, wavePsi α m N P (x - z) * h z = (((2 * π) ^ n)⁻¹ : ℂ) *
+      ∫ ξ, m (ξ - N) * fhat (wavePhi α P) ξ * fhat h ξ *
+        Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  set g : Rn n → ℂ := fun ξ => m (ξ - N) * fhat (wavePhi α P) ξ
+  have hgm : AEStronglyMeasurable g volume :=
+    (hm.measurable.comp (measurable_id.sub_const N)).aestronglyMeasurable.mul
+      (continuous_fhat_wavePhi α P).aestronglyMeasurable
+  have hgi : Integrable g := (integrable_fhat_wavePhi α P).bdd_mul (c := Cm)
+    (hm.measurable.comp (measurable_id.sub_const N)).aestronglyMeasurable
+    (Filter.Eventually.of_forall fun ξ => hmb _)
+  set F : Rn n → Rn n → ℂ := fun z ξ =>
+    g ξ * Complex.exp (Complex.I * (⟪x - z, ξ⟫_ℝ : ℂ)) * h z
+  have hF : Integrable (Function.uncurry F) (volume.prod volume) := by
+    have hprod : Integrable (fun p : Rn n × Rn n => h p.1 * g p.2) (volume.prod volume) :=
+      hh.mul_prod hgi
+    refine hprod.mono ?_ (Filter.Eventually.of_forall fun p => ?_)
+    · have hexp : Continuous fun p : Rn n × Rn n =>
+          Complex.exp (Complex.I * (⟪x - p.1, p.2⟫_ℝ : ℂ)) := by fun_prop
+      exact ((hgm.comp_snd.mul hexp.aestronglyMeasurable).mul hh.aestronglyMeasurable.comp_fst)
+    · simp only [Function.uncurry, F, norm_mul, mul_comm Complex.I, Complex.norm_exp_ofReal_mul_I,
+        mul_one]
+      rw [mul_comm]
+  have hL : ∀ z, wavePsi α m N P (x - z) * h z =
+      (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, F z ξ := by
+    intro z
+    simp only [wavePsi, F, g]
+    rw [mul_assoc, ← integral_mul_const]
+  simp_rw [hL]
+  rw [integral_const_mul, integral_integral_swap hF]
+  congr 1
+  refine integral_congr_ae (Filter.Eventually.of_forall fun ξ => ?_)
+  simp only [F, g]
+  rw [show fhat h ξ = ∫ z, Complex.exp (-(Complex.I * (⟪z, ξ⟫_ℝ : ℂ))) * h z from rfl]
+  rw [show m (ξ - N) * fhat (wavePhi α P) ξ *
+      (∫ z, Complex.exp (-(Complex.I * (⟪z, ξ⟫_ℝ : ℂ))) * h z) *
+      Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) =
+      (m (ξ - N) * fhat (wavePhi α P) ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) *
+      ∫ z, Complex.exp (-(Complex.I * (⟪z, ξ⟫_ℝ : ℂ))) * h z by ring, ← integral_const_mul]
+  refine integral_congr_ae (Filter.Eventually.of_forall fun z => ?_)
+  simp only
+  rw [inner_sub_left, Complex.ofReal_sub, mul_sub, Complex.exp_sub, div_eq_mul_inv,
+    ← Complex.exp_neg]
+  ring
+
+/-- **Term 1 as a convolution** (paper, (7.12)): if `hhat` cuts out the tiles `A ⊆ S` on the
+Fourier side, then `∑_{P ∈ A} c_P ψ^N_P(x) = ∫ (∑_{P ∈ S} c_P ψ^N_P(x − z)) h(z) dz`. -/
+theorem sum_wavePsi_eq_conv (α : Fin n → ℕ) {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    (N : Rn n) (S A : Finset (Tile n)) (c : Tile n → ℂ) {h : Rn n → ℂ} (hh : Integrable h)
+    (hwin : ∀ ξ, ∑ P ∈ A, c P * fhat (wavePhi α P) ξ =
+      fhat h ξ * ∑ P ∈ S, c P * fhat (wavePhi α P) ξ) (x : Rn n) :
+    ∑ P ∈ A, c P * wavePsi α m N P x =
+      ∫ z, (∑ P ∈ S, c P * wavePsi α m N P (x - z)) * h z := by
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  have hmeasm : Measurable fun ξ => m (ξ - N) := hm.measurable.comp (measurable_id.sub_const N)
+  have hexpc : Continuous fun ξ : Rn n => Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by fun_prop
+  -- integrability of the Fourier-side integrands
+  have hint1 : ∀ P, Integrable fun ξ => m (ξ - N) * fhat (wavePhi α P) ξ *
+      Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by
+    intro P
+    refine ((integrable_fhat_wavePhi α P).bdd_mul (c := Cm) hmeasm.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => hmb _)).mul_bdd (c := 1) hexpc.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => by rw [mul_comm Complex.I,
+        Complex.norm_exp_ofReal_mul_I]) |>.congr (Filter.Eventually.of_forall fun ξ => rfl)
+  have hfh : ∀ ξ, ‖fhat h ξ‖ ≤ ∫ z, ‖h z‖ := fun ξ => by
+    refine (norm_integral_le_integral_norm _).trans (le_of_eq ?_)
+    congr 1; ext z; rw [norm_mul, norm_cexp_neg_I_mul, one_mul]
+  have hfhm : AEStronglyMeasurable (fhat h) volume := (continuous_fhat hh).aestronglyMeasurable
+  have hint2 : ∀ P, Integrable fun ξ => m (ξ - N) * fhat (wavePhi α P) ξ * fhat h ξ *
+      Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by
+    intro P
+    have := ((integrable_fhat_wavePhi α P).bdd_mul (c := Cm) hmeasm.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => hmb _)).mul_bdd (c := ∫ z, ‖h z‖) hfhm
+      (Filter.Eventually.of_forall hfh)
+    refine this.mul_bdd (c := 1) hexpc.aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => by rw [mul_comm Complex.I,
+        Complex.norm_exp_ofReal_mul_I])
+  -- integrability of the convolution integrands
+  have hint3 : ∀ P, Integrable fun z => c P * wavePsi α m N P (x - z) * h z := by
+    intro P
+    have hc : Continuous fun z => wavePsi α m N P (x - z) := by
+      have h1 := continuous_wavePsi_joint α hm P
+      have h2 : Continuous fun z : Rn n => ((N, x - z) : Rn n × Rn n) := by fun_prop
+      simpa only [Function.comp_def] using h1.comp h2
+    have := hh.bdd_mul (c := ((2 * π) ^ n)⁻¹ * (Cm * ∫ ξ, ‖fhat (wavePhi α P) ξ‖))
+      hc.aestronglyMeasurable (Filter.Eventually.of_forall fun z => norm_wavePsi_le α hmb N P _)
+    refine (this.const_mul (c P)).congr (Filter.Eventually.of_forall fun z => by ring)
+  calc ∑ P ∈ A, c P * wavePsi α m N P x
+      = (((2 * π) ^ n)⁻¹ : ℂ) * ∑ P ∈ A, ∫ ξ, c P * (m (ξ - N) * fhat (wavePhi α P) ξ *
+          Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+        rw [Finset.mul_sum]
+        refine Finset.sum_congr rfl fun P _ => ?_
+        simp only [wavePsi]
+        rw [integral_const_mul]; ring
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, ∑ P ∈ A, c P * (m (ξ - N) * fhat (wavePhi α P) ξ *
+          Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+        rw [integral_finsetSum _ fun P _ => (hint1 P).const_mul (c P)]
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, m (ξ - N) * (∑ P ∈ A, c P * fhat (wavePhi α P) ξ) *
+          Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by
+        congr 1
+        refine integral_congr_ae (Filter.Eventually.of_forall fun ξ => ?_)
+        simp only [Finset.mul_sum, Finset.sum_mul]
+        refine Finset.sum_congr rfl fun P _ => ?_
+        ring
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, m (ξ - N) * (fhat h ξ * ∑ P ∈ S, c P * fhat (wavePhi α P) ξ) *
+          Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ)) := by simp_rw [hwin]
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, ∑ P ∈ S, c P * (m (ξ - N) * fhat (wavePhi α P) ξ *
+          fhat h ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+        congr 1
+        refine integral_congr_ae (Filter.Eventually.of_forall fun ξ => ?_)
+        simp only [Finset.mul_sum, Finset.sum_mul]
+        refine Finset.sum_congr rfl fun P _ => ?_
+        ring
+    _ = (((2 * π) ^ n)⁻¹ : ℂ) * ∑ P ∈ S, ∫ ξ, c P * (m (ξ - N) * fhat (wavePhi α P) ξ *
+          fhat h ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+        rw [integral_finsetSum _ fun P _ => (hint2 P).const_mul (c P)]
+    _ = ∑ P ∈ S, c P * ((((2 * π) ^ n)⁻¹ : ℂ) * ∫ ξ, m (ξ - N) * fhat (wavePhi α P) ξ *
+          fhat h ξ * Complex.exp (Complex.I * (⟪x, ξ⟫_ℝ : ℂ))) := by
+        rw [Finset.mul_sum]
+        refine Finset.sum_congr rfl fun P _ => ?_
+        rw [integral_const_mul]; ring
+    _ = ∑ P ∈ S, ∫ z, c P * wavePsi α m N P (x - z) * h z := by
+        refine Finset.sum_congr rfl fun P _ => ?_
+        rw [← integral_wavePsi_sub_mul α hm P N hh x, ← integral_const_mul]
+        congr 1; ext z; ring
+    _ = ∫ z, (∑ P ∈ S, c P * wavePsi α m N P (x - z)) * h z := by
+        rw [← integral_finsetSum _ fun P _ => hint3 P]
+        congr 1; ext z; rw [Finset.sum_mul]
+
+/-- A multiplier in `𝓜^ν` is bounded by its norm away from the origin. -/
+theorem norm_le_normM (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) {ξ : Rn n} (hξ : ξ ≠ 0) : ‖m ξ‖ ≤ (normM α ν m).toReal := by
+  have h := symbol_estimate α hα hm (Nat.zero_le ν) (Fin.elim0) hξ
+  simp only [Finset.univ_eq_empty, Finset.prod_empty, ENNReal.ofReal_one, mul_one] at h
+  have hmi : iterPartial 0 m Fin.elim0 ξ = m ξ := by
+    simp [iterPartial]
+  rw [hmi, ← ofReal_norm] at h
+  rw [← ENNReal.ofReal_le_iff_le_toReal (normM_lt_top α hα hm).ne]
+  exact h
+
+/-- In a `2`-tree (half-open sense), wave packets of different tiles with different frequency
+cubes are orthogonal. -/
+theorem twoTree_pairing_eq_zero (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2}
+    {i₀ : Fin n} (hr : r i₀ = 1) {top : Tile n} {S : Finset (Tile n)} (hS : IsTree α top S)
+    (hS2 : ∀ P ∈ S, top.cω α ∈ P.semiHO α r) {P P' : Tile n} (hP : P ∈ S) (hP' : P' ∈ S)
+    (hne : P.ω ≠ P'.ω) : pairing (wavePhi α P) (wavePhi α P') = 0 := by
+  by_contra h
+  rcases pairing_wavePhi_eq_zero_or α hα P P' h with h1 | ⟨-, h1⟩ | ⟨-, h1⟩
+  · exact hne h1
+  · have hc := h1 (hS P hP).2
+    exact lt_irrefl _ (lt_of_mem_semiHO0_of_mem_semi α P' hr hc
+      (P'.semiHO_subset_semi α r (hS2 P' hP')))
+  · have hc := h1 (hS P' hP').2
+    exact lt_irrefl _ (lt_of_mem_semiHO0_of_mem_semi α P hr hc
+      (P.semiHO_subset_semi α r (hS2 P hP)))
+
+/-- Plancherel in the paper's normalization: `∫ |F|² = (2π)^{-n} ∫ |F̂|²`. -/
+theorem integral_norm_sq_eq_fhat {F : Rn n → ℂ} (hF : Integrable F) (hc : Continuous F)
+    (hFi : Integrable (fhat F)) :
+    ∫ x, ‖F x‖ ^ 2 = ((2 * π) ^ n)⁻¹ * ∫ ξ, ‖fhat F ξ‖ ^ 2 := by
+  have hP := pairing_eq_fhat hF hc hF hFi
+  have h1 : pairing F F = ((∫ x, ‖F x‖ ^ 2 : ℝ) : ℂ) := by
+    unfold pairing
+    rw [← integral_complex_ofReal]
+    congr 1; ext x
+    rw [Complex.mul_conj, Complex.normSq_eq_norm_sq]
+  have h2 : ∫ ξ, fhat F ξ * (starRingEnd ℂ) (fhat F ξ) = ((∫ ξ, ‖fhat F ξ‖ ^ 2 : ℝ) : ℂ) := by
+    rw [← integral_complex_ofReal]
+    congr 1; ext ξ
+    rw [Complex.mul_conj, Complex.normSq_eq_norm_sq]
+  rw [h1, h2] at hP
+  have h3 : ((((2 * π) ^ n)⁻¹ : ℂ)) = ((((2 * π) ^ n)⁻¹ : ℝ) : ℂ) := by push_cast; ring
+  rw [h3, ← Complex.ofReal_mul] at hP
+  exact_mod_cast hP
+
+theorem fhat_finset_sum {ι : Type*} (s : Finset ι) (c : ι → ℂ) (f : ι → Rn n → ℂ)
+    (hf : ∀ i ∈ s, Integrable (f i)) (ξ : Rn n) :
+    fhat (fun x => ∑ i ∈ s, c i * f i x) ξ = ∑ i ∈ s, c i * fhat (f i) ξ := by
+  simp only [fhat, Finset.mul_sum]
+  rw [integral_finsetSum]
+  · refine Finset.sum_congr rfl fun i _ => ?_
+    rw [← integral_const_mul]; congr 1; ext x; ring
+  · intro i hi
+    exact (((hf i hi).const_mul (c i)).bdd_mul (c := 1)
+      ((by fun_prop : Continuous fun x : Rn n => Complex.exp (-(Complex.I * (⟪x, ξ⟫_ℝ : ℂ)))
+        ).aestronglyMeasurable) (Filter.Eventually.of_forall fun x => by
+          rw [norm_cexp_neg_I_mul])).congr (Filter.Eventually.of_forall fun x => by ring)
+
+theorem norm_fhat_wavePhi_le' (α : Fin n → ℕ) (P : Tile n) (ξ : Rn n) :
+    ‖fhat (wavePhi α P) ξ‖ ≤ ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := by
+  rw [fhat_wavePhi, norm_mul, norm_mul, norm_cexp_neg_I_mul, mul_one, Complex.norm_real,
+    Real.norm_eq_abs, abs_of_pos (by positivity)]
+  have h := (phiHat_re_mem (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α)))
+  have : ‖phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α))‖ ≤ 1 := by
+    rw [h.1, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg h.2.1]; exact h.2.2
+  calc ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ‖phiHat (dil α ((2 : ℝ) ^ P.k) (ξ - P.cω0 α))‖
+      ≤ ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * 1 := by gcongr
+    _ = _ := mul_one _
+
+/-- **`L²` bound for `H`** (paper, texline~760): for a `2`-tree (half-open sense) and
+`ξ₀ = c(ω_T)`, `‖∑_{P ∈ S} c_P ψ^{ξ₀}_P‖₂² ≤ C ‖m‖² ∑_P |c_P|²`. -/
+theorem twoTree_H_L2 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {r : Fin n → Fin 2} {i₀ : Fin n}
+    (hr : r i₀ = 1) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (absA α + 1) m → ∀ (top : Tile n)
+      (S : Finset (Tile n)), IsTree α top S → (∀ P ∈ S, top.cω α ∈ P.semiHO α r) →
+      ∀ (c : Tile n → ℂ), ∫ x, ‖∑ P ∈ S, c P * wavePsi α m (top.cω α) P x‖ ^ 2 ≤
+        C * (normM α (absA α + 1) m).toReal ^ 2 * ∑ P ∈ S, ‖c P‖ ^ 2 := by
+  obtain ⟨Cd, hCd, hdiag⟩ := diag_sum_le α hα
+  refine ⟨Cd, hCd, fun m hm top S hS hS2 c => ?_⟩
+  set ξ₀ := top.cω α
+  set Mn := (normM α (absA α + 1) m).toReal
+  have hMn : 0 ≤ Mn := ENNReal.toReal_nonneg
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  have hfar : ∀ P ∈ S, ∃ j, side α (-P.k) j / 4 ≤ |ξ₀ j - P.cω0 α j| := fun P hP =>
+    ⟨i₀, (far_of_mem_semiHO α hr P (hS2 P hP)).trans (le_abs_self _)⟩
+  set H : Rn n → ℂ := fun x => ∑ P ∈ S, c P * wavePsi α m ξ₀ P x
+  set G : Rn n → ℂ := fun x => ∑ P ∈ S, c P * wavePhi α P x
+  set Ghat : Rn n → ℂ := fun ξ => ∑ P ∈ S, c P * fhat (wavePhi α P) ξ
+  -- the transforms
+  have hHi : Integrable H := integrable_finsetSum _ fun P hP =>
+    (integrable_wavePsi α hα hm P (hfar P hP)).const_mul (c P)
+  have hHc : Continuous H := continuous_finsetSum _ fun P _ => continuous_const.mul (by
+    have h1 := continuous_wavePsi_joint α hm P
+    have h2 : Continuous fun x : Rn n => ((ξ₀, x) : Rn n × Rn n) :=
+      continuous_const.prodMk continuous_id
+    simpa only [Function.comp_def] using h1.comp h2)
+  have hfH : ∀ ξ, fhat H ξ = m (ξ - ξ₀) * Ghat ξ := by
+    intro ξ
+    rw [fhat_finset_sum S c _ fun P hP => integrable_wavePsi α hα hm P (hfar P hP)]
+    simp only [Ghat, Finset.mul_sum]
+    refine Finset.sum_congr rfl fun P hP => ?_
+    rw [fhat_wavePsi α hα hm P (hfar P hP)]; ring
+  have hGhati : Integrable Ghat := integrable_finsetSum _ fun P _ =>
+    (integrable_fhat_wavePhi α P).const_mul (c P)
+  have hfHi : Integrable (fhat H) := by
+    have : fhat H = fun ξ => m (ξ - ξ₀) * Ghat ξ := funext hfH
+    rw [this]
+    exact hGhati.bdd_mul (c := Cm) (hm.measurable.comp (measurable_id.sub_const
+        ξ₀)).aestronglyMeasurable
+      (Filter.Eventually.of_forall fun ξ => hmb _)
+  have hGi : Integrable G := integrable_finsetSum _ fun P _ =>
+    (integrable_wavePhi α hα P).const_mul (c P)
+  have hGc : Continuous G := continuous_finsetSum _ fun P _ =>
+    continuous_const.mul (continuous_wavePhi α P)
+  have hfG : fhat G = Ghat := funext fun ξ =>
+    fhat_finset_sum S c _ (fun P _ => integrable_wavePhi α hα P) ξ
+  -- `Ghat` vanishes at `ξ₀`
+  have hG0 : Ghat ξ₀ = 0 := Finset.sum_eq_zero fun P hP => by
+    obtain ⟨j, hj⟩ := hfar P hP
+    rw [(fhat_wavePhi_eventually_zero α P hj).eq_of_nhds]; simp
+  -- the pointwise comparison
+  have hpt : ∀ ξ, ‖fhat H ξ‖ ^ 2 ≤ Mn ^ 2 * ‖Ghat ξ‖ ^ 2 := by
+    intro ξ
+    rw [hfH, norm_mul, mul_pow]
+    by_cases hξ : ξ = ξ₀
+    · rw [hξ, hG0, norm_zero]; simp
+    · gcongr
+      exact norm_le_normM α hα hm (sub_ne_zero.mpr hξ)
+  -- `Ghat` is bounded
+  set B : ℝ := ∑ P ∈ S, ‖c P‖ * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)
+  have hGb : ∀ ξ, ‖Ghat ξ‖ ≤ B := fun ξ =>
+    (norm_sum_le _ _).trans (Finset.sum_le_sum fun P _ => by
+      rw [norm_mul]; exact mul_le_mul_of_nonneg_left (norm_fhat_wavePhi_le' α P ξ) (norm_nonneg _))
+  have hGsq : Integrable fun ξ => ‖Ghat ξ‖ ^ 2 := by
+    refine (hGhati.norm.const_mul B).mono' (hGhati.norm.aestronglyMeasurable.pow 2)
+      (Filter.Eventually.of_forall fun ξ => ?_)
+    rw [Real.norm_eq_abs, abs_of_nonneg (by positivity), sq]
+    exact mul_le_mul_of_nonneg_right (hGb ξ) (norm_nonneg _)
+  have hGsq' : Integrable fun ξ => ‖fhat G ξ‖ ^ 2 := by rw [hfG]; exact hGsq
+  have hfGi : Integrable (fhat G) := by rw [hfG]; exact hGhati
+  calc ∫ x, ‖H x‖ ^ 2 = ((2 * π) ^ n)⁻¹ * ∫ ξ, ‖fhat H ξ‖ ^ 2 :=
+        integral_norm_sq_eq_fhat hHi hHc hfHi
+    _ ≤ ((2 * π) ^ n)⁻¹ * ∫ ξ, Mn ^ 2 * ‖Ghat ξ‖ ^ 2 :=
+        mul_le_mul_of_nonneg_left (integral_mono_of_nonneg (Filter.Eventually.of_forall fun ξ =>
+          by positivity) (hGsq.const_mul _) (Filter.Eventually.of_forall hpt)) (by positivity)
+    _ = Mn ^ 2 * (((2 * π) ^ n)⁻¹ * ∫ ξ, ‖fhat G ξ‖ ^ 2) := by
+        rw [integral_const_mul, hfG]; ring
+    _ = Mn ^ 2 * ∫ x, ‖G x‖ ^ 2 := by rw [integral_norm_sq_eq_fhat hGi hGc hfGi]
+    _ ≤ Mn ^ 2 * ∑ P ∈ S, ∑ P' ∈ S, ‖c P‖ * ‖c P'‖ * ‖pairing (wavePhi α P) (wavePhi α P')‖ := by
+        gcongr
+        exact integral_norm_sq_sum_wavePhi_le α hα S c
+    _ = Mn ^ 2 * ∑ P ∈ S, ∑ P' ∈ S, (if P.ω = P'.ω then ‖c P‖ * ‖c P'‖ *
+          ‖pairing (wavePhi α P) (wavePhi α P')‖ else 0) := by
+        congr 1
+        refine Finset.sum_congr rfl fun P hP => Finset.sum_congr rfl fun P' hP' => ?_
+        split_ifs with h
+        · rfl
+        · rw [twoTree_pairing_eq_zero α hα hr hS hS2 hP hP' h, norm_zero, mul_zero]
+    _ ≤ Mn ^ 2 * (Cd * ∑ P ∈ S, ‖c P‖ ^ 2) := by
+        gcongr
+        exact hdiag S (fun P => ‖c P‖) (fun P => norm_nonneg _)
+    _ = Cd * Mn ^ 2 * ∑ P ∈ S, ‖c P‖ ^ 2 := by ring
+
+/-! ### Maximal function control of Term 1 -/
+
+/-- The radial majorant of `hBump` at scale `k`, constant on `[0, λ]`. -/
+def hMaj (α : Fin n → ℕ) (C : ℝ) (M : ℕ) (k : ℤ) (lam : ℝ) (s : ℝ) : ℝ≥0∞ :=
+  ENNReal.ofReal (2 ^ M * C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+    (1 + ((2 : ℝ) ^ k)⁻¹ * max s lam) ^ (-(M : ℝ)))
+
+theorem hMaj_antitone (α : Fin n → ℕ) {C : ℝ} (hC : 0 ≤ C) (M : ℕ) (k : ℤ) {lam : ℝ}
+    (hlam : 0 ≤ lam) : Antitone (hMaj α C M k lam) := by
+  intro s s' hss'
+  refine ENNReal.ofReal_le_ofReal (mul_le_mul_of_nonneg_left ?_ (by positivity))
+  have h1 : 0 < 1 + ((2 : ℝ) ^ k)⁻¹ * max s lam := by
+    have : 0 ≤ max s lam := le_max_of_le_right hlam
+    positivity
+  exact Real.rpow_le_rpow_of_nonpos h1 (by gcongr) (by simp)
+
+theorem hMaj_const (α : Fin n → ℕ) (C : ℝ) (M : ℕ) (k : ℤ) {lam : ℝ} (hlam : 0 ≤ lam) :
+    ∀ t ∈ Set.Icc 0 lam, hMaj α C M k lam t = hMaj α C M k lam 0 := by
+  intro t ht
+  simp only [hMaj, max_eq_right ht.2, max_eq_right hlam]
+
+theorem enorm_hBump_le_hMaj (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (L : ℝ) (hL : L ≠ 0) (M : ℕ) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (k : ℤ) (c : Rn n) (lam : ℝ), 0 ≤ lam → lam ≤ (2 : ℝ) ^ k → ∀ z : Rn n,
+      ‖hBump α L hL k c z‖ₑ ≤ hMaj α C M k lam (rho α z) := by
+  obtain ⟨C, hC, hdec⟩ := hBump_decay α hα L hL M
+  refine ⟨C, hC, fun k c lam hlam hlamk z => ?_⟩
+  rw [← ofReal_norm]
+  refine ENNReal.ofReal_le_ofReal ((hdec k c z).trans ?_)
+  have ht : (0 : ℝ) < (2 : ℝ) ^ k := by positivity
+  have hρ := rho_nonneg α z
+  have h1 : 0 < 1 + ((2 : ℝ) ^ k)⁻¹ * rho α z := by positivity
+  -- `1 + t⁻¹ max(ρ, λ) ≤ 2 (1 + t⁻¹ ρ)`
+  have h2 : 1 + ((2 : ℝ) ^ k)⁻¹ * max (rho α z) lam ≤ 2 * (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) := by
+    have : ((2 : ℝ) ^ k)⁻¹ * lam ≤ 1 := by rw [inv_mul_le_iff₀ ht]; linarith
+    rcases le_total (rho α z) lam with h | h
+    · rw [max_eq_right h]
+      have : 0 ≤ ((2 : ℝ) ^ k)⁻¹ * rho α z := by positivity
+      linarith
+    · rw [max_eq_left h]
+      have : 0 ≤ ((2 : ℝ) ^ k)⁻¹ * rho α z := by positivity
+      linarith
+  have h3 : (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) ^ (-(M : ℝ)) ≤
+      2 ^ M * (1 + ((2 : ℝ) ^ k)⁻¹ * max (rho α z) lam) ^ (-(M : ℝ)) := by
+    have hp : 0 < 1 + ((2 : ℝ) ^ k)⁻¹ * max (rho α z) lam := by
+      have : 0 ≤ max (rho α z) lam := le_max_of_le_right hlam
+      positivity
+    rw [Real.rpow_neg h1.le, Real.rpow_neg hp.le, Real.rpow_natCast, Real.rpow_natCast]
+    have hp1 := pow_pos h1 M
+    have hp2 := pow_pos hp M
+    rw [← div_eq_mul_inv, le_div_iff₀ hp2, inv_mul_eq_div, div_le_iff₀ hp1]
+    calc (1 + ((2 : ℝ) ^ k)⁻¹ * max (rho α z) lam) ^ M ≤
+        (2 * (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z)) ^ M := by gcongr
+      _ = 2 ^ M * (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) ^ M := mul_pow _ _ _
+  calc C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) * (1 + ((2 : ℝ) ^ k)⁻¹ * rho α z) ^ (-(M : ℝ))
+      ≤ C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+          (2 ^ M * (1 + ((2 : ℝ) ^ k)⁻¹ * max (rho α z) lam) ^ (-(M : ℝ))) := by gcongr
+    _ = _ := by ring
+
+theorem lintegral_hMaj_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {C : ℝ} (hC : 0 ≤ C) {M : ℕ}
+    (hM : absA α < M) (k : ℤ) (lam : ℝ) :
+    ∫⁻ y : Rn n, hMaj α C M k lam (rho α y) ≤
+      ENNReal.ofReal (2 ^ M * C * ∫ w : Rn n, (1 + rho α w) ^ (-(M : ℝ))) := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ k := by positivity
+  have hs : (absA α : ℝ) < (M : ℝ) := by exact_mod_cast hM
+  have hint := (integrable_wgt_scaled α hα hs (t := (2 : ℝ) ^ k) ht 0).const_mul
+    (2 ^ M * C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)))
+  calc ∫⁻ y : Rn n, hMaj α C M k lam (rho α y)
+      ≤ ∫⁻ y : Rn n, ENNReal.ofReal (2 ^ M * C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+          (1 + ((2 : ℝ) ^ k)⁻¹ * rho α (y - 0)) ^ (-(M : ℝ))) := by
+        refine lintegral_mono fun y => ENNReal.ofReal_le_ofReal ?_
+        refine mul_le_mul_of_nonneg_left ?_ (by positivity)
+        have hρ := rho_nonneg α y
+        have h1 : 0 < 1 + ((2 : ℝ) ^ k)⁻¹ * rho α y := by positivity
+        rw [sub_zero]
+        exact Real.rpow_le_rpow_of_nonpos h1 (by gcongr; exact le_max_left _ _) (by simp)
+    _ = ENNReal.ofReal (∫ y : Rn n, 2 ^ M * C * ((2 : ℝ) ^ k) ^ (-(absA α : ℝ)) *
+          (1 + ((2 : ℝ) ^ k)⁻¹ * rho α (y - 0)) ^ (-(M : ℝ))) :=
+        (ofReal_integral_eq_lintegral_ofReal hint (Filter.Eventually.of_forall fun y => by
+          have := rho_nonneg α (y - 0); positivity)).symm
+    _ = _ := by
+        congr 1
+        rw [integral_const_mul, integral_wgt_scaled α hα _ ht, ← Real.rpow_natCast ((2 : ℝ) ^ k),
+          mul_assoc (2 ^ M * C), ← mul_assoc (((2 : ℝ) ^ k) ^ (-(absA α : ℝ))),
+          ← Real.rpow_add ht, neg_add_cancel, Real.rpow_zero, one_mul]
+
+theorem ClassM.mono {α : Fin n → ℕ} {ν ν' : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m) (h : ν' ≤ ν) :
+    ClassM α ν' m :=
+  ⟨hm.bounded, hm.contDiffOn.of_le (by exact_mod_cast h), hm.homogeneous⟩
+
+theorem normM_mono (α : Fin n → ℕ) {ν ν' : ℕ} (m : Rn n → ℂ) (h : ν' ≤ ν) :
+    normM α ν' m ≤ normM α ν m :=
+  iSup₂_le fun k hk => le_iSup₂_of_le k (hk.trans h) le_rfl
+
+theorem normM_toReal_mono (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν ν' : ℕ} {m : Rn n → ℂ}
+    (hm : ClassM α ν m) (h : ν' ≤ ν) :
+    (normM α ν' m).toReal ≤ (normM α ν m).toReal :=
+  ENNReal.toReal_mono (normM_lt_top α hα hm).ne (normM_mono α m h)
+
+/-- **Term 1 is controlled by the maximal function** (paper, (7.15)–(7.16), via Lemma 7.2):
+`|∫ H(x − z) (h₊ − h₋)(z) dz| ≤ K M_λ|H|(x)`, `λ = 2^{k₊}`. -/
+theorem term1_le_maximal (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) :
+    ∃ K : ℝ, 0 ≤ K ∧ ∀ (H : Rn n → ℂ), Measurable H → ∀ (kp km : ℤ), kp ≤ km →
+      ∀ (cp cm x : Rn n),
+      ‖∫ z, H (x - z) * (hBump α 12 (by norm_num) kp cp z - hBump α 6 (by norm_num) km cm z)‖ₑ ≤
+        ENNReal.ofReal K * (anisoGauge α hα hn).maximal ((2 : ℝ) ^ kp) (fun y => ‖H y‖ₑ) x := by
+  set M : ℕ := absA α + 1
+  have hM : absA α < M := by omega
+  obtain ⟨C₁, hC₁, h₁⟩ := enorm_hBump_le_hMaj α hα 12 (by norm_num) M
+  obtain ⟨C₂, hC₂, h₂⟩ := enorm_hBump_le_hMaj α hα 6 (by norm_num) M
+  set GM : ℝ := ∫ w : Rn n, (1 + rho α w) ^ (-(M : ℝ))
+  have hGM : 0 ≤ GM := integral_nonneg fun w => by have := rho_nonneg α w; positivity
+  refine ⟨2 ^ M * C₁ * GM + 2 ^ M * C₂ * GM, by positivity, fun H hH kp km hk cp cm x => ?_⟩
+  set G := anisoGauge α hα hn
+  set lam : ℝ := (2 : ℝ) ^ kp
+  have hlam : 0 < lam := by positivity
+  have hlamk : lam ≤ (2 : ℝ) ^ km := zpow_le_zpow_right₀ (by norm_num) hk
+  set g : Rn n → ℝ≥0∞ := fun y => ‖H y‖ₑ
+  have hg : Measurable g := hH.enorm
+  set W₁ := hMaj α C₁ M kp lam
+  set W₂ := hMaj α C₂ M km lam
+  have hW₁ : ∫⁻ y, g (x - y) * W₁ (rho α y) ≤ (∫⁻ y, W₁ (rho α y)) * G.maximal lam g x :=
+    G.lintegral_mul_gauge_le hlam W₁ (hMaj_antitone α hC₁ M kp hlam.le)
+    (hMaj_const α C₁ M kp hlam.le) hg x
+  have hW₂ : ∫⁻ y, g (x - y) * W₂ (rho α y) ≤ (∫⁻ y, W₂ (rho α y)) * G.maximal lam g x :=
+    G.lintegral_mul_gauge_le hlam W₂ (hMaj_antitone α hC₂ M km hlam.le)
+    (hMaj_const α C₂ M km hlam.le) hg x
+  have hI₁ := lintegral_hMaj_le α hα hC₁ hM kp lam
+  have hI₂ := lintegral_hMaj_le α hα hC₂ hM km lam
+  have hmeasW : Measurable fun z : Rn n => g (x - z) * W₁ (rho α z) :=
+    (hg.comp (measurable_const.sub measurable_id)).mul
+      ((hMaj_antitone α hC₁ M kp hlam.le).measurable.comp (continuous_rho α).measurable)
+  calc ‖∫ z, H (x - z) * (hBump α 12 (by norm_num) kp cp z - hBump α 6 (by norm_num) km cm z)‖ₑ
+      ≤ ∫⁻ z, ‖H (x - z) * (hBump α 12 (by norm_num) kp cp z -
+          hBump α 6 (by norm_num) km cm z)‖ₑ := enorm_integral_le_lintegral_enorm _
+    _ ≤ ∫⁻ z, g (x - z) * W₁ (rho α z) + g (x - z) * W₂ (rho α z) := by
+        refine lintegral_mono fun z => ?_
+        rw [enorm_mul, ← mul_add]
+        gcongr
+        refine (enorm_sub_le).trans (add_le_add ?_ ?_)
+        · exact h₁ kp cp lam hlam.le le_rfl z
+        · exact h₂ km cm lam hlam.le hlamk z
+    _ ≤ (∫⁻ y, W₁ (rho α y)) * G.maximal lam g x + (∫⁻ y, W₂ (rho α y)) * G.maximal lam g x := by
+        rw [lintegral_add_left hmeasW]
+        exact add_le_add hW₁ hW₂
+    _ ≤ ENNReal.ofReal (2 ^ M * C₁ * GM) * G.maximal lam g x +
+          ENNReal.ofReal (2 ^ M * C₂ * GM) * G.maximal lam g x := by gcongr
+    _ = _ := by
+        rw [← add_mul, ← ENNReal.ofReal_add (by positivity) (by positivity)]
+
+theorem fhat_sub_of_integrable {f g : Rn n → ℂ} (hf : Integrable f) (hg : Integrable g)
+    (ξ : Rn n) : fhat (fun x => f x - g x) ξ = fhat f ξ - fhat g ξ := by
+  have h := fhat_finset_sum (Finset.univ : Finset (Fin 2)) ![1, -1] ![f, g]
+    (fun i _ => by fin_cases i <;> simpa) ξ
+  simp only [Fin.sum_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one, one_mul,
+    neg_one_mul, ← sub_eq_add_neg] at h
+  exact h
+
+/-- **Pointwise decomposition for `2`-trees** (paper, (7.10)–(7.16)): for `x`, the part of the tree
+sum at scales `≥ k₊` is bounded by `C‖m‖ε + K M_{2^{k₊}}|H|(x)`, `H = ∑_{P ∈ S} c_P ψ_P^{ξ_top}`. -/
+theorem twoTree_pointwise_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} {i₀ : Fin n} (hr : r i₀ = 1) (ν : ℕ) (hν : absA α < ν) :
+    ∃ C K : ℝ, 0 ≤ C ∧ 0 ≤ K ∧ ∀ (m : Rn n → ℂ), ClassM α (ν + 1) m → ∀ (top : Tile n)
+      (S : Finset (Tile n)), IsTree α top S → (∀ P ∈ S, top.cω α ∈ P.semiHO α r) →
+      ∀ (c : Tile n → ℂ) (ε : ℝ), 0 ≤ ε →
+      (∀ P ∈ S, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      ∀ (kp : ℤ) (E : Set (Rn n)) (N : Rn n → Rn n) (x : Rn n),
+      ‖∑ P ∈ S with kp ≤ P.k, c P * wavePsi α m (N x) P x *
+          (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+        ENNReal.ofReal (C * (normM α (ν + 1) m).toReal * ε) + ENNReal.ofReal K *
+          (anisoGauge α hα hn).maximal ((2 : ℝ) ^ kp)
+            (fun y => ‖∑ P ∈ S, c P * wavePsi α m (top.cω α) P y‖ₑ) x := by
+  classical
+  have hr0 : r ≠ 0 := fun h => by simp [h] at hr
+  obtain ⟨C, hC, h2⟩ := twoTree_term2_le α hα hr0 ν hν
+  obtain ⟨K, hK, h1⟩ := term1_le_maximal α hα hn
+  refine ⟨C, K, hC, hK, fun m hm top S hS hS2 c ε hε hc kp E N x => ?_⟩
+  set A0 := (S.filter fun P => kp ≤ P.k).filter fun P => x ∈ E ∩ N ⁻¹' (P.semiHO α r)
+  rcases A0.eq_empty_or_nonempty with hA0 | hA0
+  · have : ∑ P ∈ S with kp ≤ P.k, c P * wavePsi α m (N x) P x *
+        (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x = 0 := by
+      refine Finset.sum_eq_zero fun P hP => ?_
+      have hxP : x ∉ E ∩ N ⁻¹' (P.semiHO α r) := fun hxP => by
+        have : P ∈ A0 := Finset.mem_filter.mpr ⟨hP, hxP⟩
+        simp [hA0] at this
+      rw [Set.indicator_of_notMem hxP, mul_zero]
+    rw [this, enorm_zero]; exact bot_le
+  obtain ⟨Pm, hPmA, hPmax⟩ := A0.exists_max_image (fun P => P.k) hA0
+  have hPmS : Pm ∈ S := (Finset.mem_filter.mp (Finset.mem_filter.mp hPmA).1).1
+  have hkpPm : kp ≤ Pm.k := (Finset.mem_filter.mp (Finset.mem_filter.mp hPmA).1).2
+  have hxPm : x ∈ E ∩ N ⁻¹' (Pm.semiHO α r) := (Finset.mem_filter.mp hPmA).2
+  set A := S.filter fun P => kp ≤ P.k ∧ P.k ≤ Pm.k
+  have hAS : A ⊆ S := Finset.filter_subset _ _
+  have hNA : ∀ P ∈ A, N x ∈ P.semiHO α r := fun P hP =>
+    twoTree_semiHO_mono α hα hS hS2 (Finset.mem_filter.mp hP).1 hPmS
+      (Finset.mem_filter.mp hP).2.2 hxPm.2
+  -- the tree sum equals the sum over the window `A`
+  have hsumA : ∑ P ∈ S with kp ≤ P.k, c P * wavePsi α m (N x) P x *
+      (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x = ∑ P ∈ A, c P * wavePsi α m (N x) P x := by
+    rw [Finset.sum_filter, Finset.sum_filter]
+    refine Finset.sum_congr rfl fun P hP => ?_
+    by_cases hkp : kp ≤ P.k
+    · by_cases hk : P.k ≤ Pm.k
+      · have hxP : x ∈ E ∩ N ⁻¹' (P.semiHO α r) :=
+          ⟨hxPm.1, twoTree_semiHO_mono α hα hS hS2 hP hPmS hk hxPm.2⟩
+        rw [ite_eq_left hkp, ite_eq_left (show kp ≤ P.k ∧ P.k ≤ Pm.k from ⟨hkp, hk⟩),
+            Set.indicator_of_mem hxP, Pi.one_apply, mul_one]
+      · have hxP : x ∉ E ∩ N ⁻¹' (P.semiHO α r) := fun hxP =>
+          hk (hPmax P (Finset.mem_filter.mpr ⟨Finset.mem_filter.mpr ⟨hP, hkp⟩, hxP⟩))
+        rw [ite_eq_left hkp, ite_eq_right (fun h => hk h.2), Set.indicator_of_notMem hxP, mul_zero]
+    · rw [ite_eq_right hkp, ite_eq_right (fun h => hkp h.1)]
+  -- the window identity
+  set hp := hBump α 12 (by norm_num) kp ((DCube.ofPoint α (-kp) (top.cω α)).center α)
+  set hm' := hBump α 6 (by norm_num) Pm.k (Pm.semiCenter α r)
+  have hhp : Integrable hp := integrable_hBump α hα _ _ _ _
+  have hhm : Integrable hm' := integrable_hBump α hα _ _ _ _
+  have hh : Integrable fun z => hp z - hm' z := hhp.sub hhm
+  have hwin : ∀ ξ, ∑ P ∈ A, c P * fhat (wavePhi α P) ξ =
+      fhat (fun z => hp z - hm' z) ξ * ∑ P ∈ S, c P * fhat (wavePhi α P) ξ := by
+    intro ξ
+    rw [Finset.sum_filter, Finset.mul_sum, fhat_sub_of_integrable hhp hhm]
+    refine Finset.sum_congr rfl fun P hP => ?_
+    by_cases h0 : fhat (wavePhi α P) ξ = 0
+    · simp [h0]
+    · rw [chi_on_suppBox α hα hr hS hS2 kp hPmS hkpPm hP
+        (mem_suppBox_of_fhat_wavePhi_ne_zero α P h0)]
+      split_ifs <;> ring
+  have hconv := sum_wavePsi_eq_conv α hm (top.cω α) S A c hh hwin x
+  have hHc : Continuous fun y => ∑ P ∈ S, c P * wavePsi α m (top.cω α) P y := by
+    refine continuous_finsetSum _ fun P _ => continuous_const.mul ?_
+    have := (continuous_wavePsi_joint α hm P).comp
+      (continuous_const.prodMk continuous_id : Continuous fun y : Rn n => (top.cω α, y))
+    simpa only [Function.comp_def] using this
+  have hT1 := h1 (fun y => ∑ P ∈ S, c P * wavePsi α m (top.cω α) P y) hHc.measurable kp Pm.k
+    hkpPm ((DCube.ofPoint α (-kp) (top.cω α)).center α) (Pm.semiCenter α r) x
+  have hT2 := h2 m hm top S hS hS2 c ε hε hc (N x) A hAS hNA x
+  rw [hsumA]
+  have hsplit : ∑ P ∈ A, c P * wavePsi α m (N x) P x =
+      ∑ P ∈ A, c P * (wavePsi α m (N x) P x - wavePsi α m (top.cω α) P x) +
+        ∑ P ∈ A, c P * wavePsi α m (top.cω α) P x := by
+    rw [← Finset.sum_add_distrib]
+    refine Finset.sum_congr rfl fun P _ => by ring
+  rw [hsplit, hconv]
+  refine (enorm_add_le _ _).trans (add_le_add ?_ hT1)
+  rw [← ofReal_norm]
+  exact ENNReal.ofReal_le_ofReal hT2
+
+/-- Summing set integrals over the selected cubes of the partition `𝒥` gives the integral over
+their union. -/
+theorem tsum_indicator_setLIntegral_jSet (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    (T : Finset (Tile n)) (hT : T.Nonempty) (R : Set (DCube n)) (f : Rn n → ℝ≥0∞) :
+    ∑' J : jSet α T, R.indicator (fun J => ∫⁻ x in J.toSet α, f x) (J : DCube n) =
+      ∫⁻ x in ⋃ (J : jSet α T) (_ : (J : DCube n) ∈ R), (J : DCube n).toSet α, f x := by
+  set U := ⋃ (J : jSet α T) (_ : (J : DCube n) ∈ R), (J : DCube n).toSet α
+  have hU : MeasurableSet U :=
+    MeasurableSet.iUnion fun J => MeasurableSet.iUnion fun _ => DCube.measurableSet_toSet α _
+  rw [← lintegral_indicator hU, lintegral_eq_tsum_jSet α hα hn T hT]
+  refine tsum_congr fun J => ?_
+  rw [setLIntegral_indicator hU]
+  by_cases hJ : (J : DCube n) ∈ R
+  · rw [Set.indicator_of_mem hJ, Set.inter_eq_right.mpr fun x hx => Set.mem_iUnion₂.mpr ⟨J, hJ, hx⟩]
+  · rw [Set.indicator_of_notMem hJ]
+    have : U ∩ (J : DCube n).toSet α = ∅ := by
+      refine Set.eq_empty_of_forall_notMem fun x hx => ?_
+      obtain ⟨J', hJ', hx'⟩ := Set.mem_iUnion₂.mp hx.1
+      have hne : (J : DCube n) ≠ (J' : DCube n) := fun h => hJ (h ▸ hJ')
+      exact Set.disjoint_left.mp (jSet_disjoint α T J.2 J'.2 hne) hx.2 hx'
+    rw [this, Measure.restrict_empty, lintegral_zero_measure]
+
+/-- Cauchy–Schwarz on a set: `∫_U g ≤ |U|^{1/2} ‖g‖₂`. -/
+theorem setLIntegral_le_sqrt_mul_sqrt {U : Set (Rn n)} {g : Rn n → ℝ≥0∞} (hg : Measurable g)
+    {A B : ℝ} (hA : 0 ≤ A) (hB : 0 ≤ B) (h1 : volume U ≤ ENNReal.ofReal A)
+    (h2 : ∫⁻ x, g x ^ 2 ≤ ENNReal.ofReal B) :
+    ∫⁻ x in U, g x ≤ ENNReal.ofReal (Real.sqrt A * Real.sqrt B) := by
+  have hH := ENNReal.lintegral_mul_le_Lp_mul_Lq (volume.restrict U) Real.HolderConjugate.two_two
+    (f := fun _ => (1 : ℝ≥0∞)) (g := g) aemeasurable_const hg.aemeasurable
+  simp only [Pi.mul_apply, one_mul, ENNReal.one_rpow, lintegral_const,
+    Measure.restrict_apply_univ] at hH
+  refine hH.trans ?_
+  rw [ENNReal.ofReal_mul (Real.sqrt_nonneg _), Real.sqrt_eq_rpow, Real.sqrt_eq_rpow,
+    ← ENNReal.ofReal_rpow_of_nonneg hA (by norm_num),
+    ← ENNReal.ofReal_rpow_of_nonneg hB (by norm_num)]
+  gcongr
+  calc ∫⁻ x in U, g x ^ (2 : ℝ) ≤ ∫⁻ x, g x ^ (2 : ℝ) := setLIntegral_le_lintegral _ _
+    _ = ∫⁻ x, g x ^ 2 := by simp_rw [ENNReal.rpow_two]
+    _ ≤ _ := h2
+
+/-- **The `2`-tree part of the tree estimate** (paper, §7.2, (7.10)–(7.18)): the far part
+`K₂` of a `2`-tree sum is bounded by `C‖m‖ ε μ |I_top|`, where `ε` bounds the energy
+(`∑_{P ∈ S} |c_P|² ≤ ε²|I_top|`) and `μ` the mass. -/
+theorem K2_twoTree_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    {i₀ : Fin n} (hr : r i₀ = 1) (ν : ℕ) (hν : absA α < ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α (ν + 1) m → ∀ (E : Set (Rn n)), MeasurableSet E →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (top : Tile n) (T : Finset (Tile n)),
+      IsTree α top T → ∀ S ⊆ T, (∀ P ∈ S, top.cω α ∈ P.semiHO α r) →
+      ∀ (c : Tile n → ℂ) (ε μ : ℝ), 0 ≤ ε → 0 ≤ μ →
+      (∀ P ∈ T, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2)) →
+      ∑ P ∈ S, ‖c P‖ ^ 2 ≤ ε ^ 2 * top.vol α →
+      (∀ P ∈ T, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) →
+      ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+        c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+        ENNReal.ofReal (C * (normM α (ν + 1) m).toReal * ε * μ * top.vol α) := by
+  classical
+  obtain ⟨C1, K1, hC1, hK1, hpt⟩ := twoTree_pointwise_le α hα hn hr ν hν
+  obtain ⟨C2, hC2, hGJ⟩ := volume_GJ_le α hα hn r
+  obtain ⟨CH, hCH, hHL2⟩ := twoTree_H_L2 α hα hr
+  set D : ℕ := absA α with hD
+  set Q : ℝ := Real.sqrt (5 ^ n) * Real.sqrt (8 * 3 ^ D * CH)
+  have hQ : 0 ≤ Q := by positivity
+  refine ⟨C1 * C2 * 5 ^ n + C2 * K1 * 2 ^ D * Q, by positivity, fun m hm E hE N hN top T hT S hST
+    hS2 c ε μ hε hμ hc hsq hmass => ?_⟩
+  rcases T.eq_empty_or_nonempty with hT0 | hTne
+  · have hS0 : S = ∅ := Finset.subset_empty.mp (hT0 ▸ hST)
+    subst hS0
+    simp
+  set Nm := (normM α (ν + 1) m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  have htv : 0 < top.vol α := top.vol_pos α
+  have hm' : ClassM α (absA α + 1) m := hm.mono (by omega)
+  have hNm' : (normM α (absA α + 1) m).toReal ≤ Nm := normM_toReal_mono α hα hm (by omega)
+  have hST' : IsTree α top S := fun P hP => hT P (hST hP)
+  set G := anisoGauge α hα hn
+  have h2D : (2 : ℝ) ^ G.D = 2 ^ D := Real.rpow_natCast 2 D
+  have h3D : (3 : ℝ) ^ G.D = 3 ^ D := Real.rpow_natCast 3 D
+  set H : Rn n → ℂ := fun y => ∑ P ∈ S, c P * wavePsi α m (top.cω α) P y
+  set Hn : Rn n → ℝ≥0∞ := fun y => ‖H y‖ₑ
+  have hHc : Continuous H := continuous_finsetSum _ fun P _ => continuous_const.mul (by
+    have h1 := continuous_wavePsi_joint α hm P
+    have h2 : Continuous fun x : Rn n => ((top.cω α, x) : Rn n × Rn n) :=
+      continuous_const.prodMk continuous_id
+    simpa only [Function.comp_def] using h1.comp h2)
+  have hHn : Measurable Hn := hHc.measurable.enorm
+  set M0 := G.maximal 0 Hn
+  have hM0 : Measurable M0 := G.measurable_maximal 0 hHn
+  -- the `L²` bound for `H`
+  have hHint : Integrable H := integrable_finsetSum _ fun P hP =>
+    (integrable_wavePsi α hα hm' P ⟨i₀, (far_of_mem_semiHO α hr P (hS2 P hP)).trans
+      (le_abs_self _)⟩).const_mul (c P)
+  obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+  set B : ℝ := ∑ P ∈ S, ‖c P‖ * (((2 * π) ^ n)⁻¹ * (Cm * ∫ ξ, ‖fhat (wavePhi α P) ξ‖))
+  have hHB : ∀ y, ‖H y‖ ≤ B := fun y => (norm_sum_le _ _).trans (Finset.sum_le_sum fun P _ => by
+    rw [norm_mul]
+    exact mul_le_mul_of_nonneg_left (norm_wavePsi_le α hmb _ P y) (norm_nonneg _))
+  have hHsq : Integrable fun y => ‖H y‖ ^ 2 :=
+    (hHint.norm.const_mul B).mono' (hHint.norm.aestronglyMeasurable.pow 2)
+      (Filter.Eventually.of_forall fun y => by
+        rw [Real.norm_eq_abs, abs_of_nonneg (by positivity), sq]
+        exact mul_le_mul_of_nonneg_right (hHB y) (norm_nonneg _))
+  have hL2 : ∫⁻ y, Hn y ^ 2 ≤ ENNReal.ofReal (CH * Nm ^ 2 * (ε ^ 2 * top.vol α)) := by
+    have heq : ∫⁻ y, Hn y ^ 2 = ENNReal.ofReal (∫ y, ‖H y‖ ^ 2) := by
+      rw [ofReal_integral_eq_lintegral_ofReal hHsq
+        (Filter.Eventually.of_forall fun y => by positivity)]
+      refine lintegral_congr fun y => ?_
+      simp only [Hn]
+      rw [← ofReal_norm, ← ENNReal.ofReal_pow (norm_nonneg _)]
+    rw [heq]
+    refine ENNReal.ofReal_le_ofReal ((hHL2 m hm' top S hST' hS2 c).trans ?_)
+    have h1 : (normM α (absA α + 1) m).toReal ^ 2 ≤ Nm ^ 2 :=
+      pow_le_pow_left₀ ENNReal.toReal_nonneg hNm' 2
+    calc CH * (normM α (absA α + 1) m).toReal ^ 2 * ∑ P ∈ S, ‖c P‖ ^ 2
+        ≤ CH * Nm ^ 2 * ∑ P ∈ S, ‖c P‖ ^ 2 := by gcongr
+      _ ≤ _ := by gcongr
+  have hM0L2 : ∫⁻ y, M0 y ^ 2 ≤
+      ENNReal.ofReal (8 * 3 ^ D * (CH * Nm ^ 2 * (ε ^ 2 * top.vol α))) := by
+    calc ∫⁻ y, M0 y ^ 2 ≤ ENNReal.ofReal (8 * 3 ^ G.D) * ∫⁻ y, Hn y ^ 2 :=
+          G.lintegral_maximal_sq_le Hn hHn
+      _ ≤ ENNReal.ofReal (8 * 3 ^ D) * ENNReal.ofReal (CH * Nm ^ 2 * (ε ^ 2 * top.vol α)) :=
+          mul_le_mul' (le_of_eq (by rw [h3D])) hL2
+      _ = _ := (ENNReal.ofReal_mul (by positivity)).symm
+  -- the bound on each cube `J`
+  set R : Set (DCube n) := {J | ∃ P ∈ T, J.k + 2 ≤ P.k}
+  set a : ℝ≥0∞ := ENNReal.ofReal (C1 * Nm * ε)
+  have hJ : ∀ J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+      c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+      ENNReal.ofReal (C2 * μ) * a * R.indicator (fun J => volume (J.toSet α)) (J : DCube n) +
+      ENNReal.ofReal (C2 * μ) * ENNReal.ofReal K1 * ENNReal.ofReal (2 ^ D) *
+        R.indicator (fun J => ∫⁻ y in J.toSet α, M0 y) (J : DCube n) := by
+    intro J
+    by_cases hrel : (J : DCube n) ∈ R
+    · rw [Set.indicator_of_mem hrel, Set.indicator_of_mem hrel]
+      set GJ := (J : DCube n).toSet α ∩ ⋃ P ∈ T.filter (fun P => (J : DCube n).k + 2 ≤ P.k),
+        E ∩ N ⁻¹' (P.semiHO α r)
+      have hGm : MeasurableSet GJ := (DCube.measurableSet_toSet α _).inter
+        (Finset.measurableSet_biUnion _ fun P _ => hE.inter (hN (measurableSet_semiHO α P r)))
+      have hJm := DCube.measurableSet_toSet α (J : DCube n)
+      have hvol0 : volume ((J : DCube n).toSet α) ≠ 0 := by
+        rw [DCube.volume_toSet]; exact (ENNReal.ofReal_pos.mpr (by positivity)).ne'
+      have hvolT : volume ((J : DCube n).toSet α) ≠ ⊤ := by
+        rw [DCube.volume_toSet]; exact ENNReal.ofReal_ne_top
+      set bJ := (volume ((J : DCube n).toSet α))⁻¹ *
+        (ENNReal.ofReal (2 ^ D) * ∫⁻ y in (J : DCube n).toSet α, M0 y)
+      have hmax : ∀ x ∈ (J : DCube n).toSet α,
+          G.maximal ((2 : ℝ) ^ ((J : DCube n).k + 2)) Hn x ≤ bJ := by
+        intro x hx
+        have hle : ∀ y ∈ (J : DCube n).toSet α, G.maximal ((2 : ℝ) ^ ((J : DCube n).k + 2)) Hn x ≤
+            ENNReal.ofReal (2 ^ D) * M0 y := fun y hy => h2D ▸
+          G.maximal_le_of_rho_sub_le Hn
+            ((rho_sub_le_of_mem_DCube α hα _ hx hy).trans
+              (zpow_le_zpow_right₀ (by norm_num)
+                (show (J : DCube n).k ≤ (J : DCube n).k + 2 by omega)))
+        have h1 : volume ((J : DCube n).toSet α) *
+            G.maximal ((2 : ℝ) ^ ((J : DCube n).k + 2)) Hn x ≤
+            ENNReal.ofReal (2 ^ D) * ∫⁻ y in (J : DCube n).toSet α, M0 y := by
+          rw [← lintegral_const_mul _ hM0, mul_comm, ← setLIntegral_const]
+          exact setLIntegral_mono' hJm hle
+        calc G.maximal ((2 : ℝ) ^ ((J : DCube n).k + 2)) Hn x
+            = (volume ((J : DCube n).toSet α))⁻¹ * (volume ((J : DCube n).toSet α) *
+                G.maximal ((2 : ℝ) ^ ((J : DCube n).k + 2)) Hn x) := by
+              rw [← mul_assoc, ENNReal.inv_mul_cancel hvol0 hvolT, one_mul]
+          _ ≤ bJ := mul_le_mul' le_rfl h1
+      have hbound : ∀ x ∈ (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+          c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+          GJ.indicator (fun _ => a + ENNReal.ofReal K1 * bJ) x := by
+        intro x hx
+        by_cases hxG : x ∈ GJ
+        · rw [Set.indicator_of_mem hxG]
+          refine (hpt m hm top S hST' hS2 c ε hε (fun P hP => hc P (hST hP))
+            ((J : DCube n).k + 2) E N x).trans ?_
+          exact add_le_add le_rfl (mul_le_mul' le_rfl (hmax x hx))
+        · rw [Set.indicator_of_notMem hxG]
+          have hzero : ∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k, c P * wavePsi α m (N x) P x *
+              (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x = 0 := by
+            refine Finset.sum_eq_zero fun P hP => ?_
+            have hxP : x ∉ E ∩ N ⁻¹' (P.semiHO α r) := by
+              intro hxP
+              apply hxG
+              refine ⟨hx, Set.mem_biUnion (Finset.mem_filter.mpr ⟨hST (Finset.mem_filter.mp hP).1,
+                (Finset.mem_filter.mp hP).2⟩) hxP⟩
+            rw [Set.indicator_of_notMem hxP, mul_zero]
+          rw [hzero, enorm_zero]
+      have hbJ : bJ * volume ((J : DCube n).toSet α) =
+          ENNReal.ofReal (2 ^ D) * ∫⁻ y in (J : DCube n).toSet α, M0 y := by
+        simp only [bJ]
+        rw [mul_comm, ← mul_assoc, ENNReal.mul_inv_cancel hvol0 hvolT, one_mul]
+      calc ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+            c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ
+          ≤ ∫⁻ x in (J : DCube n).toSet α, GJ.indicator (fun _ => a + ENNReal.ofReal K1 * bJ) x :=
+            setLIntegral_mono' hJm hbound
+        _ ≤ ∫⁻ x, GJ.indicator (fun _ => a + ENNReal.ofReal K1 * bJ) x :=
+            setLIntegral_le_lintegral _ _
+        _ = (a + ENNReal.ofReal K1 * bJ) * volume GJ := lintegral_indicator_const hGm _
+        _ ≤ (a + ENNReal.ofReal K1 * bJ) *
+              ENNReal.ofReal (C2 * μ * (2 : ℝ) ^ ((J : DCube n).k * (absA α : ℤ))) := by
+            gcongr
+            exact hGJ E hE N hN top T hT μ hμ hmass J J.2
+        _ = ENNReal.ofReal (C2 * μ) * ((a + ENNReal.ofReal K1 * bJ) *
+              volume ((J : DCube n).toSet α)) := by
+            rw [DCube.volume_toSet, ENNReal.ofReal_mul (by positivity)]
+            ring
+        _ = _ := by
+            rw [add_mul, mul_assoc (ENNReal.ofReal K1), hbJ]
+            ring
+    · rw [Set.indicator_of_notMem hrel, Set.indicator_of_notMem hrel, mul_zero, mul_zero,
+        add_zero]
+      have hS'e : S.filter (fun P => (J : DCube n).k + 2 ≤ P.k) = ∅ :=
+        Finset.eq_empty_of_forall_notMem fun P hP => hrel ⟨P, hST (Finset.mem_filter.mp hP).1,
+          (Finset.mem_filter.mp hP).2⟩
+      simp [hS'e]
+  -- summation over `J`
+  have hU := tsum_indicator_setLIntegral_jSet α hα hn T hTne R
+  set U := ⋃ (J : jSet α T) (_ : (J : DCube n) ∈ R), (J : DCube n).toSet α
+  have hvolU : volume U ≤ ENNReal.ofReal (5 ^ n * top.vol α) := by
+    have h := hU (fun _ => 1)
+    simp only [setLIntegral_one] at h
+    rw [← h]
+    exact tsum_volume_relevant_le α hα hn hT
+  have hIU := setLIntegral_le_sqrt_mul_sqrt hM0 (by positivity) (by positivity) hvolU hM0L2
+  have e1 : Real.sqrt (5 ^ n * top.vol α) = Real.sqrt (5 ^ n) * Real.sqrt (top.vol α) :=
+    Real.sqrt_mul (by positivity) _
+  have e2 : Real.sqrt (8 * 3 ^ D * (CH * Nm ^ 2 * (ε ^ 2 * top.vol α))) =
+      Real.sqrt (8 * 3 ^ D * CH) * (Nm * ε) * Real.sqrt (top.vol α) := by
+    rw [show 8 * 3 ^ D * (CH * Nm ^ 2 * (ε ^ 2 * top.vol α)) =
+        (8 * 3 ^ D * CH) * (Nm * ε) ^ 2 * top.vol α by ring,
+      Real.sqrt_mul (by positivity), Real.sqrt_mul (by positivity), Real.sqrt_sq (by positivity)]
+  have hsv := Real.mul_self_sqrt (top.vol_pos α).le
+  calc ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+        c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ
+      ≤ ∑' J : jSet α T, (ENNReal.ofReal (C2 * μ) * a *
+          R.indicator (fun J => volume (J.toSet α)) (J : DCube n) +
+        ENNReal.ofReal (C2 * μ) * ENNReal.ofReal K1 * ENNReal.ofReal (2 ^ D) *
+          R.indicator (fun J => ∫⁻ y in J.toSet α, M0 y) (J : DCube n)) := ENNReal.tsum_le_tsum hJ
+    _ = ENNReal.ofReal (C2 * μ) * a * ∑' J : jSet α T,
+          R.indicator (fun J => volume (J.toSet α)) (J : DCube n) +
+        ENNReal.ofReal (C2 * μ) * ENNReal.ofReal K1 * ENNReal.ofReal (2 ^ D) * ∑' J : jSet α T,
+          R.indicator (fun J => ∫⁻ y in J.toSet α, M0 y) (J : DCube n) := by
+        rw [ENNReal.tsum_add, ENNReal.tsum_mul_left, ENNReal.tsum_mul_left]
+    _ ≤ ENNReal.ofReal (C2 * μ) * a * ENNReal.ofReal (5 ^ n * top.vol α) +
+        ENNReal.ofReal (C2 * μ) * ENNReal.ofReal K1 * ENNReal.ofReal (2 ^ D) *
+          ENNReal.ofReal (Real.sqrt (5 ^ n * top.vol α) *
+            Real.sqrt (8 * 3 ^ D * (CH * Nm ^ 2 * (ε ^ 2 * top.vol α)))) := by
+        gcongr
+        · exact tsum_volume_relevant_le α hα hn hT
+        · rw [hU]; exact hIU
+    _ = _ := by
+        rw [e1, e2]
+        simp only [a]
+        rw [← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_mul (by positivity),
+          ← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_mul (by positivity),
+          ← ENNReal.ofReal_mul (by positivity), ← ENNReal.ofReal_add (by positivity)
+            (by positivity)]
+        congr 1
+        simp only [Q]
+        linear_combination (C2 * μ * K1 * 2 ^ D * Real.sqrt (5 ^ n) *
+          Real.sqrt (8 * 3 ^ D * CH) * Nm * ε) * hsv
+
+/-! ### Assembly of the tree estimate (paper, Lemma 4.4, §7) -/
+
+/-- The energy bounds each single coefficient: `|⟨f, φ_P⟩| ≤ 𝓔 |I_P|^{1/2}`. -/
+theorem norm_pairing_le_of_energy_le (α : Fin n → ℕ) {r : Fin n → Fin 2} {f : Rn n → ℂ}
+    {S : Finset (Tile n)} {ε : ℝ} (hε : 0 ≤ ε) (hE : energy α r f S ≤ ENNReal.ofReal ε)
+    {P : Tile n} (hP : P ∈ S) :
+    ‖pairing f (wavePhi α P)‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := by
+  have h := sum_sq_le_of_energy_le α hε hE (Finset.singleton_subset_iff.mpr hP)
+    (Is2Tree.singleton α r P)
+  rw [Finset.sum_singleton, ← sqrt_vol_eq α P, ← mul_pow] at h
+  exact (pow_le_pow_iff_left₀ (norm_nonneg _) (by positivity) two_ne_zero).mp h
+
+theorem measurable_wavePsi_comp {α : Fin n → ℕ} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m)
+    {N : Rn n → Rn n} (hN : Measurable N) (P : Tile n) :
+    Measurable fun x => wavePsi α m (N x) P x := by
+  have := (continuous_wavePsi_joint α hm P).measurable.comp (hN.prodMk measurable_id)
+  simpa only [Function.comp_def, id] using this
+
+/-- Splitting the integral of a tree sum over the partition `𝒥` into the near part `𝒦₁`
+(`k_P ≤ k_J + 1`) and the far part `𝒦₂` (paper, (7.1)). -/
+theorem lintegral_treeSum_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} {ν : ℕ} {m : Rn n → ℂ} (hm : ClassM α ν m) {E : Set (Rn n)}
+    (hE : MeasurableSet E) {N : Rn n → Rn n} (hN : Measurable N) (T : Finset (Tile n))
+    (hT : T.Nonempty) (S : Finset (Tile n)) (hST : S ⊆ T) (c : Tile n → ℂ) :
+    ∫⁻ x, ‖∑ P ∈ S, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ ≤
+      (∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+        ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x) +
+      ∑' J : jSet α T, ∫⁻ x in (J : DCube n).toSet α, ‖∑ P ∈ S with (J : DCube n).k + 2 ≤ P.k,
+        c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ := by
+  classical
+  rw [lintegral_eq_tsum_jSet α hα hn T hT, ← ENNReal.tsum_add]
+  refine ENNReal.tsum_le_tsum fun J => ?_
+  have hA : Measurable fun x => ∑ P ∈ T with P.k ≤ (J : DCube n).k + 1,
+      ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x :=
+    Finset.measurable_sum _ fun P _ => (((measurable_wavePsi_comp hm hN P).const_mul
+      (c P)).enorm).mul (measurable_one.indicator (hE.inter (hN (measurableSet_semiHO α P r))))
+  rw [← lintegral_add_left hA]
+  refine lintegral_mono fun x => ?_
+  rw [← Finset.sum_filter_add_sum_filter_not S (fun P => (J : DCube n).k + 2 ≤ P.k)]
+  refine (enorm_add_le _ _).trans ?_
+  rw [add_comm]
+  refine add_le_add ?_ le_rfl
+  have hterm : ∀ P : Tile n, ‖c P * wavePsi α m (N x) P x *
+      (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ =
+      ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x := by
+    intro P
+    by_cases hx : x ∈ E ∩ N ⁻¹' (P.semiHO α r)
+    · simp [Set.indicator_of_mem hx]
+    · simp [Set.indicator_of_notMem hx]
+  calc ‖∑ P ∈ S with ¬ (J : DCube n).k + 2 ≤ P.k, c P * wavePsi α m (N x) P x *
+        (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ
+      ≤ ∑ P ∈ S with ¬ (J : DCube n).k + 2 ≤ P.k, ‖c P * wavePsi α m (N x) P x *
+        (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x‖ₑ := enorm_sum_le _ _
+    _ = ∑ P ∈ S with ¬ (J : DCube n).k + 2 ≤ P.k,
+        ‖c P * wavePsi α m (N x) P x‖ₑ * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x :=
+        Finset.sum_congr rfl fun P _ => hterm P
+    _ ≤ _ := Finset.sum_le_sum_of_subset fun P hP => Finset.mem_filter.mpr
+        ⟨hST (Finset.mem_filter.mp hP).1, by have := (Finset.mem_filter.mp hP).2; omega⟩
+
+/-- **Tree estimate** (paper, Lemma 4.4, (4.9), proved in §7): for a tree `T` with top `top`,
+energy `𝓔(T) ≤ ε` and mass `𝓜(P) ≤ μ` for all `P ∈ T`,
+`∑_{P ∈ T} |⟨f, φ_P⟩| |∫_{E ∩ N⁻¹(ω_{P(r)})} ψ_P^{N(x)}(x) σ(x) dx| ≤ C ‖m‖ ε μ |I_top|`. -/
+theorem tree_estimate (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : Rn n → ℂ) (N : Rn n → Rn n),
+      Measurable N → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (σ : Rn n → ℂ), Measurable σ → (∀ x, ‖σ x‖ ≤ 1) →
+      ∀ (top : Tile n) (T : Finset (Tile n)), IsTree α top T → ∀ (ε μ : ℝ), 0 ≤ ε → 0 ≤ μ →
+      energy α r f T ≤ ENNReal.ofReal ε →
+      (∀ P ∈ T, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) →
+      ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ ≤
+        C * (normM α ν m).toReal * ε * μ * top.vol α := by
+  classical
+  obtain ⟨i₀, hi₀⟩ : ∃ i, r i = 1 := by
+    by_contra h
+    push Not at h
+    exact hr (funext fun i => by
+      simpa using (Fin.exists_fin_two.mp ⟨r i, rfl⟩ : r i = 0 ∨ r i = 1).resolve_right (h i))
+  obtain ⟨CK, hCK, hK1⟩ := K1_le α hα hn hr ν hν
+  obtain ⟨Co, hCo, hK2o⟩ := K2_oneTree_le α hα hn hr ν (by omega)
+  obtain ⟨Ct, hCt, hK2t⟩ := K2_twoTree_le α hα hn hi₀ (ν - 1) (by omega)
+  have hνe : ν - 1 + 1 = ν := by omega
+  refine ⟨2 * CK + Co + Ct, by positivity, fun m hm f N hN E hE hEfin σ hσ hσ1 top T hT ε μ hε hμ
+    henergy hmass => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  have htv : 0 < top.vol α := top.vol_pos α
+  rcases T.eq_empty_or_nonempty with hT0 | hTne
+  · subst hT0
+    rw [Finset.sum_empty]
+    positivity
+  set a : Tile n → ℂ := fun P => pairing f (wavePhi α P)
+  set d : Tile n → ℂ := fun P => dualTerm α m r N E σ P
+  set c : Tile n → ℂ := fun P =>
+    if d P = 0 then 0 else (‖a P‖ : ℂ) * (star (d P) / (‖d P‖ : ℂ))
+  have hcd : ∀ P, c P * d P = ((‖a P‖ * ‖d P‖ : ℝ) : ℂ) := by
+    intro P
+    by_cases h0 : d P = 0
+    · simp [c, h0]
+    · have hn0 : (‖d P‖ : ℂ) ≠ 0 := by exact_mod_cast (norm_ne_zero_iff.mpr h0)
+      have hsd : star (d P) * d P = ((‖d P‖ : ℂ)) ^ 2 := Complex.conj_mul' (d P)
+      simp only [c, ite_eq_right h0]
+      calc (‖a P‖ : ℂ) * (star (d P) / (‖d P‖ : ℂ)) * d P
+          = (‖a P‖ : ℂ) * (star (d P) * d P) / (‖d P‖ : ℂ) := by ring
+        _ = (‖a P‖ : ℂ) * (‖d P‖ : ℂ) ^ 2 / (‖d P‖ : ℂ) := by rw [hsd]
+        _ = _ := by push_cast; field_simp
+  have hcn : ∀ P, ‖c P‖ ≤ ‖a P‖ := by
+    intro P
+    by_cases h0 : d P = 0
+    · simp [c, h0]
+    · simp only [c, ite_eq_right h0, norm_mul, norm_div, Complex.norm_real, norm_norm, norm_star]
+      rw [div_self (norm_ne_zero_iff.mpr h0), mul_one]
+  have hc : ∀ P ∈ T, ‖c P‖ ≤ ε * ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) := fun P hP =>
+    (hcn P).trans (norm_pairing_le_of_energy_le α hε henergy hP)
+  have hmass1 : ∀ P ∈ T, ∫⁻ x in E ∩ N ⁻¹' (P.ω.toSet α), ENNReal.ofReal (wP α (nu1 α) P x) ≤
+      ENNReal.ofReal μ := by
+    intro P hP
+    have := hmass P hP
+    unfold massTile at this
+    exact le_trans (le_iSup₂_of_le P (Tile.le_refl α P) le_rfl) this
+  set S1 := T.filter fun P => top.cω α ∉ P.semiHO α r
+  set S2 := T.filter fun P => top.cω α ∈ P.semiHO α r
+  have hS1T : S1 ⊆ T := Finset.filter_subset _ _
+  have hS2T : S2 ⊆ T := Finset.filter_subset _ _
+  have hS1 : ∀ P ∈ S1, top.cω α ∉ P.semiHO α r := fun P hP => (Finset.mem_filter.mp hP).2
+  have hS2 : ∀ P ∈ S2, top.cω α ∈ P.semiHO α r := fun P hP => (Finset.mem_filter.mp hP).2
+  have hsq : ∑ P ∈ S2, ‖c P‖ ^ 2 ≤ ε ^ 2 * top.vol α :=
+    (Finset.sum_le_sum fun P _ => pow_le_pow_left₀ (norm_nonneg _) (hcn P) 2).trans
+      (sum_sq_le_of_energy_le α hε henergy hS2T ⟨fun P hP => hT P (hS2T hP),
+        fun P hP => Tile.semiHO_subset_semi α P r (hS2 P hP)⟩)
+  set Fs : Finset (Tile n) → Rn n → ℂ := fun S x =>
+    ∑ P ∈ S, c P * wavePsi α m (N x) P x * (E ∩ N ⁻¹' (P.semiHO α r)).indicator 1 x
+  have hFm : ∀ S, Measurable (Fs S) := fun S => Finset.measurable_sum _ fun P _ =>
+    ((measurable_wavePsi_comp hm hN P).const_mul (c P)).mul
+      (measurable_one.indicator (hE.inter (hN (measurableSet_semiHO α P r))))
+  -- the dual pairings as one integral
+  have hint : ∀ P, Integrable ((E ∩ N ⁻¹' (P.semiHO α r)).indicator
+      (fun x => wavePsi α m (N x) P x * σ x)) := by
+    intro P
+    obtain ⟨Cm, hCm, hmb⟩ := hm.bounded'
+    have hs : MeasurableSet (E ∩ N ⁻¹' (P.semiHO α r)) := hE.inter (hN (measurableSet_semiHO α P r))
+    rw [integrable_indicator_iff hs]
+    have : IsFiniteMeasure (volume.restrict (E ∩ N ⁻¹' (P.semiHO α r))) := by
+      constructor
+      rw [Measure.restrict_apply_univ]
+      exact (measure_mono Set.inter_subset_left).trans_lt hEfin
+    refine (integrable_const (((2 * π) ^ n)⁻¹ * (Cm * ∫ ξ, ‖fhat (wavePhi α P) ξ‖))).mono'
+      (((measurable_wavePsi_comp hm hN P).mul hσ).aestronglyMeasurable)
+      (Filter.Eventually.of_forall fun x => ?_)
+    rw [norm_mul]
+    calc ‖wavePsi α m (N x) P x‖ * ‖σ x‖ ≤ ‖wavePsi α m (N x) P x‖ * 1 := by
+          gcongr; exact hσ1 x
+      _ ≤ _ := by rw [mul_one]; exact norm_wavePsi_le α hmb _ P x
+  have hsum : ∑ P ∈ T, c P * d P = ∫ x, σ x * Fs T x := by
+    have h1 : ∀ P, c P * d P = ∫ x, c P * (E ∩ N ⁻¹' (P.semiHO α r)).indicator
+        (fun x => wavePsi α m (N x) P x * σ x) x := by
+      intro P
+      simp only [d, dualTerm]
+      rw [← integral_indicator (hE.inter (hN (measurableSet_semiHO α P r))), integral_const_mul]
+    rw [Finset.sum_congr rfl fun P _ => h1 P,
+      ← integral_finsetSum _ fun P _ => (hint P).const_mul (c P)]
+    congr 1
+    ext x
+    simp only [Fs, Finset.mul_sum]
+    refine Finset.sum_congr rfl fun P _ => ?_
+    by_cases hx : x ∈ E ∩ N ⁻¹' (P.semiHO α r)
+    · simp only [Set.indicator_of_mem hx, Pi.one_apply]; ring
+    · simp [Set.indicator_of_notMem hx]
+  have hmain : ENNReal.ofReal (∑ P ∈ T, ‖a P‖ * ‖d P‖) ≤
+      (∫⁻ x, ‖Fs S1 x‖ₑ) + ∫⁻ x, ‖Fs S2 x‖ₑ := by
+    have e : ENNReal.ofReal (∑ P ∈ T, ‖a P‖ * ‖d P‖) = ‖∑ P ∈ T, c P * d P‖ₑ := by
+      rw [Finset.sum_congr rfl fun P _ => hcd P, ← Complex.ofReal_sum, ← ofReal_norm,
+        Complex.norm_real, Real.norm_of_nonneg (Finset.sum_nonneg fun P _ => by positivity)]
+    rw [e, hsum]
+    calc ‖∫ x, σ x * Fs T x‖ₑ ≤ ∫⁻ x, ‖σ x * Fs T x‖ₑ := enorm_integral_le_lintegral_enorm _
+      _ ≤ ∫⁻ x, (‖Fs S1 x‖ₑ + ‖Fs S2 x‖ₑ) := lintegral_mono fun x => by
+          rw [enorm_mul]
+          have hsplit : Fs T x = Fs S1 x + Fs S2 x := by
+            simp only [Fs, S1, S2]
+            rw [← Finset.sum_filter_add_sum_filter_not T (fun P => top.cω α ∈ P.semiHO α r)]
+            exact add_comm _ _
+          rw [hsplit]
+          calc ‖σ x‖ₑ * ‖Fs S1 x + Fs S2 x‖ₑ ≤ 1 * ‖Fs S1 x + Fs S2 x‖ₑ := by
+                gcongr
+                rw [← ofReal_norm]
+                exact ENNReal.ofReal_le_one.mpr (hσ1 x)
+            _ ≤ _ := by rw [one_mul]; exact enorm_add_le _ _
+      _ = _ := lintegral_add_left (hFm S1).enorm _
+  have hK1b := hK1 m hm E hE N hN top T hT c ε μ hε hμ hc hmass1
+  have hA1 := lintegral_treeSum_le α hα hn (r := r) hm hE hN T hTne S1 hS1T c
+  have hA2 := lintegral_treeSum_le α hα hn (r := r) hm hE hN T hTne S2 hS2T c
+  have hB1 := hK2o m hm E hE N hN top T hT S1 hS1T hS1 c ε μ hε hμ hc hmass
+  have hB2 := hK2t m (hνe.symm ▸ hm) E hE N hN top T hT S2 hS2T hS2 c ε μ hε hμ hc hsq hmass
+  rw [hνe] at hB2
+  have htot : ENNReal.ofReal (∑ P ∈ T, ‖a P‖ * ‖d P‖) ≤
+      ENNReal.ofReal ((2 * CK + Co + Ct) * Nm * ε * μ * top.vol α) := by
+    refine hmain.trans ?_
+    calc (∫⁻ x, ‖Fs S1 x‖ₑ) + ∫⁻ x, ‖Fs S2 x‖ₑ
+        ≤ (ENNReal.ofReal (CK * Nm * ε * μ * top.vol α) +
+            ENNReal.ofReal (Co * Nm * ε * μ * top.vol α)) +
+          (ENNReal.ofReal (CK * Nm * ε * μ * top.vol α) +
+            ENNReal.ofReal (Ct * Nm * ε * μ * top.vol α)) :=
+          add_le_add (hA1.trans (add_le_add hK1b hB1)) (hA2.trans (add_le_add hK1b hB2))
+      _ = _ := by
+          rw [← ENNReal.ofReal_add (by positivity) (by positivity),
+            ← ENNReal.ofReal_add (by positivity) (by positivity),
+            ← ENNReal.ofReal_add (by positivity) (by positivity)]
+          congr 1
+          ring
+  exact (ENNReal.ofReal_le_ofReal_iff (by positivity)).mp htot
+
+/-! ### The iteration (paper, (4.10)–(4.12)) -/
+
+theorem sum_biUnion_le_of_nonneg {ι β : Type*} [DecidableEq β] (s : Finset ι) (g : ι → Finset β)
+    (x : β → ℝ) (hx : ∀ b, 0 ≤ x b) :
+    ∑ b ∈ s.biUnion g, x b ≤ ∑ i ∈ s, ∑ b ∈ g i, x b := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simp
+  | insert i s hi ih =>
+    rw [Finset.biUnion_insert, Finset.sum_insert hi]
+    have h := Finset.sum_union_inter (s₁ := g i) (s₂ := s.biUnion g) (f := x)
+    have h0 : 0 ≤ ∑ b ∈ g i ∩ s.biUnion g, x b := Finset.sum_nonneg fun b _ => hx b
+    linarith
+
+/-- The energy is monotone in the collection. -/
+theorem energy_mono (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ) {S S' : Finset (Tile n)}
+    (h : S' ⊆ S) : energy α r f S' ≤ energy α r f S := by
+  unfold energy
+  exact iSup_mono fun top => iSup_mono fun T => iSup_le fun hT => le_iSup_of_le (hT.trans h) le_rfl
+
+/-- The energy of a finite collection is finite. -/
+theorem energy_le_of_finset (α : Fin n → ℕ) (r : Fin n → Fin 2) (f : Rn n → ℂ)
+    (S : Finset (Tile n)) :
+    energy α r f S ≤ ENNReal.ofReal (Real.sqrt ((∑ P ∈ S, (P.vol α)⁻¹) *
+      ∑ P ∈ S, ‖pairing f (wavePhi α P)‖ ^ 2)) := by
+  unfold energy
+  refine iSup_le fun top => iSup_le fun T => iSup_le fun hT => iSup_le fun h2 => ?_
+  refine ENNReal.ofReal_le_ofReal (Real.sqrt_le_sqrt ?_)
+  rcases T.eq_empty_or_nonempty with hT0 | ⟨P₀, hP₀⟩
+  · subst hT0
+    simp only [Finset.sum_empty, mul_zero]
+    exact mul_nonneg (Finset.sum_nonneg fun P _ => (inv_pos.mpr (P.vol_pos α)).le)
+      (Finset.sum_nonneg fun P _ => by positivity)
+  · have hvol : P₀.vol α ≤ top.vol α := by
+      have h := measure_mono (μ := volume) (h2.1 P₀ hP₀).1
+      rw [Tile.volume_I, Tile.volume_I] at h
+      exact (ENNReal.ofReal_le_ofReal_iff (top.vol_pos α).le).mp h
+    have h1 : (top.vol α)⁻¹ ≤ ∑ P ∈ S, (P.vol α)⁻¹ :=
+      (inv_anti₀ (P₀.vol_pos α) hvol).trans (Finset.single_le_sum
+        (f := fun P => (P.vol α)⁻¹) (fun P _ => (inv_pos.mpr (P.vol_pos α)).le) (hT hP₀))
+    have h2' : ∑ P ∈ T, ‖pairing f (wavePhi α P)‖ ^ 2 ≤ ∑ P ∈ S, ‖pairing f (wavePhi α P)‖ ^ 2 :=
+      Finset.sum_le_sum_of_subset_of_nonneg hT fun P _ _ => by positivity
+    exact mul_le_mul h1 h2' (Finset.sum_nonneg fun P _ => by positivity)
+      (Finset.sum_nonneg fun P _ => (inv_pos.mpr (P.vol_pos α)).le)
+
+/-- `∫ w^ν_P = ∫ w^ν`: the weights `w_P` are `L¹`-normalized. -/
+theorem lintegral_wP (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (hν : (absA α : ℝ) < ν)
+    (P : Tile n) :
+    ∫⁻ x, ENNReal.ofReal (wP α ν P x) = ENNReal.ofReal (∫ z : Rn n, (1 + rho α z) ^ (-ν)) := by
+  have ht : (0 : ℝ) < (2 : ℝ) ^ P.k := by positivity
+  have hv := P.vol_pos α
+  have hw : ∀ x, wP α ν P x =
+      (P.vol α)⁻¹ * (1 + ((2 : ℝ) ^ P.k)⁻¹ * rho α (x - P.cI α)) ^ (-ν) := by
+    intro x
+    rw [← vol_mul_wP α hα ν P x, inv_mul_cancel_left₀ hv.ne']
+  simp_rw [hw]
+  rw [← ofReal_integral_eq_lintegral_ofReal
+    ((integrable_wgt_scaled α hα hν ht _).const_mul _)
+    (Filter.Eventually.of_forall fun x => mul_nonneg (inv_pos.mpr hv).le
+      (Real.rpow_nonneg (by have := rho_nonneg α (x - P.cI α); positivity) _)),
+    integral_const_mul, integral_wgt_scaled α hα _ ht, ← mul_assoc]
+  congr 1
+  have : ((2 : ℝ) ^ P.k) ^ absA α = P.vol α := by
+    rw [Tile.vol, ← zpow_natCast, ← zpow_mul]
+  rw [this, inv_mul_cancel₀ hv.ne', one_mul]
+
+/-- The mass of a tile is bounded by the constant `∫ w^ν`. -/
+theorem massTile_le (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) {ν : ℝ} (hν : (absA α : ℝ) < ν)
+    (E : Set (Rn n)) (N : Rn n → Rn n) (P : Tile n) :
+    massTile α ν E N P ≤ ENNReal.ofReal (∫ z : Rn n, (1 + rho α z) ^ (-ν)) :=
+  iSup₂_le fun P' _ => (setLIntegral_le_lintegral _ _).trans (lintegral_wP α hα hν P').le
+
+/-- **One mass step** (paper, (4.10)): removing trees for the tiles of mass `> μ'` costs
+`C ‖m‖ ε μ |E| / μ'`. -/
+theorem mass_step (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : Rn n → ℂ) (N : Rn n → Rn n),
+      Measurable N → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (σ : Rn n → ℂ), Measurable σ → (∀ x, ‖σ x‖ ≤ 1) → ∀ (R : Finset (Tile n)) (ε μ μ' : ℝ),
+      0 ≤ ε → 0 ≤ μ → 0 < μ' → energy α r f R ≤ ENNReal.ofReal ε →
+      (∀ P ∈ R, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) →
+      ∃ R' ⊆ R, (∀ P ∈ R', massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ') ∧
+        ∑ P ∈ R, ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ ≤
+          ∑ P ∈ R', ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ +
+            C * (normM α ν m).toReal * ε * μ * (volume E).toReal / μ' := by
+  classical
+  obtain ⟨CT, hCT, htree⟩ := tree_estimate α hα hn hr ν hν
+  obtain ⟨CM, hCM, hmassL⟩ := mass_lemma α hα hn (ν := nu1 α) (by unfold nu1; linarith)
+  refine ⟨CT * CM, by positivity, fun m hm f N hN E hE hEfin σ hσ hσ1 R ε μ μ' hε hμ hμ' hEn
+    hmass => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set x : Tile n → ℝ := fun P => ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖
+  have hx : ∀ P, 0 ≤ x P := fun P => by positivity
+  obtain ⟨𝒯, h𝒯, hcov, hvol⟩ := hmassL E hE hEfin N hN R μ' hμ'
+  refine ⟨R.filter (fun P => massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ'),
+    Finset.filter_subset _ _, fun P hP => (Finset.mem_filter.mp hP).2, ?_⟩
+  rw [← Finset.sum_filter_add_sum_filter_not R
+    (fun P => massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ')]
+  refine add_le_add le_rfl ?_
+  have hsub : R.filter (fun P => ¬ massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ') ⊆
+      𝒯.biUnion (fun t => t.2) := fun P hP => by
+    obtain ⟨hPR, hPm⟩ := Finset.mem_filter.mp hP
+    obtain ⟨t, ht, hPt⟩ := hcov P hPR (not_le.mp hPm)
+    exact Finset.mem_biUnion.mpr ⟨t, ht, hPt⟩
+  calc ∑ P ∈ R with ¬ massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ', x P
+      ≤ ∑ P ∈ 𝒯.biUnion (fun t => t.2), x P :=
+        Finset.sum_le_sum_of_subset_of_nonneg hsub fun P _ _ => hx P
+    _ ≤ ∑ t ∈ 𝒯, ∑ P ∈ t.2, x P := sum_biUnion_le_of_nonneg _ _ _ hx
+    _ ≤ ∑ t ∈ 𝒯, CT * Nm * ε * μ * t.1.vol α := Finset.sum_le_sum fun t ht =>
+        htree m hm f N hN E hE hEfin σ hσ hσ1 t.1 t.2 (h𝒯 t ht).1 ε μ hε hμ
+          ((energy_mono α r f (h𝒯 t ht).2).trans hEn) (fun P hP => hmass P ((h𝒯 t ht).2 hP))
+    _ = CT * Nm * ε * μ * ∑ t ∈ 𝒯, t.1.vol α := by rw [Finset.mul_sum]
+    _ ≤ CT * Nm * ε * μ * (CM * (volume E).toReal / μ') := by gcongr
+    _ = _ := by ring
+
+/-- **One energy step** (paper, (4.11)): removing trees to halve the energy costs
+`C ‖m‖ μ ‖f‖₂² / ε'`. -/
+theorem energy_step (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (f : Rn n → ℂ), MemLp f 2 →
+      ∀ (N : Rn n → Rn n), Measurable N → ∀ (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∀ (σ : Rn n → ℂ), Measurable σ → (∀ x, ‖σ x‖ ≤ 1) → ∀ (R : Finset (Tile n)) (ε' μ : ℝ),
+      0 < ε' → 0 ≤ μ → energy α r f R ≤ ENNReal.ofReal (2 * ε') →
+      (∀ P ∈ R, massTile α (nu1 α) E N P ≤ ENNReal.ofReal μ) →
+      ∃ R' ⊆ R, energy α r f R' ≤ ENNReal.ofReal ε' ∧
+        ∑ P ∈ R, ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ ≤
+          ∑ P ∈ R', ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖ +
+            C * (normM α ν m).toReal * μ * (eLpNorm f 2 volume).toReal ^ 2 / ε' := by
+  classical
+  obtain ⟨CT, hCT, htree⟩ := tree_estimate α hα hn hr ν hν
+  obtain ⟨CE, hCE, henL⟩ := energy_lemma α hα hn hr
+  refine ⟨2 * CT * CE, by positivity, fun m hm f hf N hN E hE hEfin σ hσ hσ1 R ε' μ hε' hμ hEn
+    hmass => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set x : Tile n → ℝ := fun P => ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖
+  have hx : ∀ P, 0 ≤ x P := fun P => by positivity
+  obtain ⟨𝒯, Slow, hSlow, h𝒯, hcov, hElow, hvol⟩ := henL f hf R ε' hε' hEn
+  refine ⟨Slow, hSlow, hElow, ?_⟩
+  rw [← Finset.sum_sdiff hSlow, add_comm]
+  refine add_le_add le_rfl ?_
+  have hsub : R \ Slow ⊆ 𝒯.biUnion (fun t => t.2) := fun P hP => by
+    obtain ⟨hPR, hPS⟩ := Finset.mem_sdiff.mp hP
+    rcases hcov P hPR with h | ⟨t, ht, hPt⟩
+    · exact absurd h hPS
+    · exact Finset.mem_biUnion.mpr ⟨t, ht, hPt⟩
+  set F := (eLpNorm f 2 volume).toReal ^ 2
+  calc ∑ P ∈ R \ Slow, x P
+      ≤ ∑ P ∈ 𝒯.biUnion (fun t => t.2), x P :=
+        Finset.sum_le_sum_of_subset_of_nonneg hsub fun P _ _ => hx P
+    _ ≤ ∑ t ∈ 𝒯, ∑ P ∈ t.2, x P := sum_biUnion_le_of_nonneg _ _ _ hx
+    _ ≤ ∑ t ∈ 𝒯, CT * Nm * (2 * ε') * μ * t.1.vol α := Finset.sum_le_sum fun t ht =>
+        htree m hm f N hN E hE hEfin σ hσ hσ1 t.1 t.2 (h𝒯 t ht).1 (2 * ε') μ (by positivity) hμ
+          ((energy_mono α r f (h𝒯 t ht).2).trans hEn) (fun P hP => hmass P ((h𝒯 t ht).2 hP))
+    _ = CT * Nm * (2 * ε') * μ * ∑ t ∈ 𝒯, t.1.vol α := by rw [Finset.mul_sum]
+    _ ≤ CT * Nm * (2 * ε') * μ * (CE * F / ε' ^ 2) := by gcongr
+    _ = _ := by field_simp
+
+/-- **The key estimate (4.1)** (paper, §4, (4.10)–(4.12)): for `ν ≥ 3|α| + 2` there is `K₀` with
+`KeyEstimate α r m (K₀ ‖m‖_{𝓜^ν})` for every `m ∈ 𝓜^ν`. The collection is exhausted by first
+halving the energy down to `1` (energy steps at mass level `M = 1 + ∫ w^{ν₁}`), then alternately
+reducing the mass by `4` and the energy by `2`. -/
+theorem keyEstimate_of_classM (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n)
+    {r : Fin n → Fin 2} (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ K₀ : ℝ, 0 ≤ K₀ ∧ ∀ (m : Rn n → ℂ), ClassM α ν m →
+      KeyEstimate α r m (K₀ * (normM α ν m).toReal) := by
+  classical
+  obtain ⟨Cm, hCm, hmstep⟩ := mass_step α hα hn hr ν hν
+  obtain ⟨Ce, hCe, hestep⟩ := energy_step α hα hn hr ν hν
+  have hν1 : (absA α : ℝ) < nu1 α := by unfold nu1; linarith
+  set G0 : ℝ := ∫ z : Rn n, (1 + rho α z) ^ (-(nu1 α))
+  have hG0 : 0 ≤ G0 := integral_nonneg fun z => Real.rpow_nonneg
+    (by have := rho_nonneg α z; positivity) _
+  set Mw : ℝ := G0 + 1
+  have hMw : 0 < Mw := by positivity
+  refine ⟨8 * Cm + 4 * Ce * Mw, by positivity, fun m hm f hf N hN E hE hEfin σ hσ hσ1 S => ?_⟩
+  set Nm := (normM α ν m).toReal
+  have hNm : 0 ≤ Nm := ENNReal.toReal_nonneg
+  set x : Tile n → ℝ := fun P => ‖pairing f (wavePhi α P)‖ * ‖dualTerm α m r N E σ P‖
+  have hx : ∀ P, 0 ≤ x P := fun P => by positivity
+  set V := (volume E).toReal
+  have hV : 0 ≤ V := ENNReal.toReal_nonneg
+  set F := (eLpNorm f 2 volume).toReal ^ 2
+  have hF : 0 ≤ F := by positivity
+  have hmassb : ∀ P, massTile α (nu1 α) E N P ≤ ENNReal.ofReal Mw := fun P =>
+    (massTile_le α hα hν1 E N P).trans (ENNReal.ofReal_le_ofReal (by linarith))
+  -- phase 1: energy steps down to energy `≤ 1`
+  set A := Ce * Nm * Mw * F
+  have hA : 0 ≤ A := by positivity
+  obtain ⟨p, hp⟩ := pow_unbounded_of_one_lt (Real.sqrt ((∑ P ∈ S, (P.vol α)⁻¹) *
+    ∑ P ∈ S, ‖pairing f (wavePhi α P)‖ ^ 2)) (by norm_num : (1 : ℝ) < 2)
+  have hES : energy α r f S ≤ ENNReal.ofReal (2 ^ p) :=
+    (energy_le_of_finset α r f S).trans (ENNReal.ofReal_le_ofReal hp.le)
+  have hph1 : ∀ i ≤ p, ∃ R ⊆ S, energy α r f R ≤ ENNReal.ofReal (2 ^ (p - i)) ∧
+      ∑ P ∈ S, x P ≤ ∑ P ∈ R, x P + 2 * A * ((2 : ℝ) ^ (p - i))⁻¹ := by
+    intro i
+    induction i with
+    | zero =>
+      intro _
+      refine ⟨S, subset_rfl, by simpa using hES, ?_⟩
+      have : 0 ≤ 2 * A * ((2 : ℝ) ^ (p - 0))⁻¹ := by positivity
+      linarith
+    | succ i ih =>
+      intro hi
+      obtain ⟨R, hRS, hRE, hRx⟩ := ih (by omega)
+      have hpi : p - i = p - (i + 1) + 1 := by omega
+      set q := p - (i + 1)
+      have hRE' : energy α r f R ≤ ENNReal.ofReal (2 * 2 ^ q) := by
+        rw [hpi, pow_succ, mul_comm] at hRE; exact hRE
+      obtain ⟨R', hR'R, hR'E, hR'x⟩ := hestep m hm f hf N hN E hE hEfin σ hσ hσ1 R (2 ^ q) Mw
+        (by positivity) hMw.le hRE' (fun P _ => hmassb P)
+      refine ⟨R', hR'R.trans hRS, hR'E, ?_⟩
+      rw [hpi] at hRx
+      have e : Ce * Nm * Mw * F / 2 ^ q = A * ((2 : ℝ) ^ q)⁻¹ := by
+        simp only [A]; rw [div_eq_mul_inv]
+      have e2 : 2 * A * ((2 : ℝ) ^ (q + 1))⁻¹ = A * ((2 : ℝ) ^ q)⁻¹ := by
+        rw [pow_succ, mul_inv]; ring
+      rw [e] at hR'x
+      rw [e2] at hRx
+      linarith only [hRx, hR'x]
+  obtain ⟨R1, hR1S, hR1E, hR1x⟩ := hph1 p le_rfl
+  simp only [Nat.sub_self, pow_zero, inv_one, mul_one] at hR1E hR1x
+  -- phase 2: alternate mass and energy steps
+  set B := 4 * Cm * Nm * V + Ce * Nm * Mw * F
+  have hB : 0 ≤ B := by positivity
+  have hph2 : ∀ j : ℕ, ∃ R ⊆ S, (∀ P ∈ R, massTile α (nu1 α) E N P ≤
+      ENNReal.ofReal (Mw * ((4 : ℝ) ^ j)⁻¹)) ∧ energy α r f R ≤ ENNReal.ofReal (((2 : ℝ) ^ j)⁻¹) ∧
+      ∑ P ∈ S, x P ≤ ∑ P ∈ R, x P + 2 * A + 2 * B * (1 - ((2 : ℝ) ^ j)⁻¹) := by
+    intro j
+    induction j with
+    | zero =>
+      refine ⟨R1, hR1S, fun P _ => by simpa using hmassb P, by simpa using hR1E, ?_⟩
+      simp only [pow_zero, inv_one, sub_self, mul_zero, add_zero]
+      exact hR1x
+    | succ j ih =>
+      obtain ⟨R, hRS, hRm, hRE, hRx⟩ := ih
+      have h4 : (0 : ℝ) < (4 : ℝ) ^ j := by positivity
+      have h2 : (0 : ℝ) < (2 : ℝ) ^ j := by positivity
+      obtain ⟨R', hR'R, hR'm, hR'x⟩ := hmstep m hm f N hN E hE hEfin σ hσ hσ1 R
+        ((2 : ℝ) ^ j)⁻¹ (Mw * ((4 : ℝ) ^ j)⁻¹) (Mw * ((4 : ℝ) ^ (j + 1))⁻¹) (by positivity)
+        (by positivity) (by positivity) hRE hRm
+      have hR'E : energy α r f R' ≤ ENNReal.ofReal (2 * ((2 : ℝ) ^ (j + 1))⁻¹) := by
+        refine (energy_mono α r f hR'R).trans (hRE.trans (le_of_eq ?_))
+        congr 1; rw [pow_succ, mul_inv]; ring
+      obtain ⟨R'', hR''R', hR''E, hR''x⟩ := hestep m hm f hf N hN E hE hEfin σ hσ hσ1 R'
+        ((2 : ℝ) ^ (j + 1))⁻¹ (Mw * ((4 : ℝ) ^ (j + 1))⁻¹) (by positivity) (by positivity)
+        hR'E hR'm
+      refine ⟨R'', (hR''R'.trans hR'R).trans hRS, fun P hP => hR'm P (hR''R' hP), hR''E, ?_⟩
+      have c1 : Cm * Nm * ((2 : ℝ) ^ j)⁻¹ * (Mw * ((4 : ℝ) ^ j)⁻¹) * V /
+          (Mw * ((4 : ℝ) ^ (j + 1))⁻¹) = 4 * Cm * Nm * V * ((2 : ℝ) ^ j)⁻¹ := by
+        rw [pow_succ]; field_simp
+      have c2 : Ce * Nm * (Mw * ((4 : ℝ) ^ (j + 1))⁻¹) * F / ((2 : ℝ) ^ (j + 1))⁻¹ =
+          Ce * Nm * Mw * F * ((2 : ℝ) ^ j)⁻¹ / 2 := by
+        rw [show (4 : ℝ) ^ (j + 1) = (2 : ℝ) ^ (j + 1) * (2 : ℝ) ^ (j + 1) by
+          rw [← mul_pow]; norm_num]
+        rw [pow_succ]; field_simp
+      have c3 : 2 * B * (1 - ((2 : ℝ) ^ (j + 1))⁻¹) =
+          2 * B * (1 - ((2 : ℝ) ^ j)⁻¹) + B * ((2 : ℝ) ^ j)⁻¹ := by
+        rw [pow_succ, mul_inv]; ring
+      rw [c1] at hR'x
+      rw [c2] at hR''x
+      have : 0 ≤ Ce * Nm * Mw * F * ((2 : ℝ) ^ j)⁻¹ := by positivity
+      simp only [B] at c3 ⊢
+      nlinarith only [hRx, hR'x, hR''x, c3, this]
+  -- the remaining tiles contribute at most `2^{-j} Z`
+  set Z := ∑ P ∈ S, ((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ‖dualTerm α m r N E σ P‖
+  have hZ : 0 ≤ Z := Finset.sum_nonneg fun P _ => by positivity
+  have hfin : ∀ j : ℕ, ∑ P ∈ S, x P ≤ 2 * A + 2 * B + ((2 : ℝ) ^ j)⁻¹ * Z := by
+    intro j
+    obtain ⟨R, hRS, _, hRE, hRx⟩ := hph2 j
+    have hRZ : ∑ P ∈ R, x P ≤ ((2 : ℝ) ^ j)⁻¹ * Z := by
+      rw [Finset.mul_sum]
+      calc ∑ P ∈ R, x P ≤ ∑ P ∈ R, ((2 : ℝ) ^ j)⁻¹ *
+            (((2 : ℝ) ^ P.k) ^ ((absA α : ℝ) / 2) * ‖dualTerm α m r N E σ P‖) :=
+            Finset.sum_le_sum fun P hP => by
+              rw [← mul_assoc]
+              exact mul_le_mul_of_nonneg_right
+                (norm_pairing_le_of_energy_le α (by positivity) hRE hP) (norm_nonneg _)
+        _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg hRS fun P _ _ => by positivity
+    have : 0 ≤ 2 * B * ((2 : ℝ) ^ j)⁻¹ := by positivity
+    nlinarith only [hRx, hRZ, this]
+  have hlim : ∑ P ∈ S, x P ≤ 2 * A + 2 * B := by
+    refine le_of_forall_pos_le_add fun δ hδ => ?_
+    obtain ⟨j, hj⟩ := exists_pow_lt_of_lt_one (show 0 < δ / (Z + 1) by positivity)
+      (by norm_num : (1 / 2 : ℝ) < 1)
+    have h1 : ((2 : ℝ) ^ j)⁻¹ * Z ≤ δ := by
+      rw [← one_div, ← one_div_pow]
+      calc (1 / 2 : ℝ) ^ j * Z ≤ δ / (Z + 1) * Z := by gcongr
+        _ ≤ δ := by
+          rw [div_mul_eq_mul_div, div_le_iff₀ (by positivity)]; nlinarith
+    exact (hfin j).trans (add_le_add_right h1 (2 * A + 2 * B))
+  calc ∑ P ∈ S, x P ≤ 2 * A + 2 * B := hlim
+    _ = Nm * (8 * Cm * V + 4 * Ce * Mw * F) := by simp only [A, B]; ring
+    _ ≤ Nm * ((8 * Cm + 4 * Ce * Mw) * (V + F)) := by
+        gcongr
+        nlinarith only [mul_nonneg hCm hF, mul_nonneg (mul_nonneg hCe hMw.le) hV]
+    _ = _ := by ring
+
+/-- **Theorem 3.2** (paper, (3.4), texline~199–204), in the form used for Theorem 1.1: for
+`ν ≥ 3|α| + 2` there is `C` such that for all `m ∈ 𝓜^ν`, Schwartz `g`, finite frequency sets `F`
+and measurable `E` of finite measure,
+`∫_E max_{N ∈ F} |A^{r,m}_N g| ≤ C ‖m‖_{𝓜^ν} |E|^{1/2} ‖g‖₂`
+(this implies `‖sup_N |A_N g|‖_{2,∞} ≤ C ‖m‖ ‖g‖₂` over countable frequency sets). -/
+theorem thm_3_2 (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) {r : Fin n → Fin 2}
+    (hr : r ≠ 0) (ν : ℕ) (hν : 3 * absA α + 2 ≤ ν) :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (m : Rn n → ℂ), ClassM α ν m → ∀ (g : 𝓢(Rn n, ℂ)) (F : Finset (Rn n))
+      (hF : F.Nonempty) (E : Set (Rn n)), MeasurableSet E → volume E < ⊤ →
+      ∫ x in E, F.sup' hF (fun N => ‖modelOpHO α r m N g x‖) ≤
+        C * (normM α ν m).toReal * Real.sqrt (volume E).toReal *
+          (eLpNorm (g : Rn n → ℂ) 2).toReal := by
+  obtain ⟨K₀, hK₀, hK⟩ := keyEstimate_of_classM α hα hn hr ν hν
+  refine ⟨2 * K₀, by positivity, fun m hm g F hF E hE hEfin => ?_⟩
+  have h := thm_3_2_of_key α hα hr (hm.mono (by omega)) (hK m hm) g F hF hE hEfin
+  calc _ ≤ _ := h
+    _ = _ := by ring
+
+end CarlesonLT.Auto
diff --git a/LeanPool/CarlesonLT/Auto/ParametricIntegralContDiff.lean b/LeanPool/CarlesonLT/Auto/ParametricIntegralContDiff.lean
new file mode 100644
index 0000000000..27d3bdb5af
--- /dev/null
+++ b/LeanPool/CarlesonLT/Auto/ParametricIntegralContDiff.lean
@@ -0,0 +1,151 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Proofs generated by Claude under Joris Roos’s supervision; adapted for Lean Pool. -/
+
+public import Mathlib.Analysis.Calculus.ContDiff.Comp
+public import Mathlib.Analysis.Calculus.ParametricIntegral
+public import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
+
+/-!
+# Smoothness of parametric integrals (the higher-order Leibniz integral rule)
+
+**Theorem (Leibniz integral rule, `C^k` version).** Let `E` be a finite-dimensional real normed
+space and `F` a real normed space, let `Φ : E × ℝ → F` be `C^k` (jointly), and suppose that
+    there is a compact set `K ⊆ ℝ`
+such that `Φ (x, t) = 0` whenever `t ∉ K`. Then the parametric integral
+`x ↦ ∫ t, Φ (x, t) dt` is `C^k` on `E`, and its derivative is obtained by differentiating under
+the integral sign.
+
+The first-order case is Mathlib's `hasFDerivAt_integral_of_dominated_of_fderiv_le`; the general
+case follows by induction on `k`, since the partial derivative `∂ₓΦ` is `C^{k-1}` and vanishes for
+`t ∉ K` as well.
+
+## References
+
+* Leibniz integral rule (differentiation under the integral sign):
+  <https://en.wikipedia.org/wiki/Leibniz_integral_rule>.
+* Mathlib: `hasFDerivAt_integral_of_dominated_of_fderiv_le` in
+  `Mathlib/Analysis/Calculus/ParametricIntegral.lean` (first-order version).
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open MeasureTheory Set Metric
+
+namespace CarlesonLT.Auto
+
+universe u
+
+variable {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+
+/-- The partial derivative in the parameter variable: `∂ₓΦ(x, t) = DΦ(x, t) ∘ (v ↦ (v, 0))`. -/
+def partialFst {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F] (Φ : E × ℝ → F)
+    (p : E × ℝ) : E →L[ℝ] F :=
+  (fderiv ℝ Φ p).comp (ContinuousLinearMap.inl ℝ E ℝ)
+
+omit [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] in
+theorem integral_eq_setIntegral_of_vanish {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} {K : Set ℝ} (hsupp : ∀ x t, t ∉ K → Φ (x, t) = 0) (x : E) :
+    ∫ t, Φ (x, t) = ∫ t in K, Φ (x, t) :=
+  (setIntegral_eq_integral_of_forall_compl_eq_zero fun t ht => hsupp x t ht).symm
+
+/-- Order `0`: the parametric integral of a continuous function vanishing off a compact set is
+continuous. -/
+theorem continuous_integral_of_vanish {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} (hΦ : Continuous Φ) {K : Set ℝ} (hK : IsCompact K)
+    (hsupp : ∀ x t, t ∉ K → Φ (x, t) = 0) : Continuous fun x => ∫ t, Φ (x, t) := by
+  have : (fun x => ∫ t, Φ (x, t)) = fun x => ∫ t in K, Φ (x, t) :=
+    funext (integral_eq_setIntegral_of_vanish hsupp)
+  rw [this]
+  exact continuous_parametric_integral_of_continuous (f := fun x t => Φ (x, t))
+    (hΦ.comp continuous_id) hK
+
+omit [FiniteDimensional ℝ E] in
+theorem partialFst_vanish {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} {K : Set ℝ} (hK : IsClosed K) (hsupp : ∀ x t, t ∉ K → Φ (x, t) = 0)
+    (x : E) {t : ℝ} (ht : t ∉ K) : partialFst Φ (x, t) = 0 := by
+  have hloc : Φ =ᶠ[nhds (x, t)] fun _ => 0 := by
+    have hopen : IsOpen {p : E × ℝ | p.2 ∉ K} := hK.isOpen_compl.preimage continuous_snd
+    filter_upwards [hopen.mem_nhds ht] with p hp
+    exact hsupp p.1 p.2 hp
+  unfold partialFst
+  rw [hloc.fderiv_eq, fderiv_const_apply, ContinuousLinearMap.zero_comp]
+
+omit [FiniteDimensional ℝ E] in
+theorem hasFDerivAt_partialFst {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} (hΦ : Differentiable ℝ Φ) (x : E) (t : ℝ) :
+    HasFDerivAt (fun y => Φ (y, t)) (partialFst Φ (x, t)) x := by
+  have h1 : HasFDerivAt (fun y : E => (y, t)) (ContinuousLinearMap.inl ℝ E ℝ) x :=
+    hasFDerivAt_prodMk_left x t
+  exact (hΦ (x, t)).hasFDerivAt.comp x h1
+
+/-- The inductive step: differentiation under the integral sign. -/
+theorem hasFDerivAt_integral_of_vanish {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} (hΦ : ContDiff ℝ 1 Φ) {K : Set ℝ} (hK : IsCompact K)
+    (hsupp : ∀ x t, t ∉ K → Φ (x, t) = 0) (x₀ : E) :
+    HasFDerivAt (fun x => ∫ t, Φ (x, t)) (∫ t, partialFst Φ (x₀, t)) x₀ := by
+  have hdiff : Differentiable ℝ Φ := hΦ.differentiable one_ne_zero
+  have hcont' : Continuous (partialFst Φ) :=
+    ((hΦ.continuous_fderiv one_ne_zero).clm_comp continuous_const)
+  -- a uniform bound for the partial derivative on `closedBall x₀ 1 × K`
+  have hcpt : IsCompact (closedBall x₀ 1 ×ˢ K) := (isCompact_closedBall x₀ 1).prod hK
+  obtain ⟨C, hC⟩ := hcpt.exists_bound_of_continuousOn hcont'.continuousOn
+  have hbound : ∀ t, ∀ x ∈ ball x₀ 1, ‖partialFst Φ (x, t)‖ ≤ K.indicator (fun _ => C) t := by
+    intro t x hx
+    by_cases ht : t ∈ K
+    · rw [indicator_of_mem ht]
+      exact hC (x, t) ⟨ball_subset_closedBall hx, ht⟩
+    · rw [indicator_of_notMem ht, partialFst_vanish hK.isClosed hsupp x ht, norm_zero]
+  have hint : ∀ x, Integrable fun t => Φ (x, t) := by
+    intro x
+    have hc : Continuous fun t => Φ (x, t) := hΦ.continuous.comp (Continuous.prodMk_right x)
+    refine hc.integrable_of_hasCompactSupport (HasCompactSupport.intro hK fun t ht => hsupp x t ht)
+  refine hasFDerivAt_integral_of_dominated_of_fderiv_le (ball_mem_nhds x₀ one_pos)
+    (Filter.Eventually.of_forall fun x => (hint x).aestronglyMeasurable) (hint x₀)
+    (hcont'.comp (Continuous.prodMk_right x₀)).aestronglyMeasurable
+    (Filter.Eventually.of_forall fun t x hx => hbound t x hx)
+    ((integrableOn_const hK.measure_lt_top.ne).integrable_indicator hK.measurableSet)
+    (Filter.Eventually.of_forall fun t x _ => hasFDerivAt_partialFst hdiff x t)
+
+omit [FiniteDimensional ℝ E] in
+theorem contDiff_partialFst {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} {n : ℕ} (hΦ : ContDiff ℝ (n + 1) Φ) : ContDiff ℝ n (partialFst Φ) := by
+  unfold partialFst
+  exact (hΦ.fderiv_right (by norm_cast)).clm_comp contDiff_const
+
+/-- **Leibniz integral rule, finite order.** If `Φ : E × ℝ → F` is `C^n` and vanishes for `t`
+outside a compact set `K`, then `x ↦ ∫ Φ(x, t) dt` is `C^n`. -/
+theorem contDiff_integral_of_vanish_nat (n : ℕ) :
+    ∀ {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F] {Φ : E × ℝ → F},
+      ContDiff ℝ n Φ → ∀ {K : Set ℝ}, IsCompact K → (∀ x t, t ∉ K → Φ (x, t) = 0) →
+        ContDiff ℝ n fun x => ∫ t, Φ (x, t) := by
+  induction n with
+  | zero =>
+    intro F _ _ Φ hΦ K hK hsupp
+    rw [Nat.cast_zero, contDiff_zero] at hΦ ⊢
+    exact continuous_integral_of_vanish hΦ hK hsupp
+  | succ n ih =>
+    intro F _ _ Φ hΦ K hK hsupp
+    rw [Nat.cast_succ, contDiff_succ_iff_hasFDerivAt]
+    refine ⟨fun x => ∫ t, partialFst Φ (x, t), ?_, fun x =>
+      hasFDerivAt_integral_of_vanish (hΦ.of_le (by exact_mod_cast Nat.le_add_left 1 n)) hK hsupp x⟩
+    exact ih (contDiff_partialFst hΦ) hK fun x t ht => partialFst_vanish hK.isClosed hsupp x ht
+
+/-- **Leibniz integral rule, `C^∞` version.** If `Φ : E × ℝ → F` is smooth and vanishes for `t`
+outside a compact set `K`, then `x ↦ ∫ Φ(x, t) dt` is smooth. -/
+theorem contDiff_integral_of_vanish {F : Type u} [NormedAddCommGroup F] [NormedSpace ℝ F]
+    {Φ : E × ℝ → F} (hΦ : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) Φ) {K : Set ℝ}
+        (hK : IsCompact K)
+    (hsupp : ∀ x t, t ∉ K → Φ (x, t) = 0) :
+    ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) fun x => ∫ t, Φ (x, t) :=
+  contDiff_infty.mpr fun n =>
+    contDiff_integral_of_vanish_nat n (hΦ.of_le (by exact_mod_cast le_top)) hK hsupp
+
+end CarlesonLT.Auto
diff --git a/LeanPool/CarlesonLT/Defs.lean b/LeanPool/CarlesonLT/Defs.lean
new file mode 100644
index 0000000000..e9bbf30711
--- /dev/null
+++ b/LeanPool/CarlesonLT/Defs.lean
@@ -0,0 +1,69 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+public import Mathlib.Analysis.Fourier.AddCircle
+public import Mathlib.Analysis.Fourier.FourierTransform
+public import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
+
+/-!
+
+Definition of Fourier partial sums, multiplier class, and Carleson operator.
+
+-/
+
+@[expose] public noncomputable section
+
+namespace CarlesonLT
+
+open Real Complex Finset ENNReal MeasureTheory Set EuclideanSpace
+open scoped InnerProductSpace FourierTransform
+
+/-- The partial sums `S_N f(x) = ∑_{k = -N}^{N} f̂(k) e^{ikx}` of the Fourier series. -/
+def fourierPartialSum (f : ℝ → ℂ) (N : ℕ) (x : ℝ) : ℂ :=
+  ∑ n ∈ Finset.Icc (-(N : ℤ)) N,
+    fourierCoeffOn two_pi_pos f n * fourier n (x : AddCircle (2 * π))
+
+@[inherit_doc EuclideanSpace]
+scoped notation "ℝ^" n:max => EuclideanSpace ℝ (Fin n)
+
+variable {n : ℕ}
+
+/-- The Carleson operator associated with a multiplier `m`. Note
+we use Mathlib's Fourier transform convention here with the `2*π` in the exponent.
+This does not affect boundedness statements. -/
+def carlesonOperator (m : ℝ^n → ℂ) (f : ℝ^n → ℂ) (x : ℝ^n) : ℝ≥0∞ :=
+  ⨆ N : ℝ^n, ‖∫ ξ, 𝓕 f ξ * 𝐞 (⟪x, ξ⟫_ℝ) * m (ξ - N)‖ₑ
+
+/-- The weak `L²` quasinorm `‖g‖_{2,∞} = sup_{t > 0} t |{x : |g(x)| > t}|^{1/2}`. -/
+def weakL2Norm {X : Type*} [MeasurableSpace X] (μ : Measure X) (g : X → ℝ≥0∞) : ℝ≥0∞ :=
+  ⨆ t : ℝ≥0∞, t * μ {x | t < g x} ^ (2⁻¹ : ℝ)
+
+/-- Anisotropic dilations `δ_λ x = (λ^{α₁} x₁, …, λ^{αₙ} xₙ)` -/
+def anisoDil (α : Fin n → ℕ) (t : ℝ) (x : ℝ^n) : ℝ^n :=
+  WithLp.toLp 2 (fun i ↦ t ^ α i * x i)
+
+/-- The anisotropic norm `ρ(x) = max {|xᵢ|^{1/αᵢ} : i = 1, …, n}` -/
+def anisoNorm (α : Fin n → ℕ) (x : ℝ^n) : ℝ := ⨆ i, |x i| ^ ((α i)⁻¹ : ℝ)
+
+/-- Bounded, `ν` times continuously differentiable,
+anisotropically homogeneous multipliers -/
+structure MultiplierClass (α : Fin n → ℕ) (ν : ℕ) (m : ℝ^n → ℂ) : Prop where
+  bounded : ∃ C : ℝ, ∀ ξ, ‖m ξ‖ ≤ C
+  contDiffOn : ContDiffOn ℝ ν m {0}ᶜ
+  homogeneous : ∀ ξ, ξ ≠ 0 → ∀ t : ℝ, 0 < t → m (anisoDil α t ξ) = m ξ
+
+/-- Multiplier norm
+`‖m‖_{𝓜^ν} = sup_{|β| ≤ ν} sup_{ρ(ξ)=1} |∂^β m(ξ)|`, where `∂^β m(ξ)`
+with `|β| = k` is the `k`-th derivative of `m`
+evaluated at standard basis vectors `e_{i₁}, …, e_{i_k}`. -/
+def multiplierNorm (α : Fin n → ℕ) (ν : ℕ) (m : ℝ^n → ℂ) : ℝ≥0∞ :=
+  ⨆ (k ≤ ν) (i : Fin k → Fin n) (ξ : ℝ^n) (_ : anisoNorm α ξ = 1),
+    ‖iteratedFDeriv ℝ k m ξ (fun j ↦ single (i j) 1)‖ₑ
+
+end CarlesonLT
+
+end
diff --git a/LeanPool/CarlesonLT/Imports.lean b/LeanPool/CarlesonLT/Imports.lean
new file mode 100644
index 0000000000..efec6dab3f
--- /dev/null
+++ b/LeanPool/CarlesonLT/Imports.lean
@@ -0,0 +1,16 @@
+/-
+Copyright (c) 2026 Lean Pool contributors. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Lean Pool contributors
+-/
+module  -- shake: keep-all --deprecated_module: ignore
+
+-- Generated project imports; run `lake exe mk_all`.
+public import LeanPool.CarlesonLT
+public import LeanPool.CarlesonLT.Auto.AnisotropicCarleson
+public import LeanPool.CarlesonLT.Auto.ClassicalCarleson
+public import LeanPool.CarlesonLT.Auto.HardyLittlewoodMaximal
+public import LeanPool.CarlesonLT.Auto.ModelOperator
+public import LeanPool.CarlesonLT.Auto.ParametricIntegralContDiff
+public import LeanPool.CarlesonLT.Defs
+public import LeanPool.CarlesonLT.Theorems
diff --git a/LeanPool/CarlesonLT/Theorems.lean b/LeanPool/CarlesonLT/Theorems.lean
new file mode 100644
index 0000000000..e379e6c884
--- /dev/null
+++ b/LeanPool/CarlesonLT/Theorems.lean
@@ -0,0 +1,44 @@
+/-
+Copyright (c) 2026 Joris Roos. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joris Roos
+-/
+module
+
+/- Adapted for Lean Pool from roos-j/lean-lt-carleson. -/
+
+public import LeanPool.CarlesonLT.Defs
+public import Mathlib.Analysis.Distribution.SchwartzSpace.Basic
+import LeanPool.CarlesonLT.Auto.ClassicalCarleson
+
+/-!
+This file contains the statements of the main theorems:
+`anisotropic_carleson` and `classical_carleson`
+-/
+
+@[expose] public section
+
+namespace CarlesonLT
+
+open CarlesonLT
+open MeasureTheory Filter Topology Function Real Set SchwartzMap
+
+variable {n : ℕ}
+
+/-- Theorem 1.1 of `arXiv:1710.10962` proving a weak (2,2) a priori bound for
+Carleson operators associated with anisotropic multipliers on `ℝ^n`. -/
+theorem anisotropic_carleson (α : Fin n → ℕ) (hα : ∀ i, 1 ≤ α i) (hn : 0 < n) (ν₀ : ℕ)
+    (hν₀ : 3 * (∑ i, α i) + 2 ≤ ν₀) :
+      ∃ C : ℝ, 0 < C ∧ ∀ (m : ℝ^n → ℂ), MultiplierClass α ν₀ m → ∀ f : 𝓢(ℝ^n, ℂ),
+        weakL2Norm volume (carlesonOperator m f) ≤
+          ENNReal.ofReal C * (multiplierNorm α ν₀ m) * eLpNorm f 2 volume :=
+  Auto.anisotropic_carleson α hα hn ν₀ hν₀
+
+/-- **Carleson's theorem.** The Fourier series of a `2π`-periodic `L²` function
+on `ℝ` converges pointwise almost everywhere. -/
+theorem classical_carleson (f : ℝ → ℂ) (hper : Periodic f (2 * π))
+    (hf : MemLp f 2 (volume.restrict (Ico 0 (2 * π)))) :
+    ∀ᵐ x, Tendsto (fun N ↦ fourierPartialSum f N x) atTop (𝓝 (f x)) :=
+  Auto.classical_carleson f hper hf
+
+end CarlesonLT
diff --git a/LeanPool/projects/carleson-lacey-thiele.yaml b/LeanPool/projects/carleson-lacey-thiele.yaml
new file mode 100644
index 0000000000..5b3a7ce1fa
--- /dev/null
+++ b/LeanPool/projects/carleson-lacey-thiele.yaml
@@ -0,0 +1,41 @@
+slug: carleson-lacey-thiele
+title: Anisotropic Carleson bounds and almost-everywhere Fourier convergence
+summary: >-
+  Weak (2,2) bounds for maximally modulated anisotropically homogeneous smooth
+  multipliers on Euclidean space, following the Lacey–Thiele time-frequency method,
+  and almost-everywhere convergence of the Fourier series of periodic L² functions.
+branch: harmonic analysis
+entry_module: LeanPool.CarlesonLT
+authors:
+- Joris Roos
+source:
+  url: https://github.com/roos-j/lean-lt-carleson
+  github_repo: roos-j/lean-lt-carleson
+  commit: a83052776113c6417432c594a29b98f3500091a4
+  arxiv: '1710.10962'
+  doi: 10.1007/s00041-018-09657-7
+license: Apache-2.0
+status: verified
+provenance: AI
+main_declarations:
+- CarlesonLT.anisotropic_carleson
+- CarlesonLT.classical_carleson
+main_results:
+- declaration: CarlesonLT.anisotropic_carleson
+  informal: >-
+    For positive integer anisotropies and sufficient multiplier smoothness, the
+    associated maximally modulated multiplier operator obeys a weak L² bound on
+    Schwartz functions, with a constant independent of the multiplier and function.
+- declaration: CarlesonLT.classical_carleson
+  informal: >-
+    The symmetric Fourier partial sums of a 2π-periodic function that is square
+    integrable on one period converge to the function almost everywhere on the real line.
+tags:
+- harmonic-analysis
+- fourier-series
+- time-frequency-analysis
+- maximal-operators
+msc:
+- 42A20
+- 42B20
+- 42B25