Documentation

Complexitylib.Algebraic.LinearAlgebra.Tensor.Diagonal

The Koszul-flattening certificate for one cluster of slices #

This file proves the single-cluster lemma of the program for border rank (7/3 - o(1)) m of explicit tensors in the setting of Landsberg and Michałek, Towards finding hay in a haystack, Theory of Computing 2025: a lower bound for the Koszul flattening of the tensor formed by 2p + 1 slices of a weighted Landsberg–Michałek tensor, and the border-rank bound it gives. The definitions are in Complexitylib.Algebraic.LinearAlgebra.Tensor.Diagonal.Defs.

The statement #

Let m = 2k + 1 and let c : Fin (2p+1) → Fin (2k+1) select 2p + 1 slices (a cluster) of T_k(γ) (Tensor3.lmTensor), with offsets o t = c t - k (Tensor3.clusterOffsets). The cluster tensor map (selectSlices c) 1 1 T_k(γ) is weightedShifts o (γ ∘ c): its slice t is supported on the diagonal ℓ = j + o t. Suppose that

Then the Koszul flattening T_A^{∧p} of the cluster tensor has rank at least (2p+1).choose p * (m - sumSpread p o) (Tensor3.choose_mul_le_rank_koszulFlattening_lmTensor). The explicit coefficients lmWeight k a j = 2^{2^{a (2k+1) + j}} satisfy the label condition for every injective c (Tensor3.choose_mul_le_rank_koszulFlattening_weightedLMTensor). By the Koszul-flattening bound after the projection onto the 2p + 1 cluster slices (denominator (2p).choose p), (2p+1).choose p * (m - sumSpread p o) ≤ borderRank T * (2p).choose p for the weighted tensor T = weightedLMTensor k, and also for T = map (diagonal d) 1 1 (weightedLMTensor k) whenever d (c t) = 1 for all t, for instance when d is the indicator of a set of slices containing the cluster and T is the tensor with the other slices zeroed (Tensor3.choose_mul_le_borderRank_mul_map_diagonal_weightedLMTensor, Tensor3.not_borderRankLE_map_diagonal_weightedLMTensor). Projecting such a restricted tensor onto the cluster gives the same cluster tensor (Tensor3.map_selectSlices_map_diagonal).

For monotone offsets with median r = o p and diameter o (2p) - o 0 ≤ L, the spread is at most |r| + p L (Tensor3.sumSpread_le, Tensor3.sumSpread_clusterOffsets_le), whatever the signs of the offsets. The window of the labels is smaller: the p-subset spread is at most p L, independent of the median (Tensor3.subsetSumSpread_le, Tensor3.subsetSumSpread_clusterOffsets_le), and at most sumSpread p o (Tensor3.subsetSumSpread_le_sumSpread). So labels need only be distinct on positions whose columns differ by at most p L, which allows labels periodic in the column, with entries of size independent of m (Tensor3.periodicLMTensor).

The proof #

