Documentation

Complexitylib.Algebraic.LinearAlgebra.Tensor.Diagonal.Paired.Internal

Koszul flattenings of paired clusters: proof internals #

Proofs behind Complexitylib.Algebraic.LinearAlgebra.Tensor.Diagonal.Paired.

theorem Algebraic.Tensor3.Internal.Paired.card_mul_card_le_rank_of_det_blocks_ne_zero_of_lt {K : Type u_1} [Field K] {m : Type u_2} {n : Type u_3} [Fintype n] {ι : Type u_4} {β : Type u_5} {γ : Type u_6} [Fintype ι] [DecidableEq ι] [Fintype β] [DecidableEq β] [LinearOrder γ] (A : Matrix m n K) (f : ι → β → m) (g : ι → β → n) (v : β → γ) (hv : Function.Injective v) (hoff : ∀ (i i' : ι) (b b' : β), v b' < v b → A (f i b) (g i' b') = 0) (hdet : ∀ (b : β), (A.submatrix (fun (x : ι) => f x b) fun (x : ι) => g x b).det ≠ 0) :

Block-triangular minors. Choose, for each block b : β, rows f i b and columns g i b of A. If every entry from a block b to a block b' with v b' < v b vanishes, for an injective v into a linear order, and every block is nonsingular, then card ι * card β ≤ rank A.

theorem Algebraic.Tensor3.Internal.Paired.choose_mul_card_le_rank_of_sum_shifts {p m : ℕ} {κ : Type u_1} [Fintype κ] (o : κ → Fin (2 * p + 1) → ℤ) (g : κ → Fin (2 * p + 1) → Fin m → ℂ) (e : κ → Fin (2 * p + 1) → Fin m → ℕ) (ho : ∀ (b : κ), Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, o b t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hg : ∀ (b : κ) (t : Fin (2 * p + 1)) (j : Fin m), g b t j = 2 ^ 2 ^ e b t j) (he : ∀ (b : κ) (t t' : Fin (2 * p + 1)) (j j' : Fin m), |↑↑j - ↑↑j'| ≤ ↑(subsetSumSpread p (o b)) → e b t j = e b t' j' → t = t' ∧ j = j') (hinj : ∀ (t : Fin (2 * p + 1)), Function.Injective fun (b : κ) => o b t) {Q : Type u_2} [Fintype Q] [DecidableEq Q] (c : Q → κ) (w : Q → ℤ) (v : Q → ℕ) (hv : Function.Injective v) (hrange : ∀ (q : Q) (K : Finset (Fin (2 * p + 1))), K.card = p ∨ K.card = p + 1 → 0 ≤ w q + ∑ t ∈ K, o (c q) t ∧ w q + ∑ t ∈ K, o (c q) t < ↑m) (hvanish : ∀ (q q' : Q), v q' < v q → ∀ (b : κ) (I : Finset (Fin (2 * p + 1))) (t : Fin (2 * p + 1)), I.card = p → t ∉ I → w q + ∑ x ∈ insert t I, o (c q) x ≠ w q' + ∑ x ∈ I, o (c q') x + o b t) :
(2 * p + 1).choose p * Fintype.card Q ≤ (koszulFlattening p (∑ b : κ, weightedShifts (o b) (g b))).rank

Several clusters on one slice space. Let o b (b : κ) be clusters of offsets whose p-subset sums are pairwise distinct, with weights 2^{2^{e b t j}} as in the single-cluster certificate, and with o b t ≠ o b' t for b ≠ b'. Let the blocks q : Q have clusters c q, shifts w q with all positions in [0, m), and an injective order v. If no entry goes from a later block to an earlier one, then the Koszul flattening of ∑ b, weightedShifts (o b) (g b) has rank at least (2p+1).choose p * card Q.

theorem Algebraic.Tensor3.Internal.Paired.choose_mul_card_le_rank_of_centers {p m : ℕ} {κ : Type u_1} [Fintype κ] (o : κ → Fin (2 * p + 1) → ℤ) (g : κ → Fin (2 * p + 1) → Fin m → ℂ) (e : κ → Fin (2 * p + 1) → Fin m → ℕ) (ho : ∀ (b : κ), Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, o b t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hg : ∀ (b : κ) (t : Fin (2 * p + 1)) (j : Fin m), g b t j = 2 ^ 2 ^ e b t j) (he : ∀ (b : κ) (t t' : Fin (2 * p + 1)) (j j' : Fin m), |↑↑j - ↑↑j'| ≤ ↑(subsetSumSpread p (o b)) → e b t j = e b t' j' → t = t' ∧ j = j') (hinj : ∀ (t : Fin (2 * p + 1)), Function.Injective fun (b : κ) => o b t) (rr : κ → ℤ) (F G : ℕ) (hF : ∀ (b : κ) (K : Finset (Fin (2 * p + 1))), |∑ t ∈ K, o b t - ↑K.card * rr b| ≤ ↑F) (hG : ∀ (b : κ) (t : Fin (2 * p + 1)), |o b t - rr b| ≤ ↑G) {Q : Type u_2} [Fintype Q] [DecidableEq Q] (c : Q → κ) (x : Q → ℤ) (v : Q → ℕ) (hv : Function.Injective v) (hx : ∀ (q q' : Q), c q = c q' → x q = x q' → q = q') (hrange : ∀ (q : Q), ↑F ≤ x q ∧ x q + ↑F < ↑m ∧ ↑F ≤ x q + rr (c q) ∧ x q + rr (c q) + ↑F < ↑m) (hsep : ∀ (q q' : Q), v q' < v q → ∀ (b : κ), ¬(c q = b ∧ c q' = b) → 2 * ↑F + ↑G < |x q + rr (c q) - x q' - rr b|) :
(2 * p + 1).choose p * Fintype.card Q ≤ (koszulFlattening p (∑ b : κ, weightedShifts (o b) (g b))).rank

