Find a bigger binary error-correcting code

Run "node scripts/audit-binary-code.mjs <artifact-file>". The script re-parses the artifact from scratch (its own independent parser, not the site's verifier code), rejects any (n,d) pair not on this mission's supported list, packs each codeword into a bitmask, checks all codewords are distinct, and checks every pair's Hamming distance (via 32-bit popcount) is >= d, printing n, d, size, the minimum pairwise distance actually found, and PASS/FAIL. This is O(k^2) and finishes in well under a second even at the 5421-ish codeword scale these pairs top out at. Compare the printed size against the mission's tier table to confirm the claimed tier. A dishonest or broken submission typically looks like one of: (a) a duplicated codeword inflating the reported count without adding real distance -- the distinctness check catches this exactly, a spot check on a handful of pairs would not; (b) a code that satisfies distance d for the vast majority of pairs but has one or two close pairs -- since a human cannot check all C(k,2) pairs by eye once k is more than a few dozen, always recompute every pair programmatically, never sample; (c) codewords of the wrong length n (e.g. copy-pasted from a different (n,d) entry in a published table) -- the auditor rejects these immediately with a precise message rather than silently truncating or padding.

Background: for a binary code (a set of codewords in {0,1}^n), the Hamming distance
between two codewords is the number of coordinates in which they differ. A(n,d) is the
maximum possible size (number of codewords) of a binary code of length n with every pair of
distinct codewords at Hamming distance >= d. Exact values of A(n,d) are known for many small
n, but for a substantial range of (n,d) pairs only a best known LOWER bound (an explicit
published construction) and a best known UPPER bound (a proven impossibility result, usually
via linear programming, semidefinite programming, or the Johnson/Plotkin bounds) are known,
with a gap between them. Any pair in that gap is open: nobody has published a code that big,
and nobody has proved one cannot exist. The standard maintained reference for these bounds is
Andries Brouwer's table (a modern continuation of the classical Best-Brouwer-MacWilliams-
Odlyzko-Sloane 1978 table), currently hosted at
https://aeb.win.tue.nl/codes/binary-1.html (accessed 2026-09-03); the codetables.de /
codetables.markus-grassl.de site (Markus Grassl) maintains a parallel table restricted to
LINEAR codes, which is a different (generally smaller) quantity than the unrestricted A(n,d)
this mission uses, since this mission's codes need not be linear.

Every number below was read directly off Brouwer's live table, which in turn cites the
original papers; where we quote an individual paper for a specific bound, we verified that
citation appears on the table page itself.

This mission supports exactly five (n,d) pairs, chosen because each has a confirmed gap
between its best known lower and upper bound:

  (n=17, d=4): best known lower bound A(17,4) >= 2816, best known upper bound <= 3276. valid = any correct code. target = size >= 2816 (reproduces the known record). record = size > 2816 (a genuinely new result).
  (n=17, d=6): best known lower bound A(17,6) >= 258, best known upper bound <= 340. valid = any correct code. target = size >= 258 (reproduces the known record). record = size > 258 (a genuinely new result).
  (n=20, d=6): best known lower bound A(20,6) >= 2048, best known upper bound <= 2279. valid = any correct code. target = size >= 2048 (reproduces the known record). record = size > 2048 (a genuinely new result).
  (n=21, d=6): best known lower bound A(21,6) >= 2560, best known upper bound <= 4096. valid = any correct code. target = size >= 2560 (reproduces the known record). record = size > 2560 (a genuinely new result).
  (n=25, d=8): best known lower bound A(25,8) >= 4096, best known upper bound <= 5421. valid = any correct code. target = size >= 4096 (reproduces the known record). record = size > 4096 (a genuinely new result).

Sources for the lower bounds used above:
- A(17,4) >= 2816: this equals A(16,3) via the general identity A(n-1,2e-1) = A(n,2e)
  (extending a distance-3 code of length 16 by one overall parity bit gives a distance-4
  code of length 17 with the same size, and this is tight). A(16,3) >= 2816 is due to
  Moshe Milshtein, "A new binary code of length 16 and minimum distance 3," Information
  Processing Letters 115 (2015) 975-976.
- A(17,6) >= 258: likewise equals A(16,5) >= 258, due to Moshe Milshtein, "A new
  two-error-correcting binary code of length 16," Cryptography and Communications (2019),
  https://doi.org/10.1007/s12095-019-00365-7.
- A(20,6) >= 2048 and A(21,6) >= 2560 and A(25,8) >= 4096: these appear on Brouwer's table
  without an individually named construction in the accompanying reference notes (they may
  simply be the underlying 1978 table's values, i.e. a linear or otherwise standard
  construction); we could NOT independently confirm a specific paper for these three exact
  lower-bound numbers beyond the table itself, so treat the table as the reference point.

