Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec134SideStatesFixedOffsets

Section 13.4: Side states and fixed offsets #

This file was automatically generated by Claude.

Formalization of blueprint Section 13, "Fixed modes, the linear side, and hereditary representatives" (sec:modes), subsection 4, "Side states and fixed offsets" (lines 2123-2170) of blueprint/formalization_blueprint.tex.

Side states and fixed offsets (blueprint lines 2123-2166) #

theorem TrilinearHT.Auto.physical_error_sq_le {ι : Type u_1} (s : Finset ι) (z : ℝ) (Zp : ℂ) (β q : ι → ℂ) {δ S : ℝ} (hq : ∀ i ∈ s, ‖q i‖ ≤ δ) (hβ : ∑ i ∈ s, ‖β i‖ ≤ S) (hδ : 0 ≤ δ) :
‖↑(1 - z ^ 2) * Zp - ∑ i ∈ s, β i * q i‖ ^ 2 ≤ 2 * |1 - z ^ 2| ^ 2 * ‖Zp‖ ^ 2 + 2 * δ ^ 2 * S ^ 2

Blueprint line 2133: the physical error E = (1 - ζ²) Z_phys - Σ_Φ β_Φ q_Φ with |q_Φ| ≤ δ_c and Σ |β_Φ| ≤ S satisfies |E|² ≤ 2 |1 - ζ²|² |Z_phys|² + 2 δ_c² S².

