Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec161OneAttemptRestarts

Section 16.1: One attempt and its restarts #

This file was automatically generated by Claude.

Formalization of blueprint Section 16, "Normalized absorption and the operator estimate" (sec:completion), subsection 1, "One attempt and its restarts" (lines 2826-2842) of blueprint/formalization_blueprint.tex.

Exceptional roots and restarts (prop:normalized, blueprint lines 2838-2843) #

The quantitative inequality (prop:normalized, blueprint lines 2843-2858) #

Choice of q, α, P (prop:normalized, blueprint lines 2866-2888) #

theorem TrilinearHT.Auto.eta_power_P_le {ε C₄ η : ℝ} (hε : 0 < ε) (hC₄ : 0 ≤ C₄) (hη0 : 0 < η) (hη1 : η ≤ 1) :
η ^ ε * ↑⌈η ^ (-(ε / (4 * (C₄ + 1))))⌉₊ ^ C₄ ≤ 2 ^ C₄ * η ^ (ε / 2)

Blueprint lines 2871-2879: with α = ε/(4(C₄+1)) and P = ⌈η^{-α}⌉ (0 < η ≤ 1), η^ε P^{C₄} ≤ 2^{C₄} η^{ε/2}.

Summing the update levels (prop:normalized, blueprint lines 2893-2899) #

theorem TrilinearHT.Auto.le_stagAcc_pow {k₁ A : ℕ} (hk : 1 ≤ k₁) (hA : 2 ≤ A) {t : ℕ} (ht : 1 ≤ t) :
k₁ ^ t ≤ stagAcc k₁ A t

The union of the cuts (blueprint lines 2839-2841) #

theorem TrilinearHT.Auto.exceptional_union (G : RealDyadicGrid) {ι : Type u_1} (T : Finset ι) (F : ι → Finset (ℤ × ℤ)) (ρs : ι → ℝ) (root : ℤ × ℤ) (hFR : ∀ i ∈ T, ∀ c ∈ F i, dyadicGridCell G c.1 c.2 ⊆ dyadicGridCell G root.1 root.2) (hF : ∀ i ∈ T, dyadicRootLength G (F i) ≤ ρs i * dyadicGridLength G root.1) (hρ : ∑ i ∈ T, ρs i ≤ 1 / 4) :
∃ (X : Finset (ℤ × ℤ)), (∀ c ∈ X, dyadicGridCell G c.1 c.2 ⊆ dyadicGridCell G root.1 root.2) ∧ (∀ c ∈ X, ∀ c' ∈ X, c ≠ c' → Disjoint (dyadicGridCell G c.1 c.2) (dyadicGridCell G c'.1 c'.2)) ∧ ∑ c ∈ X, dyadicGridLength G c.1 ≤ 1 / 4 * dyadicGridLength G root.1 ∧ ∀ i ∈ T, ∀ c ∈ F i, ∃ d ∈ X, dyadicGridCell G c.1 c.2 ⊆ dyadicGridCell G d.1 d.2

Blueprint lines 2839-2841 ("choose their thresholds so the union of exceptional roots has length at most |R|/4"): finitely many cut families F_i inside the root, of lengths at most ρ_i |R| with Σ ρ_i ≤ 1/4, have maximal union cells X that are inside the root, pairwise disjoint, of total length at most |R|/4, and cover every cut cell.

Normalized absorption (prop:normalized, blueprint lines 2827-2904) #

theorem TrilinearHT.Auto.exists_exponent_near_two (C₅ : ℝ) (hC : 0 ≤ C₅) :
∃ (q : ℝ), 2 < q ∧ q < 3 ∧ 2 * C₅ * ((q - 2) / (q - 1)) < 1 / 8

Blueprint lines 2867-2869: some 2 < q < 3 satisfies 2 C₅ (q-2)/(q-1) < 1/8.

Abstract stopping generations for blueprint thm:uniform-local, lines 2910-2925: a finite laminar family of nonempty cells, roots, and a stopping relation bad J K ("K violates the averages of J").

noncomputable def TrilinearHT.Auto.firstStops {α : Type u_1} (C : Finset α) (cell : α → Set ℝ) (bad : α → α → Prop) [(J K : α) → Decidable (bad J K)] (J : α) :

The first stops of J: maximal cells of C strictly inside J violating J.

