Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec151ExactCommonHeightSelection.Setup

Section 15.1: An exact common-height selection #

This file was automatically generated by Claude.

Formalization of blueprint Section 15, "Common heights and concentration of the core terms" (sec:core), subsection 1, "An exact common-height selection" (lines 2460-2481) of blueprint/formalization_blueprint.tex.

An exact common-height selection (blueprint lines 2464-2480) #

theorem TrilinearHT.Auto.first_success_weights_sum {p : ℝ} (hp0 : 0 < p) (hp1 : p ≤ 1) :
HasSum (fun (n : ℕ) => (1 - p) ^ n * p) 1

Blueprint line 2467: the first-success weights (1 - p)^n p of words whose first success is last have total weight exactly one.

theorem TrilinearHT.Auto.all_good_proportion {α : Type u_1} [DecidableEq α] (H : Finset α) {m₀ : ℕ} (bad : Fin m₀ → Finset α) {β : ℝ} (hbad : ∀ (j : Fin m₀), ↑(bad j ∩ H).card ≤ β * ↑H.card) :
(1 - ↑m₀ * β) * ↑H.card ≤ ↑{h ∈ H | ∀ (j : Fin m₀), h ∉ bad j}.card

Blueprint line 2467 (success probability): if each of m₀ roles is bad at a proportion at most β of the heights H, then all roles are good at a proportion at least 1 - m₀ β.

theorem TrilinearHT.Auto.form_pattern_split (F : (Fin 4 → Fin 3) → ℂ) :
∑ σ : Fin 4 → Fin 3, F σ = ∑ σ : Fin 4 → Fin 3 with ∃ (l : Fin 4), σ l = 2, F σ + ∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ 3 ≤ patternCount σ 0, F σ + ∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ 3 ≤ patternCount σ 1, F σ + ∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ patternCount σ 0 = 2 ∧ patternCount σ 1 = 2, F σ

Blueprint lines 2461-2462 and 2845-2848: the patterns split into those containing a physical error, those with at least three cores and no error, those with at least three sides and no error, and those with exactly two cores and two sides.

theorem TrilinearHT.Auto.form_restore_cores {V : Type u_1} [AddCommGroup V] [Module ℂ V] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => V) ℂ) (a s e : Fin 4 → V) (σ : Fin 4 → Fin 3) (hσ : ∀ (l : Fin 4), σ l ≠ 2) :
Λ (patternPiece a s e σ) = (Λ fun (l : Fin 4) => if σ l = 0 then a l + s l + e l else s l) - ∑ τ : Fin 4 → Fin 3 with τ ≠ σ ∧ ∀ (l : Fin 4), σ l = 1 → τ l = 1, Λ (patternPiece a s e τ)

Blueprint lines 2461-2462 ("for terms with exactly two sides, replace the two core complements by their whole current Z arguments; corrections have at least three sides"): for a pattern σ without errors, the form of its pieces equals the form with the core slots restored to Z_l = A_l + S_l + E_l minus the correction patterns, each of which contains an error or has more sides than σ.

theorem TrilinearHT.Auto.restore_correction_sides (σ τ : Fin 4 → Fin 3) (hσ : ∀ (l : Fin 4), σ l ≠ 2) (hne : τ ≠ σ) (hτ : ∀ (l : Fin 4), σ l = 1 → τ l = 1) :
(∃ (l : Fin 4), τ l = 2) ∨ patternCount σ 1 < patternCount τ 1

The corrections of form_restore_cores contain an error or more sides than the pattern.

Exact common-height selection (common-height, blueprint lines 2464-2476) #

theorem TrilinearHT.Auto.first_success_identity {ι : Type u_1} {E : Type u_2} [NormedAddCommGroup E] [NormedSpace ℝ E] (T : Finset ι) (pr : ι → ℝ) (hp0 : ∀ τ ∈ T, 0 < pr τ) (hp1 : ∀ τ ∈ T, pr τ ≤ 1) (F : ι → E) :
HasSum (fun (n : ℕ) => ∑ τ ∈ T, ((1 - pr τ) ^ n * pr τ) • F τ) (∑ τ ∈ T, F τ)

Blueprint lines 2466-2467 ("the first-success rule has total weight exactly one for every tuple, hence gives an exact identity in expectation for the finite multilinear expansion"): for a finite family of tuples τ with one-trial success proportions p_τ ∈ (0, 1], the expansion Σ_τ F_τ is the sum over trial counts n of Σ_τ (1 - p_τ)^n p_τ F_τ.

theorem TrilinearHT.Auto.success_proportion_pos {α : Type u_1} [DecidableEq α] (H : Finset α) (hH : H.Nonempty) {m₀ : ℕ} (bad : Fin m₀ → Finset α) {δ : ℝ} (hbad : ∀ (j : Fin m₀), ↑(bad j ∩ H).card ≤ 2 * δ * ↑H.card) (hδ : 2 * ↑m₀ * δ < 1) :
0 < ↑{h ∈ H | ∀ (j : Fin m₀), h ∉ bad j}.card / ↑H.card

Blueprint line 2466 ("success probability is at least 1 - 2 m₀ δ_*"): if each of m₀ roles has bad proportion at most 2δ among the sampled heights, the one-trial success proportion of a tuple is at least 1 - 2 m₀ δ, positive when 2 m₀ δ < 1.

Selected modes in torus form (eq:core-torus-form, blueprint lines 2468-2476) #

theorem TrilinearHT.Auto.quad_phase_sub (lam a γ x y : ℝ) :
lam * (y - a) ^ 2 + γ * (y - a) - (lam * (x - a) ^ 2 + γ * (x - a)) = (2 * lam * (x - a) + γ) * (y - x) + lam * (y - x) ^ 2

The quadratic phase identity φ(y) - φ(x) = ω(x)(y - x) + λ(y - x)² for φ(y) = λ(y-a)² + γ(y-a), ω(y) = 2λ(y-a) + γ.

theorem TrilinearHT.Auto.mode_phase_reduction {lam a γ ωa s θ x y : ℝ} (hsl : |2 * lam * (x - a) + γ - ωa + s| ≤ θ) :
|lam * (y - a) ^ 2 + γ * (y - a) - (lam * (x - a) ^ 2 + γ * (x - a)) - (ωa - s) * (y - x)| ≤ θ * |y - x| + |lam| * (y - x) ^ 2

Blueprint lines 2470-2471 ("a PRE path to the representative supplies an integer shift with slope error at most D_* Ξ / r_{v_b} ... the quadratic Taylor error is likewise small"): if the slope of a mode m at x* equals that of the representative a minus the shift s up to θ, the phase of m on the cell is φ_m(x*) + (ω_a(x*) - s)(y - x*) up to θ |y - x*| + |λ_m| (y - x*)².

theorem TrilinearHT.Auto.mode_char_reduction {lam a γ ωa s θ x y : ℝ} (hsl : |2 * lam * (x - a) + γ - ωa + s| ≤ θ) :
‖↑(Real.fourierChar (lam * (y - a) ^ 2 + γ * (y - a))) - ↑(Real.fourierChar (lam * (x - a) ^ 2 + γ * (x - a))) * ↑(Real.fourierChar ((ωa - s) * (y - x)))‖ ≤ 2 * Real.pi * (θ * |y - x| + |lam| * (y - x) ^ 2)

The exponential form of mode_phase_reduction: with e(t) = exp(2πit), |e(φ_m(y)) - e(φ_m(x*)) e((ω_a(x*) - s)(y - x*))| ≤ 2π (θ |y - x*| + |λ_m| (y - x*)²).

theorem TrilinearHT.Auto.selected_torus_form {ι : Type u_1} (F : Finset ι) (α : ι → ℂ) (lam a γ s : ι → ℝ) {ωa θ Λ x y : ℝ} (hsl : ∀ m ∈ F, |2 * lam m * (x - a m) + γ m - ωa + s m| ≤ θ) (hlam : ∀ m ∈ F, |lam m| ≤ Λ) :
‖∑ m ∈ F, α m * ↑(Real.fourierChar (lam m * (y - a m) ^ 2 + γ m * (y - a m))) - ↑(Real.fourierChar (ωa * (y - x))) * ∑ m ∈ F, α m * (↑(Real.fourierChar (lam m * (x - a m) ^ 2 + γ m * (x - a m))) * ↑(Real.fourierChar (-(s m * (y - x)))))‖ ≤ 2 * Real.pi * (θ * |y - x| + Λ * (y - x) ^ 2) * ∑ m ∈ F, ‖α m‖

