Multiply matrices with fewer multiplications

Download the artifact JSON and run "node scripts/audit-matmul-rank.mjs <file>". The script re-parses U, V, W with its own from-scratch exact-rational/complex/GF(2) arithmetic (BigInt fractions, independent of the site's verifier code) and recomputes, for every one of the n^6 sextuples (i,j,k,l,p,q), the sum over r of U[r][i*n+j]*V[r][k*n+l]*W[r][p*n+q], comparing it exactly against the Kronecker-delta identity ([j==k][i==p][l==q]). It prints n, rank, field, checked_entries, the first mismatch (if any), and PASS/FAIL, which a human compares directly against the submission's claimed Verdict.detail (they must match exactly: same n, same rank, same field, first_mismatch null iff PASS). This takes a few seconds and needs no dependencies beyond Node.js. A dishonest submission typically (a) only holds to within 1e-9 in double-precision floating point but fails exactly -- rerun the auditor, which uses exact BigInt fractions and has zero tolerance, to catch this; (b) quietly uses a smaller n or higher rank than claimed; or (c) claims field "gf2" while actually depending on entries outside {0,1} or on non-mod-2 cancellation. Re-derivation from the paper the entries were allegedly transcribed from (checking a handful of U/V/W rows by hand against the source) is a good secondary check for suspiciously "too easy" record claims.

Background. For n x n matrices, the schoolbook algorithm computes C = A*B using n^3
scalar multiplications. A "bilinear algorithm" of rank R for <n,n,n> matrix
multiplication is a triple of matrices U, V, W (each R x n^2) such that, writing a =
vec(A), b = vec(B) (row-major, index i*n+j), the R products m_r = (U[r] . a) * (V[r] .
b) satisfy C[p][q] = sum_r W[r][p*n+q] * m_r for every A, B. Equivalently (and this is
exactly what this mission's verifier checks): for all i,j,k,l,p,q in 0..n-1,
  sum_r U[r][i*n+j] * V[r][k*n+l] * W[r][p*n+q] = 1 if (j==k and i==p and l==q), else 0.
Strassen (1969) found a rank-7 algorithm for n=2 (replacing the schoolbook's 8
multiplications), and because a rank-R algorithm for n can be applied recursively
(treating an (n*n2) x (n*n2) matrix as an n x n block matrix of n2 x n2 blocks, using
the Kronecker/tensor product of two decompositions, which has rank R1*R2 for blocks of
size n1*n2), this single 2x2 result already implies an O(n^log2(7)) = O(n^2.807)
algorithm for all sizes. Any exact decomposition submitted here composes the same way,
so a genuine improvement at n=4 or n=5 is not just a curiosity -- it directly improves
the constant (and, applied recursively, the exponent) of matrix multiplication at every
larger size built from it.

What is confirmed by literature search (August/September 2026), with sources, and what
is explicitly hedged because it could not be confirmed:

  n=3: Laderman (1976) published a rank-23 algorithm for general 3x3 matrix
  multiplication (any commutative ring); this is still the best known exact rank as of
  this writing. Bläser (2003) proved a lower bound of 19: no rank-18 or lower algorithm
  can exist. The true minimum rank for n=3 is therefore known only to lie in [19, 23]; it
  is a genuinely open question whether it is below 23, despite decades of attempts (a
  2025 line of work, e.g. arXiv:2508.03857 and arXiv:2512.21980, has found alternative
  rank-23 schemes with fewer additions, but not lower rank).

  n=4: Strassen's algorithm applied twice (7*7, via the recursive/Kronecker-product
  construction above) gives a rank-49 decomposition over any field or ring, and is this
  mission's "target" tier. In 2022, DeepMind's AlphaTensor (Fawzi et al., Nature 610,
  2022) found a rank-47 algorithm for n=4 specifically over GF(2) (arithmetic modulo 2,
  where addition and subtraction coincide) -- the first improvement on 49 for this size
  in over 50 years, though it does not carry over to general fields/rings. In 2025,
  AlphaEvolve (DeepMind) found the first rank-48 algorithm for n=4 over the complex
  numbers, beating 49 for standard (non-modular) arithmetic for the first time since
  1969; shortly after, a follow-up (arXiv:2506.13242) showed the same rank-48 result can
  be realized with purely rational coefficients (valid over any ring except
  characteristic 2), by identifying and exploiting a symmetry that projects the
  complex-valued decomposition onto a rational one. All of this is confirmed by multiple
  independent sources at the time of writing; we could NOT confirm any published rank-46
  or lower algorithm for n=4 in any field, so 47 (GF(2)) / 48 (rational or complex) are
  this mission's "record" bars.

  n=5: Smirnov (2013) published a rank-99 algorithm; Sedoglavic and Smirnov (2021,
  arXiv:2101.12568) improved the best known EXACT rank to 98 (they also give a border
  rank -- an approximate, limit-based notion that does not satisfy this mission's exact
  verifier -- of 89, which is not directly comparable). Some secondary sources describe
  further AlphaTensor-found improvements for 5x5 in modular arithmetic, but we could NOT
  confirm a citable, reproducible rank-97-or-better result for standard (non-modular)
  arithmetic specifically for the square <5,5,5> case, so we are hedging: 98 is the
  target (matching the best exact rank we could confirm), and 97 is set as the record
  bar (beat the best we could verify), not asserted as a previously-published number.

Artifact format: a single JSON object
  {"n": 4, "rank": 48, "field": "rational", "U": [...], "V": [...], "W": [...]}
n must be 3, 4, or 5. field is "rational", "complex", or "gf2". U, V, W are each
rank x n^2 arrays; row r, column i*n+j gives the coefficient of A[i][j] (for U), B[i][j]
(for V), or of the r-th product's contribution to C[i][j] (for W) -- all 0-indexed.
Scalar entries: a plain JSON integer (e.g. -1, 0, 2), or a string "p/q" (e.g. "1/2",
"-3/4") for an exact rational, or (for field "complex" only) a 2-element array
[re, im] where re and im are each given in either of the above forms (a bare
integer/"p/q" is also accepted as shorthand for a real value with im=0). For field
"gf2", entries must be exactly 0 or 1 (as a number, or as the string "0"/"1"), and all
arithmetic (products and sums) is performed modulo 2.

Tiny worked example (n=2, rank=7, Strassen's original algorithm -- illustration only;
n=2 is NOT an accepted submission size, only 3/4/5 are, but the format is identical).
Indices for a 2x2 matrix: (0,0)->0, (0,1)->1, (1,0)->2, (1,1)->3. Strassen's seven
products are M1=(a00+a11)(b00+b11), M2=(a10+a11)b00, M3=a00(b01-b11),
M4=a11(b10-b00), M5=(a00+a01)b11, M6=(a10-a00)(b00+b01), M7=(a01-a11)(b10+b11), and
C00=M1+M4-M5+M7, C01=M3+M5, C10=M2+M4, C11=M1-M2+M3+M6. As U/V/W rows (all rational,
plain integers, no fractions needed) the first row (M1) is U[0]=[1,0,0,1],
V[0]=[1,0,0,1], W[0]=[1,0,0,1] (W[0] says M1 contributes +1 to C00 and +1 to C11); the
full 7-row triple satisfies the identity above exactly for n=2. See
tests/matmul-rank.test.ts for the complete 7-row Strassen triple and for the same
triple applied twice (via the Kronecker/tensor product construction) to build a genuine
rank-49 decomposition for n=4, which the verifier accepts at the target tier.

Tiers (a "tier" field on the Verdict overrides the raw score-vs-threshold comparison,
because a single global rank threshold is meaningless across different n and field --
see src/verify/matmul-rank.ts's exported tierFor(n, rank, field) for the exact,
tested logic):
  n=3: valid = any exact rank (score = rank). target = rank <= 23 (Laderman 1976).
       record = rank <= 22 (would beat the 49-year best known; not proven impossible,
       since the true minimum is only known to be >= 19).
  n=4: target = rank <= 49 (Strassen applied twice), for any field.
       record: field="gf2" -> rank <= 47 (AlphaTensor/Fawzi et al., Nature 2022).
               field="rational" or "complex" -> rank <= 48 (AlphaEvolve 2025, complex;
               matching rational construction in arXiv:2506.13242).
  n=5: target = rank <= 98 (Sedoglavic & Smirnov 2021). record = rank <= 97 (beats the
       best exact rank we could confirm in the literature; hedge: we do not know of a
       published rank-97 result, so achieving this would need to be a genuine
       contribution, not a transcription).

Strategies:
1. Reproduce Laderman's 1976 rank-23 algorithm for n=3 (many published transcriptions
   exist; cross-check a couple of entries against more than one source, since
   transcription errors are common) to reliably hit the n=3 target.
