Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec152TorusNormsFourierTests

Section 15.2: Torus norms and Fourier tests #

This file was automatically generated by Claude.

Formalization of blueprint Section 15, "Common heights and concentration of the core terms" (sec:core), subsection 2, "Torus norms and Fourier tests" (lines 2482-2583) of blueprint/formalization_blueprint.tex.

Torus norms and Fourier tests (blueprint lines 2482-2585) #

Torus norms and Fourier tests (blueprint lines 2482-2585) #

Blueprint eq:Haar-four (lines 2497-2502): on a rational connected subtorus 𝓗, for a multiplier bounded by W, ∫_{𝓗²} K(u,v) Π_j |h_j(u + (j - l') v)| ≤ W Π_j ‖h_j‖_{L²(𝓗)}; this is eq:absolute with all four exponents equal to two. The zero-dimensional torus is included.

Blueprint lines 2487-2488 (tiny case): averaging the character e^{i a x} over [0, 1] gives 1 up to an error at most |a|.

theorem TrilinearHT.Auto.character_average_huge {a : ℝ} (ha : a ≠ 0) :
‖∫ (x : ℝ) in 0..1, Complex.exp (Complex.I * ↑(a * x))‖ ≤ 2 / |a|

Blueprint lines 2487-2488 (huge case): averaging the character e^{i a x} over [0, 1] gives at most 2 / |a|.

theorem TrilinearHT.Auto.core_moment_bound {Ω : Type u_1} [MeasurableSpace Ω] (P : MeasureTheory.Measure Ω) {m₀ : ℕ} (hm : 2 ≤ m₀) (a : Fin m₀ → Ω → ENNReal) (ha : ∀ (j : Fin m₀), Measurable (a j)) {C ρ : ENNReal} (hC : 1 ≤ C) (σ : Fin m₀ → ENNReal) (n : Fin m₀ → ℕ) (hdet : ∀ (j : Fin m₀) (ω : Ω), a j ω ≤ C * σ j) (hsq : ∀ (j : Fin m₀), ∫⁻ (ω : Ω), a j ω ^ 2 ∂P ≤ C * ρ ^ n j * σ j ^ 2) :
∫⁻ (ω : Ω), ∏ j : Fin m₀, a j ω ∂P ≤ C ^ m₀ * (ρ ^ ∑ j : Fin m₀, n j) ^ (1 / ↑m₀) * ∏ j : Fin m₀, σ j

Blueprint lines 2568-2572: for a fixed assignment of the failures, Hölder with m₀ ≥ 1 factors and the deterministic bound give E Π_j a'_j ≤ C^{m₀} ((2δ)^n)^{1/m₀} Π_j σ_j from a'_j ≤ C σ_j and E (a'_j)² ≤ C (2δ)^{n_j} σ_j² with Σ_j n_j = n (here ρ = 2δ, C ≥ 1).

Many four-step paths (lem:sparse-count, blueprint lines 2608-2609) #

def TrilinearHT.Auto.bipCodeg {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (Q : Finset Y) (E : Finset (X × Y)) (x x' : X) :

The codegree of two first-part vertices in a bipartite edge set.

Equations
Instances For
    def TrilinearHT.Auto.bipNbhd {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (P : Finset X) (E : Finset (X × Y)) (y : Y) :

    The first-part neighborhood of a second-part vertex.

    Equations
    Instances For
      def TrilinearHT.Auto.bipFourPaths {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (P : Finset X) (Q : Finset Y) (E : Finset (X × Y)) (a a' : X) :
      Finset (Y × X × Y)

      Four-step paths a - y₁ - x - y₂ - a' in a bipartite edge set.

      Equations
      Instances For
        theorem TrilinearHT.Auto.bipCodeg_comm {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (Q : Finset Y) (E : Finset (X × Y)) (x x' : X) :
        bipCodeg Q E x x' = bipCodeg Q E x' x
        theorem TrilinearHT.Auto.card_bipFourPaths {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (P : Finset X) (Q : Finset Y) (E : Finset (X × Y)) (a a' : X) :
        (bipFourPaths P Q E a a').card = ∑ x ∈ P, bipCodeg Q E a x * bipCodeg Q E x a'
        theorem TrilinearHT.Auto.sum_card_bipNbhd {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (P : Finset X) (Q : Finset Y) (E : Finset (X × Y)) (hE : E ⊆ P ×ˢ Q) :
        ∑ y ∈ Q, (bipNbhd P E y).card = E.card

        Edge count through neighborhoods.

        theorem TrilinearHT.Auto.sum_card_pairs_bipNbhd {X : Type u_1} {Y : Type u_2} [DecidableEq X] [DecidableEq Y] (P : Finset X) (Q : Finset Y) (E : Finset (X × Y)) (bad : X → X → Prop) [DecidableRel bad] :
        ∑ y ∈ Q, {p ∈ bipNbhd P E y ×ˢ bipNbhd P E y | bad p.1 p.2}.card = ∑ p ∈ P ×ˢ P with bad p.1 p.2, bipCodeg Q E p.1 p.2

        Pairs of a neighborhood with a property, summed over the second part, count codegrees.

        Torus norms (frequency-tests, eq:torus-size, blueprint lines 2482-2495) #

        theorem TrilinearHT.Auto.cell_average_close {ι : Type u_1} (F : Finset ι) (c : ι → ℂ) (φ : ι → ℝ) (rel : ι → ι → Prop) {ε : ℝ} (hε : 0 < ε) (htiny : ∀ k ∈ F, ∀ k' ∈ F, rel k k' → |φ k - φ k'| ≤ ε) (hhuge : ∀ k ∈ F, ∀ k' ∈ F, ¬rel k k' → 2 / ε ≤ |φ k - φ k'|) :
        ‖(∫ (t : ℝ) in 0..1, ∑ k ∈ F, ∑ k' ∈ F, c k * (starRingEnd ℂ) (c k') * Complex.exp (Complex.I * ↑((φ k - φ k') * t))) - ∑ k ∈ F, ∑ k' ∈ F, if rel k k' then c k * (starRingEnd ℂ) (c k') else 0‖ ≤ ε * (∑ k ∈ F, ‖c k‖) ^ 2

        Blueprint lines 2487-2490 (cell averages against Haar norms): for a trigonometric sum g(t) = Σ_k c_k e^{i φ_k t} on the normalized cell [0,1] whose frequency differences are tiny (|φ_k - φ_{k'}| ≤ ε) on the related pairs and huge (|φ_k - φ_{k'}| ≥ 2/ε) otherwise, the cell average of |g|² differs from the coset sum Σ_{k ~ k'} c_k cBar_{k'} (its Haar norm on the annihilator torus) by at most ε (Σ_k |c_k|)².

        theorem TrilinearHT.Auto.haar_norm_sq_eq {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (F : Finset ι) (c : ι → ℂ) (n : ι → Fin d → ℤ) :
        ∫ (x : ↥(torusAnnihilator (rationalIntegerIntersection V))), ∑ k ∈ F, ∑ k' ∈ F, c k * (starRingEnd ℂ) (c k') * (torusCharacter (n k) ↑x * (starRingEnd ℂ) (torusCharacter (n k') ↑x)) ∂torusAnnihilatorHaar (rationalIntegerIntersection V) = ∑ k ∈ F, ∑ k' ∈ F, if n k - n k' ∈ rationalIntegerIntersection V then c k * (starRingEnd ℂ) (c k') else 0

        Blueprint lines 2487-2490 (Haar side of eq:torus-size): on the annihilator torus of a rational space, ∫ |Σ_k c_k χ_k|² = Σ_{k - k' ∈ K_B} c_k cBar_{k'}.

        def TrilinearHT.Auto.FourRef {d : ℕ} (ζ : Fin d → ℝ) (B μ ν R : ℝ) (x : Fin 4 → ℝ) :

        The reference data of a tested four-core tuple at scale R: box shifts n, m with q' = Σ x_r + 36 n·ζ, t' = Σ r x_r + 36 m·ζ, |q'|, |t'| ≤ ν R and |t' - j q'| ≥ μ R for every line j (blueprint eq:four-tests).

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          noncomputable def TrilinearHT.Auto.sideWindow {d : ℕ} (ζ : Fin d → ℝ) (r Λ B : ℝ) (x : Fin 4 → ℝ) :

          The side window of a tested tuple (blueprint line 2564, b_Λ): the integer frequencies k with |k - r(Q + 36 n·ζ)| ≤ 2Λ for some box shift |n| ≤ B, where Q = Σ x_r. The window energies sideWinE pair the side with e(+k y / r), so the index k here is -k in the blueprint's |k + r(Q + n·ξ)| ≤ 2Λ.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For

            Torus sizes (blueprint lines 2483-2495, eq:torus-size) #

            theorem TrilinearHT.Auto.torus_size_bound {ι : Type u_1} (s : Finset ι) (A sD : ι → ℝ) (hA : ∀ i ∈ s, 0 ≤ A i) (hs : ∀ i ∈ s, 0 ≤ sD i) {a X ε Dst : ℝ} (hDst : 1 ≤ Dst) (hcard : ↑s.card ≤ Dst) (hεD : ε ≤ Dst ^ (-100)) (haX : a ^ 2 ≤ X + ε * (∑ i ∈ s, sD i) ^ 2) (hX : X ≤ 2 * ∑ i ∈ s, A i ^ 2) :
            a ≤ √2 * √(∑ i ∈ s, (A i + Dst ^ (-30) * sD i) ^ 2)

            Blueprint eq:torus-size (lines 2489-2495): if the squared Haar norm is at most the cell average X plus ε (Σ_D s_D)² (cell_average_close, haar_norm_sq_eq), the cell average is at most 2 Σ_D ‖A_D‖² (almost orthogonality of minimal CURRENT components), at most D_* components are selected and ε ≤ D_*^{-100}, then a' ≤ √2 (Σ_D (‖A_D‖ + D_*^{-30} s_D)²)^{1/2}.

            Fourier decay of the normalized kernel (blueprint lines 2526-2534) #

            theorem TrilinearHT.Auto.iteratedDeriv_eq_zero_of_support {f : ℝ → ℂ} {R : ℝ} (hsupp : ∀ (x : ℝ), f x ≠ 0 → |x| ≤ R) (k : ℕ) {x : ℝ} (hx : R < |x|) :

            A function vanishing outside [-R, R] has its iterated derivatives vanishing there too.

            theorem TrilinearHT.Auto.integral_norm_le_of_support {g : ℝ → ℂ} {R A : ℝ} (hR : 0 ≤ R) (hg : ∀ (x : ℝ), ‖g x‖ ≤ A) (hsupp : ∀ (x : ℝ), R < |x| → g x = 0) :
            ∫ (x : ℝ), ‖g x‖ ≤ 2 * R * A

            The integral of a function bounded by A and vanishing outside [-R, R] is at most 2 R A.

            theorem TrilinearHT.Auto.fourier_decay_of_support {f : ℝ → ℂ} (hf : ContDiff ℝ (↑⊤) f) {R : ℝ} (hR : 0 ≤ R) (hsupp : ∀ (x : ℝ), f x ≠ 0 → |x| ≤ R) (J : ℕ) {A₀ AJ : ℝ} (hA₀ : ∀ (x : ℝ), ‖f x‖ ≤ A₀) (hAJ : ∀ (x : ℝ), ‖iteratedDeriv J f x‖ ≤ AJ) (q : ℝ) :
            (1 + |q| ^ J) * ‖FourierTransform.fourier f q‖ ≤ 2 * R * (A₀ + ((2 * Real.pi) ^ J)⁻¹ * AJ)

            Uniform Fourier decay of a smooth function vanishing outside [-R, R]: (1 + |q|^J) ‖𝓕 f q‖ ≤ 2 R (A₀ + (2π)^{-J} A_J) when |f| ≤ A₀ and |f^{(J)}| ≤ A_J.

            structure TrilinearHT.Auto.UnitKernelBounds (w : ℝ × ℝ → ℂ) (R : ℝ) (A : ℕ → ℝ) :

            The bounds of a normalized kernel at unit scale: smooth, vanishing outside [-R, R]², with line derivatives in each variable bounded by A m.

            Instances For
              noncomputable def TrilinearHT.Auto.kernelFT (w : ℝ × ℝ → ℂ) (q t : ℝ) :

              The Fourier transform of a kernel on ℝ² (first in x, then in s).

              Equations
              Instances For
                theorem TrilinearHT.Auto.UnitKernelBounds.A_nonneg {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (m : ℕ) :
                0 ≤ A m
                theorem TrilinearHT.Auto.UnitKernelBounds.slice_x_smooth {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (s : ℝ) :
                ContDiff ℝ ↑⊤ fun (x : ℝ) => w (x, s)
                theorem TrilinearHT.Auto.UnitKernelBounds.slice_s_smooth {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (x : ℝ) :
                ContDiff ℝ ↑⊤ fun (s : ℝ) => w (x, s)
                theorem TrilinearHT.Auto.UnitKernelBounds.slice_decay {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (J : ℕ) (s q : ℝ) :
                (1 + |q| ^ J) * ‖FourierTransform.fourier (fun (x : ℝ) => w (x, s)) q‖ ≤ 2 * R * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J)

                Fourier decay of the x-slices, uniformly in s.

                theorem TrilinearHT.Auto.UnitKernelBounds.slice_eq_zero {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) {s : ℝ} (hs : R < |s|) (q : ℝ) :
                FourierTransform.fourier (fun (x : ℝ) => w (x, s)) q = 0

                The x-slices vanish for |s| > R.

                theorem TrilinearHT.Auto.UnitKernelBounds.decay_q {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (J : ℕ) (q t : ℝ) :
                (1 + |q| ^ J) * ‖kernelFT w q t‖ ≤ 2 * R * (2 * R * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J))

                Blueprint lines 2530-2533 (rapid decay in the first frequency): (1 + |q|^J) |WFourier(q, t)| ≤ 2R · 2R (A₀ + (2π)^{-J} A_J).

                The phase-weighted kernel on ℝ × ℝ (in the order (s, x)) is integrable.

                theorem TrilinearHT.Auto.UnitKernelBounds.kernelFT_swap {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (q t : ℝ) :
                kernelFT w q t = ∫ (x : ℝ), ↑(Real.fourierChar (-(x * q))) * FourierTransform.fourier (fun (s : ℝ) => w (x, s)) t

                Fubini: the kernel transform computed first in s, then in x.

                theorem TrilinearHT.Auto.UnitKernelBounds.decay_t {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (J : ℕ) (q t : ℝ) :
                (1 + |t| ^ J) * ‖kernelFT w q t‖ ≤ 2 * R * (2 * R * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J))

                Blueprint lines 2530-2533 (rapid decay in the second frequency).

                The sheared slices u ↦ w(u - j s, s) and their phase-weighted product integrability.

                theorem TrilinearHT.Auto.UnitKernelBounds.near_line {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (J : ℕ) (j : ℝ) (hmarg : ∀ (u : ℝ), ∫ (s : ℝ), w (u - j * s, s) = 0) (q δ : ℝ) :
                (1 + |q| ^ J) * ‖kernelFT w q (j * q + δ)‖ ≤ 2 * R * (2 * Real.pi * R * |δ| * (2 * (R + |j| * R) * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J)))

                Blueprint lines 2529-2533 (zeros on the lines t = j q and smoothness near them): if the marginals ∫ w(u - j s, s) ds vanish, then near the line, (1 + |q|^J) |WFourier(q, j q + δ)| ≤ 2R · 2πR|δ| · 2(R + |j|R) (A₀ + (2π)^{-J} A_J).

                theorem TrilinearHT.Auto.UnitKernelBounds.decay_lines {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (J : ℕ) (L : Finset ℝ) (hL : L.Nonempty) {Jb : ℝ} (hJb : ∀ j ∈ L, |j| ≤ Jb) (hmarg : ∀ j ∈ L, ∀ (u : ℝ), ∫ (s : ℝ), w (u - j * s, s) = 0) (q t : ℝ) :
                ‖kernelFT w q t‖ * max 1 (max |q| |t|) ^ J ≤ (2 * (2 * R * (2 * R * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J))) + (Jb + 2) ^ J * (2 * R * (2 * Real.pi * R * (2 * (R + Jb * R) * (A 0 + ((2 * Real.pi) ^ J)⁻¹ * A J))))) * min 1 (L.inf' hL fun (j : ℝ) => |t - j * q|)

                Blueprint lines 2526-2534 (|WFourier_s(r q', r t')| ≤ C_J μ ν^{-J}): if the marginals along the lines t = j q, j ∈ L (|j| ≤ J_b), vanish, then with μ = min(1, min_j |t - j q|) and ν = max(1, |q|, |t|), |WFourier(q, t)| ν^J ≤ C μ for an explicit C depending only on R, J_b and the derivative bounds.

                theorem TrilinearHT.Auto.unitKernel_bounds {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) :

                Blueprint lines 2522-2534: the unit-scale admissible kernel W_s has the bounds of a normalized kernel, uniformly over the kernel class.

                theorem TrilinearHT.Auto.unitKernel_marginal {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (j : Fin 4) (u : ℝ) :
                ∫ (s : ℝ), unitKernel a₀ r w (u - ↑↑j * s, s) = 0

                Blueprint line 2529 ("the four marginals give zeros of WFourier_s(q,t) on the four lines t = j q"): the unit-scale kernel has vanishing marginals along the four lines.

                theorem TrilinearHT.Auto.admissible_kernel_decay {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (J : ℕ) (q t : ℝ) :
                ‖kernelFT (unitKernel a₀ r w) q t‖ * max 1 (max |q| |t|) ^ J ≤ (2 * (2 * 4 * (2 * 4 * (kernelDerivBound κ 0 + ((2 * Real.pi) ^ J)⁻¹ * kernelDerivBound κ J))) + (3 + 2) ^ J * (2 * 4 * (2 * Real.pi * 4 * (2 * (4 + 3 * 4) * (kernelDerivBound κ 0 + ((2 * Real.pi) ^ J)⁻¹ * kernelDerivBound κ J))))) * min 1 ((Finset.image (fun (j : Fin 4) => ↑↑j) Finset.univ).inf' ⋯ fun (j : ℝ) => |t - j * q|)

                Blueprint lines 2526-2534 for the admissible kernels: |WFourier_s(q, t)| ν^J ≤ C_J μ with μ = min(1, min_{0 ≤ j ≤ 3} |t - j q|), ν = max(1, |q|, |t|), uniformly over the class.

                Four-core tests: coset reduction (blueprint lines 2506-2529) #

                Characters are integrable on the annihilator torus (a probability space).

                theorem TrilinearHT.Auto.UnitKernelBounds.kernelFT_eq_iter {w : ℝ × ℝ → ℂ} (q t : ℝ) :
                kernelFT w q t = ∫ (s : ℝ) (x : ℝ), ↑(Real.fourierChar (-(s * t))) * (↑(Real.fourierChar (-(x * q))) * w (x, s))

                The kernel transform as an iterated integral of the phase-weighted kernel.

                theorem TrilinearHT.Auto.UnitKernelBounds.kernelFT_lipschitz {w : ℝ × ℝ → ℂ} {R : ℝ} {A : ℕ → ℝ} (hw : UnitKernelBounds w R A) (hR : 0 ≤ R) (q t q₁ t₁ : ℝ) :
                ‖kernelFT w q t - kernelFT w q₁ t₁‖ ≤ 2 * R * (2 * R * (2 * Real.pi * R * (|q - q₁| + |t - t₁|) * A 0))

                Blueprint line 2524 ("their frequencies differ by a tiny quantity, so replace the Fourier values by the reference value"): the kernel transform is Lipschitz, |WFourier(q, t) - WFourier(q₁, t₁)| ≤ (2R)² A₀ · 2πR (|q - q₁| + |t - t₁|).

                Blueprint line 2526 (the retained coset coefficient is bounded by C Π_j a'_j by eq:Haar-four): for a bounded continuous multiplier R, continuous g_j on 𝓗 and a unimodular continuous weight χ, |∫∫_{𝓗²} R(u, v) Π_j g_j(u + (j - l) v) χ(u, v)| ≤ W Π_j ‖g_j‖_{L²(𝓗)}.

                theorem TrilinearHT.Auto.form_linear_phase {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : MeasureTheory.Integrable w MeasureTheory.volume) (A B C : ℝ) :
                (↑r)⁻¹ ^ 2 * ∫ (z : ℝ × ℝ), w z * ↑(Real.fourierChar (A * z.1 + B * z.2 + C)) = ↑(Real.fourierChar (C + A * (a₀ + r / 2))) * kernelFT (unitKernel a₀ r w) (-(r * A)) (-(r * B))

                Blueprint lines 2522-2523 ("its characters sample WFourier_s at r(Q + n·ξ, T + m·ξ)"): the normalized local form of an integrable kernel against a linear phase e(A x + B t + C) is a value of the Fourier transform of the unit-scale kernel, r⁻² ∫ w(z) e(A z₁ + B z₂ + C) = e(C + A (a₀ + r/2)) WFourier(-r A, -r B).

                Three-core tests (blueprint lines 2536-2565) #

                theorem TrilinearHT.Auto.anchor_entry_bound {K : ℝ → ℝ → ℂ} {C Jb : ℝ} (hC : 0 ≤ C) (hJb : 0 ≤ Jb) (J A : ℕ) (L : Finset ℝ) (hL : L.Nonempty) {l : ℝ} (hl : l ∈ L) (hlb : |l| ≤ Jb) (hK : ∀ (q t : ℝ), ‖K q t‖ * max 1 (max |q| |t|) ^ (J + A) ≤ C * min 1 (L.inf' hL fun (j : ℝ) => |t - j * q|)) (κ β : ℝ) :
                ‖K κ (β + l * κ)‖ * (max 1 |β| ^ J * max 1 |κ| ^ A) ≤ C * (Jb + 2) ^ (J + A) * min 1 |β|

                Blueprint lines 2540-2542 and 2553-2556 (the anchor function and the pairing entries): with anchor l and |l| ≤ J_b, a kernel transform bounded by C μ ν^{-(J + A)} (decay_lines, with the line t = l q among the zero lines) has, at (κ, β + l κ), |WFourier(κ, β + lκ)| ≤ C (J_b + 2)^{J + A} min(1, |β|) max(1, |β|)^{-J} max(1, |κ|)^{-A}.

                Blueprint lines 2545-2547 (‖D_m‖₂ ≤ C Π_{j ≠ l} a'_j by duality and eq:Haar-four): for the slice D_m(u) = ∫ D(u, v) e(-m·v) dv of D(u, v) = R(u, v) Π_{j ≠ l} g_j(u + (j - l) v), ‖D_m‖_{L²(𝓗)} ≤ W Π_{j ≠ l} ‖g_j‖_{L²(𝓗)}.

                Side windows (blueprint lines 2549-2562, eq:side-windows) #

                theorem TrilinearHT.Auto.floor_injOn_of_separated {ι : Type u_1} (N : Finset ι) (f : ι → ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |f n - f n'|) :
                Set.InjOn (fun (n : ι) => ⌊f n⌋) ↑N

                Points of a 1-separated family have distinct floors.

                theorem TrilinearHT.Auto.card_separated_near {ι : Type u_1} (N : Finset ι) (f : ι → ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |f n - f n'|) (c : ℝ) {R : ℝ} (hR : 0 ≤ R) :
                ↑{n ∈ N | |f n - c| ≤ R}.card ≤ 2 * R + 2

                A 1-separated family has at most 2R + 2 members within distance R of a point.

                theorem TrilinearHT.Auto.shell_pairing_bound {ι : Type u_1} (N : Finset ι) (f : ι → ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |f n - f n'|) (Kk : Finset ℤ) (a : ι → ℂ) (b : ℤ → ℂ) {R : ℝ} (hR : 0 ≤ R) :
                ∑ n ∈ N, ∑ k ∈ Kk with |↑k + f n| ≤ R, ‖a n‖ * ‖b k‖ ≤ (2 * R + 2) * (√(∑ n ∈ N, ‖a n‖ ^ 2) * √(∑ k ∈ Kk with ∃ n ∈ N, |↑k + f n| ≤ R, ‖b k‖ ^ 2))

                One shell of eq:side-windows (lines 2553-2556: "in a shell of radius Λ, each row and column has O(Λ) entries, since both the integers and the reference frequencies are separated"): Σ_{|k + f_n| ≤ R} |a_n| |b_k| ≤ (2R + 2) ‖a‖₂ ‖b‖_{ℓ²(W_R)}, W_R the window of k within R of some -f_n.

                theorem TrilinearHT.Auto.dyadic_majorant {x : ℝ} (hx : 0 ≤ x) (A I : ℕ) :
                (1 + x)⁻¹ ^ (A + 2) ≤ (2 ^ (A + 2) * ∑ i ∈ Finset.range (I + 1), (2 ^ i)⁻¹ ^ (A + 2) * if x ≤ 2 ^ i then 1 else 0) + (2 ^ I)⁻¹ ^ (A + 2)

                The dyadic majorant of (1 + x)^{-(A+2)}: (1 + x)^{-(A+2)} ≤ 2^{A+2} Σ_{i ≤ I} 2^{-i(A+2)} 1[x ≤ 2^i] + 2^{-I(A+2)} for x ≥ 0.

                theorem TrilinearHT.Auto.side_windows {ι : Type u_1} (N : Finset ι) (f : ι → ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |f n - f n'|) (Kk : Finset ℤ) (a : ι → ℂ) (b : ℤ → ℂ) (M : ι → ℤ → ℂ) {C : ℝ} (hC : 0 ≤ C) (A I : ℕ) (hM : ∀ (n : ι) (k : ℤ), ‖M n k‖ ≤ C * (1 + |↑k + f n|)⁻¹ ^ (A + 2)) :
                ‖∑ n ∈ N, ∑ k ∈ Kk, a n * b k * M n k‖ ≤ C * 2 ^ (A + 4) * ∑ i ∈ Finset.range (I + 1), (2 ^ i)⁻¹ ^ (A + 1) * (√(∑ n ∈ N, ‖a n‖ ^ 2) * √(∑ k ∈ Kk with ∃ n ∈ N, |↑k + f n| ≤ 2 ^ i, ‖b k‖ ^ 2)) + C * (2 ^ I)⁻¹ ^ (A + 2) * ((∑ n ∈ N, ‖a n‖) * ∑ k ∈ Kk, ‖b k‖)

                Blueprint eq:side-windows (lines 2553-2562): for a pairing matrix with entries |M_{n,k}| ≤ C (1 + |k + f_n|)^{-(A+2)} against 1-separated reference frequencies f_n, `|Σ_{n,k} a_n b_k M_{n,k}| ≤ C 2^{A+4} Σ_{Λ = 2^i ≤ 2^I} Λ^{-(A+1)} ‖a‖₂ b_Λ

                • C 2^{-I(A+2)} Σ|a_n| Σ|b_k|, with b_Λtheℓ²norm ofbon the windowW_Λ`.

                Failure assignments and the principal core (blueprint lines 2566-2585) #

                theorem TrilinearHT.Auto.normSq_sum_conj {ι : Type u_1} (F : Finset ι) (z : ι → ℂ) :
                ↑(‖∑ k ∈ F, z k‖ ^ 2) = ∑ k ∈ F, ∑ k' ∈ F, z k * (starRingEnd ℂ) (z k')

                The square of a finite sum of complex numbers is the double sum of the products with the conjugates.

                Continuous functions on the annihilator torus are integrable.

                Blueprint lines 2547-2549 ("collect horizontal Fourier coefficients by cosets and choose one reference n per coset; Parseval bounds their ℓ² norm"): for references n in distinct cosets of K_B ∩ ℤ^d, the Haar coefficients ⟨f, χ_n⟩ of a continuous function on the annihilator torus satisfy Bessel's inequality Σ_n |⟨f, χ_n⟩|² ≤ ‖f‖²_{L²(𝓗)}.

                The dual slice D_m(u) = ∫ D(u, v) e(-m·v) dv of D(u, v) = R(u, v) Π_{j ≠ l} g_j(u + (j - l) v) (blueprint lines 2543-2546).

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem TrilinearHT.Auto.continuous_dualSlice {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hRm : Continuous Rm) (l : Fin 4) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hg : ∀ (i : Fin 4), Continuous (g i)) (m : Fin d → ℤ) :
                  Continuous (dualSlice V Rm l g m)
                  theorem TrilinearHT.Auto.three_core_windows {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hRm : Continuous Rm) {W : ℝ} (hW : 0 ≤ W) (hRb : ∀ (z : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V))), ‖Rm z‖ ≤ W) (l : Fin 4) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hg : ∀ (i : Fin 4), Continuous (g i)) (m : Fin d → ℤ) (N : Finset (Fin d → ℤ)) (hN : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → n - n' ∉ rationalIntegerIntersection V) (fr : (Fin d → ℤ) → ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |fr n - fr n'|) (Kk : Finset ℤ) (b : ℤ → ℂ) (M : (Fin d → ℤ) → ℤ → ℂ) {C : ℝ} (hC : 0 ≤ C) (A I : ℕ) (hM : ∀ (n : Fin d → ℤ) (k : ℤ), ‖M n k‖ ≤ C * (1 + |↑k + fr n|)⁻¹ ^ (A + 2)) :
                  ‖∑ n ∈ N, ∑ k ∈ Kk, (∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)) * b k * M n k‖ ≤ C * 2 ^ (A + 4) * ∑ i ∈ Finset.range (I + 1), (2 ^ i)⁻¹ ^ (A + 1) * ((W * ∏ i ∈ Finset.univ.erase l, (MeasureTheory.eLpNorm (g i) 2 (torusAnnihilatorHaar (rationalIntegerIntersection V))).toReal) * √(∑ k ∈ Kk with ∃ n ∈ N, |↑k + fr n| ≤ 2 ^ i, ‖b k‖ ^ 2)) + C * (2 ^ I)⁻¹ ^ (A + 2) * ((∑ n ∈ N, ‖∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)‖) * ∑ k ∈ Kk, ‖b k‖)

                  Blueprint eq:side-windows (lines 2543-2562) for a three-core test with anchor l and reference m: the horizontal coset coefficients a_n = ⟨D_m, χ_n⟩ at references n in distinct cosets have ℓ² norm at most W Π_{j ≠ l} a'_j (torus_bessel, dual_slice_bound); against a pairing matrix with entries |M_{n,k}| ≤ C (1 + |k + f_n|)^{-(A+2)} and 1-separated reference frequencies f_n, the pairing is at most C 2^{A+4} Σ_{Λ = 2^i ≤ 2^I} Λ^{-(A+1)} (W Π_{j ≠ l} a'_j) b_Λ + C 2^{-I(A+2)} Σ|a_n| Σ|b_k|.

                  theorem TrilinearHT.Auto.mask_second_moment {κ : Type u_1} {m₀ : ℕ} (H : Finset ℕ) (good : ℕ → κ → Prop) (T : Finset κ) (σ : κ → ℝ) (hσ : ∀ K ∈ T, 0 ≤ σ K) {ρ : ℝ} (hbad : ∀ K ∈ T, ↑{h ∈ H | ¬good h K}.card ≤ ρ * ↑H.card) {n : ℕ} (a : Fin n → Fin m₀) (j : Fin m₀) :
                  ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ K ∈ T with ∀ (i : Fin n), a i = j → ¬good (w i) K, σ K ≤ ρ ^ {i : Fin n | a i = j}.card * ↑H.card ^ n * ∑ K ∈ T, σ K

                  Blueprint lines 2568-2572 ("apply the probability bound separately to each minimal-component summand ... dropping extra success requirements only enlarges its probability"): over the words w ∈ H^n of failed heights, the components K of role j failing at every height assigned to j carry total weight at most ρ^{n_j} |H|^n Σ_K σ_K when each component is bad at a proportion at most ρ of H.

                  noncomputable def TrilinearHT.Auto.wordAvg (H : Finset ℕ) (n : ℕ) :

                  The uniform average over the words w ∈ H^n as a measure on Fin n → ℕ.

                  Equations
                  Instances For
                    theorem TrilinearHT.Auto.lintegral_wordAvg (H : Finset ℕ) (n : ℕ) (f : (Fin n → ℕ) → ENNReal) :
                    ∫⁻ (w : Fin n → ℕ), f w ∂wordAvg H n = ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * f w
                    theorem TrilinearHT.Auto.word_moment_bound (H : Finset ℕ) (n : ℕ) {m₀ : ℕ} (hm : 2 ≤ m₀) (A : Fin m₀ → (Fin n → ℕ) → ENNReal) {C ρ : ENNReal} (hC : 1 ≤ C) (σ : Fin m₀ → ENNReal) (nj : Fin m₀ → ℕ) (hdet : ∀ (j : Fin m₀), ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, A j w ≤ C * σ j) (hsq : ∀ (j : Fin m₀), ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * A j w ^ 2 ≤ C * ρ ^ nj j * σ j ^ 2) :
                    ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * ∏ j : Fin m₀, A j w ≤ C ^ m₀ * (ρ ^ ∑ j : Fin m₀, nj j) ^ (1 / ↑m₀) * ∏ j : Fin m₀, σ j

                    Blueprint lines 2568-2572 averaged over the words of failed heights: if the role sizes a'_j(w) satisfy a'_j ≤ C σ_j on the words and their averaged squares are at most C ρ^{n_j} σ_j², then the averaged product is at most C^{m₀} (ρ^{Σ n_j})^{1/m₀} Π_j σ_j (Hölder with m₀ factors, core_moment_bound).

                    An admissible local kernel is integrable (it is continuous with compact support).

                    The shear (y, t) ↦ (y + c t, t) of the plane as a measurable equivalence.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      noncomputable def TrilinearHT.Auto.anchorFn (w : ℝ × ℝ → ℂ) (l : Fin 4) (B y : ℝ) :

                      The anchor function W_B(y) = ∫ w(y - l t, t) e(B t) dt of a kernel (blueprint lines 2540-2542).

                      Equations
                      Instances For
                        theorem TrilinearHT.Auto.form_phase_sum_approx {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (f : Fin 4 → ℝ → ℂ) (hfi : MeasureTheory.Integrable (fun (z : ℝ × ℝ) => w z * ∏ j : Fin 4, f j (realProgressionCoordinate j z)) MeasureTheory.volume) {ι : Type u_1} (P : Finset ι) (C : ι → ℂ) (A B : ι → ℝ) (x₀ : ℝ) {ε : ℝ} (hε0 : 0 ≤ ε) (hε : ∀ (z : ℝ × ℝ), w z ≠ 0 → ‖∏ j : Fin 4, f j (realProgressionCoordinate j z) - ∑ p ∈ P, C p * ↑(Real.fourierChar (A p * (z.1 - x₀) + B p * z.2))‖ ≤ ε) :
                        ‖localProgressionForm r w f - ∑ p ∈ P, C p * (↑(Real.fourierChar (A p * (a₀ + r / 2 - x₀))) * kernelFT (unitKernel a₀ r w) (-(r * A p)) (-(r * B p)))‖ ≤ 2 * localKernelSupBound κ * ε

                        Blueprint lines 2519-2523 with the numerical errors of eq:core-numerical: if on the kernel support the product of the inputs is within ε of a finite phase sum Σ_p C_p e(A_p (z₁ - x₀) + B_p z₂), the local form is within 2 ‖w‖_∞ ε of Σ_p C_p e(A_p (a₀ + r/2 - x₀)) WFourier(-r A_p, -r B_p).

                        theorem TrilinearHT.Auto.torusCharacter_sum_freq {d : ℕ} {κ : Type u_1} (s : Finset κ) (m : κ → Fin d → ℤ) (x : StandardTorus d) :
                        torusCharacter (∑ i ∈ s, m i) x = ∏ i ∈ s, torusCharacter (m i) x
                        theorem TrilinearHT.Auto.four_product_expand {d : ℕ} (l : ℤ) {ιR : Type u_1} {ι : Fin 4 → Type u_2} (QR : Finset ιR) (rc : ιR → ℂ) (fr : ιR → (Fin d → ℤ) × (Fin d → ℤ)) (F : (j : Fin 4) → Finset (ι j)) (a : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (u v : StandardTorus d) :
                        (∑ q ∈ QR, rc q * (torusCharacter (fr q).1 u * torusCharacter (fr q).2 v)) * ∏ j : Fin 4, ∑ k ∈ F j, a j k * torusCharacter (n j k) (u + (↑↑j - l) • v) = ∑ x ∈ QR ×ˢ Fintype.piFinset F, (rc x.1 * ∏ j : Fin 4, a j (x.2 j)) * (torusCharacter ((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) u * torusCharacter ((fr x.1).2 + ∑ j : Fin 4, (↑↑j - l) • n j (x.2 j)) v)

                        The character expansion of D(u, v) = R(u, v) Π_j g_j(u + (j - l) v) for trigonometric polynomials R = Σ_q r_q χ_{q₁}(u) χ_{q₂}(v) and g_j = Σ_k a_{j,k} χ_{n_{j,k}} on the torus (blueprint lines 2519-2523): the sum over (q, k) of r_q Π_j a_{j,k_j} times the characters χ_{q₁ + Σ_j n_{j,k_j}}(u) χ_{q₂ + Σ_j (j - l) n_{j,k_j}}(v).

                        theorem TrilinearHT.Auto.coset_sum_eq_haar' {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (P : Finset ι) (c : ι → ℂ) (fr : ι → (Fin d → ℤ) × (Fin d → ℤ)) (P₀ : (Fin d → ℤ) × (Fin d → ℤ)) :

                        coset_sum_eq_haar for a trigonometric polynomial indexed by an arbitrary finite set with a frequency map.

                        theorem TrilinearHT.Auto.four_core_test' {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (P : Finset ι) (c Kv : ι → ℂ) (fr : ι → (Fin d → ℤ) × (Fin d → ℤ)) (p₀ : (Fin d → ℤ) × (Fin d → ℤ)) (K₀ : ℂ) {ε τ : ℝ} (hclose : ∀ p ∈ P, (fr p).1 - p₀.1 ∈ rationalIntegerIntersection V ∧ (fr p).2 - p₀.2 ∈ rationalIntegerIntersection V → ‖Kv p - K₀‖ ≤ ε) (hfar : ∀ p ∈ P, ¬((fr p).1 - p₀.1 ∈ rationalIntegerIntersection V ∧ (fr p).2 - p₀.2 ∈ rationalIntegerIntersection V) → ‖Kv p‖ ≤ τ) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hRm : Continuous Rm) {W : ℝ} (hW : 0 ≤ W) (hRb : ∀ (z : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V))), ‖Rm z‖ ≤ W) (l : ℤ) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hg : ∀ (i : Fin 4), Continuous (g i)) (hexp : ∀ (u v : ↥(torusAnnihilator (rationalIntegerIntersection V))), Rm (u, v) * ∏ i : Fin 4, g i (u + (↑↑i - l) • v) = ∑ p ∈ P, c p * (torusCharacter (fr p).1 ↑u * torusCharacter (fr p).2 ↑v)) :
                        ‖∑ p ∈ P, c p * Kv p‖ ≤ ‖K₀‖ * (W * ∏ i : Fin 4, (MeasureTheory.eLpNorm (g i) 2 (torusAnnihilatorHaar (rationalIntegerIntersection V))).toReal) + max ε τ * ∑ p ∈ P, ‖c p‖

                        four_core_test for a trigonometric expansion indexed by an arbitrary finite set with a frequency map fr (no merging of equal frequencies needed).

                        theorem TrilinearHT.Auto.four_core_physical {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (f : Fin 4 → ℝ → ℂ) (hfi : MeasureTheory.Integrable (fun (z : ℝ × ℝ) => w z * ∏ j : Fin 4, f j (realProgressionCoordinate j z)) MeasureTheory.volume) {d : ℕ} (ξ : Fin d → ℝ) (x₀ : ℝ) (γ : Fin 4 → ℝ) {ιR : Type u_1} {ι : Fin 4 → Type u_2} (QR : Finset ιR) (rc : ιR → ℂ) (fr : ιR → (Fin d → ℤ) × (Fin d → ℤ)) (F : (j : Fin 4) → Finset (ι j)) (a : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) {ε : ℝ} (hε0 : 0 ≤ ε) (hε : ∀ (z : ℝ × ℝ), w z ≠ 0 → ‖∏ j : Fin 4, f j (realProgressionCoordinate j z) - ↑(Real.fourierChar (∑ j : Fin 4, γ j * (realProgressionCoordinate j z - x₀))) * ((∑ q ∈ QR, rc q * (torusCharacter (fr q).1 (torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) * torusCharacter (fr q).2 (torusMk fun (i : Fin d) => ξ i * z.2))) * ∏ j : Fin 4, ∑ k ∈ F j, a j k * torusCharacter (n j k) ((torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) + (↑↑j - 0) • torusMk fun (i : Fin d) => ξ i * z.2))‖ ≤ ε) :
                        ‖localProgressionForm r w f - ∑ x ∈ QR ×ˢ Fintype.piFinset F, (rc x.1 * ∏ j : Fin 4, a j (x.2 j)) * (↑(Real.fourierChar ((∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i) * (a₀ + r / 2 - x₀))) * kernelFT (unitKernel a₀ r w) (-(r * (∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i))) (-(r * (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin d, ↑(((fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j)) i) * ξ i))))‖ ≤ 2 * localKernelSupBound κ * ε

                        Blueprint lines 2519-2523 (four cores, anchor l' = 0): if on the kernel support the product of the inputs is within ε of e(Σ_j γ_j (y_j - x₀)) D(ξ(x - x₀), ξ t) for the torus trigonometric polynomial D(u, v) = R(u, v) Π_j g_j(u + j v), then the local form is within 2 ‖w‖_∞ ε of Σ_x C_x e(A_x (a₀ + r/2 - x₀)) WFourier(-r A_x, -r B_x) over the expansion of D (four_product_expand), with A_x = Σ_j γ_j + P₁(x)·ξ and B_x = Σ_j j γ_j + P₂(x)·ξ.

                        theorem TrilinearHT.Auto.four_core_cell_bound {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (f : Fin 4 → ℝ → ℂ) (hfi : MeasureTheory.Integrable (fun (z : ℝ × ℝ) => w z * ∏ j : Fin 4, f j (realProgressionCoordinate j z)) MeasureTheory.volume) {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (ξ : Fin d → ℝ) (x₀ : ℝ) (γ : Fin 4 → ℝ) {ιR : Type u_1} {ι : Fin 4 → Type u_2} (QR : Finset ιR) (rc : ιR → ℂ) (fr : ιR → (Fin d → ℤ) × (Fin d → ℤ)) (F : (j : Fin 4) → Finset (ι j)) (a : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) {εph : ℝ} (hε0 : 0 ≤ εph) (hε : ∀ (z : ℝ × ℝ), w z ≠ 0 → ‖∏ j : Fin 4, f j (realProgressionCoordinate j z) - ↑(Real.fourierChar (∑ j : Fin 4, γ j * (realProgressionCoordinate j z - x₀))) * ((∑ q ∈ QR, rc q * (torusCharacter (fr q).1 (torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) * torusCharacter (fr q).2 (torusMk fun (i : Fin d) => ξ i * z.2))) * ∏ j : Fin 4, ∑ k ∈ F j, a j k * torusCharacter (n j k) ((torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) + (↑↑j - 0) • torusMk fun (i : Fin d) => ξ i * z.2))‖ ≤ εph) (p₀ : (Fin d → ℤ) × (Fin d → ℤ)) (K₀ : ℂ) {ε τ : ℝ} (hclose : ∀ x ∈ QR ×ˢ Fintype.piFinset F, (fr x.1).1 + ∑ j : Fin 4, n j (x.2 j) - p₀.1 ∈ rationalIntegerIntersection V ∧ (fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j) - p₀.2 ∈ rationalIntegerIntersection V → ‖↑(Real.fourierChar ((∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i) * (a₀ + r / 2 - x₀))) * kernelFT (unitKernel a₀ r w) (-(r * (∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i))) (-(r * (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin d, ↑(((fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j)) i) * ξ i))) - K₀‖ ≤ ε) (hfar : ∀ x ∈ QR ×ˢ Fintype.piFinset F, ¬((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j) - p₀.1 ∈ rationalIntegerIntersection V ∧ (fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j) - p₀.2 ∈ rationalIntegerIntersection V) → ‖↑(Real.fourierChar ((∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i) * (a₀ + r / 2 - x₀))) * kernelFT (unitKernel a₀ r w) (-(r * (∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i))) (-(r * (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin d, ↑(((fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j)) i) * ξ i)))‖ ≤ τ) {W : ℝ} (hW : 0 ≤ W) (hRb : ∀ (u v : StandardTorus d), ‖∑ q ∈ QR, rc q * (torusCharacter (fr q).1 u * torusCharacter (fr q).2 v)‖ ≤ W) :
                        ‖localProgressionForm r w f‖ ≤ 2 * localKernelSupBound κ * εph + (‖K₀‖ * (W * ∏ j : Fin 4, (MeasureTheory.eLpNorm (fun (u : ↥(torusAnnihilator (rationalIntegerIntersection V))) => ∑ k ∈ F j, a j k * torusCharacter (n j k) ↑u) 2 (torusAnnihilatorHaar (rationalIntegerIntersection V))).toReal) + max ε τ * ∑ x ∈ QR ×ˢ Fintype.piFinset F, ‖rc x.1 * ∏ j : Fin 4, a j (x.2 j)‖)

                        Blueprint lines 2519-2531 (the four-core test on a cell): under the hypotheses of four_core_physical, if the kernel samples K_x = e(A_x (a₀ + r/2 - x₀)) WFourier(-r A_x, -r B_x) are within ε of a reference value K₀ on the reference coset p₀ + K_B² of the expansion frequencies and at most τ off it, and the torus multiplier is bounded by W on 𝓗², then |Λ| ≤ 2 ‖w‖_∞ ε_ph + |K₀| W Π_j ‖g_j‖_{L²(𝓗)} + max(ε, τ) Σ_x |C_x|.

                        The physical coordinate of a column vector has modulus at most its norm.

                        theorem TrilinearHT.Auto.augMode_toLp_sum_phys_le {V : Type u_1} [Fintype V] [DecidableEq V] {J : Set ℝ} (hJ : MeasurableSet J) (hJf : MeasureTheory.volume J ≠ ⊤) (ψ : V → ℝ → ℂ) (hψ : ∀ (m : V), Measurable (ψ m)) (hψb : ∀ (m : V) (y : ℝ), ‖ψ m y‖ ≤ 1) (εw : V → ℝ) (M : Finset V) (β : V → ℂ) :
                        ∫ (y : ℝ) in J, ‖∑ m ∈ M, β m * ψ m y‖ ^ 2 ≤ ‖∑ m ∈ M, β m • MeasureTheory.MemLp.toLp (augMode J (ψ m) (εw m) m) ⋯‖ ^ 2

                        Blueprint lines 2489-2493 ("the physical norm is bounded by the augmented one"): the cell integral of the squared physical combination is at most the squared norm of the augmented combination.

                        theorem TrilinearHT.Auto.ModeSystem.wave_sum_le_cellMode {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (J : ℤ × ℤ) (E : Finset Ms.Md) (α : Ms.Md → ℂ) :
                        ∫ (y : ℝ) in dyadicGridCell Gd J.1 J.2, ‖∑ m ∈ E, α m * Ms.wave m y‖ ^ 2 ≤ ‖∑ m ∈ E, α m • Ms.cellMode J m‖ ^ 2

                        The cell integral of the squared physical combination of waves is at most the squared norm of the combination of cell modes.

                        theorem TrilinearHT.Auto.torus_size_cell {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} {κ : Type u_2} (F : Finset ι) (c : ι → ℂ) (n : ι → Fin d → ℤ) (ξ : Fin d → ℝ) {r s₀ : ℝ} (hr : 0 < r) (hs₀ : |s₀| ≤ r) {ε : ℝ} (hε : 0 < ε) (htiny : ∀ k ∈ F, ∀ k' ∈ F, n k - n k' ∈ rationalIntegerIntersection V → |2 * Real.pi * r * ∑ i : Fin d, ↑(n k i) * ξ i - 2 * Real.pi * r * ∑ i : Fin d, ↑(n k' i) * ξ i| ≤ ε) (hhuge : ∀ k ∈ F, ∀ k' ∈ F, n k - n k' ∉ rationalIntegerIntersection V → 2 / ε ≤ |2 * Real.pi * r * ∑ i : Fin d, ↑(n k i) * ξ i - 2 * Real.pi * r * ∑ i : Fin d, ↑(n k' i) * ξ i|) (s : Finset κ) (A sD : κ → ℝ) (hA : ∀ i ∈ s, 0 ≤ A i) (hs : ∀ i ∈ s, 0 ≤ sD i) {X Dst : ℝ} (hDst : 1 ≤ Dst) (hcard : ↑s.card ≤ Dst) (hεD : 2 * ε ≤ Dst ^ (-100)) (hX : ∫ (t : ℝ) in 0..1, ‖∑ k ∈ F, c k * torusCharacter (n k) (torusMk fun (i : Fin d) => ξ i * (s₀ + r * t))‖ ^ 2 ≤ X) (hXA : X ≤ 2 * ∑ i ∈ s, A i ^ 2) (hc : ∑ k ∈ F, ‖c k‖ ≤ ∑ i ∈ s, sD i) :
                        (MeasureTheory.eLpNorm (fun (x : ↥(torusAnnihilator (rationalIntegerIntersection V))) => ∑ k ∈ F, c k * torusCharacter (n k) ↑x) 2 (torusAnnihilatorHaar (rationalIntegerIntersection V))).toReal ≤ √2 * √(∑ i ∈ s, (A i + Dst ^ (-30) * sD i) ^ 2)

                        Blueprint eq:torus-size (lines 2482-2495) for one role on the cell: with anchor shift s₀ = a₀ - x* (|s₀| ≤ r), if the frequency differences 2π r (n_k - n_{k'})·ξ of the trigonometric polynomial g = Σ_k c_k χ_{n_k} are at most ε on the relation n_k - n_{k'} ∈ K_B and at least 2/ε off it (eq:gap), its normalized cell average ∫₀¹ |g(ξ(s₀ + r t))|² dt is at most X ≤ 2 Σ_D ‖A_D‖², at most D_* components are selected with coefficient sums covering Σ_k |c_k|, and 2ε ≤ D_*^{-100}, then ‖g‖_{L²(𝓗)} ≤ √2 (Σ_D (‖A_D‖ + D_*^{-30} s_D)²)^{1/2}.

                        theorem TrilinearHT.Auto.admissible_shear_support {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) {y t : ℝ} (h : w (y - ↑↑l * t, t) ≠ 0) :
                        (∀ (j : Fin 4), y + (↑↑j - ↑↑l) * t ∈ Set.Icc a₀ (a₀ + r)) ∧ |t| ≤ r

                        The sheared kernel w(y - l t, t) vanishes unless y lies in the cell and |t| ≤ r, and then all progression points y + (j - l) t lie in the cell.

                        theorem TrilinearHT.Auto.interval_fourier_pairing {a r : ℝ} (hr : 0 < r) (S : ℝ → ℂ) (hS : MeasureTheory.IntegrableOn S (Set.Ico a (a + r)) MeasureTheory.volume) (G : ℝ → ℂ) (hG : Continuous G) (hGa : G a = G (a + r)) (hsum : Summable (fourierCoeffOn ⋯ G)) :
                        HasSum (fun (k : ℤ) => fourierCoeffOn ⋯ G k * ∫ (y : ℝ) in Set.Ico a (a + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)) (∫ (y : ℝ) in Set.Ico a (a + r), S y * G y)

                        Blueprint lines 2549-2556 ("expand S' in normalized Fourier coefficients ... the matrix of pairings"): for a continuous function G with G(a) = G(a + r) and summable Fourier coefficients on [a, a + r) and an integrable S there, the pairing ∫ S G is the convergent sum over k ∈ ℤ of GFourier(k) ∫ S(y) e(k y / r) dy.

                        theorem TrilinearHT.Auto.anchorFn_eq_zero {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (B : ℝ) {y : ℝ} (hy : y ∉ Set.Ioo a₀ (a₀ + r)) :
                        anchorFn w l B y = 0

                        The anchor function vanishes outside the open cell.

                        theorem TrilinearHT.Auto.anchorFn_eq_Icc {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (B y : ℝ) :
                        anchorFn w l B y = ∫ (t : ℝ) in Set.Icc (-r) r, w (y - ↑↑l * t, t) * ↑(Real.fourierChar (B * t))

                        The anchor function as an integral over [-r, r].

                        theorem TrilinearHT.Auto.continuous_anchorFn {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (B : ℝ) :
                        theorem TrilinearHT.Auto.fourierCoeffOn_anchor {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (α β x₀ : ℝ) (k : ℤ) :
                        fourierCoeffOn ⋯ (fun (y : ℝ) => ↑(Real.fourierChar (α * (y - x₀))) * anchorFn w l β y) k = ↑r * (↑(Real.fourierChar (-(α * x₀) + (α - ↑k / r) * (a₀ + r / 2))) * kernelFT (unitKernel a₀ r w) (-(r * (α - ↑k / r))) (-(r * (↑↑l * (α - ↑k / r) + β))))

                        Blueprint lines 2540-2556 (the pairing entries): the Fourier coefficient of G(y) = e(α (y - x₀)) W_β(y) on the cell [a₀, a₀ + r) at k is r e(-α x₀ + A (a₀ + r/2)) WFourier(-r A, -r (l A + β)) with A = α - k/r.

                        theorem TrilinearHT.Auto.summable_inv_max_sq (c : ℝ) :
                        Summable fun (k : ℤ) => (max 1 |↑k - c| ^ 2)⁻¹

                        Σ_{k ∈ ℤ} max(1, |k - c|)^{-2} < ∞.

                        noncomputable def TrilinearHT.Auto.kerC2 (κ : LocalKernelClass) :

                        The kernel decay constant at order two of admissible_kernel_decay'.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem TrilinearHT.Auto.kernelFT_le_kerC2 {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (q t : ℝ) :
                          ‖kernelFT (unitKernel a₀ r w) q t‖ ≤ kerC2 κ * (max 1 |q| ^ 2)⁻¹

                          Order-two decay of the unit kernel transform: |WFourier(q, t)| ≤ C₂ max(1, |q|)^{-2}.

                          theorem TrilinearHT.Auto.anchor_pairing_expand {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (S : ℝ → ℂ) (hS : MeasureTheory.IntegrableOn S (Set.Ico a₀ (a₀ + r)) MeasureTheory.volume) (α β x₀ : ℝ) :
                          HasSum (fun (k : ℤ) => (↑r)⁻¹ * (↑(Real.fourierChar (-(α * x₀) + (α - ↑k / r) * (a₀ + r / 2))) * kernelFT (unitKernel a₀ r w) (-(r * (α - ↑k / r))) (-(r * (↑↑l * (α - ↑k / r) + β)))) * ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)) ((↑r)⁻¹ ^ 2 * ∫ (y : ℝ), S y * (↑(Real.fourierChar (α * (y - x₀))) * anchorFn w l β y))

                          Blueprint lines 2549-2556 for one tuple term: the anchor pairing r⁻² ∫ S(y) e(α (y - x₀)) W_β(y) dy of a function integrable on the cell is the convergent sum over k ∈ ℤ of r⁻¹ e(...) WFourier(-r(α - k/r), -r(l(α - k/r) + β)) s_k, s_k = ∫_I S(y) e(k y/r) dy.

                          theorem TrilinearHT.Auto.hasSum_inv_one_add_abs_sq :
                          HasSum (fun (j : ℤ) => 1 / (1 + |↑j|) ^ 2) (Real.pi ^ 2 / 6 + (Real.pi ^ 2 / 6 - 1))

                          Σ_{j ∈ ℤ} (1 + |j|)^{-2} = π²/3 - 1.

                          theorem TrilinearHT.Auto.tsum_inv_max_sq_le (c : ℝ) :
                          ∑' (k : ℤ), (max 1 |↑k - c| ^ 2)⁻¹ ≤ 12

                          A uniform bound: Σ_{k ∈ ℤ} max(1, |k - c|)^{-2} ≤ 12 for every real c.

                          noncomputable def TrilinearHT.Auto.kerC (κ : LocalKernelClass) (J : ℕ) :

                          The decay constant of order J of admissible_kernel_decay.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem TrilinearHT.Auto.kerC_nonneg {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (J : ℕ) :
                            0 ≤ kerC κ J
                            theorem TrilinearHT.Auto.kernelFT_mul_le_kerC {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (J : ℕ) (q t : ℝ) :
                            ‖kernelFT (unitKernel a₀ r w) q t‖ * max 1 (max |q| |t|) ^ J ≤ kerC κ J

                            Decay of order J: |WFourier(q, t)| max(1, |q|, |t|)^J ≤ C_J.

                            theorem TrilinearHT.Auto.far_ksum {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) {J : ℕ} (hJ : 2 ≤ J) (c b : ℝ) (hb : 4 ≤ |b|) :
                            (Summable fun (k : ℤ) => ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b)‖) ∧ ∑' (k : ℤ), ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b)‖ ≤ 12 * (kerC κ J * (4 / |b|) ^ (J - 2))

                            Blueprint lines 2523-2526 ("other cosets have rapidly decreasing Fourier tails") summed over the cell frequencies: if |b| ≥ 4 and J ≥ 2, then Σ_k |WFourier(k - c, l (k - c) - b)| ≤ 12 C_J (4/|b|)^{J-2}.

                            theorem TrilinearHT.Auto.min_le_sqrt_mul_add {a u v : ℝ} (ha : 0 ≤ a) (hu : 0 ≤ u) (hv : 0 ≤ v) :
                            min a (u + v) ≤ √a * (√u + √v)

                            min(a, u + v) ≤ √a (√u + √v) for nonnegative reals.

                            theorem TrilinearHT.Auto.near_ksum {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (c b c' b' : ℝ) :
                            (Summable fun (k : ℤ) => ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b) - kernelFT (unitKernel a₀ r w) (↑k - c') (↑↑l * (↑k - c') - b')‖) ∧ ∑' (k : ℤ), ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b) - kernelFT (unitKernel a₀ r w) (↑k - c') (↑↑l * (↑k - c') - b')‖ ≤ 24 * √(2 * 4 * (2 * 4 * (2 * Real.pi * 4 * (4 * |c - c'| + |b - b'|) * kernelDerivBound κ 0))) * √(kerC κ 4)

                            Blueprint lines 2523-2526 ("their frequencies differ by a tiny quantity, so replace the Fourier values by the reference value") summed over the cell frequencies: with the Lipschitz constant L_W of the unit kernel transform and δ = 4|c - c'| + |b - b'|, Σ_k |WFourier(k - c, l(k - c) - b) - WFourier(k - c', l(k - c') - b')| ≤ 24 √(L_W δ C₄).

                            theorem TrilinearHT.Auto.ksum_le {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (c b : ℝ) :
                            (Summable fun (k : ℤ) => ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b)‖) ∧ ∑' (k : ℤ), ‖kernelFT (unitKernel a₀ r w) (↑k - c) (↑↑l * (↑k - c) - b)‖ ≤ 12 * kerC κ 2

                            Σ_k |WFourier(k - c, l(k - c) - b)| ≤ 12 C₂.

                            theorem TrilinearHT.Auto.dualSlice_coeff {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (P : Finset ι) (C : ι → ℂ) (fr : ι → (Fin d → ℤ) × (Fin d → ℤ)) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (l : Fin 4) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hexp : ∀ (u v : ↥(torusAnnihilator (rationalIntegerIntersection V))), Rm (u, v) * ∏ i ∈ Finset.univ.erase l, g i (u + (↑↑i - ↑↑l) • v) = ∑ x ∈ P, C x * (torusCharacter (fr x).1 ↑u * torusCharacter (fr x).2 ↑v)) (m₀ n : Fin d → ℤ) :

                            Blueprint lines 2543-2549 ("only the reference m coset contributes ... collect horizontal Fourier coefficients by cosets"): if R(u, v) Π_{j ≠ l} g_j(u + (j - l) v) has the character expansion Σ_x C_x χ_{n_x}(u) χ_{m_x}(v) on 𝓗², the Haar coefficient of the dual slice D_{m₀} at n is the coset sum Σ_{n_x ∈ n + K_B, m_x ∈ m₀ + K_B} C_x.

                            noncomputable def TrilinearHT.Auto.anchorK (a₀ r : ℝ) (w : ℝ × ℝ → ℂ) (l : Fin 4) (x₀ α β : ℝ) (k : ℤ) :

                            The kernel sample of the anchor pairing at the cell frequency k.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              noncomputable def TrilinearHT.Auto.anchorP (r : ℝ) (w : ℝ × ℝ → ℂ) (l : Fin 4) (S : ℝ → ℂ) (x₀ α β : ℝ) :

                              The normalized anchor pairing r⁻² ∫ S(y) e(α (y - x₀)) W_β(y) dy.

                              Equations
                              Instances For
                                theorem TrilinearHT.Auto.anchorK_eq {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (l : Fin 4) (x₀ α β : ℝ) (k : ℤ) :
                                anchorK a₀ r w l x₀ α β k = ↑(Real.fourierChar (-(α * x₀) + (α - ↑k / r) * (a₀ + r / 2))) * kernelFT (unitKernel a₀ r w) (↑k - r * α) (↑↑l * (↑k - r * α) - r * β)
                                theorem TrilinearHT.Auto.norm_cellCoeff_le {a₀ r : ℝ} (S : ℝ → ℂ) (k : ℤ) :
                                ‖∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖ ≤ ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), ‖S y‖

                                The cell Fourier coefficients of the side are bounded by its L¹ norm on the cell.

                                theorem TrilinearHT.Auto.anchorP_sub_le {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (S : ℝ → ℂ) (hS : MeasureTheory.IntegrableOn S (Set.Ico a₀ (a₀ + r)) MeasureTheory.volume) (x₀ α β α' β' : ℝ) (hsum : Summable fun (k : ℤ) => ‖anchorK a₀ r w l x₀ α β k - anchorK a₀ r w l x₀ α' β' k‖) :
                                ‖anchorP r w l S x₀ α β - anchorP r w l S x₀ α' β'‖ ≤ (r⁻¹ * ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), ‖S y‖) * ∑' (k : ℤ), ‖anchorK a₀ r w l x₀ α β k - anchorK a₀ r w l x₀ α' β' k‖

                                The pairing of one tuple term against a reference: the anchor pairings differ by at most r⁻¹ ‖S‖_{L¹(I)} Σ_k |K(k) - K'(k)|.

                                theorem TrilinearHT.Auto.anchorP_norm_le {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (S : ℝ → ℂ) (hS : MeasureTheory.IntegrableOn S (Set.Ico a₀ (a₀ + r)) MeasureTheory.volume) (x₀ α β : ℝ) (hsum : Summable fun (k : ℤ) => ‖anchorK a₀ r w l x₀ α β k‖) :
                                ‖anchorP r w l S x₀ α β‖ ≤ (r⁻¹ * ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), ‖S y‖) * ∑' (k : ℤ), ‖anchorK a₀ r w l x₀ α β k‖

                                The norm of one anchor pairing: at most r⁻¹ ‖S‖_{L¹(I)} Σ_k |K(k)|.

                                theorem TrilinearHT.Auto.anchorK_far {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) {J : ℕ} (hJ : 2 ≤ J) (x₀ α β : ℝ) (hb : 4 ≤ |r * β|) :
                                (Summable fun (k : ℤ) => ‖anchorK a₀ r w l x₀ α β k‖) ∧ ∑' (k : ℤ), ‖anchorK a₀ r w l x₀ α β k‖ ≤ 12 * (kerC κ J * (4 / |r * β|) ^ (J - 2))

                                Far vertical cosets: Σ_k |K(k)| ≤ 12 C_J (4/(r|β|))^{J-2} when r|β| ≥ 4.

                                theorem TrilinearHT.Auto.anchorK_near {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) {x₀ : ℝ} (hx₀ : x₀ ∈ Set.Icc a₀ (a₀ + r)) (α β α' β' : ℝ) :
                                (Summable fun (k : ℤ) => ‖anchorK a₀ r w l x₀ α β k - anchorK a₀ r w l x₀ α' β' k‖) ∧ ∑' (k : ℤ), ‖anchorK a₀ r w l x₀ α β k - anchorK a₀ r w l x₀ α' β' k‖ ≤ 24 * √(2 * 4 * (2 * 4 * (2 * Real.pi * 4 * (4 * |r * α - r * α'| + |r * β - r * β'|) * kernelDerivBound κ 0))) * √(kerC κ 4) + Real.pi * |r * α - r * α'| * (12 * kerC κ 2)

                                Near vertical cosets: the kernel samples at (α, β) and the reference (α', β') differ in total by at most 24 √(L_W δ C₄) + 12 π r|α - α'| C₂ (with x₀ in the cell).

                                noncomputable def TrilinearHT.Auto.entryC (κ : LocalKernelClass) (J A : ℕ) (b : ℝ) :

                                The entry constant of the three-core pairing matrix: C_{J+A+2} 5^{J+A+2} 2^{A+2} min(1, |b|) max(1, |b|)^{-J}.

                                Equations
                                Instances For
                                  theorem TrilinearHT.Auto.entryC_nonneg {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (J A : ℕ) (b : ℝ) :
                                  0 ≤ entryC κ J A b
                                  theorem TrilinearHT.Auto.anchorK_entry {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (x₀ α β : ℝ) (J A : ℕ) (k : ℤ) :
                                  ‖anchorK a₀ r w l x₀ α β k‖ ≤ entryC κ J A (r * β) * (1 + |↑k - r * α|)⁻¹ ^ (A + 2)

                                  Blueprint lines 2553-2556 (|M_{n,k}| ≤ C_{J,A} μ ν^{-J} (1 + |k + r(Q + n·ξ)|)^{-A}): the kernel samples of the anchor pairing at (α, β) satisfy |K(k)| ≤ entryC (1 + |k - r α|)^{-(A+2)} with μ, ν built from r β.

                                  noncomputable def TrilinearHT.Auto.windowSet {ν : Type u_1} (N : Finset ν) (c : ν → ℝ) (I : ℕ) :

                                  The windows of the reference frequencies: the integers within 2^I of some r α_n.

                                  Equations
                                  Instances For
                                    theorem TrilinearHT.Auto.far_of_not_mem_windowSet {ν : Type u_1} (N : Finset ν) (c : ν → ℝ) (I : ℕ) {k : ℤ} (hk : k ∉ windowSet N c I) (n : ν) :
                                    n ∈ N → 2 ^ I < |↑k - c n|
                                    theorem TrilinearHT.Auto.three_core_main {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (S : ℝ → ℂ) (hS : MeasureTheory.IntegrableOn S (Set.Ico a₀ (a₀ + r)) MeasureTheory.volume) (x₀ : ℝ) {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hRm : Continuous Rm) {W : ℝ} (hW : 0 ≤ W) (hRb : ∀ (z : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V))), ‖Rm z‖ ≤ W) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hg : ∀ (i : Fin 4), Continuous (g i)) (m₀ : Fin d → ℤ) (N : Finset (Fin d → ℤ)) (hN : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → n - n' ∉ rationalIntegerIntersection V) (αN : (Fin d → ℤ) → ℝ) (β₀ : ℝ) (hsep : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → 1 ≤ |-(r * αN n) - -(r * αN n')|) (J A I : ℕ) :
                                    ‖∑ n ∈ N, (∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m₀ u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)) * anchorP r w l S x₀ (αN n) β₀‖ ≤ r⁻¹ * entryC κ J A (r * β₀) * 2 ^ (A + 4) * ∑ i ∈ Finset.range (I + 1), (2 ^ i)⁻¹ ^ (A + 1) * ((W * ∏ i ∈ Finset.univ.erase l, (MeasureTheory.eLpNorm (g i) 2 (torusAnnihilatorHaar (rationalIntegerIntersection V))).toReal) * √(∑ k ∈ windowSet N (fun (n : Fin d → ℤ) => r * αN n) I with ∃ n ∈ N, |↑k + -(r * αN n)| ≤ 2 ^ i, ‖∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖ ^ 2)) + r⁻¹ * entryC κ J A (r * β₀) * (2 ^ I)⁻¹ ^ (A + 2) * ((∑ n ∈ N, ‖∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m₀ u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)‖) * ∑ k ∈ windowSet N (fun (n : Fin d → ℤ) => r * αN n) I, ‖∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖) + (12 * (r⁻¹ * entryC κ J A (r * β₀) * (2 ^ I)⁻¹ ^ A) * ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), ‖S y‖) * ∑ n ∈ N, ‖∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m₀ u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)‖

                                    Blueprint eq:side-windows (lines 2543-2562) for the reference terms of a three-core test: with Haar coefficients a_n = ⟨D_{m₀}, χ_n⟩ at 1-separated reference frequencies r α_n, |Σ_n a_n P(α_n, β₀)| is at most the window bound of three_core_windows over the windows of the references plus the tail 12 C_ent 2^{-IA} ‖S‖_{L¹(I)} Σ_n |a_n|.

                                    theorem TrilinearHT.Auto.three_core_collect (r : ℝ) (w : ℝ × ℝ → ℂ) (l : Fin 4) (S : ℝ → ℂ) (x₀ : ℝ) {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (P : Finset ι) (C : ι → ℂ) (fr : ι → (Fin d → ℤ) × (Fin d → ℤ)) (α β : ι → ℝ) (Rm : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (g : Fin 4 → ↥(torusAnnihilator (rationalIntegerIntersection V)) → ℂ) (hexp : ∀ (u v : ↥(torusAnnihilator (rationalIntegerIntersection V))), Rm (u, v) * ∏ i ∈ Finset.univ.erase l, g i (u + (↑↑i - ↑↑l) • v) = ∑ x ∈ P, C x * (torusCharacter (fr x).1 ↑u * torusCharacter (fr x).2 ↑v)) (m₀ : Fin d → ℤ) (N : Finset (Fin d → ℤ)) (hN : ∀ n ∈ N, ∀ n' ∈ N, n ≠ n' → n - n' ∉ rationalIntegerIntersection V) (αN : (Fin d → ℤ) → ℝ) (β₀ : ℝ) (nref : ι → Fin d → ℤ) (hnear : ∀ x ∈ P, (fr x).2 - m₀ ∈ rationalIntegerIntersection V → nref x ∈ N ∧ (fr x).1 - nref x ∈ rationalIntegerIntersection V) :
                                    ∑ x ∈ P, C x * anchorP r w l S x₀ (α x) (β x) = ∑ n ∈ N, (∫ (u : ↥(torusAnnihilator (rationalIntegerIntersection V))), dualSlice V Rm l g m₀ u * (starRingEnd ℂ) (torusCharacter n ↑u) ∂torusAnnihilatorHaar (rationalIntegerIntersection V)) * anchorP r w l S x₀ (αN n) β₀ + ∑ x ∈ P with (fr x).2 - m₀ ∈ rationalIntegerIntersection V, C x * (anchorP r w l S x₀ (α x) (β x) - anchorP r w l S x₀ (αN (nref x)) β₀) + ∑ x ∈ P with (fr x).2 - m₀ ∉ rationalIntegerIntersection V, C x * anchorP r w l S x₀ (α x) (β x)

                                    Blueprint lines 2523-2549 for the three-core tuple terms: collecting the tuple terms by the vertical reference coset m₀ + K_B and horizontal reference cosets, the sum Σ_x C_x P(α_x, β_x) equals Σ_{n ∈ N} a_n P(α_n, β₀) plus the near differences and the far terms, where a_n is the Haar coefficient of the dual slice D_{m₀} at n.

                                    noncomputable def TrilinearHT.Auto.nearB (κ : LocalKernelClass) (ε₁ : ℝ) :

                                    The near-coset reduction error per unit coefficient (anchorK_near with both frequency differences at most ε₁).

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      theorem TrilinearHT.Auto.anchoredForm_phase_approx {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (l : Fin 4) (Fc : ℝ × ℝ → ℂ) (Sd : ℝ → ℂ) (hfm : MeasureTheory.AEStronglyMeasurable Sd MeasureTheory.volume) (hfl : MeasureTheory.IntegrableOn Sd (Set.Icc a₀ (a₀ + r)) MeasureTheory.volume) (hfi : MeasureTheory.Integrable (fun (z : ℝ × ℝ) => w z * (Fc z * Sd (realProgressionCoordinate l z))) MeasureTheory.volume) {ι : Type u_1} (P : Finset ι) (C : ι → ℂ) (α β : ι → ℝ) (x₀ : ℝ) {ε : ℝ} (hε0 : 0 ≤ ε) (hε : ∀ (z : ℝ × ℝ), w z ≠ 0 → ‖Fc z - ∑ p ∈ P, C p * ↑(Real.fourierChar (α p * (realProgressionCoordinate l z - x₀) + β p * z.2))‖ ≤ ε) :
                                      ‖((↑r)⁻¹ ^ 2 * ∫ (z : ℝ × ℝ), w z * (Fc z * Sd (realProgressionCoordinate l z))) - ∑ p ∈ P, C p * ((↑r)⁻¹ ^ 2 * ∫ (y : ℝ), Sd y * (↑(Real.fourierChar (α p * (y - x₀))) * anchorFn w l (β p) y))‖ ≤ 2 * localKernelSupBound κ * ε * (r⁻¹ * ∫ (y : ℝ) in Set.Icc a₀ (a₀ + r), ‖Sd y‖)

                                      form_anchor_phase_approx for an anchored form r⁻² ∫ w(z) F(z) S(z₁ + l z₂) dz with a general core factor F (e.g. the core product times the side gauge).

                                      theorem TrilinearHT.Auto.reanchor_physical {d : ℕ} (l : Fin 4) (ξ : Fin d → ℝ) (x₀ : ℝ) (γ : Fin 4 → ℝ) {ιR : Type u_1} {ι : Fin 4 → Type u_2} (QR : Finset ιR) (rc : ιR → ℂ) (fr : ιR → (Fin d → ℤ) × (Fin d → ℤ)) (F : (j : Fin 4) → Finset (ι j)) (a : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (z : ℝ × ℝ) :
                                      ↑(Real.fourierChar (∑ j : Fin 4, γ j * (realProgressionCoordinate j z - x₀))) * ((∑ q ∈ QR, rc q * (torusCharacter (fr q).1 (torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) * torusCharacter (fr q).2 (torusMk fun (i : Fin d) => ξ i * z.2))) * ∏ j : Fin 4, ∑ k ∈ F j, a j k * torusCharacter (n j k) ((torusMk fun (i : Fin d) => ξ i * (z.1 - x₀)) + (↑↑j - 0) • torusMk fun (i : Fin d) => ξ i * z.2)) = ∑ x ∈ QR ×ˢ Fintype.piFinset F, (rc x.1 * ∏ j : Fin 4, a j (x.2 j)) * ↑(Real.fourierChar ((∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i) * (realProgressionCoordinate l z - x₀) + (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin d, ↑(((fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j)) i) * ξ i - ↑↑l * (∑ j : Fin 4, γ j + ∑ i : Fin d, ↑(((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) i) * ξ i)) * z.2))

                                      Blueprint lines 2537-2545 (three cores, anchor l): the four-slot torus expansion re-anchored at u = U + l V. On the physical side, e(Σ_j γ_j (y_j - x₀)) R(U, V) Π_j g_j(U + j V) = Σ_x C_x e(A_x (y_l - x₀) + (B_x - l A_x) t); on the torus, R(u - l v, v) g_l(u) Π_{j ≠ l} g_j(u + (j - l) v) has the character expansion with frequencies (P₁(x), P₂(x) - l P₁(x)).

                                      theorem TrilinearHT.Auto.reanchor_torus {d : ℕ} (l : Fin 4) {ιR : Type u_1} {ι : Fin 4 → Type u_2} (QR : Finset ιR) (rc : ιR → ℂ) (fr : ιR → (Fin d → ℤ) × (Fin d → ℤ)) (F : (j : Fin 4) → Finset (ι j)) (a : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (u v : StandardTorus d) :
                                      ((∑ q ∈ QR, rc q * (torusCharacter (fr q).1 (u - ↑↑l • v) * torusCharacter (fr q).2 v)) * ∑ k ∈ F l, a l k * torusCharacter (n l k) u) * ∏ j ∈ Finset.univ.erase l, ∑ k ∈ F j, a j k * torusCharacter (n j k) (u + (↑↑j - ↑↑l) • v) = ∑ x ∈ QR ×ˢ Fintype.piFinset F, (rc x.1 * ∏ j : Fin 4, a j (x.2 j)) * (torusCharacter ((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j)) u * torusCharacter ((fr x.1).2 + ∑ j : Fin 4, (↑↑j - 0) • n j (x.2 j) - ↑↑l • ((fr x.1).1 + ∑ j : Fin 4, n j (x.2 j))) v)

                                      The torus side of reanchor_physical.

                                      theorem TrilinearHT.Auto.form_indicator_cell {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (f : Fin 4 → ℝ → ℂ) :
                                      (localProgressionForm r w fun (j : Fin 4) => (Set.Ico a₀ (a₀ + r)).indicator (f j)) = localProgressionForm r w f

                                      Indicators of the half-open cell may be dropped in the local form of the cell.

                                      noncomputable def TrilinearHT.Auto.fourK (a₀ r : ℝ) (w : ℝ × ℝ → ℂ) (x₀ A B : ℝ) :

                                      The kernel sample of the four-core test at real frequencies (A, B).

                                      Equations
                                      Instances For
                                        theorem TrilinearHT.Auto.fourK_close {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) {x₀ : ℝ} (hx₀ : x₀ ∈ Set.Icc a₀ (a₀ + r)) {A B A' B' ε₁ : ℝ} (hA : r * |A - A'| ≤ ε₁) (hB : r * |B - B'| ≤ ε₁) :
                                        ‖fourK a₀ r w x₀ A B - fourK a₀ r w x₀ A' B'‖ ≤ (Real.pi * kerC κ 0 + 2 * (2 * 4 * (2 * 4 * (2 * Real.pi * 4 * kernelDerivBound κ 0)))) * ε₁

                                        Blueprint lines 2523-2526 (reference value on the coset): if r|A - A'|, r|B - B'| ≤ ε₁ and x₀ lies in the cell, the four-core kernel samples differ by at most (π C₀ + 2 L_W) ε₁ with C₀ = kerC 0 and L_W the Lipschitz constant of the unit kernel.

                                        theorem TrilinearHT.Auto.fourK_far {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) (x₀ : ℝ) (J : ℕ) {A B H : ℝ} (hH : 1 ≤ H) (hfar : H ≤ r * |A| ∨ H ≤ r * |B|) :
                                        ‖fourK a₀ r w x₀ A B‖ ≤ kerC κ J * (H ^ J)⁻¹

                                        Blueprint lines 2523-2526 (other cosets have rapidly decreasing Fourier tails): if r|A| ≥ H or r|B| ≥ H with H ≥ 1, the sample is at most C_J H^{-J}.

                                        theorem TrilinearHT.Auto.fourK_reference {κ : LocalKernelClass} {a₀ r : ℝ} {w : ℝ × ℝ → ℂ} {ι : Type u_1} (hr : 0 < r) (hw : IsAdmissibleLocalKernel κ a₀ r w) {x₀ : ℝ} (hx₀ : x₀ ∈ Set.Icc a₀ (a₀ + r)) (P : Finset ι) (near : ι → Prop) (A B : ι → ℝ) {A₀ B₀ ε₁ H U : ℝ} (J : ℕ) (hnear : ∀ x ∈ P, near x → r * |A x - A₀| ≤ ε₁ ∧ r * |B x - B₀| ≤ ε₁) (hfar : ∀ x ∈ P, ¬near x → H ≤ r * |A x - A₀| ∨ H ≤ r * |B x - B₀|) (hA₀ : r * |A₀| ≤ U) (hB₀ : r * |B₀| ≤ U) (hHU : 1 ≤ H - U) :
                                        (∀ x ∈ P, near x → ‖fourK a₀ r w x₀ (A x) (B x) - fourK a₀ r w x₀ A₀ B₀‖ ≤ (Real.pi * kerC κ 0 + 2 * (2 * 4 * (2 * 4 * (2 * Real.pi * 4 * kernelDerivBound κ 0)))) * ε₁) ∧ ∀ x ∈ P, ¬near x → ‖fourK a₀ r w x₀ (A x) (B x)‖ ≤ kerC κ J * ((H - U) ^ J)⁻¹

                                        Blueprint lines 2523-2526 (the reference coset of a tested four-core tuple): if the expansion frequencies on the reference coset are within ε₁/r of the reference (A₀, B₀) and off it at distance at least H/r in one coordinate, with a moderate reference r|A₀|, r|B₀| ≤ U and H - U ≥ 1, then the kernel samples satisfy the coset hypotheses of the four-core test with ε = (π C₀ + 2 L_W) ε₁ and τ = C_J (H - U)^{-J}.

                                        def TrilinearHT.Auto.expP1 {d : ℕ} (L QL : ℕ) {ι : Fin 4 → Type u_1} (n : (j : Fin 4) → ι j → Fin d → ℤ) (x : (Fin (d + d) → ℤ) × ((j : Fin 4) → (Fin d → ℤ) × ι j)) :
                                        Fin d → ℤ

                                        The horizontal torus frequency of a term of the four-core expansion (multiplier frequency L v₁ plus the four role frequencies Q₀ L v_j + n_{j,k}).

                                        Equations
                                        Instances For
                                          def TrilinearHT.Auto.expP2 {d : ℕ} (L QL : ℕ) {ι : Fin 4 → Type u_1} (n : (j : Fin 4) → ι j → Fin d → ℤ) (x : (Fin (d + d) → ℤ) × ((j : Fin 4) → (Fin d → ℤ) × ι j)) :
                                          Fin d → ℤ

                                          The vertical torus frequency of a term of the four-core expansion (anchor 0).

                                          Equations
                                          Instances For
                                            theorem TrilinearHT.Auto.gap_coset {d : ℕ} (ϑ : Fin d → ℝ) {H : ℕ} (hH : 1 ≤ H) {ε Λ : ℝ} (hε : 0 ≤ ε) (hgap : ∀ (a : Fin d → ℚ), vecHeight a ≤ H → |ratEval ϑ a| ≤ ε ∨ Λ ≤ |ratEval ϑ a|) (hsmall : (3 * ↑H ^ 2) ^ d * (↑d.factorial * ↑H ^ (d ^ 2 + d)) * ε < Λ) (n : Fin d → ℤ) (hn : (vecHeight fun (i : Fin d) => ↑(n i)) ≤ H) :
                                            (n ∈ rationalIntegerIntersection (tinySpan ϑ H ε) → |∑ i : Fin d, ↑(n i) * ϑ i| ≤ ε) ∧ (n ∉ rationalIntegerIntersection (tinySpan ϑ H ε) → Λ ≤ |∑ i : Fin d, ↑(n i) * ϑ i|)

                                            Blueprint lines 2482-2486 ("for every character difference needed below, r n·ξ is tiny if n ∈ K_B and huge otherwise"): for the tiny span K_B of the pure frequency vector ϑ of a nonexceptional primary (gap eq:gap at height H), an integer vector of height at most H in K_B ∩ ℤ^d is tiny, and one outside is huge.

                                            theorem TrilinearHT.Auto.cell_average_change {a₀ r : ℝ} (hr : 0 < r) (g : ℝ → ℝ) :
                                            ∫ (t : ℝ) in 0..1, g (a₀ + r * t) = r⁻¹ * ∫ (y : ℝ) in a₀..a₀ + r, g y

                                            The normalized cell average in the variable t ∈ [0, 1] is the cell average in y.

                                            theorem TrilinearHT.Auto.first_success_bound {m₀ : ℕ} {κ : Fin m₀ → Type u_1} (T : (j : Fin m₀) → Finset (κ j)) (H : Finset ℕ) (good : (j : Fin m₀) → ℕ → κ j → Prop) (f : ((j : Fin m₀) → κ j) → ℂ) (e : ((j : Fin m₀) → κ j) → ℝ) (hp : ∀ r ∈ Fintype.piFinset T, {h ∈ H | ∀ (j : Fin m₀), good j h (r j)}.Nonempty) (Ψ : (n : ℕ) → (Fin n → Fin m₀) → (Fin n → ℕ) → ℕ → ℝ) (hterm : ∀ (n : ℕ) (a : Fin n → Fin m₀), ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∀ h ∈ H, ‖∑ r ∈ Fintype.piFinset T with ∀ (j : Fin m₀), roleMask (good j) j a w h (r j), f r‖ ≤ Ψ n a w h + ∑ r ∈ Fintype.piFinset T with ∀ (j : Fin m₀), roleMask (good j) j a w h (r j), e r) {C Z ρ : ℝ} (hρ : 0 ≤ ρ) (hq : ↑m₀ * ρ ^ (1 / ↑m₀) < 1) (hmom : ∀ (n : ℕ) (a : Fin n → Fin m₀), ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ h ∈ H, (↑H.card ^ (n + 1))⁻¹ * Ψ n a w h ≤ C * (ρ ^ n) ^ (1 / ↑m₀) * Z) :
                                            ‖∑ r ∈ Fintype.piFinset T, f r‖ ≤ C * Z / (1 - ↑m₀ * ρ ^ (1 / ↑m₀)) + ∑ r ∈ Fintype.piFinset T, e r

                                            Blueprint lines 2566-2582 (the core terms over failure histories): if, for every trial count, assignment, failed word and final height, the masked tuple sum is at most a principal quantity Ψ plus the per-tuple numerical errors e, and the averages of Ψ over the words and final heights obey the moment bound C (ρ^n)^{1/m₀} Z (word_moment_bound), then with m₀ ρ^{1/m₀} < 1 the full tuple sum is at most C Z / (1 - m₀ ρ^{1/m₀}) + Σ_r e_r (each pure tuple has first-success weight one, first_success_masked; the assignments are summed as in assignments_total).

                                            theorem TrilinearHT.Auto.word_moment_bound_real (H : Finset ℕ) (n : ℕ) {m₀ : ℕ} (hm : 2 ≤ m₀) (A : Fin m₀ → (Fin n → ℕ) → ℝ) (hA0 : ∀ (j : Fin m₀) (w : Fin n → ℕ), 0 ≤ A j w) {C ρ : ℝ} (hC : 1 ≤ C) (hρ : 0 ≤ ρ) (σ : Fin m₀ → ℝ) (hσ : ∀ (j : Fin m₀), 0 ≤ σ j) (nj : Fin m₀ → ℕ) (hdet : ∀ (j : Fin m₀), ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, A j w ≤ C * σ j) (hsq : ∀ (j : Fin m₀), ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * A j w ^ 2 ≤ C * ρ ^ nj j * σ j ^ 2) :
                                            ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * ∏ j : Fin m₀, A j w ≤ C ^ m₀ * (ρ ^ ∑ j : Fin m₀, nj j) ^ (1 / ↑m₀) * ∏ j : Fin m₀, σ j

                                            word_moment_bound for nonnegative real role sizes.

                                            theorem TrilinearHT.Auto.sum_assigned_card {m₀ n : ℕ} (a : Fin n → Fin m₀) :
                                            ∑ j : Fin m₀, {i : Fin n | a i = j}.card = n

                                            The assigned counts of the roles add up to the number of failed trials.

                                            theorem TrilinearHT.Auto.principal_word_average (H : Finset ℕ) {m₀ : ℕ} (hm : 2 ≤ m₀) {n : ℕ} (a : Fin n → Fin m₀) {π : ℕ → Type u_1} (Pset : (h : ℕ) → Finset (π h)) (cf : (h : ℕ) → π h → ℝ) (hcf : ∀ (h : ℕ), ∀ p ∈ Pset h, 0 ≤ cf h p) (A : (h : ℕ) → π h → Fin m₀ → (Fin n → ℕ) → ℝ) (hA0 : ∀ (h : ℕ) (p : π h) (j : Fin m₀) (w : Fin n → ℕ), 0 ≤ A h p j w) (σ : (h : ℕ) → π h → Fin m₀ → ℝ) (hσ : ∀ (h : ℕ) (p : π h) (j : Fin m₀), 0 ≤ σ h p j) {ρ : ℝ} (hρ : 0 ≤ ρ) (hdet : ∀ h ∈ H, ∀ p ∈ Pset h, ∀ (j : Fin m₀), ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, A h p j w ≤ 2 * σ h p j) (hsq : ∀ h ∈ H, ∀ p ∈ Pset h, ∀ (j : Fin m₀), ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * A h p j w ^ 2 ≤ 2 * ρ ^ {i : Fin n | a i = j}.card * σ h p j ^ 2) :
                                            ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ h ∈ H, (↑H.card ^ (n + 1))⁻¹ * ∑ p ∈ Pset h, cf h p * ∏ j : Fin m₀, A h p j w ≤ 2 ^ m₀ * (ρ ^ n) ^ (1 / ↑m₀) * ∑ h ∈ H, (↑H.card)⁻¹ * ∑ p ∈ Pset h, cf h p * ∏ j : Fin m₀, σ h p j

                                            Blueprint lines 2568-2575 (Hölder with m₀ factors over the words, then the final heights): if the principal quantity of a word and final height is Σ_p c_p Π_j a'_{j,p}(w) with role sizes a'_{j,p} ≤ 2 σ_{j,p} and word averages of a'_{j,p}² at most 2 ρ^{n_j} σ_{j,p}², then its average over the words and final heights is at most 2^{m₀} (ρ^n)^{1/m₀} Z, with Z = Σ_h |H|⁻¹ Σ_p c_p Π_j σ_{j,p}.

                                            theorem TrilinearHT.Auto.sum_fiber_pi {ι : Type u_1} [Fintype ι] [DecidableEq ι] {κ : ι → Type u_2} {τ : ι → Type u_3} (M : (l : ι) → Finset (κ l)) (cls : (l : ι) → κ l → τ l) (e : ((l : ι) → κ l) → ℝ) :
                                            ∑ p ∈ Fintype.piFinset fun (l : ι) => Finset.image (cls l) (M l), ∑ r ∈ Fintype.piFinset M with ∀ (l : ι), cls l (r l) = p l, e r = ∑ r ∈ Fintype.piFinset M, e r

                                            Summing over the class tuples of the members of each class tuple recovers the full sum.

                                            theorem TrilinearHT.Auto.form_integrable_of_bounded {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (f : Fin 4 → ℝ → ℂ) (hfm : ∀ (j : Fin 4), Measurable (f j)) (M : Fin 4 → ℝ) (hfb : ∀ (j : Fin 4), ∀ y ∈ Set.Icc a₀ (a₀ + r), ‖f j y‖ ≤ M j) :

                                            The local form integrand of measurable inputs bounded on the cell is integrable.

                                            The height of a vector padded by zeros in front.

                                            theorem TrilinearHT.Auto.pure_gap_of_gap {dv dz : ℕ} (θv : Fin dv → ℝ) (ϑ : Fin dz → ℝ) {H : ℕ} (hH : 1 ≤ H) {ε Λ : ℝ} (hgap : ∀ (a : Fin (dv + dz) → ℚ), vecHeight a ≤ H → |ratEval (Fin.append θv ϑ) a| ≤ ε ∨ Λ ≤ |ratEval (Fin.append θv ϑ) a|) (a : Fin dz → ℚ) :
                                            vecHeight a ≤ H → |ratEval ϑ a| ≤ ε ∨ Λ ≤ |ratEval ϑ a|

                                            Blueprint lines 2482-2484 ("a successful component contains a nonexceptional primary; apply its gap eq:gap to pure ϑ shifts"): the gap of a frequency vector Θ = (θ_v, ϑ) at height H restricts to pure ϑ shifts of height at most H.

                                            theorem TrilinearHT.Auto.vecHeight_int_le {d : ℕ} (v : Fin d → ℤ) {B : ℕ} (hB : 1 ≤ B) (hv : ∀ (i : Fin d), |↑(v i)| ≤ ↑B) :
                                            (vecHeight fun (i : Fin d) => ↑(v i)) ≤ B

                                            Integer vectors with entries bounded by B ≥ 1 have height at most B.

                                            theorem TrilinearHT.Auto.expP_entries_le {d : ℕ} (L QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (n : (j : Fin 4) → ι j → Fin d → ℤ) {Nb : ℝ} (hn : ∀ (j : Fin 4), ∀ k ∈ F j, ∀ (i : Fin d), |↑(n j k i)| ≤ Nb) (x : (Fin (d + d) → ℤ) × ((j : Fin 4) → (Fin d → ℤ) × ι j)) (hx : x ∈ frequencyBox (d + d) Bx ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox d Bx ×ˢ F j) (i : Fin d) :
                                            |↑(expP1 L QL n x i)| ≤ ↑L * ↑Bx + 4 * (↑QL * ↑Bx + Nb) ∧ |↑(expP2 L QL n x i)| ≤ ↑L * ↑Bx + 4 * (3 * (↑QL * ↑Bx + Nb))

                                            Entries of the four-core expansion frequencies are bounded by the box and shift sizes.

                                            noncomputable def TrilinearHT.Auto.sideSd (z : ChartTag) (ρ : Fin z.dim → ℝ) (l : Fin 4) (g : ℝ → ℂ) (y : ℝ) :

                                            The anchored side function e(-c_l p_ρ(y)) f_l(y) of the three-core reduction.

                                            Equations
                                            Instances For
                                              noncomputable def TrilinearHT.Auto.coreG {d : ℕ} (QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (cc : Fin 4 → (Fin d → ℤ) → ℂ) (j : Fin 4) (u : StandardTorus d) :

                                              The truncated torus input Σ_{(v, k) ∈ B × F_j} cc_v c_k χ_{QL v + n_k} of a role.

                                              Equations
                                              Instances For
                                                noncomputable def TrilinearHT.Auto.coreR {d : ℕ} (L Bx : ℕ) (cm : (Fin (d + d) → ℤ) → ℂ) (u v : StandardTorus d) :

                                                The truncated torus multiplier Σ_q cm_q χ_{L q'}(u) χ_{L q''}(v).

                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For
                                                  noncomputable def TrilinearHT.Auto.coreRA {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (L QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (cc : Fin 4 → (Fin d → ℤ) → ℂ) (cm : (Fin (d + d) → ℤ) → ℂ) (l : Fin 4) (uv : ↥(torusAnnihilator (rationalIntegerIntersection V)) × ↥(torusAnnihilator (rationalIntegerIntersection V))) :

                                                  The re-anchored multiplier R(u - l v, v) g_l(u) on the annihilator of K ∩ ℤ^d.

                                                  Equations
                                                  Instances For
                                                    theorem TrilinearHT.Auto.integral_sqrt_le {α : Type u_1} [MeasurableSpace α] (μ : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure μ] {X : α → ℝ} (hX0 : ∀ (x : α), 0 ≤ X x) (hXi : MeasureTheory.Integrable X μ) :
                                                    MeasureTheory.Integrable (fun (x : α) => √(X x)) μ ∧ ∫ (x : α), √(X x) ∂μ ≤ √(∫ (x : α), X x ∂μ)

                                                    Jensen for the square root on a probability space: E √X ≤ √(E X).

                                                    theorem TrilinearHT.Auto.cell_coeff_eq_fourierCoeffOn {a r : ℝ} (hr : 0 < r) (S : ℝ → ℂ) (k : ℤ) :
                                                    ∫ (y : ℝ) in Set.Ico a (a + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r) = ↑r * fourierCoeffOn ⋯ S (-k)

                                                    The cell Fourier coefficient ∫_I S(y) e(k y / r) dy is r times the interval Fourier coefficient of S at -k.

                                                    theorem TrilinearHT.Auto.cell_coeff_bessel {a r : ℝ} (hr : 0 < r) (S : ℝ → ℂ) (hL2 : MeasureTheory.MemLp S 2 (MeasureTheory.volume.restrict (Set.Ioc a (a + r)))) (s : Finset ℤ) :
                                                    ∑ k ∈ s, ‖∫ (y : ℝ) in Set.Ico a (a + r), S y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖ ^ 2 ≤ r * ∫ (y : ℝ) in a..a + r, ‖S y‖ ^ 2

                                                    Bessel's inequality for the cell Fourier coefficients of a square-integrable side function: Σ_{k ∈ s} |∫_I S(y) e(k y / r) dy|² ≤ r ∫_I |S|² (blueprint lines 2556-2560, the side windows b_Λ).

                                                    The branch phase is jointly measurable in the offset and the point.

                                                    theorem TrilinearHT.Auto.measurable_sideSd_uncurry (z : ChartTag) (l : Fin 4) {g : ℝ → ℂ} (hg : Measurable g) :
                                                    Measurable fun (p : (Fin z.dim → ℝ) × ℝ) => sideSd z p.1 l g p.2

                                                    The anchored side function is jointly measurable in the offset and the point.

                                                    theorem TrilinearHT.Auto.norm_sideSd (z : ChartTag) (ρ : Fin z.dim → ℝ) (l : Fin 4) (g : ℝ → ℂ) (y : ℝ) :
                                                    ‖sideSd z ρ l g y‖ = ‖g y‖

                                                    The anchored side function has the modulus of the side function.

                                                    theorem TrilinearHT.Auto.window_energy_integrable (z : ChartTag) (l : Fin 4) {g : ℝ → ℂ} (hg : Measurable g) {a r : ℝ} (hr : 0 < r) (hL2 : MeasureTheory.MemLp g 2 (MeasureTheory.volume.restrict (Set.Ioc a (a + r)))) (K : Finset ℤ) :
                                                    MeasureTheory.Integrable (fun (ρ : Fin z.dim → ℝ) => ∑ k ∈ K, ‖∫ (y : ℝ) in Set.Ico a (a + r), sideSd z ρ l g y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖ ^ 2) (offsetMeasure z.dim) ∧ ∀ (ρ : Fin z.dim → ℝ), ∑ k ∈ K, ‖∫ (y : ℝ) in Set.Ico a (a + r), sideSd z ρ l g y * Complex.exp (2 * ↑Real.pi * Complex.I * ↑k * ↑y / ↑r)‖ ^ 2 ≤ r * ∫ (y : ℝ) in a..a + r, ‖g y‖ ^ 2

                                                    Blueprint lines 2556-2560 (the side window energies b_Λ² before the offset average): for a measurable side function, square integrable on the cell, the window energy X(ρ) = Σ_{k ∈ K} |∫_I S'_ρ(y) e(k y / r) dy|² of the anchored side is integrable in the fresh offset and at most r ∫_I |f_l|² for every offset.

                                                    theorem TrilinearHT.Auto.coreG_factor {d : ℕ} (QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (cc : Fin 4 → (Fin d → ℤ) → ℂ) (j : Fin 4) (u : StandardTorus d) :
                                                    coreG QL Bx F c n cc j u = (∑ v ∈ frequencyBox d Bx, cc j v * torusCharacter (↑QL • v) u) * ∑ k ∈ F j, c j k * torusCharacter (n j k) u

                                                    The truncated torus input of a role factors as (truncated cutoff) × (input polynomial).

                                                    theorem TrilinearHT.Auto.coreG_eLpNorm_le {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) (QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin d → ℤ) (cc : Fin 4 → (Fin d → ℤ) → ℂ) (j : Fin 4) {M : ℝ} (hM : 0 ≤ M) (hsup : ∀ (u : StandardTorus d), ‖∑ v ∈ frequencyBox d Bx, cc j v * torusCharacter (↑QL • v) u‖ ≤ M) :

                                                    Blueprint lines 2487-2495 (eq:torus-size for the truncated inputs): if the truncated cutoff of role j is at most M on the torus, the L²(𝓗) norm of the truncated torus input is at most M times that of the input polynomial Σ_k c_k χ_{n_k}.

                                                    theorem TrilinearHT.Auto.offset_average_sqrt_sum {α : Type u_1} {ι : Type u_2} [MeasurableSpace α] (μ : MeasureTheory.Measure α) [MeasureTheory.IsProbabilityMeasure μ] (s : Finset ι) {Φ : α → ℝ} {X : ι → α → ℝ} {a F : ℝ} {b : ι → ℝ} (hb : ∀ i ∈ s, 0 ≤ b i) (hΦ0 : ∀ (x : α), 0 ≤ Φ x) (hX0 : ∀ i ∈ s, ∀ (x : α), 0 ≤ X i x) (hXi : ∀ i ∈ s, MeasureTheory.Integrable (X i) μ) (hΦ : ∀ᵐ (x : α) ∂μ, Φ x ≤ a + ∑ i ∈ s, b i * √(X i x)) (hF : F ≤ 2 * ∫ (x : α), Φ x ∂μ) :
                                                    F ≤ 2 * (a + ∑ i ∈ s, b i * √(∫ (x : α), X i x ∂μ))

                                                    offset_average_sqrt with several square-root terms and an almost-everywhere bound: if F ≤ 2 E Φ and Φ ≤ a + Σ_i b_i √X_i almost everywhere, then F ≤ 2 (a + Σ_i b_i √(E X_i)).

                                                    theorem TrilinearHT.Auto.offsetMeasure_ae_mem (d : ℕ) :
                                                    ∀ᵐ (ρ : Fin d → ℝ) ∂offsetMeasure d, ∀ (a : Fin d), ρ a ∈ Set.Icc 0 1

                                                    Almost every fresh offset lies in the unit cube.

                                                    noncomputable def TrilinearHT.Auto.sideWinE (z : ChartTag) (l : Fin 4) (g : ℝ → ℂ) (a r : ℝ) (K : Finset ℤ) (ρ : Fin z.dim → ℝ) :

                                                    The window energy Σ_{k ∈ K} |∫_I S'_ρ(y) e(k y / r) dy|² of the anchored side.

                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For
                                                      theorem TrilinearHT.Auto.ModeComponents.exists_good_label {Mode : Type u_1} {P : Type u_2} [DecidableEq Mode] [DecidableEq P] (C : ModeComponents Mode P) (Δ : ℕ) (goodP : ℕ → P → Prop) [(h : ℕ) → DecidablePred (goodP h)] {h : ℕ} {m : Mode} (hg : C.Good Δ goodP h m) :
                                                      ∃ p ∈ C.labels (C.F h m), goodP h p

                                                      Blueprint line 2482 ("a successful component contains a nonexceptional primary"): a good mode's CURRENT component carries a primary label that is good (goodP h).

                                                      theorem TrilinearHT.Auto.gap_tiny_huge {dv dz : ℕ} (θv : Fin dv → ℝ) (ϑ : Fin dz → ℝ) {Hh : ℕ} (hH : 1 ≤ Hh) {T rv rt r L : ℝ} (hT : 0 < T) (hrv : 0 < rv) (hrt : 0 < rt) (hgap : ∀ (a : Fin (dv + dz) → ℚ), vecHeight a ≤ Hh → |ratEval (Fin.append θv ϑ) a| ≤ T⁻¹ / rv ∨ T / rt ≤ |ratEval (Fin.append θv ϑ) a|) (hsmall : (3 * ↑Hh ^ 2) ^ dz * (↑dz.factorial * ↑Hh ^ (dz ^ 2 + dz)) * (T⁻¹ / rv) < T / rt) (hr : r ≤ rv) (hr' : rt ≤ r) (hL : 0 < L) (n : Fin dz → ℤ) (hn : (vecHeight fun (i : Fin dz) => ↑(n i)) ≤ Hh) :
                                                      (n ∈ rationalIntegerIntersection (tinySpan ϑ Hh (T⁻¹ / rv)) → r * |∑ i : Fin dz, ↑(n i) * (ϑ i / L)| ≤ T⁻¹ / L) ∧ (n ∉ rationalIntegerIntersection (tinySpan ϑ Hh (T⁻¹ / rv)) → T / L ≤ r * |∑ i : Fin dz, ↑(n i) * (ϑ i / L)|)

                                                      Blueprint lines 2482-2486 (frequency tests): the gap eq:gap of a nonexceptional primary Θ = (θ_v, ϑ) at height H (thresholds T⁻¹/r_v and T/r_t), applied to pure ϑ shifts, makes r n·ξ (with ξ = ϑ/L, r_t ≤ r ≤ r_v) tiny (≤ T⁻¹/L) for integer n of height at most H in the tiny span K_B and huge (≥ T/L) otherwise.

                                                      theorem TrilinearHT.Auto.fourK_mu_nu {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (J : ℕ) (x₀ A B : ℝ) :
                                                      ‖fourK a₀ r w x₀ A B‖ * max 1 (max (r * |A|) (r * |B|)) ^ J ≤ (2 * (2 * 4 * (2 * 4 * (kernelDerivBound κ 0 + ((2 * Real.pi) ^ J)⁻¹ * kernelDerivBound κ J))) + (3 + 2) ^ J * (2 * 4 * (2 * Real.pi * 4 * (2 * (4 + 3 * 4) * (kernelDerivBound κ 0 + ((2 * Real.pi) ^ J)⁻¹ * kernelDerivBound κ J))))) * min 1 ((Finset.image (fun (j : Fin 4) => ↑↑j) Finset.univ).inf' ⋯ fun (j : ℝ) => r * |B - j * A|)

                                                      Blueprint lines 2512-2534 (eq:four-tests, the kernel factor of the four-core test): at the reference frequencies (q', t') the kernel sample satisfies |WFourier_s(r q', r t')| ν^J ≤ C_J μ with μ = min(1, min_{0 ≤ j ≤ 3} r|t' - j q'|) and ν = max(1, r|q'|, r|t'|) (the four marginals give zeros on the lines t = j q).

                                                      noncomputable def TrilinearHT.Auto.sideOptF {ι : Fin 4 → Type u_1} (l : Fin 4) (F : (j : Fin 4) → Finset (ι j)) (j : Fin 4) :
                                                      Finset (Option (ι j))

                                                      The core index data of a three-core tuple with side role l, the side carried as one trivial term (none, the convention of three_core_principal).

                                                      Equations
                                                      Instances For
                                                        def TrilinearHT.Auto.sideOptC {ι : Fin 4 → Type u_1} (c : (j : Fin 4) → ι j → ℂ) (j : Fin 4) :
                                                        Option (ι j) → ℂ

                                                        Coefficients of a three-core tuple, 1 on the side term.

                                                        Equations
                                                        Instances For
                                                          def TrilinearHT.Auto.sideOptN {ι : Fin 4 → Type u_1} {d : ℕ} (n : (j : Fin 4) → ι j → Fin d → ℤ) (j : Fin 4) :
                                                          Option (ι j) → Fin d → ℤ

                                                          Torus frequencies of a three-core tuple, 0 on the side term.

                                                          Equations
                                                          Instances For
                                                            noncomputable def TrilinearHT.Auto.fourMu (r A B : ℝ) :

                                                            The four-core test quantity μ = min(1, min_{0 ≤ j ≤ 3} r |t' - j q'|) of eq:four-tests.

                                                            Equations
                                                            Instances For
                                                              noncomputable def TrilinearHT.Auto.fourNu (r A B : ℝ) :

                                                              The four-core test quantity ν = max(1, r |q'|, r |t'|) of eq:four-tests.

                                                              Equations
                                                              Instances For
                                                                @[reducible, inline]
                                                                noncomputable abbrev TrilinearHT.Auto.fourKC (κ : LocalKernelClass) (J : ℕ) :

                                                                The constant C_J of fourK_mu_nu.

                                                                Equations
                                                                Instances For
                                                                  theorem TrilinearHT.Auto.fourK_discard {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) {J : ℕ} (hJ : 1 ≤ J) (x₀ A B : ℝ) {U₀ : ℝ} (hU : 0 < U₀) (hd : fourMu r A B ≤ U₀⁻¹ ∨ U₀ ≤ fourNu r A B) :
                                                                  ‖fourK a₀ r w x₀ A B‖ ≤ fourKC κ J * U₀⁻¹

                                                                  Blueprint lines 2566-2569 (discarded four-core tuples): if the inner minimum is below U₀⁻¹ (μ ≤ U₀⁻¹) or no reference lies in max(|q'|, |t'|) ≤ U₀ R_s (ν ≥ U₀), the kernel sample at the reference is at most C_J U₀⁻¹ (fourK_mu_nu with J ≥ 1).

                                                                  noncomputable def TrilinearHT.Auto.finPick {X : Type u_1} [Inhabited X] (S : Finset X) :
                                                                  X

                                                                  A fixed choice of an element of a finite set (the default if empty).

                                                                  Equations
                                                                  Instances For
                                                                    theorem TrilinearHT.Auto.finPick_mem {X : Type u_1} [Inhabited X] {S : Finset X} (h : S.Nonempty) :
                                                                    noncomputable def TrilinearHT.Auto.cosetRep {d : ℕ} (K : Submodule ℤ (Fin d → ℤ)) (P : Finset (Fin d → ℤ)) (v : Fin d → ℤ) :
                                                                    Fin d → ℤ

                                                                    The reference of the coset of v modulo K among the frequencies P: a fixed member of P in the same coset (blueprint line 2547, "choose one reference n from the box per coset").

                                                                    Equations
                                                                    Instances For
                                                                      theorem TrilinearHT.Auto.cosetRep_spec {d : ℕ} (K : Submodule ℤ (Fin d → ℤ)) (P : Finset (Fin d → ℤ)) {v : Fin d → ℤ} (hv : v ∈ P) :
                                                                      cosetRep K P v ∈ P ∧ v - cosetRep K P v ∈ K
                                                                      theorem TrilinearHT.Auto.cosetRep_eq {d : ℕ} (K : Submodule ℤ (Fin d → ℤ)) (P : Finset (Fin d → ℤ)) {v v' : Fin d → ℤ} (h : v - v' ∈ K) :
                                                                      cosetRep K P v = cosetRep K P v'
                                                                      theorem TrilinearHT.Auto.cosetRep_sub_not_mem {d : ℕ} (K : Submodule ℤ (Fin d → ℤ)) (P : Finset (Fin d → ℤ)) {v v' : Fin d → ℤ} (hv : v ∈ P) (hv' : v' ∈ P) (hne : cosetRep K P v ≠ cosetRep K P v') :
                                                                      cosetRep K P v - cosetRep K P v' ∉ K
                                                                      noncomputable def TrilinearHT.Auto.slotVal {V : Type u_1} [NormedAddCommGroup V] (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (sub : (l : Fin 4) → κ l → V) (s e : Fin 4 → V) (l : Fin 4) (o : Option (κ l)) :
                                                                      V

                                                                      The value of one slot of a pattern at one index: the component subtotal in a core slot, the pattern piece otherwise (compSlot at a single slot).

                                                                      Equations
                                                                      Instances For
                                                                        theorem TrilinearHT.Auto.compSlot_eq_slotVal {V : Type u_1} [NormedAddCommGroup V] (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (sub : (l : Fin 4) → κ l → V) (s e : Fin 4 → V) (r : (l : Fin 4) → Option (κ l)) :
                                                                        compSlot σ sub s e r = fun (l : Fin 4) => slotVal σ sub s e l (r l)
                                                                        theorem TrilinearHT.Auto.pattern_leaf_bound {V : Type u_1} [NormedAddCommGroup V] [NormedSpace ℂ V] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => V) ℂ) (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (Ks : (l : Fin 4) → Finset (κ l)) (sub : (l : Fin 4) → κ l → V) (s e : Fin 4 → V) (H : Finset ℕ) (good : (l : Fin 4) → ℕ → Option (κ l) → Prop) (hp : ∀ r ∈ Fintype.piFinset (compIdx σ Ks), {h ∈ H | ∀ (l : Fin 4), good l h (r l)}.Nonempty) {ι : Fin 4 → Type u_3} [(l : Fin 4) → DecidableEq (ι l)] (cls : ℕ → (l : Fin 4) → Option (κ l) → ι l) (Ψ : (n : ℕ) → (Fin n → Fin 4) → (Fin n → ℕ) → ℕ → ((l : Fin 4) → ι l) → ℝ) (err : ((l : Fin 4) → Option (κ l)) → ℝ) (hgrp : ∀ (n : ℕ) (a : Fin n → Fin 4), ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∀ h ∈ H, ∀ p ∈ Fintype.piFinset fun (l : Fin 4) => Finset.image (cls h l) (Finset.filter (roleMask (good l) l a w h) (compIdx σ Ks l)), ‖Λ fun (l : Fin 4) => ∑ o ∈ Finset.filter (roleMask (good l) l a w h) (compIdx σ Ks l) with cls h l o = p l, slotVal σ sub s e l o‖ ≤ Ψ n a w h p + ∑ r ∈ Fintype.piFinset fun (l : Fin 4) => Finset.filter (roleMask (good l) l a w h) (compIdx σ Ks l) with ∀ (l : Fin 4), cls h l (r l) = p l, err r) {C Z ρ : ℝ} (hρ : 0 ≤ ρ) (hq : 4 * ρ ^ (1 / 4) < 1) (hmom : ∀ (n : ℕ) (a : Fin n → Fin 4), ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ h ∈ H, (↑H.card ^ (n + 1))⁻¹ * ∑ p ∈ Fintype.piFinset fun (l : Fin 4) => Finset.image (cls h l) (Finset.filter (roleMask (good l) l a w h) (compIdx σ Ks l)), Ψ n a w h p ≤ C * (ρ ^ n) ^ (1 / 4) * Z) :
                                                                        ‖∑ r ∈ Fintype.piFinset (compIdx σ Ks), Λ (compSlot σ sub s e r)‖ ≤ C * Z / (1 - 4 * ρ ^ (1 / 4)) + ∑ r ∈ Fintype.piFinset (compIdx σ Ks), err r

                                                                        Blueprint lines 2463-2582 for one pattern on a leaf cell and group (core slots expanded into their components, sides and errors fixed): the pattern form is at most C Z / (1 - 4 ρ^{1/4}) + Σ_r e_r if for every failure history (n, a, w, h) the forms of the masked slot sums grouped by the final-height classes cls h are at most principal quantities Ψ_p plus the errors of their member tuples, and the history averages of Σ_p Ψ_p obey the moment bound (first_success_bound, multilinear_regroup).

                                                                        theorem TrilinearHT.Auto.ModeSystem.allComps_pairwiseDisjoint {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) :
                                                                        (↑(Ms.allComps S hA b J)).PairwiseDisjoint id

                                                                        Distinct minimal components of a block on a pre-cell are disjoint.

                                                                        theorem TrilinearHT.Auto.ModeSystem.coreComps_pairwiseDisjoint {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (J : ℤ × ℤ) :
                                                                        (↑(Ms.coreComps S hA SP b J)).PairwiseDisjoint id
                                                                        theorem TrilinearHT.Auto.ModeSystem.compClass_eq_of_mem {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) (h : ℕ) {K : Finset Ms.Md} (hK : K ∈ Ms.allComps S hA b J) {z : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hz : ↑z ∈ K) :
                                                                        Ms.compClass S hA b J h K = Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F h z)

                                                                        The class of a minimal component is the CURRENT component of any of its modes.

                                                                        theorem TrilinearHT.Auto.sum_by_bins {ι : Type u_1} {β : Type u_2} [DecidableEq β] (T : Finset ι) (bin : ι → β) (val : β → ℝ) (w : ι → ℝ) (hw : ∀ p ∈ T, w p ≤ val (bin p)) :
                                                                        ∑ p ∈ T, w p ≤ ∑ c ∈ Finset.image bin T, val c * ↑{p ∈ T | bin p = c}.card

                                                                        Blueprint lines 2576-2582 and 2775-2776 ("after fixing ... the dyadic amplitude and frequency bins ... a uniform per-bin estimate suffices"): if every term is at most the value of its bin, the sum is at most the sum over the occupied bins of the bin value times the number of terms in the bin.

                                                                        The frequency dichotomy on the side states (blueprint lines 2483-2487) #

                                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.tinySmall_of_valid {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : D.S.Valid Cj CA CT CK δs W) (hCT : 4 ≤ CT) (hd2 : 2 ≤ D.S.dmax) (hD : 2 ≤ D.S.Dstar) (hB : 2 ≤ D.S.Bstar) (hQ : 1 ≤ D.S.Q0) (hSP : D.SP = D.S.sideParams δs) {d : ℕ} (hd : d ≤ D.S.dmax) (b : ℤ) :
                                                                        (3 * ↑D.SP.Hn ^ 2) ^ d * (↑d.factorial * ↑D.SP.Hn ^ (d ^ 2 + d)) * (D.SP.Tt⁻¹ / dyadicGridLength A.G (b - 2 * ↑D.S.K)) < D.SP.Tt / dyadicGridLength A.G (b + ↑D.S.K)

                                                                        The tiny-span smallness eq:mode-parameters at the chosen schedule: the spanning constant of the tiny span of a chart of dimension at most d_max times the tiny threshold T⁻¹/r_{v_b} is below the large threshold T/r_{t_b} (Valid.tinySpan_small).

                                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.frequency_dichotomy {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (I : ℤ × ℤ) (l : Fin 4) (G : bf.Grp) {h : ℕ} {m : ↥((D.Ms l G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hgood : ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).Good D.SP.Δ ((D.Ms l G).goodP D.S D.SP (A.blkStart D.S.K I.1)) h m) (hHn : 1 ≤ D.SP.Hn) (hT : 0 < D.SP.Tt) (hsmall : (3 * ↑D.SP.Hn ^ 2) ^ (D.Ms l G).zc.dim * (↑(D.Ms l G).zc.dim.factorial * ↑D.SP.Hn ^ ((D.Ms l G).zc.dim ^ 2 + (D.Ms l G).zc.dim)) * (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K)) < D.SP.Tt / dyadicGridLength A.G (A.blkStart D.S.K I.1 + ↑D.S.K)) {L : ℝ} (hL : 0 < L) :
                                                                        ∃ p ∈ ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).labels (((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F h m), (D.Ms l G).goodP D.S D.SP (A.blkStart D.S.K I.1) h p ∧ ∀ (n : Fin (D.Ms l G).zc.dim → ℤ), (vecHeight fun (i : Fin (D.Ms l G).zc.dim) => ↑(n i)) ≤ D.SP.Hn → (n ∈ rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms l G).zc.dim) => (D.Ms l G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K))) → dyadicGridLength A.G I.1 * |∑ i : Fin (D.Ms l G).zc.dim, ↑(n i) * ((D.Ms l G).zc.θ i / ↑D.S.Q0 / L)| ≤ D.SP.Tt⁻¹ / L) ∧ (n ∉ rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms l G).zc.dim) => (D.Ms l G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K))) → D.SP.Tt / L ≤ dyadicGridLength A.G I.1 * |∑ i : Fin (D.Ms l G).zc.dim, ↑(n i) * ((D.Ms l G).zc.θ i / ↑D.S.Q0 / L)|)

                                                                        Blueprint lines 2483-2487 on a leaf cell I of the side states: a mode good at a height h for the block components on the pre-cell lies in a CURRENT component carrying a nonexceptional key p ("a successful component contains a nonexceptional primary"); its gap eq:gap, applied to pure ϑ shifts, makes |I| n·ξ (ξ = ϑ / L) tiny (≤ T⁻¹/L) for every integer n of height at most H in the rational tiny-frequency space K_B and huge (≥ T/L) otherwise.

                                                                        theorem TrilinearHT.Auto.ModeSchedule.Valid.Dstar_le_A0 {S : ModeSchedule} {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : S.Valid Cj CA CT CK δs W) (hCA : 1 ≤ CA) (hd2 : 2 ≤ S.dmax) (hD : 2 ≤ S.Dstar) (hB : 2 ≤ S.Bstar) :

                                                                        D_* ≤ A₀ (blueprint line 1955).

                                                                        theorem TrilinearHT.Auto.ModeSchedule.Valid.box_lt_H {S : ModeSchedule} {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : S.Valid Cj CA CT CK δs W) (hCA : 1 ≤ CA) (hd2 : 2 ≤ S.dmax) (hD : 2 ≤ S.Dstar) (hB : 2 ≤ S.Bstar) (hQ : 1 ≤ S.Q0) {h : ℕ} (hh : h ≤ S.Jstar) :
                                                                        16 * S.Dstar ^ 5 * S.Eh h < S.H

                                                                        Sixteen times the frequency box is below H (blueprint lines 2483-2487: "apply its gap to pure ϑ shifts in all the boxes under consideration"; differences of the four-core expansion frequencies): 16 D_*^5 E_h < H for h ≤ J_*.

                                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.box_dichotomy {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : D.S.Valid Cj CA CT CK δs W) (hCA : 1 ≤ CA) (hCT : 4 ≤ CT) (hd2 : 2 ≤ D.S.dmax) (hD : 2 ≤ D.S.Dstar) (hB : 2 ≤ D.S.Bstar) (hQ : 1 ≤ D.S.Q0) (hSP : D.SP = D.S.sideParams δs) (I : ℤ × ℤ) (l : Fin 4) (G : bf.Grp) (hdim : (D.Ms l G).zc.dim ≤ D.S.dmax) {h : ℕ} (hh : h ≤ D.SP.Jst) {m : ↥((D.Ms l G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hgood : ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).Good D.SP.Δ ((D.Ms l G).goodP D.S D.SP (A.blkStart D.S.K I.1)) h m) :
                                                                        ∃ p ∈ ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).labels (((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F h m), (D.Ms l G).goodP D.S D.SP (A.blkStart D.S.K I.1) h p ∧ ∀ (n : Fin (D.Ms l G).zc.dim → ℤ), (∀ (i : Fin (D.Ms l G).zc.dim), |↑(n i)| ≤ 16 * D.S.Dstar ^ 5 * D.S.Eh (h - D.SP.Δ)) → (n ∈ rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms l G).zc.dim) => (D.Ms l G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K))) → dyadicGridLength A.G I.1 * |∑ i : Fin (D.Ms l G).zc.dim, ↑(n i) * (D.Ms l G).torusξ D.S (h - D.SP.Δ) i| ≤ D.SP.Tt⁻¹ / ModeSchedule.Lh (h - D.SP.Δ)) ∧ (n ∉ rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms l G).zc.dim) => (D.Ms l G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K))) → D.SP.Tt / ModeSchedule.Lh (h - D.SP.Δ) ≤ dyadicGridLength A.G I.1 * |∑ i : Fin (D.Ms l G).zc.dim, ↑(n i) * (D.Ms l G).torusξ D.S (h - D.SP.Δ) i|)

                                                                        Blueprint lines 2483-2487 for every character difference needed below: at the chosen schedule (S.Valid, side parameters S.sideParams δ_*), on a leaf cell I and for a mode good at a final upper height h with predecessor height h - Δ, every integer frequency n with |n|_∞ ≤ 16 B'_{h-Δ} = 16 D_*^5 E_{h-Δ} (all the boxes under consideration) has |I| n·ξ tiny if n ∈ K_B and huge otherwise (ξ = ϑ / L_{h-Δ}, K_B the rational tiny-frequency space of a nonexceptional key of the successful component). The torus 𝓗 = (K_B ∩ ℤ^d)^⊥ is connected with exact character integrals (rationalAnnihilator).