Blueprint eq:core-torus-form (lines 2471-2476) for one role: the selected modes, each with slope at x* equal to the representative's ω_a(x*) minus its shift s_m up to θ, and with curvatures at most Λ, synthesize on the cell Σ_m α_m e(φ_m(y)) = e(ω_a(x*)(y - x*)) Σ_m α_m e(φ_m(x*)) e(-s_m (y - x*)) up to the uniform error 2π (θ |y - x*| + Λ (y - x*)²) Σ_m |α_m|.

theorem TrilinearHT.Auto.ModeSystem.pre_component_shift {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} (hJ : J.1 ≤ b + ↑S.K) {h : ℕ} {x a : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hx : x ∈ (Ms.blockComps S hA b J).E h a) :
∃ (n : Fin Ms.zc.dim → ℤ), (∀ (i : Fin Ms.zc.dim), |↑(n i)| ≤ ↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * S.Eh h) ∧ ∀ y ∈ Set.Icc (dyadicGridLeft Gd J.1 J.2) (dyadicGridLeft Gd J.1 J.2 + dyadicGridLength Gd J.1), |Ms.slope (↑a) y - Ms.slope (↑x) y + (∑ i : Fin Ms.zc.dim, ↑(n i) * (Ms.zc.θ i / ↑S.Q0)) / ModeSchedule.Lh h| ≤ ↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * (S.Ξ / dyadicGridLength Gd J.1)

Blueprint line 2470 ("a PRE path to the representative has at most D_* edges; it supplies an integer shift of size at most D_* E_{h-Δ}, with slope error at most D_* Ξ / r_{v_b}"): two modes in one PRE component at height h of the pre-cell J of block b differ in slope, after a shift n·ϑ/L_h with |n| ≤ |alive| E_h, by at most |alive| Ξ / r_J on the pre-cell.

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

The quadratic phase φ_m(y) = λ_m (y - a_m)² + γ_m (y - a_m) of a mode.