Equations
Instances For
    noncomputable def TrilinearHT.Auto.stopGen {α : Type u_1} [DecidableEq α] (C : Finset α) (cell : α → Set ℝ) (bad : α → α → Prop) [(J K : α) → Decidable (bad J K)] (roots : Finset α) :
    ℕ → Finset α

    The stopping generations, starting from the roots.

    Equations
    Instances For
      theorem TrilinearHT.Auto.mem_firstStops {α : Type u_1} {C : Finset α} {cell : α → Set ℝ} {bad : α → α → Prop} [(J K : α) → Decidable (bad J K)] {J K : α} :
      K ∈ firstStops C cell bad J ↔ (K ∈ C ∧ cell K ⊂ cell J ∧ bad J K) ∧ ¬∃ L ∈ C, cell K ⊂ cell L ∧ cell L ⊂ cell J ∧ bad J L
      theorem TrilinearHT.Auto.firstStops_subset {α : Type u_1} {C : Finset α} {cell : α → Set ℝ} {bad : α → α → Prop} [(J K : α) → Decidable (bad J K)] (J : α) :
      firstStops C cell bad J ⊆ C

      Normalized absorption from the active-final estimate (prop:normalized, lines 2827-2904) #

      theorem TrilinearHT.Auto.eventually_pow_mul_exp_le (C : ℕ) {θ : ℝ} (hθ : 0 < θ) :
      ∃ (K : ℕ), ∀ (k : ℕ), K ≤ k → ↑k ^ C * Real.exp (-2 * ↑k ^ θ) ≤ Real.exp (-↑k ^ θ)

      For θ > 0, eventually in k, k^{C} e^{-2 k^θ} ≤ e^{-k^θ}.

      noncomputable def TrilinearHT.Auto.ActiveSetup.depthWeight {κ : LocalKernelClass} {c₀ : ℕ} (B : ActiveSetup κ c₀) :

      The depth weight of a setup: the sum of the depths of its cells below the root plus their number; it strictly decreases on passing to a nonempty proper restart root.

      Equations
      Instances For
        theorem TrilinearHT.Auto.ActiveSetup.depthWeight_below_lt {κ : LocalKernelClass} {c₀ : ℕ} (B : ActiveSetup κ c₀) {R' : ℤ × ℤ} (hR' : dyadicGridCell B.G R'.1 R'.2 ⊆ dyadicGridCell B.G B.R.1 B.R.2) (hne : R' ≠ B.R) (hcells : (B.below R').cells.Nonempty) :
        theorem TrilinearHT.Auto.ActiveSetup.restart_recursion {κ : LocalKernelClass} {c₀ : ℕ} (Pr : ActiveSetup κ c₀ → Prop) (hPr : ∀ (B : ActiveSetup κ c₀) (R' : ℤ × ℤ), Pr B → dyadicGridCell B.G R'.1 R'.2 ⊆ dyadicGridCell B.G B.R.1 B.R.2 → Pr (B.below R')) (f : ActiveSetup κ c₀ → ℤ × ℤ → ℝ) (hf : ∀ (B : ActiveSetup κ c₀) (R' I : ℤ × ℤ), f (B.below R') I = f B I) {A : ℝ} (hA : 0 ≤ A) (hret : ∀ (B : ActiveSetup κ c₀), Pr B → ∃ (X : Finset (ℤ × ℤ)), (∀ c ∈ X, dyadicGridCell B.G c.1 c.2 ⊆ dyadicGridCell B.G B.R.1 B.R.2) ∧ (∀ c ∈ X, ∀ c' ∈ X, c ≠ c' → Disjoint (dyadicGridCell B.G c.1 c.2) (dyadicGridCell B.G c'.1 c'.2)) ∧ ∑ c ∈ X, dyadicGridLength B.G c.1 ≤ 1 / 4 * dyadicGridLength B.G B.R.1 ∧ ∑ I ∈ B.cells with ¬∃ c ∈ X, dyadicGridCell B.G I.1 I.2 ⊆ dyadicGridCell B.G c.1 c.2, f B I ≤ A * dyadicGridLength B.G B.R.1) (B : ActiveSetup κ c₀) :
        Pr B → ∑ I ∈ B.cells, f B I ≤ 4 / 3 * A * dyadicGridLength B.G B.R.1

        Blueprint prop:normalized, lines 2840-2843 ("restart there ... the root packing gives total length at most 4|R|/3; on a finite tree this recursion terminates, so a retained-attempt estimate sums with this fixed factor"): if every setup with a property Pr inherited by restarts has pairwise disjoint exceptional roots of total length at most |R|/4 and its retained cells (those below no exceptional root) contribute at most A |R|, then all cells contribute at most (4/3) A |R|.

        def TrilinearHT.Auto.ActiveSetup.basicSlot {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (p : Fin 3) :
        Fin 4

        A slot other than the marked slot of a pattern.

        Equations
        Instances For
          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.failedCells {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Hed : ℝ) (b1 b2 : ℕ) (ωp ωh : Fin (colorDegree A.famVtxBound) → bf.Vtx → Fin (colorDegree A.famVtxBound + 1)) :

          The failed cells of the admission tree of the original basic columns for fixed delay arrays.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.failure_cut {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Hed : ℝ) (b1 b2 : ℕ) (ωp ωh : Fin (colorDegree A.famVtxBound) → bf.Vtx → Fin (colorDegree A.famVtxBound + 1)) (hcol : IsMonotoneColoring bf.admT (bf.tagDist Hed) A.famVtxBound b1 b2 Finset.univ admCellSet (dyadicGridCell A.G A.R.1 A.R.2) ωp ωh) :
            have X := maximalDyadicCells A.G (bf.failedCells Hed b1 b2 ωp ωh); (∀ c ∈ X, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G A.R.1 A.R.2) ∧ (∀ c ∈ X, ∀ c' ∈ X, c ≠ c' → Disjoint (dyadicGridCell A.G c.1 c.2) (dyadicGridCell A.G c'.1 c'.2)) ∧ ∑ c ∈ X, dyadicGridLength A.G c.1 ≤ 100 * 2001 ^ 7 / ↑A.famVtxBound * dyadicGridLength A.G A.R.1 ∧ ∀ I ∈ A.cells, (¬∃ c ∈ X, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G c.1 c.2) → ¬ColorSetup.FailAt bf.admT (bf.tagDist Hed) (colorDegree A.famVtxBound) b1 b2 ωp ωh (bf.admAt I)

            Blueprint lines 1745 and 2839 ("marking failures have the length bound already proved"), on the original basic columns: the maximal failed cells of a monotone coloring are pairwise disjoint cells below the root of total length at most 100 · 2001⁷ |R| / D, and every cell of the setup below none of them succeeds.

            The failure roots of an attempt on the original basic columns: the maximal failed cells of its coloring.

            Equations
            Instances For
              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.failure_cut {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hcol : IsMonotoneColoring bf.admT (bf.tagDist fp.Hed) A.famVtxBound (A.fcb1 fp.Hmax) (cb2 fp.Hmax) Finset.univ admCellSet (dyadicGridCell A.G A.R.1 A.R.2) fp.ωp fp.ωh) :
              (∀ c ∈ fp.failRoots, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G A.R.1 A.R.2) ∧ (∀ c ∈ fp.failRoots, ∀ c' ∈ fp.failRoots, c ≠ c' → Disjoint (dyadicGridCell A.G c.1 c.2) (dyadicGridCell A.G c'.1 c'.2)) ∧ ∑ c ∈ fp.failRoots, dyadicGridLength A.G c.1 ≤ 100 * 2001 ^ 7 / ↑A.famVtxBound * dyadicGridLength A.G A.R.1 ∧ ∀ I ∈ A.cells, (¬∃ c ∈ fp.failRoots, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G c.1 c.2) → ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)

              failure_cut for an attempt: for a monotone coloring at the scales of the attempt, the failure roots are disjoint cells below the root of total length at most 100 · 2001⁷ |R| / D, and at every cell of the setup below no failure root all present vertices succeed (blueprint lines 1745, 2839).

              The slot inputs of a pattern on the main columns (blueprint lines 2838-2839) #

              noncomputable def TrilinearHT.Auto.ActiveSetup.uslot {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (p : Fin 3) :

              The slot of the basic side of the pattern p: none for the all-basic pattern, the marked slot otherwise.

              Equations
              Instances For
                theorem TrilinearHT.Auto.ActiveSetup.mslot_mem {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (p : Fin 3) :
                A.mslot p = A.a ∨ A.mslot p = A.b
                theorem TrilinearHT.Auto.ActiveSetup.uslot_ab {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {p : Fin 3} {l : Fin 4} (h : A.uslot p = some l) :
                l = A.a ∨ l = A.b
                theorem TrilinearHT.Auto.ActiveSetup.z_of_uslot {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {p : Fin 3} {l : Fin 4} (h : A.uslot p = some l) (I : ℤ × ℤ) :
                A.z p.castSucc I l = A.U l I
                theorem TrilinearHT.Auto.ActiveSetup.z_of_not_uslot {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {p : Fin 3} {l : Fin 4} (h : A.uslot p ≠ some l) (I : ℤ × ℤ) :
                A.z p.castSucc I l = A.B l I
                noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.patIn {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) (I : ℤ × ℤ) (l : Fin 4) :
                ↥(ColumnL2 (bf.Lab ⊕ Fin Mc))

                The slot inputs of the pattern p on the main columns (blueprint lines 1607-1623 and 2838-2839, the noninitial base tuple of an active pattern): the basic side U in the marked slot of a side pattern, the basic inputs B elsewhere.

                Equations
                Instances For
                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.patIn_phys {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) {I : ℤ × ℤ} (hI : I ∈ A.cells) (l : Fin 4) :
                  ∀ᵐ (y : ℝ), y ∈ dyadicGridCell A.G I.1 I.2 → augPhys (bf.patIn Mc p I l) y = A.z p.castSucc I l y

                  On a cell of the setup the physical parts of the pattern inputs are the slot arguments of the pattern.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.patIn_fresh {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) (I : ℤ × ℤ) (l : Fin 4) :
                  MainFresh Mc 0 (bf.patIn Mc p I l)

                  The pattern inputs have no template coordinates.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.patIn_support {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) (I : ℤ × ℤ) (l : Fin 4) :
                  ∀ᵐ (y : ℝ), y ∉ dyadicGridCell A.G I.1 I.2 → ↑↑(bf.patIn Mc p I l) y = 0

                  The pattern inputs vanish off their cell.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.norm_patIn_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) {I : ℤ × ℤ} (hI : I ∈ A.cells) (l : Fin 4) :
                  ‖bf.patIn Mc p I l‖ ≤ max 2 A.S * √(dyadicGridLength A.G I.1)

                  The pattern inputs have normalized size at most max 2 S on the cells of the setup.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Λc_patIn {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (p : Fin 3) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                  (fp.Λc I) (bf.patIn fp.Mc p I) = A.Hf I (A.z p.castSucc I)

                  The cell forms of the pattern inputs on the main columns are the local forms of the pattern (blueprint lines 2838-2839: the attempt acts on the noninitial base tuple of the active pattern).

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.groupsAt_cert_use {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {I : ℤ × ℤ} (hI : I ∈ A.cells) {k : ℕ} {G : bf.Grp} (hG : G ∈ fp.groupsAt I k) (hS : ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)) :
                  fp.Cert k G I ∧ fp.ActualUse G I

                  Blueprint lines 1850, 1863 and 1876 on the main columns: at a cell of the setup whose present vertices all succeed (a retained cell, below no failure root by failure_cut), every current group of color k has a certificate and an actual use at the cell.

                  The parameters of an attempt on the main columns (blueprint lines 1800-1830, 2838-2839) #

                  noncomputable def TrilinearHT.Auto.ActiveSetup.famLc {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) :

                  The number of colors L = d₀^{30} + 1 of an attempt on the main columns (blueprint line 1734: the colors are at most d₀^{30}).

                  Equations
                  Instances For
                    noncomputable def TrilinearHT.Auto.ActiveSetup.famFuel {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) :

                    The search fuel ⌈log₂ L⌉ + 1 of an attempt (blueprint line 1850: O(log L) binary steps).

                    Equations
                    Instances For
                      noncomputable def TrilinearHT.Auto.ActiveSetup.famHmax {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (P : ℕ) :

                      The pad bound H_max = 20 P (L + 1) + 40 P of an attempt with P pads (blueprint line 1808: all neighbor enlargements of the pads lie below H_max).

                      Equations
                      Instances For
                        noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.attemptFam {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (P : ℕ) (hP : 0 < P) (Hed : ℝ) (ωp ωh : Fin A.fcd0 → bf.Vtx → Fin (A.fcd0 + 1)) (Mc : ℕ) :

                        The parameters of an attempt on the main columns with P pads, edge threshold H_ed, delay arrays ω_p, ω_h and M_c main labels: L = d₀^{30} + 1, m_H = 2 fuel + 2, H_max = 20 P (L + 1) + 40 P.

                        Equations
                        • bf.attemptFam P hP Hed ωp ωh Mc = { Hed := Hed, Hmax := A.famHmax P, ωp := ωp, ωh := ωh, P := P, hP := hP, Lc := A.famLc, Mc := Mc, mH := 2 * A.famFuel + 2, pads_le := ⋯ }
                        Instances For
                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.patIn_of_ne {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (p : Fin 3) (I : ℤ × ℤ) {l : Fin 4} (h : A.uslot p ≠ some l) :
                          bf.patIn Mc p I l = bf.basicIn Mc l I
                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.exists_attempt (c Dst : ℕ) :
                          ∃ (C : ℕ) (k₀ : ℝ), 2 ≤ k₀ ∧ ∀ {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {k : ℝ}, k₀ ≤ k → SameTagBound κ A.csrc Dst → ∀ (p : Fin 3), ∀ Tc ⊆ A.cells, ∀ (x : bf.Vtx) (P : ℕ), 0 < P → ∀ {τ₃ : ℝ} {Mp : ℕ} (Bh : Type) [inst : Fintype Bh] (Hlow : ℕ → (ℕ → ℝ) → ℕ → ℝ) (Mx : ℕ → (ℕ → ℝ) → ℕ → ℕ), ↑A.famLc + 6 ≤ k ^ c → ↑A.famVtxBound ≤ Real.exp (k ^ c) → ↑(A.famHmax P) + 1 ≤ Real.exp (k ^ c) → ↑(2 * A.famFuel + 2) ≤ ↑c * (Real.log k + 1) → Real.log A.Hsrc ≤ k ^ c → 0 < τ₃ → τ₃ ≤ 1 → τ₃⁻¹ ≤ Real.exp (k ^ c) → 1 ≤ Mp → ↑Mp ≤ Real.exp (k ^ c) → 2 * A.colBudget ≤ Real.exp (k ^ c) → ↑(Fintype.card Bh) ≤ Real.exp (k ^ c) → (∀ (I : ℤ × ℤ), {I' ∈ Tc | dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I'.1 I'.2}.card ≤ Mp) → ∃ (fp : bf.FamParams) (cat : Fin 4 → List (CatCol bf.Vtx)) (Kt : ℕ) (n : ℕ → ℝ) (Tmax : ℕ), fp.P = P ∧ fp.Lc = A.famLc ∧ fp.mH = 2 * A.famFuel + 2 ∧ fp.Hmax = A.famHmax P ∧ fp.Mc = Tc.card * Tmax + Mx Kt n Tmax ∧ fp.Hed = max (Hlow Kt n Tmax) (max 2 (Real.exp (↑A.Dg * ⋯))) ∧ IsMonotoneColoring bf.admT (bf.tagDist fp.Hed) A.famVtxBound (A.fcb1 fp.Hmax) (cb2 fp.Hmax) Finset.univ admCellSet (dyadicGridCell A.G A.R.1 A.R.2) fp.ωp fp.ωh ∧ (∀ (I : ℤ × ℤ), Fintype.card (fp.TestName I Unit) ≤ Kt) ∧ (∀ (I : ℤ × ℤ), ⋯ ≤ Kt) ∧ Real.log ↑Kt ≤ k ^ C ∧ 2 * A.colBudget ≤ n 0 ∧ ⋯

                          Blueprint lines 2838-2839 with lines 1800-1856 (one attempt on the noninitial base tuple of an active pattern, on the main columns): with P pads, L = d₀^{30} + 1 colors, fuel ⌈log₂ L⌉ + 1 and m_H = 2 fuel + 2, the closure counts are fixed first (closure_poly; they do not involve H_ed, line 1830), then the edge threshold H_ed above any prescribed function of these counts and above the localization threshold, then the delays of the coloring and the label room M_c. The main catalogs, closed on the test cells T_c of path multiplicity at most M_p, then localize the weighted minima of the pattern forms on every set of test cells below no failure root to the leaves of the guarded search, up to Σ |I| · #leaves · 9 (D + 1) τ₃ S⁴.

                          theorem TrilinearHT.Auto.packetW_ge (dmax : ℕ) {H : ℝ} (hH : 0 < H) :
                          8 * (↑dmax + 1) ^ 3 * Real.log (2 * H) / Real.log 2 ≤ packetW dmax H

                          The packet width packetW dominates the width of lem:height at height H in the form used by the linear sides: 8 (d_max + 1)^3 log(2H) / log 2 ≤ packetW d_max H.

                          The uniform first-match and mode parameter bounds of one attempt (blueprint line 2839) #

                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Q0bd {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (dB : ℕ) :

                          The clearing bound of the attempt, ⌈H_ed^(d_B²)⌉: every group center z has its clearing integer Q₀(z) = clearInt C_z at most this bound (blueprint lines 1890 and 1934). It is the Q₀ of the leaf schedule; each group uses its own Q₀(z) (SideInput.withQ0).

                          Equations
                          Instances For
                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Bst {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (D dB : ℕ) (H δc N k δ : ℝ) :

                            The common cutoff B_* = Q₀ 2^(K_*+1) of the attempt (blueprint line 1944), with Q₀ the clearing bound and K_* the truncation exponent of the enlarged budget.

                            Equations
                            • fp.Bst D dB H δc N k δ = ↑(fp.Q0bd dB) * 2 ^ (fp.Kstar D dB H δc N k δ + 1)
                            Instances For
                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.one_le_Q0bd {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (dB : ℕ) (hHed : 2 ≤ fp.Hed) :
                              1 ≤ fp.Q0bd dB
                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.clearInt_le_Q0bd {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {dB : ℕ} (hdim : ∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) (hHed : 2 ≤ fp.Hed) (hC : ∀ (w : bf.Vtx) (a c : Fin (bf.vtag w).dim), ↑(rationalHeight ((bf.vtag w).C a c)) ≤ fp.Hed) (z : bf.Vtx) :
                              1 ≤ clearInt (bf.vtag z).C ∧ clearInt (bf.vtag z).C ≤ fp.Q0bd dB

                              Every group center has its clearing integer between 1 and the clearing bound.

                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.dmax_Q0bd_le_modeStarG {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (D dB : ℕ) {H δc N : ℝ} (k : ℝ) {δ : ℝ} (hδ : 0 < δ) (hHed : 2 ≤ fp.Hed) (hH : 1 ≤ H) (hδc : 0 < δc) (hN0 : 0 ≤ N) :
                              ↑(2 * dB + 2) ≤ fp.modeStarG D dB H δc N k δ ∧ ↑(fp.Q0bd dB) ≤ fp.modeStarG D dB H δc N k δ

                              The enlarged budget D_* dominates d_max = 2 d_B + 2 and the clearing bound.

                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.exists_leaf_schedule (Cj CA CT CK : ℕ) {δs : ℝ} (hδs : 0 < δs) (hδs1 : δs ≤ 1) :
                              ∃ (M : ℝ), 0 < M ∧ ∀ {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (D dB : ℕ) {H δc N : ℝ} (k : ℝ) {δ Dm : ℝ}, 0 < δ → 2 ≤ fp.Hed → 1 ≤ H → 0 < δc → 0 ≤ N → 2 ≤ Dm → (∀ (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) → have Λ := ↑(2 * dB + 2) + Real.log (fp.modeStarG D dB H δc N k δ) + Real.log (fp.Bst D dB H δc N k δ) + Real.log Dm + Real.log ↑(fp.Q0bd dB) + 1; ∃ (S : ModeSchedule), S.dmax = 2 * dB + 2 ∧ S.Dstar = fp.modeStarG D dB H δc N k δ ∧ S.Bstar = fp.Bst D dB H δc N k δ ∧ S.Dm = Dm ∧ S.Q0 = fp.Q0bd dB ∧ S.Valid Cj CA CT CK δs (packetW S.dmax S.H) ∧ 8 * (↑S.dmax + 1) ^ 3 * Real.log (2 * S.H) / Real.log 2 ≤ packetW S.dmax S.H ∧ 2 ≤ S.dmax ∧ ↑S.dmax ≤ S.Dstar ∧ 2 ≤ S.Dstar ∧ 2 ≤ S.Bstar ∧ 1 ≤ S.Q0 ∧ ↑S.Q0 ≤ S.Dstar ∧ (∀ (z : bf.Vtx), 1 ≤ clearInt (bf.vtag z).C ∧ clearInt (bf.vtag z).C ≤ S.Q0) ∧ ↑S.Q0 * 2 ^ (fp.Kstar D dB H δc N k δ + 1) ≤ S.Bstar ∧ Real.log S.H ≤ M * Λ ^ 12 ∧ Real.log S.T ≤ M * Λ ^ 16 ∧ ↑S.K ≤ M * Λ ^ 16

                              Blueprint line 2839, the uniform first-match and mode parameter bounds of one attempt (lines 1934, 1944 and eq:mode-parameters): for the absolute constants of the schedule there is M such that, for every attempt with H_ed ≥ 2, center dimensions at most d_B and center entries of height at most H_ed, and every main budget D_m ≥ 2, there is a schedule S with d_max = 2 d_B + 2, the enlarged budget D_* = modeStarG, the common cutoff B_* = Q₀ 2^(K_*+1), D_m, and the clearing bound Q₀ as S.Q0, satisfying eq:mode-parameters with the packet width of lem:height at the chosen height. Moreover d_max ≤ D_*, Q₀ ≤ D_*, every group center has its clearing integer in [1, Q₀] (the per-group Q₀ of line 1890), the box of K_* fits in B_*, the width bound used by the linear sides holds, and log H, log T, K are polynomial in Λ = d_max + log D_* + log B_* + log D_m + log Q₀ + 1.

                              Offsets and fixed modes of one attempt (blueprint line 2839, lines 2135-2156) #

                              noncomputable def TrilinearHT.Auto.LiftData.empty (Pr : Type u_1) [Fintype Pr] [DecidableEq Pr] :

                              The lift without modes (for groups without an actual use, which never enter a sum).

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                noncomputable def TrilinearHT.Auto.ModeSystem.empty (Gd : RealDyadicGrid) (Mc : ℕ) :

                                The mode system without modes (for groups without an actual use, which never enter a sum).

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  def TrilinearHT.Auto.ActiveSetup.BasicFamilies.grpCenter {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (d : bf.Vtx) (G : bf.Grp) :
                                  bf.Vtx

                                  The center vertex of a group (the vertex d for a group without a center).

                                  Equations
                                  Instances For
                                    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.center_of_actualUse {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {G : bf.Grp} {I : ℤ × ℤ} (h : fp.ActualUse G I) :
                                    ∃ (ρ₀ : Fin A.fcd0) (z : bf.Vtx) (g : ℤ), G.2.1 = some (ρ₀, z, g) ∧ 0 ≤ g

                                    A group with an actual use has a center with nonnegative top score (blueprint line 1934).

                                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.modeBd {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (D dB : ℕ) (H : ℝ) (g : ℤ) (j : ℕ) :

                                    The curvature bound B = exp(D X^D) of the modes of a group with top score g at the ball level j (exists_mainModeSystem).

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ModeExports {κ : 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) (D dB : ℕ) (H δ δc N : ℝ) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) :

                                      The exports of exists_mainModeSystem for the role l (catalog s, ball level j) and the group G (center z, top score g), at the cutoff width δ, the correction size δ_c and an offset in the unit cube (blueprint lines 1932-1940 and 1971-1975).

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        theorem TrilinearHT.Auto.exists_leaf_modes (κ : LocalKernelClass) (c₀ : ℕ) :
                                        ∃ (D : ℕ), 1 ≤ D ∧ ∀ (A : ActiveSetup κ c₀) (bf : A.BasicFamilies) (fp : bf.FamParams) (cat : Fin 4 → List (CatCol bf.Vtx)), (∀ (l : Fin 4), ∀ e ∈ cat l, ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) → (∀ (l : Fin 4), ∀ e ∈ cat l, bf.occAvail (↑e.tag.2) e.tag.1) → ∀ (mbs : (l : Fin 4) → bf.MainBudget (cat l)) (jj : Fin 4 → ℕ) (lsi : Fin 4 → List (ℕ × Bool)) (d : bf.Vtx) (gset : Finset bf.Grp), (∀ G ∈ gset, ∃ (I : ℤ × ℤ), fp.ActualUse G I) → A.AncClosed → ∀ {K : ℕ} (blk : ℤ × ℤ → ℤ), (∀ (I : ℤ × ℤ), blk I ≤ I.1 ∧ I.1 < blk I + ↑K) → ∀ (U : Fin 4 → bf.Grp → Finset (ℤ × ℤ)), (∀ (l : Fin 4) (G : bf.Grp), ∀ I ∈ U l G, fp.ActualUse G I) → ∀ {Nuse : ℕ}, (∀ (y : ℝ), ∑ l : Fin 4, ∑ G ∈ gset, {I ∈ U l G | y ∈ dyadicGridCell A.G I.1 I.2}.card ≤ Nuse) → 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 / 8 → 8 * ↑dB * δ ≤ 1 → ∀ {H : ℝ}, A.Hsrc ≤ H → ↑dB ≤ Real.log H → (∀ (w : bf.Vtx) (l : Fin 4) (i k : Fin (bf.vtag w).dim), ↑(chartRationalHeight ((↑(-slotCoeff l) • (bf.vtag w).C) i k)) ≤ H) → ↑dB * (bumpConst * 8 ^ 32 * (2 / δ)) ≤ H → ∀ {δc : ℝ}, 0 < δc → ∀ {N CF : ℝ}, 0 ≤ N → 0 ≤ CF → (∀ (l : Fin 4), ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols l) (cat l) I (fp.brank (jj l))).card ≤ N) → δc ^ 2 * N * A.colBudget ^ 2 ≤ 1 → (∀ (l : Fin 4) (jb : Fin 2), ∀ V ∈ A.cells, ‖(columnL2Restriction (dyadicGridCell A.G V.1 V.2) ⋯) (bf.P l jb).Z‖ ^ 2 ≤ CF * dyadicGridLength A.G V.1) → ∃ (Ms : Fin 4 → bf.Grp → ModeSystem A.G (Fintype.card (bf.Lab ⊕ Fin fp.Mc))) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (Ms l G).Md), (∀ (l : Fin 4), ∀ G ∈ gset, fp.ModeExports l (cat l) G (jj l) d D dB H δ δc N (Ms l G) (L l G)) ∧ (∀ (l : Fin 4), ∀ G ∉ gset, ⋯ ∧ ⋯) ∧ ∑ l : Fin 4, ∑ G ∈ gset, ∑ I ∈ U l G, ⋯ ≤ ⋯ * ⋯ * ↑Nuse * dyadicGridLength A.G A.R.1

                                        Blueprint line 2839 (the offsets, by the measurable majorant on pre-existing main uses; the corresponding fixed modes), with lines 2135-2156: on one search leaf (catalogs cat l with main budgets, ball levels j_l and shared histories of the four roles) and a finite set of groups with actual uses, whose actual main uses U_{l,G} (fixed before the offsets) have at most N_use members through each point, there are mode systems and lifts of every role and group such that each group of the set has the exports of exists_mainModeSystem at one common offset per role and group, chosen by the explicit majorant of physical_error_used, and the physical errors of eq:physical-error satisfy Σ_l Σ_G Σ_{I ∈ U_{l,G}} ∫_I |E_{l,G,b(I)}|² ≤ (8 d_B δ + 2 δ_c²) 4 N colBudget² C_F N_use |R|. Classical choice is used only after the offsets are selected; groups outside the set get the empty mode system.

                                        theorem TrilinearHT.Auto.card_image_le_of_factor {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq β] [DecidableEq γ] (s : Finset α) (f : α → β) (g : α → γ) (h : ∀ a ∈ s, ∀ b ∈ s, g a = g b → f a = f b) :

                                        An image of a finite set is not larger than a second image when the second map determines the first on the set.

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.alive_keys_le {κ : 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} {D dB : ℕ} {H : ℝ} {g : ℤ} {n : ℕ} {Ms : ModeSystem A.G n} {L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md} (hex : fp.MainLiftExports l s G j d D dB H g L Ms.wave Ms.cellOf) (hown : ∀ (m m' : Ms.Md), Ms.L.own m = Ms.L.own m' ↔ L.own m = L.own m') {N : ℝ} (hN0 : 0 ≤ N) (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols l) s I (fp.brank j)).card ≤ N) (U : ℤ × ℤ) :
                                        ↑(Finset.image Ms.keyOf (Ms.alive U)).card ≤ N

                                        The keys of the modes alive on a cell number at most N, the number of main labels of the role at every active cell: a key is determined by the primary and the first-match cell of its modes, the first-match cells of one primary are disjoint, and all these primaries are primaries at the deepest of these first-match cells (primaries_of_firstCell, blueprint line 1888: "the mode lists, including primaries whose coefficients are zero, are nested").

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ModeExports.sched {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {l : Fin 4} {s : List (CatCol bf.Vtx)} {G : bf.Grp} {j : ℕ} (hj : j ≤ 4) {d : bf.Vtx} {D dB : ℕ} {H δ δc N : ℝ} (k : ℝ) {n : ℕ} {Ms : ModeSystem A.G n} {L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md} (hE : fp.ModeExports l s G j d D dB H δ δc N Ms L) (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hHed : 2 ≤ fp.Hed) (hH : 1 ≤ H) (hδc : 0 < δc) (hN0 : 0 ≤ N) (hdim : ∀ (w : bf.Vtx), (bf.vtag w).dim ≤ dB) (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols l) s I (fp.brank j)).card ≤ N) :
                                        (∀ (p : Ms.Key), Ms.dvOf p + Ms.zc.dim ≤ 2 * dB + 2) ∧ Ms.Λ ≤ fp.modeStarG D dB H δc N k δ ∧ gaugeSqNorm Ms.zc.dim Ms.δc ≤ fp.modeStarG D dB H δc N k δ ∧ 2 * gaugeTail Ms.zc.dim Ms.δc / 2 ^ fp.Kstar D dB H δc N k δ * fp.modeStarG D dB H δc N k δ ^ 300 ≤ 1 ∧ (∀ (m : Ms.Md), (fp.modeStarG D dB H δc N k δ)⁻¹ ≤ Ms.L.εM m) ∧ (∀ (U : ℤ × ℤ), ↑(Ms.alive U).card ≤ fp.modeStarG D dB H δc N k δ) ∧ ∀ (U : ℤ × ℤ), ↑(Finset.image Ms.keyOf (Ms.alive U)).card ≤ N

                                        The schedule conditions on the mode systems of one attempt (blueprint lines 1934 and 1944): for the exports of a role and group at a ball level j ≤ 4, the dimensions are at most d_max = 2 d_B + 2; the enlarged budget D_* = modeStarG bounds the curvature bound, the gauge norm (ζ^ρ)², the inverse private weights and the alive modes; the truncation exponent K_* makes the gauge tails at most D_*^(-300); and the keys alive on a cell number at most N.

                                        theorem TrilinearHT.Auto.admTree_anc_cell {G : RealDyadicGrid} {R : ℤ × ℤ} {N : ℕ} {Λ : Type u_1} [Fintype Λ] (av : ℤ × ℤ → Λ → Prop) {I J : AdmCell G R N} (h : (admTree av).Anc (some J) (some I)) :
                                        dyadicGridCell G (↑I).1 (↑I).2 ⊆ dyadicGridCell G (↑J).1 (↑J).2

                                        An ancestor of a cell in the admission tree contains it (the converse of admTree_anc).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.grp_mem_path_of_mode {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hanc : A.AncClosed) {l : Fin 4} {s : List (CatCol bf.Vtx)} {G : bf.Grp} {j : ℕ} {d : bf.Vtx} {D dB : ℕ} {H : ℝ} {g : ℤ} {n : ℕ} {Ms : ModeSystem A.G n} {L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md} (hex : fp.MainLiftExports l s G j d D dB H g L Ms.wave Ms.cellOf) {y : ℝ} {m : Ms.Md} (hm : m ∈ Ms.ptSet y) :
                                        G ∈ Finset.image (fun (p : bf.admT.Cell × bf.Vtx) => fp.K.grp bf.admT A.famVtxBound p.1 p.2) ({p ∈ Finset.image bf.admAt ({I ∈ A.cells | y ∈ dyadicGridCell A.G I.1 I.2}) ×ˢ Finset.univ | p.2 ∈ bf.admT.X p.1})

                                        A group with a mode through a point has a present central vertex at an active cell containing the point: the primary of the mode lies in the group's ball mask at its first-match cell, and the central vertices of a mask are historical (blueprint lines 1807-1808 and 1934).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.modes_path_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hanc : A.AncClosed) {l : Fin 4} {s : List (CatCol bf.Vtx)} {j : ℕ} (hj : j ≤ 4) {d : bf.Vtx} {D dB : ℕ} {H δ δc N : ℝ} (k : ℝ) (gset : Finset bf.Grp) {n : ℕ} (Ms : bf.Grp → ModeSystem A.G n) (L : (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (Ms G).Md) (hE : ∀ G ∈ gset, fp.ModeExports l s G j d D dB H δ δc N (Ms G) (L G)) (hδ : 0 < δ) (hHed : 2 ≤ fp.Hed) (hH : 1 ≤ H) (hδc : 0 < δc) (hN0 : 0 ≤ N) (y : ℝ) :
                                        ∑ G ∈ gset, ↑((Ms G).ptSet y).card ≤ fp.modeStarG D dB H δc N k δ

                                        Blueprint line 1934 ("all modes ... along a path across groups"): for the mode systems of the groups of a finite set at one role and ball level j ≤ 4, the modes through any point number at most D_* = modeStarG: at most D (potMax + 1) groups have a central vertex on the path (card_groups_path_le), and each has at most N B (4 max(1, 4B/δ_c) + 1)^(4 d_B) modes through the point, B ≤ exp(D X_max^D).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Q0bd_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (dB : ℕ) (hHed : 2 ≤ fp.Hed) :
                                        ↑(fp.Q0bd dB) ≤ fp.Hed ^ (dB * dB) + 1

                                        The clearing bound is at most H_ed^(d_B²) + 1.

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ModeExports.hBσ_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {l : Fin 4} {s : List (CatCol bf.Vtx)} {G : bf.Grp} {j : ℕ} (hj : j ≤ 4) {d : bf.Vtx} {D dB : ℕ} {H δ δc N : ℝ} (k : ℝ) {n : ℕ} {Ms : ModeSystem A.G n} {L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md} (hE : fp.ModeExports l s G j d D dB H δ δc N Ms L) (hδ : 0 < δ) (hHed : 2 ≤ fp.Hed) (hH : 1 ≤ H) (hδc : 0 < δc) (hN0 : 0 ≤ N) {Q : ℝ} (hQ0 : 0 ≤ Q) (hQ : Q ≤ fp.Hed ^ (dB * dB) + 1) :
                                        2 * (Q * (3 * (Ms.Bσ * Ms.Bσ) ^ 2)) ^ 2 ≤ ↑⌊fp.modeStarG D dB H δc N k δ⌋₊

                                        The heights of the rescaled differences of mode differences are covered by the enlarged budget (blueprint line 1934): for the exports of a role and group at a ball level j ≤ 4 and a clearing integer Q ≤ H_ed^(d_B²) + 1, 2 (Q (3 B_σ²)²)² ≤ ⌊D_*⌋ (the hypothesis hBσ of the representatives and first top counts).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.blkStart_mem_blocks {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {K : ℕ} (hK : 1 ≤ K) {I : ℤ × ℤ} (hIR : A.R.1 ≤ I.1) {Bn : ℕ} (hbk : ((I.1 - A.R.1) / ↑K).toNat < Bn) :
                                        A.blkStart K I.1 ∈ Finset.image (fun (β : ℕ) => A.R.1 + ↑(K * β)) (Finset.range Bn)

                                        The block start of a cell below the root in block β < B_n is one of the block starts R + K β, β < B_n.

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.repAt_of_family {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (gset : Finset bf.Grp) (Bs : Finset ℤ) (c : (G : ↥gset) → ℤ → ℤ × ℤ → (D.Ms l ↑G).Md → ℂ) (hc : ∀ (G : bf.Grp) (hG : G ∈ gset), D.c l G = c ⟨G, hG⟩) (hrep : ∀ (G : ↥gset), ∀ b ∈ Bs, ∀ J ∈ fp.retainedV (↑G) b D.S.K, (D.Ms l ↑G).frozenEval (D.S.withQ0 (qG ↑G)) b J (c G b J) = (columnL2Restriction (dyadicGridCell A.G J.1 J.2) ⋯) ((L l ↑G).op (fp.frozenZ l (D.cat l) (D.mbs l) (↑G) (D.Lf.role l) (D.Lf.layers l) (b - 4 * ↑D.S.K)))) {G : bf.Grp} (hG : G ∈ gset) {I : ℤ × ℤ} (hI : A.blkStart D.S.K I.1 ∈ Bs) :
                                        (D.withQ0 (qG G)).RepAt L l G I

                                        The frozen coefficients of a family of groups give RepAt at every cell whose block start is a block of the family (the first export of first_top_count_main, per group with its clearing integer).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.hlin_of_family {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (l : Fin 4) (gset : Finset bf.Grp) (Bn : ℕ) (c : (G : ↥gset) → ℤ → ℤ × ℤ → (D.Ms l ↑G).Md → ℂ) (hc : ∀ (G : bf.Grp) (hG : G ∈ gset), D.c l G = c ⟨G, hG⟩) {V : ℝ} (hVE : ∑ G : ↥gset, ∑ b ∈ Finset.image (fun (β : ℕ) => A.R.1 + ↑(D.S.K * β)) (Finset.range Bn), ‖(D.Ms l ↑G).blockSide (D.S.withQ0 (qG ↑G)) ⋯ D.SP b (fp.retainedV (↑G) b D.S.K) (c G b)‖ ^ 2 ≤ V) :
                                        ∑ G ∈ gset, ∑ β ∈ Finset.range Bn, ‖(D.Ms l G).blockSide (D.S.withQ0 (qG G)) ⋯ D.SP (A.R.1 + ↑(D.S.K * β)) (fp.retainedV G (A.R.1 + ↑(D.S.K * β)) D.S.K) (D.c l G (A.R.1 + ↑(D.S.K * β)))‖ ^ 2 ≤ V

                                        The linear-side bound of a family of groups over the blocks R + K β, β < B_n, in the form of the side input (the hypothesis hlin of core_reduction_leaf).

                                        Helper templates leave the main objects unchanged (blueprint line 2168) #

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basicOut_restrict_append {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s t : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (mb' : bf.MainBudget (s ++ t)) (G : bf.Grp) {j : ℕ} (hj : j ≤ 4) (ls : List (ℕ × Bool)) (ht : ∀ d ∈ t, fp.hrank ≤ d.rank) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                        (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l (s ++ t) mb' G j ls I.1) = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls I.1)

                                        Blueprint line 2168 ("helper ranks exceed every main rank, so their insertion leaves all previously fixed main projections ... unchanged"): on an active cell of its depth, the basic coarse output of a catalog extended by templates of the helper rank equals that of the catalog, for any main budgets (both are the leaf outputs of the cell, basicOut_restrict, whose ball and cumulative filters are unchanged).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.frozenZ_restrict_append {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hanc : A.AncClosed) (l : Fin 4) (s t : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (mb' : bf.MainBudget (s ++ t)) (G : bf.Grp) {j : ℕ} (hj : j ≤ 4) (ls : List (ℕ × Bool)) (ht : ∀ d ∈ t, fp.hrank ≤ d.rank) {I : ℤ × ℤ} (hI : I ∈ A.cells) {u : ℤ} (hu : u ≤ I.1) :
                                        (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.frozenZ l (s ++ t) mb' G j ls u) = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.frozenZ l s mb G j ls u)

                                        The frozen output at a depth u ≤ I.1, restricted to an active cell I, is unchanged by helper templates: it is the restriction of the output on the active ancestor of depth u.

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState_restrict_append {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hanc : A.AncClosed) {n : ℕ} (Ms : ModeSystem A.G n) (l : Fin 4) (s t : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (mb' : bf.MainBudget (s ++ t)) (G : bf.Grp) {j : ℕ} (hj : j ≤ 4) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (c : ℤ × ℤ → Ms.Md → ℂ) {b : ℤ} (ht : ∀ d ∈ t, fp.hrank ≤ d.rank) {I : ℤ × ℤ} (hI : I ∈ A.cells) (hb : b - 4 * ↑S.K ≤ I.1) :
                                        (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.sideState Ms l (s ++ t) mb' G j ls S hA SP c b I.1) = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.sideState Ms l s mb G j ls S hA SP c b I.1)

                                        The side state at the depth of an active cell, restricted to the cell, is unchanged by helper templates (eq:sides: the rolling output, the frozen output at u_b ≤ I.1 and the catalog-free side subtotal).

                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mem_cells_of_retainedV {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hanc : A.AncClosed) {G : bf.Grp} {b : ℤ} {K : ℕ} {J : ℤ × ℤ} (hJ : J ∈ fp.retainedV G b K) :

                                        A retained v_b-cell is an active cell (it contains an actual use and lies below the root).

                                        def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) :

                                        The side input with the slot catalogs extended by the helper templates t, with main budgets of the extended catalogs (blueprint lines 2167-2169); all other data are those of D.

                                        Equations
                                        • D.appendCat t mb' = { cat := fun (l : Fin 4) => D.cat l ++ t l, mbs := mb', Lf := D.Lf, u := D.u, S := D.S, hA := ⋯, SP := D.SP, hK := ⋯, n := D.n, Ms := D.Ms, c := D.c }
                                        Instances For
                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.toLeafQ_sv_appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (hanc : A.AncClosed) (ht : ∀ (l : Fin 4), ∀ d ∈ t l, fp.hrank ≤ d.rank) (hrole : ∀ (l : Fin 4), D.Lf.role l ≤ 4) (qG : bf.Grp → ℕ) (l : Fin 4) (G : bf.Grp) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                          ((D.appendCat t mb').toLeafQ qG).sv l G I = (D.toLeafQ qG).sv l G I

                                          Blueprint line 2168: the side values of the leaf are unchanged by the helper templates on the active cells (sideState_restrict_append; the whole outputs of the basic U slot by the unchanged filters).

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.toLeafQ_out_appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (ht : ∀ (l : Fin 4), ∀ d ∈ t l, fp.hrank ≤ d.rank) (hrole : ∀ (l : Fin 4), D.Lf.role l ≤ 4) (qG : bf.Grp → ℕ) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                          ((D.appendCat t mb').toLeafQ qG).out l G I = (D.toLeafQ qG).out l G I

                                          The whole leaf outputs are unchanged by the helper templates (unchanged filters).

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.repAt_appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (hanc : A.AncClosed) (ht : ∀ (l : Fin 4), ∀ d ∈ t l, fp.hrank ≤ d.rank) (hrole : ∀ (l : Fin 4), D.Lf.role l ≤ 4) (q : ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                          ((D.appendCat t mb').withQ0 q).RepAt L l G I ↔ (D.withQ0 q).RepAt L l G I

                                          The frozen representation RepAt is unchanged by the helper templates: the frozen outputs on the retained (active) v_b-cells are unchanged, and the lift commutes with restrictions.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.errAt_appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (hanc : A.AncClosed) (ht : ∀ (l : Fin 4), ∀ d ∈ t l, fp.hrank ≤ d.rank) (hrole : ∀ (l : Fin 4), D.Lf.role l ≤ 4) (q : ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                          ((D.appendCat t mb').withQ0 q).errAt L l G I = (D.withQ0 q).errAt L l G I

                                          The physical errors on the active cells are unchanged by the helper templates.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.restrict_wColumn_self {W : Type u_1} [Fintype W] (s : Set ℝ) (hs : MeasurableSet s) (φ : W → ℝ → ℂ) (ε : W → ℝ) (x : W) :
                                          (columnL2Restriction s hs) (wColumn s φ ε x) = wColumn s φ ε x

                                          A weighted column on a set is fixed by the restriction to the set.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.restrict_mainRange_self {V : Type} [Fintype V] {Tg : Type u_1} {Gd : RealDyadicGrid} {Mc : ℕ} {O : OrigCols V Tg} (s : List (CatCol Tg)) (I : ℤ × ℤ) (r : ℕ) (M : Tg → Prop) {x : ↥(ColumnL2 (V ⊕ Fin Mc))} (hx : x ∈ mainRange Gd Mc O s I r M) :
                                          (columnL2Restriction (dyadicGridCell Gd I.1 I.2) ⋯) x = x

                                          The main range of a cell is fixed by the restriction to the cell (its columns live on the cell).

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.restrict_ballFilt_self {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (I : ℤ × ℤ) (G : bf.Grp) (j : ℕ) (x : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
                                          (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((fp.ballFilt l s I G j) x) = (fp.ballFilt l s I G j) x

                                          The outputs of a ball filter at a cell live on the cell.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFilt_fresh {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (I : ℤ × ℤ) (G : bf.Grp) (j : ℕ) (x : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
                                          MainFresh fp.Mc s.length ((fp.ballFilt l s I G j) x)

                                          The outputs of a ball filter of a catalog avoid the fresh labels of the catalog.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.toLeafQ_sv_fresh {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                          MainFresh fp.Mc (D.cat l).length ((D.toLeafQ qG).sv l G I)

                                          The side values of the leaf avoid the fresh labels of their slot catalog (whole side states are physical; the whole output of a basic U slot is a ball filter output).

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.toLeafQ_sv_restrict {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                          (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((D.toLeafQ qG).sv l G I) = (D.toLeafQ qG).sv l G I

                                          The side values of the leaf live on their cell.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.hhpass_appendCat {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (hanc : A.AncClosed) (ht : ∀ (l : Fin 4), ∀ d ∈ t l, fp.hrank ≤ d.rank) (hrole : ∀ (l : Fin 4), D.Lf.role l ≤ 4) (qG : bf.Grp → ℕ) {Bh : Type} (gE : ℤ × ℤ → Bh → bf.Grp) {I : ℤ × ℤ} (hI : I ∈ A.cells) {cS : ℕ} {HS τH : ℝ} (a : Fin 4) (w : fp.HelperName I Bh) (h : (fp.helperOf a I (fun (i : Bh) => (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((D.toLeafQ qG).sv a (gE I i) I)) w).Pass A.G (bf.origCols a) I cS HS bf.vtag (A.w I) τH fp.mH (D.cat a ++ t a)) :
                                          (fp.helperOf a I (fun (i : Bh) => ((D.appendCat t mb').toLeafQ qG).sv a (gE I i) I) w).Pass A.G (bf.origCols a) I cS HS bf.vtag (A.w I) τH fp.mH ((D.appendCat t mb').cat a)

                                          Blueprint lines 2167-2169 on the leaf: the helper tests closed on the whole side states of the leaf with the main catalogs (bases restricted to the active cells, catalogs extended by the helper templates t) are the helper tests of the leaf with the extended catalogs (appendCat), whose side values on the active cells are those of the main catalogs.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainLabels_append_highRank {V : Type} [Fintype V] {Tg : Type u_1} (Gd : RealDyadicGrid) (Mc : ℕ) (O : OrigCols V Tg) (s t : List (CatCol Tg)) (I : ℤ × ℤ) (r : ℕ) (ht : ∀ d ∈ t, r < d.rank) :
                                          mainLabels Gd Mc O (s ++ t) I r = mainLabels Gd Mc O s I r

                                          Catalog columns of rank above r do not change the main labels of rank at most r.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainLabelsM_append_highRank {V : Type} [Fintype V] {Tg : Type u_1} (Gd : RealDyadicGrid) (Mc : ℕ) (O : OrigCols V Tg) (s t : List (CatCol Tg)) (I : ℤ × ℤ) (r : ℕ) (M : Tg → Prop) (d : Tg) (ht : ∀ e ∈ t, r < e.rank) :
                                          mainLabelsM Gd Mc O (s ++ t) I r M d = mainLabelsM Gd Mc O s I r M d

                                          Catalog columns of rank above r do not change the masked main labels of rank at most r.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.occAvail_of_mem_X {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {I : ℤ × ℤ} (hI : I ∈ A.cells) {x : bf.Vtx} (hx : x ∈ bf.admT.X (bf.admAt I)) :
                                          bf.occAvail (↑x.2) x.1

                                          A present vertex at an active cell is an available occurrence at its admission cell.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.maskOf_mem_X {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (I : ℤ × ℤ) (M : fp.MaskName I) {x : bf.Vtx} (hx : fp.maskOf I M x) :
                                          x ∈ bf.admT.X (bf.admAt I)

                                          The vertices of a named mask are present vertices of the cell.

                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.ballDataAppend {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (t : Fin 4 → List (CatCol bf.Vtx)) (mb' : (l : Fin 4) → bf.MainBudget (D.cat l ++ t l)) (qG : bf.Grp → ℕ) {gset : Finset bf.Grp} (B : (D.toLeafQ qG).BallData gset) (hT : ∀ (l : Fin 4), ∀ e ∈ t l, ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) (htag : ∀ (l : Fin 4), ∀ e ∈ t l, bf.occAvail (↑e.tag.2) e.tag.1) (ht : ∀ (l : Fin 4), ∀ e ∈ t l, fp.brank (D.Lf.role l) < e.rank) :
                                          ((D.appendCat t mb').toLeafQ qG).BallData gset

                                          The localization data of the leaf with the catalogs extended by helper templates (of template form, with available tags and of rank above every ball rank): the ball labels are unchanged.

                                          Equations
                                          • D.ballDataAppend t mb' qG B hT htag ht = { hT := ⋯, htag := ⋯, dv := B.dv, hPH := ⋯, N := B.N, hN := ⋯ }
                                          Instances For

                                            Strong stack families cost G₀ (blueprint lines 2393-2420 and line 2839) #

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.bandJumpM_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (n c : ℕ) {k : ℝ} (hk : 1 ≤ k) (hD : Real.log (2 * mb.B) ≤ k ^ c) (hn : ↑n ≤ ↑c * (Real.log k + 1)) :
                                            fp.bandJumpM s mb n ≤ (↑n + 1) ^ 2 * Real.exp (2 * (1024 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) * (1 + Real.log (2 * k)) ^ 2))

                                            Blueprint line 2839 ("the strong stack families cost G₀") with eq:small-overhead: the jump constant of a helper product of n + 1 ≤ c (log k + 1) + 1 layers in the main column tree of a catalog with log (2 D_m) ≤ k^c is at most (n + 1)² G₀², with G₀ = exp(1024 (c + 1) (1024 (c + 1) + c + 7) (1 + log 2k)²) (compressionC_le_overhead).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.stackEA_le_G0 {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {Ω : Type u_1} (Os : Finset Ω) (sA : List (CatCol bf.Vtx)) (mbA : bf.MainBudget sA) (D : Ω → List (Bool × ℕ × Option ℕ)) (N : ℕ) {B EW : ℝ} (hB : 0 ≤ B) (hEW : 0 ≤ EW) (n c : ℕ) {k : ℝ} (hk : 1 ≤ k) (hD : Real.log (2 * mbA.B) ≤ k ^ c) (hn : ↑n ≤ ↑c * (Real.log k + 1)) (hlen : ∀ ω ∈ Os, (D ω).length ≤ n) :
                                            have Cj := (↑n + 1) ^ 2 * Real.exp (2 * (1024 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) * (1 + Real.log (2 * k)) ^ 2)); fp.stackEA Os sA mbA D N B EW ≤ (↑fp.P + 2) * (↑Os.card * (↑N * (2 * B + 16 * (Cj * EW) + 16 * (↑N * (Cj * (↑N * B)))) + EW))

                                            Blueprint eq:stack-energy with the strong stack families costing G₀ (line 2839): the banded stack energy over outer configurations whose helper prefixes have at most n ≤ c (log k + 1) steps, in the main column tree of a catalog with log (2 D_m) ≤ k^c, is at most P + 2 times the P-free quantity of stackEA_le with the jump constant (n + 1)² G₀² (bandJumpM_le).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideLeafM.pe_length_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (T : fp.SideLeafM) {fuel : ℕ} {up₀ : Fin 4} {s : ℕ} (hLf : T.Lf = leafAt fuel fp.Lc up₀ s) (l : Fin 4) :
                                            (T.pe l).length ≤ 2 ^ fuel

                                            The positive chains of a slot of a search leaf number at most 2^fuel.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideLeafM.tOf_length_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (T : fp.SideLeafM) {fuel : ℕ} {up₀ : Fin 4} {s : ℕ} (hLf : T.Lf = leafAt fuel fp.Lc up₀ s) (l : Fin 4) (i : ℕ) :
                                            (T.tOf l i).length ≤ fuel

                                            Every positive chain of a slot of a search leaf has at most fuel steps.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideLeafM.desc_tOf_length_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (T : fp.SideLeafM) {fuel : ℕ} {up₀ : Fin 4} {s : ℕ} (hLf : T.Lf = leafAt fuel fp.Lc up₀ s) (c d : Fin 4) (i i' : ℕ) :
                                            (T.desc c d (T.tOf c i) (T.tOf d i')).length ≤ 2 * fuel + 2

                                            The merged descriptors of two positive chains of a search leaf have at most 2 fuel + 2 steps.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideLeafM.Dpre_length_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (T : fp.SideLeafM) {fuel : ℕ} {up₀ : Fin 4} {s : ℕ} (hLf : T.Lf = leafAt fuel fp.Lc up₀ s) (ω : Fin 4 × Fin 4 × ℕ × ℕ × ℕ × ℕ) :
                                            (T.Dpre ω).length ≤ 2 * fuel + 2

                                            The prefixes of the step descriptors of a search leaf have at most 2 fuel + 2 steps.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.errAt_sq_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (q : ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                            ‖(D.withQ0 q).errAt L l G I‖ ^ 2 ≤ ∫ (y : ℝ) in dyadicGridCell A.G I.1 I.2, ‖(↑↑(fp.physError (D.Ms l G) (L l G) l (D.cat l) (D.mbs l) G (D.Lf.role l) (D.Lf.layers l) D.S.K (A.blkStart D.S.K I.1)) y).ofLp none‖ ^ 2

                                            The squared norm of the physical error of a basic slot at a cell is the integral over the cell of its physical coordinate (the error is a difference of physical parts).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.errAt_energy_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (S : Finset (ℤ × ℤ)) (gs : ℤ × ℤ → Finset bf.Grp) (gset : Finset bf.Grp) (hgs : ∀ I ∈ S, gs I ⊆ gset) {E : ℝ} (hE : ∑ l : Fin 4, ∑ G ∈ gset, ∑ I ∈ S with G ∈ gs I, ∫ (y : ℝ) in dyadicGridCell A.G I.1 I.2, ‖(↑↑(fp.physError (D.Ms l G) (L l G) l (D.cat l) (D.mbs l) G (D.Lf.role l) (D.Lf.layers l) D.S.K (A.blkStart D.S.K I.1)) y).ofLp none‖ ^ 2 ≤ E) :
                                            ∑ I ∈ S, ∑ G ∈ gs I, ∑ l : Fin 4, ‖(D.withQ0 (qG G)).errAt L l G I‖ ^ 2 ≤ E

                                            Blueprint eq:physical-error on the leaf: the physical errors of the retained cells, summed over their groups and slots, are bounded by the physical errors of the actual uses of exists_leaf_modes (the uses I ∈ S with G ∈ gs I).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.multNorm_eq (d : ℕ) (δ : ℝ) (Q0 : ℕ) (Cm : ℝ) :
                                            multNorm d δ Q0 Cm = gaugeMultNorm d (↑Q0) Cm δ

                                            The full Fourier norm bound of the multiplier of the principal bins is that of gaugeMult_star.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.multTail_eq (d : ℕ) (δ : ℝ) (Q0 : ℕ) (Cm : ℝ) (K : ℕ) :
                                            multTail d δ Q0 Cm K = 2 * gaugeMultTail d (↑Q0) Cm δ / 2 ^ K

                                            The truncation error of the multiplier of the principal bins is that of gaugeMult_star.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.center_principal_bounds {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (D dB : ℕ) {H δc N : ℝ} (k : ℝ) {δ : ℝ} (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hHed : 2 ≤ fp.Hed) (hH : 1 ≤ H) (hδc : 0 < δc) (hN0 : 0 ≤ N) (hdB : 1 ≤ 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) (z : bf.Vtx) :
                                            multNorm (bf.vtag z).dim (δ / 2) (clearInt (bf.vtag z).C) fp.Hed ≤ fp.modeStarG D dB H δc N k δ ∧ multTail (bf.vtag z).dim (δ / 2) (clearInt (bf.vtag z).C) fp.Hed (fp.Kstar D dB H δc N k δ) ≤ (fp.modeStarG D dB H δc N k δ ^ 300)⁻¹ ∧ cutNorm (bf.vtag z).dim δ ≤ fp.modeStarG D dB H δc N k δ ∧ cutTail (bf.vtag z).dim δ (fp.Kstar D dB H δc N k δ) ≤ (fp.modeStarG D dB H δc N k δ ^ 300)⁻¹ ∧ (∀ (a b : Fin (bf.vtag z).dim), |↑((bf.vtag z).C a b)| ≤ fp.Hed) ∧ ∀ (a b : Fin (bf.vtag z).dim), ∃ (m : ℤ), ↑(clearInt (bf.vtag z).C) * ↑((bf.vtag z).C a b) = ↑m

                                            Blueprint lines 1942-1944 for the principal bins of a group center z: with its clearing integer Q₀ = clearInt C_z and C_m = H_ed, the full Fourier norms of the multiplier (cutoff δ/2) and of the cutoff ζ are at most the enlarged budget D_*, their truncations at K_* are within D_*^(-300), |C_{ab}| ≤ H_ed, and Q₀ C_z is integral.

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.classNode_mem_succNodes {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {G : bf.Grp} {I : ℤ × ℤ} {j : Fin 4} {h : ℕ} {F : Finset (D.Ms j G).Md} (hF : F ∈ D.goodCls G I j h) {P : Finset (ℤ × ℤ × ℤ)} (hP : (A.blkStart D.S.K I.1, D.preAt I) ∈ P) :
                                            D.classNode G I j h hF ∈ (D.Ms j G).succNodes D.S ⋯ D.SP P h

                                            The node of a successful final class at a cell is a node of the successful components of its (block, pre-cell) pair: its chosen mode is good, its class contains a good core mode (the class of a core component), and it is the good mode of least index of the class (goodRep_min).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.repOK_of_repClass {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (j : Fin 4) (h : ℕ) (Cs : Finset (ℤ × ℤ)) (R : ℕ → ℕ → (D.Ms j G).RepClass D.S ⋯ D.SP 10 h) (hsub : ∀ (k₁ k₂ : ℕ), D.typedNodes G j h Cs k₁ k₂ ⊆ (R k₁ k₂).Nd) :
                                            D.RepOK G j h Cs fun (k₁ k₂ : ℕ) => (R k₁ k₂).rep

                                            Hereditary representatives of type classes (RepClass, as built by first_top_count_main) whose nodes contain the typed class nodes of the cells Cs have the properties RepOK there: representatives in the predecessors, and different representatives on comparable nodes of one type class with predecessors in different later CURRENT components (RepClass.hsepP).

                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.helper_sides_closure {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (Dst : ℕ) (fp : bf.FamParams) (Tc : Finset (ℤ × ℤ)) (hTc : Tc ⊆ A.cells) {cS : ℕ} (hst : SameTagBound κ cS Dst) {HS τ₃ : ℝ} {Mp : ℕ} (ι : Type) [Fintype ι] (cat : Fin 4 → List (CatCol bf.Vtx)) (st : Fin 4 → ι → ℤ × ℤ → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (hside : ∀ (l : Fin 4) (G : ι) (I : ℤ × ℤ), MainFresh fp.Mc (cat l).length ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (st l G I))) {Wm : Type} (main : Wm → Fin 4 × (ℤ × ℤ) × MainTest bf.Vtx bf.Lab fp.Mc) (hmain : ∀ (i : Wm), (main i).2.2.r ≤ fp.Lc + 4 ∧ ∀ l < (main i).2.2.m, (main i).2.2.hr l ≤ fp.Lc + 4) (τm : Wm → ℝ) (hpass : ∀ (i : Wm), (main i).2.2.Pass A.G (bf.origCols (main i).1) (main i).2.1 cS HS bf.vtag (A.w (main i).2.1) (τm i) fp.mH (cat (main i).1)) (hHS : Real.exp 2 ≤ HS) (hτ : 0 < τ₃) (hMp1 : 1 ≤ Mp) {Kt : ℕ} {n : ℕ → ℝ} {Tmax : ℕ} (hKh : ∀ (I : ℤ × ℤ), Fintype.card (fp.HelperName I ι) ≤ Kt) (hn0 : 2 * A.colBudget ≤ n 0) (hgrow : ∀ (r : ℕ), (1 + (↑fp.Lc + 6) * ↑Mp * closureRatio A.famVtxBound Kt fp.mH Tmax (Real.exp (↑Dst * (1 + Real.log HS) ^ Dst)) τ₃) * n r ≤ n (r + 1)) (hcapH : closureRatio A.famVtxBound Kt fp.mH Tmax (Real.exp (↑Dst * (1 + Real.log HS) ^ Dst)) τ₃ * n (fp.Lc + 4) < ↑Tmax) (hMc : ∀ (l : Fin 4), (cat l).length + Tc.card * Tmax ≤ fp.Mc) :
                                            ∃ (hcat : Fin 4 → List (CatCol bf.Vtx)), (∀ (l : Fin 4), ∀ I ∈ Tc, ∀ (w : fp.HelperName I ι), (fp.helperOf l I (fun (G : ι) => (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (st l G I)) w).Pass A.G (bf.origCols l) I cS HS bf.vtag (A.w I) (catThreshold A.famVtxBound τ₃ n (fp.Lc + 5)) fp.mH (cat l ++ hcat l)) ∧ (∀ (i : Wm), (main i).2.2.Pass A.G (bf.origCols (main i).1) (main i).2.1 cS HS bf.vtag (A.w (main i).2.1) (τm i) fp.mH (cat (main i).1 ++ hcat (main i).1)) ∧ (∀ (l : Fin 4) (I : ℤ × ℤ) (G : ℕ × Option (Fin A.fcd0 × bf.Vtx × ℤ) × ℕ × (ℕ × ℕ) × Option (Fin A.fcd0 × bf.Vtx × ℤ)), ∀ j ≤ 4, fp.ballFilt l (cat l ++ hcat l) I G j = fp.ballFilt l (cat l) I G j) ∧ (∀ (l : Fin 4) (I : ℤ × ℤ) (m : ℕ), fp.cumFilt l (cat l ++ hcat l) I m = fp.cumFilt l (cat l) I m) ∧ (∀ (l : Fin 4), ∀ I ∈ Tc, ↑(List.filter (fun (d : CatCol bf.Vtx) => decide (d.birth = I)) (hcat l)).length ≤ n (fp.Lc + 5)) ∧ ∀ (l : Fin 4), ∀ d ∈ hcat l, d.birth ∈ Tc ∧ d.rank = fp.Lc + 5 ∧ (∃ (M : fp.MaskName d.birth), fp.maskOf d.birth M d.tag) ∧ ∃ R ∈ residueBox (bf.vtag d.tag).dim 9, ∃ (γ : ℝ), d = templateCol (bf.vtag d.tag) l R γ d.birth d.rank d.tag

                                            Blueprint lines 2167-2169 with line 1828 ("there are L + 5 ranks, so the resulting global trial cap T = n_{L+5}"), the helper catalogs of one attempt on the closure counts of its main catalogs: with the attempt's named-test bound K_t, path counts n_r (one sequence for the main ranks ≤ L + 4 and the helper rank L + 5) and trial cap T_max (exists_attempt), the helper tests of rank L + 5 on the whole side states close with helper templates such that the main tests still pass, the ball and cumulative filters are unchanged, and the helper insertions per active cell number at most n_{L+5} (helper_instantiation_main, as in helper_sides).

                                            def TrilinearHT.Auto.ActiveSetup.padDc {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (M : ℝ) (hM : 0 ≤ M) :
                                            ActiveSetup κ c₀

                                            The setup with its coefficient bound raised to at least M ≥ 0. All other data are unchanged, so the column budget is at least M when there is a label. The vertex bound D of an attempt can then be taken as large as required (blueprint line 1745: the failure bound of the colors "tends to zero as D grows").

                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For
                                              theorem TrilinearHT.Auto.ActiveSetup.le_colBudget_padDc {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {M : ℝ} (hM : 0 ≤ M) (hL : 1 ≤ Fintype.card A.L) :
                                              M ≤ (A.padDc M hM).colBudget
                                              theorem TrilinearHT.Auto.ActiveSetup.colBudget_padDc_le {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {M : ℝ} (hM : 0 ≤ M) :
                                              (A.padDc M hM).colBudget ≤ 2 + ↑(Fintype.card A.L) * (1 + A.Dc + M)
                                              theorem TrilinearHT.Auto.ActiveSetup.HasColumnRep.padDc {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {M : ℝ} (hM : 0 ≤ M) {CF : ℝ} (h : A.HasColumnRep CF) :
                                              (A.padDc M hM).HasColumnRep CF
                                              theorem TrilinearHT.Auto.ActiveSetup.SubRootProps.padDc {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {M : ℝ} (hM : 0 ≤ M) {η₀ E : ℝ} (h : A.SubRootProps η₀ E) :
                                              (A.padDc M hM).SubRootProps η₀ E
                                              theorem TrilinearHT.Auto.ActiveSetup.not_active_of_card_eq_zero {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (hL : Fintype.card A.L = 0) (δ : ℝ) (I : ℤ × ℤ) :
                                              ¬A.active δ I

                                              Without labels no cell is active.

                                              theorem TrilinearHT.Auto.ActiveSetup.attempt_param_bounds {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {Y : ℝ} (hY : 1 ≤ Y) (hH : A.H ≤ Real.exp Y) (hcb : A.colBudget ≤ Real.exp Y) :
                                              ↑A.famVtxBound ≤ Real.exp (Y + 3) ∧ ↑A.fcd0 ≤ 6000 * Y ∧ ↑A.famLc ≤ 6000 ^ 30 * Y ^ 30 + 1 ∧ 2 ^ A.famFuel ≤ 4 * ↑A.famLc ∧ Real.log (max A.H padW) ≤ Real.log padW + Y ∧ Real.log A.Hsrc ≤ Real.log (↑tagKρ ^ (2 * tagKρ) + 20) + 2 * (Real.log padW + Y)

                                              The attempt parameters of a setup whose height and column budget are at most e^Y, Y ≥ 1, are polynomial in Y: the vertex bound is at most e^{Y+3}, the colour degree d₀ at most 5000 Y, the colour count L = d₀^{30} + 1 at most 5000^{30} Y^{30} + 1, 2^{fuel} ≤ 4 L, and log H_src and log max(H, padW) are at most Y plus constants.