Documentation

LeanPool.TrilinearHilbertTransform.Auto.Sec152bTorusSizeFourierTests.ThreeCoreTupleBound

Trilinear Hilbert transform: three_core_tuple_bound #

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.three_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 < δ) (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) {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 : 3 ≤ 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‖) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (Aw Iw : ℕ) (hAw : 1 ≤ Aw) (hIw : D.U0 ≤ 2 ^ (Iw + 1)) :
‖(fp.Λc I) (Function.update (fun (j : Fin 4) => D.compSub j G I (Finset.map { toFun := Subtype.val, inj' := ⋯ } (Fsel j))) l X)‖ ≤ (if D.threePasses G I xs (h - D.SP.Δ) l a then D.threePrin G I xs (h - D.SP.Δ) l a Fsel n X J Aw Iw else 0) + (threeErrC κ' J Aw * (D.S.Dstar ^ 100)⁻¹ * ∏ j ∈ Finset.univ.erase l, D.coefSum G I j (Fsel j)) * √((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)

Blueprint eq:core-numerical (lines 2562-2567) for a three-core tuple on a leaf cell of the side states, side role l and side column X (enlarged gauge cutoff δ/2, truncation tails at most D_*^{-300}, full Fourier norms at most D_*, J ≥ 3, windows up to 2^{I_w} ≥ U₀/2): the cell form is at most the principal window quantity threePrin if the tuple passes the three-core test, and 0 if it is discarded, plus the absolute error C_{J,A} D_*^{-100} Π_{j ≠ l} Σ_{F_j} |α| σ with the local side size σ = (r⁻¹ ∫_I |S_phys|²)^{1/2} as extra factor. Discarded tuples: |β| < U₀⁻¹ gives C_{J,A} μ ν^{-J} ≤ C_{J,A} U₀⁻¹ (entryC_le_min), and no reference gives all anchored frequencies far (three_core_noref_side).

Moments of the core torus sizes over the failure histories (blueprint lines 2569-2577) #

theorem TrilinearHT.Auto.role_moments_of_le {κ : Type u_1} {m₀ : ℕ} (H : Finset ℕ) (good : ℕ → κ → Prop) (T : Finset κ) (b : κ → ℝ) (hb : ∀ K ∈ T, 0 ≤ b K) {ρ : ℝ} (hρ : 0 ≤ ρ) (hbad : ∀ K ∈ T, ↑{h ∈ H | ¬good h K}.card ≤ ρ * ↑H.card) {n : ℕ} (a : Fin n → Fin m₀) (j : Fin m₀) (A : (Fin n → ℕ) → ℝ) (hA0 : ∀ (w : Fin n → ℕ), 0 ≤ A w) {c : ℝ} (hc : 0 ≤ c) (hA : ∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, A w ≤ c * √(∑ K ∈ T with ∀ (i : Fin n), a i = j → ¬good (w i) K, b K)) :
(∀ w ∈ Fintype.piFinset fun (x : Fin n) => H, A w ≤ c * √(∑ K ∈ T, b K)) ∧ ∑ w ∈ Fintype.piFinset fun (x : Fin n) => H, (↑H.card ^ n)⁻¹ * A w ^ 2 ≤ c ^ 2 * ρ ^ {i : Fin n | a i = j}.card * ∑ K ∈ T, b K

role_moments with an arbitrary constant c: if for every word w ∈ H^n the role size is at most c (Σ_K b_K)^{1/2} over the K ∈ T failing at all heights assigned to the role, and every K ∈ T is bad at a proportion at most ρ of H, then A(w) ≤ c (Σ_T b)^{1/2} and the word average of A² is at most c² ρ^{n_j} Σ_T b.

theorem TrilinearHT.Auto.ModeSystem.allComps_of_coreComps {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) :
K ∈ Ms.allComps S hA b J
theorem TrilinearHT.Auto.ModeSystem.mem_coreComps_of_core {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} {z : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hz : (Ms.blockComps S hA b J).Core SP.Δ (Ms.goodP S SP b) SP.Jst SP.δs z) :
Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).E 0 z) ∈ Ms.coreComps S hA SP b J

The minimal PRE component of a core mode is a core component.

theorem TrilinearHT.Auto.ModeSystem.isCoreAt_of_mem_coreComps {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) {z : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hz : ↑z ∈ K) :
Ms.IsCoreAt S hA SP b J ↑z

The modes of a core component are core.

theorem TrilinearHT.Auto.ModeSystem.subset_F_zero_of_mem {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} {K : Finset Ms.Md} (hK : K ∈ Ms.allComps S hA b J) {y : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hy : ↑y ∈ K) :
K ⊆ Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F 0 y)

A minimal component lies in the minimal CURRENT component of any of its modes.

theorem TrilinearHT.Auto.ModeSystem.compClass_zero_of_subset {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) {b : ℤ} {J : ℤ × ℤ} {K : Finset Ms.Md} (hK : K ∈ Ms.allComps S hA b J) {y : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (hKU : K ⊆ Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F 0 y)) :
Ms.compClass S hA b J 0 K = Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F 0 y)

