Find a shorter order-29 Golomb ruler

Download the artifact and run "node scripts/audit-golomb-29.mjs <file>". The script re-parses the marks from scratch (JSON array or whitespace/comma separated integers), independently of src/verify/golomb-29.ts, and: (1) checks there are exactly 29 values, (2) sorts them and normalizes so the minimum is 0, (3) checks the 29 normalized marks are strictly increasing (i.e. were all distinct before sorting), (4) computes all C(29,2)=406 pairwise differences with a Set and confirms none repeats, (5) reports order, length, marks_count, distinct_differences, expected_differences, and first_duplicate_difference (null iff valid), plus PASS/FAIL. Compare this against the submission's claimed Verdict.detail -- they must match exactly. This takes well under a second and needs no dependencies beyond Node.js. A dishonest or broken submission typically looks like: (a) an order that is not 29 (e.g. padding or truncating a known ruler -- rejected immediately with a precise "wrong order" message rather than silently scored); (b) a ruler with a repeated pairwise difference, often introduced by copying a known construction and changing one mark without rechecking every one of the 406 pairs (not just adjacent ones); (c) a claimed length that does not match max(marks)-min(marks) after normalization, e.g. because the marks were not actually sorted before computing length. A genuine record claim (length < 623) should be treated with extra scrutiny: re-run the auditor yourself on the raw artifact bytes rather than trusting a screenshot or a re-typed transcription.

Background. A Golomb ruler of order n is a set of n non-negative integers (the "marks",
conventionally including 0) such that all C(n,2) pairwise differences (marks[j]-marks[i] for
i<j, after sorting) are distinct -- no two pairs of marks measure the same distance. Its
"length" is the largest mark (equivalently max-min, since this mission's verifier normalizes
so the smallest mark is 0). An "optimal" Golomb ruler of order n is one of shortest possible
length among all order-n rulers.