theorem TrilinearHT.Auto.majorant_offset_mean {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (hdδ : 8 * ↑d * δ ≤ 1) (hδ' : δ ≤ 1 / 8) (u : Fin d → ℝ) (Z K : ℝ) :
∫ (ρ : Fin d → ℝ), 2 * |1 - branchCutoffValue δ ρ u ^ 2| ^ 2 * Z + 2 * δ ^ 2 * K ∂offsetMeasure d ≤ 8 * ↑d * δ * |Z| + 2 * δ ^ 2 * K

Blueprint lines 2135-2139: for each point, the offset mean of the majorant B(ρ, y) = 2 |1 - ζ^ρ(y)²|² |Z(y)|² + 2 δ_c² K is at most 8 d δ_c |Z(y)|² + 2 δ_c² K (by offsetMean).

The physical error of the frozen lift and its offset majorant (lines 2125-2139) #

Selection of the branch offsets (blueprint lines 2135-2140) #

theorem TrilinearHT.Auto.offsetMeasure_coord_null (d : ℕ) (j : Fin d) :
(offsetMeasure d) {r : Fin d → ℝ | r j ∉ Set.Icc 0 1} = 0
theorem TrilinearHT.Auto.exists_offsets_le {ι : Type u_1} [Fintype ι] (d : ι → ℕ) (G : (i : ι) → (Fin (d i) → ℝ) → ENNReal) (hG : ∀ (i : ι), Measurable (G i)) :
∃ (ρ : (i : ι) → Fin (d i) → ℝ), (∀ (i : ι) (j : Fin (d i)), ρ i j ∈ Set.Icc 0 1) ∧ ∑ i : ι, G i (ρ i) ≤ ∑ i : ι, ∫⁻ (r : Fin (d i) → ℝ), G i r ∂offsetMeasure (d i)

Blueprint lines 2135-2140 (first moment): for finitely many independent uniform offsets and measurable nonnegative majorants, some choice of offsets in the unit cubes makes the total majorant at most its expectation.

theorem TrilinearHT.Auto.branchCutoffValue_measurable_joint {d : ℕ} (δ : ℝ) (θ : Fin d → ℝ) :
Measurable fun (p : (Fin d → ℝ) × ℝ) => branchCutoffValue δ p.1 fun (i : Fin d) => θ i * p.2
theorem TrilinearHT.Auto.majorant_offset_lintegral {d : ℕ} {δ : ℝ} (hδ : 0 < δ) (hdδ : 8 * ↑d * δ ≤ 1) (hδ' : δ ≤ 1 / 8) (u : Fin d → ℝ) {Z K : ℝ} (hZ : 0 ≤ Z) (hK : 0 ≤ K) :
∫⁻ (ρ : Fin d → ℝ), ENNReal.ofReal (2 * |1 - branchCutoffValue δ ρ u ^ 2| ^ 2 * Z + 2 * δ ^ 2 * K) ∂offsetMeasure d ≤ ENNReal.ofReal (8 * ↑d * δ * Z + 2 * δ ^ 2 * K)

majorant_offset_mean as a lower integral.

theorem TrilinearHT.Auto.exists_offsets_physical {ι : Type u_1} {κ : Type u_2} [Fintype ι] (zc : ι → ChartTag) {δ : ℝ} (hδ : 0 < δ) (hδ' : δ ≤ 1 / 8) (hdδ : ∀ (i : ι), 8 * ↑(zc i).dim * δ ≤ 1) (U : ι → Finset κ) (Iset : ι → κ → Set ℝ) (hI : ∀ (i : ι) (k : κ), MeasurableSet (Iset i k)) (Zf : ι → κ → ℝ → ℝ) (hZm : ∀ (i : ι) (k : κ), Measurable (Zf i k)) (hZ0 : ∀ (i : ι) (k : κ) (y : ℝ), 0 ≤ Zf i k y) {K : ℝ} (hK : 0 ≤ K) :
∃ (ρ : (i : ι) → Fin (zc i).dim → ℝ), (∀ (i : ι) (j : Fin (zc i).dim), ρ i j ∈ Set.Icc 0 1) ∧ ∑ i : ι, ∑ k ∈ U i, ∫⁻ (y : ℝ) in Iset i k, ENNReal.ofReal (2 * |1 - centerCut (zc i) δ (ρ i) y ^ 2| ^ 2 * Zf i k y + 2 * δ ^ 2 * K) ≤ ∑ i : ι, ∑ k ∈ U i, ∫⁻ (y : ℝ) in Iset i k, ENNReal.ofReal (8 * ↑(zc i).dim * δ * Zf i k y + 2 * δ ^ 2 * K)

Blueprint lines 2135-2147 (eq:physical-error before the domination): there are offsets in the unit cubes for which the total majorant Σ_i Σ_k ∫_{I_k} (2|1 - ζ_i²|² Z_k + 2δ²K) is at most Σ_i Σ_k ∫_{I_k} (8 d_i δ Z_k + 2 δ² K).

Side caps from integrated budgets (blueprint lines 2159-2166, eq:side-cap) #

theorem TrilinearHT.Auto.side_caps_of_budgets (G : RealDyadicGrid) (S : Finset (ℤ × ℤ)) {ν : Type u_1} [Fintype ν] (a : ν → ℤ × ℤ → ℝ) (ha : ∀ (v : ν), ∀ c ∈ S, 0 ≤ a v c) (root : ℤ × ℤ) (hroot : ∀ c ∈ S, dyadicGridCell G c.1 c.2 ⊆ dyadicGridCell G root.1 root.2) (A : ν → ℝ) (hW : ∀ (v : ν), dyadicWeightedMass G S (a v) ≤ A v * dyadicGridLength G root.1) {ρ : ℝ} (hρ : 0 < ρ) (hρ1 : ρ < 1) :
dyadicRootLength G (dyadicFirstCrossings G S (fun (c : ℤ × ℤ) => ∑ v : ν, a v c) ((∑ v : ν, A v) / ρ)) ≤ ρ * dyadicGridLength G root.1 ∧ ∀ (x : ℝ), dyadicRealPathSum G (dyadicRetainedCells G S (fun (c : ℤ × ℤ) => ∑ v : ν, a v c) ((∑ v : ν, A v) / ρ)) (fun (c : ℤ × ℤ) => ∑ v : ν, a v c) x ≤ (∑ v : ν, A v) / ρ

Blueprint eq:side-cap via lem:cuts: finitely many families of nonnegative cell weights with integrated budgets Σ_I |I| a_ν(I) ≤ A_ν |R| are capped simultaneously by one first-crossing cut at (Σ_ν A_ν)/ρ, of total length at most ρ |R|.

Expansion of catalog outputs into columns (blueprint lemma coeff, lines 488-497) #

Helper instantiation on whole side states (blueprint lines 2167-2169) #

Cores, sides and errors in the active form (blueprint lines 2461-2462, 2845-2848) #

def TrilinearHT.Auto.patternPiece {V : Type u_1} (a s e : Fin 4 → V) (σ : Fin 4 → Fin 3) :
Fin 4 → V

The pattern piece: slot l takes the core part (0), the side part (1) or the physical error (2).

Equations
Instances For
    theorem TrilinearHT.Auto.form_pattern_expand {V : Type u_1} [AddCommGroup V] [Module ℂ V] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => V) ℂ) (a s e : Fin 4 → V) :
    (Λ fun (l : Fin 4) => a l + s l + e l) = ∑ σ : Fin 4 → Fin 3, Λ (patternPiece a s e σ)

    Blueprint eq:core-side-error in a 4-linear form: with Z_l = A_l + S_l + E_l, H(Z) = Σ_σ H(pieces σ) over all core/side/error patterns.

    The data of the core-side-error split of the leaf outputs of an attempt (blueprint eq:sides, eq:core-side-error, lines 2120-2135): the block length K, the schedule and side parameters, the mode systems of the slots and groups, the pre-cells of the blocks and the frozen coefficients, and the slots carrying a basic U (whole sides).

    • Numerical height and block schedule for the leaf split.

    • hA : 6 ≤ self.S.A0
    • Side-event and coherence parameters for the leaf split.

    • Ms : Fin 4 → A.Grp → ModeSystem A.G ap.Mc

      Frozen mode system in each slot and group.

    • cells : Fin 4 → A.Grp → ℤ → Finset (ℤ × ℤ)

      Pre-cells assigned to each slot, group and block start.

    • c (l : Fin 4) (G : A.Grp) : ℤ → ℤ × ℤ → (self.Ms l G).Md → ℂ

      Frozen coefficient of each mode on a pre-cell at a block start.

    • usl : Fin 4 → Prop

      Predicate selecting slots that carry a whole basic L² side.

    Instances For
      noncomputable def TrilinearHT.Auto.ActiveSetup.AttemptParams.LeafSplit.blockOf {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {ap : A.AttemptParams} (D : ap.LeafSplit) (h : ℤ) :

      The block start of a depth: the largest R.1 + K β ≤ h.

      Equations
      Instances For

        The squared norm of the physical input of a cell function is its L² energy on the cell.

        theorem TrilinearHT.Auto.sameDepth_pairwiseDisjoint (G : RealDyadicGrid) (T : Finset (ℤ × ℤ)) {d : ℤ} (hT : ∀ I ∈ T, I.1 = d) :
        (↑T).PairwiseDisjoint fun (I : ℤ × ℤ) => dyadicGridCell G I.1 I.2

        Distinct cells of one depth are pairwise disjoint.

        The core as a sum of minimal CURRENT component subtotals (blueprint lines 2124, 2460) #

        theorem TrilinearHT.Auto.ModeComponents.sum_classes {Mode : Type u_1} {P : Type u_2} [DecidableEq Mode] [DecidableEq P] (C : ModeComponents Mode P) [Fintype Mode] {M : Type u_3} [AddCommMonoid M] (h : ℕ) (f : Mode → M) :
        ∑ x : Mode, f x = ∑ K ∈ Finset.image (C.E h) Finset.univ, ∑ x ∈ K, f x

        The components at one height partition the modes: a sum over all modes is the sum over the components of the sums over their members.

        noncomputable def TrilinearHT.Auto.ModeSystem.allComps {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) :

        The minimal CURRENT components of the block b on the pre-cell J, as sets of modes.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          noncomputable def TrilinearHT.Auto.ModeSystem.coreComps {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (J : ℤ × ℤ) :

          The core components: the minimal CURRENT components that are not side events.

          Equations
          Instances For
            theorem TrilinearHT.Auto.ModeSystem.sideEvents_subset_allComps {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (J : ℤ × ℤ) :
            Ms.sideEvents S hA SP b J ⊆ Ms.allComps S hA b J
            theorem TrilinearHT.Auto.ModeSystem.frozenEval_eq_comps {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) (c : Ms.Md → ℂ) :
            Ms.frozenEval S b J c = ∑ K ∈ Ms.allComps S hA b J, ∑ m ∈ K, c m • Ms.cellMode J m

            The frozen evaluation is the sum of the subtotals of all minimal CURRENT components.

            theorem TrilinearHT.Auto.ModeSystem.frozenEval_sub_side {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (J : ℤ × ℤ) (c : Ms.Md → ℂ) :
            Ms.frozenEval S b J c - ∑ E ∈ Ms.sideEvents S hA SP b J, ∑ m ∈ E, c m • Ms.cellMode J m = ∑ K ∈ Ms.coreComps S hA SP b J, ∑ m ∈ K, c m • Ms.cellMode J m

            Blueprint lines 2124 and 2460 (A = ZTilde - V): on a pre-cell, the frozen evaluation minus the side subtotal is the sum of the subtotals of the core components.

            theorem TrilinearHT.Auto.ModeSystem.restrict_cellMode_self {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (J : ℤ × ℤ) (m : Ms.Md) :
            (columnL2Restriction (dyadicGridCell Gd J.1 J.2) ⋯) (Ms.cellMode J m) = Ms.cellMode J m

            A cell mode is fixed by the restriction to its cell.

            theorem TrilinearHT.Auto.ModeSystem.restrict_cellMode_disjoint {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) {J J' : ℤ × ℤ} (h : Disjoint (dyadicGridCell Gd J.1 J.2) (dyadicGridCell Gd J'.1 J'.2)) (m : Ms.Md) :
            (columnL2Restriction (dyadicGridCell Gd J'.1 J'.2) ⋯) (Ms.cellMode J m) = 0

            A cell mode vanishes after restriction to a disjoint cell.

            theorem TrilinearHT.Auto.ModeSystem.restrict_blockSide {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {cells : Finset (ℤ × ℤ)} (hdis : (↑cells).PairwiseDisjoint fun (J : ℤ × ℤ) => dyadicGridCell Gd J.1 J.2) (c : ℤ × ℤ → Ms.Md → ℂ) {J : ℤ × ℤ} (hJ : J ∈ cells) :
            (columnL2Restriction (dyadicGridCell Gd J.1 J.2) ⋯) (Ms.blockSide S hA SP b cells c) = ∑ E ∈ Ms.sideEvents S hA SP b J, ∑ m ∈ E, c J m • Ms.cellMode J m

            Restricting the block side subtotal to one of its pre-cells keeps exactly the side events of that pre-cell (the pre-cells of a block are disjoint).

            The rolling mass of a basic leaf slot (blueprint lines 2159-2162, eq:rolling-energy) #

            theorem TrilinearHT.Auto.columnL2Restriction_norm_sq_mono {V : Type u_1} [Fintype V] {s t : Set ℝ} (hs : MeasurableSet s) (ht : MeasurableSet t) (hst : s ⊆ t) (g : ↥(ColumnL2 V)) :

            Restrictions to smaller sets have smaller norm.

            Whole outputs of leaf slots: U slots and cells without decision cell (lines 2159-2162) #

            The linear sides of a basic leaf slot (blueprint lines 2104-2118, 2160) #

            The whole outputs of a U slot of a leaf (blueprint lines 2159-2162) #

            The side mass of a basic leaf slot (blueprint lines 2159-2162) #

            The side mass of a U leaf slot (blueprint lines 2159-2162) #

            Size cuts from integrated budgets (blueprint lines 2163-2166) #

            theorem TrilinearHT.Auto.sum_biUnion_le_of_nonneg {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (t : α → Finset β) (f : β → ℝ) (hf : ∀ (b : β), 0 ≤ f b) :
            ∑ b ∈ s.biUnion t, f b ≤ ∑ a ∈ s, ∑ b ∈ t a, f b

            A sum over a union of finite sets of nonnegative terms is at most the sum of the sums.

            Piece sizes on retained cells of a leaf (blueprint lines 2163-2166) #

            Side caps and three sides on a leaf (blueprint lines 2159-2166, 2372-2384) #

            Variation of single ball pads over global histories (blueprint lines 2390-2391) #

            Variation of single cumulative pads over global histories (blueprint lines 2390-2391) #

            Global pads of the transfer steps (blueprint lines 2386-2391, 2412-2420) #

            Intertwining transfer steps with a restriction (blueprint line 2386) #

            def TrilinearHT.Auto.StepRel {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] {P : ℕ} (r : E →L[ℂ] E) (sg sl : Bool × (Fin P → E →L[ℂ] E) × (Fin P → E →L[ℂ] E)) :

            Two raw transfer steps (slot flag, helper pads, complement pads) are intertwined by r when their flags agree and r intertwines all their pads.

            Equations
            Instances For

              Single pads after global histories on any catalog (blueprint lines 2390-2391, 2414-2420) #

              theorem TrilinearHT.Auto.caps_cut (Gd : RealDyadicGrid) (S : Finset (ℤ × ℤ)) (root : ℤ × ℤ) (hroot : ∀ I ∈ S, dyadicGridCell Gd I.1 I.2 ⊆ dyadicGridCell Gd root.1 root.2) {ν : Type u_1} [Fintype ν] (a : ν → ℤ × ℤ → ℝ) (ha : ∀ (v : ν), ∀ I ∈ S, 0 ≤ a v I) (B : ν → ℝ) (hB : ∀ (v : ν), ∑ I ∈ S, dyadicGridLength Gd I.1 * a v I ≤ B v * dyadicGridLength Gd root.1) {ρ : ℝ} (hρ : 0 < ρ) (hρ1 : ρ < 1) :
              ∃ C ⊆ S, dyadicRootLength Gd C ≤ ρ * dyadicGridLength Gd root.1 ∧ ∀ (v : ν) (x : ℝ), ∑ I ∈ {I ∈ S | ¬∃ c ∈ C, dyadicGridCell Gd I.1 I.2 ⊆ dyadicGridCell Gd c.1 c.2} with x ∈ dyadicGridCell Gd I.1 I.2, a v I ≤ (∑ v : ν, B v) / ρ

              lem:cuts for finitely many families of nonnegative cell weights with integrated budgets Σ_I |I| a_ν(I) ≤ B_ν |R|: one first-crossing cut of total length at most ρ |R| makes all retained path sums of every family at most (Σ_ν B_ν)/ρ.

              noncomputable def TrilinearHT.Auto.ActiveSetup.AttemptParams.LeafSplit.preCell {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {ap : A.AttemptParams} (D : ap.LeafSplit) (I : ℤ × ℤ) :

              The pre-cell J = anc_{b-2K}(I) of a leaf cell I (blueprint line 1975).

              Equations
              Instances For

                Side states of the basic roles on the main columns (blueprint lines 2124-2133) #

                noncomputable def TrilinearHT.Auto.ModeSystem.blockCore {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (cells : Finset (ℤ × ℤ)) (c : ℤ × ℤ → Ms.Md → ℂ) :
                ↥(ColumnL2 Ms.Md)

                The full core subtotal A_{l,G,b} of the block b (blueprint line 2124): the subtotals of the core components (the minimal CURRENT components that are not side events) on the retained pre-cells, with the frozen coefficients.

                Equations
                Instances For
                  theorem TrilinearHT.Auto.ModeSystem.eq_blockCore_add_blockSide {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {cells : Finset (ℤ × ℤ)} (hdis : (↑cells).PairwiseDisjoint fun (J : ℤ × ℤ) => dyadicGridCell Gd J.1 J.2) (c : ℤ × ℤ → Ms.Md → ℂ) (X : ↥(ColumnL2 Ms.Md)) (hsupp : (columnL2Restriction (⋃ J ∈ cells, dyadicGridCell Gd J.1 J.2) ⋯) X = X) (hrep : ∀ J ∈ cells, (columnL2Restriction (dyadicGridCell Gd J.1 J.2) ⋯) X = Ms.frozenEval S b J (c J)) :
                  X = Ms.blockCore S hA SP b cells c + Ms.blockSide S hA SP b cells c

                  Blueprint lines 2124-2133 (ZTilde = A + V): a column function supported on the disjoint retained pre-cells of a block, which restricts on each of them to the frozen evaluation of its coefficients, is the sum of the full core subtotal and the side subtotal of the block. Every mode alive at the decision cell lies in exactly one minimal CURRENT component, which is either a core component or a side event.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.retainedV_pairwiseDisjoint {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (G : bf.Grp) (b : ℤ) (K : ℕ) :
                  (↑(fp.retainedV G b K)).PairwiseDisjoint fun (J : ℤ × ℤ) => dyadicGridCell A.G J.1 J.2

                  The retained v_b-cells of a block are pairwise disjoint (they have one depth).

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.frozenLift_eq_core_add_side {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (c : ℤ × ℤ → Ms.Md → ℂ) (hrep : ∀ J ∈ fp.retainedV G b S.K, Ms.frozenEval S b J (c J) = (columnL2Restriction (dyadicGridCell A.G J.1 J.2) ⋯) (L.op (fp.frozenZ l s mb G j ls (b - 4 * ↑S.K)))) :
                  fp.frozenLift L l s mb G j ls b S.K = Ms.blockCore S hA SP b (fp.retainedV G b S.K) c + Ms.blockSide S hA SP b (fp.retainedV G b S.K) c

                  Blueprint line 1967 and lines 2124-2133: the frozen lifted output of a block, ZTilde_{l,G,b} = R_{l,G} Z_{l,G,u_b} on the retained branches, is the sum A_{l,G,b} + V_{l,G,b} of its full core subtotal and its side subtotal, for frozen coefficients representing it on the retained v_b-cells (as produced by linear_energy).

                  @[reducible, inline]
                  noncomputable abbrev TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physMain {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (V : Type u_1) [Fintype V] :
                  ↥(ColumnL2 V) →L[ℂ] ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                  The physical coordinate of a column function, in the main column space.

                  Equations
                  Instances For
                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (c : ℤ × ℤ → Ms.Md → ℂ) (b h : ℤ) :
                    ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                    Blueprint eq:sides (line 2125): in a basic B role the side state at the depth h of the block b, S_{l,G,h} = Z_{l,G,h} - Z_{l,G,u_b} + V_{l,G,b}, in physical coordinates. Here Z_{l,G,h} is the coarse output, Z_{l,G,u_b} the output frozen at u_b = b - 4K (zero before the attempt) and V_{l,G,b} the side subtotal of prop:linear-side.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState_norm_sq_le {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (c : ℤ × ℤ → Ms.Md → ℂ) (b h : ℤ) (E : Set ℝ) (hE : MeasurableSet E) :
                      ‖(columnL2Restriction E hE) (fp.sideState Ms l s mb G j ls S hA SP c b h)‖ ^ 2 ≤ 2 * ‖(columnL2Restriction E hE) (fp.basicOut l s mb G j ls h - fp.frozenZ l s mb G j ls (b - 4 * ↑S.K))‖ ^ 2 + 2 * ‖Ms.blockSide S hA SP b (fp.retainedV G b S.K) c‖ ^ 2

                      A restricted side state splits into its rolling energy and its fixed block subtotal.

                      noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physError {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (K : ℕ) (b : ℤ) :
                      ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                      Blueprint eq:core-side-error (line 2129): the physical error E_{l,G,b} = (Z_{l,G,u_b})_phys - (ZTilde_{l,G,b})_phys of a block.

                      Equations
                      Instances For
                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.core_side_error {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (c : ℤ × ℤ → Ms.Md → ℂ) (hrep : ∀ J ∈ fp.retainedV G b S.K, Ms.frozenEval S b J (c J) = (columnL2Restriction (dyadicGridCell A.G J.1 J.2) ⋯) (L.op (fp.frozenZ l s mb G j ls (b - 4 * ↑S.K)))) (h : ℤ) :
                        (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (fp.basicOut l s mb G j ls h) = (fp.physMain Ms.Md) (Ms.blockCore S hA SP b (fp.retainedV G b S.K) c) + fp.sideState Ms l s mb G j ls S hA SP c b h + fp.physError Ms L l s mb G j ls S.K b

                        Blueprint eq:core-side-error (lines 2127-2130) in a basic B role: in physical coordinates the coarse output at any depth h of the block b is the full core subtotal plus the side state plus the physical error, Z_{l,G,h} = A_{l,G,b} + S_{l,G,h} + E_{l,G,b}, for frozen coefficients representing ZTilde_{l,G,b} on the retained v_b-cells. (In a basic U role the whole output is the side state, with no core and no error.)

                        The physical error of the frozen lift on the main columns (blueprint lines 2131-2156) #

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.norm_mainScalar_le_one {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s : List (CatCol bf.Vtx)) {U : ℤ × ℤ} (hU : U ∈ A.cells) {r : ℕ} {Φ : bf.Lab ⊕ Fin fp.Mc} (hΦ : Φ ∈ mainLabels A.G fp.Mc (bf.origCols l) s U r) {y : ℝ} (hy : y ∈ dyadicGridCell A.G U.1 U.2) :
                        ‖mainScalar fp.Mc (bf.origCols l) s Φ y‖ ≤ 1

                        Blueprint line 2131 ("physical supremum"): on an active cell the scalars of its main labels are bounded atoms or bounded templates, hence at most one.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.frozenZ_main_rep {κ : 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)) (d : bf.Vtx) {N : ℝ} (hN : ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols l) s I (fp.brank j)).card ≤ N) {u : ℤ} {U : ℤ × ℤ} (hUc : U ∈ A.cells) (hU1 : U.1 = u) :
                        ∃ (β : bf.Lab ⊕ Fin fp.Mc → ℂ), ∑ Φ : bf.Lab ⊕ Fin fp.Mc, ‖β Φ‖ ≤ √N * A.colBudget * (‖(columnL2Restriction (dyadicGridCell A.G U.1 U.2) ⋯) (fp.frozenZ l s mb G j ls u)‖ / √(dyadicGridLength A.G U.1)) ∧ (∀ᵐ (y : ℝ), y ∈ dyadicGridCell A.G U.1 U.2 → ↑↑(fp.frozenZ l s mb G j ls u) y = augmentedMain (fun (Φ : bf.Lab ⊕ Fin fp.Mc) => mainScalar fp.Mc (bf.origCols l) s Φ y) (mainWeight fp.Mc (bf.origCols l)) β) ∧ ∀ᵐ (y : ℝ), y ∈ dyadicGridCell A.G U.1 U.2 → ‖(↑↑(fp.frozenZ l s mb G j ls u) y).ofLp none‖ ≤ ∑ Φ : bf.Lab ⊕ Fin fp.Mc, ‖β Φ‖

                        Blueprint line 2131 ("on a normalized u_b-cell the already fixed main output Z_{l,G,u_b} = Σ_Φ β_Φ Φ has coefficient sum and physical supremum at most D_m^C, with no pre-lag loss"): on an active cell U of depth u the frozen main output is the main combination Σ_Φ β_Φ (φ_Φ, √ε_Φ e_Φ) of the primaries at U, with Σ_Φ |β_Φ| ≤ √N colBudget ‖Z‖_U / √|U| (private-coordinate recovery) and physical supremum on U at most Σ_Φ |β_Φ|.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physError_majorant {κ : 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)) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) (hεP : ∀ (Φ : bf.Lab ⊕ Fin fp.Mc), L.εP Φ = mainWeight fp.Mc (bf.origCols l) Φ) (ζ : ℝ → ℝ) (hs : ∀ (y : ℝ), L.s y = ↑(ζ y) ^ 2) {K : ℕ} {b : ℤ} {J : ℤ × ℤ} (hJ : J ∈ fp.retainedV G b K) {U : ℤ × ℤ} (hJU : dyadicGridCell A.G J.1 J.2 ⊆ dyadicGridCell A.G U.1 U.2) (β : bf.Lab ⊕ Fin fp.Mc → ℂ) (hrep : ∀ᵐ (y : ℝ), y ∈ dyadicGridCell A.G U.1 U.2 → ↑↑(fp.frozenZ l s mb G j ls (b - 4 * ↑K)) y = augmentedMain (fun (Φ : bf.Lab ⊕ Fin fp.Mc) => mainScalar fp.Mc (bf.origCols l) s Φ y) (mainWeight fp.Mc (bf.origCols l)) β) :
                        ∀ᵐ (y : ℝ), y ∈ dyadicGridCell A.G J.1 J.2 → ‖(↑↑(fp.physError Ms L l s mb G j ls K b) y).ofLp none‖ ^ 2 ≤ 2 * |1 - ζ y ^ 2| ^ 2 * ‖(↑↑(fp.frozenZ l s mb G j ls (b - 4 * ↑K)) y).ofLp none‖ ^ 2 + 2 * L.δ ^ 2 * (∑ Φ : bf.Lab ⊕ Fin fp.Mc, ‖β Φ‖) ^ 2

                        Blueprint lines 2132-2143: on a retained v_b-cell J of a block, for a main representation Z_{u_b} = Σ_Φ β_Φ Φ on a cell U ⊇ J (frozenZ_main_rep), every lift with the main private weights and gauge s = ζ² (every admissible choice of first-match expansions) has physical error E = (1 - ζ²) (Z_{u_b})_phys - Σ_Φ β_Φ q_Φ on J, hence |E|² ≤ 2 |1 - ζ²|² |(Z_{u_b})_phys|² + 2 δ_c² (Σ_Φ |β_Φ|)² (|q_Φ| ≤ δ_c).

                        theorem TrilinearHT.Auto.exists_offsets_used {ι : Type u_1} [Fintype ι] (Gd : RealDyadicGrid) (zc : ι → ChartTag) {δ : ℝ} (hδ : 0 < δ) (hδ' : δ ≤ 1 / 8) {dmax : ℕ} (hdim : ∀ (i : ι), (zc i).dim ≤ dmax) (hdδ : 8 * ↑dmax * δ ≤ 1) (U : ι → Finset (ℤ × ℤ)) {R : ℤ × ℤ} (hUR : ∀ (i : ι), ∀ I ∈ U i, dyadicGridCell Gd I.1 I.2 ⊆ dyadicGridCell Gd R.1 R.2) {Nuse : ℕ} (hpath : ∀ (y : ℝ), ∑ i : ι, {I ∈ U i | y ∈ dyadicGridCell Gd I.1 I.2}.card ≤ Nuse) (Zf : ι → ℤ × ℤ → ℝ → ℝ) (hZm : ∀ (i : ι) (I : ℤ × ℤ), Measurable (Zf i I)) (hZ0 : ∀ (i : ι) (I : ℤ × ℤ) (y : ℝ), 0 ≤ Zf i I y) {M : ℝ} (hM : 0 ≤ M) (hZM : ∀ (i : ι), ∀ I ∈ U i, ∀ᵐ (y : ℝ), y ∈ dyadicGridCell Gd I.1 I.2 → Zf i I y ≤ M) {C : ℝ} (hC : 0 ≤ C) :
                        ∃ (ρ : (i : ι) → Fin (zc i).dim → ℝ), (∀ (i : ι) (j : Fin (zc i).dim), ρ i j ∈ Set.Icc 0 1) ∧ ∑ i : ι, ∑ I ∈ U i, ∫⁻ (y : ℝ) in dyadicGridCell Gd I.1 I.2, ENNReal.ofReal (2 * |1 - centerCut (zc i) δ (ρ i) y ^ 2| ^ 2 * Zf i I y + C) ≤ ENNReal.ofReal ((8 * ↑dmax * δ * M + C) * ↑Nuse * dyadicGridLength Gd R.1)

                        Blueprint lines 2144-2150: for the actual main uses I ∈ U_i of the roles and groups i (fixed before the offsets), at most N_use of them through each point of the root R, and majorants B_i(ρ, y) = 2 |1 - ζ_i^ρ(y)²|² Z_{i,I}(y) + C with Z_{i,I} ≤ M on I, eq:offset-mean and the path multiplicity bound the offset mean of Σ_i Σ_{I ∈ U_i} ∫_I B_i by (8 d_max δ M + C) N_use |R|, and the first moment method selects offsets in the unit cubes attaining this bound (no measurable selection of expansions is needed).

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ancAt_mem_retainedV {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {G : bf.Grp} {I : ℤ × ℤ} (hI : fp.ActualUse G I) {b : ℤ} {K : ℕ} (hb : b ≤ I.1) (hbK : I.1 < b + ↑K) (hR : A.R.1 ≤ b - 2 * ↑K) :
                        ancAt A.G I (b - 2 * ↑K) ∈ fp.retainedV G b K

                        Blueprint line 1967 (retention rule): the v_b-ancestor of a cell with an actual use of the group in the block [b, b + K) is retained, when it lies below the attempt root.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physical_error_used {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {ι : Type u_1} [Fintype ι] (lr : ι → Fin 4) (cat : ι → List (CatCol bf.Vtx)) (mb : (i : ι) → bf.MainBudget (cat i)) (gr : ι → bf.Grp) (jj : ι → ℕ) (lsi : ι → List (ℕ × Bool)) (dv : ι → bf.Vtx) (zc : ι → ChartTag) (hanc : A.AncClosed) {K : ℕ} (blk : ℤ × ℤ → ℤ) (hblk : ∀ (I : ℤ × ℤ), blk I ≤ I.1 ∧ I.1 < blk I + ↑K) (U : ι → Finset (ℤ × ℤ)) (hU : ∀ (i : ι), ∀ I ∈ U i, fp.ActualUse (gr i) I) {Nuse : ℕ} (hpath : ∀ (y : ℝ), ∑ i : ι, {I ∈ U i | y ∈ dyadicGridCell A.G I.1 I.2}.card ≤ Nuse) {δ δc : ℝ} (hδ : 0 < δ) (hδ' : δ ≤ 1 / 8) {dmax : ℕ} (hdim : ∀ (i : ι), (zc i).dim ≤ dmax) (hdδ : 8 * ↑dmax * δ ≤ 1) {N CF : ℝ} (hN0 : 0 ≤ N) (hCF : 0 ≤ CF) (hN : ∀ (i : ι), ∀ I ∈ A.cells, ↑(mainLabels A.G fp.Mc (bf.origCols (lr i)) (cat i) I (fp.brank (jj i))).card ≤ N) (hnorm : ∀ (l : Fin 4) (jb : Fin 2), ∀ V ∈ A.cells, ‖(columnL2Restriction (dyadicGridCell A.G V.1 V.2) ⋯) (bf.P l jb).Z‖ ^ 2 ≤ CF * dyadicGridLength A.G V.1) :
                        ∃ (ρ : (i : ι) → Fin (zc i).dim → ℝ), (∀ (i : ι) (j : Fin (zc i).dim), ρ i j ∈ Set.Icc 0 1) ∧ ∀ {n : ℕ} (Ms : ι → ModeSystem A.G n) (L : (i : ι) → LiftData (bf.Lab ⊕ Fin fp.Mc) (Ms i).Md), (∀ (i : ι) (Φ : bf.Lab ⊕ Fin fp.Mc), (L i).εP Φ = mainWeight fp.Mc (bf.origCols (lr i)) Φ) → (∀ (i : ι) (y : ℝ), (L i).s y = ↑(centerCut (zc i) δ (ρ i) y) ^ 2) → (∀ (i : ι), (L i).δ = δc) → ∑ i : ι, ∑ I ∈ U i, ∫ (y : ℝ) in dyadicGridCell A.G I.1 I.2, ‖(↑↑(fp.physError (Ms i) (L i) (lr i) (cat i) (mb i) (gr i) (jj i) (lsi i) K (blk I)) y).ofLp none‖ ^ 2 ≤ (8 * ↑dmax * δ + 2 * δc ^ 2) * (4 * N * A.colBudget ^ 2 * CF) * ↑Nuse * dyadicGridLength A.G A.R.1

                        Blueprint eq:physical-error (lines 2151-2156), with the selection of lines 2144-2150: for the roles and groups i of a search leaf (role l_i, group G_i with center tag z_i, catalog, ball level and shared history), the actual main uses I ∈ U_i (fixed before the offsets, at most N_use through each point of the root) in their blocks [b(I), b(I) + K), active cells closed under ancestors, fresh normalized attempt roots (‖1_V F_{l,j}‖² ≤ C_F |V| on active cells) and at most N main labels at each active cell, there are offsets in the unit cubes such that every choice of first-match lifts at these offsets (main private weights, gauge (ζ_i^ρ)², corrections |q_Φ| ≤ δ_c) has physical errors Σ_i Σ_{I ∈ U_i} ∫_I |E_{l_i,G_i,b(I)}|² ≤ (8 d_max δ + 2 δ_c²) · 4 N colBudget² C_F · N_use |R| (δ the cutoff width; with δ = δ_c this is the blueprint's 2 D_m^{C''} d_max δ_c |R|). No measurable selection of expansions is used: the offsets are chosen by the explicit majorant B(ρ, y) = 2 |1 - ζ^ρ(y)²|² |(Z_{u_b})_phys(y)|² + 2 δ_c² (Σ|β|)², which dominates every admissible choice.

                        Integrated budgets of the side states (blueprint line 2159) #

                        theorem TrilinearHT.Auto.sum_block_le (Sd : Finset ℕ) {K : ℕ} (hK : 0 < K) (f : ℕ → ℝ) (hf : ∀ (b : ℕ), 0 ≤ f b) :
                        ∑ s ∈ Sd, f (K * (s / K)) ≤ ↑K * ∑ b ∈ Finset.image (fun (s : ℕ) => K * (s / K)) Sd, f b

                        Blueprint line 2159 ("a fixed V_{l,G,b} is counted at most K times"): a quantity attached to the block start K ⌊s/K⌋ of each depth s is counted at most K times.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.basic_variation_overlap_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) {M : ℕ} (col : ι' → Fin M) (hdis : ∀ (i i' : ι'), i ≠ i' → col i = col 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 ≤ ↑M * (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 with the loss G₀ and bounded overlap: if the depth intervals are colored with M colors such that intervals of one color are disjoint, the bound of basic_variation_G0 is multiplied by M.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.rolling_budget {κ : 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} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) {K : ℕ} (hK : 1 ≤ K) (Sd : Finset ℕ) (hSd : ∀ t ∈ Sd, t ≤ A.treeDepth) (Ec : ι → ℕ → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, I ∈ A.cells ∧ I.1 = A.R.1 + ↑t) (hcert : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, 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)) :
                        ∑ t ∈ Sd, ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G t, dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb (grp G) j ls (A.R.1 + ↑t) - fp.frozenZ l s mb (grp G) j ls (A.R.1 + ↑(K * (t / K)) - 4 * ↑K))‖ ^ 2 ≤ ↑K * (20 * Real.exp ((4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) + ↑c ^ 2 + 3) * (1 + Real.log (2 * kk)) ^ 2) + 32) * dyadicGridLength A.G A.R.1

                        Blueprint line 2159 ("rolling sides have integrated square budget K G₀ |R| by eq:variation, since the intervals [u_b, s] have overlap O(K)"): with the blocks [b, b + K) starting on R.1 + Kℤ, u_b = b - 4K and the frozen output zero before the attempt, the rolling sides Z_{l,G,s} - Z_{l,G,u_b} on certified cells of the depths s ∈ S_d have total square at most K (20 G₀ + 32) |R|. Depths with b - 4K ≥ R.1 use eq:variation with intervals colored modulo 5K; the first 4K depths use the one-time projection estimate.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.rolling_budget_blocks {κ : 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} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) {K : ℕ} (hK : 1 ≤ K) (Sd : Finset ℕ) (hSd : ∀ t ∈ Sd, t ≤ A.treeDepth) (hSdK : ∀ t ∈ Sd, K ∣ t) (Ec : ι → ℕ → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, I ∈ A.cells ∧ I.1 = A.R.1 + ↑t) (hcert : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, 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)) :
                        ∑ t ∈ Sd, ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G t, dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb (grp G) j ls (A.R.1 + ↑t) - fp.frozenZ l s mb (grp G) j ls (A.R.1 + ↑(K * (t / K)) - 4 * ↑K))‖ ^ 2 ≤ (20 * Real.exp ((4096 * (↑c + 1) * (1024 * (↑c + 1) + ↑c + 7) + ↑c ^ 2 + 3) * (1 + Real.log (2 * kk)) ^ 2) + 32) * dyadicGridLength A.G A.R.1

                        Blueprint lines 2393-2399 and 2415-2419 (eq:stack-energy, "its base term uses Lemma variation on [u_b, b], whose overlap over blocks is bounded"): at the block starts t ∈ K ℕ (blocks [b, b + K) starting on R.1 + K ℤ, u_b = b - 4K, the frozen output zero before the attempt) the rolling block inputs Z_{l,G,b} - Z_{l,G,u_b} on certified cells have total square at most (20 G₀ + 32) |R|: the intervals [u_b, b] of block starts are colored by b / K modulo 5 (eq:variation per color), and at most four block starts lie in the first 4K depths (one-time projection estimate).

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState_budget {κ : 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} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (hK : 1 ≤ S.K) {n : ℕ} (Ms : ι → ModeSystem A.G n) (q : ι → ℕ) (c : (G : ι) → ℤ → ℤ × ℤ → (Ms G).Md → ℂ) (Sd : Finset ℕ) (hSd : ∀ t ∈ Sd, t ≤ A.treeDepth) (Ec : ι → ℕ → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, I ∈ A.cells ∧ I.1 = A.R.1 + ↑t) (hcert : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, 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) (cc : ℕ) (hcc : 1 ≤ cc) {kk : ℝ} (hk : 1 ≤ kk) (hDm : Real.log (2 * mb.B) ≤ kk ^ cc) (hDb : Real.log (2 * A.colBudget) ≤ kk ^ cc) (hn : ↑ls.length ≤ ↑cc * (Real.log kk + 1)) :
                        ∑ t ∈ Sd, ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G t, dyadicGridCell A.G I.1 I.2) ⋯) (fp.sideState (Ms G) l s mb (grp G) j ls (S.withQ0 (q G)) hA SP (c G (A.R.1 + ↑(S.K * (t / S.K)))) (A.R.1 + ↑(S.K * (t / S.K))) (A.R.1 + ↑t))‖ ^ 2 ≤ 2 * (↑S.K * (20 * Real.exp ((4096 * (↑cc + 1) * (1024 * (↑cc + 1) + ↑cc + 7) + ↑cc ^ 2 + 3) * (1 + Real.log (2 * kk)) ^ 2) + 32) * dyadicGridLength A.G A.R.1) + 2 * (↑S.K * ∑ b ∈ Finset.image (fun (t : ℕ) => S.K * (t / S.K)) Sd, ∑ G : ι, ‖(Ms G).blockSide (S.withQ0 (q G)) hA SP (A.R.1 + ↑b) (fp.retainedV (grp G) (A.R.1 + ↑b) S.K) (c G (A.R.1 + ↑b))‖ ^ 2)

                        Blueprint line 2159 for the side states of a basic B role (eq:sides): on the certified cells of the depths s ∈ S_d, Σ_{s,G} ‖1_E S_{l,G,s}‖² ≤ 2 K (20 G₀ + 32) |R| + 2 K Σ_{b,G} ‖V_{l,G,b}‖², the rolling sides by rolling_budget and each fixed V_{l,G,b} counted at most K times (sum_block_le); eq:linear-energy then bounds the second sum.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState_budget_blocks {κ : 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} [Fintype ι] (grp : ι → bf.Grp) (hgrp : Function.Injective grp) (k j : ℕ) (hPH : fp.bbase j + fp.P ≤ fp.Hmax) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (hK : 1 ≤ S.K) {n : ℕ} (Ms : ι → ModeSystem A.G n) (q : ι → ℕ) (c : (G : ι) → ℤ → ℤ × ℤ → (Ms G).Md → ℂ) (Sd : Finset ℕ) (hSd : ∀ t ∈ Sd, t ≤ A.treeDepth) (hSdK : ∀ t ∈ Sd, S.K ∣ t) (Ec : ι → ℕ → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, I ∈ A.cells ∧ I.1 = A.R.1 + ↑t) (hcert : ∀ (G : ι) (t : ℕ), ∀ I ∈ Ec G t, 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) (cc : ℕ) (hcc : 1 ≤ cc) {kk : ℝ} (hk : 1 ≤ kk) (hDm : Real.log (2 * mb.B) ≤ kk ^ cc) (hDb : Real.log (2 * A.colBudget) ≤ kk ^ cc) (hn : ↑ls.length ≤ ↑cc * (Real.log kk + 1)) :
                        ∑ t ∈ Sd, ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G t, dyadicGridCell A.G I.1 I.2) ⋯) (fp.sideState (Ms G) l s mb (grp G) j ls (S.withQ0 (q G)) hA SP (c G (A.R.1 + ↑(S.K * (t / S.K)))) (A.R.1 + ↑(S.K * (t / S.K))) (A.R.1 + ↑t))‖ ^ 2 ≤ 2 * ((20 * Real.exp ((4096 * (↑cc + 1) * (1024 * (↑cc + 1) + ↑cc + 7) + ↑cc ^ 2 + 3) * (1 + Real.log (2 * kk)) ^ 2) + 32) * dyadicGridLength A.G A.R.1) + 2 * ∑ b ∈ Sd, ∑ G : ι, ‖(Ms G).blockSide (S.withQ0 (q G)) hA SP (A.R.1 + ↑b) (fp.retainedV (grp G) (A.R.1 + ↑b) S.K) (c G (A.R.1 + ↑b))‖ ^ 2

                        Blueprint lines 2393-2399 and 2415-2419 (eq:stack-energy) for the block inputs of a basic B role: at the block starts t ∈ K ℕ the side states are the block inputs W_{l,G,b} = Z_b - Z_{u_b} + V_{l,G,b}, and on certified cells Σ_{b,G} ‖1_E W_{l,G,b}‖² ≤ 2 (20 G₀ + 32) |R| + 2 Σ_{b,G} ‖V_{l,G,b}‖²: the rolling block inputs by rolling_budget_blocks (bounded overlap of the intervals [u_b, b]) and each fixed V_{l,G,b} once.

                        The side caps (blueprint eq:side-cap, lines 2160-2163) #

                        theorem TrilinearHT.Auto.norm_sq_restrict_biUnion {V : Type u_1} [Fintype V] (Gd : RealDyadicGrid) (T : Finset (ℤ × ℤ)) (hT : (↑T).PairwiseDisjoint fun (I : ℤ × ℤ) => dyadicGridCell Gd I.1 I.2) (x : ↥(ColumnL2 V)) :
                        ‖(columnL2Restriction (⋃ I ∈ T, dyadicGridCell Gd I.1 I.2) ⋯) x‖ ^ 2 = ∑ I ∈ T, ‖(columnL2Restriction (dyadicGridCell Gd I.1 I.2) ⋯) x‖ ^ 2

                        The restriction to a disjoint union of cells has squared norm the sum over the cells.

                        theorem TrilinearHT.Auto.cell_budget_eq (Gd : RealDyadicGrid) (Sc : Finset (ℤ × ℤ)) {ι : Type u_1} {W : Type u_2} [Fintype ι] [Fintype W] (X : ι → ℤ → ↥(ColumnL2 W)) (cert : ι → ℤ × ℤ → Prop) (Sd : Finset ℕ) (R1 : ℤ) (Ec : ι → ℕ → Finset (ℤ × ℤ)) (hEc : ∀ (G : ι) (t : ℕ), Ec G t = {I ∈ Sc | I.1 = R1 + ↑t ∧ cert G I}) (hSc : ∀ I ∈ Sc, ∃ t ∈ Sd, I.1 = R1 + ↑t) :
                        (∑ I ∈ Sc, ∑ G : ι, if cert G I then ‖(columnL2Restriction (dyadicGridCell Gd I.1 I.2) ⋯) (X G I.1)‖ ^ 2 else 0) = ∑ t ∈ Sd, ∑ G : ι, ‖(columnL2Restriction (⋃ I ∈ Ec G t, dyadicGridCell Gd I.1 I.2) ⋯) (X G (R1 + ↑t))‖ ^ 2

                        The integrated budget of side states over the needed cells of each depth, written cell by cell: the needed cells of one depth are disjoint (norm_sq_restrict_biUnion).

                        Terms containing a physical error (blueprint line 2164) #

                        theorem TrilinearHT.Auto.cellForm_norm_le_L2 {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) {V : Type u_1} [Fintype V] (x : Fin 4 → ↥(ColumnL2 V)) (n : Fin 4 → ℝ) (hn0 : ∀ (j : Fin 4), 0 ≤ n j) (hn : ∀ (j : Fin 4), MeasureTheory.eLpNorm (augPhys (x j)) 2 (normalizedIntervalMeasure a₀ r) ≤ ENNReal.ofReal (n j)) :
                        ‖(cellForm hr hw V) x‖ ≤ localFormUniformConstant κ * (n 0 * n 1 * n 2 * n 3)

                        Blueprint eq:absolute with all four exponents two, for the cell form: its modulus is at most C_κ times the product of the normalized L² sizes of the physical parts.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.core_error_sizes {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {n : ℕ} (Ms : ModeSystem A.G n) (L : LiftData (bf.Lab ⊕ Fin fp.Mc) Ms.Md) (l : Fin 4) (s : List (CatCol bf.Vtx)) (mb : bf.MainBudget s) (G : bf.Grp) (j : ℕ) (ls : List (ℕ × Bool)) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) (b : ℤ) (c : ℤ × ℤ → Ms.Md → ℂ) (hrep : ∀ J ∈ fp.retainedV G b S.K, Ms.frozenEval S b J (c J) = (columnL2Restriction (dyadicGridCell A.G J.1 J.2) ⋯) (L.op (fp.frozenZ l s mb G j ls (b - 4 * ↑S.K)))) {J I : ℤ × ℤ} (hJ : J ∈ fp.retainedV G b S.K) (hIJ : dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G J.1 J.2) (h : ℤ) :
                        ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.physError Ms L l s mb G j ls S.K b)‖ ≤ (1 + √5) * (‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls h)‖ + ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls h - fp.frozenZ l s mb G j ls (b - 4 * ↑S.K))‖) ∧ ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((fp.physMain Ms.Md) (Ms.blockCore S hA SP b (fp.retainedV G b S.K) c))‖ ≤ √5 * (‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls h)‖ + ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l s mb G j ls h - fp.frozenZ l s mb G j ls (b - 4 * ↑S.K))‖) + ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (Ms.blockSide S hA SP b (fp.retainedV G b S.K) c)‖

                        Blueprint line 2164 ("the lift is pointwise bounded and Z_{u_b} = Z_s - (Z_s - Z_{u_b}), so the full core and error sizes on retained cells are also at most P^C"): on a cell I inside a retained v_b-cell of the block, the physical error and the full core subtotal are bounded by the coarse output, the rolling side and the side subtotal on I: ‖1_I E‖ ≤ (1 + √5)(‖1_I Z_h‖ + ‖1_I (Z_h - Z_{u_b})‖) and ‖1_I A‖ ≤ √5 (‖1_I Z_h‖ + ‖1_I (Z_h - Z_{u_b})‖) + ‖1_I V‖.

                        The normalized L² size of the physical part on a cell is the square root of its cell integral divided by the length (so that |I| e_I² = ∫_I |x_phys|², as in eq:physical-error).

                        Helper instantiation on the main columns (blueprint lines 2167-2169) #

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

                        Blueprint lines 2167-2169 ("helper ranks exceed every main rank, so their insertion leaves all previously fixed main projections ... unchanged"): catalog columns of rank above r do not change the main selections of rank at most r.

                        theorem TrilinearHT.Auto.mainProj_append_highRank {V : Type} [Fintype V] {Tg : Type u_1} {G : RealDyadicGrid} {Mc : ℕ} {O : OrigCols V Tg} (s t : List (CatCol Tg)) (I : ℤ × ℤ) (r : ℕ) (M : Tg → Prop) (ht : ∀ d ∈ t, r < d.rank) :
                        mainProj G Mc O (s ++ t) I r M = mainProj G Mc O s I r M
                        theorem TrilinearHT.Auto.MainTest.pass_append_highRank {V : Type} [Fintype V] {Tg : Type u_1} {G : RealDyadicGrid} {Mc : ℕ} {O : OrigCols V Tg} (w : MainTest Tg V Mc) (I : ℤ × ℤ) (c₀ : ℕ) (H : ℝ) (tagOf : Tg → ChartTag) (wI : ℝ × ℝ → ℂ) (τ : ℝ) (mH : ℕ) (s t : List (CatCol Tg)) (ht : ∀ d ∈ t, w.r < d.rank ∧ ∀ l < w.m, w.hr l < d.rank) :
                        w.Pass G O I c₀ H tagOf wI τ mH (s ++ t) ↔ w.Pass G O I c₀ H tagOf wI τ mH s

                        Main tests whose target and history ranks lie below every inserted column keep passing.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.ballFilt_append_helper {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s t : List (CatCol bf.Vtx)) (I : ℤ × ℤ) (G : bf.Grp) {j : ℕ} (hj : j ≤ 4) (ht : ∀ d ∈ t, fp.hrank ≤ d.rank) :
                        fp.ballFilt l (s ++ t) I G j = fp.ballFilt l s I G j

                        The ball filters of the levels j ≤ 4 are unchanged by helper columns of rank L + 5.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.cumFilt_append_helper {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (l : Fin 4) (s t : List (CatCol bf.Vtx)) (I : ℤ × ℤ) (m : ℕ) (ht : ∀ d ∈ t, fp.hrank ≤ d.rank) :
                        fp.cumFilt l (s ++ t) I m = fp.cumFilt l s I m

                        The cumulative filters are unchanged by helper columns of rank L + 5.

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.helper_instantiation_main {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (Tc : Finset (ℤ × ℤ)) (hTc : Tc ⊆ A.cells) {cS Dst : ℕ} (hst : SameTagBound κ cS Dst) {HS : ℝ} (hHS : Real.exp 2 ≤ HS) (cat : Fin 4 → List (CatCol bf.Vtx)) (W : Fin 4 → ℤ × ℤ → Type u_1) [(l : Fin 4) → (I : ℤ × ℤ) → Fintype (W l I)] (tests : (l : Fin 4) → (I : ℤ × ℤ) → W l I → MainTest bf.Vtx bf.Lab fp.Mc) (ht : ∀ (l : Fin 4) (I : ℤ × ℤ) (w : W l I), (tests l I w).t = l) (hr : ∀ (l : Fin 4) (I : ℤ × ℤ) (w : W l I), (tests l I w).r = fp.Lc + 5) (hbase : ∀ (l : Fin 4), ∀ I ∈ Tc, ∀ (w : W l I), MainFresh fp.Mc (cat l).length (tests l I w).base ∧ ∀ᵐ (y : ℝ), y ∉ dyadicGridCell A.G I.1 I.2 → ↑↑(tests l I w).base y = 0) {Kt : ℕ} (hKt : ∀ (l : Fin 4) (I : ℤ × ℤ), Fintype.card (W l I) ≤ Kt) {τ₃ : ℝ} (hτ₃ : 0 < τ₃) {Tmax : ℕ} (n : ℕ → ℝ) (hn : 0 < n (fp.Lc + 4)) (hcapH : closureRatio A.famVtxBound Kt fp.mH Tmax (Real.exp (↑Dst * (1 + Real.log HS) ^ Dst)) τ₃ * n (fp.Lc + 4) < ↑Tmax) (hMc : ∀ (l : Fin 4), (cat l).length + Tc.card * Tmax ≤ fp.Mc) {Wm : Type u_2} (main : Wm → Fin 4 × (ℤ × ℤ) × MainTest bf.Vtx bf.Lab fp.Mc) (hmain : ∀ (i : Wm), (main i).2.2.r ≤ fp.Lc + 4 ∧ ∀ l < (main i).2.2.m, (main i).2.2.hr l ≤ fp.Lc + 4) (τm : Wm → ℝ) (hpass : ∀ (i : Wm), (main i).2.2.Pass A.G (bf.origCols (main i).1) (main i).2.1 cS HS bf.vtag (A.w (main i).2.1) (τm i) fp.mH (cat (main i).1)) :
                        ∃ (hcat : Fin 4 → List (CatCol bf.Vtx)), (∀ (l : Fin 4), ∀ I ∈ Tc, ∀ (w : W l I), (tests l I w).Pass A.G (bf.origCols l) I cS HS bf.vtag (A.w I) (catThreshold A.famVtxBound τ₃ n (fp.Lc + 5)) fp.mH (cat l ++ hcat l)) ∧ (∀ (i : Wm), (main i).2.2.Pass A.G (bf.origCols (main i).1) (main i).2.1 cS HS bf.vtag (A.w (main i).2.1) (τm i) fp.mH (cat (main i).1 ++ hcat (main i).1)) ∧ (∀ (l : Fin 4) (I : ℤ × ℤ) (G : ℕ × Option (Fin A.fcd0 × bf.Vtx × ℤ) × ℕ × (ℕ × ℕ) × Option (Fin A.fcd0 × bf.Vtx × ℤ)), ∀ j ≤ 4, fp.ballFilt l (cat l ++ hcat l) I G j = fp.ballFilt l (cat l) I G j) ∧ (∀ (l : Fin 4) (I : ℤ × ℤ) (m : ℕ), fp.cumFilt l (cat l ++ hcat l) I m = fp.cumFilt l (cat l) I m) ∧ (∀ (l : Fin 4), ∀ I ∈ Tc, ↑(List.filter (fun (d : CatCol bf.Vtx) => decide (d.birth = I)) (hcat l)).length ≤ closureRatio A.famVtxBound Kt fp.mH Tmax (Real.exp (↑Dst * (1 + Real.log HS) ^ Dst)) τ₃ * n (fp.Lc + 4)) ∧ ∀ (l : Fin 4), ∀ d ∈ hcat l, d.birth ∈ Tc ∧ d.rank = fp.Lc + 5 ∧ (∃ (w : W l d.birth), (tests l d.birth w).M d.tag) ∧ ∃ R ∈ residueBox (bf.vtag d.tag).dim 9, ∃ (γ : ℝ), d = templateCol (bf.vtag d.tag) l R γ d.birth d.rank d.tag

                        Blueprint "Helper instantiation" (lines 2167-2169) on the main columns: for helper tests of rank L + 5 on fixed whole bases at the active cells (the entire side states, sideState_base), there are helper templates of rank L + 5 born at the active cells such that all helper tests pass on the extended catalogs, every main test of ranks at most L + 4 that passed still passes, and the ball filters of the levels j ≤ 4 and the cumulative filters are unchanged (so are the main projections, offsets and side states built from them); the insertions per cell are counted as in lem:closure (helper_closure).

                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.sideState_base {κ : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {W : Type} [Fintype W] (x : ↥(ColumnL2 W)) (nf : ℕ) (I : ℤ × ℤ) :
                        MainFresh fp.Mc nf ((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((fp.physMain W) x)) ∧ ∀ᵐ (y : ℝ), y ∉ dyadicGridCell A.G I.1 I.2 → ↑↑((columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((fp.physMain W) x)) y = 0

                        Blueprint line 2168 ("the helper bases are these entire states"): a side state (any physical column function) restricted to an active cell is an admissible helper base: its template coordinates vanish and it is supported on the cell.