Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec131OneExpansionAtFirstMatch.ChooseSchedule

Trilinear Hilbert transform: chooseSchedule #

theorem TrilinearHT.Auto.chooseSchedule (Cj CA CT CK : ℕ) {δs : ℝ} (hδs : 0 < δs) (_hδs1 : δs ≤ 1) :
∃ (M : ℝ), 0 < M ∧ ∀ (dmax : ℕ) (Dstar Bstar Dm : ℝ) (Wf : ℝ → ℝ) (Q0 : ℕ), 2 ≤ dmax → 2 ≤ Dstar → 2 ≤ Bstar → 2 ≤ Dm → 1 ≤ Q0 → (∀ (y : ℝ), 0 ≤ Wf y) → have Λ := ↑dmax + Real.log Dstar + Real.log Bstar + Real.log Dm + Real.log ↑Q0 + 1; ∃ (S : ModeSchedule), S.dmax = dmax ∧ S.Dstar = Dstar ∧ S.Bstar = Bstar ∧ S.Dm = Dm ∧ S.Q0 = Q0 ∧ S.Valid Cj CA CT CK δs (Wf S.H) ∧ Real.log S.H ≤ M * Λ ^ 12 ∧ Real.log S.T ≤ M * Λ ^ 16 ∧ ↑S.K ≤ 2 * Wf S.H + M * Λ ^ 16

Blueprint mode-schedule (line 1976, THT.Modes.chooseSchedule): given the main budget D_m, the dimension bound d_max, the mode budget D_*, the cutoff B_*, the clearing integer Q₀ and the packet width W(H) as a function of the height H (lem:height), the parameters of eq:mode-parameters can be chosen in the displayed order (K last, using W(H) at the chosen H), and all their logarithms are polynomial in Λ = d_max + log D_* + log B_* + log D_m + log Q₀ + 1: log H ≤ M Λ^{12}, log T ≤ M Λ^{16}, K ≤ 2 W(H) + M Λ^{16}, with M depending only on the absolute constants.

@[simp]
theorem TrilinearHT.Auto.foldIdx_castAdd {d : ℕ} (a : Fin d) :
@[simp]
theorem TrilinearHT.Auto.foldIdx_addNat {d : ℕ} (a : Fin d) :
foldIdx d (a.addNat d) = a
def TrilinearHT.Auto.diagAvgQ (d : ℕ) :
Matrix (Fin (d + d)) (Fin (d + d)) ℚ

The averaging projection of the doubled coordinates onto the diagonal.