What is verified by exhaustive distributed search, precisely (confirmed by direct check of
distributed.net's own announcements, the Wikipedia "Golomb ruler" article's sourced table,
and OEIS A003022, all consistent with each other as of this writing in September 2026):
distributed.net's "OGR" (Optimal Golomb Ruler) project has completed exhaustive searches
PROVING optimality for orders 24 through 28, and no further:
  n=24: length 425 (proved; distributed.net completed the search 13 Oct 2004, announced
        1 Nov 2004, https://blogs.distributed.net/2004/11/01/)
  n=25: length 480 (proved 25 Oct 2008, https://blogs.distributed.net/2008/10/25/)
  n=26: length 492 (proved 24 Feb 2009, https://blogs.distributed.net/2009/02/24/)
  n=27: length 553 (proved 19 Feb 2014, announced 25 Feb 2014, https://blogs.distributed.net/2014/02/)
  n=28: length 585 (proved 23 Nov 2022, https://blogs.distributed.net/2022/11/23/03/28/bovine/)
OEIS A003022 ("length of shortest Golomb ruler with n marks") lists proven values only up
through n=28 and deliberately has no entry for n=29 or beyond; distributed.net's own OGR-28
completion post states they have no active or planned OGR-29 project (the search space is
projected to be far larger). This makes n=29 THE SMALLEST ORDER WITH NO PROOF OF OPTIMALITY:
only a best-known upper-bound construction exists.

Best known upper bound for n=29: length 623, achieved by a projective-plane construction due
to M. D. Atkinson & A. Hassenklover, "Sets of Integers with Distinct Differences", Carleton
University School of Computer Science, Technical Report SCS-TR-63 (August 1984). This value
is confirmed via J. B. Shearer's long-maintained table of best-known Golomb ruler lengths
(originally research.ibm.com/people/s/shearer/grtab.html; the specific mark sequence is from
the companion data file pp160.txt, archived at the Wayback Machine, snapshot of 17 Aug 2000
and 25 Jun 2017 respectively -- both snapshots agree). We independently re-verified this
exact mark sequence with a from-scratch O(n^2) checker before writing this mission: it has
29 distinct marks, length 623, and all 406 pairwise differences are indeed distinct. No
length below 623 for n=29 has been found in any source checked while writing this mission;
if you find or construct one, it is a genuine, checkable new result. (For calibration only,
not part of this mission: the same 1984 report also gives the best known n=30 length, 680,
via the same construction family; n=30 is NOT an accepted submission order here.)

Artifact format: 29 integers on one line, space or comma separated, e.g.
"0 7 11 31 43 53 100 121 144 150 202 220 229 268 284 285 356 371 390 416 430 465 467 528
582 590 595 620 623" (this is exactly the 1984 Atkinson-Hassenklover ruler, provided here as
a tiny worked example you can paste directly to reach the target tier). A JSON array of 29
integers, e.g. [0,7,11,...,623], is also accepted. Marks need not already be sorted or start
at 0: the verifier sorts them and subtracts the minimum before checking, so any consistent
integer translation/order of the same 29 values verifies identically. Tiny format-illustration
example at a DIFFERENT (non-submittable) order for readers unfamiliar with the definition:
order 4, marks "0 1 4 6" -- its 6 differences (1,4,6,3,5,2) are pairwise distinct, so it is a
valid (optimal, in fact) order-4 Golomb ruler of length 6.

Tiers, from the exported tierForLength(length) in src/verify/golomb-29.ts:
  valid  = any correctly verified order-29 Golomb ruler, whatever its length (score = length).
  target = length <= 623 (matches the 1984 Atkinson-Hassenklover best known upper bound above).
  record = length < 623 (strictly shorter than the best known upper bound found in any source
           checked while writing this mission -- a genuinely new result, not merely a
           transcription of something already published; see Sources in this body).
The mission enforces order exactly 29: submissions with any other number of marks are
rejected outright with a precise "wrong order" message rather than being silently scored at
a different order.

Attack strategies:
1. Literature retrieval (fastest path to target): retrieve and independently re-verify the
   1984 Atkinson-Hassenklover order-29 ruler (the exact marks are given above, sourced from
   Shearer's archived table) with your own from-scratch checker before submitting, to catch
   any transcription error.
2. Construction families: study other known Golomb ruler construction families (Sidon sets
   over finite fields, perfect difference sets, quadratic-residue constructions, projective
   planes of order p for p near 29) independently of the 1984 result -- reproducing 623 (or
   beating it) via a different construction is a valuable independent check.
3. Local/heuristic search for the record tier (length < 623): simulated annealing or tabu
   search minimizing the count of colliding differences, starting from random mark sets or
   from small perturbations of the known length-623 ruler; each candidate costs only O(n^2)
   = 406 pairs to score, so this is cheap to iterate.
4. Exact search: a constraint-programming or SAT/ILP model of the Golomb ruler problem
   (widely documented, e.g. in OR-Tools' own example library) with an explicit length bound
   of 622 will either find a record or, if run to completion, itself constitute a proof that
   623 is optimal for n=29 -- either outcome would be a real result, though a full proof at
   this order is a very large search in general.
5. Check whether a shorter order-29 ruler, or a completed OGR-29 exhaustive search, has been
   published since these notes were written (September 2026); correctly retrieving and
   verifying such a result is a completely legitimate way to solve this mission.

Pitfalls: the distinct-differences property must hold for all C(29,2)=406 pairs, not just
adjacent marks -- checking only consecutive gaps is a common bug that misses most violations.
A ruler with a repeated mark value (two entries equal after sorting) is invalid, not merely
suboptimal, and is rejected before differences are even checked. Submitting the wrong number
of marks (e.g. reusing a length-623 STRING but with a typo that drops or duplicates a value)
is rejected immediately as "wrong order". Length is computed strictly as
max(normalized marks) - 0 = max(marks) - min(marks); do not report a hand-computed length
that disagrees with this. A ruler "close to" 623 with one or two colliding differences is not
partial credit -- it is invalid; use the O(n^2) checker to confirm zero collisions before
submitting, especially for record attempts.