Datasets:

roseking
/

openAI-math-dataset

import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Arithmetic.RankExponent
import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Growth.PolynomialOverhead
import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Growth.SpectralLimit
import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Tensor.Scalar

namespace OAI

/-!
# The rank obstruction behind the preliminary spectral state

The finite catalyst is kept fixed while first tensor powers, then exponent
slack, then the number of copies are varied.  The hypotheses below isolate the
rank inequalities supplied by the catalytic comparison; they do not assert
the existence of a tensor spectrum or the separation argument producing that
comparison.
-/

noncomputable section

open MatrixMultiplication.Foundation

namespace MatrixMultiplication.AuxiliarySeparation

/-- Tensor powers of a fixed exact matrix algorithm retain their exact rank
bound after identifying the product coordinates with one matrix dimension. -/
theorem exactMatrixRank_pow_le (u j : ℕ) :
    exactMatrixRank (u ^ j) ≤ exactMatrixRank u ^ j := by
  classical
  let e : Fin (u ^ j) ≃ (Fin j → Fin u) := Fintype.equivOfCardEq (by simp)
  let f : Fin (u ^ j) × Fin (u ^ j) → Fin j → Fin u × Fin u :=
    fun x i => (e x.1 i, e x.2 i)
  have h := ((exactMatrixRank_spec u).power j).pullback f f f
  have heq : Tensor.pullback f f f (Tensor.power (Tensor.matrixMultiplication u u u) j) =
      Tensor.matrixMultiplication (u ^ j) (u ^ j) (u ^ j) := by
    funext x y z
    simp only [Tensor.pullback, Tensor.power, Tensor.matrixMultiplication, f,
      Fintype.prod_boole, forall_and, ← funext_iff, e.injective.eq_iff]
  rw [heq] at h
  exact exactRank_le h