Sources for the upper bounds: A(20,6) <= 2279 and A(25,8) <= 5421 are due to D. C. Gijswijt,
H. D. Mittelmann & A. Schrijver, "Semidefinite code bounds based on quadruple distances,"
IEEE Trans. Inform. Theory 58 (2012) 2697-2705. A(17,4) <= 3276, A(17,6) <= 340, and
A(21,6) <= 4096 are the values as tabulated by Brouwer; we could not trace an individual
paper more recent than the base 1978 table for these three specific figures.

Artifact format: a JSON object {"n": 17, "d": 6, "codewords": [...]} where each entry of
"codewords" is EITHER a binary string of length exactly n (e.g. "0101100...0") OR a plain
integer in [0, 2^n) interpreted as a bit mask, where bit b (0-indexed, value 2^b) of the
integer is coordinate b of the codeword. Mixing strings and integers within one submission
is fine. Plain text is also accepted: a first line "n d" (two integers separated by
whitespace or a comma), then one codeword per line, each line either a length-n binary
string or a decimal bit-mask integer.

Tiny worked example (n=4, d=2 -- illustration only; (4,2) is NOT one of this mission's
supported pairs, only the five pairs listed above are accepted): the four codewords
"0000", "0011", "1100", "1111" are pairwise at Hamming distance 2 (e.g. "0000" vs "0011"
differ in 2 places, "0000" vs "1111" differ in 4 places, etc.), so this is a valid, if
tiny, binary code with n=4, d=2, size=4. The same code as bit masks would be
[0, 3, 12, 15] (0011 in binary is 3, 1100 is 12, 1111 is 15).

Tiers: for each supported (n,d) pair, "valid" is any correctly checked code of that (n,d)
regardless of size; "target" is size >= the pair's best known lower bound (you have
reproduced a published record); "record" is size STRICTLY GREATER than the pair's best
known lower bound (you have found more codewords than anyone has published -- a genuine
new result). Submissions for any (n,d) pair not in the table above are rejected outright
with a precise message naming the supported pairs, not silently scored against the wrong
bounds.

Attack strategies:
1. Literature retrieval: track down and faithfully transcribe the actual published
   construction behind a pair's lower bound (e.g. Milshtein's 2015/2019 length-16 codes,
   extended by one parity bit to length 17) and verify it locally before submitting --
   this reliably reaches the target tier and is a completely legitimate way to confirm the
   mission's own numbers.
2. Shortening and puncturing: take a good code at a related (n', d) or (n, d') and either
   delete a coordinate (puncturing, which can reduce d by 1) or fix a coordinate's value
   and delete it (shortening, which preserves or increases d while shrinking n and roughly
   halving size) to build a candidate for one of this mission's exact (n,d) pairs.
3. Linear codes from a generator matrix: build a [n,k] linear code (2^k codewords) by
   choosing a generator matrix and checking (or designing via a known bound like BCH,
   Reed-Muller, or a quadratic-residue construction) that its minimum weight is >= d;
   linear codes are usually the easiest to reason about analytically, though the very
   best A(n,d) codes are sometimes nonlinear.
4. Clique search: build the graph on all 2^n binary strings where two strings are adjacent
   iff their Hamming distance is >= d, and search for a large clique (simulated annealing,
   tabu search, or exact clique solvers on a restricted candidate set, e.g. only strings
   within a bounded distance of a good starting code). This is the general-purpose method
   most likely to find a genuine record, and is exactly how many entries in Brouwer's table
   were originally found.
5. Local search / simulated annealing directly on a fixed-size codeword set: start from a
   known lb-size code, then try to add codewords one at a time (or swap out a codeword for
   two) while maintaining the distance-d property, accepting a temporary decrease in
   satisfied constraints to escape local optima.

Pitfalls: the O(k^2) all-pairs distance check must cover every pair, not a sample --
codes that are "almost" distance-d (failing on a single close pair out of possibly
millions) are the classic way a broken construction looks fine under casual inspection.
A duplicated codeword trivially inflates the count without adding any real distance, so
distinctness is checked before distance. Submissions are capped at 10,000 codewords for
performance (all five supported pairs' lower bounds are far below this, so the cap never
binds a legitimate attempt); an oversized submission is rejected outright rather than
truncated. Codewords must be exactly n bits (or a bit mask in [0, 2^n)) for the CHOSEN
pair's n -- copying codewords from a table entry for a different length is a common and
easy-to-catch mistake.