Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec124BinaryLocalizationVariation.MainRangeWholeRanges

Trilinear Hilbert transform: mainRange_wholeRanges #

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainRange_wholeRanges {κ : 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} {κ' : Type u_2} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k : ℕ) (T : ι → Finset κ') (u : ι → κ' → ℤ × ℤ) (hu : ∀ (G : ι), ∀ q ∈ T G, u G q ∈ A.cells) (rk hq : ι → κ' → ℕ) (hqH : ∀ (G : ι) (q : κ'), hq G q ≤ fp.Hmax) (w : ι → κ' → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (hw : ∀ (G : ι), ∀ q ∈ T G, w G q ∈ mainRange A.G fp.Mc (bf.origCols l) s (u G q) (rk G q) fun (x : bf.Vtx) => x ∈ fp.K.mask bf.admT A.famVtxBound (grp G) (hq G q) (bf.admAt (u G q))) (hcert : ∀ (G : ι), ∀ q ∈ T G, fp.Cert k (grp G) (u G q)) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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.Lab ⊕ Fin fp.Mc) | ∃ q ∈ T p.1, y ∈ dyadicGridCell A.G (u p.1 q).1 (u p.1 q).2 ∧ p.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s (u p.1 q) (rk p.1 q) (fun (x : bf.Vtx) => x ∈ fp.K.mask bf.admT A.famVtxBound (grp p.1) (hq p.1 q) (bf.admAt (u p.1 q))) d}.card ≤ N) :
‖∑ G : ι, ∑ q ∈ T G, w G q‖ ^ 2 ≤ (1 + τ * ↑N * A.colBudget ^ 2) * ∑ G : ι, ‖∑ q ∈ T G, w G q‖ ^ 2

Blueprint lem:whole-ranges (lines 1777-1789) in vector form on the main columns: group vectors that are sums of elements of main ranges at certified active cells, with the group's ball masks at pads at most H_max, are almost orthogonal across the groups of one color, ‖Σ_G Z_G‖² ≤ (1 + τ N colBudget²) Σ_G ‖Z_G‖², where at most N group-label pairs are present at each point.

noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFamT {κ : 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 global depth family of the ball projections of the slot l for the group G, the ball level j and the pad index p (blueprint line 1859).

Equations
Instances For
    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gBall_eq {κ : 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 : ℤ) :
    fp.gBall l s mb G j h = opAvg fun (p : Fin fp.P) => (fp.ballFamT l s mb G j p).proj h
    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.mainTree_mem {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
    I ∈ (bf.mainTree fp.Mc s mb).cells
    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFamT_cell {κ : 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) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
    (fp.ballFamT l s mb G j p).proj I.1 ∘SL columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯ = cellColumnProjection (bf.mainTree fp.Mc s mb) (fp.ballMaskT l s mb G j p) ⋯

    At an active cell the ball depth projection after the restriction to the cell is the cell projection of the main tree.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.relabel_ballCell {κ : 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) {I : ℤ × ℤ} (hI : I ∈ A.cells) (z : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    (colRelabel (bf.rv fp.Mc s)) ((cellColumnProjection (bf.mainTree fp.Mc s mb) (fp.ballMaskT l s mb G j p) ⋯) z) = (mainProj A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I G j (↑p + 1))) ((colRelabel (bf.rv fp.Mc s)) z)

    The relabeled ball cell projection is the main ball projection of the cell.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFamT_interval_decomp {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (hanc : A.AncClosed) (G : bf.Grp) (j : ℕ) (p : Fin fp.P) {hr ht : ℤ} (hR1 : A.R.1 ≤ hr) (hrt : hr ≤ ht) (Ec : Finset (ℤ × ℤ)) (hEc : ∀ I ∈ Ec, I ∈ A.cells ∧ I.1 = ht) (y : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    (colRelabel (bf.rv fp.Mc s)) (((fp.ballFamT l s mb G j p).proj ht - (fp.ballFamT l s mb G j p).proj hr) ((columnL2Restriction (⋃ I ∈ Ec, dyadicGridCell A.G I.1 I.2) ⋯) y)) = ∑ I ∈ Ec, ((mainProj A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I G j (↑p + 1))) ((colRelabel (bf.rv fp.Mc s)) y) - (mainProj A.G fp.Mc (bf.origCols l) s (ancAt A.G I hr) (fp.brank j) (fp.bmask (ancAt A.G I hr) G j (↑p + 1))) ((colRelabel (bf.rv fp.Mc s)) ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) y)))

    The relabeled ball rows of one interval on a union of active right-endpoint cells: the sum over the cells of the main ball projection at the cell minus the main ball projection at its left-endpoint ancestor applied to the cell restriction.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFamT_right_decomp {κ : 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) {ht : ℤ} (Ec : Finset (ℤ × ℤ)) (hEc : ∀ I ∈ Ec, I ∈ A.cells ∧ I.1 = ht) (y : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    (colRelabel (bf.rv fp.Mc s)) (((fp.ballFamT l s mb G j p).proj ht) ((columnL2Restriction (⋃ I ∈ Ec, dyadicGridCell A.G I.1 I.2) ⋯) y)) = ∑ I ∈ Ec, (mainProj A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I G j (↑p + 1))) ((colRelabel (bf.rv fp.Mc s)) y)

    The relabeled right-endpoint ball rows on a union of active cells of their depth.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_wr1 {κ : 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) (mb : bf.MainBudget s) (hanc : A.AncClosed) {ι : Type u_1} {ι' : Type u_2} [Fintype ι] [Fintype ι'] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (r t : ι' → ℕ) (hrt : ∀ (i : ι'), r i ≤ t i) (Ec : ι → ι' → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, I ∈ A.cells ∧ I.1 = A.R.1 + ↑(t i)) (hcert : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (p : Fin fp.P) (x : ι × ι' → ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    ‖∑ q : ι × ι', (ContinuousLinearMap.adjoint (columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL ((fp.ballFamT l s mb (grp q.1) j p).proj (A.R.1 + ↑(t q.2)) - (fp.ballFamT l s mb (grp q.1) j p).proj (A.R.1 + ↑(r q.2))))) (x q)‖ ^ 2 ≤ (1 + τ * ↑N * A.colBudget ^ 2) * ∑ G : ι, ‖∑ q : ι × ι' with q.1 = G, (ContinuousLinearMap.adjoint (columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL ((fp.ballFamT l s mb (grp q.1) j p).proj (A.R.1 + ↑(t q.2)) - (fp.ballFamT l s mb (grp q.1) j p).proj (A.R.1 + ↑(r q.2))))) (x q)‖ ^ 2

    eq:whole-ranges for the interval rows of the variation on the main columns (blueprint lines 1875: "their adjoints lie in sums of whole ball ranges at the two endpoints; a right certificate certifies every needed earlier endpoint ... Lemma whole-ranges makes the rows jointly Bessel across groups").

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_wr2 {κ : 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) (mb : bf.MainBudget s) {ι : Type u_1} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ht : ℤ) (Ec : ι → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι), ∀ I ∈ Ec G, I ∈ A.cells ∧ I.1 = ht) (hcert : ∀ (G : ι), ∀ I ∈ Ec G, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (p : Fin fp.P) (x : ι → ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    ‖∑ G : ι, (ContinuousLinearMap.adjoint (columnL2Restriction (⋃ I ∈ Ec G, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.ballFamT l s mb (grp G) j p).proj ht)) (x G)‖ ^ 2 ≤ (1 + τ * ↑N * A.colBudget ^ 2) * ∑ G : ι, ‖∑ G' : ι with G' = G, (ContinuousLinearMap.adjoint (columnL2Restriction (⋃ I ∈ Ec G', dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.ballFamT l s mb (grp G') j p).proj ht)) (x G')‖ ^ 2

    eq:whole-ranges for the outer ball rows at a common right endpoint on the main columns (blueprint line 1877: "sum the outer ball rows at each common right endpoint using eq:whole-ranges").

    theorem TrilinearHT.Auto.ActiveSetup.restrict_union_vanish' {κ : LocalKernelClass} {c₀ : ℕ} (A : ActiveSetup κ c₀) {V : Type u_1} [Fintype V] (Ec : Finset (ℤ × ℤ)) (hEc : ∀ I ∈ Ec, I ∈ A.cells) (v : ↥(ColumnL2 V)) :
    ∀ᵐ (y : ℝ), y ∉ dyadicGridCell A.G A.R.1 A.R.2 → ↑↑((columnL2Restriction (⋃ I ∈ Ec, dyadicGridCell A.G I.1 I.2) ⋯) v) y = 0

    The restriction to a union of cells of the setup vanishes off the root.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_blk {κ : 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) {hr ht : ℤ} (hrt : hr ≤ ht) (Ec : Finset (ℤ × ℤ)) (hEc : ∀ I ∈ Ec, I ∈ A.cells) (x : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    ‖(columnL2Restriction (⋃ I ∈ Ec, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL ((fp.ballFamT l s mb G j p).proj ht - (fp.ballFamT l s mb G j p).proj hr)) x‖ ^ 2 = ∑ Q : ↥((bf.mainBase fp.Mc s mb).partition hr).cells, ‖(columnL2Restriction (⋃ I ∈ Ec, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL ((fp.ballFamT l s mb G j p).proj ht - (fp.ballFamT l s mb G j p).proj hr)) ((columnL2Restriction (dyadicGridCell A.G (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2

    The interval rows of the variation split orthogonally over the depth partition of the main tree at the left depth.

    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_variation {κ : 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) (mb : bf.MainBudget s) (hanc : A.AncClosed) {ι : Type u_1} {ι' : Type u_2} [Fintype ι] [Fintype ι'] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (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'))) (Ec : ι → ι' → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, I ∈ A.cells ∧ I.1 = A.R.1 + ↑(t i)) (hcert : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (z : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
    ∑ q : ι × ι', ‖(columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gBall l s mb (grp q.1) j (A.R.1 + ↑(t q.2))) ((fp.gHist l s mb ls (A.R.1 + ↑(t q.2))) z) - (fp.gBall l s mb (grp q.1) j (A.R.1 + ↑(r q.2))) ((fp.gHist l s mb ls (A.R.1 + ↑(r q.2))) z))‖ ^ 2 ≤ 2 * (1 + τ * ↑N * A.colBudget ^ 2) * (compressionC (bf.mainTree fp.Mc s mb) ls.length ^ 2 * ‖z‖ ^ 2 + (↑ls.length * ∑ m ∈ Finset.range ls.length, compressionC (bf.mainTree fp.Mc s mb) m ^ 2) * ‖z‖ ^ 2)

    Blueprint lem:variation (eq:variation, lines 1861-1877) on the main columns for one ball level and color of the attempt, with a common input z: the global ball outputs Z_{G,s} = L_{G,s} B'_s z of the groups, restricted at the right endpoints to unions of certified active cells, have square-summable variation over disjoint depth intervals, Σ_{G,[r,t]} ‖1_E (Z_{G,t} - Z_{G,r})‖² ≤ 2 (1 + τ N colBudget²) (C_{|ls|}² + |ls| Σ_m C_m²) ‖z‖² with the complement compression constants C_m of the main tree.

    theorem TrilinearHT.Auto.emb_insert {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {ι : Type u_3} {F : Type u_4} [Fintype ι] [NormedAddCommGroup F] [NormedSpace ℂ F] (Ψ : ColumnDepthFamily V) (E : ↥(ColumnL2 V) →L[ℂ] ↥(ColumnL2 W)) (hE : ∀ (x : ↥(ColumnL2 V)), ‖E x‖ ≤ ‖x‖) (hEr : ∀ (s : Set ℝ) (hs : MeasurableSet s) (x : ↥(ColumnL2 V)), E ((columnL2Restriction s hs) x) = (columnL2Restriction s hs) (E x)) (d : ι → ℤ) (R : ι → ↥(ColumnL2 W) →L[ℂ] F) {B : ℝ} (hB : 0 ≤ B) (hR : ∀ (x : ↥(ColumnL2 W)), ∑ i : ι, ‖(R i) x‖ ^ 2 ≤ B * ‖x‖ ^ 2) (hblk : ∀ (i : ι) (x : ↥(ColumnL2 W)), ‖(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) (E ((Ψ.proj (d i)) Z))‖ ^ 2 ≤ B * compressionC Ψ.D 1 ^ 2 * ‖Z‖ ^ 2

    Blueprint lines 1859, 1879 for a rank-zero innermost factor: rows that are Bessel for all inputs and split orthogonally over the cells of the depth partition of a basic column family remain Bessel after inserting its depth projection through a contraction commuting with restrictions, at the cost of one compression constant.

    theorem TrilinearHT.Auto.emb_variation {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {ι : Type u_3} [Fintype ι] (Ψ : ColumnDepthFamily V) (E : ↥(ColumnL2 V) →L[ℂ] ↥(ColumnL2 W)) (hE : ∀ (x : ↥(ColumnL2 V)), ‖E x‖ ≤ ‖x‖) (hEr : ∀ (s : Set ℝ) (hs : MeasurableSet s) (x : ↥(ColumnL2 V)), E ((columnL2Restriction s hs) x) = (columnL2Restriction s hs) (E x)) (S : ι → ↥(ColumnL2 W) →L[ℂ] ↥(ColumnL2 W)) (T : ι → ℤ → ↥(ColumnL2 W) →L[ℂ] ↥(ColumnL2 W)) (r t : ι → ℤ) {B : ℝ} (hB : 0 ≤ B) (hrows : ∀ (x : ↥(ColumnL2 W)), ∑ i : ι, ‖(S i) ((T i (t i) - T i (r i)) x)‖ ^ 2 ≤ B * ‖x‖ ^ 2) (hblk : ∀ (i : ι) (x : ↥(ColumnL2 W)), ‖(S i) ((T i (t i) - T i (r i)) x)‖ ^ 2 = ∑ Q : ↥(Ψ.partition (r i)).cells, ‖(S i) ((T i (t i) - T i (r i)) ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x))‖ ^ 2) (Z : ↥(ColumnL2 V)) {J : ℝ} (hjoint : ∑ i : ι, ‖(S i) ((T i (t i)) (E ((Ψ.proj (t i) - Ψ.proj (r i)) Z)))‖ ^ 2 ≤ J) :
    ∑ i : ι, ‖(S i) ((T i (t i)) (E ((Ψ.proj (t i)) Z)) - (T i (r i)) (E ((Ψ.proj (r i)) Z)))‖ ^ 2 ≤ 2 * (B * compressionC Ψ.D 1 ^ 2 * ‖Z‖ ^ 2) + 2 * J

    Blueprint lem:variation (eq:variation) for histories acting on a rank-zero basic projection through a contraction commuting with restrictions: if the history rows S_i (T_i(t_i) - T_i(r_i)) are Bessel for all inputs and split over the basic partition at the left depths, then the variation of the outputs T_i(h) (E P_h Z) is bounded by the compressed row constant plus the joint size J of the outputs on the jumps of the basic projections.

    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.famEmbR {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (l : Fin 4) (j : Fin 2) :
    ↥(ColumnL2 (bf.P l j).V) →L[ℂ] ↥(ColumnL2 (bf.RLab Mc s))

    The embedding of the basic family (l, j) into the relevant main labels: the basic column embedding followed by the adjoint of the relabeling.

    Equations
    Instances For
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.norm_famEmbR_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (l : Fin 4) (j : Fin 2) (x : ↥(ColumnL2 (bf.P l j).V)) :
      ‖(bf.famEmbR Mc s l j) x‖ ≤ ‖x‖
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.famEmbR_restrict {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} (bf : A.BasicFamilies) (Mc : ℕ) (s : List (CatCol bf.Vtx)) (l : Fin 4) (j : Fin 2) (S : Set ℝ) (hS : MeasurableSet S) (x : ↥(ColumnL2 (bf.P l j).V)) :
      (bf.famEmbR Mc s l j) ((columnL2Restriction S hS) x) = (columnL2Restriction S hS) ((bf.famEmbR Mc s l j) x)
      noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gOut {κ : 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 : ℕ) (ls : List (ℕ × Bool)) (h : ℤ) :
      ↥(ColumnL2 (bf.RLab fp.Mc s)) →L[ℂ] ↥(ColumnL2 (bf.RLab fp.Mc s))

      The global ball output of the slot l for the group G at the ball level j and the depth h: the global ball filter after the global shared history (blueprint lines 1859, 1871: Z_{G,h} = L_{G,h} B'_h).

      Equations
      Instances For
        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gOut_commute {κ : 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 : ℕ) (ls : List (ℕ × Bool)) (h : ℤ) {Q : ℤ × ℤ} (hQ : Q.1 ≤ (bf.mainBase fp.Mc s mb).depth h) :
        columnL2Restriction (dyadicGridCell A.G Q.1 Q.2) ⋯ ∘SL fp.gOut l s mb G j ls h = fp.gOut l s mb G j ls h ∘SL columnL2Restriction (dyadicGridCell A.G Q.1 Q.2) ⋯

        The global ball outputs at depth h commute with the restriction to every dyadic cell of depth at most the clamped depth h.

        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gOut_rows_blk {κ : 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 : ℕ) (ls : List (ℕ × Bool)) {hr ht : ℤ} (hrt : hr ≤ ht) (htd : ht ≤ A.R.1 + ↑A.treeDepth) (E : Finset (ℤ × ℤ)) (hE : ∀ I ∈ E, I ∈ A.cells) {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) (hΨG : Ψ.D.grid = A.G) (hΨR : dyadicGridCell A.G A.R.1 A.R.2 ⊆ dyadicGridCell A.G Ψ.D.root.1 Ψ.D.root.2) (hΨr : Ψ.D.root.1 ≤ A.R.1) (hRr : A.R.1 ≤ hr) (x : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
        ‖(columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.gOut l s mb G j ls ht - fp.gOut l s mb G j ls hr)) x‖ ^ 2 = ∑ Q : ↥(Ψ.partition hr).cells, ‖(columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.gOut l s mb G j ls ht - fp.gOut l s mb G j ls hr)) ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2

        The restricted jump rows of the global ball outputs between two depths split orthogonally over the depth partition of a basic family at the left depth.

        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_joint {κ : 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) (mb : bf.MainBudget s) {ι : Type u_1} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (ht : ℤ) (Ec : ι → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι), ∀ I ∈ Ec G, I ∈ A.cells ∧ I.1 = ht) (hcert : ∀ (G : ι), ∀ I ∈ Ec G, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (w : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
        ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gOut l s mb (grp G) j ls ht) w)‖ ^ 2 ≤ (1 + τ * ↑N * A.colBudget ^ 2) * ‖w‖ ^ 2

        Blueprint eq:whole-ranges (line 1875) for the global ball outputs of one depth: the outputs of the groups, restricted to unions of certified cells of that depth, are jointly Bessel with constant 1 + τ N colBudget².

        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.main_variation_basic {κ : 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) (mb : bf.MainBudget s) (hanc : A.AncClosed) {ι : Type u_1} {ι' : Type u_2} [Fintype ι] [Fintype ι'] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (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'))) (htd : ∀ (i : ι'), t i ≤ A.treeDepth) (Ec : ι → ι' → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, I ∈ A.cells ∧ I.1 = A.R.1 + ↑(t i)) (hcert : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (jb : Fin 2) (Z : ↥(ColumnL2 (bf.P l jb).V)) :
        ∑ q : ι × ι', ‖(columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gOut l s mb (grp q.1) j ls (A.R.1 + ↑(t q.2))) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj (A.R.1 + ↑(t q.2))) Z)) - (fp.gOut l s mb (grp q.1) j ls (A.R.1 + ↑(r q.2))) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj (A.R.1 + ↑(r q.2))) Z)))‖ ^ 2 ≤ 2 * (2 * (1 + τ * ↑N * A.colBudget ^ 2) * (compressionC (bf.mainTree fp.Mc s mb) ls.length ^ 2 + ↑ls.length * ∑ m ∈ Finset.range ls.length, compressionC (bf.mainTree fp.Mc s mb) m ^ 2) * compressionC (bf.P l jb).Ψ.D 1 ^ 2 * ‖Z‖ ^ 2) + 2 * ((1 + τ * ↑N * A.colBudget ^ 2) * ‖Z‖ ^ 2)

        Blueprint lem:variation (eq:variation, lines 1861-1877) on the main columns for a basic slot and one of its basic families j_b: the histories act on the basic depth projection P_{l,j_b,h} F (the input of the cells of depth h), and the certified variation of the global ball outputs over disjoint depth intervals is bounded by 2 (B C₁² + (1 + τ N colBudget²)) ‖F‖², with B the constant of main_variation and C₁ the one-factor compression constant of the basic tree.

        theorem TrilinearHT.Auto.compressionC_mono {V : Type u_1} [Fintype V] (D : ColumnTreeData V) {m n : ℕ} (hmn : m ≤ n) :

        The complement compression constants increase with the number of factors.

        theorem TrilinearHT.Auto.compression_loss_le' {V : Type u_1} {W : Type u_2} [Fintype V] [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 * compressionC D' 1 ^ 2 ≤ Real.exp (4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) * (1 + Real.log (2 * k)) ^ 2)

        compression_loss_le with the basic projection inserted as a one-layer history.

        theorem TrilinearHT.Auto.variation_loss_le {V : Type u_1} {W : Type u_2} [Fintype V] [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)) {Cw : ℝ} (hCw : Cw ≤ 2) :
        2 * (2 * Cw * (compressionC D n ^ 2 + ↑n * ∑ m ∈ Finset.range n, compressionC D m ^ 2) * compressionC D' 1 ^ 2) + 2 * Cw ≤ Real.exp ((4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) + ↑c ^ 2 + 3) * (1 + Real.log (2 * k)) ^ 2)

        Blueprint lem:variation, "the compression loss is G₀" (lines 1859, 1877: "the O(log L) terms, signed expansions and averages are absorbed in G₀"): the constant of main_variation_basic for histories of length n ≤ c (log k + 1), column budgets with log (2 budget) ≤ k^c and a whole-range constant at most 2 is at most G₀ = exp(C_q (1 + log 2k)^2), C_q = 4096 (c+1) (1024 (c+1) + c + 7) + c² + 3.

        noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basicOut {κ : 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 : ℕ) (ls : List (ℕ × Bool)) (h : ℤ) :
        ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

        The global coarse output of a basic slot (blueprint eq:localized, lines 1841, 1859): the global ball output of the group at the depth h acting on the global basic input, in the main column space. Its restriction to an active cell of depth h is the leaf output (basic_leaf_out).

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basicOut_eq {κ : 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 : ℕ) (ls : List (ℕ × Bool)) (h : ℤ) :
          fp.basicOut l s mb G j ls h = (colRelabel (bf.rv fp.Mc s)) ((fp.gOut l s mb G j ls h) ((bf.famEmbR fp.Mc s l 0) (((bf.P l 0).Ψ.proj h) (bf.P l 0).Z)) - (fp.gOut l s mb G j ls h) ((bf.famEmbR fp.Mc s l 1) (((bf.P l 1).Ψ.proj h) (bf.P l 1).Z)))
          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basicOut_restrict {κ : 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 : ℕ) (ls : List (ℕ × Bool)) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
          (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls I.1) = (fp.ballFilt l s I G j) ((layerOp (fun (m : ℕ) => fp.cumFilt l s I m) ls) (bf.basicIn fp.Mc l I))

          The restriction of the basic coarse output to an active cell of its depth is the leaf output L_{l,G,s} B_{l,s} B_l of the cell (blueprint eq:localized and line 1859).

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.famN_ge {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (hne : A.cells.Nonempty) (l : Fin 4) (jb : Fin 2) :
          A.R.1 ≤ (bf.P l jb).Ψ.N

          The basic families reach the depth of the attempt root.

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.out_restrictR {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hne : A.cells.Nonempty) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (jb : Fin 2) {h : ℤ} (hRh : A.R.1 ≤ h) (E : Finset (ℤ × ℤ)) (hE : ∀ I ∈ E, I ∈ A.cells) (Z : ↥(ColumnL2 (bf.P l jb).V)) :
          (columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gOut l s mb G j ls h) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj h) Z))) = (columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gOut l s mb G j ls h) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj h) ((columnL2Restriction (dyadicGridCell A.G A.R.1 A.R.2) ⋯) Z))))

          On unions of active cells, the global ball outputs of a basic family depend only on the restriction of the family input to the attempt root (blueprint line 1865: ‖1_R F‖).

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_variation {κ : 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) (mb : bf.MainBudget s) (hanc : A.AncClosed) (hne : A.cells.Nonempty) {ι : Type u_1} {ι' : Type u_2} [Fintype ι] [Fintype ι'] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (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'))) (htd : ∀ (i : ι'), t i ≤ A.treeDepth) (Ec : ι → ι' → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, I ∈ A.cells ∧ I.1 = A.R.1 + ↑(t i)) (hcert : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) :
          ∑ q : ι × ι', ‖(columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb (grp q.1) j ls (A.R.1 + ↑(t q.2)) - fp.basicOut l s mb (grp q.1) j ls (A.R.1 + ↑(r q.2)))‖ ^ 2 ≤ ∑ jb : Fin 2, 2 * (2 * (2 * (1 + τ * ↑N * A.colBudget ^ 2) * (compressionC (bf.mainTree fp.Mc s mb) ls.length ^ 2 + ↑ls.length * ∑ m ∈ Finset.range ls.length, compressionC (bf.mainTree fp.Mc s mb) m ^ 2) * compressionC (bf.P l jb).Ψ.D 1 ^ 2) + 2 * (1 + τ * ↑N * A.colBudget ^ 2)) * ‖(columnL2Restriction (dyadicGridCell A.G A.R.1 A.R.2) ⋯) (bf.P l jb).Z‖ ^ 2

          Blueprint lem:variation (eq:variation, lines 1861-1877) on the main columns for a basic coarse output: for depth intervals [r_i, t_i] (offsets below the attempt root) that are disjoint, and unions E_{G,i} of active cells of depth t_i carrying downstream actual-use certificates of G, Σ_{G,i} ‖1_E (Z_{G,t_i} - Z_{G,r_i})‖² ≤ Σ_{j_b} 2 V_{j_b} ‖1_R F_{l,j_b}‖², where Z_{G,h} = L_{G,h} B'_h B_l is the global coarse output (basicOut) and V_{j_b} = 2 (2 C_w S) C_{1,j_b}² + 2 C_w with the whole-range constant C_w = 1 + τ N colBudget², the history compression sum S and the one-factor compression constant C_{1,j_b} of the basic tree.

          theorem TrilinearHT.Auto.sum_le_of_coloring {ι' : Type u_1} [Fintype ι'] {M : ℕ} (col : ι' → Fin M) (f : ι' → ℝ) {B : ℝ} (hB : ∀ (c : Fin M), ∑ i : ι' with col i = c, f i ≤ B) :
          ∑ i : ι', f i ≤ ↑M * B

          Sums over a finite family colored with M colors are at most M times a bound valid on every color class (blueprint line 1877: "color the depth intervals to handle bounded overlap").

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gHist_commute {κ : 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 : ℤ) {Q : ℤ × ℤ} (hQ : Q.1 ≤ (bf.mainBase fp.Mc s mb).depth h) :
          columnL2Restriction (dyadicGridCell A.G Q.1 Q.2) ⋯ ∘SL fp.gHist l s mb ls h = fp.gHist l s mb ls h ∘SL columnL2Restriction (dyadicGridCell A.G Q.1 Q.2) ⋯

          The global shared histories commute with the restriction to every dyadic cell of depth at most the clamped depth.

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.gHist_rows_blk {κ : 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)) {hr ht : ℤ} (hrt : hr ≤ ht) (htd : ht ≤ A.R.1 + ↑A.treeDepth) (E : Finset (ℤ × ℤ)) (hE : ∀ I ∈ E, I ∈ A.cells) {V : Type u_1} [Fintype V] (Ψ : ColumnDepthFamily V) (hΨG : Ψ.D.grid = A.G) (hΨR : dyadicGridCell A.G A.R.1 A.R.2 ⊆ dyadicGridCell A.G Ψ.D.root.1 Ψ.D.root.2) (hΨr : Ψ.D.root.1 ≤ A.R.1) (hRr : A.R.1 ≤ hr) (x : ↥(ColumnL2 (bf.RLab fp.Mc s))) :
          ‖(columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.gHist l s mb ls ht - fp.gHist l s mb ls hr)) x‖ ^ 2 = ∑ Q : ↥(Ψ.partition hr).cells, ‖(columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯ ∘SL (fp.gHist l s mb ls ht - fp.gHist l s mb ls hr)) ((columnL2Restriction (dyadicGridCell Ψ.D.grid (↑Q).1 (↑Q).2) ⋯) x)‖ ^ 2

          The restricted jump rows of the global shared histories split orthogonally over the depth partition of a basic family at the left depth.

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.hist_restrictR {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (hne : A.cells.Nonempty) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (ls : List (ℕ × Bool)) (jb : Fin 2) {h : ℤ} (hRh : A.R.1 ≤ h) (E : Finset (ℤ × ℤ)) (hE : ∀ I ∈ E, I ∈ A.cells) (Z : ↥(ColumnL2 (bf.P l jb).V)) :
          (columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gHist l s mb ls h) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj h) Z))) = (columnL2Restriction (⋃ I ∈ E, dyadicGridCell A.G I.1 I.2) ⋯) ((fp.gHist l s mb ls h) ((bf.famEmbR fp.Mc s l jb) (((bf.P l jb).Ψ.proj h) ((columnL2Restriction (dyadicGridCell A.G A.R.1 A.R.2) ⋯) Z))))

          On unions of active cells, the global shared histories of a basic family depend only on the restriction of the family input to the attempt root.

          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.histOut {κ : 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.Lab ⊕ Fin fp.Mc))

          The global shared history of a basic slot acting on its global basic input, in the main column space; its restriction to an active cell of depth h is B_{l,s} B_l (basic_history).

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_history_variation {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (hne : A.cells.Nonempty) {ι' : Type u_1} [Fintype ι'] (ls : List (ℕ × Bool)) (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'))) (htd : ∀ (i : ι'), t i ≤ A.treeDepth) (Ec : ι' → Finset (ℤ × ℤ)) (hEc : ∀ (i : ι'), ∀ I ∈ Ec i, I ∈ A.cells) :
            ∑ i : ι', ‖(columnL2Restriction (⋃ I ∈ Ec i, dyadicGridCell A.G I.1 I.2) ⋯) (fp.histOut l s mb ls (A.R.1 + ↑(t i)) - fp.histOut l s mb ls (A.R.1 + ↑(r i)))‖ ^ 2 ≤ ∑ jb : Fin 2, 2 * (2 * ((↑ls.length * ∑ m ∈ Finset.range ls.length, compressionC (bf.mainTree fp.Mc s mb) m ^ 2) * compressionC (bf.P l jb).Ψ.D 1 ^ 2) + 2) * ‖(columnL2Restriction (dyadicGridCell A.G A.R.1 A.R.2) ⋯) (bf.P l jb).Z‖ ^ 2

            Blueprint lem:variation, shared-history assertion ("without an outer ball the same assertion holds for a shared history, omitting G"): over disjoint depth intervals and unions E_i of active cells of depth t_i, Σ_i ‖1_{E_i} (B'_{t_i} B_l - B'_{r_i} B_l)‖² ≤ Σ_{j_b} 2 (2 S C_{1,j_b}² + 2) ‖1_R F_{l,j_b}‖² with S = |ls| Σ_m C_m² the history jump constant.

            The basic inputs have energy at most |R| on the root: ‖1_R F_{l,j}‖² ≤ |R| (blueprint line 2075: ‖F_l‖₂² ≤ |R|).

            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_onetime {κ : 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) (mb : bf.MainBudget s) (hne : A.cells.Nonempty) {ι : Type u_1} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (t : ℕ) (Ec : ι → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι), ∀ I ∈ Ec G, I ∈ A.cells ∧ I.1 = A.R.1 + ↑t) (hcert : ∀ (G : ι), ∀ I ∈ Ec G, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) :
            ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G, dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb (grp G) j ls (A.R.1 + ↑t))‖ ^ 2 ≤ ∑ jb : Fin 2, 2 * (1 + τ * ↑N * A.colBudget ^ 2) * ‖(columnL2Restriction (dyadicGridCell A.G A.R.1 A.R.2) ⋯) (bf.P l jb).Z‖ ^ 2

            Blueprint lem:variation, intervals crossing the attempt start: with the zero convention the outputs before the attempt vanish, so such an interval contributes the one-time projection estimate at its right endpoint, Σ_G ‖1_{E_G} Z_{G,t}‖² ≤ Σ_{j_b} 2 (1 + τ N colBudget²) ‖1_R F_{l,j_b}‖².

            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_variation_G0 {κ : 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) (mb : bf.MainBudget s) (hanc : A.AncClosed) (hne : A.cells.Nonempty) {ι : Type u_1} {ι' : Type u_2} [Fintype ι] [Fintype ι'] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (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'))) (htd : ∀ (i : ι'), t i ≤ A.treeDepth) (Ec : ι → ι' → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, I ∈ A.cells ∧ I.1 = A.R.1 + ↑(t i)) (hcert : ∀ (G : ι) (i : ι'), ∀ I ∈ Ec G i, fp.Cert k (grp G) I) {ra rb : ℝ} (hroot : ∀ I ∈ A.cells, 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 : ℝ), {q : ι × (bf.Lab ⊕ Fin fp.Mc) | ∃ I ∈ A.cells, (∃ (k' : ℕ), fp.Cert k' (grp q.1) I) ∧ ∃ (p : Fin fp.P), y ∈ dyadicGridCell A.G I.1 I.2 ∧ q.2 ∈ mainLabelsM A.G fp.Mc (bf.origCols l) s I (fp.brank j) (fp.bmask I (grp q.1) j (↑p + 1)) d}.card ≤ N) (hτN : τ * ↑N * A.colBudget ^ 2 ≤ 1) (c : ℕ) (hc : 1 ≤ c) {kk : ℝ} (hk : 1 ≤ kk) (hDm : Real.log (2 * mb.B) ≤ kk ^ c) (hDb : Real.log (2 * A.colBudget) ≤ kk ^ c) (hn : ↑ls.length ≤ ↑c * (Real.log kk + 1)) :
            ∑ q : ι × ι', ‖(columnL2Restriction (⋃ I ∈ Ec q.1 q.2, dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb (grp q.1) j ls (A.R.1 + ↑(t q.2)) - fp.basicOut l s mb (grp q.1) j ls (A.R.1 + ↑(r q.2)))‖ ^ 2 ≤ Real.exp ((4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) + ↑c ^ 2 + 3) * (1 + Real.log (2 * kk)) ^ 2) * (4 * dyadicGridLength A.G A.R.1)

            Blueprint lem:variation (eq:variation, lines 1861-1866) with the compression loss G₀: under log (2 D_m) ≤ k^c, log (2 colBudget) ≤ k^c, histories of O(log k) layers and a pair threshold with τ N colBudget² ≤ 1 (chosen after the counts, line 1854), Σ_{G,[r,t]} ‖1_E (Z_{G,t} - Z_{G,r})‖² ≤ G₀ Σ_{j_b} 2 ‖1_R F_{l,j_b}‖² ≤ 4 G₀ |R| with G₀ = exp(C_q (1 + log 2k)²).