/-- A floor approximation uses at most `n^j` copies of a fixed matrix
algorithm and loses at most one factor of its fixed matrix dimension. -/
theorem floor_rank_power_bounds {u n R : ℕ} (hu : 2 ≤ u) (hn : 1 ≤ n)
    {τ : ℝ} (hτ : 0 < τ) (hR : (R : ℝ) ≤ (u : ℝ) ^ τ) (j : ℕ) :
    let l := ⌊(j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ⌋₊
    (R : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
      (n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l := by
  have hu1 : (1 : ℝ) < u := by exact_mod_cast (show 1 < u by omega)
  have hu0 : (0 : ℝ) < u := zero_lt_one.trans hu1
  have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
  have hn0 : (0 : ℝ) < n := zero_lt_one.trans_le hn1
  let x := (j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ
  let l := ⌊x⌋₊
  have hx : 0 ≤ x := div_nonneg
    (mul_nonneg (Nat.cast_nonneg j) (Real.logb_nonneg hu1 hn1)) hτ.le
  have hl : (l : ℝ) ≤ x := Nat.floor_le hx
  have hxl : x ≤ (l : ℝ) + 1 := (Nat.lt_floor_add_one x).le
  have hlog : (u : ℝ) ^ Real.logb (u : ℝ) (n : ℝ) = n :=
    Real.rpow_logb hu0 (ne_of_gt hu1) hn0
  change (R : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
    (n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l
  constructor
  · calc
      (R : ℝ) ^ l ≤ ((u : ℝ) ^ τ) ^ l :=
        pow_le_pow_left₀ (Nat.cast_nonneg R) hR l
      _ = (u : ℝ) ^ (τ * (l : ℝ)) := by
        rw [← Real.rpow_natCast, ← Real.rpow_mul hu0.le]
      _ ≤ (u : ℝ) ^ (τ * x) :=
        Real.rpow_le_rpow_of_exponent_le hu1.le (mul_le_mul_of_nonneg_left hl hτ.le)
      _ = (n : ℝ) ^ j := by
        rw [show τ * x = Real.logb (u : ℝ) (n : ℝ) * (j : ℝ) by
          dsimp [x]; field_simp]
        rw [Real.rpow_mul hu0.le, hlog, Real.rpow_natCast]
  · calc
      (n : ℝ) ^ ((j : ℝ) / τ) = (u : ℝ) ^ x := by
        rw [← hlog, ← Real.rpow_mul hu0.le]
        congr 1
        dsimp [x]
        ring
      _ ≤ (u : ℝ) ^ ((l : ℝ) + 1) :=
        Real.rpow_le_rpow_of_exponent_le hu1.le hxl
      _ = (u : ℝ) * (u : ℝ) ^ l := by
        rw [Real.rpow_add hu0, Real.rpow_natCast, Real.rpow_one, mul_comm]

/-- At fixed `n` and exponent slack, every admissible matrix rank budget
forces the exponential growth rate of the catalytic comparison.  The constant
`R` is fixed before the tensor-power parameter varies. -/
theorem catalytic_rank_bound_at_slack {d n K R : ℕ}
    (hd : 0 < d) (hn : 1 ≤ n)
    (hbound : ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ, exactMatrixRank g ≤ n ^ j →
      exactMatrixRank (d ^ j * g) ≤ R * K ^ j)
    {δ : ℝ} (hδ : 0 < δ) :
    (d : ℝ) ^ exactRankExponent *
      (n : ℝ) ^ (exactRankExponent / (exactRankExponent + δ)) ≤ K := by
  let ν := exactRankExponent
  let τ := ν + δ
  have hν : 0 ≤ ν := (by norm_num : (0 : ℝ) ≤ 2).trans exactRankExponent_lower
  have hτ : 0 < τ := add_pos_of_nonneg_of_pos hν hδ
  obtain ⟨u, hu, huR⟩ := exists_exactMatrixRank_lt_rpow
    (show exactRankExponent < τ from lt_add_of_pos_right _ hδ)
  apply le_of_eventually_pow_le_const_mul_pow (C := (u : ℝ) ^ ν * R)
    (Nat.cast_nonneg K)
  filter_upwards [Filter.eventually_ge_atTop (1 : ℕ)] with j hj
  let l := ⌊(j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ⌋₊
  let g := u ^ l
  have hg : 0 < g := pow_pos (by omega) l
  have hf := floor_rank_power_bounds hu hn hτ huR.le j
  change (exactMatrixRank u : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
    (n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l at hf
  have hbudget : exactMatrixRank g ≤ n ^ j := by
    have hpow : (exactMatrixRank g : ℝ) ≤ (exactMatrixRank u : ℝ) ^ l := by
      exact_mod_cast exactMatrixRank_pow_le u l
    have hb := hpow.trans hf.1
    exact_mod_cast hb
  have hrank := hbound j hj g hbudget
  have hsize : (n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * g := by
    simpa only [g, Nat.cast_pow] using hf.2
  have hlow := exactMatrixRank_rpow_lower_of_pos (mul_pos (pow_pos hd j) hg)
  have hpow_n : ((n : ℝ) ^ (ν / τ)) ^ j =
      ((n : ℝ) ^ ((j : ℝ) / τ)) ^ ν := by
    rw [← Real.rpow_natCast, ← Real.rpow_mul (Nat.cast_nonneg n),
      ← Real.rpow_mul (Nat.cast_nonneg n)]
    congr 1
    ring
  calc
    ((d : ℝ) ^ ν * (n : ℝ) ^ (ν / τ)) ^ j =
        (((d ^ j : ℕ) : ℝ) ^ ν) * ((n : ℝ) ^ ((j : ℝ) / τ)) ^ ν := by
      rw [mul_pow, Real.rpow_pow_comm (Nat.cast_nonneg d), hpow_n, Nat.cast_pow]
    _ ≤ (((d ^ j : ℕ) : ℝ) ^ ν) * ((u : ℝ) * g) ^ ν := by
      exact mul_le_mul_of_nonneg_left
        (Real.rpow_le_rpow (Real.rpow_nonneg (Nat.cast_nonneg n) _) hsize hν)
        (Real.rpow_nonneg (Nat.cast_nonneg _) _)
    _ = (u : ℝ) ^ ν * (((d ^ j * g : ℕ) : ℝ) ^ ν) := by
      rw [Nat.cast_mul, Real.mul_rpow (Nat.cast_nonneg u) (Nat.cast_nonneg g),
        Real.mul_rpow (Nat.cast_nonneg (d ^ j)) (Nat.cast_nonneg g)]
      ring
    _ ≤ (u : ℝ) ^ ν * (exactMatrixRank (d ^ j * g) : ℝ) :=
      mul_le_mul_of_nonneg_left hlow (Real.rpow_nonneg (Nat.cast_nonneg u) _)
    _ ≤ (u : ℝ) ^ ν * ((R : ℝ) * (K : ℝ) ^ j) := by
      apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg (Nat.cast_nonneg u) _)
      exact_mod_cast hrank
    _ = ((u : ℝ) ^ ν * R) * (K : ℝ) ^ j := by ring

/-- The numerical rank consequence of a single fixed finite catalyst is
incompatible with `k < d^ν`.  The same `D` and `R` occur for every `n` and
every tensor power.  No uniform bound on the approximation block selected
after an exponent slack is assumed. -/
theorem catalytic_rank_obstruction {d k D R : ℕ} (hd : 0 < d)
    (hbound : ∀ n : ℕ, 1 ≤ n → ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ,
      exactMatrixRank g ≤ n ^ j →
      exactMatrixRank (d ^ j * g) ≤ R * (n * k + D) ^ j) :
    (d : ℝ) ^ exactRankExponent ≤ k := by
  apply spectral_coefficient_le_of_all_nat
    (hν := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 2) exactRankExponent_lower)
    (D := (D : ℝ))
  intro n hn δ hδ
  have h := catalytic_rank_bound_at_slack hd hn (hbound n hn) hδ
  simpa only [Nat.cast_add, Nat.cast_mul] using h

/-- Contradiction form for the finite-obstruction argument. -/
theorem not_catalytic_rank_bounds_of_lt {d k D R : ℕ} (hd : 0 < d)
    (hk : (k : ℝ) < (d : ℝ) ^ exactRankExponent) :
    ¬ (∀ n : ℕ, 1 ≤ n → ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ,
      exactMatrixRank g ≤ n ^ j →
      exactMatrixRank (d ^ j * g) ≤ R * (n * k + D) ^ j) := by
  intro hbound
  exact (not_lt_of_ge (catalytic_rank_obstruction hd hbound)) hk

/-- Iteration and absorption of a fixed catalyst require no cancellation of
the tensor factor `s`.  Monotonicity is explicit so the lemma applies to the
restriction order on a tensor semiring, where additive cancellation fails. -/
theorem catalytic_power_comparison {S : Type*} [CommSemiring S] [Preorder S]
    (hadd : ∀ {a b c e : S}, a ≤ b → c ≤ e → a + c ≤ b + e)
    (hmul : ∀ {a b c e : S}, a ≤ b → c ≤ e → a * c ≤ b * e)
    (hzero : ∀ a : S, 0 ≤ a)
    (D t s : S) (k C : ℕ)
    (hcat : D + t * s ≤ D + (k : S) * s)
    (hD : D ≤ (C : S) * s) (n j : ℕ) :
    (n : S) ^ j * t ^ j * s ≤ ((n * k + C : ℕ) : S) ^ j * s := by
  have hiter : ∀ m : ℕ,
      D + (m : S) * (t * s) ≤ D + (m : S) * ((k : S) * s) := by
    intro m
    induction m with
    | zero => simp
    | succ m ih =>
      calc
        D + ((m + 1 : ℕ) : S) * (t * s) =
            (D + t * s) + (m : S) * (t * s) := by push_cast; ring
        _ ≤ (D + (k : S) * s) + (m : S) * (t * s) := hadd hcat le_rfl
        _ = (D + (m : S) * (t * s)) + (k : S) * s := by ring
        _ ≤ (D + (m : S) * ((k : S) * s)) + (k : S) * s := hadd ih le_rfl
        _ = D + ((m + 1 : ℕ) : S) * ((k : S) * s) := by push_cast; ring
  have habsorb : (n : S) * t * s ≤ ((n * k + C : ℕ) : S) * s := by
    calc
      (n : S) * t * s = 0 + (n : S) * (t * s) := by ring
      _ ≤ D + (n : S) * (t * s) := hadd (hzero D) le_rfl
      _ ≤ D + (n : S) * ((k : S) * s) := hiter n
      _ ≤ (C : S) * s + (n : S) * ((k : S) * s) := hadd hD le_rfl
      _ = ((n * k + C : ℕ) : S) * s := by push_cast; ring
  induction j with
  | zero => simp
  | succ j ih =>
    calc
      (n : S) ^ (j + 1) * t ^ (j + 1) * s =
          ((n : S) ^ j * t ^ j) * ((n : S) * t * s) := by ring
      _ ≤ ((n : S) ^ j * t ^ j) * (((n * k + C : ℕ) : S) * s) :=
        hmul le_rfl habsorb
      _ = ((n * k + C : ℕ) : S) * ((n : S) ^ j * t ^ j * s) := by ring
      _ ≤ ((n * k + C : ℕ) : S) * (((n * k + C : ℕ) : S) ^ j * s) :=
        hmul le_rfl ih
      _ = ((n * k + C : ℕ) : S) ^ (j + 1) * s := by ring

/-- A rank-compatible ordered tensor semiring converts a single finite
catalytic inequality into the actual exact-rank obstruction.  The hypotheses
name the required tensor interpretation and scalar rank domination explicitly;
no additive rank formula or cancellation property is assumed. -/
theorem catalytic_semiring_obstruction {S : Type*} [CommSemiring S] [Preorder S]
    (hadd : ∀ {a b c e : S}, a ≤ b → c ≤ e → a + c ≤ b + e)
    (hmul : ∀ {a b c e : S}, a ≤ b → c ≤ e → a * c ≤ b * e)
    (hzero : ∀ a : S, 0 ≤ a)
    (ρ : S → ℕ) (hρmono : Monotone ρ)
    (hρcopies : ∀ (m : ℕ) (s : S), ρ ((m : S) * s) ≤ m * ρ s)
    (M : ℕ → S)
    (hMmul : ∀ a b : ℕ, M (a * b) = M a * M b)
    (hMpow : ∀ a j : ℕ, M (a ^ j) = M a ^ j)
    (hρM : ∀ a : ℕ, ρ (M a) = exactMatrixRank a)
    (hbudget : ∀ n j g : ℕ, exactMatrixRank g ≤ n ^ j → M g ≤ (n : S) ^ j)
    (D s : S) (d k C : ℕ) (hd : 0 < d) (hs : 1 ≤ s)
    (hcat : D + M d * s ≤ D + (k : S) * s)
    (hD : D ≤ (C : S) * s) :
    (d : ℝ) ^ exactRankExponent ≤ k := by
  apply catalytic_rank_obstruction (D := C) (R := ρ s) hd
  intro n _hn j _hj g hg
  have hcompare : M (d ^ j * g) ≤ ((n * k + C : ℕ) : S) ^ j * s := by
    calc
      M (d ^ j * g) = M d ^ j * M g := by rw [hMmul, hMpow]
      _ ≤ M d ^ j * (n : S) ^ j := hmul le_rfl (hbudget n j g hg)
      _ = ((n : S) ^ j * M d ^ j) * 1 := by ring
      _ ≤ ((n : S) ^ j * M d ^ j) * s := hmul le_rfl hs
      _ ≤ ((n * k + C : ℕ) : S) ^ j * s :=
        catalytic_power_comparison hadd hmul hzero D (M d) s k C hcat hD n j
  calc
    exactMatrixRank (d ^ j * g) = ρ (M (d ^ j * g)) := (hρM _).symm
    _ ≤ ρ (((n * k + C : ℕ) : S) ^ j * s) := hρmono hcompare
    _ = ρ ((((n * k + C) ^ j : ℕ) : S) * s) := by rw [Nat.cast_pow]
    _ ≤ (n * k + C) ^ j * ρ s := hρcopies _ s
    _ = ρ s * (n * k + C) ^ j := Nat.mul_comm _ _

/-- In the semiring of actual finite complex tensors modulo mutual
restriction, a fixed catalyst cannot make `k` copies dominate multiplication
by `T_d` unless `k ≥ d^ν`.  The nonzero hypothesis is exactly what supplies
the scalar restriction `s ≥ 1`; the catalyst remains fixed throughout. -/
theorem tensor_catalytic_obstruction
    {D s : TensorSemiring.TensorClass} {d k : ℕ}
    (hd : 0 < d) (hs : s ≠ 0)
    (hcat : D + TensorSemiring.matrixClass d * s ≤ D + (k : TensorSemiring.TensorClass) * s) :
    (d : ℝ) ^ exactRankExponent ≤ k := by
  have hs1 : 1 ≤ s := TensorSemiring.one_le_of_ne_zero hs
  have hcopies : ∀ (m : ℕ) (x : TensorSemiring.TensorClass),
      TensorSemiring.rank ((m : TensorSemiring.TensorClass) * x) ≤
        m * TensorSemiring.rank x := by
    intro m x
    simpa only [TensorSemiring.rank_natCast] using
      TensorSemiring.rank_mul_le (m : TensorSemiring.TensorClass) x
  have hbudget : ∀ n j g : ℕ, exactMatrixRank g ≤ n ^ j →
      TensorSemiring.matrixClass g ≤ (n : TensorSemiring.TensorClass) ^ j := by
    intro n j g hg
    have hleft : TensorSemiring.matrixClass g ≤
        (exactMatrixRank g : TensorSemiring.TensorClass) := by
      simpa only [TensorSemiring.rank_matrixClass] using
        TensorSemiring.le_rank (TensorSemiring.matrixClass g)
    obtain ⟨q, hq⟩ := Nat.exists_eq_add_of_le hg
    have hright : (exactMatrixRank g : TensorSemiring.TensorClass) ≤
        (n : TensorSemiring.TensorClass) ^ j := by
      rw [← Nat.cast_pow, hq, Nat.cast_add]
      simpa only [add_zero] using TensorSemiring.add_mono
        (le_refl (exactMatrixRank g : TensorSemiring.TensorClass))
        (TensorSemiring.zero_le (q : TensorSemiring.TensorClass))
    exact hleft.trans hright
  have hD : D ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) * s := by
    calc
      D ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) := TensorSemiring.le_rank D
      _ = (TensorSemiring.rank D : TensorSemiring.TensorClass) * 1 := (mul_one _).symm
      _ ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) * s :=
        TensorSemiring.mul_mono le_rfl hs1
  exact catalytic_semiring_obstruction
    TensorSemiring.add_mono TensorSemiring.mul_mono TensorSemiring.zero_le
    TensorSemiring.rank (fun _ _ h => TensorSemiring.rank_mono h) hcopies
    TensorSemiring.matrixClass TensorSemiring.matrixClass_mul TensorSemiring.matrixClass_pow
    TensorSemiring.rank_matrixClass hbudget D s d k (TensorSemiring.rank D) hd hs1 hcat hD

/-- The stronger comparison produced by a finite separation certificate
has the same consequence.  Its positive scalar summand is only needed
earlier to rule out `s = 0`; that nonzero fact is explicit here. -/
theorem tensor_catalytic_obstruction_of_scalar_gain
    {D s : TensorSemiring.TensorClass} {d k m : ℕ}
    (hd : 0 < d) (hs : s ≠ 0)
    (hcat : D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
      D + (k : TensorSemiring.TensorClass) * s) :
    (d : ℝ) ^ exactRankExponent ≤ k := by
  apply tensor_catalytic_obstruction hd hs
  refine le_trans ?_ hcat
  simpa only [add_zero] using TensorSemiring.add_mono
    (TensorSemiring.add_mono (le_refl D)
      (TensorSemiring.zero_le (m : TensorSemiring.TensorClass)))
    (le_refl (TensorSemiring.matrixClass d * s))

/-- A finite tensor cannot absorb a positive scalar direct summand.  Iterating
such an absorption would place arbitrarily large scalar tensors below one
fixed finite-rank tensor.  This uses rank monotonicity, not rank additivity. -/
theorem not_tensor_add_positive_nat_le_self (D : TensorSemiring.TensorClass)
    {m : ℕ} (hm : 0 < m) : ¬ D + (m : TensorSemiring.TensorClass) ≤ D := by
  intro h
  have hiter : ∀ n : ℕ, D + ((n * m : ℕ) : TensorSemiring.TensorClass) ≤ D := by
    intro n
    induction n with
    | zero => simp
    | succ n ih =>
      calc
        D + (((n + 1) * m : ℕ) : TensorSemiring.TensorClass) =
            (D + ((n * m : ℕ) : TensorSemiring.TensorClass)) + m := by push_cast; ring
        _ ≤ D + (m : TensorSemiring.TensorClass) := TensorSemiring.add_mono ih le_rfl
        _ ≤ D := h
  let n := TensorSemiring.rank D + 1
  have hscalar : ((n * m : ℕ) : TensorSemiring.TensorClass) ≤ D := by
    have hleft := TensorSemiring.add_mono (TensorSemiring.zero_le D)
      (le_refl ((n * m : ℕ) : TensorSemiring.TensorClass))
    have hsmall : ((n * m : ℕ) : TensorSemiring.TensorClass) ≤
        D + ((n * m : ℕ) : TensorSemiring.TensorClass) := by
      simpa only [zero_add] using hleft
    exact hsmall.trans (hiter n)
  have hrank : n * m ≤ TensorSemiring.rank D := by
    simpa only [TensorSemiring.rank_natCast] using TensorSemiring.rank_mono hscalar
  have hnm : n ≤ n * m := by
    simpa only [Nat.mul_one] using Nat.mul_le_mul_left n (Nat.succ_le_of_lt hm)
  have hlarge : TensorSemiring.rank D + 1 ≤ TensorSemiring.rank D := hnm.trans hrank
  omega

/-- The exact finite-obstruction comparison from Appendix A.1 forces
`k ≥ d^ν`.  Both tensors are fixed, `m` is a positive scalar gain, and the
ordinary tensor rank and restriction order are the actual ones. -/
theorem tensor_catalytic_obstruction_of_positive_scalar_gain
    {D s : TensorSemiring.TensorClass} {d k m : ℕ}
    (hd : 0 < d) (hm : 0 < m)
    (hcat : D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
      D + (k : TensorSemiring.TensorClass) * s) :
    (d : ℝ) ^ exactRankExponent ≤ k := by
  apply tensor_catalytic_obstruction_of_scalar_gain hd (m := m) ?_ hcat
  intro hs
  subst s
  have hbad : D + (m : TensorSemiring.TensorClass) ≤ D := by
    simpa only [mul_zero, add_zero] using hcat
  exact not_tensor_add_positive_nat_le_self D hm hbad

/-- Contradiction interface for the finite inconsistency certificate in
the construction of an additive monotone state. -/
theorem no_tensor_catalytic_gain {d k : ℕ} (hd : 0 < d)
    (hk : (k : ℝ) < (d : ℝ) ^ exactRankExponent) :
    ¬ ∃ (D s : TensorSemiring.TensorClass) (m : ℕ), 0 < m ∧
      D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
        D + (k : TensorSemiring.TensorClass) * s := by
  rintro ⟨D, s, m, hm, hcat⟩
  exact (not_lt_of_ge (tensor_catalytic_obstruction_of_positive_scalar_gain hd hm hcat)) hk

end MatrixMultiplication.AuxiliarySeparation

end

end OAI

	import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Arithmetic.RankExponent
	import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Growth.PolynomialOverhead
	import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Growth.SpectralLimit
	import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Tensor.Scalar

	namespace OAI

	/-!
	# The rank obstruction behind the preliminary spectral state

	The finite catalyst is kept fixed while first tensor powers, then exponent
	slack, then the number of copies are varied. The hypotheses below isolate the
	rank inequalities supplied by the catalytic comparison; they do not assert
	the existence of a tensor spectrum or the separation argument producing that
	comparison.
	-/

	noncomputable section

	open MatrixMultiplication.Foundation

	namespace MatrixMultiplication.AuxiliarySeparation

	/-- Tensor powers of a fixed exact matrix algorithm retain their exact rank
	bound after identifying the product coordinates with one matrix dimension. -/
	theorem exactMatrixRank_pow_le (u j : ℕ) :
	exactMatrixRank (u ^ j) ≤ exactMatrixRank u ^ j := by
	classical
	let e : Fin (u ^ j) ≃ (Fin j → Fin u) := Fintype.equivOfCardEq (by simp)
	let f : Fin (u ^ j) × Fin (u ^ j) → Fin j → Fin u × Fin u :=
	fun x i => (e x.1 i, e x.2 i)
	have h := ((exactMatrixRank_spec u).power j).pullback f f f
	have heq : Tensor.pullback f f f (Tensor.power (Tensor.matrixMultiplication u u u) j) =
	Tensor.matrixMultiplication (u ^ j) (u ^ j) (u ^ j) := by
	funext x y z
	simp only [Tensor.pullback, Tensor.power, Tensor.matrixMultiplication, f,
	Fintype.prod_boole, forall_and, ← funext_iff, e.injective.eq_iff]
	rw [heq] at h
	exact exactRank_le h

	/-- A floor approximation uses at most `n^j` copies of a fixed matrix
	algorithm and loses at most one factor of its fixed matrix dimension. -/
	theorem floor_rank_power_bounds {u n R : ℕ} (hu : 2 ≤ u) (hn : 1 ≤ n)
	{τ : ℝ} (hτ : 0 < τ) (hR : (R : ℝ) ≤ (u : ℝ) ^ τ) (j : ℕ) :
	let l := ⌊(j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ⌋₊
	(R : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
	(n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l := by
	have hu1 : (1 : ℝ) < u := by exact_mod_cast (show 1 < u by omega)
	have hu0 : (0 : ℝ) < u := zero_lt_one.trans hu1
	have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
	have hn0 : (0 : ℝ) < n := zero_lt_one.trans_le hn1
	let x := (j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ
	let l := ⌊x⌋₊
	have hx : 0 ≤ x := div_nonneg
	(mul_nonneg (Nat.cast_nonneg j) (Real.logb_nonneg hu1 hn1)) hτ.le
	have hl : (l : ℝ) ≤ x := Nat.floor_le hx
	have hxl : x ≤ (l : ℝ) + 1 := (Nat.lt_floor_add_one x).le
	have hlog : (u : ℝ) ^ Real.logb (u : ℝ) (n : ℝ) = n :=
	Real.rpow_logb hu0 (ne_of_gt hu1) hn0
	change (R : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
	(n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l
	constructor
	· calc
	(R : ℝ) ^ l ≤ ((u : ℝ) ^ τ) ^ l :=
	pow_le_pow_left₀ (Nat.cast_nonneg R) hR l
	_ = (u : ℝ) ^ (τ * (l : ℝ)) := by
	rw [← Real.rpow_natCast, ← Real.rpow_mul hu0.le]
	_ ≤ (u : ℝ) ^ (τ * x) :=
	Real.rpow_le_rpow_of_exponent_le hu1.le (mul_le_mul_of_nonneg_left hl hτ.le)
	_ = (n : ℝ) ^ j := by
	rw [show τ * x = Real.logb (u : ℝ) (n : ℝ) * (j : ℝ) by
	dsimp [x]; field_simp]
	rw [Real.rpow_mul hu0.le, hlog, Real.rpow_natCast]
	· calc
	(n : ℝ) ^ ((j : ℝ) / τ) = (u : ℝ) ^ x := by
	rw [← hlog, ← Real.rpow_mul hu0.le]
	congr 1
	dsimp [x]
	ring
	_ ≤ (u : ℝ) ^ ((l : ℝ) + 1) :=
	Real.rpow_le_rpow_of_exponent_le hu1.le hxl
	_ = (u : ℝ) * (u : ℝ) ^ l := by
	rw [Real.rpow_add hu0, Real.rpow_natCast, Real.rpow_one, mul_comm]

	/-- At fixed `n` and exponent slack, every admissible matrix rank budget
	forces the exponential growth rate of the catalytic comparison. The constant
	`R` is fixed before the tensor-power parameter varies. -/
	theorem catalytic_rank_bound_at_slack {d n K R : ℕ}
	(hd : 0 < d) (hn : 1 ≤ n)
	(hbound : ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ, exactMatrixRank g ≤ n ^ j →
	exactMatrixRank (d ^ j * g) ≤ R * K ^ j)
	{δ : ℝ} (hδ : 0 < δ) :
	(d : ℝ) ^ exactRankExponent *
	(n : ℝ) ^ (exactRankExponent / (exactRankExponent + δ)) ≤ K := by
	let ν := exactRankExponent
	let τ := ν + δ
	have hν : 0 ≤ ν := (by norm_num : (0 : ℝ) ≤ 2).trans exactRankExponent_lower
	have hτ : 0 < τ := add_pos_of_nonneg_of_pos hν hδ
	obtain ⟨u, hu, huR⟩ := exists_exactMatrixRank_lt_rpow
	(show exactRankExponent < τ from lt_add_of_pos_right _ hδ)
	apply le_of_eventually_pow_le_const_mul_pow (C := (u : ℝ) ^ ν * R)
	(Nat.cast_nonneg K)
	filter_upwards [Filter.eventually_ge_atTop (1 : ℕ)] with j hj
	let l := ⌊(j : ℝ) * Real.logb (u : ℝ) (n : ℝ) / τ⌋₊
	let g := u ^ l
	have hg : 0 < g := pow_pos (by omega) l
	have hf := floor_rank_power_bounds hu hn hτ huR.le j
	change (exactMatrixRank u : ℝ) ^ l ≤ (n : ℝ) ^ j ∧
	(n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * (u : ℝ) ^ l at hf
	have hbudget : exactMatrixRank g ≤ n ^ j := by
	have hpow : (exactMatrixRank g : ℝ) ≤ (exactMatrixRank u : ℝ) ^ l := by
	exact_mod_cast exactMatrixRank_pow_le u l
	have hb := hpow.trans hf.1
	exact_mod_cast hb
	have hrank := hbound j hj g hbudget
	have hsize : (n : ℝ) ^ ((j : ℝ) / τ) ≤ (u : ℝ) * g := by
	simpa only [g, Nat.cast_pow] using hf.2
	have hlow := exactMatrixRank_rpow_lower_of_pos (mul_pos (pow_pos hd j) hg)
	have hpow_n : ((n : ℝ) ^ (ν / τ)) ^ j =
	((n : ℝ) ^ ((j : ℝ) / τ)) ^ ν := by
	rw [← Real.rpow_natCast, ← Real.rpow_mul (Nat.cast_nonneg n),
	← Real.rpow_mul (Nat.cast_nonneg n)]
	congr 1
	ring
	calc
	((d : ℝ) ^ ν * (n : ℝ) ^ (ν / τ)) ^ j =
	(((d ^ j : ℕ) : ℝ) ^ ν) * ((n : ℝ) ^ ((j : ℝ) / τ)) ^ ν := by
	rw [mul_pow, Real.rpow_pow_comm (Nat.cast_nonneg d), hpow_n, Nat.cast_pow]
	_ ≤ (((d ^ j : ℕ) : ℝ) ^ ν) * ((u : ℝ) * g) ^ ν := by
	exact mul_le_mul_of_nonneg_left
	(Real.rpow_le_rpow (Real.rpow_nonneg (Nat.cast_nonneg n) _) hsize hν)
	(Real.rpow_nonneg (Nat.cast_nonneg _) _)
	_ = (u : ℝ) ^ ν * (((d ^ j * g : ℕ) : ℝ) ^ ν) := by
	rw [Nat.cast_mul, Real.mul_rpow (Nat.cast_nonneg u) (Nat.cast_nonneg g),
	Real.mul_rpow (Nat.cast_nonneg (d ^ j)) (Nat.cast_nonneg g)]
	ring
	_ ≤ (u : ℝ) ^ ν * (exactMatrixRank (d ^ j * g) : ℝ) :=
	mul_le_mul_of_nonneg_left hlow (Real.rpow_nonneg (Nat.cast_nonneg u) _)
	_ ≤ (u : ℝ) ^ ν * ((R : ℝ) * (K : ℝ) ^ j) := by
	apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg (Nat.cast_nonneg u) _)
	exact_mod_cast hrank
	_ = ((u : ℝ) ^ ν * R) * (K : ℝ) ^ j := by ring

	/-- The numerical rank consequence of a single fixed finite catalyst is
	incompatible with `k < d^ν`. The same `D` and `R` occur for every `n` and
	every tensor power. No uniform bound on the approximation block selected
	after an exponent slack is assumed. -/
	theorem catalytic_rank_obstruction {d k D R : ℕ} (hd : 0 < d)
	(hbound : ∀ n : ℕ, 1 ≤ n → ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ,
	exactMatrixRank g ≤ n ^ j →
	exactMatrixRank (d ^ j * g) ≤ R * (n * k + D) ^ j) :
	(d : ℝ) ^ exactRankExponent ≤ k := by
	apply spectral_coefficient_le_of_all_nat
	(hν := lt_of_lt_of_le (by norm_num : (0 : ℝ) < 2) exactRankExponent_lower)
	(D := (D : ℝ))
	intro n hn δ hδ
	have h := catalytic_rank_bound_at_slack hd hn (hbound n hn) hδ
	simpa only [Nat.cast_add, Nat.cast_mul] using h

	/-- Contradiction form for the finite-obstruction argument. -/
	theorem not_catalytic_rank_bounds_of_lt {d k D R : ℕ} (hd : 0 < d)
	(hk : (k : ℝ) < (d : ℝ) ^ exactRankExponent) :
	¬ (∀ n : ℕ, 1 ≤ n → ∀ j : ℕ, 1 ≤ j → ∀ g : ℕ,
	exactMatrixRank g ≤ n ^ j →
	exactMatrixRank (d ^ j * g) ≤ R * (n * k + D) ^ j) := by
	intro hbound
	exact (not_lt_of_ge (catalytic_rank_obstruction hd hbound)) hk

	/-- Iteration and absorption of a fixed catalyst require no cancellation of
	the tensor factor `s`. Monotonicity is explicit so the lemma applies to the
	restriction order on a tensor semiring, where additive cancellation fails. -/
	theorem catalytic_power_comparison {S : Type*} [CommSemiring S] [Preorder S]
	(hadd : ∀ {a b c e : S}, a ≤ b → c ≤ e → a + c ≤ b + e)
	(hmul : ∀ {a b c e : S}, a ≤ b → c ≤ e → a * c ≤ b * e)
	(hzero : ∀ a : S, 0 ≤ a)
	(D t s : S) (k C : ℕ)
	(hcat : D + t * s ≤ D + (k : S) * s)
	(hD : D ≤ (C : S) * s) (n j : ℕ) :
	(n : S) ^ j * t ^ j * s ≤ ((n * k + C : ℕ) : S) ^ j * s := by
	have hiter : ∀ m : ℕ,
	D + (m : S) * (t * s) ≤ D + (m : S) * ((k : S) * s) := by
	intro m
	induction m with
	\| zero => simp
	\| succ m ih =>
	calc
	D + ((m + 1 : ℕ) : S) * (t * s) =
	(D + t * s) + (m : S) * (t * s) := by push_cast; ring
	_ ≤ (D + (k : S) * s) + (m : S) * (t * s) := hadd hcat le_rfl
	_ = (D + (m : S) * (t * s)) + (k : S) * s := by ring
	_ ≤ (D + (m : S) * ((k : S) * s)) + (k : S) * s := hadd ih le_rfl
	_ = D + ((m + 1 : ℕ) : S) * ((k : S) * s) := by push_cast; ring
	have habsorb : (n : S) * t * s ≤ ((n * k + C : ℕ) : S) * s := by
	calc
	(n : S) * t * s = 0 + (n : S) * (t * s) := by ring
	_ ≤ D + (n : S) * (t * s) := hadd (hzero D) le_rfl
	_ ≤ D + (n : S) * ((k : S) * s) := hiter n
	_ ≤ (C : S) * s + (n : S) * ((k : S) * s) := hadd hD le_rfl
	_ = ((n * k + C : ℕ) : S) * s := by push_cast; ring
	induction j with
	\| zero => simp
	\| succ j ih =>
	calc
	(n : S) ^ (j + 1) * t ^ (j + 1) * s =
	((n : S) ^ j * t ^ j) * ((n : S) * t * s) := by ring
	_ ≤ ((n : S) ^ j * t ^ j) * (((n * k + C : ℕ) : S) * s) :=
	hmul le_rfl habsorb
	_ = ((n * k + C : ℕ) : S) * ((n : S) ^ j * t ^ j * s) := by ring
	_ ≤ ((n * k + C : ℕ) : S) * (((n * k + C : ℕ) : S) ^ j * s) :=
	hmul le_rfl ih
	_ = ((n * k + C : ℕ) : S) ^ (j + 1) * s := by ring

	/-- A rank-compatible ordered tensor semiring converts a single finite
	catalytic inequality into the actual exact-rank obstruction. The hypotheses
	name the required tensor interpretation and scalar rank domination explicitly;
	no additive rank formula or cancellation property is assumed. -/
	theorem catalytic_semiring_obstruction {S : Type*} [CommSemiring S] [Preorder S]
	(hadd : ∀ {a b c e : S}, a ≤ b → c ≤ e → a + c ≤ b + e)
	(hmul : ∀ {a b c e : S}, a ≤ b → c ≤ e → a * c ≤ b * e)
	(hzero : ∀ a : S, 0 ≤ a)
	(ρ : S → ℕ) (hρmono : Monotone ρ)
	(hρcopies : ∀ (m : ℕ) (s : S), ρ ((m : S) * s) ≤ m * ρ s)
	(M : ℕ → S)
	(hMmul : ∀ a b : ℕ, M (a * b) = M a * M b)
	(hMpow : ∀ a j : ℕ, M (a ^ j) = M a ^ j)
	(hρM : ∀ a : ℕ, ρ (M a) = exactMatrixRank a)
	(hbudget : ∀ n j g : ℕ, exactMatrixRank g ≤ n ^ j → M g ≤ (n : S) ^ j)
	(D s : S) (d k C : ℕ) (hd : 0 < d) (hs : 1 ≤ s)
	(hcat : D + M d * s ≤ D + (k : S) * s)
	(hD : D ≤ (C : S) * s) :
	(d : ℝ) ^ exactRankExponent ≤ k := by
	apply catalytic_rank_obstruction (D := C) (R := ρ s) hd
	intro n _hn j _hj g hg
	have hcompare : M (d ^ j * g) ≤ ((n * k + C : ℕ) : S) ^ j * s := by
	calc
	M (d ^ j * g) = M d ^ j * M g := by rw [hMmul, hMpow]
	_ ≤ M d ^ j * (n : S) ^ j := hmul le_rfl (hbudget n j g hg)
	_ = ((n : S) ^ j * M d ^ j) * 1 := by ring
	_ ≤ ((n : S) ^ j * M d ^ j) * s := hmul le_rfl hs
	_ ≤ ((n * k + C : ℕ) : S) ^ j * s :=
	catalytic_power_comparison hadd hmul hzero D (M d) s k C hcat hD n j
	calc
	exactMatrixRank (d ^ j * g) = ρ (M (d ^ j * g)) := (hρM _).symm
	_ ≤ ρ (((n * k + C : ℕ) : S) ^ j * s) := hρmono hcompare
	_ = ρ ((((n * k + C) ^ j : ℕ) : S) * s) := by rw [Nat.cast_pow]
	_ ≤ (n * k + C) ^ j * ρ s := hρcopies _ s
	_ = ρ s * (n * k + C) ^ j := Nat.mul_comm _ _

	/-- In the semiring of actual finite complex tensors modulo mutual
	restriction, a fixed catalyst cannot make `k` copies dominate multiplication
	by `T_d` unless `k ≥ d^ν`. The nonzero hypothesis is exactly what supplies
	the scalar restriction `s ≥ 1`; the catalyst remains fixed throughout. -/
	theorem tensor_catalytic_obstruction
	{D s : TensorSemiring.TensorClass} {d k : ℕ}
	(hd : 0 < d) (hs : s ≠ 0)
	(hcat : D + TensorSemiring.matrixClass d * s ≤ D + (k : TensorSemiring.TensorClass) * s) :
	(d : ℝ) ^ exactRankExponent ≤ k := by
	have hs1 : 1 ≤ s := TensorSemiring.one_le_of_ne_zero hs
	have hcopies : ∀ (m : ℕ) (x : TensorSemiring.TensorClass),
	TensorSemiring.rank ((m : TensorSemiring.TensorClass) * x) ≤
	m * TensorSemiring.rank x := by
	intro m x
	simpa only [TensorSemiring.rank_natCast] using
	TensorSemiring.rank_mul_le (m : TensorSemiring.TensorClass) x
	have hbudget : ∀ n j g : ℕ, exactMatrixRank g ≤ n ^ j →
	TensorSemiring.matrixClass g ≤ (n : TensorSemiring.TensorClass) ^ j := by
	intro n j g hg
	have hleft : TensorSemiring.matrixClass g ≤
	(exactMatrixRank g : TensorSemiring.TensorClass) := by
	simpa only [TensorSemiring.rank_matrixClass] using
	TensorSemiring.le_rank (TensorSemiring.matrixClass g)
	obtain ⟨q, hq⟩ := Nat.exists_eq_add_of_le hg
	have hright : (exactMatrixRank g : TensorSemiring.TensorClass) ≤
	(n : TensorSemiring.TensorClass) ^ j := by
	rw [← Nat.cast_pow, hq, Nat.cast_add]
	simpa only [add_zero] using TensorSemiring.add_mono
	(le_refl (exactMatrixRank g : TensorSemiring.TensorClass))
	(TensorSemiring.zero_le (q : TensorSemiring.TensorClass))
	exact hleft.trans hright
	have hD : D ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) * s := by
	calc
	D ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) := TensorSemiring.le_rank D
	_ = (TensorSemiring.rank D : TensorSemiring.TensorClass) * 1 := (mul_one _).symm
	_ ≤ (TensorSemiring.rank D : TensorSemiring.TensorClass) * s :=
	TensorSemiring.mul_mono le_rfl hs1
	exact catalytic_semiring_obstruction
	TensorSemiring.add_mono TensorSemiring.mul_mono TensorSemiring.zero_le
	TensorSemiring.rank (fun _ _ h => TensorSemiring.rank_mono h) hcopies
	TensorSemiring.matrixClass TensorSemiring.matrixClass_mul TensorSemiring.matrixClass_pow
	TensorSemiring.rank_matrixClass hbudget D s d k (TensorSemiring.rank D) hd hs1 hcat hD

	/-- The stronger comparison produced by a finite separation certificate
	has the same consequence. Its positive scalar summand is only needed
	earlier to rule out `s = 0`; that nonzero fact is explicit here. -/
	theorem tensor_catalytic_obstruction_of_scalar_gain
	{D s : TensorSemiring.TensorClass} {d k m : ℕ}
	(hd : 0 < d) (hs : s ≠ 0)
	(hcat : D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
	D + (k : TensorSemiring.TensorClass) * s) :
	(d : ℝ) ^ exactRankExponent ≤ k := by
	apply tensor_catalytic_obstruction hd hs
	refine le_trans ?_ hcat
	simpa only [add_zero] using TensorSemiring.add_mono
	(TensorSemiring.add_mono (le_refl D)
	(TensorSemiring.zero_le (m : TensorSemiring.TensorClass)))
	(le_refl (TensorSemiring.matrixClass d * s))

	/-- A finite tensor cannot absorb a positive scalar direct summand. Iterating
	such an absorption would place arbitrarily large scalar tensors below one
	fixed finite-rank tensor. This uses rank monotonicity, not rank additivity. -/
	theorem not_tensor_add_positive_nat_le_self (D : TensorSemiring.TensorClass)
	{m : ℕ} (hm : 0 < m) : ¬ D + (m : TensorSemiring.TensorClass) ≤ D := by
	intro h
	have hiter : ∀ n : ℕ, D + ((n * m : ℕ) : TensorSemiring.TensorClass) ≤ D := by
	intro n
	induction n with
	\| zero => simp
	\| succ n ih =>
	calc
	D + (((n + 1) * m : ℕ) : TensorSemiring.TensorClass) =
	(D + ((n * m : ℕ) : TensorSemiring.TensorClass)) + m := by push_cast; ring
	_ ≤ D + (m : TensorSemiring.TensorClass) := TensorSemiring.add_mono ih le_rfl
	_ ≤ D := h
	let n := TensorSemiring.rank D + 1
	have hscalar : ((n * m : ℕ) : TensorSemiring.TensorClass) ≤ D := by
	have hleft := TensorSemiring.add_mono (TensorSemiring.zero_le D)
	(le_refl ((n * m : ℕ) : TensorSemiring.TensorClass))
	have hsmall : ((n * m : ℕ) : TensorSemiring.TensorClass) ≤
	D + ((n * m : ℕ) : TensorSemiring.TensorClass) := by
	simpa only [zero_add] using hleft
	exact hsmall.trans (hiter n)
	have hrank : n * m ≤ TensorSemiring.rank D := by
	simpa only [TensorSemiring.rank_natCast] using TensorSemiring.rank_mono hscalar
	have hnm : n ≤ n * m := by
	simpa only [Nat.mul_one] using Nat.mul_le_mul_left n (Nat.succ_le_of_lt hm)
	have hlarge : TensorSemiring.rank D + 1 ≤ TensorSemiring.rank D := hnm.trans hrank
	omega

	/-- The exact finite-obstruction comparison from Appendix A.1 forces
	`k ≥ d^ν`. Both tensors are fixed, `m` is a positive scalar gain, and the
	ordinary tensor rank and restriction order are the actual ones. -/
	theorem tensor_catalytic_obstruction_of_positive_scalar_gain
	{D s : TensorSemiring.TensorClass} {d k m : ℕ}
	(hd : 0 < d) (hm : 0 < m)
	(hcat : D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
	D + (k : TensorSemiring.TensorClass) * s) :
	(d : ℝ) ^ exactRankExponent ≤ k := by
	apply tensor_catalytic_obstruction_of_scalar_gain hd (m := m) ?_ hcat
	intro hs
	subst s
	have hbad : D + (m : TensorSemiring.TensorClass) ≤ D := by
	simpa only [mul_zero, add_zero] using hcat
	exact not_tensor_add_positive_nat_le_self D hm hbad

	/-- Contradiction interface for the finite inconsistency certificate in
	the construction of an additive monotone state. -/
	theorem no_tensor_catalytic_gain {d k : ℕ} (hd : 0 < d)
	(hk : (k : ℝ) < (d : ℝ) ^ exactRankExponent) :
	¬ ∃ (D s : TensorSemiring.TensorClass) (m : ℕ), 0 < m ∧
	D + (m : TensorSemiring.TensorClass) + TensorSemiring.matrixClass d * s ≤
	D + (k : TensorSemiring.TensorClass) * s := by
	rintro ⟨D, s, m, hm, hcat⟩
	exact (not_lt_of_ge (tensor_catalytic_obstruction_of_positive_scalar_gain hd hm hcat)) hk

	end MatrixMultiplication.AuxiliarySeparation

	end

	end OAI