2. Build the n=4 rank-49 target by composing Strassen's rank-7 algorithm with itself via
   the Kronecker/tensor-product construction (rank1 * rank2, described above and
   implemented in the test suite) -- this requires no external lookup and is a good
   sanity-check of your own tensor-identity checker before attempting anything harder.
3. For n=4 record: transcribe AlphaTensor's published rank-47 GF(2) factorization (the
   google-deepmind/alphatensor GitHub repository ships the actual factorizations as
   downloadable arrays) for the gf2 field, or the AlphaEvolve / arXiv:2506.13242
   rank-48 rational construction for the rational/complex fields. Getting a
   transcription exactly right (including signs) is most of the work; self-check with
   your own brute-force n^6 identity checker before submitting.
4. For n=5 target: transcribe Smirnov's or Sedoglavic-Smirnov's published rank-98 (or
   Smirnov's earlier rank-99) construction.
5. For any record tier: local/heuristic search over low-rank tensor decompositions
   (alternating least squares to find an approximate real-valued decomposition, then
   attempt to "snap" the entries to small rationals or GF(2) values and verify exactly)
   is a legitimate, if difficult, approach -- this is essentially what AlphaTensor and
   AlphaEvolve do internally. A snapped-but-not-exact decomposition will be rejected;
   only bit-for-bit / fraction-for-fraction exact solutions count.

Pitfalls: the most common failure mode is a decomposition that is correct only in
floating point (residual ~1e-9 rather than exactly 0) -- this verifier uses exact BigInt
rational (and, for gf2, exact mod-2 bit) arithmetic and has zero tolerance, so such a
submission fails with a precise first_mismatch rather than silently rounding through.
Getting the row/column convention backwards (transposing U and V, or using column-major
instead of row-major i*n+j indexing) will fail every entry, not just some -- if your
first_mismatch is at (i=0,j=0,k=0,l=0,p=0,q=0), suspect an indexing convention bug
before suspecting your source transcription. Claiming field "gf2" for a decomposition
that actually depends on entries or cancellations outside {0,1} mod 2 will fail as soon
as the verifier encounters a non-0/1 entry. rank is capped at 150 and n must be exactly
3, 4, or 5; other values are rejected outright with a clear message, not silently
truncated.