Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec151ExactCommonHeightSelection.CoreReduction

Trilinear Hilbert transform: core_reduction #

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.core_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) (hanc : A.AncClosed) (hne : A.cells.Nonempty) (S : Finset (ℤ × ℤ)) (hS : S ⊆ A.cells) (gs : ℤ × ℤ → Finset bf.Grp) (gset : Finset bf.Grp) (hgs : ∀ I ∈ S, gs I ⊆ gset) (k Bn : ℕ) (hcertS : ∀ I ∈ S, ∀ G ∈ gs I, fp.Cert k G I) (huse : ∀ I ∈ S, ∀ G ∈ gs I, fp.ActualUse G I) (hBn : ∀ I ∈ S, (D.toLeafQ qG).bk I < Bn) (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)) {Vl : Fin 4 → ℝ} (hlin : ∀ (l : Fin 4), D.u ≠ some l → ∑ 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 l * dyadicGridLength A.G A.R.1) (hrep : ∀ I ∈ S, ∀ G ∈ gs I, ∀ (l : Fin 4), D.u ≠ some l → (D.withQ0 (qG G)).RepAt L l G I) {B₀ : ℝ} (hB₀ : 0 ≤ B₀) (hout : ∀ I ∈ S, ∀ G ∈ gs I, ∀ (l : Fin 4), ‖(D.toLeafQ qG).out l G I‖ ≤ B₀ * √(dyadicGridLength A.G I.1)) (C : Finset (ℤ × ℤ)) {η : ℝ} (hη : 0 ≤ η) {B₂ Tc : ℝ} (htwo : ∑ I ∈ S with ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2, dyadicGridLength A.G I.1 * min η ‖∑ σ : 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 ∈ gs 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‖ ≤ B₂) (hcap : ∀ (x : ℝ), ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with x ∈ dyadicGridCell A.G I.1 I.2, ∑ G ∈ gs I, (D.toLeafQ qG).s2 G I ≤ Tc) {B₃ : ℝ → ℝ} (hthree : ∀ (core err : ℤ × ℤ → bf.Grp → Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))), ∀ S' ⊆ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2}, ∀ {Bc : ℝ}, 0 ≤ Bc → (∀ I ∈ S', ∀ G ∈ gs I, ∀ (l : Fin 4), ‖core I G l‖ ≤ Bc * √(dyadicGridLength A.G I.1)) → ∑ I ∈ S', dyadicGridLength A.G I.1 * min η (∑ σ : Fin 4 → Fin 3 with (∀ (l : Fin 4), σ l ≠ 2) ∧ 3 ≤ patternCount σ 1, ‖∑ G ∈ gs I, (fp.Λc I) (patternPiece (core I G) (fun (l : Fin 4) => (D.toLeafQ qG).sv l G I) (err I G) σ)‖) ≤ B₃ Bc) {Ee M : ℝ} (hEe : ∑ I ∈ S, ∑ G ∈ gs I, ∑ l : Fin 4, ‖(D.withQ0 (qG G)).errAt L l G I‖ ^ 2 ≤ Ee) (hM : ∑ I ∈ S, dyadicGridLength A.G I.1 * ↑(gs I).card ≤ M) {ρ₂ : ℝ} (hρ₂ : 0 < ρ₂) (hρ₂1 : ρ₂ < 1) :
∃ C₂ ⊆ S, dyadicRootLength A.G C₂ ≤ ρ₂ * dyadicGridLength A.G A.R.1 ∧ (∀ I ∈ {I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} | ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2}, ∀ G ∈ gs I, ∀ (l : Fin 4), ‖(D.withQ0 (qG G)).coreAt l G I‖ ≤ coreBd B₀ (D.T2 cc kk Vl ρ₂) * √(dyadicGridLength A.G I.1) ∧ ‖(D.withQ0 (qG G)).errAt L l G I‖ ≤ errBd B₀ (D.T2 cc kk Vl ρ₂) * √(dyadicGridLength A.G I.1) ∧ ‖(D.toLeafQ qG).sv l G I‖ ≤ √Tc * √(dyadicGridLength A.G I.1)) ∧ ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2, dyadicGridLength A.G I.1 * min η ‖∑ G ∈ gs I, (fp.Λc I) fun (l : Fin 4) => (D.toLeafQ qG).out l G I‖ ≤ B₂ + 82 * (81 * (localFormUniformConstant κ' * (coreBd B₀ (D.T2 cc kk Vl ρ₂) + errBd B₀ (D.T2 cc kk Vl ρ₂) + √Tc) ^ 3) * (√(4 * M) * √Ee)) + 82 * B₃ (coreBd B₀ (D.T2 cc kk Vl ρ₂)) + ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2, dyadicGridLength A.G I.1 * min η ‖∑ τ : Fin 4 → Fin 3 with (∀ (l : Fin 4), τ l ≠ 2) ∧ 3 ≤ patternCount τ 0, ∑ G ∈ gs I, (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, the reduction of the core terms on the side states. Take the cut family C of the side estimate (two-side bound B₂, side cap T_c, three-side power bound B₃(B_c) on retained cells with cores of normalized size B_c) and a second cut C₂ of root fraction at most ρ₂ for the integrated budgets of the rolling sides (eq:variation) and the linear sides (eq:linear-energy). On the cells retained by both, the cores, errors and sides have the P^C retained sizes coreBd, errBd and √T_c (the lift is pointwise bounded), and the weighted active minimum of the whole leaf outputs is at most B₂, 82 times the error patterns (bounded by eq:physical-error, the active multiplicity M and Cauchy-Schwarz), 82 B₃ and the weighted active minimum of the patterns with at least three cores. A basic U role remains a side.

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.core_reduction_leaf {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (qG : bf.Grp → ℕ) {q : ℝ} (hq2 : 2 < q) (hq3 : q < 3) (hanc : A.AncClosed) (hne : A.cells.Nonempty) {fuel : ℕ} {up₀ : Fin 4} {s : ℕ} (hLf : D.Lf = leafAt fuel fp.Lc up₀ s) (hmH : 2 * fuel + 2 ≤ fp.mH) {Nd N : ℕ} (hKNd : A.DepthWin Nd) (hKN : D.S.K ≤ 2 ^ N) (S : Finset (ℤ × ℤ)) (hS : S ⊆ A.cells) (hroot : ∀ I ∈ S, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G A.R.1 A.R.2) (gs : ℤ × ℤ → Finset bf.Grp) (gset : Finset bf.Grp) (hgs : ∀ I ∈ S, gs I ⊆ gset) (Lp Jm Bn k : ℕ) (hBn : ∀ I ∈ S, (D.toLeafQ qG).bk I < Bn) (hLp : ∀ (l : Fin 4), ((D.toLeafQ qG).pe l).length ≤ Lp) (hJm : ∀ (c d : Fin 4) (i i' : ℕ), ((D.toLeafQ qG).desc c d ((D.toLeafQ qG).tOf c i) ((D.toLeafQ qG).tOf d i')).length ≤ Jm) (Act : Finset (ℤ × ℤ)) (hact : ∀ I ∈ S, I ∈ Act ∧ ∀ G ∈ gs I, G ∈ fp.groupsAt I k) {Mp : ℝ} (hMp : ∀ (y : ℝ), ↑{c ∈ Act | y ∈ dyadicGridCell A.G c.1 c.2}.card ≤ Mp) (hcertS : ∀ I ∈ S, ∀ G ∈ gs I, fp.Cert k G I) (huse : ∀ I ∈ S, ∀ G ∈ gs I, fp.ActualUse G I) {Np : ℝ} (hNp : ∀ (c d : Fin 4), ↑((D.toLeafQ qG).pe d).length * ↑((D.toLeafQ qG).pe c).length ≤ Np) {τ : ℝ} (hτ : 0 ≤ τ) (hpair : ∀ I ∈ S, ∀ (c d : Fin 4), c ≠ d → D.u ≠ some c → D.u ≠ some d → PairSmall (dyadicGridLeft A.G I.1 I.2) (dyadicGridLength A.G I.1) (A.w I) c d (A.Y I c) (A.Y I d) τ) {CF : ℝ} (hCF : 0 < CF) (hnormF : ∀ (l : Fin 4) (jb : Fin 2), ∀ U ∈ A.cells, ‖(columnL2Restriction (dyadicGridCell A.G U.1 U.2) ⋯) (bf.P l jb).Z‖ ^ 2 ≤ CF * dyadicGridLength A.G U.1) {η₀ E : ℝ} (hsub : A.SubRootProps η₀ E) {τr : ℕ → ℝ} (hpass : ∀ I ∈ S, ∀ (l : Fin 4), D.u ≠ some l → ∀ (w : fp.TestName I Unit), fp.MainRk w → (fp.testOf l I (fun (x : Unit) => bf.basicIn fp.Mc l I) w).Pass A.G (bf.origCols l) I A.csrc A.Hsrc bf.vtag (A.w I) (τr (fp.testOf l I (fun (x : Unit) => bf.basicIn fp.Mc l I) w).r) fp.mH (D.cat l)) {τH : ℝ} (hτH : 0 ≤ τH) {Bh : Type} (gE : ℤ × ℤ → Bh → bf.Grp) (hgE : ∀ I ∈ S, ∀ G ∈ gs I, ∃ (i : Bh), gE I i = G) (hhpass : ∀ I ∈ S, ∀ (a : Fin 4) (w : fp.HelperName I Bh), (fp.helperOf a I (fun (i : Bh) => (D.toLeafQ qG).sv a (gE I i) I) w).Pass A.G (bf.origCols a) I A.csrc A.Hsrc bf.vtag (A.w I) τH fp.mH (D.cat a)) {τ₃ Sz : ℝ} (hτ0 : ∀ (R : ℕ), 0 ≤ τr R) (n : ℕ → ℝ) (hn : Monotone n) (hn0 : 2 * A.colBudget ≤ n 0) (hτr : ∀ (R : ℕ), 1 ≤ R → R ≤ fp.Lc + 4 → τr R * (A.colBudget * √(n (R - 1))) ≤ τ₃) (hτH' : τH * (A.colBudget * √(n (fp.Lc + 4))) ≤ τ₃) (hSz : 2 * √CF ≤ Sz) (d₀ : bf.Vtx) {NH : ℝ} (hNl : ∀ I ∈ S, ∀ (l : Fin 4), ∀ r ≤ fp.Lc + 4, ∀ (M : bf.Vtx → Prop), ↑(mainLabelsM A.G fp.Mc (bf.origCols l) (D.cat l) I r M d₀).card ≤ n r) (hNH : ∀ I ∈ S, ∀ (a : Fin 4) (M : bf.Vtx → Prop), ↑(mainLabelsM A.G fp.Mc (bf.origCols a) (D.cat a) I (fp.Lc + 5) M d₀).card ≤ NH) {τ₂ : ℝ} (hτ₂ : 0 < τ₂) (hτ₂1 : τ₂ ≤ 1) (hτ₂' : τ₂ * (A.colBudget * √(n (fp.Lc + 4)) * (A.colBudget * √NH)) ≤ τ₃) (hHed₂ : Real.exp (↑A.Dg * (1 + Real.log A.Hsrc + Real.log τ₂⁻¹) ^ A.Dg) ≤ fp.Hed) (G₀ : bf.Grp) (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) (hJc : ↑Jm ≤ ↑cc * (Real.log kk + 1)) (hLs : ∀ (l : Fin 4), ↑(D.Lf.layers l).length ≤ ↑cc * (Real.log kk + 1)) {Vl : Fin 4 → ℝ} (hlin : ∀ (l : Fin 4), D.u ≠ some l → ∑ 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 l * dyadicGridLength A.G A.R.1) (hP : 1 ≤ fp.P) (Γa Γb : Fin 4 → ℝ) (ΓU : ℝ) (hΓa : ∀ (a : Fin 4), D.u ≠ some a → fp.stackEA (SideLeafM.nOs Lp Jm) (D.cat a) (D.mbs a) (D.toLeafQ qG).Dpre N (capV A cc kk) (sideB0 A cc kk (Vl a)) ≤ (↑fp.P + 2) * Γa a * dyadicGridLength A.G A.R.1) (hΓb : ∀ (b : Fin 4), D.u ≠ some b → ↑(SideLeafM.nOs Lp Jm).card * (↑N * capV A cc kk + sideB0 A cc kk (Vl b)) ≤ Γb b * dyadicGridLength A.G A.R.1) (hΓU : ↑(SideLeafM.nOs Lp Jm).card * (2 * (4 * E * dyadicGridLength A.G A.R.1)) ≤ ΓU * dyadicGridLength A.G A.R.1) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) (hrep : ∀ I ∈ S, ∀ G ∈ gs I, ∀ (l : Fin 4), D.u ≠ some l → (D.withQ0 (qG G)).RepAt L l G I) {Ee M : ℝ} (hEe : ∑ I ∈ S, ∑ G ∈ gs I, ∑ l : Fin 4, ‖(D.withQ0 (qG G)).errAt L l G I‖ ^ 2 ≤ Ee) (hM : ∑ I ∈ S, dyadicGridLength A.G I.1 * ↑(gs I).card ≤ M) {ρ₂ : ℝ} (hρ₂ : 0 < ρ₂) (hρ₂1 : ρ₂ < 1) {η p ρ : ℝ} (hη : 0 ≤ η) (hp : 2 / 3 < p) (hp1 : p ≤ 1) (hρ : 0 < ρ) (hρ1 : ρ < 1) :
∃ (C : Finset (ℤ × ℤ)) (C₂ : Finset (ℤ × ℤ)), C ⊆ A.cells ∧ dyadicRootLength A.G (maximalDyadicCells A.G C) ≤ 2 * ρ * dyadicGridLength A.G A.R.1 ∧ C₂ ⊆ S ∧ dyadicRootLength A.G C₂ ≤ ρ₂ * dyadicGridLength A.G A.R.1 ∧ (∀ I ∈ {I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} | ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2}, ∀ G ∈ gs I, ∀ (l : Fin 4), ‖(D.withQ0 (qG G)).coreAt l G I‖ ≤ coreBd (max (2 * √CF) A.S) (D.T2 cc kk Vl ρ₂) * √(dyadicGridLength A.G I.1) ∧ ‖(D.withQ0 (qG G)).errAt L l G I‖ ≤ errBd (max (2 * √CF) A.S) (D.T2 cc kk Vl ρ₂) * √(dyadicGridLength A.G I.1) ∧ ‖(D.toLeafQ qG).sv l G I‖ ≤ √(D.Tside qG Lp Jm CF E cc kk Vl ρ) * √(dyadicGridLength A.G I.1)) ∧ (∀ (x : ℝ), ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with x ∈ dyadicGridCell A.G I.1 I.2, ∑ G ∈ gs I, (D.toLeafQ qG).s2 G I ≤ D.Tside qG Lp Jm CF E cc kk Vl ρ) ∧ ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2, dyadicGridLength A.G I.1 * min η ‖∑ G ∈ gs I, (fp.Λc I) fun (l : Fin 4) => (D.toLeafQ qG).out l G I‖ ≤ 6 * 256 * Np * (τ + fp.farC fuel τ₃ Sz) * D.Tside qG Lp Jm CF E cc kk Vl ρ * dyadicGridLength A.G A.R.1 + 6 * ∑ a : Fin 4, ∑ b : Fin 4, ∑ e : Fin 4, (D.toLeafQ qG).nearBnd hq2 hq3 Nd N Lp Jm Mp (2 * √CF) (ρ / 64) Γa Γb ΓU a b e + η ^ (1 - p) * (D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * dyadicGridLength A.G A.R.1) + 82 * (81 * (localFormUniformConstant κ' * (coreBd (max (2 * √CF) A.S) (D.T2 cc kk Vl ρ₂) + errBd (max (2 * √CF) A.S) (D.T2 cc kk Vl ρ₂) + √(D.Tside qG Lp Jm CF E cc kk Vl ρ)) ^ 3) * (√(4 * M) * √Ee)) + 82 * (η ^ (1 - p) * (81 * localFormUniformConstant κ' * max (coreBd (max (2 * √CF) A.S) (D.T2 cc kk Vl ρ₂)) √(D.Tside qG Lp Jm CF E cc kk Vl ρ)) ^ p * (D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * D.Tside qG Lp Jm CF E cc kk Vl ρ ^ (p / 2) * dyadicGridLength A.G A.R.1)) + ∑ I ∈ {I ∈ S | ¬∃ e ∈ C, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2} with ¬∃ e ∈ C₂, dyadicGridCell A.G I.1 I.2 ⊆ dyadicGridCell A.G e.1 e.2, dyadicGridLength A.G I.1 * min η ‖∑ τ : Fin 4 → Fin 3 with (∀ (l : Fin 4), τ l ≠ 2) ∧ 3 ≤ patternCount τ 0, ∑ G ∈ gs I, (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 with the side estimate (lines 2446-2456): on one localization leaf of the guarded search, after the cut family of the side estimate (root fraction 2ρ) and the second cut for the rolling and linear sides (root fraction ρ₂), the cores, errors and sides have the retained sizes coreBd, errBd, √T_c, the side cap of the side estimate holds along the retained paths, and the weighted active minimum of the whole leaf outputs is at most the two-side bound of the side estimate, 82 times the error patterns (eq:physical-error, the active multiplicity and Cauchy-Schwarz), 82 times the three-side power bound with cores of size coreBd, and the weighted active minimum of the patterns with at least three cores (core_reduction, side_estimate_leaf).

The exact common-height selection on the side states (blueprint lines 2464-2466) #

theorem TrilinearHT.Auto.restrict_physEmbed_eq_zero {V : Type u_1} {W : Type u_2} [Fintype V] [Fintype W] {s t : Set ℝ} (ht : MeasurableSet t) (hst : Disjoint s t) (x : ↥(ColumnL2 V)) (hx : ∀ᵐ (y : ℝ), y ∉ s → ↑↑x y = 0) :
(columnL2Restriction t ht) ((physEmbed V W) x) = 0

A column function vanishing off a set restricts to zero on a disjoint set, also after taking its physical part.

noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.preAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (I : ℤ × ℤ) :

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

Equations
Instances For
    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.compsAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
    Finset (Finset (D.Ms l G).Md)

    The core components of the slot l and group G at the cell I: those of the retained pre-cell of its block (none in the basic U slot or when the pre-cell is not retained).

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

      The physical subtotal on the cell I of a core component on its pre-cell.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreAt_eq_comps {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) :
        D.coreAt l G I = ∑ K ∈ D.compsAt l G I, D.compSub l G I K

        Blueprint lines 2463-2464: on a cell the core is the sum of the subtotals of the core components of its retained pre-cell (the other retained pre-cells of the block are disjoint from the cell).

        def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.slotGood {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (l : Fin 4) (h : ℕ) (o : Option (Finset (D.Ms l G).Md)) :

        The goodness at a height of the entry of a component tuple in a slot: the goodness of the component on the pre-cell of the block of I in a core slot, always good otherwise.

        Equations
        Instances For
          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.tuple_success {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (r : (a : Fin 4) → Option (Finset (D.Ms a G).Md)) :
          r ∈ Fintype.piFinset (compIdx σ fun (l : Fin 4) => D.compsAt l G I) → {h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs | ∀ (l : Fin 4), D.slotGood G I l h (r l)}.Nonempty

          Blueprint lines 2464-2466 ("each core mode has bad proportion at most 2δ_*, so success probability is at least 1 - 2 m₀ δ_*"): every tuple of core components of a pattern on a cell has an upper height at which all its slots are good.

          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.pattern_first_success {κ' : 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 : ℤ × ℤ) (G : bf.Grp) (σ : Fin 4 → Fin 3) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) :
          (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) σ) = ∑ r ∈ Fintype.piFinset (compIdx σ fun (l : Fin 4) => D.compsAt l G I), (fp.Λc I) (compSlot σ (fun (l : Fin 4) (K : Finset (D.Ms l G).Md) => D.compSub l G I K) (fun (l : Fin 4) => D.toLeaf.sv l G I) (fun (l : Fin 4) => D.errAt L l G I) r) ∧ HasSum (fun (n : ℕ) => ∑ a : Fin n → Fin 4, ∑ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, ∑ h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs, (↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card ^ (n + 1))⁻¹ • ∑ r ∈ Fintype.piFinset (compIdx σ fun (l : Fin 4) => D.compsAt l G I) with ∀ (l : Fin 4), roleMask (D.slotGood G I l) l a w h (r l), (fp.Λc I) (compSlot σ (fun (l : Fin 4) (K : Finset (D.Ms l G).Md) => D.compSub l G I K) (fun (l : Fin 4) => D.toLeaf.sv l G I) (fun (l : Fin 4) => D.errAt L l G I) r)) ((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 lines 2463-2466, the exact common-height selection on one actual cell and group of the side states: the form of a core/side/error pattern is the sum over the tuples of core components of the forms of their subtotals (the finite multilinear expansion), and it is the convergent sum over the trial counts n, the assignments a of the failed trials to their first failing roles, the words w of failed upper heights and the final heights h, with the weights |H|^{-(n+1)} of the uniformly sampled heights, of the sums over the tuples in the product masks; the first-success rule has total weight one for every tuple.

          Failure masks and representatives on the side states (blueprint lines 2466-2467) #

          theorem TrilinearHT.Auto.ModeComponents.good_same_predecessor_le {Mode : Type u_1} {P : Type u_2} [DecidableEq Mode] [DecidableEq P] (C : ModeComponents Mode P) (Δ : ℕ) (goodP : ℕ → P → Prop) [(h : ℕ) → DecidablePred (goodP h)] {J : ℕ} (hstab : ∀ h ≤ J, ∀ (x x' : Mode), goodP h (C.π x) → C.π x' = C.π x → x' ∈ C.F h x → x' ∈ C.E (h - Δ) x) {h : ℕ} (hhJ : h ≤ J) {m m' : Mode} (hm : C.Good Δ goodP h m) (hm' : C.Good Δ goodP h m') (hmm' : m' ∈ C.F h m) :
          C.E (h - Δ) m = C.E (h - Δ) m'

          good_same_predecessor with the stabilization only at the heights h ≤ J.

          theorem TrilinearHT.Auto.ModeComponents.core_good_iff_le {Mode : Type u_1} {P : Type u_2} [DecidableEq Mode] [DecidableEq P] (C : ModeComponents Mode P) (Δ : ℕ) (goodP : ℕ → P → Prop) [(h : ℕ) → DecidablePred (goodP h)] {J : ℕ} (hstab : ∀ h ≤ J, ∀ (x x' : Mode), goodP h (C.π x) → C.π x' = C.π x → x' ∈ C.F h x → x' ∈ C.E (h - Δ) x) (hJ : 2 ≤ J) {δ : ℝ} (hδ : 0 < δ) (hδJ : ⌈4 * δ * ↑J⌉₊ ≤ J) {m m' : Mode} (hm : C.Core Δ goodP J δ m) (hm' : C.Core Δ goodP J δ m') (hmm' : m' ∈ C.F 0 m) (h : ℕ) :
          h ∈ upperHeights J δ → (C.Good Δ goodP h m ↔ C.Good Δ goodP h m')

          core_good_iff with the stabilization only at the heights h ≤ J.

          theorem TrilinearHT.Auto.ModeComponents.mem_pred_of_good_class_le {Mode : Type u_1} {P : Type u_2} [DecidableEq Mode] [DecidableEq P] (C : ModeComponents Mode P) (Δ : ℕ) (goodP : ℕ → P → Prop) [(h : ℕ) → DecidablePred (goodP h)] {J : ℕ} (hstab : ∀ h ≤ J, ∀ (x x' : Mode), goodP h (C.π x) → C.π x' = C.π x → x' ∈ C.F h x → x' ∈ C.E (h - Δ) x) {h : ℕ} (hhJ : h ≤ J) {m x₀ x a : Mode} (hm : C.Good Δ goodP h m) (hx₀ : C.Good Δ goodP h x₀) (hcls : C.F h x₀ = C.F h m) (hx : x ∈ C.E 0 x₀) (ha : a ∈ C.E (h - Δ) m) :
          x ∈ C.E (h - Δ) a

          mem_pred_of_good_class with the stabilization only at the heights h ≤ J.

          theorem TrilinearHT.Auto.ModeSystem.compGood_iff_of_same_class_le {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} (hstab : ∀ h ≤ SP.Jst, ∀ (x x' : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))), Ms.goodP S SP b h ((Ms.blockComps S hA b J).π x) → (Ms.blockComps S hA b J).π x' = (Ms.blockComps S hA b J).π x → x' ∈ (Ms.blockComps S hA b J).F h x → x' ∈ (Ms.blockComps S hA b J).E (h - SP.Δ) x) (hJ : 2 ≤ SP.Jst) (hδ : 0 < SP.δs) (hδJ : ⌈4 * SP.δs * ↑SP.Jst⌉₊ ≤ SP.Jst) {K K' : Finset Ms.Md} (hK : K ∈ Ms.coreComps S hA SP b J) (hK' : K' ∈ Ms.coreComps S hA SP b J) (hcls : Ms.compClass S hA b J 0 K = Ms.compClass S hA b J 0 K') (h : ℕ) :
          h ∈ ModeComponents.upperHeights SP.Jst SP.δs → (Ms.compGood S hA SP b J h K ↔ Ms.compGood S hA SP b J h K')

          compGood_iff_of_same_class with the stabilization only at the heights h ≤ J_*.

          Blueprint lem:stabilize on the pre-cells of the side states (blockComps_stab): two alive modes of one key good at a height h ≤ J_* lying in one CURRENT component at h are PRE-joined at h - Δ.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.stab_of_valid {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : D.S.Valid Cj CA CT CK δs W) (hCA : 5 ≤ CA) (hCT : 4 ≤ CT) (hd2 : 2 ≤ D.S.dmax) (hD : 2 ≤ D.S.Dstar) (hB : 2 ≤ D.S.Bstar) (hQ : 1 ≤ D.S.Q0) (hSP : D.SP = D.S.sideParams δs) (hdim : ∀ (l : Fin 4) (G : bf.Grp) (p : (D.Ms l G).Key), (D.Ms l G).dvOf p + (D.Ms l G).zc.dim ≤ D.S.dmax) (hBσ : ∀ (l : Fin 4) (G : bf.Grp), 2 * (↑D.S.Q0 * (3 * ((D.Ms l G).Bσ * (D.Ms l G).Bσ) ^ 2)) ^ 2 ≤ ↑⌊D.S.Dstar⌋₊) (hcard : ∀ (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ), ↑((D.Ms l G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))).card ≤ D.S.Dstar) :

            At the chosen schedule (S.Valid, side parameters S.sideParams δ_*) the stabilization holds on the pre-cells of the side states (blockComps_stab): the alive modes number at most D_*, the dimensions are at most d_max and D_* covers the heights of the mode differences.

            noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreCls {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (h : ℕ) (l : Fin 4) (o : Option (Finset (D.Ms l G).Md)) :
            Finset (D.Ms l G).Md

            The final class at height h of a component index of a core slot (blueprint line 2467): the union of the CURRENT components at h of its modes.

            Equations
            Instances For
              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.roleMask_iff_of_same_unit {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (hstab : D.Stab) (G : bf.Grp) (I : ℤ × ℤ) (l : Fin 4) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) {K K' : Finset (D.Ms l G).Md} (hK : K ∈ (D.Ms l G).coreComps D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I)) (hK' : K' ∈ (D.Ms l G).coreComps D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I)) (hcls : (D.Ms l G).compClass D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I) 0 K = (D.Ms l G).compClass D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I) 0 K') {n : ℕ} (a : Fin n → Fin 4) {w : Fin n → ℕ} (hw : ∀ (i : Fin n), w i ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) {h : ℕ} (hh : h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) :
              (roleMask (D.slotGood G I l) l a w h (some K) ↔ roleMask (D.slotGood G I l) l a w h (some K')) ∧ D.coreCls G I h l (some K) = D.coreCls G I h l (some K')

              Blueprint lines 2466-2467 ("for a fixed assignment, the conditions in a role form a product mask ... the upper-height coherence proved in Section sec:modes means these masks select unions of entire core subtotals in minimal CURRENT components"): two core components of a slot in one minimal CURRENT component have the same role mask for every assignment and every failure history with heights in the upper heights, and the same final class at every height.

              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.selected_in_pred_of_rep {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (hstab : D.Stab) (G : bf.Grp) (I : ℤ × ℤ) (l : Fin 4) {h : ℕ} (hh : h ≤ D.SP.Jst) {K : Finset (D.Ms l G).Md} (hK : (D.Ms l G).compGood D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I) h K) {m a : ↥((D.Ms l G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hm : ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).Good D.SP.Δ ((D.Ms l G).goodP D.S D.SP (A.blkStart D.S.K I.1)) h m) (hcls : Finset.map { toFun := Subtype.val, inj' := ⋯ } (((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F h m) = (D.Ms l G).compClass D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I) h K) (ha : a ∈ ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).E (h - D.SP.Δ) m) (x : ↥((D.Ms l G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (hxK : ↑x ∈ K) :
              x ∈ ((D.Ms l G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).E (h - D.SP.Δ) a

              Blueprint line 2467 for any representative of the predecessor (in particular the hereditary representative of lines 2172-2183): every mode of a core component good at the final height h lies in the PRE predecessor E_{h-Δ}(a) of any mode a of the predecessor E_{h-Δ}(m) of a good mode m of its final class (the unique good predecessor of the final component).

              The core torus form on the side states (blueprint eq:core-torus-form, lines 2467-2471) #

              A cell at least j depths below s has length at most 2^{-j} times that of depth s.

              theorem TrilinearHT.Auto.abs_sub_le_of_mem_cell' (G : RealDyadicGrid) {I : ℤ × ℤ} {x y : ℝ} (hx : x ∈ dyadicGridCell G I.1 I.2) (hy : y ∈ dyadicGridCell G I.1 I.2) :

              Points of one dyadic cell are at distance at most its length.

              theorem TrilinearHT.Auto.ModeSchedule.Valid.Dstar_pow_le (S : ModeSchedule) {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : S.Valid Cj CA CT CK δs W) (hW : 0 ≤ W) (hT : 1 ≤ S.T) (hD : 1 ≤ S.Dstar) :
              S.Dstar ^ CK ≤ 2 ^ S.K

              eq:lags at the chosen schedule: the pre-lag satisfies D_*^{C_K} ≤ 2^K.

              noncomputable def TrilinearHT.Auto.ModeSystem.torusξ {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (h : ℕ) (i : Fin Ms.zc.dim) :

              The common torus frequency ξ = ϑ / L_h (ϑ = θ / Q₀) of a selected group at height h (blueprint line 2467).

              Equations
              Instances For
                noncomputable def TrilinearHT.Auto.ModeSystem.torusG {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) {U : ℤ × ℤ} (h : ℕ) (xs : ℝ) (F : Finset ↥(Ms.alive U)) (α : ↥(Ms.alive U) → ℂ) (n : ↥(Ms.alive U) → Fin Ms.zc.dim → ℤ) (u : Fin Ms.zc.dim → ℝ) :

                The periodic factor g_j of eq:core-torus-form: the true periodic cutoff (re-centered at x*) times the finite trigonometric polynomial of the selected modes with their integer shifts (blueprint lines 2468-2470).

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem TrilinearHT.Auto.ModeSystem.torusG_periodic {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) {U : ℤ × ℤ} (h : ℕ) (xs : ℝ) (F : Finset ↥(Ms.alive U)) (α : ↥(Ms.alive U) → ℂ) (n : ↥(Ms.alive U) → Fin Ms.zc.dim → ℤ) (u : Fin Ms.zc.dim → ℝ) (j : Fin Ms.zc.dim → ℤ) :
                  Ms.torusG S h xs F α n (u + fun (i : Fin Ms.zc.dim) => ↑(j i)) = Ms.torusG S h xs F α n u

                  The periodic factor is periodic on the ξ torus (L_h is an integer).

                  theorem TrilinearHT.Auto.ModeSystem.cell_torus_form {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} (hJ : J.1 = b - 2 * ↑S.K) {I : ℤ × ℤ} (hIJ : dyadicGridCell Gd I.1 I.2 ⊆ dyadicGridCell Gd J.1 J.2) (hIb : b ≤ I.1) {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))) → ℂ) {xs : ℝ} (hxs : xs ∈ dyadicGridCell Gd I.1 I.2) (hQ : 1 ≤ S.Q0) (hD : 2 ≤ S.Dstar) (hcard : ↑(Ms.alive (ancAt Gd J (b - 4 * ↑S.K))).card ≤ S.Dstar) (hΛ : Ms.Λ ≤ S.Dstar) (hK : S.Dstar ^ 600 ≤ 2 ^ S.K) :
                  ∃ (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) ∧ ∀ y ∈ dyadicGridCell Gd I.1 I.2, ‖∑ m ∈ F, α m * Ms.wave (↑m) y - ↑(Real.fourierChar (↑Ms.cl * centerPhase Ms.zc Ms.ρ y)) * ↑(Real.fourierChar (Ms.slope (↑a) xs * (y - xs))) * Ms.torusG S h xs F α n fun (i : Fin Ms.zc.dim) => Ms.torusξ S h i * (y - xs)‖ ≤ (S.Dstar ^ 150)⁻¹ * ∑ m ∈ F, ‖α m‖

                  Blueprint eq:core-torus-form (lines 2467-2471) for a group of selected modes F in the PRE component E_h(a) of a representative a, on an actual cell I of the block b (I.1 ≥ b) inside the pre-cell J (J.1 = b - 2K), at any x* ∈ I: the wave sum is e(c p_ρ(y)) e(γ*(y - x*)) g(ξ (y - x*)) with γ* = ω_a(x*), ξ = ϑ / L_h and the periodic factor g = torusG (the true cutoff times a trigonometric polynomial with integer shifts of size at most |alive| E_h), up to D_*^{-150} times the absolute coefficient sum: the PRE path gives slope error D_* Ξ / r_J and the pre-lag 2^K ≥ D_*^{600} makes it and the quadratic Taylor error (curvature at most Λ ≤ D_* at the admission scale) negligible.

                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.augPhys_compSub {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) (K : Finset (D.Ms l G).Md) :
                  augPhys (D.compSub l G I K) =ᵐ[MeasureTheory.volume] (dyadicGridCell A.G I.1 I.2).indicator fun (y : ℝ) => ∑ m ∈ K, D.c l G (A.blkStart D.S.K I.1) (D.preAt I) m * (D.Ms l G).wave m y

                  Blueprint lines 2463-2470 (the core subtotals as physical functions): the physical function of the subtotal on a cell of a core component is a.e. 1_I Σ_{m ∈ K} c_m wave_m.

                  The frequency box (blueprint eq:frequency-box, lines 2471-2476) #

                  theorem TrilinearHT.Auto.ModeSchedule.Valid.Bstar_le_A0 {S : ModeSchedule} {Cj CA CT CK : ℕ} {δs W : ℝ} (hV : S.Valid Cj CA CT CK δs W) (hCA : 1 ≤ CA) (hd2 : 2 ≤ S.dmax) (hD : 2 ≤ S.Dstar) (hB : 2 ≤ S.Bstar) :

                  The common cutoff B_* is at most A₀ (blueprint line 1955: A₀ is a power of C_* 6^{R_*} B_* D_*).

                  theorem TrilinearHT.Auto.ModeSchedule.Bstar_Lh_le_Eh (S : ModeSchedule) (hA6 : 6 ≤ S.A0) (hBA : S.Bstar ≤ S.A0) (h : ℕ) :
                  S.Bstar * Lh h ≤ S.Eh h

                  B_* L_h ≤ E_h (blueprint line 2055: E_h ≥ B_* L_h) for 6 ≤ A₀ and B_* ≤ A₀.

                  theorem TrilinearHT.Auto.cutTail_le_gaugeTail (d : ℕ) {δ : ℝ} (hδ : 0 < δ) (K : ℕ) :
                  cutTail d δ K ≤ 2 * gaugeTail d δ / 2 ^ K

                  The truncation tail of the periodic cutoff is at most twice the gauge tail over 2^K.

                  theorem TrilinearHT.Auto.cutTail_le_of_Kf (d : ℕ) {δ : ℝ} (hδ : 0 < δ) {Kf : ℕ} {D : ℝ} (hD : 0 < D) (hKf : 2 * gaugeTail d δ / 2 ^ Kf * D ^ 300 ≤ 1) :
                  cutTail d δ Kf ≤ (D ^ 300)⁻¹

                  Blueprint lines 1944 and 2471 ("truncate the Fourier series to tails at most D_*^{-300}"): with the Fourier cutoff K_f of the schedule (2 gaugeTail / 2^{K_f} ≤ D_*^{-300}), the truncation tail of every true periodic cutoff of width δ in dimension d is at most D_*^{-300}.

                  theorem TrilinearHT.Auto.freqBox_cutoff (S : ModeSchedule) (hA6 : 6 ≤ S.A0) (hBA : S.Bstar ≤ S.A0) {Kf : ℕ} (hQB : ↑S.Q0 * 2 ^ (Kf + 1) ≤ S.Bstar) (hD : 1 ≤ S.Dstar) {d : ℕ} {v : Fin d → ℤ} (hv : v ∈ frequencyBox d (2 ^ (Kf + 1))) (h : ℕ) (i : Fin d) :
                  |↑S.Q0 * ModeSchedule.Lh h * ↑(v i)| ≤ S.Dstar ^ 5 * S.Eh h

                  Blueprint eq:frequency-box for the truncated cutoffs: in the torus coordinates ξ = ϑ / L_h the frequencies Q₀ L_h v of the truncated cutoffs (|v|_∞ ≤ 2^{K_f + 1}, Q₀ 2^{K_f + 1} ≤ B_*) lie in the box B'_h = D_*^5 E_h (the cutoff indices B_* L_h ≤ E_h).

                  theorem TrilinearHT.Auto.freqBox_mult (S : ModeSchedule) (hA6 : 6 ≤ S.A0) (hBA : S.Bstar ≤ S.A0) {Kf : ℕ} (hQ : 1 ≤ S.Q0) (hQB : ↑S.Q0 * 2 ^ (Kf + 1) ≤ S.Bstar) (hD : 1 ≤ S.Dstar) {d : ℕ} {v : Fin d → ℤ} (hv : v ∈ frequencyBox d (2 ^ (Kf + 1))) (h : ℕ) (i : Fin d) :
                  |ModeSchedule.Lh h * ↑(v i)| ≤ S.Dstar ^ 5 * S.Eh h

                  Blueprint eq:frequency-box for the truncated common progression multiplier: its frequencies L_h v (|v|_∞ ≤ 2^{K_f + 1} ≤ B_*) lie in the box B'_h = D_*^5 E_h.

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

                  The full Fourier norm bound of the true periodic cutoff.

                  Equations
                  Instances For
                    theorem TrilinearHT.Auto.cutNorm_le_gaugeSqNorm (d : ℕ) {δ : ℝ} (hδ : 0 < δ) :

                    The full Fourier norm of the cutoff is at most that of the squared gauge (which the schedule covers by D_*, blueprint line 1944).

                    theorem TrilinearHT.Auto.cutoffP_truncate_full {d : ℕ} (hd : 1 ≤ d) {δ : ℝ} (hδ : 0 < δ) (ρ : Fin d → ℝ) (K : ℕ) :
                    ∃ (c : (Fin d → ℤ) → ℂ), (∀ (v : Fin d → ℤ), ‖c v‖ ≤ 1) ∧ (∀ (s : Finset (Fin d → ℤ)), ∑ v ∈ s, ‖c v‖ ≤ cutNorm d δ) ∧ ∀ (w : Fin d → ℝ), ‖cutoffP δ ρ w - ∑ v ∈ frequencyBox d (2 ^ (K + 1)), c v * ↑(Real.fourierChar (∑ i : Fin d, ↑(v i) * w i))‖ ≤ cutTail d δ K

                    Blueprint lines 2471-2476 ("absolute Fourier costs ... are fixed powers of D_*; dilation of indices does not change coefficient sums"), for the true periodic cutoff: its Fourier coefficients have modulus at most one, every finite absolute coefficient sum is at most cutNorm (at most gaugeSqNorm ≤ D_*), and the truncation to the box |v|_∞ ≤ 2^{K+1} is uniformly within cutTail (at most D_*^{-300} at the Fourier cutoff of the schedule).

                    The truncated multiplier R_z (blueprint line 2478) #

                    theorem TrilinearHT.Auto.multTrunc_sup {d : ℕ} {δ : ℝ} {Q0 : ℕ} (l' : Fin 4) (C : Matrix (Fin d) (Fin d) ℚ) (ρ : Fin 4 → Fin d → ℝ) (K : ℕ) (cm0 : (Fin (d + d) → ℤ) → ℂ) {τm : ℝ} (hcmT : ∀ (w : Fin (d + d) → ℝ), ‖gaugeMult δ Q0 l' C ρ w - ∑ v ∈ frequencyBox (d + d) (2 ^ (K + 1)), cm0 v * ↑(Real.fourierChar (∑ i : Fin (d + d), ↑(v i) * w i))‖ ≤ τm) (θ : Fin d → ℝ) (xs : ℝ) (L : ℕ) (u v : StandardTorus d) :
                    ‖∑ p ∈ frequencyBox (d + d) (2 ^ (K + 1)), cm0 p * ↑(Real.fourierChar (∑ a : Fin d, ↑(p (Fin.castAdd d a)) * (θ a * xs / ↑Q0))) * (torusCharacter (↑L • fun (a : Fin d) => p (Fin.castAdd d a)) u * torusCharacter (↑L • fun (a : Fin d) => p (Fin.natAdd d a)) v)‖ ≤ 1 + τm

                    Blueprint line 2478 ("in coordinates u = ξ(y_{l'} - x*), v = ξ t, denote its shifted truncated version by R_z(u, v); it has uniformly bounded supremum, including for different offsets and anchors"): the truncated common progression multiplier of any anchor l', re-centered at x* and lifted to the torus by L, is bounded by 1 + τ_m at every pair of torus points, where τ_m is its truncation tail.

                    The declaration common-height (blueprint lines 2463-2480) #