A minimal component inside a minimal CURRENT component has that component as its class at height 0.

theorem TrilinearHT.Auto.ModeSystem.selComps_sum_le_filter {Gd : RealDyadicGrid} {Mc : ℕ} (Ms : ModeSystem Gd Mc) (S : ModeSchedule) (hA : 6 ≤ S.A0) (SP : SideParams) {b : ℤ} {J : ℤ × ℤ} (I : ℤ × ℤ) {h : ℕ} {x : ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))} (F : Finset ↥(Ms.alive (ancAt Gd J (b - 4 * ↑S.K)))) (P : Finset Ms.Md → Prop) [DecidablePred P] (hFh : ∀ y ∈ F, y ∈ (Ms.blockComps S hA b J).F h x) (hunit : ∀ y ∈ F, ∀ z ∈ (Ms.blockComps S hA b J).F 0 y, z ∈ F ↔ Ms.IsCoreAt S hA SP b J ↑z) (hP : ∀ y ∈ F, P (Finset.map { toFun := Subtype.val, inj' := ⋯ } ((Ms.blockComps S hA b J).F 0 y))) (c : Ms.Md → ℂ) :
∑ E ∈ Ms.selComps S hA b J F, (‖∑ m ∈ E, c m • Ms.cellMode I m‖ / √(dyadicGridLength Gd I.1) + (S.Dstar ^ 30)⁻¹ * ∑ m ∈ E, ‖c m‖) ^ 2 ≤ ∑ U ∈ Ms.minComps S hA b J h x with P U, (‖∑ m ∈ U with (Ms.IsCoreAt S hA SP b J) m, c m • Ms.cellMode I m‖ / √(dyadicGridLength Gd I.1) + (S.Dstar ^ 30)⁻¹ * ∑ m ∈ U with (Ms.IsCoreAt S hA SP b J) m, ‖c m‖) ^ 2

Blueprint lines 2569-2572 ("apply the probability bound separately to each minimal-component summand in eq:torus-size"): when the selected modes F are the core modes of entire minimal CURRENT components inside F_h(x), each satisfying P, the sum of eq:torus-size is at most the sum of the summands of eq:component-size over the minimal CURRENT components satisfying P.

theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.mem_compsAt {κ' : 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} (hK : K ∈ D.compsAt l G I) :
K ∈ (D.Ms l G).coreComps D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I) ∧ D.compsAt l G I = (D.Ms l G).coreComps D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I)

The components of a core slot at a cell are the core components of its pre-cell.

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

The final class F_h(m) of a mode of the role j (blueprint line 2467), as a set of modes.

Equations
Instances For
    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskComps {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) :
    Finset (Finset (D.Ms j G).Md)

    The masked components of a core role j with final class F (blueprint lines 2466-2467 and 2569): the core components of the cell in the role mask of the assignment asg of the failed trials, the failed word w and the final height h, whose final class at h is F.

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

      The selected modes of a core role with final class F (blueprint line 2569): the alive modes of its masked components.

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

        The goodness at a height t of a minimal CURRENT component U of a core role: every core component of the cell inside U is good at t.

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

          The summand of eq:component-size of a minimal CURRENT component U of the role j: (‖A_U‖_{2,I} + D_*^{-30} Σ_{m core in U} |α_m|)².

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.TorusFormAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (h' : ℕ) (xs : ℝ) (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 → ℤ) (a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :

            The torus form eq:core-torus-form of selected modes F of the role j at the torus height h' and the point x*, with shifts n and anchor mode a: shifts at most D_* E_{h'} and error at most D_*^{-150} times the absolute coefficient sum.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSel_units {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (hstab : D.Stab) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) {n : ℕ} (asg : 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) (m : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
              (∀ y ∈ D.maskSel G I j asg w h (D.finCls G I j h m), y ∈ ((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F h m) ∧ ∀ y ∈ D.maskSel G I j asg w h (D.finCls G I j h m), ∀ z ∈ ((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F 0 y, z ∈ D.maskSel G I j asg w h (D.finCls G I j h m) ↔ (D.Ms j G).IsCoreAt D.S ⋯ D.SP (A.blkStart D.S.K I.1) (D.preAt I) ↑z

              Blueprint lines 2466-2467 and 2569 for the masked selection: the selected modes of a core role with the final class F_h(m) lie in F_h(m), and they are the core modes of entire minimal CURRENT components (the masks select whole units, roleMask_iff_of_same_unit).

              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.unitGood_bad_card {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (hstab : D.Stab) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) (y : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
              ↑{t ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs | ¬D.unitGood G I j t (Finset.map { toFun := Subtype.val, inj' := ⋯ } (((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).F 0 y))}.card ≤ 2 * D.SP.δs * ↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card

              Blueprint line 2466 for minimal CURRENT components: on the upper heights a minimal CURRENT component of a core role is bad at a proportion at most 2δ_* (its core components share their good predicates, compGood_iff_of_same_class_le, coreComp_bad_card).

              theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.role_size_moments {κ' : 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) (hstab : D.Stab) (I : ℤ × ℤ) (j : Fin 4) (G : bf.Grp) (hdim : (D.Ms j G).zc.dim ≤ D.S.dmax) (hδc : 0 < (D.Ms j G).δc) (hDg : gaugeSqNorm (D.Ms j G).zc.dim (D.Ms j G).δc ≤ D.S.Dstar) {Kf : ℕ} (hKf : 2 * gaugeTail (D.Ms j G).zc.dim (D.Ms j G).δc / 2 ^ Kf * D.S.Dstar ^ 300 ≤ 1) (hQB : ↑D.S.Q0 * 2 ^ (Kf + 1) ≤ D.S.Bstar) (hεw : ∀ (m : (D.Ms j G).Md), D.S.Dstar⁻¹ ≤ (D.Ms j G).L.εM m) (hcard : ↑((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))).card ≤ D.S.Dstar) (hΛ : (D.Ms j G).Λ ≤ D.S.Dstar) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) {h : ℕ} (hh : h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) {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) {n : ℕ} (asg : Fin n → Fin 4) (ns : (Fin 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 → ℤ) (a : ↥((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 : ∀ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, D.TorusFormAt G I j (h - D.SP.Δ) xs (D.maskSel G I j asg w h (D.finCls G I j h m)) (ns w) a) :
              (∀ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, D.coreSize G I xs (h - D.SP.Δ) j (D.maskSel G I j asg w h (D.finCls G I j h m)) (ns w) ≤ 6 * √((D.Ms j G).compSizeSq D.S ⋯ D.SP I (A.blkStart D.S.K I.1) (D.preAt I) h m (D.c j G (A.blkStart D.S.K I.1) (D.preAt I)))) ∧ ∑ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, (↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card ^ n)⁻¹ * D.coreSize G I xs (h - D.SP.Δ) j (D.maskSel G I j asg w h (D.finCls G I j h m)) (ns w) ^ 2 ≤ 36 * (2 * D.SP.δs) ^ {i : Fin n | asg i = j}.card * (D.Ms j G).compSizeSq D.S ⋯ D.SP I (A.blkStart D.S.K I.1) (D.preAt I) h m (D.c j G (A.blkStart D.S.K I.1) (D.preAt I))

              Blueprint lines 2569-2572 on a leaf cell of the side states: for a final upper height h, the final class F_h(m) of a good mode m of a core role j, an assignment asg of the n failed trials and torus forms of the selected modes for all words w ∈ H^n (shifts ns w, anchor a), the torus sizes a'_j(w) of eq:torus-size satisfy a'_j(w) ≤ 6 σ_F and E_w a'_j(w)² ≤ 36 (2δ_*)^{n_j} σ_F², with n_j the number of trials assigned to j and σ_F² = compSizeSq (eq:component-size): each minimal-component summand of eq:torus-size requires its unit to fail at the n_j heights assigned to j, which has probability at most (2δ_*)^{n_j} (the other success requirements are dropped).

              The principal core contributions (blueprint eq:principal-core, lines 2577-2582) #

              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.clsUnits {κ' : 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).Md) :
              Finset (Finset (D.Ms j G).Md)

              The minimal CURRENT components inside a final class F of the role j (the summation units of eq:component-size).

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.clsSize {κ' : 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).Md) :

                The component size σ_F of a final class F of the role j (blueprint eq:component-size).

                Equations
                Instances For
                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.clsSize_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).Md) :
                  0 ≤ D.clsSize G I j F
                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.clsSize_finCls {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (h : ℕ) (m : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
                  D.clsSize G I j (D.finCls G I j h m) = √((D.Ms j G).compSizeSq D.S ⋯ D.SP I (A.blkStart D.S.K I.1) (D.preAt I) h m (D.c j G (A.blkStart D.S.K I.1) (D.preAt I)))

                  The component size of the final class F_h(m) is σ_F = compSizeSq^{1/2}.

                  noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskShift {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) (xs : ℝ) (a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
                  ↥((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 → ℤ

                  A choice of the shifts of the torus form eq:core-torus-form of the selected modes of a core role (any shifts with the torus form, when they exist).

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskShift_spec {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) (xs : ℝ) (a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (hx : ∃ (ns : ↥((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.TorusFormAt G I j (h - D.SP.Δ) xs (D.maskSel G I j asg w h F) ns a) :
                    D.TorusFormAt G I j (h - D.SP.Δ) xs (D.maskSel G I j asg w h F) (D.maskShift G I j asg w h F xs a) a
                    noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSize {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) (xs : ℝ) (a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :

                    The torus size a'_j of the selected modes of a core role with the chosen shifts.

                    Equations
                    Instances For
                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSize_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) (xs : ℝ) (a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
                      0 ≤ D.maskSize G I j asg w h F xs a
                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSel_torus_form_of {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {h : ℕ} (hQ : 1 ≤ D.S.Q0) (hD : 2 ≤ D.S.Dstar) (hcard : ↑((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))).card ≤ D.S.Dstar) (hΛ : (D.Ms j G).Λ ≤ D.S.Dstar) (hK : D.S.Dstar ^ 600 ≤ 2 ^ D.S.K) {a : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (F : Finset (D.Ms j G).Md) {xs : ℝ} (hxs : xs ∈ dyadicGridCell A.G I.1 I.2) (hF : ∀ x ∈ D.maskSel G I j asg w h F, x ∈ ((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).E (h - D.SP.Δ) a) :
                      ∃ (ns : ↥((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.TorusFormAt G I j (h - D.SP.Δ) xs (D.maskSel G I j asg w h F) ns a

                      Blueprint lines 2467-2471 for the masked selection with a given anchor: when every selected mode lies in the PRE predecessor E_{h-Δ}(a) of the anchor, the selected modes have the torus form eq:core-torus-form at h - Δ (cell_torus_form).

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.sum_compSub {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (l : Fin 4) (G : bf.Grp) (I : ℤ × ℤ) (S : Finset (Finset (D.Ms l G).Md)) (hS : (↑S).PairwiseDisjoint id) :
                      ∑ K ∈ S, D.compSub l G I K = D.compSub l G I (S.biUnion id)

                      The subtotals of pairwise disjoint components add up to the subtotal of their union.

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSel_map {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) :
                      Finset.map { toFun := Subtype.val, inj' := ⋯ } (D.maskSel G I j asg w h F) = (D.maskComps G I j asg w h F).biUnion id

                      The selected modes are the union of the masked components.

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_filter_sum {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {M : Type u_1} [AddCommMonoid M] (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) {l : Fin 4} (hl : σ l = 0) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms l G).Md) (f : Option (Finset (D.Ms l G).Md) → M) :
                      ∑ o ∈ Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) with D.coreCls G I h l o = F, f o = ∑ K ∈ D.maskComps G I l asg w h F, f (some K)

                      The masked components of a core slot with final class F, as entries of the component index set: summing any function over them is summing over maskComps.

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskComps_disjoint {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms j G).Md) :
                      (↑(D.maskComps G I j asg w h F)).PairwiseDisjoint id

                      The masked components of a core slot are pairwise disjoint.

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_sum {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) {l : Fin 4} (hl : σ l = 0) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms l G).Md) (s e : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
                      ∑ o ∈ Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) with D.coreCls G I h l o = F, slotVal σ (fun (l : Fin 4) (K : Finset (D.Ms l G).Md) => D.compSub l G I K) s e l o = D.compSub l G I (Finset.map { toFun := Subtype.val, inj' := ⋯ } (D.maskSel G I l asg w h F))

                      Blueprint lines 2466-2467 (grouping at the final classes): the masked subtotals of a core slot with final class F add up to the subtotal of the selected modes.

                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_coef {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) {l : Fin 4} (hl : σ l = 0) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (F : Finset (D.Ms l G).Md) (s : ℝ) :
                      (∑ o ∈ Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) with D.coreCls G I h l o = F, o.elim s fun (K : Finset (D.Ms l G).Md) => ∑ m ∈ K, ‖D.c l G (A.blkStart D.S.K I.1) (D.preAt I) m‖) = D.coefSum G I l (D.maskSel G I l asg w h F)

                      Blueprint lines 2565-2566 for a group of masked tuples: the absolute coefficient sum of the selected modes of a core slot is the sum over the masked components of their coefficient sums.

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

                      The final classes at h of the core components of a role good at h.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.mem_goodCls {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {G : bf.Grp} {I : ℤ × ℤ} {j : Fin 4} {h : ℕ} {F : Finset (D.Ms j G).Md} (hF : F ∈ D.goodCls G I j h) :
                        ∃ (m : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))), ((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 ∧ D.finCls G I j h m = F

                        A final class of a good core component is the final class of a mode good at h.

                        def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.AnchorOK {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (anc : ℕ → (j : Fin 4) → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :

                        Anchors of the final classes (blueprint line 2467, "they lie in the unique good predecessor of each F_j; let a_j be its representative"): at every upper height h and in every role, every mode of a core component good at h lies in the PRE predecessor E_{h-Δ} of the anchor of its final class (for instance the hereditary representatives, selected_in_pred_of_rep).

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSel_anchor {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {G : bf.Grp} {I : ℤ × ℤ} {anc : ℕ → (j : Fin 4) → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hanc : D.AnchorOK G I anc) {h : ℕ} (hh : h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) (j : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (F : Finset (D.Ms j G).Md) (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
                          x ∈ D.maskSel G I j asg w h F → x ∈ ((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).E (h - D.SP.Δ) (anc h j F)

                          The selected modes of a final class lie in the PRE predecessor of its anchor.

                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.role_size_moments_cls {κ' : 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) (hstab : D.Stab) (I : ℤ × ℤ) (j : Fin 4) (G : bf.Grp) (hdim : (D.Ms j G).zc.dim ≤ D.S.dmax) (hδc : 0 < (D.Ms j G).δc) (hDg : gaugeSqNorm (D.Ms j G).zc.dim (D.Ms j G).δc ≤ D.S.Dstar) {Kf : ℕ} (hKf : 2 * gaugeTail (D.Ms j G).zc.dim (D.Ms j G).δc / 2 ^ Kf * D.S.Dstar ^ 300 ≤ 1) (hQB : ↑D.S.Q0 * 2 ^ (Kf + 1) ≤ D.S.Bstar) (hεw : ∀ (m : (D.Ms j G).Md), D.S.Dstar⁻¹ ≤ (D.Ms j G).L.εM m) (hcard : ↑((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K))).card ≤ D.S.Dstar) (hΛ : (D.Ms j G).Λ ≤ D.S.Dstar) (hJ : 2 ≤ D.SP.Jst) (hδ : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) {h : ℕ} (hh : h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) {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) {F : Finset (D.Ms j G).Md} (hF : D.finCls G I j h m = F) {n : ℕ} (asg : Fin n → Fin 4) (ns : (Fin 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 → ℤ) (a : ↥((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 : ∀ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, D.TorusFormAt G I j (h - D.SP.Δ) xs (D.maskSel G I j asg w h F) (ns w) a) :
                          (∀ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, D.coreSize G I xs (h - D.SP.Δ) j (D.maskSel G I j asg w h F) (ns w) ≤ 6 * D.clsSize G I j F) ∧ ∑ w ∈ Fintype.piFinset fun (x : Fin n) => ModeComponents.upperHeights D.SP.Jst D.SP.δs, (↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card ^ n)⁻¹ * D.coreSize G I xs (h - D.SP.Δ) j (D.maskSel G I j asg w h F) (ns w) ^ 2 ≤ 36 * (2 * D.SP.δs) ^ {i : Fin n | asg i = j}.card * D.clsSize G I j F ^ 2

                          role_size_moments for a final class F = F_h(m), in terms of σ_F = clsSize F.

                          noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.fourCoef {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (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)))) :

                          The principal coefficient of a four-core tuple with representatives a: |WFourier_s(r q', r t')| when it passes the four-core test, 0 when it is discarded (blueprint lines 2519-2530).

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.fourCoef_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (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)))) :
                            0 ≤ D.fourCoef G I xs h' a
                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_err {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) (hσ : ∀ (l : Fin 4), σ l = 0) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (p : (l : Fin 4) → Finset (D.Ms l G).Md) :
                            (∑ r ∈ Fintype.piFinset fun (l : Fin 4) => Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) with ∀ (l : Fin 4), D.coreCls G I h l (r l) = p l, ∏ l : Fin 4, (r l).elim 1 fun (K : Finset (D.Ms l G).Md) => ∑ m ∈ K, ‖D.c l G (A.blkStart D.S.K I.1) (D.preAt I) m‖) = ∏ l : Fin 4, D.coefSum G I l (D.maskSel G I l asg w h (p l))

                            The tuple errors of a group of masked tuples with final classes p: the sum over the group of Π_l Σ_{m ∈ r_l} |α_m| is the product of the coefficient sums of the selected modes.

                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.four_core_principal {κ' : 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) (hstab : D.Stab) (hK : D.S.Dstar ^ 600 ≤ 2 ^ D.S.K) {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 : ℕ} (hJ1 : 1 ≤ J) (hDg : ∀ (j : Fin 4), gaugeSqNorm (D.Ms j G).zc.dim (D.Ms j G).δc ≤ D.S.Dstar) {Kf : ℕ} (hKf : ∀ (j : Fin 4), 2 * gaugeTail (D.Ms j G).zc.dim (D.Ms j G).δc / 2 ^ Kf * D.S.Dstar ^ 300 ≤ 1) (hQBf : ↑D.S.Q0 * 2 ^ (Kf + 1) ≤ D.S.Bstar) (hεw : ∀ (j : Fin 4) (m : (D.Ms j G).Md), D.S.Dstar⁻¹ ≤ (D.Ms j G).L.εM m) (hcard : ∀ (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))).card ≤ D.S.Dstar) (hΛ : ∀ (j : Fin 4), (D.Ms j G).Λ ≤ D.S.Dstar) (hJ : 2 ≤ D.SP.Jst) (hδs : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) (hq : 4 * (2 * D.SP.δs) ^ (1 / 4) < 1) (anc : ℕ → (j : Fin 4) → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (hanc : D.AnchorOK G I anc) {xs : ℝ} (hxs : xs ∈ dyadicGridCell A.G I.1 I.2) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) :
                            ‖(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) fun (x : Fin 4) => 0)‖ ≤ (2 ^ 4 * ∑ h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs, (↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card)⁻¹ * ∑ p ∈ Fintype.piFinset fun (j : Fin 4) => D.goodCls G I j h, (D.fourCoef G I xs (h - D.SP.Δ) fun (j : Fin 4) => anc h j (p j)) * ∏ j : Fin 4, 6 * D.clsSize G I j (p j)) / (1 - 4 * (2 * D.SP.δs) ^ (1 / 4)) + ∑ r ∈ Fintype.piFinset (compIdx (fun (x : Fin 4) => 0) fun (l : Fin 4) => D.compsAt l G I), fourErrC κ' J * (D.S.Dstar ^ 100)⁻¹ * ∏ l : Fin 4, (r l).elim 1 fun (K : Finset (D.Ms l G).Md) => ∑ m ∈ K, ‖D.c l G (A.blkStart D.S.K I.1) (D.preAt I) m‖

                            Blueprint lines 2463-2582 for the four-core pattern on a leaf cell of the side states (eq:principal-core before binning, with eq:core-numerical): with anchors of the final classes (AnchorOK), the form of the four core slots is at most 2⁴ Z / (1 - 4 (2δ_*)^{1/4}) plus the absolute tuple errors C_J D_*^{-100} Π_l Σ_{m ∈ r_l} |α_m|, where Z = Σ_{h ∈ H} |H|⁻¹ Σ_p c_p Π_j 6 σ_{p_j} sums over the final heights and the tuples p of final classes of good core components the principal coefficients c_p = |WFourier_s(r q', r t')| of the passing tuples (0 for discarded ones) times the class sizes (exact common-height selection pattern_first_success, first success pattern_leaf_bound, grouping masked_group_sum, tuple bounds four_core_tuple_bound, moments role_size_moments_cls and principal_word_average).

                            noncomputable def TrilinearHT.Auto.fourBinVal (κ : LocalKernelClass) (J : ℕ) (c : ℝ × ℝ × (Fin 4 → ℝ)) :

                            The value C_J 2μ ν^{-J} Π_j 6 (2 σ_j) of a four-core dyadic bin (μ, ν, σ) (blueprint eq:principal-core, Λ = 1).

                            Equations
                            Instances For
                              noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.fourBin {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (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)))) (σv : Fin 4 → ℝ) :
                              ℝ × ℝ × (Fin 4 → ℝ)

                              The dyadic bin (μ, ν, (σ_j)_j) of a four-core tuple with representatives a and sizes σ (the bands of eq:four-tests and the dyadic bands of the sizes).

                              Equations
                              Instances For
                                noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.fourTestedOf {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) {ι : Type u_1} (T : Finset ι) (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)))) (σv : ι → Fin 4 → ℝ) :

                                The tested four-core tuples of a family: those passing the four-core test with all sizes positive.

                                Equations
                                Instances For
                                  theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.four_core_binned {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (hD : 2 ≤ D.S.Dstar) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (xs : ℝ) (h' J : ℕ) {ι : Type u_1} (T : Finset ι) (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)))) (σv : ι → Fin 4 → ℝ) (hσ : ∀ p ∈ T, ∀ (j : Fin 4), 0 ≤ σv p j) :
                                  ∑ p ∈ T, D.fourCoef G I xs h' (a p) * ∏ j : Fin 4, 6 * σv p j ≤ ∑ c ∈ Finset.image (fun (p : ι) => D.fourBin G I xs h' (a p) (σv p)) (D.fourTestedOf G I xs h' T a σv), fourBinVal κ' J c * ↑{p ∈ D.fourTestedOf G I xs h' T a σv | D.fourBin G I xs h' (a p) (σv p) = c}.card

                                  Blueprint eq:principal-core (lines 2577-2582) for four cores (Λ = 1), at one final height: the principal quantity Σ_p c_p Π_j 6 σ_{p,j} (c_p = |WFourier_s(r q', r t')| for passing tuples, 0 for discarded ones) is at most the sum over the occupied dyadic bins (μ, ν, σ) of the bin values C_J 2μ ν^{-J} Π_j 6 (2σ_j) times the number N of tuples in the bin that pass the four-core test and have all σ_j > 0 (zero factors contribute nothing; four_core_kernel_sample, fourBands_spec, sum_by_bins).

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

                                  The tested four-core tuples at a final height h: tuples of final classes of good core components passing the four-core test with their anchors and with all class sizes positive.

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

                                    The dyadic bin of a four-core tuple of final classes at the final height h.

                                    Equations
                                    Instances For
                                      theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.four_core_principal_bins {κ' : 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) (hstab : D.Stab) (hK : D.S.Dstar ^ 600 ≤ 2 ^ D.S.K) {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 : ℕ} (hJ1 : 1 ≤ J) (hDg : ∀ (j : Fin 4), gaugeSqNorm (D.Ms j G).zc.dim (D.Ms j G).δc ≤ D.S.Dstar) {Kf : ℕ} (hKf : ∀ (j : Fin 4), 2 * gaugeTail (D.Ms j G).zc.dim (D.Ms j G).δc / 2 ^ Kf * D.S.Dstar ^ 300 ≤ 1) (hQBf : ↑D.S.Q0 * 2 ^ (Kf + 1) ≤ D.S.Bstar) (hεw : ∀ (j : Fin 4) (m : (D.Ms j G).Md), D.S.Dstar⁻¹ ≤ (D.Ms j G).L.εM m) (hcard : ∀ (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))).card ≤ D.S.Dstar) (hΛ : ∀ (j : Fin 4), (D.Ms j G).Λ ≤ D.S.Dstar) (hJ : 2 ≤ D.SP.Jst) (hδs : 0 < D.SP.δs) (hδ16 : D.SP.δs ≤ 1 / 16) (hδJ : ⌈4 * D.SP.δs * ↑D.SP.Jst⌉₊ ≤ D.SP.Jst) (hq : 4 * (2 * D.SP.δs) ^ (1 / 4) < 1) (anc : ℕ → (j : Fin 4) → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) (hanc : D.AnchorOK G I anc) {xs : ℝ} (hxs : xs ∈ dyadicGridCell A.G I.1 I.2) (L : (l : Fin 4) → (G : bf.Grp) → LiftData (bf.Lab ⊕ Fin fp.Mc) (D.Ms l G).Md) :
                                      ‖(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) fun (x : Fin 4) => 0)‖ ≤ (2 ^ 4 * ∑ h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs, (↑(ModeComponents.upperHeights D.SP.Jst D.SP.δs).card)⁻¹ * ∑ c ∈ Finset.image (D.fourBinOf G I xs anc h) (D.fourTested G I xs anc h), fourBinVal κ' J c * ↑{p ∈ D.fourTested G I xs anc h | D.fourBinOf G I xs anc h p = c}.card) / (1 - 4 * (2 * D.SP.δs) ^ (1 / 4)) + ∑ r ∈ Fintype.piFinset (compIdx (fun (x : Fin 4) => 0) fun (l : Fin 4) => D.compsAt l G I), fourErrC κ' J * (D.S.Dstar ^ 100)⁻¹ * ∏ l : Fin 4, (r l).elim 1 fun (K : Finset (D.Ms l G).Md) => ∑ m ∈ K, ‖D.c l G (A.blkStart D.S.K I.1) (D.preAt I) m‖

                                      Blueprint eq:principal-core (lines 2577-2582) for the four-core pattern on a leaf cell of the side states (Λ = 1): the form of the four core slots is at most 2⁴/(1 - 4(2δ_*)^{1/4}) Σ_{h ∈ H} |H|⁻¹ Σ_{bins} C_J 2μ ν^{-J} Π_j 6(2σ_j) N_{h,bin}, plus the absolute tuple errors of eq:core-numerical. Here N_{h,bin} is the number of tested tuples of final classes at the final height h in the bin. These tuples pass the four-core test and have nonzero class sizes, and they are counted once each: distinct classes have distinct anchors, anchor_injective. The bin consists of the dyadic bands of μ, ν and of the component sizes σ_j of eq:component-size.

                                      theorem TrilinearHT.Auto.prod_ite_one {M : Type u_1} [CommMonoid M] (l : Fin 4) (f : Fin 4 → M) :
                                      (∏ j : Fin 4, if j = l then 1 else f j) = ∏ j ∈ Finset.univ.erase l, f j

                                      A product with the factor 1 at one index is the product over the other indices.

                                      noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.threeC {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (l : Fin 4) (a : Fin 4 → ℝ) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (J Aw Iw : ℕ) :

                                      The principal window coefficient of a three-core tuple with side role l (blueprint eq:side-windows): 2 Σ_{Λ = 2^i ≤ 2^{I_w}} r⁻¹ C_{J,A} μ ν^{-J} 2^{A+4} Λ^{-(A+1)} b_Λ r with the offset-averaged window energies of the side X, so that threePrin = threeC Π_{j ≠ l} a'_j.

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.threePrin_eq {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (l : Fin 4) (a : 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 → ℤ) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (J Aw Iw : ℕ) :
                                        D.threePrin G I xs h' l a Fsel n X J Aw Iw = D.threeC G I xs h' l a X J Aw Iw * ∏ j ∈ Finset.univ.erase l, D.coreSize G I xs h' j (Fsel j) (n j)
                                        theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.threeC_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (xs : ℝ) (h' : ℕ) (l : Fin 4) (a : Fin 4 → ℝ) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (J Aw Iw : ℕ) :
                                        0 ≤ D.threeC G I xs h' l a X J Aw Iw
                                        noncomputable def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.threeCoef {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (xs : ℝ) (h' : ℕ) (l : Fin 4) (a : Fin 4 → ℝ) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (J Aw Iw : ℕ) :

                                        The principal coefficient of a three-core tuple: threeC if it passes the three-core test, 0 if it is discarded.

                                        Equations
                                        Instances For
                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.threeCoef_nonneg {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {I : ℤ × ℤ} (hI : I ∈ A.cells) (G : bf.Grp) (xs : ℝ) (h' : ℕ) (l : Fin 4) (a : Fin 4 → ℝ) (X : ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) (J Aw Iw : ℕ) :
                                          0 ≤ D.threeCoef G I xs h' l a X J Aw Iw
                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_none {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) {l : Fin 4} (hl : σ l ≠ 0) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) {F : Finset (D.Ms l G).Md} (hF : F ∈ Finset.image (D.coreCls G I h l) (Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l))) :
                                          {o ∈ Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) | D.coreCls G I h l o = F} = {none}

                                          In a non-core slot occurring in a group of masked tuples, the group consists of the single dummy entry.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_side {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (σ : Fin 4 → Fin 3) {l : Fin 4} (hl : σ l = 1) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) {F : Finset (D.Ms l G).Md} (hF : F ∈ Finset.image (D.coreCls G I h l) (Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l))) (s e : Fin 4 → ↥(ColumnL2 (bf.Lab ⊕ Fin fp.Mc))) :
                                          ∑ o ∈ Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx σ (fun (l : Fin 4) => D.compsAt l G I) l) with D.coreCls G I h l o = F, slotVal σ (fun (l : Fin 4) (K : Finset (D.Ms l G).Md) => D.compSub l G I K) s e l o = s l

                                          Blueprint lines 2549-2560 for a group of masked tuples of a three-core pattern: the side slot of the grouped form is the side itself.

                                          theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.masked_group_err3 {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (l : Fin 4) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (h : ℕ) (p : (l : Fin 4) → Finset (D.Ms l G).Md) (hp : p l ∈ Finset.image (D.coreCls G I h l) (Finset.filter (roleMask (D.slotGood G I l) l asg w h) (compIdx (fun (k : Fin 4) => if k = l then 1 else 0) (fun (l : Fin 4) => D.compsAt l G I) l))) :
                                          (∑ r ∈ Fintype.piFinset fun (k : Fin 4) => Finset.filter (roleMask (D.slotGood G I k) k asg w h) (compIdx (fun (k : Fin 4) => if k = l then 1 else 0) (fun (l : Fin 4) => D.compsAt l G I) k) with ∀ (k : Fin 4), D.coreCls G I h k (r k) = p k, ∏ k : Fin 4, (r k).elim 1 fun (K : Finset (D.Ms k G).Md) => ∑ m ∈ K, ‖D.c k G (A.blkStart D.S.K I.1) (D.preAt I) m‖) = ∏ j ∈ Finset.univ.erase l, D.coefSum G I j (D.maskSel G I j asg w h (p j))

                                          The tuple errors of a group of masked tuples of a three-core pattern (side slot l): the sum over the group of Π_k Σ_{m ∈ r_k} |α_m| (the side slot contributing 1) is the product over the core slots of the coefficient sums of the selected modes.

                                          theorem TrilinearHT.Auto.compIdx_of_core (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_1} (Ks : (l : Fin 4) → Finset (κ l)) {l : Fin 4} (hl : σ l = 0) :
                                          theorem TrilinearHT.Auto.compIdx_of_side (σ : Fin 4 → Fin 3) {κ : Fin 4 → Type u_1} (Ks : (l : Fin 4) → Finset (κ l)) {l : Fin 4} (hl : σ l ≠ 0) :
                                          compIdx σ Ks l = {none}
                                          def TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.AnchorOKAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) (G : bf.Grp) (I : ℤ × ℤ) (j : Fin 4) (anc : ℕ → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :

                                          Anchors of the final classes in one role j (the property AnchorOK for this role): every mode of a core component good at an upper height h lies in E_{h-Δ} of the anchor of its class.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            theorem TrilinearHT.Auto.ActiveSetup.BasicFamilies.FamParams.SideInput.maskSel_anchorAt {κ' : LocalKernelClass} {c₀ : ℕ} {A : ActiveSetup κ' c₀} {bf : A.BasicFamilies} {fp : bf.FamParams} (D : fp.SideInput) {G : bf.Grp} {I : ℤ × ℤ} {j : Fin 4} {anc : ℕ → Finset (D.Ms j G).Md → ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))} (hanc : D.AnchorOKAt G I j anc) {h : ℕ} (hh : h ∈ ModeComponents.upperHeights D.SP.Jst D.SP.δs) {n : ℕ} (asg : Fin n → Fin 4) (w : Fin n → ℕ) (F : Finset (D.Ms j G).Md) (x : ↥((D.Ms j G).alive (ancAt A.G (D.preAt I) (A.blkStart D.S.K I.1 - 4 * ↑D.S.K)))) :
                                            x ∈ D.maskSel G I j asg w h F → x ∈ ((D.Ms j G).blockComps D.S ⋯ (A.blkStart D.S.K I.1) (D.preAt I)).E (h - D.SP.Δ) (anc h F)

                                            The selected modes of a final class lie in the PRE predecessor of its anchor (one role).

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

                                            The slopes γ_j^* = ω_{a_j}(x_*) of the anchors of a three-core tuple p of final classes at the height h (side role l, whose entry is 0).

                                            Equations
                                            • D.slopes3 G I xs l anc h p j = if hj : j = l then 0 else (D.Ms j G).slope (↑(anc h j hj (p j))) xs
                                            Instances For