Several clusters, by centers. The certificate choose_mul_card_le_rank_of_sum_shifts with the shift of block q equal to x q - p * rr (c q), where the sums ∑_K o b lie within F of |K| * rr b and the offsets o b t within G of rr b: the columns of block q then lie within F of x q and its rows within F of x q + rr (c q). It suffices that these stay in [0, m), that blocks of one cluster have distinct centers, and that the row center of a later block q is more than 2F + G away from x q' + rr b for an earlier block q' and a cluster b not shared by both.

theorem Algebraic.Tensor3.Internal.Paired.abs_sum_sub_card_mul_le {p : ℕ} (o : Fin (2 * p + 1) → ℤ) (ho : Monotone o) {L : ℤ} (hL : o (Fin.last (2 * p)) - o 0 ≤ L) (K : Finset (Fin (2 * p + 1))) :
|∑ t ∈ K, o t - ↑K.card * o ⟨p, ⋯⟩| ≤ ↑p * L

The sums over subsets of a monotone cluster with median o p and diameter at most L lie within p L of |K| * o p.

theorem Algebraic.Tensor3.Internal.Paired.abs_sub_median_le {p : ℕ} (o : Fin (2 * p + 1) → ℤ) (ho : Monotone o) {L : ℤ} (hL : o (Fin.last (2 * p)) - o 0 ≤ L) (t : Fin (2 * p + 1)) :
|o t - o ⟨p, ⋯⟩| ≤ L

The offsets of a monotone cluster with diameter at most L lie within L of the median.

@[reducible, inline]
abbrev Algebraic.Tensor3.Internal.Paired.Tiles (a₁ a₂ a₃ a₄ : ℕ) :

The blocks of the two-tile certificate: the tiles P1, P2, N2, N1, in this order.