theorem Algebraic.Tensor3.map_selectSlices {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_4} [Fintype α] [DecidableEq α] [Fintype β] [DecidableEq β] [Fintype γ] [DecidableEq γ] (c : α' → α) (T : Tensor3 α β γ) :

selectSlices c applied to the first factor keeps the slices c t.

theorem Algebraic.Tensor3.map_diagonal_apply {α : Type u_1} {β : Type u_3} {γ : Type u_4} [Fintype α] [DecidableEq α] [Fintype β] [DecidableEq β] [Fintype γ] [DecidableEq γ] (d : α → ℂ) (T : Tensor3 α β γ) (a : α) (j : β) (l : γ) :
map (Matrix.diagonal d) 1 1 T a j l = d a * T a j l

diagonal d applied to the first factor scales the slice a by d a.

theorem Algebraic.Tensor3.map_selectSlices_map_diagonal {α : Type u_1} {α' : Type u_2} {β : Type u_3} {γ : Type u_4} [Fintype α] [DecidableEq α] [Fintype β] [DecidableEq β] [Fintype γ] [DecidableEq γ] (c : α' → α) (d : α → ℂ) (hd : ∀ (t : α'), d (c t) = 1) (T : Tensor3 α β γ) :
map (selectSlices c) 1 1 (map (Matrix.diagonal d) 1 1 T) = map (selectSlices c) 1 1 T

Scaling slices by d and then keeping the slices c t gives the same tensor as keeping them directly, when d (c t) = 1 for every t.

theorem Algebraic.Tensor3.sub_le_sumSpread {α : Type u_1} {p : ℕ} [Fintype α] (o : α → ℤ) {K K' : Finset α} (hK : K.card = p ∨ K.card = p + 1) (hK' : K'.card = p ∨ K'.card = p + 1) :
∑ t ∈ K, o t - ∑ t ∈ K', o t ≤ ↑(sumSpread p o)

The difference of two sums over subsets of size p or p + 1 is at most the spread.

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

The spread of a cluster. For monotone offsets o with median r = o p and diameter o (2p) - o 0 ≤ L, the sums over subsets of size p or p + 1 spread over at most |r| + p L. No sign condition on the offsets is needed.

theorem Algebraic.Tensor3.sumSpread_clusterOffsets_le {p k : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Monotone c) {L : ℤ} (hL : ↑↑(c (Fin.last (2 * p))) - ↑↑(c 0) ≤ L) :
↑(sumSpread p (clusterOffsets k c)) ≤ |↑↑(c ⟨p, ⋯⟩) - ↑k| + ↑p * L

The spread of a cluster of slices. For a monotone cluster c with median slice c p (offset c p - k) and diameter c (2p) - c 0 ≤ L, the spread of its offsets is at most |c p - k| + p L.

theorem Algebraic.Tensor3.sub_le_subsetSumSpread {α : Type u_1} {p : ℕ} [Fintype α] (o : α → ℤ) {I I' : Finset α} (hI : I.card = p) (hI' : I'.card = p) :
∑ t ∈ I, o t - ∑ t ∈ I', o t ≤ ↑(subsetSumSpread p o)

The difference of two p-subset sums is at most the p-subset spread.

The p-subset spread is at most the spread over subsets of size p or p + 1.

theorem Algebraic.Tensor3.subsetSumSpread_le {p : ℕ} (o : Fin (2 * p + 1) → ℤ) (ho : Monotone o) {L : ℤ} (hL : o (Fin.last (2 * p)) - o 0 ≤ L) :
↑(subsetSumSpread p o) ≤ ↑p * L

The p-subset spread of a cluster. For monotone offsets o with diameter o (2p) - o 0 ≤ L, the p-subset sums spread over at most p L, whatever the median.

theorem Algebraic.Tensor3.subsetSumSpread_clusterOffsets_le {p k : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Monotone c) {L : ℤ} (hL : ↑↑(c (Fin.last (2 * p))) - ↑↑(c 0) ≤ L) :
↑(subsetSumSpread p (clusterOffsets k c)) ≤ ↑p * L

The p-subset spread of a cluster of slices. For a monotone cluster c with diameter c (2p) - c 0 ≤ L, the p-subset spread of its offsets is at most p L.

theorem Algebraic.Tensor3.choose_mul_le_rank_koszulFlattening_weightedShifts {p m : ℕ} (o : Fin (2 * p + 1) → ℤ) (g : Fin (2 * p + 1) → Fin m → ℂ) (e : Fin (2 * p + 1) → Fin m → ℕ) (ho : Set.InjOn (fun (I : Finset (Fin (2 * p + 1))) => ∑ t ∈ I, o t) {I : Finset (Fin (2 * p + 1)) | I.card = p}) (hg : ∀ (t : Fin (2 * p + 1)) (j : Fin m), g t j = 2 ^ 2 ^ e t j) (he : ∀ (t t' : Fin (2 * p + 1)) (j j' : Fin m), |↑↑j - ↑↑j'| ≤ ↑(subsetSumSpread p o) → e t j = e t' j' → t = t' ∧ j = j') :

The single-cluster Koszul certificate for weighted shifts. Let o be offsets of 2p + 1 slices whose p-subset sums are pairwise distinct, and let the weights be g t j = 2^{2^{e t j}} with labels e that are injective on positions whose columns differ by at most the p-subset spread subsetSumSpread p o (at most sumSpread p o). Then the Koszul flattening T_A^{∧p} of weightedShifts o g has rank at least (2p+1).choose p * (m - sumSpread p o).

theorem Algebraic.Tensor3.map_selectSlices_lmTensor {k : ℕ} (γ : Fin (2 * k + 1) → Fin (2 * k + 1) → ℂ) {n : ℕ} (c : Fin n → Fin (2 * k + 1)) :
map (selectSlices c) 1 1 (lmTensor k γ) = weightedShifts (clusterOffsets k c) fun (t : Fin n) (j : Fin (2 * k + 1)) => γ (c t) j

The cluster tensor of T_k(γ): keeping the slices c t of T_k(γ) gives the weighted shifts with offsets c t - k and weights γ (c t).

theorem Algebraic.Tensor3.lmWeight_eq {k : ℕ} (a j : Fin (2 * k + 1)) :
lmWeight k a j = 2 ^ 2 ^ (↑a * (2 * k + 1) + ↑j)

The explicit weights are doubly exponential: lmWeight k a j = 2^{2^{a (2k+1) + j}}.

theorem Algebraic.Tensor3.choose_mul_le_rank_koszulFlattening_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) (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (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}) (he : ∀ (t t' : Fin (2 * p + 1)) (j j' : Fin (2 * k + 1)), |↑↑j - ↑↑j'| ≤ ↑(subsetSumSpread p (clusterOffsets k c)) → e (c t) j = e (c t') j' → t = t' ∧ j = j') :
(2 * p + 1).choose p * (2 * k + 1 - sumSpread p (clusterOffsets k c)) ≤ (koszulFlattening p (map (selectSlices c) 1 1 (lmTensor k γ))).rank

The single-cluster Koszul certificate for T_k(γ). Let c select 2p + 1 slices of T_k(γ) whose offsets c t - k have pairwise distinct p-subset sums, and let γ a j = 2^{2^{e a j}} with labels e (c t) j injective on positions whose columns differ by at most the p-subset spread. Then the Koszul flattening of the cluster tensor map (selectSlices c) 1 1 T_k(γ) has rank at least (2p+1).choose p * (2k + 1 - sumSpread p (clusterOffsets k c)).

theorem Algebraic.Tensor3.choose_mul_le_rank_koszulFlattening_weightedLMTensor {k p : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Function.Injective c) (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}) :

The single-cluster Koszul certificate for the weighted Landsberg–Michałek tensor. If c selects 2p + 1 distinct slices whose offsets c t - k have pairwise distinct p-subset sums, the Koszul flattening of the cluster tensor of weightedLMTensor k has rank at least (2p+1).choose p * (2k + 1 - sumSpread p (clusterOffsets k c)).

theorem Algebraic.Tensor3.choose_mul_le_borderRank_mul_map_diagonal_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) (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (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}) (he : ∀ (t t' : Fin (2 * p + 1)) (j j' : Fin (2 * k + 1)), |↑↑j - ↑↑j'| ≤ ↑(subsetSumSpread p (clusterOffsets k c)) → e (c t) j = e (c t') j' → t = t' ∧ j = j') (d : Fin (2 * k + 1) → ℂ) (hd : ∀ (t : Fin (2 * p + 1)), d (c t) = 1) :
(2 * p + 1).choose p * (2 * k + 1 - sumSpread p (clusterOffsets k c)) ≤ (map (Matrix.diagonal d) 1 1 (lmTensor k γ)).borderRank * (2 * p).choose p

Border rank from one cluster, for T_k(γ) with some slices zeroed. Under the hypotheses of choose_mul_le_rank_koszulFlattening_lmTensor, if d (c t) = 1 for every t (for instance if d is the indicator of a set of slices containing the cluster), then (2p+1).choose p * (2k + 1 - spread) ≤ borderRank ((diagonal d ⊗ 1 ⊗ 1) T_k(γ)) * (2p).choose p.

theorem Algebraic.Tensor3.choose_mul_le_borderRank_mul_map_diagonal_weightedLMTensor {k p : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Function.Injective c) (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}) (d : Fin (2 * k + 1) → ℂ) (hd : ∀ (t : Fin (2 * p + 1)), d (c t) = 1) :
(2 * p + 1).choose p * (2 * k + 1 - sumSpread p (clusterOffsets k c)) ≤ (map (Matrix.diagonal d) 1 1 (weightedLMTensor k)).borderRank * (2 * p).choose p

Border rank from one cluster, for the weighted Landsberg–Michałek tensor with some slices zeroed. If c selects 2p + 1 distinct slices whose offsets have pairwise distinct p-subset sums and d (c t) = 1 for every t, then (2p+1).choose p * (2k + 1 - spread) ≤ borderRank ((diagonal d ⊗ 1 ⊗ 1) T) * (2p).choose p for T = weightedLMTensor k.

theorem Algebraic.Tensor3.not_borderRankLE_map_diagonal_weightedLMTensor {k p : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Function.Injective c) (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}) (d : Fin (2 * k + 1) → ℂ) (hd : ∀ (t : Fin (2 * p + 1)), d (c t) = 1) {r : ℕ} (hr : r * (2 * p).choose p < (2 * p + 1).choose p * (2 * k + 1 - sumSpread p (clusterOffsets k c))) :

Border rank from one cluster, contrapositive form. Under the hypotheses of choose_mul_le_borderRank_mul_map_diagonal_weightedLMTensor, if r * (2p).choose p < (2p+1).choose p * (2k + 1 - spread), then (diagonal d ⊗ 1 ⊗ 1) (weightedLMTensor k) does not have border rank at most r.

theorem Algebraic.Tensor3.choose_mul_le_borderRank_mul_weightedLMTensor {k p : ℕ} (c : Fin (2 * p + 1) → Fin (2 * k + 1)) (hc : Function.Injective c) (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}) :
(2 * p + 1).choose p * (2 * k + 1 - sumSpread p (clusterOffsets k c)) ≤ (weightedLMTensor k).borderRank * (2 * p).choose p

Border rank from one cluster, for the weighted Landsberg–Michałek tensor. If c selects 2p + 1 distinct slices whose offsets have pairwise distinct p-subset sums, then (2p+1).choose p * (2k + 1 - spread) ≤ borderRank (weightedLMTensor k) * (2p).choose p.