Equations
Instances For
    theorem TrilinearHT.Auto.ModeSystem.component_torus_form {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} (hJ : J.1 ≤ b + ↑S.K) {h : ℕ} (a : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) (F : Finset ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) (hF : F ⊆ (Ms.blockComps S hA b J).E h a) (α : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K))) → ℂ) {Λ : ℝ} (hΛ : ∀ m ∈ F, |Ms.lamOf ↑m| ≤ Λ) :
    ∃ (n : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K))) → Fin Ms.zc.dim → ℤ), (∀ m ∈ F, ∀ (i : Fin Ms.zc.dim), |↑(n m i)| ≤ ↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * S.Eh h) ∧ ∀ x ∈ Set.Icc (dyadicGridLeft Gd J.1 J.2) (dyadicGridLeft Gd J.1 J.2 + dyadicGridLength Gd J.1), ∀ (y : ℝ), ‖∑ m ∈ F, α m * ↑(Real.fourierChar (Ms.phase (↑m) y)) - ↑(Real.fourierChar (Ms.slope (↑a) x * (y - x))) * ∑ m ∈ F, α m * (↑(Real.fourierChar (Ms.phase (↑m) x)) * ↑(Real.fourierChar (-((-∑ i : Fin Ms.zc.dim, ↑(n m i) * (Ms.zc.θ i / ↑S.Q0)) / ModeSchedule.Lh h * (y - x)))))‖ ≤ 2 * Real.pi * (↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * (S.Ξ / dyadicGridLength Gd J.1) * |y - x| + Λ * (y - x) ^ 2) * ∑ m ∈ F, ‖α m‖

    Blueprint eq:core-torus-form (lines 2468-2476) for one selected component: the selected modes F of the PRE predecessor of the representative a at height h on the pre-cell J synthesize, at points x*, y of the pre-cell, the representative phase times a trigonometric polynomial in the integer shifts n_m (|n_m| ≤ |alive| E_h): Σ_m α_m e(φ_m(y)) = e(ω_a(x*)(y - x*)) Σ_m α_m e(φ_m(x*)) e(-(n_m·ϑ/L_h)(y - x*)), up to 2π (|alive| Ξ/r_J |y - x*| + Λ (y - x*)²) Σ |α_m| when all curvatures are at most Λ.

    theorem TrilinearHT.Auto.pattern_error_le {W : Type u_1} [NormedAddCommGroup W] [NormedSpace ℂ W] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => W) ℂ) {C r Bs : ℝ} (hC : 0 ≤ C) (hr : 0 < r) (hΛ : ∀ (x : Fin 4 → W), ‖Λ x‖ ≤ C * ∏ l : Fin 4, ‖x l‖ / √r) (a s e : Fin 4 → W) (hsize : ∀ (l : Fin 4), ‖a l‖ ≤ Bs * √r ∧ ‖s l‖ ≤ Bs * √r ∧ ‖e l‖ ≤ Bs * √r) (σ : Fin 4 → Fin 3) {l₀ : Fin 4} (hl₀ : σ l₀ = 2) :
    ‖Λ (patternPiece a s e σ)‖ ≤ C * Bs ^ 3 * (‖e l₀‖ / √r)

    A pattern containing an error slot: its form is at most the size cap cubed times the normalized error size of that slot.

    theorem TrilinearHT.Auto.error_patterns_le {W : Type u_1} [NormedAddCommGroup W] [NormedSpace ℂ W] {ι : Type u_2} {γ : Type u_3} (S : Finset ι) (len : ι → ℝ) (hlen : ∀ I ∈ S, 0 < len I) (Gs : ι → Finset γ) (Λ : ι → MultilinearMap ℂ (fun (x : Fin 4) => W) ℂ) {C Bs : ℝ} (hC : 0 ≤ C) (hBs : 0 ≤ Bs) (hΛ : ∀ I ∈ S, ∀ (x : Fin 4 → W), ‖(Λ I) x‖ ≤ C * ∏ l : Fin 4, ‖x l‖ / √(len I)) (a s e : ι → γ → Fin 4 → W) (hsize : ∀ I ∈ S, ∀ G ∈ Gs I, ∀ (l : Fin 4), ‖a I G l‖ ≤ Bs * √(len I) ∧ ‖s I G l‖ ≤ Bs * √(len I) ∧ ‖e I G l‖ ≤ Bs * √(len I)) {M Ee : ℝ} (hM : ∑ I ∈ S, len I * ↑(Gs I).card ≤ M) (hE : ∑ I ∈ S, ∑ G ∈ Gs I, ∑ l : Fin 4, ‖e I G l‖ ^ 2 ≤ Ee) :
    ∑ I ∈ S, len I * ∑ σ : Fin 4 → Fin 3 with ∃ (l : Fin 4), σ l = 2, ‖∑ G ∈ Gs I, (Λ I) (patternPiece (a I G) (s I G) (e I G) σ)‖ ≤ 81 * (C * Bs ^ 3) * (√(4 * M) * √Ee)

    Blueprint line 2461 and line 2166 ("every term containing a physical error is O(e^{-k}|R|)"): the error patterns of all cells and groups are bounded, after Cauchy-Schwarz over the cells and groups, by 324 C B³ (Σ_I |I| #G_I)^{1/2} (Σ_{I,G,l} ‖E‖²)^{1/2}.

    theorem TrilinearHT.Auto.two_two_cell_le {W : Type u_1} [NormedAddCommGroup W] [NormedSpace ℂ W] {γ : Type u_2} (Gs : Finset γ) (Λ : MultilinearMap ℂ (fun (x : Fin 4) => W) ℂ) (a s e : γ → Fin 4 → W) :
    ‖∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ patternCount σ 0 = 2 ∧ patternCount σ 1 = 2, ∑ G ∈ Gs, Λ (patternPiece (a G) (s G) (e G) σ)‖ ≤ ‖∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ patternCount σ 0 = 2 ∧ patternCount σ 1 = 2, ∑ G ∈ Gs, Λ fun (l : Fin 4) => if σ l = 0 then a G l + s G l + e G l else s G l‖ + 81 * ∑ τ : Fin 4 → Fin 3 with ∃ (l : Fin 4), τ l = 2, ‖∑ G ∈ Gs, Λ (patternPiece (a G) (s G) (e G) τ)‖ + 81 * ∑ τ : Fin 4 → Fin 3 with (∀ (l : Fin 4), τ l ≠ 2) ∧ 3 ≤ patternCount τ 1, ‖∑ G ∈ Gs, Λ (patternPiece (a G) (s G) (e G) τ)‖

    Blueprint line 2461 ("for terms with exactly two sides, replace the two core complements by their whole current Z arguments; corrections have at least three sides"): at one cell the two-core two-side patterns differ from the restored ones by at most 81 times the error and the three-side pattern sums.

    theorem TrilinearHT.Auto.physEmbed_physEmbed {V : Type u_1} {W : Type u_3} [Fintype V] [Fintype W] {X : Type u_4} [Fintype X] (x : ↥(ColumnL2 V)) :
    (physEmbed W X) ((physEmbed V W) x) = (physEmbed V X) x

    Physical embeddings compose.

    First-success heights on the attempt cores (blueprint lines 2463-2467) #

    def TrilinearHT.Auto.failMask {α : Type u_1} [DecidableEq α] {m₀ : ℕ} (H : Finset α) (bad : Fin m₀ → Finset α) (j : Fin m₀) :

    Blueprint lines 2468-2469 (product masks): the heights whose first failing role is j: failure at role j and success at every earlier role.

    Equations
    Instances For
      theorem TrilinearHT.Auto.failMask_disjoint {α : Type u_1} [DecidableEq α] {m₀ : ℕ} (H : Finset α) (bad : Fin m₀ → Finset α) {j j' : Fin m₀} (hne : j ≠ j') :
      Disjoint (failMask H bad j) (failMask H bad j')

      The failure masks of distinct roles are disjoint.

      theorem TrilinearHT.Auto.failed_mem_failMask {α : Type u_1} [DecidableEq α] {m₀ : ℕ} (H : Finset α) (bad : Fin m₀ → Finset α) {h : α} (hH : h ∈ H) (hf : ∃ (j : Fin m₀), h ∈ bad j) :
      ∃ (j : Fin m₀), h ∈ failMask H bad j

      Every failed height lies in the failure mask of exactly one role (its first failing role).

      theorem TrilinearHT.Auto.failed_words_eq_biUnion {α : Type u_1} [DecidableEq α] {m₀ n : ℕ} (H : Finset α) (bad : Fin m₀ → Finset α) :
      (Fintype.piFinset fun (x : Fin n) => {h ∈ H | ∃ (j : Fin m₀), h ∈ bad j}) = Finset.univ.biUnion fun (a : Fin n → Fin m₀) => Fintype.piFinset fun (i : Fin n) => failMask H bad (a i)

      Blueprint lines 2468-2469 ("there are at most m₀^n assignments; for a fixed assignment the conditions form a product mask"): the words of n failed trials are the disjoint union, over the assignments a : Fin n → Fin m₀ of trials to first failing roles, of the product masks.

      Frequency box and the offset side (blueprint lines 2476-2479) #

      The physical-error patterns of a leaf (blueprint lines 2149-2166) #

      noncomputable def TrilinearHT.Auto.compSlot {V : Type u_1} [AddCommGroup V] (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (sub : (l : Fin 4) → κ l → V) (s e : Fin 4 → V) (r : (l : Fin 4) → Option (κ l)) (l : Fin 4) :
      V

      The slot values of a component tuple: the selected component subtotal in a core slot, the pattern piece otherwise.

      Equations
      Instances For
        noncomputable def TrilinearHT.Auto.compIdx (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (Ks : (l : Fin 4) → Finset (κ l)) (l : Fin 4) :
        Finset (Option (κ l))

        The index sets of the component tuples: the components of a core slot, a single dummy otherwise.

        Equations
        Instances For
          theorem TrilinearHT.Auto.pattern_comp_expand {V : Type u_1} [AddCommGroup V] [Module ℂ V] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => V) ℂ) (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_2} (Ks : (l : Fin 4) → Finset (κ l)) (sub : (l : Fin 4) → κ l → V) (a s e : Fin 4 → V) (ha : ∀ (l : Fin 4), σ l = 0 → a l = ∑ K ∈ Ks l, sub l K) :
          Λ (patternPiece a s e σ) = ∑ r ∈ Fintype.piFinset (compIdx σ Ks), Λ (compSlot σ sub s e r)

          Blueprint lines 2463-2467 (the finite multilinear expansion of the core slots): if each core slot of a pattern is the sum of its component subtotals, the pattern form is the sum over the component tuples of the forms of the tuple values.

          def TrilinearHT.Auto.roleMask {m₀ : ℕ} {κ : Type u_1} (good : ℕ → κ → Prop) (j : Fin m₀) {n : ℕ} (a : Fin n → Fin m₀) (w : Fin n → ℕ) (h : ℕ) (K : κ) :

          The role mask of a component at a final height h after the failed trials w with the assignment a of trials to first failing roles: good at h, bad at its own assigned trials and good at the trials assigned to later roles.

          Equations
          Instances For
            theorem TrilinearHT.Auto.masked_count {m₀ : ℕ} {κ : Fin m₀ → Type u_1} (H : Finset ℕ) (good : (j : Fin m₀) → ℕ → κ j → Prop) (r : (j : Fin m₀) → κ j) (n : ℕ) :
            (∑ a : Fin n → Fin m₀, ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ h ∈ H, if ∀ (j : Fin m₀), roleMask (good j) j a w h (r j) then 1 else 0) = ↑{h ∈ H | ∀ (j : Fin m₀), good j h (r j)}.card * ↑{h ∈ H | ¬∀ (j : Fin m₀), good j h (r j)}.card ^ n

            Blueprint lines 2466-2469 (first success, counted): for a tuple of components, the number of triples (a, w, h) of an assignment of n failed trials to first failing roles, a word of n heights and a final height, with every role in its mask, is |S| |H \ S|^n, S the heights at which all roles are good.

            theorem TrilinearHT.Auto.first_success_masked {m₀ : ℕ} {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {κ : Fin m₀ → Type u_2} (T : (j : Fin m₀) → Finset (κ j)) (H : Finset ℕ) (good : (j : Fin m₀) → ℕ → κ j → Prop) (F : ((j : Fin m₀) → κ j) → E) (hp : ∀ r ∈ Fintype.piFinset T, {h ∈ H | ∀ (j : Fin m₀), good j h (r j)}.Nonempty) :
            HasSum (fun (n : ℕ) => ∑ a : Fin n → Fin m₀, ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, ∑ h ∈ H, (↑H.card ^ (n + 1))⁻¹ • ∑ r ∈ Fintype.piFinset T with ∀ (j : Fin m₀), roleMask (good j) j a w h (r j), F r) (∑ r ∈ Fintype.piFinset T, F r)

            Blueprint lines 2463-2469 (the exact common-height selection with failure assignments): if every tuple of components has a height at which all its roles are good, the sum over the tuples is the convergent sum over the trial counts n of the sums over the assignments a of the failed trials to first failing roles, the words w of failed heights and the final heights h, with weight |H|^{-(n+1)}, of the sums over the tuples in the product masks.

            theorem TrilinearHT.Auto.ModeSystem.compGood_iff {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} {K : Finset Ms.Md} {x : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hK : K = Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).E 0 x)) (h : ℕ) :
            Ms.compGood S hA SP b J h K ↔ (Ms.blockComps S hA b J).Good SP.Δ (Ms.goodP S SP b) h x

            The goodness of a component is that of any mode it is the minimal PRE component of (good_iff_of_minimal_pre).

            theorem TrilinearHT.Auto.ModeSystem.coreComps_rep {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} {K : Finset Ms.Md} (hK : K ∈ Ms.coreComps S hA SP b J) :
            ∃ (x : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))), K = Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).E 0 x) ∧ (Ms.blockComps S hA b J).Core SP.Δ (Ms.goodP S SP b) SP.Jst SP.δs x

            Every core component is the minimal PRE component of a core mode.

            theorem TrilinearHT.Auto.ModeSystem.coreComp_bad_card {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} {K : Finset Ms.Md} (hK : K ∈ Ms.coreComps S hA SP b J) (hJ : 2 ≤ SP.Jst) (hδ : 0 < SP.δs) (hδ16 : SP.δs ≤ 1 / 16) :
            ↑{h ∈ ModeComponents.upperHeights SP.Jst SP.δs | ¬Ms.compGood S hA SP b J h K}.card ≤ 2 * SP.δs * ↑(ModeComponents.upperHeights SP.Jst SP.δs).card

            Blueprint line 2466 for components: a core component is bad at a proportion at most 2δ of the upper heights.

            The upper heights are nonempty for δ ≤ 1/16.

            theorem TrilinearHT.Auto.multilinear_regroup {V : Type u_1} [AddCommGroup V] [Module ℂ V] (Λ : MultilinearMap ℂ (fun (x : Fin 4) => V) ℂ) {κ : Fin 4 → Type u_2} {ι : Fin 4 → Type u_3} [(l : Fin 4) → DecidableEq (ι l)] (M : (l : Fin 4) → Finset (κ l)) (cls : (l : Fin 4) → κ l → ι l) (g : (l : Fin 4) → κ l → V) :
            (∑ r ∈ Fintype.piFinset M, Λ fun (l : Fin 4) => g l (r l)) = ∑ p ∈ Fintype.piFinset fun (l : Fin 4) => Finset.image (cls l) (M l), Λ fun (l : Fin 4) => ∑ K ∈ M l with cls l K = p l, g l K

            Blueprint lines 2469-2470 ("group the selected modes at the final successful components"): the sum of a 4-linear form over a product of finite sets equals the sum over the tuples of classes of the forms of the class subtotals.

            noncomputable def TrilinearHT.Auto.ModeSystem.gauge {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (y : ℝ) :

            The common gauge factor of the waves of a mode system: the center cutoff times the center branch phase.

            Equations
            Instances For
              theorem TrilinearHT.Auto.ModeSystem.wave_eq {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (m : Ms.Md) (y : ℝ) :
              Ms.wave m y = Ms.gauge y * ↑(Real.fourierChar (Ms.phase m y))

              The wave of a mode is the gauge factor times the phase character.

              theorem TrilinearHT.Auto.ModeSystem.group_torus_form {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} (hJ : J.1 ≤ b + ↑S.K) {h : ℕ} (a : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) (F : Finset ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) (hF : F ⊆ (Ms.blockComps S hA b J).E h a) (α : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K))) → ℂ) {Λ : ℝ} (hΛ : ∀ m ∈ F, |Ms.lamOf ↑m| ≤ Λ) :
              ∃ (n : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K))) → Fin Ms.zc.dim → ℤ), (∀ m ∈ F, ∀ (i : Fin Ms.zc.dim), |↑(n m i)| ≤ ↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * S.Eh h) ∧ ∀ x ∈ Set.Icc (dyadicGridLeft Gd J.1 J.2) (dyadicGridLeft Gd J.1 J.2 + dyadicGridLength Gd J.1), ∀ (y : ℝ), ‖∑ m ∈ F, α m * Ms.wave (↑m) y - Ms.gauge y * (↑(Real.fourierChar (Ms.slope (↑a) x * (y - x))) * ∑ m ∈ F, α m * (↑(Real.fourierChar (Ms.phase (↑m) x)) * ↑(Real.fourierChar (-((-∑ i : Fin Ms.zc.dim, ↑(n m i) * (Ms.zc.θ i / ↑S.Q0)) / ModeSchedule.Lh h * (y - x))))))‖ ≤ 2 * Real.pi * (↑(Fintype.card ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) * (S.Ξ / dyadicGridLength Gd J.1) * |y - x| + Λ * (y - x) ^ 2) * ∑ m ∈ F, ‖α m‖

              Blueprint eq:core-torus-form (lines 2468-2476) for the waves of one group of selected modes: inside the PRE component of the representative a at height h, the wave sum is the gauge factor times the representative phase times the trigonometric polynomial in the integer shifts, up to 2π (|alive| Ξ/r_J |y - x*| + Λ (y - x*)²) Σ |α_m|.

              noncomputable def TrilinearHT.Auto.cutoffP {d : ℕ} (δ : ℝ) (ρ w : Fin d → ℝ) :

              The periodic cutoff w ↦ Π_i b({w_i - ρ_i}) on ℝ^d (the true cutoff ζ^ρ).

              Equations
              Instances For
                theorem TrilinearHT.Auto.centerCut_eq_cutoffP (z : ChartTag) (δ : ℝ) (ρ : Fin z.dim → ℝ) (y : ℝ) :
                ↑(centerCut z δ ρ y) = cutoffP δ ρ fun (i : Fin z.dim) => z.θ i * y
                theorem TrilinearHT.Auto.cutoffP_periodic {d : ℕ} (δ : ℝ) (ρ w : Fin d → ℝ) (j : Fin d → ℤ) :
                cutoffP δ ρ (w + fun (i : Fin d) => ↑(j i)) = cutoffP δ ρ w
                theorem TrilinearHT.Auto.cutoffP_norm_le {d : ℕ} (δ : ℝ) (ρ w : Fin d → ℝ) :
                ‖cutoffP δ ρ w‖ ≤ 1
                theorem TrilinearHT.Auto.prod_four_sub_le (a b : Fin 4 → ℂ) {M ε : ℝ} (ha : ∀ (j : Fin 4), ‖a j‖ ≤ M) (hb : ∀ (j : Fin 4), ‖b j‖ ≤ M) (hε : ∀ (j : Fin 4), ‖a j - b j‖ ≤ ε) :
                ‖∏ j : Fin 4, a j - ∏ j : Fin 4, b j‖ ≤ 4 * M ^ 3 * ε

                The difference of two products of four factors bounded by M: |Π a - Π b| ≤ 4 M³ max_j |a_j - b_j|.

                The torus point of a real vector.

                Equations
                Instances For
                  theorem TrilinearHT.Auto.torusMk_add {d : ℕ} (u v : Fin d → ℝ) :
                  theorem TrilinearHT.Auto.torusMk_smul {d : ℕ} (k : ℤ) (u : Fin d → ℝ) :
                  torusMk (↑k • u) = k • torusMk u
                  theorem TrilinearHT.Auto.torusCharacter_mk {d : ℕ} (n : Fin d → ℤ) (u : Fin d → ℝ) :
                  torusCharacter n (torusMk u) = ↑(Real.fourierChar (∑ i : Fin d, ↑(n i) * u i))
                  theorem TrilinearHT.Auto.torusCharacter_mk_line {d : ℕ} (n : Fin d → ℤ) (ξ : Fin d → ℝ) (s : ℝ) :
                  torusCharacter n (torusMk fun (i : Fin d) => ξ i * s) = ↑(Real.fourierChar ((∑ i : Fin d, ↑(n i) * ξ i) * s))

                  A character at the torus point of a line: χ_n(ξ s) = e((n·ξ) s).

                  noncomputable def TrilinearHT.Auto.cutTail (d : ℕ) (δ : ℝ) (K : ℕ) :

                  The truncation error of the periodic cutoff (cutoffP_truncate).

                  Equations
                  Instances For
                    noncomputable def TrilinearHT.Auto.multTail (d : ℕ) (δ : ℝ) (Q0 : ℕ) (Cm : ℝ) (K : ℕ) :

                    The truncation error of the gauge multiplier (gaugeMult_truncate).

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      theorem TrilinearHT.Auto.cutTail_nonneg (d : ℕ) {δ : ℝ} (hδ : 0 < δ) (K : ℕ) :
                      0 ≤ cutTail d δ K
                      theorem TrilinearHT.Auto.trunc_cut_line {d : ℕ} {δ : ℝ} (ρ : Fin d → ℝ) (K : ℕ) (cc0 : (Fin d → ℤ) → ℂ) (hccT : ∀ (w : Fin d → ℝ), ‖cutoffP δ ρ w - ∑ v ∈ frequencyBox d (2 ^ (K + 1)), cc0 v * ↑(Real.fourierChar (∑ i : Fin d, ↑(v i) * w i))‖ ≤ cutTail d δ K) (θ ξ : Fin d → ℝ) (QL : ℕ) (hξ : ∀ (i : Fin d), ↑↑QL * ξ i = θ i) (xs y : ℝ) :
                      ‖∑ v ∈ frequencyBox d (2 ^ (K + 1)), cc0 v * ↑(Real.fourierChar (∑ i : Fin d, ↑(v i) * (θ i * xs))) * torusCharacter (↑QL • v) (torusMk fun (i : Fin d) => ξ i * (y - xs)) - cutoffP δ ρ fun (i : Fin d) => θ i * y‖ ≤ cutTail d δ K

                      Blueprint lines 2470-2476 (the truncated cutoff of a slot along the cell line): with QL ξ = θ, the re-centered truncated cutoff at the torus point ξ (y - x*) approximates the true cutoff ζ^ρ(θ y) within τ_c.

                      theorem TrilinearHT.Auto.trunc_cut_sup {d : ℕ} {δ : ℝ} (ρ : Fin d → ℝ) (K : ℕ) (cc0 : (Fin d → ℤ) → ℂ) (hccT : ∀ (w : Fin d → ℝ), ‖cutoffP δ ρ w - ∑ v ∈ frequencyBox d (2 ^ (K + 1)), cc0 v * ↑(Real.fourierChar (∑ i : Fin d, ↑(v i) * w i))‖ ≤ cutTail d δ K) (θ : Fin d → ℝ) (xs : ℝ) (QL : ℕ) (u : StandardTorus d) :
                      ‖∑ v ∈ frequencyBox d (2 ^ (K + 1)), cc0 v * ↑(Real.fourierChar (∑ i : Fin d, ↑(v i) * (θ i * xs))) * torusCharacter (↑QL • v) u‖ ≤ 1 + cutTail d δ K

                      A truncated slot cutoff, re-centered at x* and lifted to the torus by Q₀L, is bounded by 1 + τ_c at every torus point (the truncation approximates the periodic cutoff everywhere).

                      noncomputable def TrilinearHT.Auto.gaugeErr (d : ℕ) (δ δ'' : ℝ) :

                      The error of the gauge multiplier with cutoff parameter δ'' on the true cutoff supports (blueprint line 1942, "slightly enlarge the cutoffs inside each branch region, making them one on the required supports"): zero for the enlarged cutoff δ'' = δ/2 (gauge_factors_eq_mult_exact) and the thin-layer bound 8 d δ'' R_δ otherwise (gauge_factors_eq_mult).

                      Equations
                      Instances For
                        theorem TrilinearHT.Auto.gaugeErr_half (d : ℕ) (δ : ℝ) :
                        gaugeErr d δ (δ / 2) = 0
                        theorem TrilinearHT.Auto.gaugeErr_nonneg (d : ℕ) {δ δ'' : ℝ} (hδ : 0 < δ) (hδ'' : 0 < δ'') :
                        0 ≤ gaugeErr d δ δ''
                        theorem TrilinearHT.Auto.gauge_factors_le_gaugeErr {d : ℕ} {δ δ'' : ℝ} (hδ : 0 < δ) (hδ'' : 0 < δ'') (θ : Fin d → ℝ) (C : Matrix (Fin d) (Fin d) ℚ) (lam : ℝ) {Q0 : ℕ} (hQ0 : 0 < Q0) (l' : Fin 4) (ρ : Fin 4 → Fin d → ℝ) (x t : ℝ) :
                        ‖(∏ j : Fin 4, ↑(branchCutoffValue δ (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))) * ↑(Real.fourierChar (∑ j : Fin 4, ↑(slotCoeff j) * (lam * (x + ↑↑j * t) ^ 2 + chartMatrixPhase C (fun (a : Fin d) => θ a * (x + ↑↑j * t)) (branchLift (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))))) - (∏ j : Fin 4, ↑(branchCutoffValue δ (ρ j) fun (a : Fin d) => θ a * (x + ↑↑j * t))) * gaugeMult δ'' Q0 l' C ρ (torusPt θ Q0 l' x t)‖ ≤ gaugeErr d δ δ''

                        The four true cutoffs times the four gauge phases differ from the four true cutoffs times the multiplier with cutoff parameter δ'' by at most gaugeErr d δ δ'' (exactly equal for δ'' = δ/2).

                        theorem TrilinearHT.Auto.gauge_torus_approx_of (z : ChartTag) {δ δ'' : ℝ} (hδ : 0 < δ) (hδ'' : 0 < δ'') (ρ : Fin 4 → Fin z.dim → ℝ) (hρ : ∀ (j : Fin 4) (a : Fin z.dim), ρ j a ∈ Set.Icc 0 1) {Q0 : ℕ} (hQ0 : 0 < Q0) (hQ : ∀ (a b : Fin z.dim), ∃ (k : ℤ), ↑Q0 * ↑(z.C a b) = ↑k) {Cm : ℝ} (hCm : ∀ (a b : Fin z.dim), |↑(z.C a b)| ≤ Cm) {L : ℕ} (hL : 0 < L) (K : ℕ) (xs : ℝ) (cc0 : Fin 4 → (Fin z.dim → ℤ) → ℂ) (hcc0 : ∀ (j : Fin 4) (v : Fin z.dim → ℤ), ‖cc0 j v‖ ≤ 1) (hccT : ∀ (j : Fin 4) (w : Fin z.dim → ℝ), ‖cutoffP δ (ρ j) w - ∑ v ∈ frequencyBox z.dim (2 ^ (K + 1)), cc0 j v * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑(v i) * w i))‖ ≤ cutTail z.dim δ K) (cm0 : (Fin (z.dim + z.dim) → ℤ) → ℂ) (hcm0 : ∀ (v : Fin (z.dim + z.dim) → ℤ), ‖cm0 v‖ ≤ 1) (hcmT : ∀ (w : Fin (z.dim + z.dim) → ℝ), ‖gaugeMult δ'' Q0 0 z.C ρ w - ∑ v ∈ frequencyBox (z.dim + z.dim) (2 ^ (K + 1)), cm0 v * ↑(Real.fourierChar (∑ i : Fin (z.dim + z.dim), ↑(v i) * w i))‖ ≤ multTail z.dim δ'' Q0 Cm K) :
                        ∃ (cc : Fin 4 → (Fin z.dim → ℤ) → ℂ) (cm : (Fin (z.dim + z.dim) → ℤ) → ℂ), (∀ (j : Fin 4) (v : Fin z.dim → ℤ), cc j v = cc0 j v * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑(v i) * (z.θ i * xs)))) ∧ (∀ (v : Fin (z.dim + z.dim) → ℤ), cm v = cm0 v * ↑(Real.fourierChar (∑ a : Fin z.dim, ↑(v (Fin.castAdd z.dim a)) * (z.θ a * xs / ↑Q0)))) ∧ (∀ (j : Fin 4) (v : Fin z.dim → ℤ), ‖cc j v‖ ≤ 1) ∧ (∀ (v : Fin (z.dim + z.dim) → ℤ), ‖cm v‖ ≤ 1) ∧ (∀ (j : Fin 4) (u : StandardTorus z.dim), ‖∑ v ∈ frequencyBox z.dim (2 ^ (K + 1)), cc j v * torusCharacter (↑(Q0 * L) • v) u‖ ≤ 1 + cutTail z.dim δ K) ∧ (∀ (j : Fin 4) (y : ℝ), ‖∑ v ∈ frequencyBox z.dim (2 ^ (K + 1)), cc j v * torusCharacter (↑(Q0 * L) • v) (torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * (y - xs)) - ↑(centerCut z δ (ρ j) y)‖ ≤ cutTail z.dim δ K) ∧ ∀ (x t : ℝ), ‖∏ j : Fin 4, ↑(centerCut z δ (ρ j) (x + ↑↑j * t)) * ↑(Real.fourierChar (↑(slotCoeff j) * centerPhase z (ρ j) (x + ↑↑j * t))) - (∑ v ∈ frequencyBox (z.dim + z.dim) (2 ^ (K + 1)), cm v * (torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.castAdd z.dim a)) (torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * (x - xs)) * torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.natAdd z.dim a)) (torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * t))) * ∏ j : Fin 4, ∑ v ∈ frequencyBox z.dim (2 ^ (K + 1)), cc j v * torusCharacter (↑(Q0 * L) • v) ((torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * (x - xs)) + (↑↑j - 0) • torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * t)‖ ≤ gaugeErr z.dim δ δ'' + 4 * (1 + cutTail z.dim δ K) ^ 3 * cutTail z.dim δ K + (1 + cutTail z.dim δ K) ^ 4 * multTail z.dim δ'' Q0 Cm K

                        Blueprint lines 2470-2479 (eq:gauge-cancel with the true cutoffs, then their Fourier truncation): with ξ = θ/(Q₀ L), u = ξ(x - x*) and v = ξ t, the four gauge factors of a common chart tag at y_j = x + j t are, up to E_g + 4 (1+τ_c)³ τ_c + (1+τ_c)⁴ τ_m, the torus trigonometric polynomial R(u, v) Π_j K_j(u + j v), where K_j (truncated cutoffs, with frequencies Q₀ L v) and R (truncated multiplier, with frequencies (L v₁, L v₂)) have coefficients of modulus at most one.

                        theorem TrilinearHT.Auto.prod_four_sub_le_rel (a b : Fin 4 → ℂ) (M : Fin 4 → ℝ) {η : ℝ} (hη : 0 ≤ η) (ha : ∀ (j : Fin 4), ‖a j‖ ≤ M j) (hb : ∀ (j : Fin 4), ‖b j‖ ≤ M j) (hε : ∀ (j : Fin 4), ‖a j - b j‖ ≤ η * M j) :
                        ‖∏ j : Fin 4, a j - ∏ j : Fin 4, b j‖ ≤ 4 * η * ∏ j : Fin 4, M j

                        The difference of two products of four factors with relative errors: if |a_j|, |b_j| ≤ M_j and |a_j - b_j| ≤ η M_j, then |Π a - Π b| ≤ 4 η Π M_j.

                        theorem TrilinearHT.Auto.four_inputs_approx (z : ChartTag) (δ : ℝ) (ρ : Fin 4 → Fin z.dim → ℝ) (ξ : Fin z.dim → ℝ) (xs : ℝ) (γ : Fin 4 → ℝ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin z.dim → ℤ) (f : Fin 4 → ℝ → ℂ) (lo hi : ℝ) {η : ℝ} (hη : 0 ≤ η) (hfa : ∀ (j : Fin 4), ∀ y ∈ Set.Icc lo hi, ‖f j y - ↑(centerCut z δ (ρ j) y) * ↑(Real.fourierChar (↑(slotCoeff j) * centerPhase z (ρ j) y)) * (↑(Real.fourierChar (γ j * (y - xs))) * ∑ k ∈ F j, c j k * torusCharacter (n j k) (torusMk fun (i : Fin z.dim) => ξ i * (y - xs)))‖ ≤ η * ∑ k ∈ F j, ‖c j k‖) (hfb : ∀ (j : Fin 4), ∀ y ∈ Set.Icc lo hi, ‖f j y‖ ≤ ∑ k ∈ F j, ‖c j k‖) {B QL L : ℕ} (cc : Fin 4 → (Fin z.dim → ℤ) → ℂ) (cm : (Fin (z.dim + z.dim) → ℤ) → ℂ) {Eg : ℝ} (hg : ∀ (x t : ℝ), ‖∏ j : Fin 4, ↑(centerCut z δ (ρ j) (x + ↑↑j * t)) * ↑(Real.fourierChar (↑(slotCoeff j) * centerPhase z (ρ j) (x + ↑↑j * t))) - (∑ v ∈ frequencyBox (z.dim + z.dim) B, cm v * (torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.castAdd z.dim a)) (torusMk fun (i : Fin z.dim) => ξ i * (x - xs)) * torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.natAdd z.dim a)) (torusMk fun (i : Fin z.dim) => ξ i * t))) * ∏ j : Fin 4, ∑ v ∈ frequencyBox z.dim B, cc j v * torusCharacter (↑QL • v) ((torusMk fun (i : Fin z.dim) => ξ i * (x - xs)) + (↑↑j - 0) • torusMk fun (i : Fin z.dim) => ξ i * t)‖ ≤ Eg) (x t : ℝ) (hxt : ∀ (j : Fin 4), x + ↑↑j * t ∈ Set.Icc lo hi) :
                        ‖∏ j : Fin 4, f j (x + ↑↑j * t) - ↑(Real.fourierChar (∑ j : Fin 4, γ j * (x + ↑↑j * t - xs))) * ((∑ v ∈ frequencyBox (z.dim + z.dim) B, cm v * (torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.castAdd z.dim a)) (torusMk fun (i : Fin z.dim) => ξ i * (x - xs)) * torusCharacter (↑L • fun (a : Fin z.dim) => v (Fin.natAdd z.dim a)) (torusMk fun (i : Fin z.dim) => ξ i * t))) * ∏ j : Fin 4, ∑ p ∈ frequencyBox z.dim B ×ˢ F j, cc j p.1 * c j p.2 * torusCharacter (↑QL • p.1 + n j p.2) ((torusMk fun (i : Fin z.dim) => ξ i * (x - xs)) + (↑↑j - 0) • torusMk fun (i : Fin z.dim) => ξ i * t))‖ ≤ (4 * η + Eg) * ∏ j : Fin 4, ∑ k ∈ F j, ‖c j k‖

                        Blueprint lines 2470-2479 (eq:core-torus-form for the four core roles together with the gauge multiplier): if each input is, on the cell, within η Σ_k |c_{j,k}| of gauge_j(y) e(γ_j (y - x*)) Σ_k c_{j,k} χ_{n_{j,k}}(ξ (y - x*)) and bounded by Σ_k |c_{j,k}|, and the four gauges at y_j = x + j t are within E_g of R(u, v) Π_j K_j(u + j v), then on the cell the product of the inputs is within (4 η + E_g) Π_j Σ_k |c_{j,k}| of e(Σ_j γ_j (y_j - x*)) R(u, v) Π_j g_j(u + j v) with g_j = K_j · Σ_k c_{j,k} χ_{n_{j,k}} expanded over box × F_j.

                        theorem TrilinearHT.Auto.augMode_sum_none {V : Type u_1} [DecidableEq V] (J : Set ℝ) (ψ : V → ℝ → ℂ) (εw : V → ℝ) (M : Finset V) (β : V → ℂ) (y : ℝ) (hy : y ∈ J) :
                        (∑ m ∈ M, β m • augMode J (ψ m) (εw m) m y).ofLp none = ∑ m ∈ M, β m * ψ m y

                        The physical part of a combination of augmented modes on J is the combination of the physical waves.

                        theorem TrilinearHT.Auto.offset_average_form {r : ℝ} (w : ℝ × ℝ → ℂ) (f : Fin 4 → ℝ → ℂ) (hfi : MeasureTheory.Integrable (fun (z : ℝ × ℝ) => w z * ∏ j : Fin 4, f j (realProgressionCoordinate j z)) MeasureTheory.volume) (l : Fin 4) {d : ℕ} (θ : Fin d → ℝ) {δ : ℝ} (hδ : 0 < δ) (hdδ : 8 * ↑d * δ ≤ 1) (hδ' : δ ≤ 1 / 8) :
                        ‖localProgressionForm r w f‖ ≤ 2 * ∫ (ρ : Fin d → ℝ), ‖localProgressionForm r w (Function.update f l fun (y : ℝ) => ↑(branchCutoffValue δ ρ fun (i : Fin d) => θ i * y) * f l y)‖ ∂offsetMeasure d

                        Blueprint line 2478 ("insert an independent offset cutoff ζ^{ρ_l} divided by its constant expectation c_ζ ≥ 1/2"): for an integrable local form, inserting the offset cutoff ζ^ρ(θ y) into the side slot l and averaging over the offset recovers c_ζ times the form, so |Λ(f)| ≤ 2 E_ρ |Λ(f with ζ^ρ f_l in slot l)|.

                        theorem TrilinearHT.Auto.offset_form_anchored {r : ℝ} (w : ℝ × ℝ → ℂ) (f : Fin 4 → ℝ → ℂ) (l : Fin 4) (ζ ph : ℝ → ℝ) :
                        localProgressionForm r w (Function.update f l fun (y : ℝ) => ↑(ζ y) * f l y) = (↑r)⁻¹ ^ 2 * ∫ (z : ℝ × ℝ), w z * ((∏ j ∈ Finset.univ.erase l, f j (realProgressionCoordinate j z)) * (↑(ζ (realProgressionCoordinate l z)) * ↑(Real.fourierChar (ph (realProgressionCoordinate l z)))) * (↑(Real.fourierChar (-ph (realProgressionCoordinate l z))) * f l (realProgressionCoordinate l z)))

                        Blueprint lines 2478-2480 (S' = ζ^{ρ_l} e(-c_l p_{ρ_l}) S_phys, the side gauge joins the core product): with the side gauge G_l = ζ^ρ e(c_l p_ρ), the form with the offset cutoff inserted in the side slot is the anchored form with core factor Π_{j ≠ l} f_j(y_j) · G_l(y_l) and side e(-c_l p_ρ) f_l.

                        theorem TrilinearHT.Auto.ModeSystem.cellMode_sum_none {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (J : ℤ × ℤ) (E : Finset Ms.Md) (α : Ms.Md → ℂ) :
                        ∀ᵐ (y : ℝ), y ∈ dyadicGridCell Gd J.1 J.2 → (↑↑(∑ m ∈ E, α m • Ms.cellMode J m) y).ofLp none = ∑ m ∈ E, α m * Ms.wave m y

                        The physical function of a combination of cell modes on J: a.e. the combination of the waves on J.

                        theorem TrilinearHT.Auto.truncMult_le_card {d : ℕ} (B L : ℕ) (cm : (Fin (d + d) → ℤ) → ℂ) (hcm : ∀ (v : Fin (d + d) → ℤ), ‖cm v‖ ≤ 1) (u v : StandardTorus d) :
                        ‖∑ q ∈ frequencyBox (d + d) B, cm q * (torusCharacter (↑L • fun (a : Fin d) => q (Fin.castAdd d a)) u * torusCharacter (↑L • fun (a : Fin d) => q (Fin.natAdd d a)) v)‖ ≤ ↑(frequencyBox (d + d) B).card

                        The truncated multiplier is bounded by the number of its frequencies (blueprint line 2476: absolute Fourier costs are fixed powers of D_*).

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

                        The decision cell U = anc_{b-4K}(J) of the pre-cell of I.

                        Equations
                        Instances For
                          noncomputable def TrilinearHT.Auto.ModeSystem.compClass {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) (h : ℕ) (K : Finset Ms.Md) :

                          The final CURRENT class at height h of a component K of the block b on the pre-cell J (blueprint line 2467, "group the selected modes at the final successful components"): the union of the CURRENT components F_h(x) of the modes x whose minimal component is K.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem TrilinearHT.Auto.ModeSystem.compClass_eq {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (b : ℤ) (J : ℤ × ℤ) (h : ℕ) (x : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) :
                            Ms.compClass S hA b J h (Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).E 0 x)) = Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F h x)

                            The final class of the minimal component of x is the CURRENT component of x.

                            theorem TrilinearHT.Auto.core_pattern_cases (σ : Fin 4 → Fin 3) :
                            (∀ (l : Fin 4), σ l ≠ 2) → 3 ≤ patternCount σ 0 → (σ = fun (x : Fin 4) => 0) ∨ ∃ (l : Fin 4), σ = fun (k : Fin 4) => if k = l then 1 else 0

                            Blueprint lines 2461-2462: a pattern without physical errors and with at least three cores is the four-core pattern or has exactly one side slot l.

                            The core reduction on the side states (blueprint line 2461) #

                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.Λc_phys {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (I : ℤ × ℤ) (x : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
                            (fp.Λc I) x = (fp.Λc I) fun (l : Fin 4) => (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (x l)

                            The cell forms of the main columns see only the physical parts of their inputs.

                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physMain_physMain {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) {V : Type u_1} [Fintype V] (x : ↥(ColumnL2 V)) :
                            (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) ((fp.physMain V) x) = (fp.physMain V) x

                            The physical coordinate is idempotent.

                            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                            ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                            The full core subtotal A_{l,G,b} of the block of the cell I restricted to I, in physical coordinates (zero in the basic U slot, which is a side; blueprint line 2461).

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.errAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                              ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                              The physical error E_{l,G,b} of the block of the cell I for the lifts L, restricted to I (zero in the basic U slot).

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.RepAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :

                                The frozen coefficients represent the lifted frozen outputs on the retained v_b-cells of the block of I (the first export of linear_energy).

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.phys_out_eq {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (l : Fin 4) (G : bf.Grp) (hrep : D.u ≠ some l → D.RepAt L l G I) :
                                  (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (D.toLeaf.out l G I) = D.coreAt l G I + (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (D.toLeaf.sv l G I) + D.errAt L l G I

                                  Blueprint eq:core-side-error on a cell (line 2129): the physical part of the whole leaf output is the core plus the side plus the error (in the basic U slot the whole output is the side).

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.physMain_coreAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                  (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (D.coreAt l G I) = D.coreAt l G I
                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.physMain_errAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
                                  (fp.physMain (bf.Lab ⊕ Fin fp.Mc)) (D.errAt L l G I) = D.errAt L l G I
                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.form_expand {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hrep : ∀ (l : Fin 4), D.u ≠ some l → D.RepAt L l G I) :
                                  ((fp.Λc I) fun (l : Fin 4) => D.toLeaf.out l G I) = ∑ σ : Fin 4 → Fin 3, (fp.Λc I) (patternPiece (fun (l : Fin 4) => D.coreAt l G I) (fun (l : Fin 4) => D.toLeaf.sv l G I) (fun (l : Fin 4) => D.errAt L l G I) σ)

                                  Blueprint eq:core-side-error in the cell form (line 2461): the form of the whole leaf outputs is the sum over the core/side/error patterns of the forms of their pieces.

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.restored_eq {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hrep : ∀ (l : Fin 4), D.u ≠ some l → D.RepAt L l G I) (σ : Fin 4 → Fin 3) :
                                  ((fp.Λc I) fun (l : Fin 4) => if σ l = 0 then D.coreAt l G I + D.toLeaf.sv l G I + D.errAt L l G I else D.toLeaf.sv l G I) = (fp.Λc I) fun (l : Fin 4) => if σ l = 0 then D.toLeaf.out l G I else D.toLeaf.sv l G I

                                  The restored two-side patterns of the pieces are the two-side patterns of the whole outputs and the sides (the form sees only physical parts).

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.form_expandQ {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hrep : ∀ (l : Fin 4), D.u ≠ some l → (D.withQ0 (qG G)).RepAt L l G I) :
                                  ((fp.Λc I) fun (l : Fin 4) => (D.toLeafQ qG).out l G I) = ∑ σ : Fin 4 → Fin 3, (fp.Λc I) (patternPiece (fun (l : Fin 4) => (D.withQ0 (qG G)).coreAt l G I) (fun (l : Fin 4) => (D.toLeafQ qG).sv l G I) (fun (l : Fin 4) => (D.withQ0 (qG G)).errAt L l G I) σ)

                                  form_expand for the leaf data with per-group clearing integers.

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.restored_eqQ {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hrep : ∀ (l : Fin 4), D.u ≠ some l → (D.withQ0 (qG G)).RepAt L l G I) (σ : Fin 4 → Fin 3) :
                                  ((fp.Λc I) fun (l : Fin 4) => if σ l = 0 then (D.withQ0 (qG G)).coreAt l G I + (D.toLeafQ qG).sv l G I + (D.withQ0 (qG G)).errAt L l G I else (D.toLeafQ qG).sv l G I) = (fp.Λc I) fun (l : Fin 4) => if σ l = 0 then (D.toLeafQ qG).out l G I else (D.toLeafQ qG).sv l G I

                                  restored_eq for the leaf data with per-group clearing integers.

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.cell_reduction {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (gsI : Finset bf.Grp) (hrep : ∀ G ∈ gsI, ∀ (l : Fin 4), D.u ≠ some l → (D.withQ0 (qG G)).RepAt L l G I) :
                                  ‖∑ G ∈ gsI, (fp.Λc I) fun (l : Fin 4) => (D.toLeafQ qG).out l G I‖ ≤ ‖∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ {l : Fin 4 | σ l = 0}.card = 2 ∧ {l : Fin 4 | σ l = 1}.card = 2, ∑ G ∈ gsI, (fp.Λc I) fun (l : Fin 4) => if σ l = 0 then (D.toLeafQ qG).out l G I else (D.toLeafQ qG).sv l G I‖ + 82 * ∑ τ : Fin 4 → Fin 3 with ∃ (l : Fin 4), τ l = 2, ‖∑ G ∈ gsI, (fp.Λc I) (patternPiece (fun (l : Fin 4) => (D.withQ0 (qG G)).coreAt l G I) (fun (l : Fin 4) => (D.toLeafQ qG).sv l G I) (fun (l : Fin 4) => (D.withQ0 (qG G)).errAt L l G I) τ)‖ + 82 * ∑ τ : Fin 4 → Fin 3 with (∀ (l : Fin 4), τ l ≠ 2) ∧ 3 ≤ patternCount τ 1, ‖∑ G ∈ gsI, (fp.Λc I) (patternPiece (fun (l : Fin 4) => (D.withQ0 (qG G)).coreAt l G I) (fun (l : Fin 4) => (D.toLeafQ qG).sv l G I) (fun (l : Fin 4) => (D.withQ0 (qG G)).errAt L l G I) τ)‖ + ‖∑ τ : Fin 4 → Fin 3 with (∀ (l : Fin 4), τ l ≠ 2) ∧ 3 ≤ patternCount τ 0, ∑ G ∈ gsI, (fp.Λc I) (patternPiece (fun (l : Fin 4) => (D.withQ0 (qG G)).coreAt l G I) (fun (l : Fin 4) => (D.toLeafQ qG).sv l G I) (fun (l : Fin 4) => (D.withQ0 (qG G)).errAt L l G I) τ)‖

                                  Blueprint line 2461 on one cell: the form of the whole leaf outputs summed over the groups is at most the restored two-side patterns of the whole outputs and sides, 82 times the error patterns and the patterns with at least three sides, and the patterns with at least three cores (a basic U role remains a side: its core and error vanish).

                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.core_size_phys {κ' : 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.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) ⋯) ((fp.physMain Ms.Md) (Ms.blockSide S hA SP b (fp.retainedV G b S.K) c))‖

                                  Blueprint line 2164 with the physical side subtotal: on a cell I inside a retained v_b-cell, ‖1_I A‖ ≤ √5 (‖1_I Z_h‖ + ‖1_I (Z_h - Z_{u_b})‖) + ‖1_I V_phys‖.

                                  noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.roll {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (h : ℤ) :
                                  ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                                  The rolling increment Z_{l,G,h} - Z_{l,G,u_b} of the slot l at the depth h.

                                  Equations
                                  Instances For
                                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.pV {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (h : ℤ) :
                                    ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))

                                    The physical linear side V_{l,G,b} of the block of the depth h.

                                    Equations
                                    Instances For
                                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.roll_cell_energy {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (hanc : A.AncClosed) (hne : A.cells.Nonempty) (l : Fin 4) (S : Finset (ℤ × ℤ)) (hS : S ⊆ A.cells) (gs : ℤ × ℤ → Finset bf.Grp) (gset : Finset bf.Grp) (hgs : ∀ I ∈ S, gs I ⊆ gset) (k : ℕ) (hcertS : ∀ I ∈ S, ∀ G ∈ gs I, fp.Cert k G I) (B : (D.toLeafQ qG).BallData gset) {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) (hτN : τ' * ↑B.N * A.colBudget ^ 2 ≤ 1) (cc : ℕ) (hc : 1 ≤ cc) {kk : ℝ} (hk : 1 ≤ kk) (hDm : ∀ (l : Fin 4), Real.log (2 * (D.mbs l).B) ≤ kk ^ cc) (hDb : Real.log (2 * A.colBudget) ≤ kk ^ cc) (hLs : ∀ (l : Fin 4), ↑(D.Lf.layers l).length ≤ ↑cc * (Real.log kk + 1)) :
                                      ∑ I ∈ S, ∑ G ∈ gs I, ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (D.roll l G I.1)‖ ^ 2 ≤ ↑D.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

                                      Blueprint line 2159 (rolling sides): the rolling increments of a basic slot on the cells of all groups have total square at most K (20 G₀ + 32) |R| (rolling_budget).

                                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.V_cell_energy {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (l : Fin 4) (S : Finset (ℤ × ℤ)) (hS : S ⊆ A.cells) (gs : ℤ × ℤ → Finset bf.Grp) (gset : Finset bf.Grp) (hgs : ∀ I ∈ S, gs I ⊆ gset) (Bn : ℕ) (hBn : ∀ I ∈ S, (D.toLeafQ qG).bk I < Bn) {Vl : ℝ} (hlin : ∑ G ∈ gset, ∑ β ∈ Finset.range Bn, ‖(D.Ms l G).blockSide (D.S.withQ0 (qG G)) ⋯ D.SP (A.R.1 + ↑(D.S.K * β)) (fp.retainedV G (A.R.1 + ↑(D.S.K * β)) D.S.K) (D.c l G (A.R.1 + ↑(D.S.K * β)))‖ ^ 2 ≤ Vl * dyadicGridLength A.G A.R.1) :
                                      ∑ I ∈ S, ∑ G ∈ gs I, ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((D.withQ0 (qG G)).pV l G I.1)‖ ^ 2 ≤ ↑D.S.K * (Vl * dyadicGridLength A.G A.R.1)

                                      Blueprint line 2159 ("a fixed V_{l,G,b} is counted at most K times"): the physical linear sides of a basic slot on the cells of all groups have total square at most K V_l |R| under the linear-side bound.

                                      theorem TrilinearHT.Auto.min_four_le {η a e t c : ℝ} (hη : 0 ≤ η) (ha : 0 ≤ a) (he : 0 ≤ e) (ht : 0 ≤ t) (hc : 0 ≤ c) :
                                      min η (a + 82 * e + 82 * t + c) ≤ min η a + 82 * e + 82 * min η t + min η c

                                      Four cell terms under one minimum.

                                      noncomputable def TrilinearHT.Auto.coreBd (B₀ T : ℝ) :

                                      The core size bound √5 (B₀ + √T) + √T on retained cells (blueprint line 2164).

                                      Equations
                                      Instances For
                                        noncomputable def TrilinearHT.Auto.errBd (B₀ T : ℝ) :

                                        The error size bound (1 + √5)(B₀ + √T) on retained cells (blueprint line 2164).

                                        Equations
                                        Instances For
                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.retainedV_eq_empty {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} (fp : bf.FamParams) (G : bf.Grp) {b : ℤ} {K : ℕ} (hb : b - 2 * ↑K < A.R.1) :
                                          fp.retainedV G b K = ∅

                                          Before the attempt there are no retained v_b-cells.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.physError_eq_zero {κ' : 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 : ℤ} (hb : b - 4 * ↑K < A.R.1) :
                                          fp.physError Ms L l s mb G j ls K b = 0

                                          Before the attempt the physical error vanishes (the frozen output is zero).

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.out_eq_restrict {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {l : Fin 4} (hl : D.u ≠ some l) (G : bf.Grp) {I : ℤ × ℤ} (hI : I ∈ A.cells) :
                                          D.toLeaf.out l G I = (columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (fp.basicOut l (D.cat l) (D.mbs l) G (D.Lf.role l) (D.Lf.layers l) I.1)

                                          The whole output of a basic slot on an active cell is the restriction of its coarse output.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.sizes_at {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (huse : fp.ActualUse G I) (l : Fin 4) (hrep : D.RepAt L l G I) {B₀ T : ℝ} (hB₀ : 0 ≤ B₀) (hout : ‖D.toLeaf.out l G I‖ ≤ B₀ * √(dyadicGridLength A.G I.1)) (hroll : ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (D.roll l G I.1)‖ ≤ √T * √(dyadicGridLength A.G I.1)) (hpV : ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (D.pV l G I.1)‖ ≤ √T * √(dyadicGridLength A.G I.1)) :
                                          ‖D.coreAt l G I‖ ≤ coreBd B₀ T * √(dyadicGridLength A.G I.1) ∧ ‖D.errAt L l G I‖ ≤ errBd B₀ T * √(dyadicGridLength A.G I.1)

                                          Blueprint line 2164 on one cell of an actual use: with the whole output, the rolling increment and the physical linear side of normalized sizes at most B₀, √T, √T, the core and the physical error have normalized sizes at most coreBd B₀ T and errBd B₀ T.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.sizes_atQ {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (huse : fp.ActualUse G I) (l : Fin 4) (hrep : (D.withQ0 (qG G)).RepAt L l G I) {B₀ T : ℝ} (hB₀ : 0 ≤ B₀) (hout : ‖(D.toLeafQ qG).out l G I‖ ≤ B₀ * √(dyadicGridLength A.G I.1)) (hroll : ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) (D.roll l G I.1)‖ ≤ √T * √(dyadicGridLength A.G I.1)) (hpV : ‖(columnL2Restriction (dyadicGridCell A.G I.1 I.2) ⋯) ((D.withQ0 (qG G)).pV l G I.1)‖ ≤ √T * √(dyadicGridLength A.G I.1)) :
                                          ‖(D.withQ0 (qG G)).coreAt l G I‖ ≤ coreBd B₀ T * √(dyadicGridLength A.G I.1) ∧ ‖(D.withQ0 (qG G)).errAt L l G I‖ ≤ errBd B₀ T * √(dyadicGridLength A.G I.1)

                                          sizes_at for the group's own schedule, with the output of the family leaf toLeafQ.

                                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.T2 {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (cc : ℕ) (kk : ℝ) (Vl : Fin 4 → ℝ) (ρ₂ : ℝ) :

                                          The cap of the rolling increments and the physical linear sides on the retained paths of the second cut: Σ_l (K (20 G₀ + 32) + K V_l) / ρ₂ over the basic slots.

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