Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec124BinaryLocalizationVariation.LeafBound

Trilinear Hilbert transform: leaf_bound #

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.leaf_bound {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cat : Fin 4 → List (CatCol bf.Vtx)) (hT : ∀ (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) (htag : ∀ (l : Fin 4), ∀ e ∈ cat l, bf.occAvail (↑e.tag.2) e.tag.1) {I : ℤ × ℤ} (hI : I ∈ A.cells) (x : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) {τ : ℕ → ℝ} (hpass : ∀ (l : Fin 4) (w : fp.TestName I Unit), (fp.testOf l I (fun (x_1 : Unit) => x l) w).Pass A.G (bf.origCols l) I A.csrc A.Hsrc bf.vtag (A.w I) (τ (fp.testOf l I (fun (x_1 : Unit) => x l) w).r) fp.mH (cat l)) (hsucc : ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)) {fuel : ℕ} {up₀ : Fin 4} (hL1 : 1 ≤ fp.Lc) (hfuel : fp.Lc - 1 < 2 ^ fuel) (hmH : fuel ≤ fp.mH) {s : ℕ} (hs : s < (searchList fuel fp.Lc up₀).length) {τo τm τr τ₂ Sz Nt : ℝ} (hτo : 0 ≤ τo) (hτm : 0 ≤ τm) (hτr : 0 ≤ τr) (hτ₂ : 0 < τ₂) (hτ₂1 : τ₂ ≤ 1) (hHed : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log τ₂⁻¹) ^ A.Dg) ≤ fp.Hed) (hτo' : τ (fp.crank ((leafAt fuel fp.Lc up₀ s).k - 1)) ≤ τo) (hτm' : τ (fp.Lc + 1) ≤ τm) (hτr' : ∀ (j : ℕ), 2 ≤ j → j ≤ 4 → τ (fp.Lc + j) ≤ τr) (hSz0 : 0 < Sz) (hSz : ∀ (l : Fin 4), ‖x l‖ / √(dyadicGridLength A.G I.1) ≤ Sz) (d : bf.Vtx) {ι : Type} (S : Finset ι) (a : ι → ℂ) (φ : ι → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (hx : fp.inputL cat I x (leafAt fuel fp.Lc up₀ s).layers (leafAt fuel fp.Lc up₀ s).up = ∑ v ∈ S, a v • φ v) (hsrc : ∀ v ∈ S, ∃ (y : bf.Vtx), ∃ hpad ≤ fp.cbase (leafAt fuel fp.Lc up₀ s).k + fp.P + 1, y ∈ fp.K.cumMask bf.admT A.famVtxBound (leafAt fuel fp.Lc up₀ s).k hpad (bf.admAt I) ∧ ∃ (Ay : QuadraticChartData (bf.vtag y).dim), QuadraticChartComplexity A.csrc A.Hsrc Ay ∧ IsBoundedQuadraticChart Ay ∧ Ay.horizontal = (bf.vtag y).θ ∧ Ay.matrix = ↑(slotCoeff (leafAt fuel fp.Lc up₀ s).up) • (bf.vtag y).C ∧ Ay.quadratic = ↑(slotCoeff (leafAt fuel fp.Lc up₀ s).up) * (bf.vtag y).lam ∧ ∀ᵐ (z : ℝ), z ∈ dyadicGridCell A.G I.1 I.2 → augPhys (φ v) z = quadraticChartAtom Ay z) (hNt : ∀ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, ↑(mainLabelsM A.G fp.Mc (bf.origCols (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) (cat (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) I (fp.Lc + 1) (fun (y : bf.Vtx) => ∃ (p : Fin fp.P), fp.bmask I G 1 (↑p + 1) y) d).card ≤ Nt) :
‖(cellForm ⋯ ⋯ (bf.Lab ⊕ Fin fp.Mc)) (fp.inputL cat I x (leafAt fuel fp.Lc up₀ s).layers) - ∑ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, (cellForm ⋯ ⋯ (bf.Lab ⊕ Fin fp.Mc)) fun (l : Fin 4) => (fp.ballFilt l (cat l) I G ((leafAt fuel fp.Lc up₀ s).role l)) (fp.inputL cat I x (leafAt fuel fp.Lc up₀ s).layers l)‖ ≤ (∑ v ∈ S, ‖a v‖) * ((↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card + 1) * (τo * Sz * Sz * Sz) + τm * Sz * Sz * Sz + ↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card * (τ₂ * Sz * Sz * (A.colBudget * √Nt * Sz))) + ↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card * (3 * (A.colBudget * √Nt * Sz * (τr * Sz * Sz * Sz)))

Blueprint prop:localize at one active cell and one leaf (lines 1848-1853) on the main columns: given an expansion of the upper guard input in pure bounded charts of vertices of its cumulative mask, the form of the leaf inputs is the sum over the current groups of the forms of their ball outputs, up to the old-source (τ_o), matching (τ_m), separation (τ₂) and residual (τ_r) errors; the first ball outputs expand with coefficient sums at most colBudget √N_t S.

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.leaf_main {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cat : Fin 4 → List (CatCol bf.Vtx)) (hT : ∀ (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) (htag : ∀ (l : Fin 4), ∀ e ∈ cat l, bf.occAvail (↑e.tag.2) e.tag.1) {I : ℤ × ℤ} (hI : I ∈ A.cells) (x : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) {τ : ℕ → ℝ} (hpass : ∀ (l : Fin 4) (w : fp.TestName I Unit), (fp.testOf l I (fun (x_1 : Unit) => x l) w).Pass A.G (bf.origCols l) I A.csrc A.Hsrc bf.vtag (A.w I) (τ (fp.testOf l I (fun (x_1 : Unit) => x l) w).r) fp.mH (cat l)) (hsucc : ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)) (hLcol : ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.color bf.admT A.famVtxBound (bf.admAt I) w ≤ fp.Lc) {fuel : ℕ} {up₀ : Fin 4} (hbasic : ∃ (cb : bf.Lab → ℂ), x up₀ = ∑ v : bf.Lab with (bf.origCols up₀).avail I v, cb v • mainCol A.G fp.Mc (bf.origCols up₀) (cat up₀) I (Sum.inl v)) (hL1 : 1 ≤ fp.Lc) (hfuel : fp.Lc - 1 < 2 ^ fuel) (hmH : fuel ≤ fp.mH) {s : ℕ} (hs : s < (searchList fuel fp.Lc up₀).length) {τo τm τr τ₂ Sz Nt Nu : ℝ} (hτo : 0 ≤ τo) (hτm : 0 ≤ τm) (hτr : 0 ≤ τr) (hτ₂ : 0 < τ₂) (hτ₂1 : τ₂ ≤ 1) (hHed : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log τ₂⁻¹) ^ A.Dg) ≤ fp.Hed) (hτo' : τ (fp.crank ((leafAt fuel fp.Lc up₀ s).k - 1)) ≤ τo) (hτm' : τ (fp.Lc + 1) ≤ τm) (hτr' : ∀ (j : ℕ), 2 ≤ j → j ≤ 4 → τ (fp.Lc + j) ≤ τr) (hSz0 : 0 < Sz) (hSz : ∀ (l : Fin 4), ‖x l‖ / √(dyadicGridLength A.G I.1) ≤ Sz) (d : bf.Vtx) (hNu : ↑(mainLabelsM A.G fp.Mc (bf.origCols (leafAt fuel fp.Lc up₀ s).up) (cat (leafAt fuel fp.Lc up₀ s).up) I (fp.crank (leafAt fuel fp.Lc up₀ s).k) (fun (y : bf.Vtx) => ∃ (p : Fin fp.P), fp.cmask I (leafAt fuel fp.Lc up₀ s).k (↑p + 1) y) d).card ≤ Nu) (hNt : ∀ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, ↑(mainLabelsM A.G fp.Mc (bf.origCols (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) (cat (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) I (fp.Lc + 1) (fun (y : bf.Vtx) => ∃ (p : Fin fp.P), fp.bmask I G 1 (↑p + 1) y) d).card ≤ Nt) :
‖(cellForm ⋯ ⋯ (bf.Lab ⊕ Fin fp.Mc)) (fp.inputL cat I x (leafAt fuel fp.Lc up₀ s).layers) - ∑ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, (cellForm ⋯ ⋯ (bf.Lab ⊕ Fin fp.Mc)) fun (l : Fin 4) => (fp.ballFilt l (cat l) I G ((leafAt fuel fp.Lc up₀ s).role l)) (fp.inputL cat I x (leafAt fuel fp.Lc up₀ s).layers l)‖ ≤ A.colBudget * (√Nu + √(2 * A.colBudget)) * Sz * ((↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card + 1) * (τo * Sz * Sz * Sz) + τm * Sz * Sz * Sz + ↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card * (τ₂ * Sz * Sz * (A.colBudget * √Nt * Sz))) + ↑(fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k).card * (3 * (A.colBudget * √Nt * Sz * (τr * Sz * Sz * Sz)))

Blueprint prop:localize at one active cell and one leaf (lines 1848-1853), with the expansion of the upper guard (line 1850: "expand only this outer primal"): a cumulative main filter (coefficient sum at most colBudget √N_u S over its N_u main labels, blueprint line 1835) or the basic slot, whose input is a combination of its available original columns (coefficient sum at most colBudget √(2 colBudget) S).

noncomputable def TrilinearHT.Auto.ActiveSetup.leafErrM {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) (Sz Nu Nt τo τm τr τ₂ : ℝ) :

The error of one leaf of leaf_main with at most D current groups.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Λc {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (I : ℤ × ℤ) :
    MultilinearMap ℂ (fun (x : Fin 4) => ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) ℂ

    The cell form of an attempt on the main columns (zero off the active cells).

    Equations
    Instances For
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Λc_of_mem {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {I : ℤ × ℤ} (h : I ∈ A.cells) :
      fp.Λc I = cellForm ⋯ ⋯ (bf.Lab ⊕ Fin fp.Mc)
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Λc_apply {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {I : ℤ × ℤ} (h : I ∈ A.cells) (z : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
      (fp.Λc I) z = localProgressionForm (dyadicGridLength A.G I.1) (A.w I) fun (l : Fin 4) => augPhys (z l)

      On an active cell the cell form is the local form of the physical parts (blueprint line 1841: H_I(Z_0, Z_1, Z_2, Z_3)).

      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.localized_sum {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (cat : Fin 4 → List (CatCol bf.Vtx)) (hT : ∀ (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) (htag : ∀ (l : Fin 4), ∀ e ∈ cat l, bf.occAvail (↑e.tag.2) e.tag.1) (cs : Finset (ℤ × ℤ)) (hcs : cs ⊆ A.cells) (x : ℤ × ℤ → Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) {τ : ℕ → ℝ} (hpass : ∀ I ∈ cs, ∀ (l : Fin 4) (w : fp.TestName I Unit), (fp.testOf l I (fun (x_1 : Unit) => x I l) w).Pass A.G (bf.origCols l) I A.csrc A.Hsrc bf.vtag (A.w I) (τ (fp.testOf l I (fun (x_1 : Unit) => x I l) w).r) fp.mH (cat l)) (hsucc : ∀ I ∈ cs, ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)) (hLcol : ∀ I ∈ cs, ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.color bf.admT A.famVtxBound (bf.admAt I) w ≤ fp.Lc) {fuel : ℕ} {up₀ : Fin 4} (hbasic : ∀ I ∈ cs, ∃ (cb : bf.Lab → ℂ), x I up₀ = ∑ v : bf.Lab with (bf.origCols up₀).avail I v, cb v • mainCol A.G fp.Mc (bf.origCols up₀) (cat up₀) I (Sum.inl v)) (hL1 : 1 ≤ fp.Lc) (hfuel : fp.Lc - 1 < 2 ^ fuel) (hmH : fuel ≤ fp.mH) {τo Nu : ℕ → ℝ} {τm τr τ₂ Sz Nt η : ℝ} (hη : 0 ≤ η) (hτo : ∀ (k : ℕ), 0 ≤ τo k) (hτm : 0 ≤ τm) (hτr : 0 ≤ τr) (hτ₂ : 0 < τ₂) (hτ₂1 : τ₂ ≤ 1) (hHed : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log τ₂⁻¹) ^ A.Dg) ≤ fp.Hed) (hτo' : ∀ (k : ℕ), 1 ≤ k → k ≤ fp.Lc → τ (fp.crank (k - 1)) ≤ τo k) (hτm' : τ (fp.Lc + 1) ≤ τm) (hτr' : ∀ (j : ℕ), 2 ≤ j → j ≤ 4 → τ (fp.Lc + j) ≤ τr) (hSz0 : 0 < Sz) (hSz : ∀ I ∈ cs, ∀ (l : Fin 4), ‖x I l‖ / √(dyadicGridLength A.G I.1) ≤ Sz) (d : bf.Vtx) (hNu : ∀ I ∈ cs, ∀ s < (searchList fuel fp.Lc up₀).length, ↑(mainLabelsM A.G fp.Mc (bf.origCols (leafAt fuel fp.Lc up₀ s).up) (cat (leafAt fuel fp.Lc up₀ s).up) I (fp.crank (leafAt fuel fp.Lc up₀ s).k) (fun (y : bf.Vtx) => ∃ (p : Fin fp.P), fp.cmask I (leafAt fuel fp.Lc up₀ s).k (↑p + 1) y) d).card ≤ Nu (leafAt fuel fp.Lc up₀ s).k) (hNt : ∀ I ∈ cs, ∀ s < (searchList fuel fp.Lc up₀).length, ∀ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, ↑(mainLabelsM A.G fp.Mc (bf.origCols (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) (cat (thirdSlot (leafAt fuel fp.Lc up₀ s).up (leafAt fuel fp.Lc up₀ s).low)) I (fp.Lc + 1) (fun (y : bf.Vtx) => ∃ (p : Fin fp.P), fp.bmask I G 1 (↑p + 1) y) d).card ≤ Nt) :
      ∑ I ∈ cs, dyadicGridLength A.G I.1 * min η ‖(fp.Λc I) (x I)‖ ≤ ∑ s ∈ Finset.range (searchList fuel fp.Lc up₀).length, ∑ I ∈ cs, dyadicGridLength A.G I.1 * min η ‖∑ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, (fp.Λc I) fun (l : Fin 4) => (fp.ballFilt l (cat l) I G ((leafAt fuel fp.Lc up₀ s).role l)) (fp.inputL cat I (x I) (leafAt fuel fp.Lc up₀ s).layers l)‖ + ∑ I ∈ cs, dyadicGridLength A.G I.1 * ∑ s ∈ Finset.range (searchList fuel fp.Lc up₀).length, A.leafErrM Sz (Nu (leafAt fuel fp.Lc up₀ s).k) Nt (τo (leafAt fuel fp.Lc up₀ s).k) τm τr τ₂

      Blueprint prop:localize (lines 1838-1856) for an attempt on the main columns, summed over a set of active cells without failed vertices: the weighted cell minima of the forms of the slot inputs are at most the weighted minima, over the leaves of the guarded color search, of the sums over the current groups of the forms of their ball outputs Z_{l,G,s} = L_{l,G,s} B_{l,s} z_l, plus the weighted leaf errors (the cell minimum distributes over the leaves by eq:min-subadd).

      The localized sum of an attempt on the main columns (blueprint prop:localize, line 1854) #

      theorem TrilinearHT.Auto.leafErr_core {Cs D a b c cc τ₃ Sz ColSum : ℝ} (hCs : 0 < Cs) (hCD : Cs ≤ D) (ha : 0 < a) (hab : a ≤ b) (hbc : b ≤ c) (hcc : cc = c ^ 2) (hτ₃ : 0 < τ₃) (hSz : 0 < Sz) (hCol : ColSum ≤ 2 * Cs * a * Sz) :
      ColSum * ((D + 1) * (τ₃ / (D * a) * Sz * Sz * Sz) + τ₃ / (D * b) * Sz * Sz * Sz + D * (τ₃ / (D ^ 2 * cc) * Sz * Sz * (Cs * c * Sz))) + D * (3 * (Cs * c * Sz * (τ₃ / (D * c) * Sz * Sz * Sz))) ≤ 9 * (D + 1) * τ₃ * Sz ^ 4

      The arithmetic of the leaf error (blueprint line 1854): with the coefficient sum of the upper guard at most 2 C a S, the thresholds τ₃ / (D a), τ₃ / (D b), τ₃ / (D c) of eq:catalog-test for path counts a² ≤ b² ≤ c², the pair threshold τ₂ = τ₃ / (D² c²) and C ≤ D, each expansion cost is canceled and the leaf error is at most 9 (D + 1) τ₃ S⁴.

      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.leafErrM_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {τ₃ Sz : ℝ} (hτ₃ : 0 < τ₃) (hSz0 : 0 < Sz) {n : ℕ → ℝ} (hn0 : 2 * A.colBudget ≤ n 0) (hmono : Monotone n) {k : ℕ} (hk1 : 1 ≤ k) (hkL : k ≤ fp.Lc) :
      A.leafErrM Sz (n (fp.crank k)) (n (fp.Lc + 1)) (catThreshold A.famVtxBound τ₃ n (fp.crank (k - 1))) (catThreshold A.famVtxBound τ₃ n (fp.Lc + 1)) (catThreshold A.famVtxBound τ₃ n (fp.Lc + 2)) (τ₃ / (↑A.famVtxBound ^ 2 * n (fp.Lc + 1))) ≤ 9 * (↑A.famVtxBound + 1) * τ₃ * Sz ^ 4

      The leaf error with the thresholds of eq:catalog-test at the path counts n and the pair threshold τ₂ = τ₃ / (D² n_{L+1}) is at most 9 (D + 1) τ₃ S⁴ (blueprint line 1854).

      theorem TrilinearHT.Auto.mainCol_inl_indep {V : Type} [Fintype V] {Tg : Type u_1} (G : RealDyadicGrid) (Mc : ℕ) (O : OrigCols V Tg) (s s' : List (CatCol Tg)) (I : ℤ × ℤ) (v : V) :
      mainCol G Mc O s I (Sum.inl v) = mainCol G Mc O s' I (Sum.inl v)

      The original main columns do not depend on the catalog.

      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.attempt_localization {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (Tc : Finset (ℤ × ℤ)) (hTc : Tc ⊆ A.cells) {Dst : ℕ} (hst : SameTagBound κ A.csrc Dst) (x : ℤ × ℤ → Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (hxb : ∀ (l : Fin 4), ∀ I ∈ Tc, MainFresh fp.Mc 0 (x I l) ∧ ∀ᵐ (y : ℝ), y ∉ dyadicGridCell A.G I.1 I.2 → ↑↑(x I l) y = 0) {Kt : ℕ} (hKt : ∀ (I : ℤ × ℤ), Fintype.card (fp.TestName I Unit) ≤ Kt) {Mp : ℕ} (hMp : 1 ≤ Mp) {τ₃ : ℝ} (hτ₃ : 0 < τ₃) (hτ₃1 : τ₃ ≤ 1) {Tmax : ℕ} (n : ℕ → ℝ) (hn0 : 2 * A.colBudget ≤ n 0) (hratio : ∀ (r : ℕ), (1 + (↑fp.Lc + 6) * ↑Mp * closureRatio A.famVtxBound Kt fp.mH Tmax (Real.exp (↑Dst * (1 + Real.log A.Hsrc) ^ Dst)) τ₃) * n r ≤ n (r + 1)) (hT : n (fp.Lc + 5) ≤ ↑Tmax) (hMc : Tc.card * Tmax ≤ fp.Mc) {fuel : ℕ} {up₀ : Fin 4} (hL1 : 1 ≤ fp.Lc) (hfuel : fp.Lc - 1 < 2 ^ fuel) (hmH : fuel ≤ fp.mH) (hHed : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log (τ₃ / (↑A.famVtxBound ^ 2 * n (fp.Lc + 1)))⁻¹) ^ A.Dg) ≤ fp.Hed) (d : bf.Vtx) :
      ∃ (cat : Fin 4 → List (CatCol bf.Vtx)), (∀ (l : Fin 4), (∀ I ∈ Tc, ∀ (w : fp.TestName I Unit), (fp.testOf l I (fun (x_1 : Unit) => x I l) w).Pass A.G (bf.origCols l) I A.csrc A.Hsrc bf.vtag (A.w I) (catThreshold A.famVtxBound τ₃ n (fp.testOf l I (fun (x_1 : Unit) => x I l) w).r) fp.mH (cat l)) ∧ (∀ e ∈ cat l, e.birth ∈ Tc ∧ e.rank ≤ fp.Lc + 5 ∧ ∃ R ∈ residueBox (bf.vtag e.tag).dim 9, ∃ (γ : ℝ), e = templateCol (bf.vtag e.tag) l R γ e.birth e.rank e.tag) ∧ (∀ e ∈ cat l, bf.occAvail (↑e.tag.2) e.tag.1) ∧ (∀ (I : ℤ × ℤ), {I' ∈ Tc | dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I'.1 I'.2}.card ≤ Mp → ∀ r ≤ fp.Lc + 5, ↑(mainLabels A.G fp.Mc (bf.origCols l) (cat l) I r).card ≤ n r) ∧ (cat l).length ≤ Tc.card * Tmax) ∧ ∀ cs ⊆ Tc, (∀ I ∈ cs, {I' ∈ Tc | dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G I'.1 I'.2}.card ≤ Mp) → (∀ I ∈ cs, ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.Success (fp.K.colorData (bf.admT.st (bf.admAt I)) w)) → (∀ I ∈ cs, ∀ w ∈ bf.admT.X (bf.admAt I), fp.K.color bf.admT A.famVtxBound (bf.admAt I) w ≤ fp.Lc) → (∀ I ∈ cs, ∃ (cb : bf.Lab → ℂ), x I up₀ = ∑ v : bf.Lab with (bf.origCols up₀).avail I v, cb v • mainCol A.G fp.Mc (bf.origCols up₀) [] I (Sum.inl v)) → ∀ {Sz η : ℝ}, 0 ≤ η → 0 < Sz → (∀ I ∈ cs, ∀ (l : Fin 4), ‖x I l‖ / √(dyadicGridLength A.G I.1) ≤ Sz) → ∑ I ∈ cs, dyadicGridLength A.G I.1 * min η ‖(fp.Λc I) (x I)‖ ≤ ∑ s ∈ Finset.range (searchList fuel fp.Lc up₀).length, ∑ I ∈ cs, dyadicGridLength A.G I.1 * min η ‖∑ G ∈ fp.groupsAt I (leafAt fuel fp.Lc up₀ s).k, (fp.Λc I) fun (l : Fin 4) => (fp.ballFilt l (cat l) I G ((leafAt fuel fp.Lc up₀ s).role l)) (fp.inputL cat I (x I) (leafAt fuel fp.Lc up₀ s).layers l)‖ + (∑ I ∈ cs, dyadicGridLength A.G I.1) * (↑(searchList fuel fp.Lc up₀).length * (9 * (↑A.famVtxBound + 1) * τ₃ * Sz ^ 4))

      Blueprint prop:localize (lines 1838-1856) for an attempt on the main columns. For slot inputs z_l that are augmented vectors supported on the active cells without template coordinates, the catalog closure (lem:closure) at the thresholds τ₃ / (D √n_{r-1}) of eq:catalog-test gives slot catalogs of same-tag templates passing all named tests, and then, on every set of active cells of path multiplicity at most M_p without failed vertices whose colors are at most L and whose basic guard slot input is a combination of its original columns, with local input sizes at most S: the weighted cell minima of the forms of the slot inputs are at most the sum over the leaves of the guarded color search of the weighted minima of the current-group sums Σ_G H_I(Z_{0,G,s}, …, Z_{3,G,s}), Z_{l,G,s} = L_{l,G,s} B_{l,s} z_l (one positive smeared ball filter after a shared product of cumulative filters or complements), plus Σ|I| · #leaves · 9 (D + 1) τ₃ S⁴. The pair threshold is τ₂ = τ₃ / (D² n_{L+1}), chosen after the main count (line 1854), and H_ed is large for it (lem:graph). The catalogs also satisfy the closure counts of lem:closure (ranks at most L + 5, at most n_r main labels of rank at most r at cells in at most M_p active cells, length at most #cells · T), which give the main budget of line 1859.

      Basic-slot histories on the main columns (blueprint line 1859) #

      Generic compression and locality lemmas (moved from Sec13_3) #

      theorem TrilinearHT.Auto.starProjection_restrict_eq {V : Type u_1} [Fintype V] (K : Submodule ℂ ↥(ColumnL2 V)) [K.HasOrthogonalProjection] (s : Set ℝ) (hs : MeasurableSet s) (hK : ∀ v ∈ K, (columnL2Restriction s hs) v = v) (w : ↥(ColumnL2 V)) :

      A projection onto vectors fixed by a self-adjoint restriction ignores the restriction.

      theorem TrilinearHT.Auto.span_vanish_restrict {V : Type u_1} [Fintype V] {J s : Set ℝ} (hJs : J ⊆ s) (hs : MeasurableSet s) (S : Set ↥(ColumnL2 V)) (hS : ∀ v ∈ S, ∀ᵐ (y : ℝ), y ∉ J → ↑↑v y = 0) (v : ↥(ColumnL2 V)) :

      The span of column functions vanishing off J is fixed by the restriction to J ⊆ s.

      theorem TrilinearHT.Auto.opAvg_commute {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] {P : ℕ} (Q : Fin P → E →L[ℂ] E) (r : E →L[ℂ] E) (h : ∀ (p : Fin P), Q p ∘SL r = r ∘SL Q p) :
      theorem TrilinearHT.Auto.layerOp_commute {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] (Cum : ℕ → E →L[ℂ] E) (r : E →L[ℂ] E) (h : ∀ (m : ℕ), Cum m ∘SL r = r ∘SL Cum m) (ls : List (ℕ × Bool)) :
      layerOp Cum ls ∘SL r = r ∘SL layerOp Cum ls

      Compression of the outer main ball projection (blueprint lines 2068-2070) #

      @[reducible, inline]
      noncomputable abbrev TrilinearHT.Auto.compression1 {V : Type u_1} [Fintype V] (D : ColumnTreeData V) :

      The one-factor compression constant of columnSpatialCompression.

      Equations
      Instances For
        theorem TrilinearHT.Auto.rows_projection_compression {V : Type u_1} {κ : Type u_2} {F : Type u_3} [Fintype V] [NormedAddCommGroup F] [NormedSpace ℂ F] (D : ColumnTreeData V) (A : InheritedColumnMask D) (s : Finset κ) (u : κ → ℤ × ℤ) (hu : ∀ (k : κ), u k ∈ D.cells) (Q : κ → ↥(ColumnL2 V) →L[ℂ] F) {c : ℝ} (hc : 0 ≤ c) (hQ : ∀ (x : ↥(ColumnL2 V)), ∑ k ∈ s, ‖(Q k) x‖ ^ 2 ≤ c * ‖x‖ ^ 2) (hloc : ∀ k ∈ s, Q k ∘SL columnL2Restriction (dyadicGridCell D.grid (u k).1 (u k).2) ⋯ = Q k) (z : ↥(ColumnL2 V)) :
        ∑ k ∈ s, ‖(Q k) ((cellColumnProjection D A ⋯) z)‖ ^ 2 ≤ c * compression1 D ^ 2 * ‖z‖ ^ 2

        Blueprint lines 2068-2070 (lem:compression with one factor): rows Q_k local to decision cells u_k and Bessel with constant c remain Bessel after inserting the inherited projection at their decision cells, with constant c · C₁².

        theorem TrilinearHT.Auto.rows_opAvg_le {H : Type u_1} {F : Type u_2} {κ : Type u_3} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [NormedAddCommGroup F] [NormedSpace ℂ F] {P : ℕ} (hP : 0 < P) (s : Finset κ) (T : κ → Fin P → H →L[ℂ] H) (Q : κ → H →L[ℂ] F) (z : H) {B : ℝ} (hB : ∀ (p : Fin P), ∑ k ∈ s, ‖(Q k) ((T k p) z)‖ ^ 2 ≤ B) :
        ∑ k ∈ s, ‖(Q k) ((opAvg (T k)) z)‖ ^ 2 ≤ B

        The row-space triangle inequality for averages (blueprint line 2069, "restore its average"): a row bound for each averaged operator persists for the average.

        Averaged cumulative layers as averages of complement products (lines 2072-2074) #

        noncomputable def TrilinearHT.Auto.layerFactor {H : Type u_1} [NormedAddCommGroup H] [InnerProductSpace ℂ H] {P : ℕ} (Pf : ℕ → Fin P → H →L[ℂ] H) (ls : List (ℕ × Bool)) (ω : Fin ls.length → Fin P) (l : ℕ) :

        The factors of the expanded layer product for a pad tuple ω.

        Equations
        Instances For

          The complement pattern of a layer list.

          Equations
          Instances For
            theorem TrilinearHT.Auto.layerOp_opAvg_expand {H : Type u_1} [NormedAddCommGroup H] [InnerProductSpace ℂ H] {P : ℕ} (hP : 0 < P) (Pf : ℕ → Fin P → H →L[ℂ] H) (ls : List (ℕ × Bool)) (x : H) :
            (layerOp (fun (m : ℕ) => opAvg (Pf m)) ls) x = (↑P ^ ls.length)⁻¹ • ∑ ω : Fin ls.length → Fin P, (operatorComplementProduct (layerFactor Pf ls ω) (layerPattern ls) ls.length) x

            Blueprint lines 2072-2074 ("expand complements ... retain averages as averages"): a layer product of pad averages is the uniform average over pad tuples of complement products.

            Compression of averaged cumulative histories (blueprint lines 2072-2075) #

            noncomputable def TrilinearHT.Auto.compressionC {V : Type u_1} [Fintype V] (D : ColumnTreeData V) (n : ℕ) :

            The complement-compression constant of columnSpatialCompression_complements for n factors.

            Equations
            Instances For
              theorem TrilinearHT.Auto.rows_uniformAvg_le {H : Type u_1} {F : Type u_2} {ι : Type u_3} {Ω : Type u_4} [NormedAddCommGroup H] [NormedAddCommGroup F] [NormedSpace ℂ H] [NormedSpace ℂ F] [Fintype ι] [Fintype Ω] [Nonempty Ω] (R : ι → H →L[ℂ] F) (X : ι → Ω → H) {B : ℝ} (hB : ∀ (ω : Ω), ∑ i : ι, ‖(R i) (X i ω)‖ ^ 2 ≤ B) :
              ∑ i : ι, ‖(R i) ((↑(Fintype.card Ω))⁻¹ • ∑ ω : Ω, X i ω)‖ ^ 2 ≤ B

              Rows bounded for each member of a uniform average over a finite set remain bounded for the average.

              theorem TrilinearHT.Auto.rows_layer_compression {V : Type u_1} {F : Type u_2} {ι : Type u_3} [Fintype V] [NormedAddCommGroup F] [NormedSpace ℂ F] [Fintype ι] (D : ColumnTreeData V) (ls : List (ℕ × Bool)) {P : ℕ} (hP : 0 < P) (A : ℕ → Fin P → InheritedColumnMask D) (u : ι → ℤ × ℤ) (hu : ∀ (i : ι), u i ∈ D.cells) (Pf : ι → ℕ → Fin P → ↥(ColumnL2 V) →L[ℂ] ↥(ColumnL2 V)) (hPf : ∀ (i : ι) (m : ℕ) (p : Fin P), Pf i m p = cellColumnProjection D (A m p) ⋯) (R : ι → ↥(ColumnL2 V) →L[ℂ] F) {B : ℝ} (hB : 0 ≤ B) (hR : ∀ (x : ↥(ColumnL2 V)), ∑ i : ι, ‖(R i) x‖ ^ 2 ≤ B * ‖x‖ ^ 2) (hloc : ∀ (i : ι), R i ∘SL columnL2Restriction (dyadicGridCell D.grid (u i).1 (u i).2) ⋯ = R i) (z : ↥(ColumnL2 V)) :
              ∑ i : ι, ‖(R i) ((layerOp (fun (m : ℕ) => opAvg (Pf i m)) ls) z)‖ ^ 2 ≤ B * compressionC D ls.length ^ 2 * ‖z‖ ^ 2

              Blueprint lines 2072-2075 (lem:compression with complements and averages): rows local to their decision cells and Bessel with constant B remain Bessel after inserting the averaged cumulative layers at their decision cells, at the complement-compression cost.

              On a cell of the depth-h partition, the depth projection is the cell projection, on both sides.

              theorem TrilinearHT.Auto.layerOp_intertwine {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] (C C' : ℕ → E →L[ℂ] E) (r : E →L[ℂ] E) (h : ∀ (m : ℕ), r ∘SL C m = C' m ∘SL r) (ls : List (ℕ × Bool)) :
              r ∘SL layerOp C ls = layerOp C' ls ∘SL r
              theorem TrilinearHT.Auto.opAvg_intertwine {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] {P : ℕ} (Q Q' : Fin P → E →L[ℂ] E) (r : E →L[ℂ] E) (h : ∀ (p : Fin P), r ∘SL Q p = Q' p ∘SL r) :
              theorem TrilinearHT.Auto.globHist_compression {V : Type u_1} {F : Type u_2} [Fintype V] [NormedAddCommGroup F] [NormedSpace ℂ F] {ι : Type u_3} [Fintype ι] (Ψ : ColumnDepthFamily V) {P : ℕ} (hP : 0 < P) (Am : ℕ → Fin P → InheritedColumnMask Ψ.D) (ls : List (ℕ × Bool)) (d : ι → ℤ) (R : ι → ↥(ColumnL2 V) →L[ℂ] F) {B : ℝ} (hB : 0 ≤ B) (hR : ∀ (x : ↥(ColumnL2 V)), ∑ i : ι, ‖(R i) x‖ ^ 2 ≤ B * ‖x‖ ^ 2) (hblk : ∀ (i : ι) (x : ↥(ColumnL2 V)), ‖(R i) x‖ ^ 2 = ∑ Q : ↥(Ψ.partition (d i)).cells, ‖(R i) ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2) (z : ↥(ColumnL2 V)) :
              ∑ i : ι, ‖(R i) ((globHist Ψ Am ls (d i)) z)‖ ^ 2 ≤ B * compressionC Ψ.D ls.length ^ 2 * ‖z‖ ^ 2

              Blueprint lines 1879-1890 (compression for global histories): rows that split orthogonally over the cells of their depth partition and are Bessel with constant B remain Bessel after inserting the global averaged histories of their depths, at the complement-compression cost.

              Relabeling of column spaces (blueprint line 1859: histories acting on F_l) #

              noncomputable def TrilinearHT.Auto.relabelCLM {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) :

              The pointwise relabeling of augmented vectors along an injection of labels: the physical coordinate is kept and the private coordinate of v is moved to f v.

              Equations
              Instances For
                theorem TrilinearHT.Auto.relabelCLM_apply {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) (z : ColumnHilbert V) :
                theorem TrilinearHT.Auto.norm_relabelCLM {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} (hf : Function.Injective f) (z : ColumnHilbert V) :
                noncomputable def TrilinearHT.Auto.colRelabel {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) :

                The relabeling of column inputs along an injection of labels.

                Equations
                Instances For
                  theorem TrilinearHT.Auto.colRelabel_coeFn {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) (z : ↥(ColumnL2 V)) :
                  ↑↑((colRelabel f) z) =ᵐ[MeasureTheory.volume] fun (y : ℝ) => (relabelCLM f) (↑↑z y)
                  theorem TrilinearHT.Auto.norm_colRelabel {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} (hf : Function.Injective f) (z : ↥(ColumnL2 V)) :
                  noncomputable def TrilinearHT.Auto.colRelabelLI {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} (hf : Function.Injective f) :

                  The relabeling as a linear isometry.

                  Equations
                  Instances For

                    An isometric embedding transports orthogonal projections onto finite-dimensional subspaces: the projection onto the image of K of the image of x is the image of the projection of x.

                    theorem TrilinearHT.Auto.relabelCLM_privateColumnValue {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} {φ : V → ℝ → ℂ} {ε : V → ℝ} {φ' : W → ℝ → ℂ} {ε' : W → ℝ} {v : V} (hφ : φ' (f v) = φ v) (hε : ε' (f v) = ε v) (y : ℝ) :
                    (relabelCLM f) (privateColumnValue φ ε v y) = privateColumnValue φ' ε' (f v) y

                    Relabeling a private column value moves its private coordinate.

                    theorem TrilinearHT.Auto.colRelabel_wColumn {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} {s : Set ℝ} {φ : V → ℝ → ℂ} {ε : V → ℝ} {φ' : W → ℝ → ℂ} {ε' : W → ℝ} {v : V} (hφ : φ' (f v) = φ v) (hε : ε' (f v) = ε v) (hmem : MeasureTheory.MemLp (s.indicator (privateColumnValue φ ε v)) 2 MeasureTheory.volume) (hmem' : MeasureTheory.MemLp (s.indicator (privateColumnValue φ' ε' (f v))) 2 MeasureTheory.volume) :
                    (colRelabel f) (wColumn s φ ε v) = wColumn s φ' ε' (f v)

                    Relabeling a weighted column gives the weighted column of the image label.

                    theorem TrilinearHT.Auto.cellColumnLp_eq_wColumn {V : Type u_1} [Fintype V] (D : ColumnTreeData V) (A : InheritedColumnMask D) {c : ℤ × ℤ} (hc : c ∈ D.cells) (v : ↥(A.labels c)) :

                    A cell column of a column tree is a weighted column.

                    theorem TrilinearHT.Auto.cellColumnRange_map_relabel {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (D : ColumnTreeData V) (A : InheritedColumnMask D) {c : ℤ × ℤ} (hc : c ∈ D.cells) {f : V → W} {φ' : W → ℝ → ℂ} {ε' : W → ℝ} (hφ : ∀ (v : V), φ' (f v) = D.scalar v) (hε : ∀ (v : V), ε' (f v) = D.privateWeight v) (hmem' : ∀ v ∈ A.labels c, MeasureTheory.MemLp ((dyadicGridCell D.grid c.1 c.2).indicator (privateColumnValue φ' ε' (f v))) 2 MeasureTheory.volume) :
                    Submodule.map (↑(colRelabel f)) (cellColumnRange D A hc) = Submodule.span ℂ ((fun (v : ↥(A.labels c)) => wColumn (dyadicGridCell D.grid c.1 c.2) φ' ε' (f ↑v)) '' Set.univ)

                    The image of a cell range of a column tree under a relabeling is the span of the relabeled weighted columns.

                    The main column tree of an attempt (blueprint lines 1805, 1859) #

                    def TrilinearHT.Auto.ActiveSetup.BasicFamilies.Relevant {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) :
                    bf.Lab ⊕ Fin Mc → Prop

                    The relevant main labels of a catalog: the original basic columns available on some active cell and the templates of the catalog.

                    Equations
                    Instances For

                      The relevant main labels.

                      Equations
                      Instances For
                        @[instance_reducible]
                        noncomputable instance TrilinearHT.Auto.ActiveSetup.BasicFamilies.instFintypeRLab {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) :
                        Fintype (bf.RLab Mc s)
                        Equations
                        def TrilinearHT.Auto.ActiveSetup.BasicFamilies.rv {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (v : bf.RLab Mc s) :
                        bf.Lab ⊕ Fin Mc

                        The underlying main label of a relevant label.

                        Equations
                        • bf.rv Mc s v = ↑v
                        Instances For

                          The family birth cell of an original label.

                          Equations
                          Instances For
                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mBirth {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (v : bf.RLab Mc s) :

                            The birth cells of the relevant main labels: the family birth cell of an original column, clamped to the attempt root, and the birth cell of a template.

                            Equations
                            Instances For
                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.cell_sub_famBirth {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {c : ℤ × ℤ} {x : bf.Lab} (h : bf.occAvail c x) :
                              dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G (bf.famBirth x).1 (bf.famBirth x).2

                              An original label available at a cell of the setup is available at its family birth cell.

                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mBirth_inl_sub {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (x : bf.Lab) (hx : bf.Relevant s (Sum.inl x)) :
                              dyadicGridCell A.G (bf.mBirth s ⟨Sum.inl x, hx⟩).1 (bf.mBirth s ⟨Sum.inl x, hx⟩).2 ⊆ dyadicGridCell A.G (bf.famBirth x).1 (bf.famBirth x).2
                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.cell_sub_mBirth_inl {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) {c : ℤ × ℤ} {x : bf.Lab} (h : bf.occAvail c x) (hx : bf.Relevant s (Sum.inl x)) :
                              dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G (bf.mBirth s ⟨Sum.inl x, hx⟩).1 (bf.mBirth s ⟨Sum.inl x, hx⟩).2

                              An available original label's cell lies in its main birth cell.

                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mBirth_mem_tree {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (hb : ∀ e ∈ s, e.birth ∈ A.cells) (v : bf.RLab Mc s) :
                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.tmplPath {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (s : List (CatCol bf.Vtx)) (y : ℝ) :

                              The number of templates of a catalog whose birth cell contains the point y.

                              Equations
                              Instances For

                                A main budget of a catalog of an attempt: the templates are born at active cells, and the budget B dominates eight column budgets plus the template path counts (blueprint line 1835: the common main catalog budget).

                                Instances For
                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.card_orig_births_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (y : ℝ) :
                                  ↑{v : bf.RLab Mc s | (↑v).isLeft = true ∧ y ∈ dyadicGridCell A.G (bf.mBirth s v).1 (bf.mBirth s v).2}.card ≤ 8 * A.colBudget

                                  At most eight column budgets of original columns have a main birth cell containing a point.

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.card_tmpl_births_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (y : ℝ) :
                                  {v : bf.RLab Mc s | ¬(↑v).isLeft = true ∧ y ∈ dyadicGridCell A.G (bf.mBirth s v).1 (bf.mBirth s v).2}.card ≤ bf.tmplPath s y
                                  noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainTree {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) :

                                  The main column tree of a catalog of an attempt (blueprint lines 1805, 1859): the relevant main labels with their main scalars and private weights, born at their (clamped) family birth cells and template birth cells, on the complete tree of the attempt, with a budget B that dominates eight column budgets plus the template path counts.

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

                                    The active ancestors of a cell: the active cells containing it.

                                    Equations
                                    Instances For

                                      The deepest active ancestor of a cell, if any (blueprint line 1859: between actual uses the inherited projections are retained).

                                      Equations
                                      Instances For
                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.deepAnc_spec {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {c a : ℤ × ℤ} (h : deepAnc c = some a) :
                                        a ∈ A.cells ∧ dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G a.1 a.2 ∧ ∀ b ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G b.1 b.2 → dyadicGridCell A.G a.1 a.2 ⊆ dyadicGridCell A.G b.1 b.2
                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.deepAnc_mono {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {c d a : ℤ × ℤ} (hcd : dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2) (hd : deepAnc d = some a) :
                                        ∃ (a' : ℤ × ℤ), deepAnc c = some a' ∧ dyadicGridCell A.G a'.1 a'.2 ⊆ dyadicGridCell A.G a.1 a.2
                                        def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainPred {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (a : ℤ × ℤ) (r : ℕ) (M : bf.Vtx → Prop) :
                                        bf.Lab ⊕ Fin Mc → Prop

                                        The main labels of the slot l at an active cell a, of rank at most r, in the vertex mask M: the available original columns whose vertex lies in M and the templates born above a of rank at most r with tag in M (blueprint lines 1805-1806).

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainPred_relevant {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) {Mc : ℕ} (s : List (CatCol bf.Vtx)) {a : ℤ × ℤ} {r : ℕ} {M : bf.Vtx → Prop} {v : bf.Lab ⊕ Fin Mc} (hv : bf.mainPred l s a r M v) :
                                          bf.Relevant s v
                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainMaskT {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) :

                                          The inherited masks of the main column tree for the slot l, rank r and depth-monotone vertex masks M: at a cell, the main labels of its deepest active ancestor, none above the attempt (blueprint line 1859: retained inherited projections, zero before the attempt).

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainMaskT_labels_self {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {c : ℤ × ℤ} (hc : c ∈ A.cells) (v : bf.RLab Mc s) :
                                            v ∈ (bf.mainMaskT l Mc s mb r M hM).labels c ↔ bf.mainPred l s c r (M c) ↑v
                                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainFam {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) :

                                            The main depth family of the slot l for the rank r and the depth-monotone vertex masks M (blueprint line 1859): the nested depth projections of the main column tree with the inherited masks, on the complete tree of the attempt.

                                            Equations
                                            Instances For
                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.relabel_cellProj {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {c : ℤ × ℤ} (hc : c ∈ A.cells) (z : ↥(ColumnL2 (bf.RLab Mc s))) :
                                              (colRelabel (bf.rv Mc s)) ((cellColumnProjection (bf.mainTree Mc s mb) (bf.mainMaskT l Mc s mb r M hM) ⋯) z) = (mainProj A.G Mc (bf.origCols l) s c r (M c)) ((colRelabel (bf.rv Mc s)) z)

                                              At an active cell the relabeled cell projection of the main depth family is the main projection (blueprint lines 1805, 1859): the global main projections restrict to the cell-local ones.

                                              Relabelings, restrictions and adjoints #

                                              theorem TrilinearHT.Auto.colRelabel_restrict {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) (s : Set ℝ) (hs : MeasurableSet s) (z : ↥(ColumnL2 V)) :

                                              A relabeling commutes with the restriction to a set.

                                              The adjoint of a relabeling also commutes with the restriction to a set.

                                              theorem TrilinearHT.Auto.colRelabel_adjoint_apply_relabel {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} (hf : Function.Injective f) (z : ↥(ColumnL2 V)) :

                                              Along an injection the adjoint of the relabeling is a left inverse.

                                              theorem TrilinearHT.Auto.colRelabel_adjoint_of_mem_range {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {f : V → W} (hf : Function.Injective f) {w : ↥(ColumnL2 W)} (hw : w ∈ (↑(colRelabel f)).range) :

                                              On the range of an injective relabeling, relabeling after the adjoint is the identity.

                                              theorem TrilinearHT.Auto.layerOp_intertwine₂ {E : Type u_1} {E' : Type u_2} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [NormedAddCommGroup E'] [InnerProductSpace ℂ E'] (C : ℕ → E →L[ℂ] E) (C' : ℕ → E' →L[ℂ] E') (r : E →L[ℂ] E') (h : ∀ (m : ℕ), r ∘SL C m = C' m ∘SL r) (ls : List (ℕ × Bool)) :
                                              r ∘SL layerOp C ls = layerOp C' ls ∘SL r

                                              Layer products intertwine along a map intertwining their factors.

                                              theorem TrilinearHT.Auto.opAvg_intertwine₂ {E : Type u_1} {E' : Type u_2} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [NormedAddCommGroup E'] [InnerProductSpace ℂ E'] {P : ℕ} (Q : Fin P → E →L[ℂ] E) (Q' : Fin P → E' →L[ℂ] E') (r : E →L[ℂ] E') (h : ∀ (p : Fin P), r ∘SL Q p = Q' p ∘SL r) :
                                              theorem TrilinearHT.Auto.globHist_restrict {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) {P : ℕ} (Am : ℕ → Fin P → InheritedColumnMask Ψ.D) (ls : List (ℕ × Bool)) (h : ℤ) {Q : ℤ × ℤ} (hQ : Q ∈ (Ψ.partition h).cells) (z : ↥(ColumnL2 V)) :
                                              (columnL2Restriction (dyadicGridCell Ψ.D.grid Q.1 Q.2) ⋯) ((globHist Ψ Am ls h) z) = (layerOp (fun (m : ℕ) => opAvg fun (p : Fin P) => cellColumnProjection Ψ.D (Am m p) ⋯) ls) ((columnL2Restriction (dyadicGridCell Ψ.D.grid Q.1 Q.2) ⋯) z)

                                              On a cell of the depth partition, the global averaged history is the layer product of the averaged cell projections of the cell (blueprint lines 1859, 1879: histories evaluated at their decision cells).

                                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainBase {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) :

                                              The main column tree as a depth family on the complete tree of the attempt (its masks are replaced by withMask).

                                              Equations
                                              Instances For
                                                theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mem_partition_mainBase {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                I ∈ ((bf.mainBase Mc s mb).partition I.1).cells
                                                theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.proj_bridge {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {I : ℤ × ℤ} (hI : I ∈ A.cells) (z : ↥(ColumnL2 (bf.RLab Mc s))) :
                                                (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv Mc s)) ((((bf.mainBase Mc s mb).withMask (bf.mainMaskT l Mc s mb r M hM)).proj I.1) z)) = (mainProj A.G Mc (bf.origCols l) s I r (M I)) ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv Mc s)) z))

                                                At an active cell, the cell restriction of the relabeled global depth projection of the main tree with the inherited masks is the main projection of the cell applied to the restricted relabeled input (blueprint lines 1805, 1859).

                                                noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.cumMaskT {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (m : ℕ) (p : Fin fp.P) :

                                                The inherited cumulative masks of the main tree of the slot l (blueprint lines 1807, 1859): the split m, the pad index p.

                                                Equations
                                                Instances For
                                                  noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballMaskT {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (p : Fin fp.P) :

                                                  The inherited ball masks of the main tree of the slot l for the group G at the ball level j and the pad index p (blueprint lines 1807, 1859).

                                                  Equations
                                                  Instances For
                                                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gHist {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) (h : ℤ) :
                                                    ↥(ColumnL2 (bf.RLab fp.Mc s)) →L[ℂ] ↥(ColumnL2 (bf.RLab fp.Mc s))

                                                    The global shared cumulative history B'_{l,s} with layers ls at the depth h, on the relevant main labels: a layer product of averaged global main depth projections or their complements (blueprint lines 1859, 1871).

                                                    Equations
                                                    Instances For
                                                      noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gBall {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (h : ℤ) :
                                                      ↥(ColumnL2 (bf.RLab fp.Mc s)) →L[ℂ] ↥(ColumnL2 (bf.RLab fp.Mc s))

                                                      The global positive smeared ball filter L_{l,G} at the ball level j and the depth h (blueprint lines 1807, 1859).

                                                      Equations
                                                      Instances For
                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.hist_bridge {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) {I : ℤ × ℤ} (hI : I ∈ A.cells) (z : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
                                                        (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) ((fp.gHist l s mb ls I.1) z)) = (layerOp (fun (m : ℕ) => fp.cumFilt l s I m) ls) ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) z))

                                                        At an active cell the global cumulative history restricts to the cell-local history of the search leaves (blueprint line 1859).

                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ball_bridge {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) {I : ℤ × ℤ} (hI : I ∈ A.cells) (z : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
                                                        (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) ((fp.gBall l s mb G j I.1) z)) = (fp.ballFilt l s I G j) ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) z))

                                                        At an active cell the global ball filter restricts to the cell-local ball filter (blueprint line 1859).

                                                        theorem TrilinearHT.Auto.colRelabel_inl_fresh {V : Type} [Fintype V] {Mc : ℕ} {V' : Type u_1} [Fintype V'] (g : V' → V) (z : ↥(ColumnL2 V')) :
                                                        MainFresh Mc 0 ((colRelabel fun (v : V') => Sum.inl (g v)) z)

                                                        Relabeling into original labels creates no template coordinates.

                                                        theorem TrilinearHT.Auto.MainFresh.restrict {V : Type} [Fintype V] {Mc n : ℕ} {x : ↥(ColumnL2 (V ⊕ Fin Mc))} (h : MainFresh Mc n x) (s : Set ℝ) (hs : MeasurableSet s) :

                                                        The restriction to a set keeps the absence of template coordinates.

                                                        theorem TrilinearHT.Auto.augPhys_colRelabel {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (f : V → W) (z : ↥(ColumnL2 V)) :

                                                        A relabeling keeps the physical coordinate.

                                                        The restriction to a set restricts the physical coordinate.

                                                        theorem TrilinearHT.Auto.augPhys_sub {V : Type u_1} [Fintype V] (x x' : ↥(ColumnL2 V)) :
                                                        noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.famEmb {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) (j : Fin 2) :
                                                        ↥(ColumnL2 (bf.P l j).V) →L[ℂ] ↥(ColumnL2 (bf.Lab ⊕ Fin Mc))

                                                        The embedding of the column space of the basic family (l, j) into the main column space: its columns are the original basic columns of the slot l (blueprint lines 1676, 1805).

                                                        Equations
                                                        Instances For
                                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.famEmb_injective {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) (j : Fin 2) :
                                                          Function.Injective fun (v : (bf.P l j).V) => Sum.inl ⟨l, ⟨j, v⟩⟩
                                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.gBasic {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) (h : ℤ) :
                                                          ↥(ColumnL2 (bf.Lab ⊕ Fin Mc))

                                                          The global basic input of the slot l at the depth h: the fixed signed sum P_{l,0,h} F_{l,0} - P_{l,1,h} F_{l,1} of the depth projections of the two basic families acting on their inputs, in the main column space (blueprint prop:base line 1611, line 1859).

                                                          Equations
                                                          Instances For
                                                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.basicIn {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) (I : ℤ × ℤ) :
                                                            ↥(ColumnL2 (bf.Lab ⊕ Fin Mc))

                                                            The basic input of the slot l on the cell I: the global basic input at the depth of I restricted to I.

                                                            Equations
                                                            Instances For
                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.famCell_mem {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (j : Fin 2) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              I ∈ ((bf.P l j).Ψ.partition I.1).cells
                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.fam_restrict {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (j : Fin 2) {I : ℤ × ℤ} (hI : I ∈ A.cells) (Z : ↥(ColumnL2 (bf.P l j).V)) :
                                                              (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (((bf.P l j).Ψ.proj I.1) Z) = (cellColumnProjection (bf.P l j).Ψ.D (bf.P l j).Ψ.A ⋯) Z

                                                              At an active cell the basic depth projection restricts to the basic cell projection.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.basicIn_eq {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              bf.basicIn Mc l I = (bf.famEmb Mc l 0) ((cellColumnProjection (bf.P l 0).Ψ.D (bf.P l 0).Ψ.A ⋯) (bf.P l 0).Z) - (bf.famEmb Mc l 1) ((cellColumnProjection (bf.P l 1).Ψ.D (bf.P l 1).Ψ.A ⋯) (bf.P l 1).Z)

                                                              The basic input on an active cell is the fixed signed sum of the basic cell projections of the family inputs.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.famEmb_cellColumn {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (l : Fin 4) (j : Fin 2) {I : ℤ × ℤ} (hI : I ∈ A.cells) (hID : I ∈ (bf.P l j).Ψ.D.cells) (v : ↥((bf.P l j).Ψ.A.labels I)) :
                                                              (bf.famEmb Mc l j) (cellColumnLp (bf.P l j).Ψ.D (bf.P l j).Ψ.A hID v) = mainCol A.G Mc (bf.origCols l) s I (Sum.inl ⟨l, ⟨j, ↑v⟩⟩)

                                                              A basic cell column embeds as the main column of its original label.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.origCol_mem_range {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) {I : ℤ × ℤ} (hI : I ∈ A.cells) {x : bf.Lab} (hxl : x.fst = l) (hx : bf.occAvail I x) :
                                                              mainCol A.G Mc (bf.origCols l) s I (Sum.inl x) ∈ (↑(colRelabel (bf.rv Mc s))).range

                                                              An original column of the slot l available at an active cell is the relabeling of a column of the main tree.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.basicIn_mem_range {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (l : Fin 4) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              bf.basicIn Mc l I ∈ (↑(colRelabel (bf.rv Mc s))).range

                                                              The basic input on an active cell has only relevant main coordinates.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_history {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              (layerOp (fun (m : ℕ) => fp.cumFilt l s I m) ls) (bf.basicIn fp.Mc l I) = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) ((fp.gHist l s mb ls I.1) ((ContinuousLinearMap.adjoint (colRelabel (bf.rv fp.Mc s))) (bf.gBasic fp.Mc l I.1))))

                                                              Blueprint line 1859: on an active cell the shared history of a basic B slot is the cell restriction of the global shared history at the depth of the cell acting on the global basic input (the fixed signed sum of the basic depth projections of the family inputs F_l), relabeled from the relevant main labels.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_leaf_out {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) (G : bf.Grp) (j : ℕ) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              (fp.ballFilt l s I G j) ((layerOp (fun (m : ℕ) => fp.cumFilt l s I m) ls) (bf.basicIn fp.Mc l I)) = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((colRelabel (bf.rv fp.Mc s)) ((fp.gBall l s mb G j I.1) ((fp.gHist l s mb ls I.1) ((ContinuousLinearMap.adjoint (colRelabel (bf.rv fp.Mc s))) (bf.gBasic fp.Mc l I.1)))))

                                                              Blueprint line 1859, the leaf outputs of a basic B slot: on an active cell the ball output Z_{l,G,s} = L_{l,G,s} B_{l,s} B_l is the cell restriction of the global ball filter applied to the global shared history of the global basic input.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_compression {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {F : Type u_1} {ι : Type u_2} [NormedAddCommGroup F] [NormedSpace ℂ F] [Fintype ι] (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) (j : Fin 2) (u : ι → ℤ × ℤ) (hu : ∀ (i : ι), u i ∈ A.cells) (R : ι → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc)) →L[ℂ] F) {B : ℝ} (hB : 0 ≤ B) (hR : ∀ (x : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))), ∑ i : ι, ‖(R i) x‖ ^ 2 ≤ B * ‖x‖ ^ 2) (hloc : ∀ (i : ι), R i ∘SL columnL2Restriction (dyadicGridCell A.G (u i).1 (u i).2) ⋯ = R i) (Z : ↥(ColumnL2 (bf.P l j).V)) :
                                                              ∑ i : ι, ‖(R i) ((colRelabel (bf.rv fp.Mc s)) ((fp.gHist l s mb ls (u i).1) ((ContinuousLinearMap.adjoint (colRelabel (bf.rv fp.Mc s))) ((bf.famEmb fp.Mc l j) (((bf.P l j).Ψ.proj (u i).1) Z)))))‖ ^ 2 ≤ B * compressionC (bf.mainTree fp.Mc s mb) ls.length ^ 2 * compression1 (bf.P l j).Ψ.D ^ 2 * ‖Z‖ ^ 2

                                                              Blueprint line 1859 (the compression loss): rows on the main column space that are Bessel with constant B and local to active decision cells u_i remain Bessel after inserting, at the depth of each decision cell, the global shared history of the slot l and the basic depth projection of the family (l, j) acting on an input Z of the family (e.g. F_{l,j} or 1_R F_{l,j}), at the cost of the complement compression of the main tree for |ls| factors and the one-factor compression of the basic tree.

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

                                                              The basic input of a cell has no template coordinates (blueprint line 1805: original labels have rank zero).

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

                                                              The basic input of a cell vanishes off the cell.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.basicIn_comb {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (l : Fin 4) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              ∃ (cb : bf.Lab → ℂ), bf.basicIn Mc l I = ∑ v : bf.Lab with (bf.origCols l).avail I v, cb v • mainCol A.G Mc (bf.origCols l) s I (Sum.inl v)

                                                              On an active cell the basic input is a combination of the original columns of the slot available there (blueprint lines 1611, 1859: the basic guard slot input of prop:localize).

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.basicIn_phys {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                                              augPhys (bf.basicIn Mc l I) =ᵐ[MeasureTheory.volume] (dyadicGridCell A.G I.1 I.2).indicator (A.B l I)

                                                              The physical coordinate of the basic input of an active cell is the basic argument B_l on the cell (blueprint prop:base line 1611).

                                                              The zero convention and the retained inherited projections (blueprint line 1859) #

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainMaskT_labels_none {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {c : ℤ × ℤ} (hc : deepAnc c = none) :
                                                              (bf.mainMaskT l Mc s mb r M hM).labels c = ∅

                                                              Above the attempt (no active cell contains the cell) the inherited masks of the main tree are empty (blueprint line 1859: before an attempt the outputs are zero).

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainMaskT_labels_retain {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {c a : ℤ × ℤ} (hc : deepAnc c = some a) :
                                                              (bf.mainMaskT l Mc s mb r M hM).labels c = (bf.mainMaskT l Mc s mb r M hM).labels a

                                                              Between actual uses the inherited projections are retained (blueprint line 1859): at a cell of the tree whose deepest active ancestor is a, the masks of the main tree are those of a.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.mainCellProj_none {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (r : ℕ) (M : ℤ × ℤ → bf.Vtx → Prop) (hM : ∀ c ∈ A.cells, ∀ d ∈ A.cells, dyadicGridCell A.G c.1 c.2 ⊆ dyadicGridCell A.G d.1 d.2 → ∀ (x : bf.Vtx), M d x → M c x) {c : ℤ × ℤ} (hcT : c ∈ (bf.mainTree Mc s mb).cells) (hc : deepAnc c = none) :
                                                              cellColumnProjection (bf.mainTree Mc s mb) (bf.mainMaskT l Mc s mb r M hM) hcT = 0

                                                              Above the attempt the main cell projections vanish.

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gBall_zero_before {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (h : ℤ) {c : ℤ × ℤ} (hc : c ∈ ((bf.mainBase fp.Mc s mb).partition h).cells) (hnone : deepAnc c = none) (z : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
                                                              (columnL2Restriction (dyadicGridCell A.G c.1 c.2) ⋯) ((fp.gBall l s mb G j h) z) = 0

                                                              Blueprint line 1859 (zero convention): on a cell of the depth partition lying above the attempt (contained in no active cell) the global ball outputs vanish.

                                                              The compression loss G₀ (blueprint lines 1670, 1859) #

                                                              theorem TrilinearHT.Auto.compressionC_le_overhead {V : Type u_1} [Fintype V] (D : ColumnTreeData V) (n c : ℕ) {k : ℝ} (hk : 1 ≤ k) (hD : Real.log (2 * D.budget) ≤ k ^ c) (hn : ↑n ≤ ↑c * (Real.log k + 1)) :
                                                              compressionC D n ≤ Real.exp (1024 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) * (1 + Real.log (2 * k)) ^ 2)

                                                              The complement compression for n = O(log k) factors in a column tree with log (2 budget) ≤ k^c is a small overhead G₀ = exp(C_q (1 + log 2k)^2) (eq:small-overhead).

                                                              The one-factor compression constant is at most the complement compression constant for one factor.

                                                              theorem TrilinearHT.Auto.compression_loss_le {V : Type u_1} [Fintype V] {W : Type u_2} [Fintype W] (D : ColumnTreeData V) (D' : ColumnTreeData W) (n c : ℕ) (hc : 1 ≤ c) {k : ℝ} (hk : 1 ≤ k) (hD : Real.log (2 * D.budget) ≤ k ^ c) (hD' : Real.log (2 * D'.budget) ≤ k ^ c) (hn : ↑n ≤ ↑c * (Real.log k + 1)) :
                                                              compressionC D n ^ 2 * compression1 D' ^ 2 ≤ Real.exp (4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) * (1 + Real.log (2 * k)) ^ 2)

                                                              Blueprint line 1859, "the compression loss is G₀": the loss of basic_compression for histories of length n ≤ c (log k + 1) in a main tree and a basic tree with log (2 budget) ≤ k^c is at most G₀ = exp(C_q (1 + log 2k)^2) with C_q = 4096 (c+1) (1024 (c+1) + c + 7).

                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.tmplPath_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (hMc : s.length ≤ Mc) (l : Fin 4) (hb : ∀ e ∈ s, e.birth ∈ A.cells) {r : ℕ} (hr : ∀ e ∈ s, e.rank ≤ r) {N : ℝ} (hN0 : 0 ≤ N) (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G Mc (bf.origCols l) s I r).card ≤ N) (y : ℝ) :
                                                              ↑(bf.tmplPath s y) ≤ N

                                                              The template path count of a catalog is at most the number of main labels at the deepest template birth cell containing the point (blueprint line 1835: the main catalog budget is a path count).

                                                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.MainBudget.ofCounts {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (hMc : s.length ≤ Mc) (l : Fin 4) (hb : ∀ e ∈ s, e.birth ∈ A.cells) {r : ℕ} (hr : ∀ e ∈ s, e.rank ≤ r) {N : ℝ} (hN0 : 0 ≤ N) (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G Mc (bf.origCols l) s I r).card ≤ N) :

                                                              A main budget from catalog counts: if the main labels of rank at most r number at most N at every active cell, then 8 colBudget + N is a main budget (blueprint lines 1828, 1835).

                                                              Equations
                                                              Instances For

                                                                Certified variation on the main columns (blueprint lem:variation, lines 1861-1879) #

                                                                Generic variation lemmas (moved from Sec13_1, Sec13_3 and Sec13_4) #

                                                                theorem TrilinearHT.Auto.dyadicGridCell_eq_of_meet (Gd : RealDyadicGrid) {I J : ℤ × ℤ} (hIJ : I.1 = J.1) (h : (dyadicGridCell Gd I.1 I.2 ∩ dyadicGridCell Gd J.1 J.2).Nonempty) :
                                                                I = J
                                                                theorem TrilinearHT.Auto.ColumnDepthFamily.proj_comm_restrict {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) {h' h : ℤ} (hh : h' ≤ h) {Q : ℤ × ℤ} (hQ : Q ∈ (Ψ.partition h').cells) :

                                                                A depth projection commutes with the restriction to a cell of a coarser depth partition.

                                                                theorem TrilinearHT.Auto.ColumnDepthFamily.proj_vanish {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) (h : ℤ) (z : ↥(ColumnL2 V)) :
                                                                ∀ᵐ (y : ℝ), y ∉ dyadicGridCell Ψ.D.grid Ψ.D.root.1 Ψ.D.root.2 → ↑↑((Ψ.proj h) z) y = 0

                                                                Outputs of a depth projection vanish off the root.

                                                                theorem TrilinearHT.Auto.ColumnDepthFamily.norm_sq_partition' {V : Type u_1} [Fintype V] {W : Type u_2} [Fintype W] (Ψ : ColumnDepthFamily V) (h : ℤ) (v : ↥(ColumnL2 W)) (hv : ∀ᵐ (y : ℝ), y ∉ dyadicGridCell Ψ.D.grid Ψ.D.root.1 Ψ.D.root.2 → ↑↑v y = 0) :
                                                                ‖v‖ ^ 2 = ∑ Q : ↥(Ψ.partition h).cells, ‖(columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) v‖ ^ 2

                                                                A column function (of any label type) vanishing off the root of a depth family splits orthogonally over its depth partition.

                                                                theorem TrilinearHT.Auto.ColumnDepthFamily.norm_sq_partition {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) (h : ℤ) (v : ↥(ColumnL2 V)) (hv : ∀ᵐ (y : ℝ), y ∉ dyadicGridCell Ψ.D.grid Ψ.D.root.1 Ψ.D.root.2 → ↑↑v y = 0) :
                                                                ‖v‖ ^ 2 = ∑ Q : ↥(Ψ.partition h).cells, ‖(columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) v‖ ^ 2

                                                                A column function vanishing off the root splits orthogonally over a depth partition.

                                                                theorem TrilinearHT.Auto.ColumnDepthFamily.interval_rows {V : Type u_1} [Fintype V] {ι : Type u_2} [Fintype ι] (Ψ : ColumnDepthFamily V) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (hdis : ∀ (i j : ι), i ≠ j → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r j) (t j))) :
                                                                (∀ (x : ↥(ColumnL2 V)), ∑ i : ι, ‖(Ψ.proj (Ψ.D.root.1 + ↑(t i)) - Ψ.proj (Ψ.D.root.1 + ↑(r i))) x‖ ^ 2 ≤ 1 * ‖x‖ ^ 2) ∧ ∀ (i : ι) (x : ↥(ColumnL2 V)), ‖(Ψ.proj (Ψ.D.root.1 + ↑(t i)) - Ψ.proj (Ψ.D.root.1 + ↑(r i))) x‖ ^ 2 = ∑ Q : ↥(Ψ.partition (Ψ.D.root.1 + ↑(r i))).cells, ‖(Ψ.proj (Ψ.D.root.1 + ↑(t i)) - Ψ.proj (Ψ.D.root.1 + ↑(r i))) ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2

                                                                The interval rows of one nested depth family are Bessel (orthogonal increments) and split orthogonally over the partition at their left depth.

                                                                theorem TrilinearHT.Auto.globHist_layer_jump {V : Type u_1} [Fintype V] {ι : Type u_2} [Fintype ι] (Ψ : ColumnDepthFamily V) {P : ℕ} (hP : 0 < P) (Am : ℕ → Fin P → InheritedColumnMask Ψ.D) (l : List (ℕ × Bool)) (a : ℕ × Bool) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (hdis : ∀ (i j : ι), i ≠ j → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r j) (t j))) (z : ↥(ColumnL2 V)) :
                                                                ∑ i : ι, ‖((opAvg fun (p : Fin P) => (Ψ.withMask (Am a.1 p)).proj (Ψ.D.root.1 + ↑(t i))) - opAvg fun (p : Fin P) => (Ψ.withMask (Am a.1 p)).proj (Ψ.D.root.1 + ↑(r i))) ((globHist Ψ Am l (Ψ.D.root.1 + ↑(r i))) z)‖ ^ 2 ≤ compressionC Ψ.D l.length ^ 2 * ‖z‖ ^ 2

                                                                One layer of the jump: the change of a single averaged layer between the endpoints, applied to the left history of the preceding layers, is compressed.

                                                                theorem TrilinearHT.Auto.globHist_jump {V : Type u_1} [Fintype V] {ι : Type u_2} [Fintype ι] (Ψ : ColumnDepthFamily V) {P : ℕ} (hP : 0 < P) (Am : ℕ → Fin P → InheritedColumnMask Ψ.D) (ls : List (ℕ × Bool)) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (hdis : ∀ (i j : ι), i ≠ j → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r j) (t j))) (z : ↥(ColumnL2 V)) :
                                                                ∑ i : ι, ‖(globHist Ψ Am ls (Ψ.D.root.1 + ↑(t i))) z - (globHist Ψ Am ls (Ψ.D.root.1 + ↑(r i))) z‖ ^ 2 ≤ (↑ls.length * ∑ m ∈ Finset.range ls.length, compressionC Ψ.D m ^ 2) * ‖z‖ ^ 2

                                                                Blueprint lines 1886-1888 ("telescope B_t' - B_r', discard left contractions, and use the changed middle factors as orthogonal rows on [r,t]; compression inserts their right factors"): the jumps of the global averaged histories over disjoint depth intervals.

                                                                The active cells are closed under ancestors below the root.

                                                                Equations
                                                                • One or more equations did not get rendered due to their size.
                                                                Instances For
                                                                  theorem TrilinearHT.Auto.sum_filter_fst_eq {γ : Type u_1} {ι : Type u_2} {M : Type u_3} [Fintype γ] [Fintype ι] [DecidableEq γ] [AddCommMonoid M] (f : γ × ι → M) (G : γ) :
                                                                  ∑ k : γ × ι with k.1 = G, f k = ∑ i : ι, f (G, i)
                                                                  theorem TrilinearHT.Auto.cells_pairwiseDisjoint_of_depth (Gd : RealDyadicGrid) (S : Finset (ℤ × ℤ)) {h : ℤ} (hS : ∀ I ∈ S, I.1 = h) :
                                                                  (↑S).PairwiseDisjoint fun (I : ℤ × ℤ) => dyadicGridCell Gd I.1 I.2
                                                                  theorem TrilinearHT.Auto.ColumnDepthFamily.blk_of_commute {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (Ψ : ColumnDepthFamily V) (h : ℤ) (R : ↥(ColumnL2 W) →L[ℂ] ↥(ColumnL2 W)) (hvan : ∀ (x : ↥(ColumnL2 W)), ∀ᵐ (y : ℝ), y ∉ dyadicGridCell Ψ.D.grid Ψ.D.root.1 Ψ.D.root.2 → ↑↑(R x) y = 0) (hc : ∀ Q ∈ (Ψ.partition h).cells, R ∘SL columnL2Restriction (dyadicGridCell Ψ.D.grid Q.1 Q.2) ⋯ = columnL2Restriction (dyadicGridCell Ψ.D.grid Q.1 Q.2) ⋯ ∘SL R) (x : ↥(ColumnL2 W)) :
                                                                  ‖R x‖ ^ 2 = ∑ Q : ↥(Ψ.partition h).cells, ‖R ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2

                                                                  Rows whose outputs vanish off the root of a depth family and which commute with the restrictions to its depth-h cells split orthogonally over that partition (the hypothesis of basic_insert).

                                                                  theorem TrilinearHT.Auto.columnL2Restriction_vanish {V : Type u_1} [Fintype V] (s : Set ℝ) (hs : MeasurableSet s) (x : ↥(ColumnL2 V)) :
                                                                  ∀ᵐ (y : ℝ), y ∉ s → ↑↑((columnL2Restriction s hs) x) y = 0

                                                                  Outputs of a restriction vanish off its set.

                                                                  theorem TrilinearHT.Auto.Ioc_disjoint_shift {a b c d δ : ℕ} (h : Disjoint (Finset.Ioc a b) (Finset.Ioc c d)) :
                                                                  Disjoint (Finset.Ioc (a + δ) (b + δ)) (Finset.Ioc (c + δ) (d + δ))

                                                                  Depth intervals of naturals shifted by a common offset stay disjoint.

                                                                  theorem TrilinearHT.Auto.ColumnDepthFamily.jumps_from_le {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) {ι : Type u_2} [Fintype ι] {ρ : ℤ} (hρ : Ψ.D.root.1 ≤ ρ) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (hdis : ∀ (i i' : ι), i ≠ i' → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r i') (t i'))) (Z : ↥(ColumnL2 V)) :
                                                                  ∑ i : ι, ‖(Ψ.proj (ρ + ↑(t i)) - Ψ.proj (ρ + ↑(r i))) Z‖ ^ 2 ≤ ‖Z‖ ^ 2

                                                                  The jumps of a basic depth family over disjoint intervals measured from a deeper root are Bessel.

                                                                  Certified variation with general histories (blueprint lines 1879-1905, 2149) #

                                                                  theorem TrilinearHT.Auto.certifiedVariation_gen {H : Type u_1} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] {γ : Type u_2} {ι : Type u_3} [Fintype γ] [DecidableEq γ] [Fintype ι] (T : ℕ) (L : γ → ℕ → H →L[ℂ] H) (hL : ∀ (G : γ), ∀ n ≤ T, IsStarProjection (L G n)) (hLnest : ∀ (G : γ), ∀ i ≤ T, ∀ j ≤ T, i ≤ j → L G i ∘SL L G j = L G i) (E : γ → ι → H →L[ℂ] H) (hE : ∀ (G : γ) (i : ι) (y : H), ‖(E G i) y‖ ≤ ‖y‖) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (ht : ∀ (i : ι), t i ≤ T) (hdis : ∀ (i j : ι), i ≠ j → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r j) (t j))) (Bt Br : ι → H) (F : H) {Cw G₀ J : ℝ} (hCw : 0 ≤ Cw) (hwr1 : ∀ (x : γ × ι → H), ‖∑ k : γ × ι, (ContinuousLinearMap.adjoint (E k.1 k.2 ∘SL (L k.1 (t k.2) - L k.1 (r k.2)))) (x k)‖ ^ 2 ≤ Cw * ∑ G : γ, ‖∑ k : γ × ι with k.1 = G, (ContinuousLinearMap.adjoint (E k.1 k.2 ∘SL (L k.1 (t k.2) - L k.1 (r k.2)))) (x k)‖ ^ 2) (hcomp1 : ∀ (c : ℝ), 0 ≤ c → (∀ (h : H), ∑ k : γ × ι, ‖(E k.1 k.2 ∘SL (L k.1 (t k.2) - L k.1 (r k.2))) h‖ ^ 2 ≤ c * ‖h‖ ^ 2) → ∑ k : γ × ι, ‖(E k.1 k.2 ∘SL (L k.1 (t k.2) - L k.1 (r k.2))) (Br k.2)‖ ^ 2 ≤ c * G₀ * ‖F‖ ^ 2) (hwr2 : ∀ (i : ι) (x : γ → H), ‖∑ G : γ, (ContinuousLinearMap.adjoint (E G i ∘SL L G (t i))) (x G)‖ ^ 2 ≤ Cw * ∑ G : γ, ‖∑ G' : γ with G' = G, (ContinuousLinearMap.adjoint (E G' i ∘SL L G' (t i))) (x G')‖ ^ 2) (hjump : ∑ i : ι, ‖Bt i - Br i‖ ^ 2 ≤ J) :
                                                                  ∑ k : γ × ι, ‖(E k.1 k.2) ((L k.1 (t k.2)) (Bt k.2) - (L k.1 (r k.2)) (Br k.2))‖ ^ 2 ≤ 2 * Cw * (G₀ * ‖F‖ ^ 2 + J)

                                                                  certifiedVariation with the histories B' replaced by arbitrary vectors: the left histories Br i enter only through the compression estimate for the ball rows, and the right histories Bt i only through the jump bound Σ_i ‖Bt i - Br i‖² ≤ J. Then Σ_{G,i} ‖E (L_{t} Bt - L_{r} Br)‖² ≤ 2 C_w (G₀ ‖F‖² + J). This is the form used for the attempt (blueprint line 2149), whose histories are products of global nested projections.

                                                                  theorem TrilinearHT.Auto.certifiedVariation_avg {H : Type u_1} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] {γ : Type u_2} {ι : Type u_3} [Fintype γ] [DecidableEq γ] [Fintype ι] (T : ℕ) {P : ℕ} (hP : 0 < P) (L : Fin P → γ → ℕ → H →L[ℂ] H) (hL : ∀ (p : Fin P) (G : γ), ∀ n ≤ T, IsStarProjection (L p G n)) (hLnest : ∀ (p : Fin P) (G : γ), ∀ i ≤ T, ∀ j ≤ T, i ≤ j → L p G i ∘SL L p G j = L p G i) (E : γ → ι → H →L[ℂ] H) (hE : ∀ (G : γ) (i : ι) (y : H), ‖(E G i) y‖ ≤ ‖y‖) (r t : ι → ℕ) (hrt : ∀ (i : ι), r i ≤ t i) (ht : ∀ (i : ι), t i ≤ T) (hdis : ∀ (i j : ι), i ≠ j → Disjoint (Finset.Ioc (r i) (t i)) (Finset.Ioc (r j) (t j))) (Bt Br : ι → H) (F : H) {Cw G₀ J : ℝ} (hCw : 0 ≤ Cw) (hwr1 : ∀ (p : Fin P) (x : γ × ι → H), ‖∑ k : γ × ι, (ContinuousLinearMap.adjoint (E k.1 k.2 ∘SL (L p k.1 (t k.2) - L p k.1 (r k.2)))) (x k)‖ ^ 2 ≤ Cw * ∑ G : γ, ‖∑ k : γ × ι with k.1 = G, (ContinuousLinearMap.adjoint (E k.1 k.2 ∘SL (L p k.1 (t k.2) - L p k.1 (r k.2)))) (x k)‖ ^ 2) (hcomp1 : ∀ (p : Fin P) (c : ℝ), 0 ≤ c → (∀ (h : H), ∑ k : γ × ι, ‖(E k.1 k.2 ∘SL (L p k.1 (t k.2) - L p k.1 (r k.2))) h‖ ^ 2 ≤ c * ‖h‖ ^ 2) → ∑ k : γ × ι, ‖(E k.1 k.2 ∘SL (L p k.1 (t k.2) - L p k.1 (r k.2))) (Br k.2)‖ ^ 2 ≤ c * G₀ * ‖F‖ ^ 2) (hwr2 : ∀ (p : Fin P) (i : ι) (x : γ → H), ‖∑ G : γ, (ContinuousLinearMap.adjoint (E G i ∘SL L p G (t i))) (x G)‖ ^ 2 ≤ Cw * ∑ G : γ, ‖∑ G' : γ with G' = G, (ContinuousLinearMap.adjoint (E G' i ∘SL L p G' (t i))) (x G')‖ ^ 2) (hjump : ∑ i : ι, ‖Bt i - Br i‖ ^ 2 ≤ J) :
                                                                  ∑ k : γ × ι, ‖(E k.1 k.2) ((opAvg fun (p : Fin P) => L p k.1 (t k.2)) (Bt k.2) - (opAvg fun (p : Fin P) => L p k.1 (r k.2)) (Br k.2))‖ ^ 2 ≤ 2 * Cw * (G₀ * ‖F‖ ^ 2 + J)

                                                                  certifiedVariation_gen for pad averages of ball projections (blueprint line 1883, "couple individual pad choices across times; Jensen").

                                                                  Whole endpoint ranges on the main columns (blueprint lines 1777-1789, 1875) #

                                                                  theorem TrilinearHT.Auto.groupOutput_fiber_norm {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (lab : V → W) (φ : W → ℝ → ℂ) (ε : W → ℝ) (φ' : V → ℝ → ℂ) (ε' : V → ℝ) (hε0 : ∀ (w : W), 0 ≤ ε w) (hε'0 : ∀ (v : V), 0 ≤ ε' v) (a : V → ℝ → ℂ) (y : ℝ) (hφ : ∀ (v : V), a v y ≠ 0 → φ (lab v) y = φ' v y) (hε : ∀ (v : V), ε (lab v) = ε' v) (hfib : ∀ (v₁ v₂ : V), lab v₁ = lab v₂ → a v₁ y ≠ 0 → a v₂ y ≠ 0 → v₁ = v₂) :
                                                                  ‖groupOutput φ ε (fun (w : W) (y : ℝ) => ∑ v : V with lab v = w, a v y) y‖ = ‖groupOutput φ' ε' a y‖

                                                                  Group outputs over finer labels V that push forward along lab : V → W, with at most one label of each fiber present at the point, have the norm of the pushed-forward group output when the scalars agree at the present labels and the weights agree.

                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vtxAt_eq_of_meet {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) {I J : ℤ × ℤ} {x : bf.Lab} (hI : bf.occAvail I x) (hJ : bf.occAvail J x) (hm : (dyadicGridCell A.G (↑(bf.vtxAt I x).2).1 (↑(bf.vtxAt I x).2).2 ∩ dyadicGridCell A.G (↑(bf.vtxAt J x).2).1 (↑(bf.vtxAt J x).2).2).Nonempty) :
                                                                  bf.vtxAt I x = bf.vtxAt J x

                                                                  Two occurrences of an original label whose admission cells meet have the same vertex: admission cells of distinct vertices of one label are disjoint.

                                                                  @[reducible, inline]

                                                                  The vertex-labelled main labels: vertices (original column occurrences) and templates.

                                                                  Equations
                                                                  Instances For
                                                                    def TrilinearHT.Auto.ActiveSetup.BasicFamilies.vLab {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) :
                                                                    bf.VLab Mc → bf.Lab ⊕ Fin Mc

                                                                    The main label of a vertex-labelled main label.

                                                                    Equations
                                                                    Instances For
                                                                      noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.vKey {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (I : ℤ × ℤ) :
                                                                      bf.Lab ⊕ Fin Mc → bf.VLab Mc

                                                                      The vertex-labelled main label of a main label at a cell.

                                                                      Equations
                                                                      Instances For
                                                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vLab_vKey {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (I : ℤ × ℤ) (v : bf.Lab ⊕ Fin Mc) :
                                                                        bf.vLab Mc (bf.vKey Mc I v) = v
                                                                        noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.vPhi {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) :
                                                                        bf.VLab Mc → ℝ → ℂ

                                                                        The scalars of the vertex-labelled main labels: the chart atom of an available vertex (zero otherwise) and the template atom.

                                                                        Equations
                                                                        Instances For
                                                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.vEps {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) :
                                                                          bf.VLab Mc → ℝ

                                                                          The private weights of the vertex-labelled main labels.

                                                                          Equations
                                                                          Instances For
                                                                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.vTag {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (d : bf.Vtx) :
                                                                            bf.VLab Mc → bf.Vtx

                                                                            The tag of a vertex-labelled main label (a default beyond the catalog).

                                                                            Equations
                                                                            Instances For
                                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vEps_pos {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (v : bf.VLab Mc) :
                                                                              0 < bf.vEps Mc v
                                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vEps_eq {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (l : Fin 4) (v : bf.VLab Mc) :
                                                                              mainWeight Mc (bf.origCols l) (bf.vLab Mc v) = bf.vEps Mc v
                                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vPhi_measurable {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (v : bf.VLab Mc) :
                                                                              Measurable (bf.vPhi Mc s v)
                                                                              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.norm_vPhi_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (v : bf.VLab Mc) (y : ℝ) :
                                                                              ‖bf.vPhi Mc s v y‖ ≤ 1
                                                                              def TrilinearHT.Auto.ActiveSetup.BasicFamilies.VOccurs {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) {Mc : ℕ} (s : List (CatCol bf.Vtx)) (I : ℤ × ℤ) :
                                                                              bf.VLab Mc → Prop

                                                                              A vertex-labelled main label occurs at a cell: an available original column of the slot with that vertex, or a template of the catalog.

                                                                              Equations
                                                                              Instances For
                                                                                theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.vPhi_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 : ℤ × ℤ} {v : bf.VLab Mc} (hv : bf.VOccurs l s I v) :
                                                                                ∃ (B : QuadraticChartData (bf.vtag (bf.vTag Mc s d v)).dim), QuadraticChartComplexity A.csrc A.Hsrc B ∧ IsBoundedQuadraticChart B ∧ B.horizontal = (bf.vtag (bf.vTag Mc s d v)).θ ∧ B.matrix = ↑(slotCoeff l) • (bf.vtag (bf.vTag Mc s d v)).C ∧ B.quadratic = ↑(slotCoeff l) * (bf.vtag (bf.vTag Mc s d v)).lam ∧ bf.vPhi Mc s v = quadraticChartAtom B

                                                                                The scalar of an occurring vertex-labelled main label is a pure source chart of its tag in the slot, on the whole line (blueprint line 1798: pure main columns).

                                                                                def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Cert {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (k : ℕ) (G : bf.Grp) (I : ℤ × ℤ) :

                                                                                A downstream actual-use certificate of the group G of color k inside the cell I: an active cell u ⊆ I with a successful present vertex of color k and group G (blueprint lines 1863, 1876).

                                                                                Equations
                                                                                • One or more equations did not get rendered due to their size.
                                                                                Instances For
                                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Cert.mono {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {k : ℕ} {G : bf.Grp} {I J : ℤ × ℤ} (h : fp.Cert k G I) (hIJ : dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G J.1 J.2) :
                                                                                  fp.Cert k G J
                                                                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.endpoint_sep {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {k : ℕ} {G G' : bf.Grp} (hGG : G ≠ G') {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) (hcI : fp.Cert k G I) (hcJ : fp.Cert k G' J) {h h' : ℕ} (hh : h ≤ fp.Hmax) (hh' : h' ≤ fp.Hmax) {b b' : bf.Vtx} (hb : b ∈ fp.K.mask bf.admT A.famVtxBound G h (bf.admAt I)) (hb' : b' ∈ fp.K.mask bf.admT A.famVtxBound G' h' (bf.admAt J)) :
                                                                                  ¬(bf.tagDist fp.Hed).d J.1 b b' ≤ 1

                                                                                  Blueprint lem:masks, separation clause, for endpoints: tags in the ball masks of distinct groups of one color on nested certified endpoint cells J ⊆ I are at distance greater than one at the finer endpoint.

                                                                                  def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.VOccOK {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (d : bf.Vtx) (k : ℕ) (G : bf.Grp) (v : bf.VLab fp.Mc) (I : ℤ × ℤ) :

                                                                                  An endpoint occurrence of a vertex-labelled main label for the group G of color k on the cell I: the cell is active, the label occurs there with its tag in a pad mask of G at a pad at most H_max, and I carries a downstream use certificate of G (blueprint lem:whole-ranges: "usable endpoint cells whose masks contain their tags").

                                                                                  Equations
                                                                                  Instances For
                                                                                    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.vocc_overlap_sep {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (d : bf.Vtx) {k : ℕ} {G G' : bf.Grp} (hGG : G ≠ G') {v w : bf.VLab fp.Mc} {I J : ℤ × ℤ} (hI : fp.VOccOK l s d k G v I) (hJ : fp.VOccOK l s d k G' w J) (hov : (dyadicGridCell A.G I.1 I.2 ∩ dyadicGridCell A.G J.1 J.2).Nonempty) :
                                                                                    ∃ (t : ℤ), I.1 ≤ t ∧ J.1 ≤ t ∧ (t = I.1 ∨ t = J.1) ∧ ¬(bf.tagDist fp.Hed).d t (bf.vTag fp.Mc s d v) (bf.vTag fp.Mc s d w) ≤ 1

                                                                                    Overlapping occurrences of two labels in distinct groups of one color are separated at the finer of the two depths.

                                                                                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.vLastSep {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (s : List (CatCol bf.Vtx)) (d : bf.Vtx) {ι : Type u_1} [Fintype ι] (occ : ι → bf.VLab fp.Mc → Finset (ℤ × ℤ)) (v w : bf.VLab fp.Mc) :

                                                                                    The last separating depth of two vertex-labelled main labels among the occurrence depths.

                                                                                    Equations
                                                                                    • One or more equations did not get rendered due to their size.
                                                                                    Instances For
                                                                                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.vWholeRanges {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (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) {ι : Type u_1} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k : ℕ) (occ : ι → bf.VLab fp.Mc → Finset (ℤ × ℤ)) (hocc : ∀ (G : ι) (v : bf.VLab fp.Mc), ∀ I ∈ occ G v, fp.VOccOK l s d k (grp G) v I) (c : ι → bf.VLab fp.Mc → ℤ × ℤ → ℂ) {Mc' : ℝ} (hMc : 0 ≤ Mc') (hc : ∀ (G : ι) (v : bf.VLab fp.Mc) (I : ℤ × ℤ), ‖c G v I‖ ≤ Mc') {K₀ : ℕ} (hK : ∀ (G : ι) (v : bf.VLab fp.Mc), (occ G v).card ≤ K₀) {ra rb : ℝ} (hroot : ∀ (G : ι) (v : bf.VLab fp.Mc), ∀ I ∈ occ G v, dyadicGridCell A.G I.1 I.2 ⊆ Set.Icc ra rb) {τ : ℝ} (hτ : 0 < τ) (hτ1 : τ ≤ 1) (hHed : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log τ⁻¹) ^ A.Dg) ≤ fp.Hed) {N : ℕ} (hN : ∀ (y : ℝ), {p : ι × bf.VLab fp.Mc | occCoef A.G occ c p.1 p.2 y ≠ 0}.card ≤ N) :
                                                                                      ∫ (y : ℝ), ‖∑ G : ι, groupOutput (bf.vPhi fp.Mc s) (bf.vEps fp.Mc) (occCoef A.G occ c G) y‖ ^ 2 ≤ (1 + τ * ↑N * A.colBudget ^ 2) * ∑ G : ι, ∫ (y : ℝ), ‖groupOutput (bf.vPhi fp.Mc s) (bf.vEps fp.Mc) (occCoef A.G occ c G) y‖ ^ 2

                                                                                      Blueprint lem:whole-ranges (lines 1777-1789) for one slot l and color k of the attempt on the main columns: group outputs built from occurring vertex-labelled main columns (original column occurrences and templates) with coefficients constant on whole certified endpoint cells, whose masks contain the tags, are almost orthogonal, ‖Σ_G Z_G‖² ≤ (1 + τ N W₀²) Σ_G ‖Z_G‖² with the inverse private weights at most W₀² = colBudget², when the edge height dominates the graph threshold at τ and at most N group-label pairs are present at each point.

                                                                                      theorem TrilinearHT.Auto.groupOutput_pushforward {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] (lab : V → W) (φ : W → ℝ → ℂ) (ε : W → ℝ) (a : V → ℝ → ℂ) (y : ℝ) :
                                                                                      groupOutput φ ε (fun (w : W) (y : ℝ) => ∑ v : V with lab v = w, a v y) y = ∑ v : V, a v y • privateColumnValue φ ε (lab v) y

                                                                                      A group output with pushed-forward coefficients is the sum of the coefficients times the columns of the image labels.

                                                                                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.sum_mainCols_ae {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (l : Fin 4) {Mc : ℕ} (s : List (CatCol bf.Vtx)) {κ' : Type u_1} (T : Finset κ') (u : κ' → ℤ × ℤ) (r : κ' → ℕ) (L : κ' → Finset (bf.Lab ⊕ Fin Mc)) (hL : ∀ q ∈ T, L q ⊆ mainLabels A.G Mc (bf.origCols l) s (u q) (r q)) (β : κ' → bf.Lab ⊕ Fin Mc → ℂ) :
                                                                                      ↑↑(∑ q ∈ T, ∑ v ∈ L q, β q v • mainCol A.G Mc (bf.origCols l) s (u q) v) =ᵐ[MeasureTheory.volume] fun (y : ℝ) => ∑ q ∈ T, ∑ v ∈ L q, (dyadicGridCell A.G (u q).1 (u q).2).indicator (fun (x : ℝ) => β q v) y • privateColumnValue (mainScalar Mc (bf.origCols l) s) (mainWeight Mc (bf.origCols l)) v y

                                                                                      Finite sums of main columns on cells are, as functions, sums of indicator coefficients times the private column values.