Equations
Instances For
    theorem TrilinearHT.Auto.diagAvg_sum {d : ℕ} (i : Fin (d + d)) (f : Fin (d + d) → ℝ) :
    ∑ k : Fin (d + d), diagAvgR d i k * f k = 1 / 2 * (f (Fin.castAdd d (foldIdx d i)) + f (Fin.natAdd d (foldIdx d i)))
    theorem TrilinearHT.Auto.diagAvgQ_map {d : ℕ} :
    ((diagAvgQ d).map fun (q : ℚ) => ↑q) = diagAvgR d
    theorem TrilinearHT.Auto.tagEdge_refl {B : ℝ} (hB : 2 ≤ B) (r : ℝ) (v : ChartTag) :
    tagEdge B r v v

    Equal tags are joined by an edge of every height B ≥ 2: the diagonal of the doubled coordinates is isotropic for the difference form, and the difference data vanish on it.

    Primaries of a ball are joined to the group center (blueprint lines 1893-1903) #

    Complexity of the branch charts of a group center (blueprint lines 1893-1903) #

    noncomputable def TrilinearHT.Auto.bumpConst :

    The Gevrey constant of the bump normalization.

    Equations
    Instances For
      theorem TrilinearHT.Auto.branchProfile_deriv_le {δ : ℝ} (hδ : 0 < δ) {m i : ℕ} (hi : i ≤ m) (x : ℝ) :
      |iteratedDeriv i (branchProfile δ) x| ≤ (bumpConst * (8 * (↑m + 1)) ^ 32 * (2 / δ)) ^ i

      The branch profile at width δ has geometric derivative bounds of ratio A (8(m+1))³² (2/δ) up to order m.

      theorem TrilinearHT.Auto.branchAmp_eq_shift {d : ℕ} (δ : ℝ) (ρ : Fin d → ℝ) :
      branchAmp δ ρ = fun (w : Fin d → ℝ) => chartCoordinateProduct (branchProfile δ) (w - ρ)

      The branch amplitude is the coordinate product of the branch profile, shifted by ρ.

      theorem TrilinearHT.Auto.branchAmp_iteratedFDeriv_le {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (ρ w : Fin d → ℝ) (m : ℕ) :
      ‖iteratedFDeriv ℝ m (branchAmp δ ρ) w‖ ≤ (↑d * (bumpConst * (8 * (↑m + 1)) ^ 32 * (2 / δ))) ^ m
      theorem TrilinearHT.Auto.branchChart_complexity (z : ChartTag) (c : ℤ) {δ : ℝ} (hδ : 0 < δ) (hδ' : δ < 1 / 4) (ρ : Fin z.dim → ℝ) (hρ : ∀ (i : Fin z.dim), ρ i ∈ Set.Icc 0 1) {H : ℝ} (hH : Real.exp 2 ≤ H) (hdim : ↑z.dim ≤ Real.log H) (hC : ∀ (i j : Fin z.dim), ↑(chartRationalHeight ((↑(-c) • z.C) i j)) ≤ H) (hHδ : ↑z.dim * (bumpConst * 8 ^ 32 * (2 / δ)) ≤ H) :

      Blueprint lines 1893-1903: the branch chart of a center tag z in a slot of multiplier c (phase -c p_ρ, amplitude the periodic Gevrey branch cutoff of width δ) has Gevrey order 32 complexity at every height H ≥ d A 8³² (2/δ) dominating e², its dimension and matrix heights (offsets in [0,1]).

      Recentred first-match expansions (blueprint lines 1903-1922: "recentring adds only a #

      common unrestricted linear phase")

      theorem TrilinearHT.Auto.firstMatchExpansion_at (c₀ : ℕ) (hc : 1 ≤ c₀) (R : ℝ) (hR : 0 ≤ R) :
      ∃ (D : ℕ), 1 ≤ D ∧ ∀ (v z : ChartTag) (c : ℤ), c ≠ 0 → |c| ≤ 3 → ∀ (H B r : ℝ) (Φ : QuadraticChartData v.dim) {g : (Fin z.dim → ℝ) → ℂ} (hg : ContDiff ℝ (↑⊤) g) (hgc : HasCompactSupport g), Φ.horizontal = v.θ → Φ.matrix = ↑c • v.C → Φ.quadratic = ↑c * v.lam → QuadraticChartComplexity c₀ H (productQuadraticChart Φ (branchChart z c hg hgc)) → 0 < r → 2 ≤ B → tagEdge B r v z → ∀ (a₀ : ℝ), have P := productQuadraticChart Φ (branchChart z c hg hgc); have X := 1 + Real.log (chartTranslationBudget H) + Real.log (3 * B); ∃ (M : Matrix (Fin (v.dim + z.dim)) (Fin (v.dim + z.dim)) ℚ), (∀ (i j : Fin (v.dim + z.dim)), ↑(rationalHeight (M i j)) ≤ Real.exp (↑D * X ^ D)) ∧ |P.quadratic + ∑ i : Fin (v.dim + z.dim), ∑ j : Fin (v.dim + z.dim), P.horizontal i * ↑(M i j) * P.horizontal j| * r ^ 2 ≤ Real.exp (↑D * X ^ D) ∧ ∃ (ι : Type) (x : Fintype ι) (σ : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ) → Fin (v.dim + z.dim) → ℚ), ↑(Fintype.card ι) ≤ Real.exp (↑D * X ^ D) ∧ (∀ (p : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ)) (i : Fin (v.dim + z.dim)), ↑(rationalHeight (σ p i)) ≤ Real.exp (↑D * X ^ D) * (1 + frequencyLength p.2)) ∧ ∃ (β : ℝ) (a : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ) → ℂ), (∀ (t : ℝ), |t| ≤ R * r → HasSum (fun (p : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ)) => a p * ↑(Real.fourierChar ((P.quadratic + ∑ i : Fin (v.dim + z.dim), ∑ j : Fin (v.dim + z.dim), P.horizontal i * ↑(M i j) * P.horizontal j) * t ^ 2 + (β + ∑ i : Fin (v.dim + z.dim), ↑(σ p i) * P.horizontal i) * t))) (quadraticChartAtom P (a₀ + t))) ∧ (Summable fun (p : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ)) => ‖a p‖) ∧ ∑' (p : ι × (Fin (v.dim + z.dim + (v.dim + z.dim)) → ℤ)), ‖a p‖ ≤ Real.exp (↑D * X ^ D) ∧ ∀ (T : ℝ), 1 ≤ T → (∑ f : ι, ∑ w ∈ frequencyShell (v.dim + z.dim + (v.dim + z.dim)) T, ‖a (f, w)‖) * T ≤ Real.exp (↑D * X ^ D)

      Blueprint first-match, recentred at an arbitrary point a₀: for a primary Φ of tag v matched to a center z by an edge at length r, the product chart P = Φ ⊗ branchChart has, on the window |t| ≤ R r around a₀, an exact absolutely convergent expansion φ_P(a₀ + t) = Σ_ℓ a_ℓ e(λ_* t² + (β + σ_ℓ·θ) t) with one common curvature and rational frequency differences, everything quasipolynomial in the translated complexity and B.

      First-match expansions of attempt primaries (blueprint lines 1903-1922) #

      Finite first-match expansions (blueprint line 1907: + O(δ_c)) #

      The global mode lift (blueprint lines 1932-1940) #

      noncomputable def TrilinearHT.Auto.modeLiftLin {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] (own : Md → Pr) (s : ℂ) (q : Pr → ℂ) (a : Md → ℂ) (εP : Pr → ℝ) (εM : Md → ℝ) :

      The pointwise lift as a linear map.

      Equations
      Instances For
        theorem TrilinearHT.Auto.modeLift_eq_sum {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Md] (own : Md → Pr) (s : ℂ) (q : Pr → ℂ) (a : Md → ℂ) (εP : Pr → ℝ) (εM : Md → ℝ) (F : ColumnHilbert Pr) :
        modeLift own s q a εP εM F = (s * F.ofLp none + ∑ Φ : Pr, F.ofLp (some Φ) / ↑√(εP Φ) * q Φ) • EuclideanSpace.single none 1 + ∑ m : Md, (↑√(εM m) * a m * F.ofLp (some (own m)) / ↑√(εP (own m))) • EuclideanSpace.single (some m) 1

        The lift written in coordinates: each output coordinate is a combination of the input coordinates.

        structure TrilinearHT.Auto.LiftData (Pr : Type u_3) (Md : Type u_4) [Fintype Pr] [Fintype Md] [DecidableEq Pr] :
        Type (max u_3 u_4)

        The data of a global mode lift: measurable gauge s = (ζ^ρ)² with |s| ≤ 1, measurable physical corrections |q_Φ| ≤ δ, mode coefficients and private weights obeying the hypotheses of modeLift_norm_sq_le (blueprint lines 1932-1940).

        • own : Md → Pr

          Primary label owning each mode.

        • s : ℝ → ℂ

          Bounded measurable gauge multiplying the physical component of the lift.

        • q : Pr → ℝ → ℂ

          Small physical correction associated with each primary label.

        • a : Md → ℝ → ℂ

          Measurable coefficient of each lifted mode.

        • εP : Pr → ℝ

          Positive private-coordinate weight assigned to each primary label.

        • εM : Md → ℝ

          Nonnegative private-coordinate weight assigned to each mode.

        • δ : ℝ

          Uniform norm bound for the primary physical corrections.

        • a_meas (m : Md) : Measurable (self.a m)
        • s_meas : Measurable self.s
        • s_le (y : ℝ) : ‖self.s y‖ ≤ 1
        • q_meas (Φ : Pr) : Measurable (self.q Φ)
        • q_le (Φ : Pr) (y : ℝ) : ‖self.q Φ y‖ ≤ self.δ
        • εP_pos (Φ : Pr) : 0 < self.εP Φ
        • q_sum (y : ℝ) : ∑ Φ : Pr, ‖self.q Φ y‖ ^ 2 / self.εP Φ ≤ 1
        • εM_nonneg (m : Md) : 0 ≤ self.εM m
        • weights (Φ : Pr) (y : ℝ) : ∑ m : Md with self.own m = Φ, self.εM m * ‖self.a m y‖ ^ 2 ≤ self.εP Φ
        Instances For
          noncomputable def TrilinearHT.Auto.LiftData.at_ {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) (y : ℝ) :

          The lift at the point y.

          Equations
          Instances For
            theorem TrilinearHT.Auto.LiftData.norm_at_le {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) (y : ℝ) (F : ColumnHilbert Pr) :
            theorem TrilinearHT.Auto.LiftData.at_aestronglyMeasurable {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) (F : ↥(ColumnL2 Pr)) :
            theorem TrilinearHT.Auto.LiftData.at_memLp {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) (F : ↥(ColumnL2 Pr)) :
            MeasureTheory.MemLp (fun (y : ℝ) => (L.at_ y) (↑↑F y)) 2 MeasureTheory.volume
            noncomputable def TrilinearHT.Auto.LiftData.op {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) :
            ↥(ColumnL2 Pr) →L[ℂ] ↥(ColumnL2 Md)

            The global lift R on square-integrable columns.

            Equations
            Instances For
              theorem TrilinearHT.Auto.LiftData.op_coeFn {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] (L : LiftData Pr Md) (F : ↥(ColumnL2 Pr)) :
              ↑↑(L.op F) =ᵐ[MeasureTheory.volume] fun (y : ℝ) => (L.at_ y) (↑↑F y)
              theorem TrilinearHT.Auto.modeLift_synthesis_supp {Pr : Type u_1} {Md : Type u_2} [Fintype Pr] [Fintype Md] [DecidableEq Pr] [DecidableEq Md] (own : Md → Pr) (s : ℂ) (φ : Pr → ℂ) (a ψphys : Md → ℂ) (εP : Pr → ℝ) (hεP : ∀ (Φ : Pr), 0 < εP Φ) (εM : Md → ℝ) (q β : Pr → ℂ) (hq : ∀ (Φ : Pr), β Φ ≠ 0 → q Φ = ∑ m : Md with own m = Φ, a m * ψphys m - s * φ Φ) :
              modeLift own s q a εP εM (augmentedMain φ εP β) = ∑ m : Md, (β (own m) * a m) • augmentedMode ψphys εM m

              Blueprint lines 1934-1937 with the zero convention before the match: the lift carries a main output exactly to its mode synthesis whenever the physical corrections are exact on the primaries with nonzero coefficient.

              First-match cells (blueprint line 1891: "At its first match on I₀") #

              The maximal cells of a finite family of dyadic cells.

              Equations
              Instances For
                theorem TrilinearHT.Auto.mem_maxCells {G : RealDyadicGrid} {C : Finset (ℤ × ℤ)} {I : ℤ × ℤ} :
                I ∈ maxCells G C ↔ I ∈ C ∧ ∀ J ∈ C, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G J.1 J.2 → J = I
                theorem TrilinearHT.Auto.exists_maxCell_above {G : RealDyadicGrid} {C : Finset (ℤ × ℤ)} {I : ℤ × ℤ} (hI : I ∈ C) :
                ∃ I₀ ∈ maxCells G C, dyadicGridCell G I.1 I.2 ⊆ dyadicGridCell G I₀.1 I₀.2

                Every cell of the family lies in a maximal one.

                theorem TrilinearHT.Auto.maxCells_eq_of_mem {G : RealDyadicGrid} {C : Finset (ℤ × ℤ)} {I₀ I₁ : ℤ × ℤ} (h₀ : I₀ ∈ maxCells G C) (h₁ : I₁ ∈ maxCells G C) {y : ℝ} (hy₀ : y ∈ dyadicGridCell G I₀.1 I₀.2) (hy₁ : y ∈ dyadicGridCell G I₁.1 I₁.2) :
                I₀ = I₁

                Two maximal cells sharing a point coincide.

                The gauge of a group center (blueprint lines 1893-1900) #

                noncomputable def TrilinearHT.Auto.centerCut (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (y : ℝ) :

                The cutoff ζ^ρ(θ_z y) of a center tag.

                Equations
                Instances For
                  noncomputable def TrilinearHT.Auto.centerPhase (z : ChartTag) (ρ : Fin z.dim → ℝ) (y : ℝ) :

                  The branch phase p_ρ(y) = λ_z y² + (θ_z y)ᵀ C_z d_ρ(y) of a center tag.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem TrilinearHT.Auto.centerCut_mem (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (y : ℝ) :
                    centerCut z δ ρ y ∈ Set.Icc 0 1
                    theorem TrilinearHT.Auto.firstMatch_atom {v : ChartTag} (Φ : QuadraticChartData v.dim) (z : ChartTag) (c : ℤ) {δ : ℝ} (hδ : 0 < δ) (hδ' : δ < 1 / 4) (ρ : Fin z.dim → ℝ) (y : ℝ) :

                    The atom of a primary times the branch chart of a center is the primary atom times the gauge ζ^ρ e(-c p_ρ).

                    Counted first-match truncation (blueprint line 1913: the number of modes is at most #

                    D₁)

                    theorem TrilinearHT.Auto.exists_late_shell_of_not_mem_box {d K : ℕ} {w : Fin d → ℤ} (hw : w ∉ frequencyBox d (2 ^ (K + 1))) :
                    ∃ (k : ℕ), w ∈ frequencyShell d (2 ^ (K + k))

                    Frequencies outside the box of radius 2^(K+1) lie in the dyadic shells from 2^K on.

                    theorem TrilinearHT.Auto.box_tail_le {ι : Type u_1} [Fintype ι] {d : ℕ} (a : ι × (Fin d → ℤ) → ℂ) {B : ℝ} (hB : 0 ≤ B) (hshell : ∀ (T : ℝ), 1 ≤ T → (∑ f : ι, ∑ w ∈ frequencyShell d T, ‖a (f, w)‖) * T ≤ B) (K : ℕ) (s : Finset (ι × (Fin d → ℤ))) (hs : ∀ p ∈ s, p.2 ∉ frequencyBox d (2 ^ (K + 1))) :
                    ∑ p ∈ s, ‖a p‖ ≤ 2 * B / 2 ^ K

                    The absolute tail outside a frequency box from dyadic shell bounds (Σ_shell |a|) T ≤ B.

                    theorem TrilinearHT.Auto.hasSum_box_truncate {ι : Type u_1} {T : Type u_2} [Fintype ι] {d : ℕ} (a : ι × (Fin d → ℤ) → ℂ) (ha : Summable fun (p : ι × (Fin d → ℤ)) => ‖a p‖) {B : ℝ} (hB : 0 ≤ B) (hshell : ∀ (T : ℝ), 1 ≤ T → (∑ f : ι, ∑ w ∈ frequencyShell d T, ‖a (f, w)‖) * T ≤ B) (K : ℕ) (e : ι × (Fin d → ℤ) → T → ℂ) (he : ∀ (p : ι × (Fin d → ℤ)) (t : T), ‖e p t‖ = 1) (F : T → ℂ) (t : T) (hF : HasSum (fun (p : ι × (Fin d → ℤ)) => a p * e p t) (F t)) :
                    ‖F t - ∑ p ∈ Finset.univ ×ˢ frequencyBox d (2 ^ (K + 1)), a p * e p t‖ ≤ 2 * B / 2 ^ K

                    Truncation of an absolutely convergent unimodular expansion to a frequency box, with the remainder controlled by the shell bounds.

                    Bounded expansions in a basis (blueprint line 1958: "Expressing a height-D_* vector in a #

                    basis of such vectors in dimension at most d_max costs coefficients and common denominator at most C_*")

                    theorem TrilinearHT.Auto.rational_pivot_cramer_range {m n r : ℕ} (A : Matrix (Fin m) (Fin n) ℚ) (rows : Fin r ↪ Fin m) (cols : Fin r ↪ Fin n) (hdet : (A.submatrix ⇑rows ⇑cols).det ≠ 0) (hspan : Submodule.span ℚ (Set.range fun (j : Fin r) => A.col (cols j)) = Submodule.span ℚ (Set.range A.col)) (y : Fin m → ℚ) (hy : y ∈ A.mulVecLin.range) :
                    (A.submatrix id ⇑cols).mulVec ((A.submatrix ⇑rows ⇑cols).cramer (y ∘ ⇑rows)) = (A.submatrix ⇑rows ⇑cols).det • y

                    Cramer numerators of a pivot minor reproduce every vector of the column span.

                    The normalized frequency vector Θ' = (θ_v, ϑ), ϑ = θ_z/Q₀ (blueprint line 1893) #

                    def TrilinearHT.Auto.scaleZ (dv dz Q0 : ℕ) (a : Fin (dv + dz) → ℚ) :
                    Fin (dv + dz) → ℚ

                    Scaling the ϑ-coordinates of a rational vector by Q₀.

                    Equations
                    Instances For
                      theorem TrilinearHT.Auto.branchProfile_eq_zero_of_le {δ s : ℝ} (hδ : 0 < δ) (hs : s ≤ 0) :
                      theorem TrilinearHT.Auto.branchProfile_eq_zero_of_ge {δ s : ℝ} (hδ : 0 < δ) (hs : 1 ≤ s) :
                      noncomputable def TrilinearHT.Auto.modeWave (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (cl : ℤ) (lam a γ y : ℝ) :

                      The physical part of a mode (eq:modes): ζ^ρ(y) e(c p_ρ(y)) e(λ(y-a)² + γ(y-a)).

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem TrilinearHT.Auto.modeWave_measurable (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (cl : ℤ) (lam a γ : ℝ) :
                        Measurable (modeWave z δ ρ cl lam a γ)
                        theorem TrilinearHT.Auto.modeWave_norm_le (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (cl : ℤ) (lam a γ y : ℝ) :
                        ‖modeWave z δ ρ cl lam a γ y‖ ≤ 1

                        Augmented modes on cells (eq:modes, blueprint line 1928) #

                        noncomputable def TrilinearHT.Auto.augMode {V : Type u_1} [DecidableEq V] (J : Set ℝ) (ψ : ℝ → ℂ) (ε : ℝ) (m : V) :

                        The augmented mode 1_J (ψ e_phys + √ε e_m) on a cell J.

                        Equations
                        Instances For
                          theorem TrilinearHT.Auto.augMode_memLp {V : Type u_1} [Fintype V] [DecidableEq V] {J : Set ℝ} (hJ : MeasurableSet J) (hJf : MeasureTheory.volume J ≠ ⊤) {ψ : ℝ → ℂ} (hψ : Measurable ψ) (hψb : ∀ (y : ℝ), ‖ψ y‖ ≤ 1) (ε : ℝ) (m : V) :

                          The frozen-mode data interface of one role and group (blueprint lines 1971-1975) #

                          The frozen modes of one role, group and offset (blueprint "Frozen-mode data interface", lines 1971-1975): for each primary and first-match cell, the finite list of modes with one curvature, the coefficient functions, the rational frequency differences eq:mode-differences and the private indices, together with the pointwise lift.

                          Instances For
                            noncomputable def TrilinearHT.Auto.ModeSystem.wave {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (m : Ms.Md) :
                            ℝ → ℂ

                            The physical wave of a mode (eq:modes).

                            Equations
                            Instances For
                              noncomputable def TrilinearHT.Auto.ModeSystem.slope {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (m : Ms.Md) (y : ℝ) :

                              The slope ω_m(y) = 2λ_m (y - a_m) + γ_m of a mode.

                              Equations
                              Instances For
                                noncomputable def TrilinearHT.Auto.ModeSystem.alive {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (U : ℤ × ℤ) :

                                The modes alive on a cell U: their first-match cell contains U.

                                Equations
                                Instances For
                                  theorem TrilinearHT.Auto.ModeSystem.mem_alive {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) {U : ℤ × ℤ} {m : Ms.Md} :
                                  m ∈ Ms.alive U ↔ dyadicGridCell Gd U.1 U.2 ⊆ dyadicGridCell Gd (Ms.cellOf m).1 (Ms.cellOf m).2

                                  Blocks, goodness, side modes and side events of a frozen mode system (lines 1952-2047) #

                                  The numerical data of the coherence argument: heights Hn, the mode-difference height D, the gap threshold T, witness and kernel size sequences, the stability lag R, the shift Δ, the top height J_* and the core fraction δ_*.

                                  • Hn : ℕ

                                    Number of height levels used by the coherence argument.

                                  • D : ℕ

                                    Rational-height bound for mode differences in the coherence argument.

                                  • Tt : ℝ

                                    Gap threshold used to separate coherent mode components.

                                  • Eq : ℕ → ℚ

                                    Witness-size sequence indexed by height.

                                  • Sk : ℕ → ℚ

                                    Kernel-size sequence indexed by height.

                                  • R : ℕ

                                    Stability lag used when comparing components at different heights.

                                  • Δ : ℕ

                                    Height shift between predecessor and current mode components.

                                  • Jst : ℕ

                                    Top height in the mode-coherence schedule.

                                  • δs : ℝ

                                    Core fraction retained by the side-event estimates.

                                  Instances For

                                    The frozen evaluation on a pre-cell as a mode synthesis (blueprint lines 1934-1937, 1959) #

                                    theorem TrilinearHT.Auto.ModeSystem.wave_norm_le {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (m : Ms.Md) (y : ℝ) :
                                    ‖Ms.wave m y‖ ≤ 1
                                    noncomputable def TrilinearHT.Auto.ModeSystem.cellMode {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (J : ℤ × ℤ) (m : Ms.Md) :
                                    ↥(ColumnL2 Ms.Md)

                                    The augmented mode of m on the cell J.

                                    Equations
                                    Instances For

                                      Frozen evaluations as lifted ball outputs (blueprint lines 1959, 2112-2116) #

                                      noncomputable def TrilinearHT.Auto.torusW {d : ℕ} (Q0 : ℕ) (l' j : Fin 4) (x : Fin (d + d) → ℝ) :
                                      Fin d → ℝ

                                      The slot positions θ y_j = Q₀ (u + (j - l') v) in the torus variables x = (u, v), u = ϑ y_{l'}, v = ϑ t, ϑ = θ / Q₀.

                                      Equations
                                      Instances For
                                        noncomputable def TrilinearHT.Auto.carryVec {d : ℕ} (n : Fin 4 → Fin d → ℤ) (j : Fin 4) :
                                        Fin d → ℝ

                                        The carries k_j = (1-j) n_0 + j n_1 - n_j of a lattice tuple.

                                        Equations
                                        Instances For
                                          noncomputable def TrilinearHT.Auto.gaugeTerm {d : ℕ} (δ : ℝ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (n : Fin 4 → Fin d → ℤ) (x : Fin (d + d) → ℝ) :

                                          One carry piece of the gauge multiplier: the shifted branch profiles of the four slots times the integer-carry character.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            noncomputable def TrilinearHT.Auto.gaugeFloor {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x : Fin (d + d) → ℝ) :
                                            Fin 4 → Fin d → ℤ

                                            The branch lattice points ⌊θ y_j - ρ_j⌋.

                                            Equations
                                            Instances For
                                              noncomputable def TrilinearHT.Auto.gaugeMult {d : ℕ} (δ : ℝ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (x : Fin (d + d) → ℝ) :

                                              Blueprint eq:gauge-cancel (lines 1938-1944): the common progression multiplier, the carry piece of the actual branch lattice points.

                                              Equations
                                              Instances For
                                                theorem TrilinearHT.Auto.gaugeTerm_eq_zero {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) {n : Fin 4 → Fin d → ℤ} {x : Fin (d + d) → ℝ} (hn : n ≠ gaugeFloor Q0 l' ρ x) :
                                                gaugeTerm δ Q0 l' C ρ n x = 0

                                                Only the carry piece of the actual lattice points is nonzero.

                                                noncomputable def TrilinearHT.Auto.gaugeBox {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x₀ : Fin (d + d) → ℝ) :
                                                Finset (Fin 4 → Fin d → ℤ)

                                                Near any point the multiplier is the sum of the carry pieces of the lattice tuples within one step of the local lattice points.

                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For
                                                  theorem TrilinearHT.Auto.gaugeMult_eq_sum {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) {x₀ x : Fin (d + d) → ℝ} (hx : gaugeFloor Q0 l' ρ x ∈ gaugeBox Q0 l' ρ x₀) :
                                                  gaugeMult δ Q0 l' C ρ x = ∑ n ∈ gaugeBox Q0 l' ρ x₀, gaugeTerm δ Q0 l' C ρ n x
                                                  noncomputable def TrilinearHT.Auto.torusWL {d : ℕ} (Q0 : ℕ) (l' j : Fin 4) :
                                                  (Fin (d + d) → ℝ) →L[ℝ] Fin d → ℝ

                                                  The slot position as a continuous linear map of the torus variables.

                                                  Equations
                                                  Instances For
                                                    theorem TrilinearHT.Auto.torusWL_apply {d : ℕ} (Q0 : ℕ) (l' j : Fin 4) (x : Fin (d + d) → ℝ) :
                                                    (torusWL Q0 l' j) x = torusW Q0 l' j x
                                                    theorem TrilinearHT.Auto.norm_torusWL_le {d : ℕ} (Q0 : ℕ) (l' j : Fin 4) :
                                                    ‖torusWL Q0 l' j‖ ≤ 4 * ↑Q0
                                                    noncomputable def TrilinearHT.Auto.carryPhaseL {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (n : Fin 4 → Fin d → ℤ) :
                                                    (Fin (d + d) → ℝ) →L[ℝ] ℝ

                                                    The carry phase of a lattice tuple as a continuous linear form of the torus variables.

                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For
                                                      theorem TrilinearHT.Auto.carryPhaseL_apply {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (n : Fin 4 → Fin d → ℤ) (x : Fin (d + d) → ℝ) :
                                                      (carryPhaseL Q0 l' C n) x = ∑ j : Fin 4, ↑(slotCoeff j) * chartMatrixPhase C (torusW Q0 l' j x) (carryVec n j)
                                                      theorem TrilinearHT.Auto.gaugeTerm_contDiff {d : ℕ} {δ : ℝ} (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (n : Fin 4 → Fin d → ℤ) :
                                                      ContDiff ℝ (↑⊤) (gaugeTerm δ Q0 l' C ρ n)
                                                      theorem TrilinearHT.Auto.gaugeFloor_mem_box {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) {x₀ x : Fin (d + d) → ℝ} (hx : ‖x - x₀‖ < 1 / (4 * ↑Q0 + 1)) :
                                                      gaugeFloor Q0 l' ρ x ∈ gaugeBox Q0 l' ρ x₀

                                                      Points within 1 / (4 Q₀ + 1) keep their lattice points within one step.

                                                      theorem TrilinearHT.Auto.gaugeMult_eventuallyEq {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (x₀ : Fin (d + d) → ℝ) :
                                                      gaugeMult δ Q0 l' C ρ =ᶠ[nhds x₀] fun (x : Fin (d + d) → ℝ) => ∑ n ∈ gaugeBox Q0 l' ρ x₀, gaugeTerm δ Q0 l' C ρ n x
                                                      theorem TrilinearHT.Auto.gaugeMult_contDiff {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) :
                                                      ContDiff ℝ (↑⊤) (gaugeMult δ Q0 l' C ρ)

                                                      The common progression multiplier is smooth: near every point it is a finite sum of smooth carry pieces, since the branch profiles vanish to infinite order at the cuts.

                                                      theorem TrilinearHT.Auto.torusW_affine {d : ℕ} (Q0 : ℕ) (l' j : Fin 4) (x : Fin (d + d) → ℝ) (a : Fin d) :
                                                      torusW Q0 l' j x a = (1 - ↑↑j) * torusW Q0 l' 0 x a + ↑↑j * torusW Q0 l' 1 x a
                                                      theorem TrilinearHT.Auto.carryVec_box_le {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (hρ : ∀ (j : Fin 4) (a : Fin d), ρ j a ∈ Set.Icc 0 1) {x₀ : Fin (d + d) → ℝ} {n : Fin 4 → Fin d → ℤ} (hn : n ∈ gaugeBox Q0 l' ρ x₀) (j : Fin 4) (b : Fin d) :
                                                      |carryVec n j b| ≤ 18

                                                      The carries of the lattice tuples in the local box are bounded by 18 when the offsets lie in [0, 1].

                                                      theorem TrilinearHT.Auto.norm_carryPhaseL_le {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (n : Fin 4 → Fin d → ℤ) {Cm K : ℝ} (hCm0 : 0 ≤ Cm) (hK0 : 0 ≤ K) (hCm : ∀ (a b : Fin d), |↑(C a b)| ≤ Cm) (hK : ∀ (j : Fin 4) (b : Fin d), |carryVec n j b| ≤ K) :
                                                      ‖carryPhaseL Q0 l' C n‖ ≤ 8 * (↑d * (↑d * (Cm * K * (4 * ↑Q0))))
                                                      noncomputable def TrilinearHT.Auto.profR (δ : ℝ) (m : ℕ) :

                                                      The derivative constant of the branch profiles up to order m.

                                                      Equations
                                                      Instances For
                                                        theorem TrilinearHT.Auto.profR_nonneg {δ : ℝ} (hδ : 0 < δ) (m : ℕ) :
                                                        0 ≤ profR δ m
                                                        theorem TrilinearHT.Auto.gaugeTerm_eq_mul {d : ℕ} (δ : ℝ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (n : Fin 4 → Fin d → ℤ) :
                                                        gaugeTerm δ Q0 l' C ρ n = fun (x : Fin (d + d) → ℝ) => (∏ j : Fin 4, (fun (y : Fin (d + d) → ℝ) => chartCoordinateProduct (branchProfile δ) ((torusWL Q0 l' j) y - fun (a : Fin d) => ρ j a + ↑(n j a))) x) * ↑(Real.fourierChar ((carryPhaseL Q0 l' C n) x))
                                                        theorem TrilinearHT.Auto.gaugeTerm_deriv_le {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (n : Fin 4 → Fin d → ℤ) (m : ℕ) (x : Fin (d + d) → ℝ) :
                                                        ‖iteratedFDeriv ℝ m (gaugeTerm δ Q0 l' C ρ n) x‖ ≤ (4 * (4 * ↑Q0 * (↑d * profR δ m)) + 2 * Real.pi * ‖carryPhaseL Q0 l' C n‖) ^ m

                                                        The derivatives of one carry piece: ‖D^m term‖ ≤ (16 Q₀ d R + 2π ‖L_n‖)^m.

                                                        theorem TrilinearHT.Auto.gaugeBox_card {d : ℕ} (Q0 : ℕ) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x₀ : Fin (d + d) → ℝ) :
                                                        (gaugeBox Q0 l' ρ x₀).card = 3 ^ (4 * d)
                                                        theorem TrilinearHT.Auto.gaugeMult_deriv_le {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (hρ : ∀ (j : Fin 4) (a : Fin d), ρ j a ∈ Set.Icc 0 1) {Cm : ℝ} (hCm0 : 0 ≤ Cm) (hCm : ∀ (a b : Fin d), |↑(C a b)| ≤ Cm) (m : ℕ) (x : Fin (d + d) → ℝ) :
                                                        ‖iteratedFDeriv ℝ m (gaugeMult δ Q0 l' C ρ) x‖ ≤ 3 ^ (4 * d) * (4 * (4 * ↑Q0 * (↑d * profR δ m)) + 2 * Real.pi * (8 * (↑d * (↑d * (Cm * 18 * (4 * ↑Q0)))))) ^ m

                                                        Blueprint lines 1942-1944 ("its Gevrey and absolute Fourier bounds are uniform in offsets"): for offsets in [0, 1] and |C_{ab}| ≤ C_m, the derivatives of the multiplier obey ‖D^m M‖ ≤ 3^{4d} (16 Q₀ d R + 2π · 8 d² C_m · 18 · 4 Q₀)^m everywhere.

                                                        theorem TrilinearHT.Auto.gaugeMult_periodic {d : ℕ} (δ : ℝ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (hQ : ∀ (a b : Fin d), ∃ (z : ℤ), ↑Q0 * ↑(C a b) = ↑z) (x : Fin (d + d) → ℝ) (e : Fin (d + d) → ℤ) :
                                                        gaugeMult δ Q0 l' C ρ (x + fun (i : Fin (d + d)) => ↑(e i)) = gaugeMult δ Q0 l' C ρ x

                                                        Blueprint line 1942 ("for fixed carries the right side is an integer character on (ϑ y_{l'}, ϑ t) ... because Q₀ clears C_z"): the multiplier is 1-periodic in the torus variables.

                                                        theorem TrilinearHT.Auto.gaugeMult_norm_le {d : ℕ} (δ : ℝ) (Q0 : ℕ) (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (x : Fin (d + d) → ℝ) :
                                                        ‖gaugeMult δ Q0 l' C ρ x‖ ≤ 1
                                                        theorem TrilinearHT.Auto.branchProfile_le_edge {δ : ℝ} (hδ : 0 < δ) (s : ℝ) :
                                                        branchProfile δ s ≤ profR δ 1 * |s| ∧ branchProfile δ s ≤ profR δ 1 * |1 - s|

                                                        The branch profile vanishes at both cuts with slope at most R = profR δ 1: b_δ(s) ≤ R |s| and b_δ(s) ≤ R |1 - s|.

                                                        theorem TrilinearHT.Auto.prod_le_factor {ι : Type u_1} (s : Finset ι) (f : ι → ℝ) (h0 : ∀ i ∈ s, 0 ≤ f i) (h1 : ∀ i ∈ s, f i ≤ 1) {i : ι} (hi : i ∈ s) :
                                                        ∏ j ∈ s, f j ≤ f i
                                                        noncomputable def TrilinearHT.Auto.torusPt {d : ℕ} (θ : Fin d → ℝ) (Q0 : ℕ) (l' : Fin 4) (x t : ℝ) :
                                                        Fin (d + d) → ℝ

                                                        The torus point (ϑ y_{l'}, ϑ t), ϑ = θ / Q₀, of the progression y_j = x + j t.

                                                        Equations
                                                        Instances For
                                                          theorem TrilinearHT.Auto.torusW_torusPt {d : ℕ} (θ : Fin d → ℝ) {Q0 : ℕ} (hQ0 : 0 < Q0) (l' j : Fin 4) (x t : ℝ) :
                                                          torusW Q0 l' j (torusPt θ Q0 l' x t) = fun (a : Fin d) => θ a * (x + ↑↑j * t)
                                                          theorem TrilinearHT.Auto.gaugeCarry_eq_carryVec {d : ℕ} (θ : Fin d → ℝ) {Q0 : ℕ} (hQ0 : 0 < Q0) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x t : ℝ) (j : Fin 4) :
                                                          gaugeCarry θ ρ x t j = carryVec (gaugeFloor Q0 l' ρ (torusPt θ Q0 l' x t)) j
                                                          theorem TrilinearHT.Auto.gauge_factors_eq_mult {d : ℕ} {δ δ'' : ℝ} (hδ : 0 < δ) (hδ'' : 0 < δ'') (θ : Fin d → ℝ) (C : Matrix (Fin d) (Fin d) ℚ) (lam : ℝ) {Q0 : ℕ} (hQ0 : 0 < Q0) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x t : ℝ) :
                                                          ‖(∏ j : Fin 4, ↑(branchCutoffValue δ (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))) * ↑(Real.fourierChar (∑ j : Fin 4, ↑(slotCoeff j) * (lam * (x + ↑↑j * t) ^ 2 + chartMatrixPhase C (fun (a : Fin d) => θ a * (x + ↑↑j * t)) (branchLift (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))))) - (∏ j : Fin 4, ↑(branchCutoffValue δ (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))) * gaugeMult δ'' Q0 l' C ρ (torusPt θ Q0 l' x t)‖ ≤ 8 * ↑d * δ'' * profR δ 1

                                                          Blueprint lines 1942-1944 and 2479 ("on all true cutoff supports the four gauge factors have the bounded smooth periodic multiplier"), with the thin enlargement of ErrorReport 2026-10-12: the four true cutoffs times the four gauge phases e(c_j p_{ρ_j}(y_j)) differ from the four true cutoffs times the multiplier with cutoff parameter δ'' by at most 8 d δ'' R_δ.

                                                          theorem TrilinearHT.Auto.fourierChar_sum_coe {ι : Type u_1} (s : Finset ι) (a : ι → ℝ) :
                                                          ↑(Real.fourierChar (∑ i ∈ s, a i)) = ∏ i ∈ s, ↑(Real.fourierChar (a i))
                                                          theorem TrilinearHT.Auto.gauge_prod_eq (z : ChartTag) (δ : ℝ) (ρ : Fin 4 → Fin z.dim → ℝ) (x t : ℝ) :
                                                          ∏ j : Fin 4, ↑(centerCut z δ (ρ j) (x + ↑↑j * t)) * ↑(Real.fourierChar (↑(slotCoeff j) * centerPhase z (ρ j) (x + ↑↑j * t))) = (∏ j : Fin 4, ↑(branchCutoffValue δ (ρ j) fun (a : Fin z.dim) => z.θ a * (x + ↑↑j * t))) * ↑(Real.fourierChar (∑ j : Fin 4, ↑(slotCoeff j) * (z.lam * (x + ↑↑j * t) ^ 2 + chartMatrixPhase z.C (fun (a : Fin z.dim) => z.θ a * (x + ↑↑j * t)) (branchLift (ρ j) fun (a : Fin z.dim) => z.θ a * (x + ↑↑j * t)))))

                                                          The four gauge factors of a common chart tag at the progression points y_j = x + j t are the four true cutoffs times the gauge phase of eq:gauge-cancel.

                                                          Primaries and first-match cells on the main columns (blueprint line 1888) #

                                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.primaries {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) (I : ℤ × ℤ) :
                                                          Finset (bf.Lab ⊕ Fin fp.Mc)

                                                          The primaries of a role (slot l, outer ball of the group G at the ball level j) at the cell I: the main columns available to the maximal pad P and the rank L + j of the outer ball (blueprint line 1888).

                                                          Equations
                                                          Instances For
                                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballLabels_subset_primaries {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) (I : ℤ × ℤ) {p : ℕ} (hp : p ≤ fp.P) :
                                                            mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I G j p) d ⊆ fp.primaries l s G j d I

                                                            The labels of every individual ball projection of the role are primaries.

                                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.primaries_desc {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) {I J : ℤ × ℤ} (hI : I ∈ A.cells) (hJ : J ∈ A.cells) (hJI : dyadicGridCell A.G J.1 J.2 ⊆ dyadicGridCell A.G I.1 I.2) {v : bf.Lab ⊕ Fin fp.Mc} (hv : v ∈ fp.primaries l s G j d I) :
                                                            v ∈ fp.primaries l s G j d J

                                                            The primaries are nested in depth (blueprint line 1888: "the mode lists, including primaries whose coefficients are zero, are nested"; a primary keeps its role on every descendant).

                                                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.firstCells {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cs : Finset (ℤ × ℤ)) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) (v : bf.Lab ⊕ Fin fp.Mc) :

                                                            The first-match cells of a primary among a family cs of active cells: the maximal cells of cs at which it is a primary (blueprint line 1888: "at its first match on I₀").

                                                            Equations
                                                            Instances For
                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.exists_firstCell {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cs : Finset (ℤ × ℤ)) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) {v : bf.Lab ⊕ Fin fp.Mc} {I : ℤ × ℤ} (hI : I ∈ cs) (hv : v ∈ fp.primaries l s G j d I) :
                                                              ∃ I₀ ∈ fp.firstCells cs l s G j d v, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I₀.1 I₀.2

                                                              A primary at a cell of the family has a first-match cell containing the cell.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.firstCell_unique {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cs : Finset (ℤ × ℤ)) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) {v : bf.Lab ⊕ Fin fp.Mc} {I₀ I₁ : ℤ × ℤ} (h₀ : I₀ ∈ fp.firstCells cs l s G j d v) (h₁ : I₁ ∈ fp.firstCells cs l s G j d v) {y : ℝ} (hy₀ : y ∈ dyadicGridCell A.G I₀.1 I₀.2) (hy₁ : y ∈ dyadicGridCell A.G I₁.1 I₁.2) :
                                                              I₀ = I₁

                                                              The first-match cell of a primary above a cell is unique.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.primaries_of_firstCell {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cs : Finset (ℤ × ℤ)) (hcs : cs ⊆ A.cells) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) {v : bf.Lab ⊕ Fin fp.Mc} {I₀ I : ℤ × ℤ} (h₀ : I₀ ∈ fp.firstCells cs l s G j d v) (hI : I ∈ A.cells) (hII₀ : dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I₀.1 I₀.2) :
                                                              v ∈ fp.primaries l s G j d I

                                                              A primary is a primary on every active descendant of its first-match cell (blueprint line 1888: "keep its modes and labels on every descendant").

                                                              The first-match expansion on the main columns (blueprint lines 1888, 1903-1910) #

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.tagWalk_path {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Hed : ℝ) (s : ℤ) (n : ℕ) (x y : bf.Vtx) :
                                                              reachIn (bf.tagGraphEdge Hed) s n x y → ∃ L ≤ n, ∃ (v : Fin (L + 1) → ChartTag), v 0 = bf.vtag x ∧ v (Fin.last L) = bf.vtag y ∧ (∀ (i : Fin (L + 1)), ∃ (w : bf.Vtx), v i = bf.vtag w) ∧ ∀ (j : Fin L), tagEdge Hed (dyadicGridLength A.G s) (v j.castSucc) (v j.succ)

                                                              A walk of length n in the tag graph of the original basic columns collapses to a path of at most n tag edges between the endpoint tags (equal-tag steps are removed).

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.tagEdge_of_dist {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Hed : ℝ} (hHed : 2 ≤ Hed) {dB : ℕ} (hdim : ∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) (hC : ∀ (w : bf.Vtx) (a b : Fin (bf.vtag w).dim), ↑(rationalHeight ((bf.vtag w).C a b)) ≤ Hed) {s : ℤ} {x y : bf.Vtx} {n : ℕ} (hd : (bf.tagDist Hed).d s x y ≤ ↑n) :
                                                              bf.vtag x = bf.vtag y ∨ tagEdge (Real.exp (100000 * ((↑n + 1) * (↑dB + 1)) ^ 8 * Real.log (2 * Hed))) (dyadicGridLength A.G s) (bf.vtag x) (bf.vtag y)

                                                              Blueprint lem:graph, short paths, for the original basic columns: two vertices at tag-graph distance at most n carry equal tags or tags joined by an edge of height exp(10⁵ ((n+1)(d+1))⁸ log(2 H_ed)), given tag dimensions at most d and matrix heights at most H_ed.

                                                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballRadius {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (g : ℤ) (h : ℕ) :

                                                              The graph radius of a ball mask around its center.

                                                              Equations
                                                              Instances For
                                                                noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballEdgeH {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (dB n : ℕ) :

                                                                The edge height of the ball radius n in the tag graph.

                                                                Equations
                                                                Instances For
                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.two_le_ballEdgeH {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hHed : 2 ≤ fp.Hed) (dB n : ℕ) :
                                                                  2 ≤ fp.ballEdgeH dB n
                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mask_tagEdge_center {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {I : ℤ × ℤ} (hI : I ∈ A.cells) {G : bf.Grp} {h : ℕ} {b : bf.Vtx} (hb : b ∈ fp.K.mask bf.admT A.famVtxBound G h (bf.admAt I)) {ρ : Fin fp.K.d0} {z : bf.Vtx} {g : ℤ} (hG : G.2.1 = some (ρ, z, g)) (hHed : 2 ≤ fp.Hed) {dB : ℕ} (hdim : ∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) (hC : ∀ (w : bf.Vtx) (a c : Fin (bf.vtag w).dim), ↑(rationalHeight ((bf.vtag w).C a c)) ≤ fp.Hed) :
                                                                  tagEdge (fp.ballEdgeH dB (fp.ballRadius g h)) (dyadicGridLength A.G I.1) (bf.vtag b) (bf.vtag z)

                                                                  Blueprint line 1903 (first match, short-path part of lem:graph): a vertex of the ball mask of a group at an active cell carries a tag joined to the tag of the group center by an edge at the cell length, of height ballEdgeH of the ball radius.

                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainLabel_chart {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (hT : ∀ e ∈ s, ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) (htag : ∀ e ∈ s, bf.occAvail (↑e.tag.2) e.tag.1) (d : bf.Vtx) {I : ℤ × ℤ} {r : ℕ} {v : bf.Lab ⊕ Fin Mc} (hv : v ∈ mainLabels A.G Mc (bf.origCols l) s I r) :
                                                                  ∃ (B : QuadraticChartData (bf.vtag (labelTag (bf.origCols l) s I d v)).dim), QuadraticChartComplexity A.csrc A.Hsrc B ∧ IsBoundedQuadraticChart B ∧ B.horizontal = (bf.vtag (labelTag (bf.origCols l) s I d v)).θ ∧ B.matrix = ↑(slotCoeff l) • (bf.vtag (labelTag (bf.origCols l) s I d v)).C ∧ B.quadratic = ↑(slotCoeff l) * (bf.vtag (labelTag (bf.origCols l) s I d v)).lam ∧ ∀ y ∈ dyadicGridCell A.G I.1 I.2, mainScalar Mc (bf.origCols l) s v y = quadraticChartAtom B y

                                                                  An available main label is, on the cell, a pure chart of its tag in the slot, of the common source complexity (blueprint line 1798: pure main columns; line 1903: the primary at first match).

                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainFirstMatch_attempt (κ : LocalKernelClass) (c₀ : ℕ) (R : ℝ) (hR : 0 ≤ R) :
                                                                  ∃ (D : ℕ), 1 ≤ D ∧ ∀ (A : ActiveSetup κ c₀) (bf : A.BasicFamilies) (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)), (∀ e ∈ s, ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) → (∀ e ∈ s, bf.occAvail (↑e.tag.2) e.tag.1) → ∀ (d : bf.Vtx) {I : ℤ × ℤ}, I ∈ A.cells → ∀ {G : bf.Grp} {j : ℕ} {v : bf.Lab ⊕ Fin fp.Mc}, v ∈ fp.primaries l s G j d I → ∀ {ρ₀ : Fin fp.K.d0} {z : bf.Vtx} {g : ℤ}, G.2.1 = some (ρ₀, z, g) → 2 ≤ fp.Hed → ∀ {dB : ℕ}, (∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) → (∀ (w : bf.Vtx) (a c : Fin (bf.vtag w).dim), ↑(rationalHeight ((bf.vtag w).C a c)) ≤ fp.Hed) → ∀ {δ : ℝ} (hδ : 0 < δ) (hδ' : δ < 1 / 4) (ρ : Fin (bf.vtag z).dim → ℝ), (∀ (i : Fin (bf.vtag z).dim), ρ i ∈ Set.Icc 0 1) → ∀ {H : ℝ}, A.Hsrc ≤ H → ↑(bf.vtag z).dim ≤ Real.log H → (∀ (i k : Fin (bf.vtag z).dim), ↑(chartRationalHeight ((↑(-slotCoeff l) • (bf.vtag z).C) i k)) ≤ H) → ↑(bf.vtag z).dim * (bumpConst * 8 ^ 32 * (2 / δ)) ≤ H → ∃ (Φ : QuadraticChartData (bf.vtag (labelTag (bf.origCols l) s I d v)).dim), (∀ y ∈ dyadicGridCell A.G I.1 I.2, mainScalar fp.Mc (bf.origCols l) s v y = quadraticChartAtom Φ y) ∧ IsBoundedQuadraticChart Φ ∧ Φ.horizontal = (bf.vtag (labelTag (bf.origCols l) s I d v)).θ ∧ Φ.matrix = ↑(slotCoeff l) • (bf.vtag (labelTag (bf.origCols l) s I d v)).C ∧ Φ.quadratic = ↑(slotCoeff l) * (bf.vtag (labelTag (bf.origCols l) s I d v)).lam ∧ have P := productQuadraticChart Φ (branchChart (bf.vtag z) (slotCoeff l) ⋯ ⋯); have X := 1 + Real.log (chartTranslationBudget (H ^ 6)) + Real.log (3 * fp.ballEdgeH dB (fp.ballRadius g (fp.bbase j + fp.P))); let dd := (bf.vtag (labelTag (bf.origCols l) s I d v)).dim + (bf.vtag z).dim; ∃ (M : Matrix (Fin dd) (Fin dd) ℚ), (∀ (i k : Fin dd), ↑(rationalHeight (M i k)) ≤ Real.exp (↑D * X ^ D)) ∧ |P.quadratic + ∑ i : ⋯, ⋯| * dyadicGridLength A.G I.1 ^ 2 ≤ Real.exp (↑D * X ^ D) ∧ ∃ (ι : Type) (x : Fintype ι) (σ : ι × (Fin (dd + dd) → ℤ) → Fin dd → ℚ), ↑(Fintype.card ι) ≤ Real.exp (↑D * X ^ D) ∧ ⋯ ∧ ⋯

                                                                  Blueprint first-match (lines 1903-1916, eq:firstmatch, eq:mode-differences) on the main columns: a primary v of the role (slot l, outer ball of the group G at the level j) at an active cell I is, on the cell, a pure chart Φ of its tag (an original column occurrence or a template), and on the window |t| ≤ R |I| at the left end a_I of the cell, the product chart P of Φ with the branch chart of the group center (cutoff of width δ, demodulation e(-c_l p_ρ)) has an exact absolutely convergent mode expansion φ_P(a_I + t) = Σ a_ℓ e(λ_* t² + (β + σ_ℓ·θ) t) with one common curvature, rational frequency differences, and counts, heights and coefficient sums at most exp(D X^D), X = 1 + log T(H⁶) + log(3B) (T the translation budget, B the edge height of the ball radius at the maximal pad).

                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainFirstMatch_finite (κ : LocalKernelClass) (c₀ : ℕ) :
                                                                  ∃ (D : ℕ), 1 ≤ D ∧ ∀ (A : ActiveSetup κ c₀) (bf : A.BasicFamilies) (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)), (∀ e ∈ s, ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) → (∀ e ∈ s, bf.occAvail (↑e.tag.2) e.tag.1) → ∀ (d : bf.Vtx) {I : ℤ × ℤ}, I ∈ A.cells → ∀ {G : bf.Grp} {j : ℕ} {v : bf.Lab ⊕ Fin fp.Mc}, v ∈ fp.primaries l s G j d I → ∀ {ρ₀ : Fin fp.K.d0} {z : bf.Vtx} {g : ℤ}, G.2.1 = some (ρ₀, z, g) → 2 ≤ fp.Hed → ∀ {dB : ℕ}, (∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) → (∀ (w : bf.Vtx) (a c : Fin (bf.vtag w).dim), ↑(rationalHeight ((bf.vtag w).C a c)) ≤ fp.Hed) → ∀ {δ : ℝ}, 0 < δ → δ < 1 / 4 → ∀ (ρ : Fin (bf.vtag z).dim → ℝ), (∀ (i : Fin (bf.vtag z).dim), ρ i ∈ Set.Icc 0 1) → ∀ {H : ℝ}, A.Hsrc ≤ H → ↑(bf.vtag z).dim ≤ Real.log H → (∀ (i k : Fin (bf.vtag z).dim), ↑(chartRationalHeight ((↑(-slotCoeff l) • (bf.vtag z).C) i k)) ≤ H) → ↑(bf.vtag z).dim * (bumpConst * 8 ^ 32 * (2 / δ)) ≤ H → ∀ {δc : ℝ}, 0 < δc → have X := 1 + Real.log (chartTranslationBudget (H ^ 6)) + Real.log (3 * fp.ballEdgeH dB (fp.ballRadius g (fp.bbase j + fp.P))); ∃ (Ny : Type) (x : Fintype Ny) (coef : Ny → ℂ) (lam : ℝ) (γ : Ny → ℝ) (dv : ℕ) (θv : Fin dv → ℝ) (σ : Ny → Fin (dv + (bf.vtag z).dim) → ℚ) (β : ℝ), (∀ (k : Ny), γ k = β + ∑ i : Fin (dv + (bf.vtag z).dim), ⋯) ∧ dv ≤ dB ∧ ↑(Fintype.card Ny) ≤ Real.exp (↑D * X ^ D) * ⋯ ∧ (∀ (k : Ny), ⋯) ∧ ∑ k : Ny, ‖coef k‖ ≤ Real.exp (↑D * X ^ D) ∧ ⋯

                                                                  Blueprint eq:firstmatch (lines 1903-1910) on the main columns: at an active cell where v is a primary of the role, finitely many modes e(λ (y - a_I)² + γ_k (y - a_I)), with one curvature and frequencies γ_k = β + σ_k·Θ (σ_k rational, Θ = (θ_v, θ_z)), approximate φ_v ζ^ρ e(-c_l p_ρ) within δ_c on the whole cell, with coefficient sum and |λ| |I|² at most exp(D X^D); the count and the heights are bounded as in eq:mode-differences.

                                                                  The main-column lift with local mode weights (blueprint line 1932) #

                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.card_matched_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cs : Finset (ℤ × ℤ)) (hcs : cs ⊆ A.cells) (l : Fin 4) (s : List (CatCol bf.Vtx)) (G : bf.Grp) (j : ℕ) (d : bf.Vtx) {N : ℝ} (hN0 : 0 ≤ N) (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols l) s I (fp.brank j)).card ≤ N) (y : ℝ) :
                                                                  ↑{v : bf.Lab ⊕ Fin fp.Mc | ∃ I ∈ fp.firstCells cs l s G j d v, y ∈ dyadicGridCell A.G I.1 I.2}.card ≤ N

                                                                  At every point, the primaries matched there (those with a first-match cell containing the point) are primaries at the deepest such cell; hence they number at most the main labels there (blueprint line 1932: the physical correction runs over the primaries matched at y).