Equations
Instances For
    def Algebraic.Tensor3.Internal.Paired.tileSign {a₁ a₂ a₃ a₄ : ℕ} :
    Tiles a₁ a₂ a₃ a₄ → Bool

    The cluster of a block: true (positive) on P1 and P2, false (negative) on N2 and N1.

    Equations
    Instances For
      def Algebraic.Tensor3.Internal.Paired.tileCenter {a₁ a₂ a₃ a₄ : ℕ} (r s μ : ℕ) :
      Tiles a₁ a₂ a₃ a₄ → ℤ

      The column center of a block, for z = r + s and the margin μ: μ + i on P1, z + μ + i on P2, z + s + μ + i on N2, and s + μ + i on N1.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        def Algebraic.Tensor3.Internal.Paired.tileOrder {a₁ a₂ a₃ a₄ : ℕ} :
        Tiles a₁ a₂ a₃ a₄ → ℕ

        The order of the blocks: P1, then P2, then N2, then N1.

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

          The median of the cluster of sign b: r for the positive cluster, -s for the negative one.

          Equations
          Instances For
            theorem Algebraic.Tensor3.Internal.Paired.tileCenter_injOn {a₁ a₂ a₃ a₄ r s μ : ℕ} (ha₁ : a₁ ≤ s) (ha₄ : a₄ ≤ r) (q q' : Tiles a₁ a₂ a₃ a₄) (hc : tileSign q = tileSign q') (hx : tileCenter r s μ q = tileCenter r s μ q') :
            q = q'
            theorem Algebraic.Tensor3.Internal.Paired.tileCenter_range {a₁ a₂ a₃ a₄ r s m μ F : ℕ} (hF : F ≤ μ) (ha₁ : a₁ ≤ s - 2 * μ) (ha₂ : a₂ ≤ min s (m - r - (r + s)) - 2 * μ) (ha₃ : a₃ ≤ min r (m - s - (r + s)) - 2 * μ) (ha₄ : a₄ ≤ r - 2 * μ) (hrs : r + s ≤ m) (q : Tiles a₁ a₂ a₃ a₄) :
            ↑F ≤ tileCenter r s μ q ∧ tileCenter r s μ q + ↑F < ↑m ∧ ↑F ≤ tileCenter r s μ q + signMedian r s (tileSign q) ∧ tileCenter r s μ q + signMedian r s (tileSign q) + ↑F < ↑m
            theorem Algebraic.Tensor3.Internal.Paired.tileCenter_sep {a₁ a₂ a₃ a₄ r s m μ : ℕ} (ha₁ : a₁ ≤ s - 2 * μ) (ha₂ : a₂ ≤ min s (m - r - (r + s)) - 2 * μ) (ha₃ : a₃ ≤ min r (m - s - (r + s)) - 2 * μ) (ha₄ : a₄ ≤ r - 2 * μ) (q q' : Tiles a₁ a₂ a₃ a₄) (hlt : tileOrder q' < tileOrder q) (b : Bool) (hb : ¬(tileSign q = b ∧ tileSign q' = b)) :
            2 * ↑μ < |tileCenter r s μ q + signMedian r s (tileSign q) - tileCenter r s μ q' - signMedian r s b|

            The tiles are separated. For a later block q and an earlier block q', and a cluster b not shared by both, the row center of q is more than 2μ away from the center of q' shifted by the median of b.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_rank_pair {p m : ℕ} (oP oN : Fin (2 * p + 1) → ℤ) (gP gN : Fin (2 * p + 1) → Fin m → ℂ) (eP eN : Fin (2 * p + 1) → Fin m → ℕ) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, oP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, oN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hgP : ∀ (t : Fin (2 * p + 1)) (j : Fin m), gP t j = 2 ^ 2 ^ eP t j) (hgN : ∀ (t : Fin (2 * p + 1)) (j : Fin m), gN t j = 2 ^ 2 ^ eN t j) {L : ℕ} (heP : ∀ (t t' : Fin (2 * p + 1)) (j j' : Fin m), |↑↑j - ↑↑j'| ≤ ↑p * ↑L → eP t j = eP t' j' → t = t' ∧ j = j') (heN : ∀ (t t' : Fin (2 * p + 1)) (j j' : Fin m), |↑↑j - ↑↑j'| ≤ ↑p * ↑L → eN t j = eN t' j' → t = t' ∧ j = j') (hPN : ∀ (t : Fin (2 * p + 1)), oP t ≠ oN t) (hmP : Monotone oP) (hmN : Monotone oN) {r s : ℕ} (hr : oP ⟨p, ⋯⟩ = ↑r) (hs : oN ⟨p, ⋯⟩ = -↑s) (hLP : oP (Fin.last (2 * p)) - oP 0 ≤ ↑L) (hLN : oN (Fin.last (2 * p)) - oN 0 ≤ ↑L) (hrs : r + s ≤ m) :
            (2 * p + 1).choose p * (r + s + min s (m - r - (r + s)) + min r (m - s - (r + s)) - 8 * ((p + 1) * L)) ≤ (koszulFlattening p (weightedShifts oP gP + weightedShifts oN gN)).rank

            The two-tile certificate for a positive and a negative cluster. For a positive cluster oP with median r and a negative cluster oN with median -s, both monotone with diameter at most L and with distinct p-subset sums, labels injective on positions whose columns differ by at most p L, and r + s ≤ m, the Koszul flattening of weightedShifts oP gP + weightedShifts oN gN has rank at least (2p+1).choose p times r + s + min s (m - r - z) + min r (m - s - z) - 8 (p + 1) L, where z = r + s.

            theorem Algebraic.Tensor3.Internal.Paired.map_add_left {α : Type u_1} {α' : Type u_2} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {γ' : Type u_6} [Fintype α] [Fintype β] [Fintype γ] (X X' : Matrix α' α ℂ) (Y : Matrix β' β ℂ) (Z : Matrix γ' γ ℂ) (T : Tensor3 α β γ) :
            map (X + X') Y Z T = map X Y Z T + map X' Y Z T
            theorem Algebraic.Tensor3.Internal.Paired.map_add_selectSlices_map_diagonal {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_5} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (cP cN : α' → α) (d : α → ℂ) (hdP : ∀ (t : α'), d (cP t) = 1) (hdN : ∀ (t : α'), d (cN t) = 1) (T : Tensor3 α β γ) :
            theorem Algebraic.Tensor3.Internal.Paired.map_add_selectSlices_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) :
            map (selectSlices cP + selectSlices cN) 1 1 (lmTensor k γ) = (weightedShifts (clusterOffsets k cP) fun (t : Fin (2 * p + 1)) (j : Fin (2 * k + 1)) => γ (cP t) j) + weightedShifts (clusterOffsets k cN) fun (t : Fin (2 * p + 1)) (j : Fin (2 * k + 1)) => γ (cN t) j
            theorem Algebraic.Tensor3.Internal.Paired.map_add_selectSlices_weightedLMTensor {k p : ℕ} (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) :
            map (selectSlices cP + selectSlices cN) 1 1 (weightedLMTensor k) = (weightedShifts (clusterOffsets k cP) fun (t : Fin (2 * p + 1)) (j : Fin (2 * k + 1)) => lmWeight k (cP t) j) + weightedShifts (clusterOffsets k cN) fun (t : Fin (2 * p + 1)) (j : Fin (2 * k + 1)) => lmWeight k (cN t) j
            theorem Algebraic.Tensor3.Internal.Paired.lmLabel_window {k p : ℕ} (L : ℕ) (a a' j j' : Fin (2 * k + 1)) :
            |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → ∀ (h : ↑a * (2 * k + 1) + ↑j = ↑a' * (2 * k + 1) + ↑j'), a = a' ∧ j = j'

            The labels a (2k + 1) + j of lmWeight separate all positions, in particular those of every window.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_rank_pair_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ (koszulFlattening p (map (selectSlices cP + selectSlices cN) 1 1 (lmTensor k γ))).rank

            The paired certificate for T_k(γ) with window labels. The coefficients are γ a j = 2^{2^{e a j}} with labels e separating positions whose slices differ by at most L and whose columns differ by at most p L.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_rank_pair_weightedLMTensor {k p : ℕ} (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s L : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ (koszulFlattening p (map (selectSlices cP + selectSlices cN) 1 1 (weightedLMTensor k))).rank

            The paired certificate for the weighted Landsberg–Michałek tensor.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_borderRank_mul_map_diagonal_pair_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (d : Fin (2 * k + 1) → ℂ) (hdP : ∀ (t : Fin (2 * p + 1)), d (cP t) = 1) (hdN : ∀ (t : Fin (2 * p + 1)), d (cN t) = 1) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ (map (Matrix.diagonal d) 1 1 (lmTensor k γ)).borderRank * (2 * p).choose p
            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_borderRank_mul_map_diagonal_pair {k p : ℕ} (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s L : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (d : Fin (2 * k + 1) → ℂ) (hdP : ∀ (t : Fin (2 * p + 1)), d (cP t) = 1) (hdN : ∀ (t : Fin (2 * p + 1)), d (cN t) = 1) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ (map (Matrix.diagonal d) 1 1 (weightedLMTensor k)).borderRank * (2 * p).choose p
            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_borderRank_mul_restrictSlices_pair_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (S : Finset (Fin (2 * k + 1))) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ ((lmTensor k γ).restrictSlices S).borderRank * (2 * p).choose p
            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_le_borderRank_mul_restrictSlices_pair {k p : ℕ} (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hP : k < ↑(cP 0)) (hN : ↑(cN (Fin.last (2 * p))) < k) {r s L : ℕ} (hr : ↑(cP ⟨p, ⋯⟩) = k + r) (hs : ↑(cN ⟨p, ⋯⟩) + s = k) (hLP : ↑(cP (Fin.last (2 * p))) ≤ ↑(cP 0) + L) (hLN : ↑(cN (Fin.last (2 * p))) ≤ ↑(cN 0) + L) (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (S : Finset (Fin (2 * k + 1))) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) :
            (2 * p + 1).choose p * (r + s + min s (2 * k + 1 - r - (r + s)) + min r (2 * k + 1 - s - (r + s)) - 8 * ((p + 1) * L)) ≤ ((weightedLMTensor k).restrictSlices S).borderRank * (2 * p).choose p
            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_sub_le_borderRank_mul_restrictSlices_single {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : StrictMono c) (hL : ↑↑(c (Fin.last (2 * p))) - ↑↑(c 0) ≤ ↑L) (ho : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k c t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (S : Finset (Fin (2 * k + 1))) (hS : ∀ (t : Fin (2 * p + 1)), c t ∈ S) :
            ↑((2 * p + 1).choose p) * (2 * ↑k + 1 - (|↑↑(c ⟨p, ⋯⟩) - ↑k| + ↑p * ↑L)) ≤ ↑((lmTensor k γ).restrictSlices S).borderRank * ↑((2 * p).choose p)

            The single-cluster bound on a restricted tensor, with the spread bounded by the median: (2p+1).choose p * (2k + 1 - (|median| + p L)) ≤ borderRank * (2p).choose p, over ℤ.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_phi_sub_le_borderRank_mul_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) (S : Finset (Fin (2 * k + 1))) (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hLP : clusterOffsets k cP ⟨2 * p, ⋯⟩ - clusterOffsets k cP 0 ≤ ↑L) (hLN : clusterOffsets k cN ⟨2 * p, ⋯⟩ - clusterOffsets k cN 0 ≤ ↑L) (hP : ∀ (t : Fin (2 * p + 1)), 1 ≤ clusterOffsets k cP t ∧ clusterOffsets k cP t ≤ ↑k) (hN : ∀ (t : Fin (2 * p + 1)), -↑k ≤ clusterOffsets k cN t ∧ clusterOffsets k cN t ≤ -1) :
            ↑((2 * p + 1).choose p) * (DeletionGame.phi (2 * ↑k + 1) (clusterOffsets k cP ⟨p, ⋯⟩) (-clusterOffsets k cN ⟨p, ⋯⟩) - 8 * (↑p + 1) * ↑L) ≤ ↑((lmTensor k γ).restrictSlices S).borderRank * ↑((2 * p).choose p)

            The combined bound for T_k(γ) with window labels, over ℤ.

            theorem Algebraic.Tensor3.Internal.Paired.choose_mul_phi_sub_le_borderRank_mul {k p : ℕ} (S : Finset (Fin (2 * k + 1))) (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) {L : ℕ} (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hLP : clusterOffsets k cP ⟨2 * p, ⋯⟩ - clusterOffsets k cP 0 ≤ ↑L) (hLN : clusterOffsets k cN ⟨2 * p, ⋯⟩ - clusterOffsets k cN 0 ≤ ↑L) (hP : ∀ (t : Fin (2 * p + 1)), 1 ≤ clusterOffsets k cP t ∧ clusterOffsets k cP t ≤ ↑k) (hN : ∀ (t : Fin (2 * p + 1)), -↑k ≤ clusterOffsets k cN t ∧ clusterOffsets k cN t ≤ -1) :
            ↑((2 * p + 1).choose p) * (DeletionGame.phi (2 * ↑k + 1) (clusterOffsets k cP ⟨p, ⋯⟩) (-clusterOffsets k cN ⟨p, ⋯⟩) - 8 * (↑p + 1) * ↑L) ≤ ↑((weightedLMTensor k).restrictSlices S).borderRank * ↑((2 * p).choose p)

            The combined bound, over ℤ.

            theorem Algebraic.Tensor3.Internal.Paired.div_eq_choose_div_choose {p : ℕ} :
            (2 * ↑p + 1) / (↑p + 1) = ↑((2 * p + 1).choose p) / ↑((2 * p).choose p)

            (2p+1) / (p+1) = (2p+1).choose p / (2p).choose p.

            theorem Algebraic.Tensor3.Internal.Paired.div_mul_phi_sub_le_borderRank_lmTensor {k p : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) (e : Fin (2 * k + 1) → Fin (2 * k + 1) → ℕ) (hγ : ∀ (a j : Fin (2 * k + 1)), γ a j = 2 ^ 2 ^ e a j) (S : Finset (Fin (2 * k + 1))) (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) {L : ℕ} (he : ∀ (a a' j j' : Fin (2 * k + 1)), |↑↑a - ↑↑a'| ≤ ↑L → |↑↑j - ↑↑j'| ≤ ↑p * ↑L → e a j = e a' j' → a = a' ∧ j = j') (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hLP : clusterOffsets k cP ⟨2 * p, ⋯⟩ - clusterOffsets k cP 0 ≤ ↑L) (hLN : clusterOffsets k cN ⟨2 * p, ⋯⟩ - clusterOffsets k cN 0 ≤ ↑L) (hP : ∀ (t : Fin (2 * p + 1)), 1 ≤ clusterOffsets k cP t ∧ clusterOffsets k cP t ≤ ↑k) (hN : ∀ (t : Fin (2 * p + 1)), -↑k ≤ clusterOffsets k cN t ∧ clusterOffsets k cN t ≤ -1) :
            (2 * ↑p + 1) / (↑p + 1) * (↑(DeletionGame.phi (2 * ↑k + 1) (clusterOffsets k cP ⟨p, ⋯⟩) (-clusterOffsets k cN ⟨p, ⋯⟩)) - 8 * (↑p + 1) * ↑L) ≤ ↑((lmTensor k γ).restrictSlices S).borderRank

            The combined bound for T_k(γ) with window labels.

            theorem Algebraic.Tensor3.Internal.Paired.div_mul_phi_sub_le_borderRank {k p : ℕ} (S : Finset (Fin (2 * k + 1))) (cP cN : Fin (2 * p + 1) → Fin (2 * k + 1)) (hcP : StrictMono cP) (hcN : StrictMono cN) (hSP : ∀ (t : Fin (2 * p + 1)), cP t ∈ S) (hSN : ∀ (t : Fin (2 * p + 1)), cN t ∈ S) {L : ℕ} (hoP : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cP t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hoN : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, clusterOffsets k cN t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hLP : clusterOffsets k cP ⟨2 * p, ⋯⟩ - clusterOffsets k cP 0 ≤ ↑L) (hLN : clusterOffsets k cN ⟨2 * p, ⋯⟩ - clusterOffsets k cN 0 ≤ ↑L) (hP : ∀ (t : Fin (2 * p + 1)), 1 ≤ clusterOffsets k cP t ∧ clusterOffsets k cP t ≤ ↑k) (hN : ∀ (t : Fin (2 * p + 1)), -↑k ≤ clusterOffsets k cN t ∧ clusterOffsets k cN t ≤ -1) :
            (2 * ↑p + 1) / (↑p + 1) * (↑(DeletionGame.phi (2 * ↑k + 1) (clusterOffsets k cP ⟨p, ⋯⟩) (-clusterOffsets k cN ⟨p, ⋯⟩)) - 8 * (↑p + 1) * ↑L) ≤ ↑((weightedLMTensor k).restrictSlices S).borderRank

            The combined bound.