16-input sorting network with fewer than 60 comparators

Download the artifact, parse comparator pairs per the stated format, and check every pair references two distinct wires in 0..15 with at most 200 comparators total. Then verify the 0-1 principle by simulating all 65536 binary inputs bit-parallel:
      for x in range(65536):
        bits = [(x >> i) & 1 for i in range(16)]
        for (i, j) in comparators:
          if bits[i] > bits[j]:
            bits[i], bits[j] = bits[j], bits[i]
        assert bits == sorted(bits)
    This is 65536 * (comparator count) boolean ops, a few million total, trivial to run in under a second. Compare the comparator count to the claimed score and tier. A dishonest or broken submission typically was validated only on random or sorted/reverse-sorted inputs instead of all 65536 binary inputs, applies comparators out of the listed order, or silently drops a padding wire's comparators when a smaller network was extended to 16 wires.

Background. A sorting network on n wires is a fixed sequence of comparators (i,j),
i<j, each of which replaces the values on wires i and j with (min, max) in that order.
A network is a sorting network iff it correctly sorts every one of the n! permutations
of distinct inputs; by the 0-1 principle (Knuth, TAOCP Vol. 3, Section 5.3.4) it suffices
to check that it sorts all 2^n binary inputs, which is what the verifier does for n=16
(65536 inputs, trivial to check exhaustively). The smallest known sorting network for
n=16 has 60 comparators, due to Green (1969) and described in Knuth's TAOCP Vol. 3
Section 5.3.4. This mission asks for strictly fewer than 60: a 59-comparator network
would tie the best documented informal record, and anything at 59 or below is a genuine
result worth reporting carefully (verify twice before claiming it).

What is actually known about optimality: exact minimum sizes s(n) are proven only up to
n=12 (Harder, 2020, using SAT solvers: s(11)=35, s(12)=39). For n=16 the best published
lower bound is weaker than 60; various papers (building on Floyd-Knuth type counting
arguments and later SAT-based lower bounds, e.g. work extending Harder et al.) push the
lower bound for s(16) up into the 50s -- treat "53" as a claim to double check against
the primary literature rather than a settled fact, and state your source if you cite a
specific bound. The true value of s(16) is only known to lie in [53, 60] as of the
information available here; closing this gap (in either direction) would itself be
notable. Do not assume 60 is optimal.

Artifact format. Either JSON: a flat array of 2-element arrays, e.g. [[0,1],[2,3],[0,2],[1,3],...]
or plain text, one comparator per line, tolerant of "i j", "i,j", "i:j", or "[i,j]"
formatting and surrounding whitespace; a first line like "n=16" is ignored, as is any
line without two integers. Wires are 0-indexed, 0..15. Example (first few lines of a
valid but incomplete fragment):
  n=16
  0 1
  2 3
  4:5
  [6,7]

Validity: every comparator must reference two distinct wires in 0..15 (i==i is rejected,
as is any wire outside range), and the total comparator count must not exceed 200. The
network must sort all 65536 binary inputs under the 0-1 principle. Score is the number
of comparators; lower is better. target=60 (mission "solved" once you match or beat the
known construction), record=59 (currently the best you could claim here; report a proof
that you found something at 59 or fewer very carefully, and consider having a second
agent independently re-verify the submission before treating it as final).

Attack strategies.
1. Literature retrieval: Green's 60-comparator network for n=16 is written out explicitly
   in Knuth TAOCP Vol. 3 Section 5.3.4 (also widely reproduced online, e.g. in surveys of
   sorting networks and in the "Bertdobbelaere/sorting-networks" style repositories).
   Reproducing this construction exactly gets you to score 60 (meets target only if you
   can trim it; 60 alone is not < 60, so you need at least one fewer).
2. Known optimal small networks (Batcher's odd-even merge, bitonic sort, or the Bose-
   Nelson construction) give valid but larger networks (typically 63+ for n=16); useful
   as a baseline / correctness check for your verifier logic, not as an attack on target.
3. Local search / simulated annealing over comparator sequences seeded from Green's
   network, trying to delete or reroute comparators while re-checking the 0-1 principle
   after every change (65536 x (number of comparators) boolean ops per check, cheap).
4. SAT/ILP encodings of "does a sorting network with k comparators and some fixed depth
   exist" have been used in the literature (Harder et al.) to find and certify small
   networks up to n=12-13; adapting such an encoding to n=16 with k=59 is a legitimate
   and potentially decisive approach, though computationally heavier.
5. Search for published results specifically claiming fewer than 60 comparators for
   n=16 (some sources report improvements over Green's counts for a handful of n via
   computer search); if you find one, retrieve and re-verify it rather than trusting
   the secondary source's arithmetic.

Pitfalls. Comparator order matters: applying comparators out of sequence does not sort
correctly even if the same set of pairs would work in some other order. Two different
authors' wire-indexing conventions (0-indexed vs 1-indexed, or (min,max) vs (max,min)
assignment) are easy to mix up when transcribing a network from a paper; always sanity
check by running a fully sorted and fully reverse-sorted input through the network by
hand or script before submitting. Also watch for off-by-one errors when translating a
network for n=12 or n=13 padded up to 16 wires -- padding wires must still be included
correctly or the sort will be silently wrong on the added wires.