Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec152bTorusSizeFourierTests.ThreeCoreTest

Trilinear Hilbert transform: three_core_test #

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.three_core_test {κ' : 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 : 1 ≤ 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) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hz : ∀ (j : Fin 4), (D.Ms j G).zc = (D.Ms 0 G).zc) (hdim : (D.Ms 0 G).zc.dim ≤ D.S.dmax) {δ : ℝ} (hδ : 0 < δ) (hdδ : 8 * ↑(D.Ms 0 G).zc.dim * δ ≤ 1) (hδ8 : δ ≤ 1 / 8) (hδc : ∀ (j : Fin 4), (D.Ms j G).δc = δ) (hcl : ∀ (j : Fin 4), (D.Ms j G).cl = slotCoeff j) (hρ : ∀ (j : Fin 4) (k : Fin (D.Ms j G).zc.dim), (D.Ms j G).ρ k ∈ Set.Icc 0 1) (hQC : ∀ (a b : Fin (D.Ms 0 G).zc.dim), ∃ (k : ℤ), ↑D.S.Q0 * ↑((D.Ms 0 G).zc.C a b) = ↑k) {Cm : ℝ} (hCm0 : 0 ≤ Cm) (hCm : ∀ (a b : Fin (D.Ms 0 G).zc.dim), |↑((D.Ms 0 G).zc.C a b)| ≤ Cm) {δ'' : ℝ} (hδ'' : 0 < δ'') {Kt : ℕ} (hQB : ↑D.S.Q0 * 2 ^ (Kt + 1) ≤ D.S.Bstar) {J : ℕ} (hJ : 2 ≤ J) {h : ℕ} (hh : h ≤ D.SP.Jst) (j₀ : Fin 4) {m₀ : ↥((D.Ms j₀ G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hgood : ((D.Ms j₀ G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).Good D.SP.Δ ((D.Ms j₀ G).goodP D.S D.SP (A.blkStart D.S.K I.1)) h m₀) (l : Fin 4) (Fsel : (j : Fin 4) → Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : (j : Fin 4) → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) (hn : ∀ (j : Fin 4), j ≠ l → ∀ x ∈ Fsel j, ∀ (i : Fin (D.Ms j G).zc.dim), |↑(n j x i)| ≤ D.S.Dstar * D.S.Eh (h - D.SP.Δ)) (a : Fin 4 → ℝ) {xs : ℝ} (hxs : xs ∈ dyadicGridCell A.G I.1 I.2) (hform : ∀ (j : Fin 4), j ≠ l → ∀ y ∈ dyadicGridCell A.G I.1 I.2, ‖∑ x ∈ Fsel j, D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x * (D.Ms j G).wave (↑x) y - ↑(Real.fourierChar (↑(D.Ms j G).cl * centerPhase (D.Ms j G).zc (D.Ms j G).ρ y)) * ↑(Real.fourierChar (a j * (y - xs))) * (D.Ms j G).torusG D.S (h - D.SP.Δ) xs (Fsel j) (fun (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) => D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x) (n j) fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).torusξ D.S (h - D.SP.Δ) i * (y - xs)‖ ≤ (D.S.Dstar ^ 150)⁻¹ * ∑ x ∈ Fsel j, ‖D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x‖) (hne : (D.threeRefSet G I xs (h - D.SP.Δ) l a).Nonempty) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (Aw Iw : ℕ) (hAw : 1 ≤ Aw) :
‖(fp.Λc I) (Function.update (fun (j : Fin 4) => D.compSub j G I (Finset.map { toFun := Subtype.val, inj' := ⋯ } (Fsel j))) l X)‖ ≤ 2 * (2 * localKernelSupBound κ' * ((4 * (D.S.Dstar ^ 150)⁻¹ + (gaugeErr (D.Ms 0 G).zc.dim δ δ'' + 4 * (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) ^ 3 * cutTail (D.Ms 0 G).zc.dim δ Kt + (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) ^ 4 * multTail (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm Kt)) * ∏ j ∈ Finset.univ.erase l, ∑ x ∈ Fsel j, ‖D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x‖) * ((dyadicGridLength A.G I.1)⁻¹ * ∫ (y : ℝ) in Set.Icc (dyadicGridLeft A.G I.1 I.2) (dyadicGridLeft A.G I.1 I.2 + dyadicGridLength A.G I.1), ‖augPhys X y‖) + (dyadicGridLength A.G I.1)⁻¹ * entryC κ' J Aw (D.threeBeta G I xs (h - D.SP.Δ) l a) * 2 ^ (Aw + 4) * (2 * (2 ^ (Iw + 1))⁻¹ ^ (Aw + 1)) * (((1 + multTail (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm Kt) * (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) * ∏ j ∈ Finset.univ.erase l, ((MeasureTheory.eLpNorm (fun (u : ↥(torusAnnihilator (rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K)))))) => (D.Ms j G).torusGT D.S (h - D.SP.Δ) xs (Fsel j) (fun (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) => D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x) (n j) ↑u) 2 (torusAnnihilatorHaar (rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K)))))).toReal + cutTail (D.Ms 0 G).zc.dim δ Kt * ∑ x ∈ Fsel j, ‖D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x‖)) * √(dyadicGridLength A.G I.1 * ∫ (y : ℝ) in dyadicGridLeft A.G I.1 I.2..dyadicGridLeft A.G I.1 I.2 + dyadicGridLength A.G I.1, ‖augPhys X y‖ ^ 2)) + multNorm (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm * (cutNorm (D.Ms 0 G).zc.dim δ * ∏ j ∈ Finset.univ.erase l, cutNorm (D.Ms 0 G).zc.dim δ * ∑ x ∈ Fsel j, ‖D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x‖) * (((dyadicGridLength A.G I.1)⁻¹ * ∫ (y : ℝ) in Set.Ico (dyadicGridLeft A.G I.1 I.2) (dyadicGridLeft A.G I.1 I.2 + dyadicGridLength A.G I.1), ‖augPhys X y‖) * (nearB κ' (D.SP.Tt⁻¹ / ModeSchedule.Lh (h - D.SP.Δ)) + 12 * (kerC κ' J * (4 / (D.SP.Tt / ModeSchedule.Lh (h - D.SP.Δ) - D.U0)) ^ (J - 2)))) + ∑ i ∈ Finset.range (Iw + 1), (dyadicGridLength A.G I.1)⁻¹ * entryC κ' J Aw (D.threeBeta G I xs (h - D.SP.Δ) l a) * 2 ^ (Aw + 4) * (2 ^ i)⁻¹ ^ (Aw + 1) * ((1 + multTail (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm Kt) * (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) * ∏ j ∈ Finset.univ.erase l, ((MeasureTheory.eLpNorm (fun (u : ↥(torusAnnihilator (rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K)))))) => (D.Ms j G).torusGT D.S (h - D.SP.Δ) xs (Fsel j) (fun (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) => D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x) (n j) ↑u) 2 (torusAnnihilatorHaar (rationalIntegerIntersection (tinySpan (fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).zc.θ i / ↑D.S.Q0) D.SP.Hn (D.SP.Tt⁻¹ / dyadicGridLength A.G (A.blkStart D.S.K I.1 - 2 * ↑D.S.K)))))).toReal + cutTail (D.Ms 0 G).zc.dim δ Kt * ∑ x ∈ Fsel j, ‖D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x‖)) * √(∫ (ρ' : Fin (D.Ms 0 G).zc.dim → ℝ), sideWinE (D.Ms 0 G).zc l (augPhys X) (dyadicGridLeft A.G I.1 I.2) (dyadicGridLength A.G I.1) (D.threeWin G I xs (h - D.SP.Δ) l a (2 ^ i)) ρ' ∂offsetMeasure (D.Ms 0 G).zc.dim))

Blueprint eq:side-windows (lines 2536-2560) on a leaf cell I of the side states, for a three-core tuple with side role l of the group G (all roles in the chart of role 0): let F_j, j ≠ l, be the selected modes of the core roles with their torus forms eq:core-torus-form at the final height h ≤ J_* (representatives a_j, shifts of size at most D_* E_{h-Δ}, error D_*^{-150}), let a role j₀ be good at h (a successful component, whose gap gives the tiny/huge dichotomy), and let the tuple have a reference for the three-core test (m = threeRef, β = threeBeta; the threshold |β| ≥ U₀⁻¹ is not used). Then for every side column X (S_phys = augPhys X) the cell form with the three selected core subtotals and the side X in slot l is at most twice

  • the torus-form and gauge errors 2‖w‖_∞ (4 D_*^{-150} + E_g) Π_{j ≠ l} Σ_{F_j} |α| times r⁻¹ ∫_I |S_phys|, plus
  • the shells above 2^{I_w}: C_{J,A} μ ν^{-J} 2^{-(I_w+1)(A+1)} W Π_{j ≠ l} a''_j times (r ∫_I |S_phys|²)^{1/2}, with W = (1 + τ_m)(1 + τ_c), a''_j = a'_j + τ_c Σ_{F_j} |α| and a'_j the torus size of the true periodic factor of role j (eq:torus-size), plus
  • the coset errors: tiny replacement errors (ε₁ = T⁻¹/L_{h-Δ}) and far-coset tails (H = T/L_{h-Δ} - U₀ ≥ 4) times the absolute coefficient sum multNorm cutNorm Π_{j ≠ l} (cutNorm Σ_{F_j} |α|) and r⁻¹ ∫_I |S_phys|, plus
  • the window sum Σ_{Λ = 2^i ≤ 2^{I_w}} C_{J,A} μ ν^{-J} Λ^{-(A+1)} W Π_{j ≠ l} a''_j b_Λ of eq:side-windows, where b_Λ² = E_{ρ_l} Σ_{k ∈ threeWin(Λ)} |SFourier'_ρ(k)|² is the offset average of the side energies in the mask-independent windows |k - r(Q + n·ξ)| ≤ 2Λ, |n|_∞ ≤ 16 B'. Here C_{J,A} μ ν^{-J} = entryC κ J A β with μ = min(1, |β|), ν = max(1, |β|).

The absolute numerical errors (blueprint eq:core-numerical, lines 2562-2567) #

theorem TrilinearHT.Auto.prod_add_mul_le {ι : Type u_1} (s : Finset ι) {a S : ι → ℝ} {τ : ℝ} (hτ : 0 ≤ τ) (ha : ∀ j ∈ s, 0 ≤ a j) (haS : ∀ j ∈ s, a j ≤ S j) :
∏ j ∈ s, (a j + τ * S j) ≤ ∏ j ∈ s, a j + ((1 + τ) ^ s.card - 1) * ∏ j ∈ s, S j

Π_{j ∈ s} (a_j + τ S_j) ≤ Π_{j ∈ s} a_j + ((1 + τ)^{|s|} - 1) Π_{j ∈ s} S_j for 0 ≤ a_j ≤ S_j and τ ≥ 0 (the truncation parts of the core sizes are replacement errors).

theorem TrilinearHT.Auto.fourK_le_fourKC {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (x₀ A B : ℝ) :
‖fourK a₀ r w x₀ A B‖ ≤ fourKC κ 0

A four-core kernel sample is at most the constant C₀ of fourK_mu_nu (μ ≤ 1).

theorem TrilinearHT.Auto.expP_anchor_le {d : ℕ} (L QL Bx : ℕ) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (n : (j : Fin 4) → ι j → Fin d → ℤ) {Nb : ℝ} (hn : ∀ (j : Fin 4), ∀ k ∈ F j, ∀ (i : Fin d), |↑(n j k i)| ≤ Nb) (x : (Fin (d + d) → ℤ) × ((j : Fin 4) → (Fin d → ℤ) × ι j)) (hx : x ∈ frequencyBox (d + d) Bx ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox d Bx ×ˢ F j) (l : Fin 4) (i : Fin d) :
|↑((expP2 L QL n x - ↑↑l • expP1 L QL n x) i)| ≤ 4 * (↑L * ↑Bx) + 6 * (↑QL * ↑Bx + Nb)

The anchored expansion frequencies P₂ - l P₁ of the core product (anchor l, including l = 0, where it is P₂): with indices at most B_x and shifts at most N_b, their entries are at most 4 L B_x + 6 (QL B_x + N_b) (Σ_j |j - l| ≤ 6).

theorem TrilinearHT.Auto.four_core_noref_of {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (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) (Kt : ℕ) {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 → ℝ → ℂ) (hfi : MeasureTheory.Integrable (fun (zz : ℝ × ℝ) => w zz * ∏ j : Fin 4, f j (realProgressionCoordinate j zz)) MeasureTheory.volume) {η : ℝ} (hη : 0 ≤ η) (hfa : ∀ (j : Fin 4), ∀ y ∈ Set.Icc a₀ (a₀ + r), ‖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) => z.θ i / (↑Q0 * ↑L) * (y - xs)))‖ ≤ η * ∑ k ∈ F j, ‖c j k‖) (hfb : ∀ (j : Fin 4), ∀ y ∈ Set.Icc a₀ (a₀ + r), ‖f j y‖ ≤ ∑ k ∈ F j, ‖c j k‖) (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 ^ (Kt + 1)), cc0 j v * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑(v i) * w i))‖ ≤ cutTail z.dim δ Kt) (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 ^ (Kt + 1)), cm0 v * ↑(Real.fourierChar (∑ i : Fin (z.dim + z.dim), ↑(v i) * w i))‖ ≤ multTail z.dim δ'' Q0 Cm Kt) {U₀ : ℝ} (hU₀ : 0 < U₀) (hnoref : ∀ x ∈ frequencyBox (z.dim + z.dim) (2 ^ (Kt + 1)) ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox z.dim (2 ^ (Kt + 1)) ×ˢ F j, U₀ ≤ fourNu r (∑ j : Fin 4, γ j + ∑ i : Fin z.dim, ↑(expP1 L (Q0 * L) n x i) * (z.θ i / (↑Q0 * ↑L))) (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin z.dim, ↑(expP2 L (Q0 * L) n x i) * (z.θ i / (↑Q0 * ↑L)))) :
‖localProgressionForm r w f‖ ≤ 2 * localKernelSupBound κ * ((4 * η + (gaugeErr z.dim δ δ'' + 4 * (1 + cutTail z.dim δ Kt) ^ 3 * cutTail z.dim δ Kt + (1 + cutTail z.dim δ Kt) ^ 4 * multTail z.dim δ'' Q0 Cm Kt)) * ∏ j : Fin 4, ∑ k ∈ F j, ‖c j k‖) + fourKC κ 1 * U₀⁻¹ * ∑ x ∈ frequencyBox (z.dim + z.dim) (2 ^ (Kt + 1)) ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox z.dim (2 ^ (Kt + 1)) ×ˢ F j, ‖cm0 x.1 * ↑(Real.fourierChar (∑ a : Fin z.dim, ↑(x.1 (Fin.castAdd z.dim a)) * (z.θ a * xs / ↑Q0))) * ∏ j : Fin 4, cc0 j (x.2 j).1 * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑((x.2 j).1 i) * (z.θ i * xs))) * c j (x.2 j).2‖

Blueprint lines 2512-2514 and 2562-2567 (a four-core tuple without reference is discarded) with the Fourier truncations made explicit: if every expansion frequency has ν = max(1, r|q'|, r|t'|) ≥ U₀, every kernel sample is at most C₁ U₀⁻¹ (fourK_discard), and the local form is at most the numerical errors plus C₁ U₀⁻¹ times the absolute expansion coefficient sum.

theorem TrilinearHT.Auto.ModeSystem.torusGT_eLpNorm_le_sum {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hδ : 0 < Ms.δc) {U : ℤ × ℤ} (h : ℕ) (xs : ℝ) (F : Finset ↥(Ms.alive U)) (α : ↥(Ms.alive U) → ℂ) (n : ↥(Ms.alive U) → Fin Ms.zc.dim → ℤ) (V : Submodule ℚ (Fin Ms.zc.dim → ℚ)) :

The torus size of the true periodic factor is at most its absolute coefficient sum: the true periodic cutoff is at most one, the characters are unimodular, and 𝓗 is a probability space.

theorem TrilinearHT.Auto.expP_fullBox (S : ModeSchedule) (hA6 : 6 ≤ S.A0) (hBA : S.Bstar ≤ S.A0) (hD : 2 ≤ S.Dstar) (hQ : 1 ≤ S.Q0) {Kt : ℕ} (hQB : ↑S.Q0 * 2 ^ (Kt + 1) ≤ S.Bstar) {d h' : ℕ} {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (n : (j : Fin 4) → ι j → Fin d → ℤ) (hn : ∀ (j : Fin 4), ∀ k ∈ F j, ∀ (i : Fin d), |↑(n j k i)| ≤ S.Dstar * S.Eh h') (x : (Fin (d + d) → ℤ) × ((j : Fin 4) → (Fin d → ℤ) × ι j)) (hx : x ∈ frequencyBox (d + d) (2 ^ (Kt + 1)) ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox d (2 ^ (Kt + 1)) ×ˢ F j) (l : Fin 4) (i : Fin d) :
|↑(expP1 (6 ^ h') (S.Q0 * 6 ^ h') n x i)| ≤ S.Dstar ^ 5 * S.Eh h' ∧ |↑((expP2 (6 ^ h') (S.Q0 * 6 ^ h') n x - ↑↑l • expP1 (6 ^ h') (S.Q0 * 6 ^ h') n x) i)| ≤ S.Dstar ^ 5 * S.Eh h'

Blueprint eq:frequency-box for the combined expansion frequencies: with shifts at most D_* E_{h'}, truncated cutoff indices Q₀ L_{h'} v and multiplier indices L_{h'} v (|v|_∞ ≤ 2^{K_t+1}, Q₀ 2^{K_t+1} ≤ B_*), the horizontal frequency P₁ and every anchored frequency P₂ - l P₁ of the core product lie in the full box B'_{h'} = D_*^5 E_{h'}.

noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreSize {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (j : Fin 4) (F : Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) :

The torus size a'_j = ‖g_j‖_{L²(𝓗)} (blueprint eq:torus-size) of the true periodic factor of a core role j with selected modes F and shifts n at a leaf cell I and torus height h' (𝓗 the annihilator torus of the tiny-frequency space of the chart of role j).

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coefSum {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (F : Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :

    The absolute coefficient sum Σ_{m ∈ F} |α_m| of selected modes of a role j.

    Equations
    Instances For
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coefSum_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (F : Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
      0 ≤ D.coefSum G I j F
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreSize_le {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (j : Fin 4) (hδ : 0 < (D.Ms j G).δc) (F : Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) :
      D.coreSize G I xs h' j F n ≤ D.coefSum G I j F

      The torus size of a core role is at most its absolute coefficient sum (torusGT_eLpNorm_le_sum).

      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.coreSize_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (j : Fin 4) (F : Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) :
      0 ≤ D.coreSize G I xs h' j F n
      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.Lh_mul_Ξ_le_Tt {κ' : 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) (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) {h' : ℕ} (hh : h' ≤ D.SP.Jst) :

      At the chosen schedule L_{h'} Ξ ≤ T for h' ≤ J_* (T > H Ξ, H > L_{J_*}).

      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.four_core_noref_side {κ' : 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 : 1 ≤ CA) (hd2 : 2 ≤ D.S.dmax) (hD : 2 ≤ D.S.Dstar) (hB : 2 ≤ D.S.Bstar) (hQ : 1 ≤ D.S.Q0) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hz : ∀ (j : Fin 4), (D.Ms j G).zc = (D.Ms 0 G).zc) {δ : ℝ} (hδ : 0 < δ) (hδc : ∀ (j : Fin 4), (D.Ms j G).δc = δ) (hcl : ∀ (j : Fin 4), (D.Ms j G).cl = slotCoeff j) (hρ : ∀ (j : Fin 4) (k : Fin (D.Ms j G).zc.dim), (D.Ms j G).ρ k ∈ Set.Icc 0 1) (hQC : ∀ (a b : Fin (D.Ms 0 G).zc.dim), ∃ (k : ℤ), ↑D.S.Q0 * ↑((D.Ms 0 G).zc.C a b) = ↑k) {Cm : ℝ} (hCm0 : 0 ≤ Cm) (hCm : ∀ (a b : Fin (D.Ms 0 G).zc.dim), |↑((D.Ms 0 G).zc.C a b)| ≤ Cm) {δ'' : ℝ} (hδ'' : 0 < δ'') {Kt : ℕ} (hQB : ↑D.S.Q0 * 2 ^ (Kt + 1) ≤ D.S.Bstar) (h' : ℕ) (Fsel : (j : Fin 4) → Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : (j : Fin 4) → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) (hn : ∀ (j : Fin 4), ∀ x ∈ Fsel j, ∀ (i : Fin (D.Ms j G).zc.dim), |↑(n j x i)| ≤ D.S.Dstar * D.S.Eh h') (a : (j : Fin 4) → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (xs : ℝ) (hform : ∀ (j : Fin 4), ∀ y ∈ dyadicGridCell A.G I.1 I.2, ‖∑ x ∈ Fsel j, D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x * (D.Ms j G).wave (↑x) y - ↑(Real.fourierChar (↑(D.Ms j G).cl * centerPhase (D.Ms j G).zc (D.Ms j G).ρ y)) * ↑(Real.fourierChar ((D.Ms j G).slope (↑(a j)) xs * (y - xs))) * (D.Ms j G).torusG D.S h' xs (Fsel j) (fun (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) => D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x) (n j) fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).torusξ D.S h' i * (y - xs)‖ ≤ (D.S.Dstar ^ 150)⁻¹ * D.coefSum G I j (Fsel j)) (hnoref : D.fourRefSet G I xs h' a = ∅) :
      ‖(fp.Λc I) fun (j : Fin 4) => D.compSub j G I (Finset.map { toFun := Subtype.val, inj' := ⋯ } (Fsel j))‖ ≤ 2 * localKernelSupBound κ' * ((4 * (D.S.Dstar ^ 150)⁻¹ + (gaugeErr (D.Ms 0 G).zc.dim δ δ'' + 4 * (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) ^ 3 * cutTail (D.Ms 0 G).zc.dim δ Kt + (1 + cutTail (D.Ms 0 G).zc.dim δ Kt) ^ 4 * multTail (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm Kt)) * ∏ j : Fin 4, D.coefSum G I j (Fsel j)) + fourKC κ' 1 * D.U0⁻¹ * (multNorm (D.Ms 0 G).zc.dim δ'' D.S.Q0 Cm * ∏ j : Fin 4, cutNorm (D.Ms 0 G).zc.dim δ * D.coefSum G I j (Fsel j))

      Blueprint lines 2512-2514 and 2562-2567 on a leaf cell of the side states (four cores, no reference: the tuple is discarded). When no reference lies in the full box (fourRefSet empty), every expansion frequency of the four transported core inputs has ν ≥ U₀ (its horizontal and vertical frequencies lie in the full box, expP_fullBox), so the cell form of the four selected subtotals is at most the torus-form and gauge errors plus C₁ U₀⁻¹ multNorm Π_j (cutNorm Σ_{F_j} |α|) (four_core_noref_of).

      theorem TrilinearHT.Auto.gauge_err_le {K D τc τm P δ : ℝ} (d : ℕ) (hD1 : 1 ≤ D) (hK : 0 ≤ K) (hP : 0 ≤ P) (hτc0 : 0 ≤ τc) (hτm0 : 0 ≤ τm) (hτc : τc ≤ (D ^ 300)⁻¹) (hτm : τm ≤ (D ^ 300)⁻¹) :
      2 * K * ((4 * (D ^ 150)⁻¹ + (gaugeErr d δ (δ / 2) + 4 * (1 + τc) ^ 3 * τc + (1 + τc) ^ 4 * τm)) * P) ≤ 104 * K * (D ^ 100)⁻¹ * P

      The torus-form and gauge errors at the enlarged gauge cutoff δ/2 (zero gauge error, gaugeErr_half) with truncation tails at most D_*^{-300} (blueprint eq:core-numerical): 2K (4 D_*^{-150} + E_g) P ≤ 104 K D_*^{-100} P.

      theorem TrilinearHT.Auto.trunc_core_err {a S : Fin 4 → ℝ} {τc τm u : ℝ} (ha0 : ∀ (j : Fin 4), 0 ≤ a j) (haS : ∀ (j : Fin 4), a j ≤ S j) (hτc0 : 0 ≤ τc) (hτm0 : 0 ≤ τm) (hτc : τc ≤ u) (hτm : τm ≤ u) (hu1 : u ≤ 1) :
      (1 + τm) * ∏ j : Fin 4, (a j + τc * S j) ≤ ∏ j : Fin 4, a j + 31 * u * ∏ j : Fin 4, S j

      The truncation parts of the core sizes (blueprint eq:core-numerical): for 0 ≤ a_j ≤ S_j and tails τ_c, τ_m ≤ u ≤ 1, (1 + τ_m) Π_j (a_j + τ_c S_j) ≤ Π_j a_j + 31 u Π_j S_j.

      theorem TrilinearHT.Auto.norm_prod_le_pow {D MN CN : ℝ} {S : Fin 4 → ℝ} (hS : ∀ (j : Fin 4), 0 ≤ S j) (hMN : MN ≤ D) (hCN0 : 0 ≤ CN) (hCN : CN ≤ D) :
      MN * ∏ j : Fin 4, CN * S j ≤ D ^ 5 * ∏ j : Fin 4, S j

      The absolute Fourier costs of the expansion: multNorm Π_j (cutNorm S_j) ≤ D_*^5 Π_j S_j when both full Fourier norms are at most D_* (blueprint line 1944).

      theorem TrilinearHT.Auto.inv_pow_mul_pow5_le {D : ℝ} (hD1 : 1 ≤ D) {k : ℕ} (hk : 105 ≤ k) :
      (D ^ k)⁻¹ * D ^ 5 ≤ (D ^ 100)⁻¹

      D_*^{-k} D_*^5 ≤ D_*^{-100} for k ≥ 105.

      theorem TrilinearHT.Auto.coset_err_le {D ε H nC kJ MN CN : ℝ} {J : ℕ} {S : Fin 4 → ℝ} (hJ : 1 ≤ J) (hD1 : 1 ≤ D) (hnC : 0 ≤ nC) (hkJ : 0 ≤ kJ) (hS : ∀ (j : Fin 4), 0 ≤ S j) (hMN0 : 0 ≤ MN) (hMN : MN ≤ D) (hCN0 : 0 ≤ CN) (hCN : CN ≤ D) (hε : ε ≤ (D ^ 999)⁻¹) (hH : D ^ 999 ≤ H) :
      max (nC * ε) (kJ * (H ^ J)⁻¹) * (MN * ∏ j : Fin 4, CN * S j) ≤ (nC + kJ) * (D ^ 100)⁻¹ * ∏ j : Fin 4, S j

      The coset replacement and tail errors (blueprint eq:core-numerical): with replacement precision ε ≤ D_*^{-999}, far separation H ≥ D_*^{999}, J ≥ 1 and full Fourier norms at most D_*, max(C ε, C_J H^{-J}) multNorm Π_j (cutNorm S_j) ≤ (C + C_J) D_*^{-100} Π_j S_j.

      theorem TrilinearHT.Auto.four_err_combine {Λ E1 Fk T E3 Pa P u C0 A1 A3 : ℝ} (hkey : Λ ≤ E1 + (Fk * T + E3)) (hE1 : E1 ≤ A1 * u * P) (hT : T ≤ Pa + 31 * u * P) (hE3 : E3 ≤ A3 * u * P) (hF0 : 0 ≤ Fk) (hFC : Fk ≤ C0) (hu0 : 0 ≤ u) (hP0 : 0 ≤ P) :
      Λ ≤ Fk * Pa + (A1 + 31 * C0 + A3) * u * P

      The arithmetic of a tuple with a reference (blueprint eq:core-numerical): from Λ ≤ E₁ + (F T + E₃) with E₁ ≤ A₁ u P, T ≤ P_a + 31 u P, E₃ ≤ A₃ u P and 0 ≤ F ≤ C₀, the form is at most the principal quantity F P_a plus (A₁ + 31 C₀ + A₃) u P.

      noncomputable def TrilinearHT.Auto.fourErrC (κ : LocalKernelClass) (J : ℕ) :

      The absolute constant of the numerical errors of a four-core tuple (blueprint eq:core-numerical): torus-form and gauge errors, truncation parts of the core sizes, coset replacement and tail errors, and discarded tuples.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.Tt_far_bounds {κ' : 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) (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) {h' : ℕ} (hh : h' ≤ D.SP.Jst) :

        The schedule facts used for the numerical errors: T⁻¹/L_{h'} ≤ D_*^{-999} and T/L_{h'} - U₀ ≥ D_*^{999} for h' ≤ J_* (L_{h'} Ξ ≤ T, Ξ = D_*^{1000}, U₀ = D_*^{250}).

        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.four_core_tuple_bound {κ' : 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 : 1 ≤ 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) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (hz : ∀ (j : Fin 4), (D.Ms j G).zc = (D.Ms 0 G).zc) (hdim : (D.Ms 0 G).zc.dim ≤ D.S.dmax) {δ : ℝ} (hδ : 0 < δ) (hδc : ∀ (j : Fin 4), (D.Ms j G).δc = δ) (hcl : ∀ (j : Fin 4), (D.Ms j G).cl = slotCoeff j) (hρ : ∀ (j : Fin 4) (k : Fin (D.Ms j G).zc.dim), (D.Ms j G).ρ k ∈ Set.Icc 0 1) (hQC : ∀ (a b : Fin (D.Ms 0 G).zc.dim), ∃ (k : ℤ), ↑D.S.Q0 * ↑((D.Ms 0 G).zc.C a b) = ↑k) {Cm : ℝ} (hCm0 : 0 ≤ Cm) (hCm : ∀ (a b : Fin (D.Ms 0 G).zc.dim), |↑((D.Ms 0 G).zc.C a b)| ≤ Cm) {Kt : ℕ} (hQB : ↑D.S.Q0 * 2 ^ (Kt + 1) ≤ D.S.Bstar) (hτc : cutTail (D.Ms 0 G).zc.dim δ Kt ≤ (D.S.Dstar ^ 300)⁻¹) (hτm : multTail (D.Ms 0 G).zc.dim (δ / 2) D.S.Q0 Cm Kt ≤ (D.S.Dstar ^ 300)⁻¹) (hMN : multNorm (D.Ms 0 G).zc.dim (δ / 2) D.S.Q0 Cm ≤ D.S.Dstar) (hCN : cutNorm (D.Ms 0 G).zc.dim δ ≤ D.S.Dstar) {J : ℕ} (hJ : 1 ≤ J) {h : ℕ} (hh : h ≤ D.SP.Jst) {m₀ : ↥((D.Ms 0 G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hgood : ((D.Ms 0 G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).Good D.SP.Δ ((D.Ms 0 G).goodP D.S D.SP (A.blkStart D.S.K I.1)) h m₀) (Fsel : (j : Fin 4) → Finset ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (n : (j : Fin 4) → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))) → Fin (D.Ms j G).zc.dim → ℤ) (hn : ∀ (j : Fin 4), ∀ x ∈ Fsel j, ∀ (i : Fin (D.Ms j G).zc.dim), |↑(n j x i)| ≤ D.S.Dstar * D.S.Eh (h - D.SP.Δ)) (a : (j : Fin 4) → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) {xs : ℝ} (hxs : xs ∈ dyadicGridCell A.G I.1 I.2) (hform : ∀ (j : Fin 4), ∀ y ∈ dyadicGridCell A.G I.1 I.2, ‖∑ x ∈ Fsel j, D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x * (D.Ms j G).wave (↑x) y - ↑(Real.fourierChar (↑(D.Ms j G).cl * centerPhase (D.Ms j G).zc (D.Ms j G).ρ y)) * ↑(Real.fourierChar ((D.Ms j G).slope (↑(a j)) xs * (y - xs))) * (D.Ms j G).torusG D.S (h - D.SP.Δ) xs (Fsel j) (fun (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) => D.c j G (A.blkStart D.S.K I.1) (D.preAt I) ↑x) (n j) fun (i : Fin (D.Ms j G).zc.dim) => (D.Ms j G).torusξ D.S (h - D.SP.Δ) i * (y - xs)‖ ≤ (D.S.Dstar ^ 150)⁻¹ * D.coefSum G I j (Fsel j)) :
        ‖(fp.Λc I) fun (j : Fin 4) => D.compSub j G I (Finset.map { toFun := Subtype.val, inj' := ⋯ } (Fsel j))‖ ≤ (if D.fourPasses G I xs (h - D.SP.Δ) a then ‖fourK (dyadicGridLeft A.G I.1 I.2) (dyadicGridLength A.G I.1) (A.w I) xs (D.fourQ' G I xs (h - D.SP.Δ) a) (D.fourT' G I xs (h - D.SP.Δ) a)‖ * ∏ j : Fin 4, D.coreSize G I xs (h - D.SP.Δ) j (Fsel j) (n j) else 0) + fourErrC κ' J * (D.S.Dstar ^ 100)⁻¹ * ∏ j : Fin 4, D.coefSum G I j (Fsel j)

        Blueprint eq:core-numerical (lines 2562-2567) for a four-core tuple on a leaf cell of the side states (common chart of role 0, torus forms with error D_*^{-150}, anchor role good at the final height h; enlarged gauge cutoff δ/2, Fourier truncation tails at most D_*^{-300} and full Fourier norms at most D_*, as chosen in blueprint line 1944): the cell form of the four selected subtotals is at most the principal quantity |WFourier_s(r q', r t')| Π_j a'_j if the tuple passes the four-core test, and 0 if it is discarded, plus the absolute error C_J D_*^{-100} Π_j Σ_{F_j} |α|. The error collects the torus-form and gauge errors, the truncation parts of the core sizes (a'_j ≤ Σ_{F_j} |α|, coreSize_le), the coset replacement and tail errors (T⁻¹/L ≤ D_*^{-999}, T/L - U₀ ≥ D_*^{999}), discarded tuples with a reference (|WFourier_s| ≤ C₁ U₀⁻¹, fourK_discard) and tuples without reference (four_core_noref_side).

        noncomputable def TrilinearHT.Auto.entryCU (κ : LocalKernelClass) (J A : ℕ) :

        The constant of the anchor entries entryC without the band factor μ ν^{-J}.

        Equations
        Instances For
          theorem TrilinearHT.Auto.entryCU_nonneg {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (J A : ℕ) :
          0 ≤ entryCU κ J A
          theorem TrilinearHT.Auto.entryC_le_min {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (J A : ℕ) (b : ℝ) :
          entryC κ J A b ≤ entryCU κ J A * min 1 |b|

          The anchor entry constant C_{J,A} μ ν^{-J} is at most C_{J,A} min(1, |β|) (a discarded three-core tuple with |β| < U₀⁻¹).

          theorem TrilinearHT.Auto.entryC_le_far {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (J A : ℕ) {b U : ℝ} (hU : 1 ≤ U) (hb : U ≤ |b|) :
          entryC κ J A b ≤ entryCU κ J A * (U ^ J)⁻¹

          The anchor entry constant C_{J,A} μ ν^{-J} is at most C_{J,A} U^{-J} when |β| ≥ U ≥ 1 (all anchored frequencies far: a three-core tuple without reference).

          theorem TrilinearHT.Auto.three_core_noref_of {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) (z : ChartTag) {δ δ'' : ℝ} (hδ : 0 < δ) (hδ'' : 0 < δ'') (hdδ : 8 * ↑z.dim * δ ≤ 1) (hδ8 : δ ≤ 1 / 8) (ρc : Fin 4 → Fin z.dim → ℝ) (hρc : ∀ (j : Fin 4) (a : Fin z.dim), ρc j a ∈ Set.Icc 0 1) {Q0 : ℕ} (hQ0 : 0 < Q0) (hQ : ∀ (a b : Fin z.dim), ∃ (k : ℤ), ↑Q0 * ↑(z.C a b) = ↑k) {Cm : ℝ} (hCm0 : 0 ≤ Cm) (hCm : ∀ (a b : Fin z.dim), |↑(z.C a b)| ≤ Cm) {L : ℕ} (hL : 0 < L) (Kt : ℕ) {xs : ℝ} (hxs : xs ∈ Set.Icc a₀ (a₀ + r)) (l : Fin 4) (γ : Fin 4 → ℝ) (hγl : γ l = 0) {ι : Fin 4 → Type u_1} (F : (j : Fin 4) → Finset (ι j)) (c : (j : Fin 4) → ι j → ℂ) (n : (j : Fin 4) → ι j → Fin z.dim → ℤ) {k₀ : ι l} (hFl : F l = {k₀}) (hcl : c l k₀ = 1) (hnl : n l k₀ = 0) (f : Fin 4 → ℝ → ℂ) (hgm : Measurable (f l)) (hL2 : MeasureTheory.MemLp (f l) 2 (MeasureTheory.volume.restrict (Set.Ioc a₀ (a₀ + r)))) (hfi : MeasureTheory.Integrable (fun (zz : ℝ × ℝ) => w zz * ∏ j : Fin 4, f j (realProgressionCoordinate j zz)) MeasureTheory.volume) (hfiρ : ∀ (ρ' : Fin z.dim → ℝ), MeasureTheory.Integrable (fun (zz : ℝ × ℝ) => w zz * ∏ j : Fin 4, Function.update f l (fun (y : ℝ) => ↑(centerCut z δ ρ' y) * f l y) j (realProgressionCoordinate j zz)) MeasureTheory.volume) {η : ℝ} (hη : 0 ≤ η) (hfa : ∀ (j : Fin 4), j ≠ l → ∀ y ∈ Set.Icc a₀ (a₀ + r), ‖f j y - ↑(centerCut z δ (ρc j) y) * ↑(Real.fourierChar (↑(slotCoeff j) * centerPhase z (ρc j) y)) * (↑(Real.fourierChar (γ j * (y - xs))) * ∑ k ∈ F j, c j k * torusCharacter (n j k) (torusMk fun (i : Fin z.dim) => z.θ i / (↑Q0 * ↑L) * (y - xs)))‖ ≤ η * ∑ k ∈ F j, ‖c j k‖) (hfb : ∀ (j : Fin 4), j ≠ l → ∀ y ∈ Set.Icc a₀ (a₀ + r), ‖f j y‖ ≤ ∑ k ∈ F j, ‖c j k‖) (cc0 : Fin 4 → (Fin z.dim → ℤ) → ℂ) (hcc0 : ∀ (j : Fin 4) (v : Fin z.dim → ℤ), ‖cc0 j v‖ ≤ 1) (hccN : ∀ (j : Fin 4) (s : Finset (Fin z.dim → ℤ)), ∑ v ∈ s, ‖cc0 j v‖ ≤ cutNorm z.dim δ) (hccT : ∀ (j : Fin 4), j ≠ l → ∀ (w : Fin z.dim → ℝ), ‖cutoffP δ (ρc j) w - ∑ v ∈ frequencyBox z.dim (2 ^ (Kt + 1)), cc0 j v * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑(v i) * w i))‖ ≤ cutTail z.dim δ Kt) {U : ℝ} (hU4 : 4 ≤ U) (hfarall : ∀ x ∈ frequencyBox (z.dim + z.dim) (2 ^ (Kt + 1)) ×ˢ Fintype.piFinset fun (j : Fin 4) => frequencyBox z.dim (2 ^ (Kt + 1)) ×ˢ F j, U ≤ |r * (∑ j : Fin 4, ↑↑j * γ j + ∑ i : Fin z.dim, ↑(expP2 L (Q0 * L) n x i) * (z.θ i / (↑Q0 * ↑L)) - ↑↑l * (∑ j : Fin 4, γ j + ∑ i : Fin z.dim, ↑(expP1 L (Q0 * L) n x i) * (z.θ i / (↑Q0 * ↑L))))|) {J : ℕ} (hJ : 2 ≤ J) (A : ℕ) (hA : 1 ≤ A) :
          ‖localProgressionForm r w f‖ ≤ 2 * (2 * localKernelSupBound κ * ((4 * η + (gaugeErr z.dim δ δ'' + 4 * (1 + cutTail z.dim δ Kt) ^ 3 * cutTail z.dim δ Kt + (1 + cutTail z.dim δ Kt) ^ 4 * multTail z.dim δ'' Q0 Cm Kt)) * ∏ j : Fin 4, ∑ k ∈ F j, ‖c j k‖) * (r⁻¹ * ∫ (y : ℝ) in Set.Icc a₀ (a₀ + r), ‖f l y‖) + 4 * (r⁻¹ * (entryCU κ J A * (U ^ J)⁻¹) * 2 ^ (A + 4) * (((1 + multTail z.dim δ'' Q0 Cm Kt) * (1 + cutTail z.dim δ Kt) * ∏ i ∈ Finset.univ.erase l, (MeasureTheory.eLpNorm (fun (u : ↥(torusAnnihilator (rationalIntegerIntersection ⊥))) => coreG (Q0 * L) (2 ^ (Kt + 1)) F c n (fun (j : Fin 4) (v : Fin z.dim → ℤ) => cc0 j v * ↑(Real.fourierChar (∑ i : Fin z.dim, ↑(v i) * (z.θ i * xs)))) i ↑u) 2 (torusAnnihilatorHaar (rationalIntegerIntersection ⊥))).toReal) * √(r * ∫ (y : ℝ) in a₀..a₀ + r, ‖f l y‖ ^ 2))) + (multNorm z.dim δ'' Q0 Cm * ∏ j : Fin 4, cutNorm z.dim δ * ∑ k ∈ F j, ‖c j k‖) * ((r⁻¹ * ∫ (y : ℝ) in Set.Ico a₀ (a₀ + r), ‖f l y‖) * (12 * (kerC κ J * (4 / U) ^ (J - 2)))))

          Blueprint lines 2540 and 2562-2567 (a three-core tuple without reference is discarded) with the Fourier truncations made explicit: if every anchored expansion frequency is far, r |T_l + (P₂ - l P₁)·ξ| ≥ U ≥ 4, the averaged three-core bound (three_core_averaged_of, with no near coset) gives the form at most twice the torus-form and gauge errors, plus 4 r⁻¹ C_{J,A} U^{-J} 2^{A+4} W Π_{j ≠ l} ‖g_j‖₂ (r ∫_I |f_l|²)^{1/2}, plus the far-coset tails multNorm Π_j (cutNorm Σ|c|) r⁻¹ ∫_I |f_l| 12 C_J (4/U)^{J-2}.

          noncomputable def TrilinearHT.Auto.nearBC (κ : LocalKernelClass) :

          The constant of the near-coset replacement error: nearB κ ε ≤ nearBC κ √ε for ε ≤ 1.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem TrilinearHT.Auto.nearB_le {κ : LocalKernelClass} {a₀ r : ℝ} (hr : 0 < r) {w : ℝ × ℝ → ℂ} (hw : IsAdmissibleLocalKernel κ a₀ r w) {ε : ℝ} (hε0 : 0 ≤ ε) (hε1 : ε ≤ 1) :
            nearB κ ε ≤ nearBC κ * √ε
            theorem TrilinearHT.Auto.trunc_core_err3 {ι : Type u_1} (s : Finset ι) (hs : s.card = 3) {a S : ι → ℝ} {τc τm u : ℝ} (ha0 : ∀ j ∈ s, 0 ≤ a j) (haS : ∀ j ∈ s, a j ≤ S j) (hτc0 : 0 ≤ τc) (hτm0 : 0 ≤ τm) (hτc : τc ≤ u) (hτm : τm ≤ u) (hu1 : u ≤ 1) :
            (1 + τm) * (1 + τc) * ∏ j ∈ s, (a j + τc * S j) ≤ ∏ j ∈ s, a j + 31 * u * ∏ j ∈ s, S j

            The truncation parts of three core sizes with the multiplier and side-cutoff factor W = (1 + τ_m)(1 + τ_c) (blueprint eq:core-numerical): for 0 ≤ a_j ≤ S_j, three roles and tails τ_c, τ_m ≤ u ≤ 1, W Π_{j ∈ s} (a_j + τ_c S_j) ≤ Π_{j ∈ s} a_j + 31 u Π_{j ∈ s} S_j.

            theorem TrilinearHT.Auto.inv_mul_sqrt_mul {r X : ℝ} (hr : 0 < r) :
            r⁻¹ * √(r * X) = √(r⁻¹ * X)

            r⁻¹ (r X)^{1/2} = (r⁻¹ X)^{1/2}: the normalized L² size of the side on a cell.

            theorem TrilinearHT.Auto.cell_l1_le_size {a r : ℝ} (hr : 0 < r) {g : ℝ → ℂ} (hg : MeasureTheory.MemLp g 2 (MeasureTheory.volume.restrict (Set.Ioc a (a + r)))) :
            r⁻¹ * ∫ (y : ℝ) in Set.Icc a (a + r), ‖g y‖ ≤ √(r⁻¹ * ∫ (y : ℝ) in a..a + r, ‖g y‖ ^ 2) ∧ r⁻¹ * ∫ (y : ℝ) in Set.Ico a (a + r), ‖g y‖ ≤ √(r⁻¹ * ∫ (y : ℝ) in a..a + r, ‖g y‖ ^ 2)

            Cauchy-Schwarz on a cell: the normalized L¹ norm of a square-integrable side on [a, a + r] (or [a, a + r)) is at most its normalized L² size (r⁻¹ ∫ |g|²)^{1/2}.

            theorem TrilinearHT.Auto.eLpNorm_charSum_le {d : ℕ} (V : Submodule ℚ (Fin d → ℚ)) {ι : Type u_1} (F : Finset ι) (c : ι → ℂ) (n : ι → Fin d → ℤ) :

            The L²(𝓗) norm of a character polynomial Σ_{k ∈ F} c_k χ_{n_k} is at most its absolute coefficient sum (𝓗 a probability space).