n
16
Target: the weight-6 / unrestricted general stabilizer frontier. Use two repetition-word blocks in the established additive CWS framework, and change the graph coupling to eliminate short logicals while retaining sparse checks. This is not a claim of a new family or a global parameter record. See Cross, Smith, Smolin and Zeng, Codeword Stabilized Quantum Codes, v4. The concrete code-space novelty is unverified (provenance.novelty: unknown).
At upstream 175743117923cfca407a35a71834b6a75529a5a5 the official candidate gate reports board_advancing=true, no duplicate/WL match, and no d-only peer. Compared with codes/18-2-5-s.json (recorded d<=5, weight 5, degree 5), n falls 18 to 16 while weight and degree rise to 6; neither code dominates the other. The CSS codes/20-2-5.json has certified d=5, weight 6, degree 6 and 20 checks; codes/18-2-5-b.json has certified d=5, weight 7, degree 8 and 16 checks. At k>=2, d>=5, weight<=6, degree<=6, arbitrary repeated direct sums from the current catalog do not improve those old minima: n=18 using recorded bounds, or n=20 using the consistent exact certificates. These are catalog-relative resource comparisons, not new connected submission candidates.
Grassl's table already gives [[16,2,6]], so the point of this submission is sparse resources, not improving unrestricted n,k,d. No decoder, circuit, layout or LER benefit has been measured. kd^2/n=3.125 is descriptive, not a performance proof.
Two C8-square matchings and two C9-square matchings were initially built: their exact distances were 4,4,5,5. C8 matchings were then quotiented by the known dihedral symmetries: 202 representatives cover 8!=40320 matchings. Only the first two representatives were visited; the second supplied this code. In total that branch materialized five distinct check matrices; multiple saved witnesses of one matrix were not counted as separate codes. The 16-check and 14-check versions generate the same stabilizer group. Construction and exhaustive screening were deterministic, with no RIS seed.
The submitted Pauli witness is X={0}, Z={0,3,4,5,8}, physical weight 5. Complete enumeration below establishes mathematical distance 5; it is supplementary evidence, not the Challenge's official exact certificate. The JSON therefore retains distance.P.confidence=upper_bound.
The final JSON passed the official candidate gate at seed 20261017301. The deep CI gate was also run locally, using an unchanged separate trusted base checkout, seed 20261017303: 26,920 Pauli RIS trials and 4,038,000 completed accelerator trials on the symplectic doubling, with no lighter logical. The distinct orbit-fold/random-frame pass used a 50,000-trial per-problem budget (seed 20261017316); its receipt reports 13 folded/frame problems. These budgets are different search mechanisms and are not summed as one Pauli search depth. A further 100,000 native Pauli RIS trials at fresh seed 20261017304, with no time cap, doubling or folds, also held at 5.
Let Γ be the adjacency matrix of two disjoint squares of the cycle C8, with vertices 0..7 and 8..15, joined by the matching p=(0,1,2,3,4,5,7,6). Put K_i=X_i Z_{N(i)}. The submitted generators are K_i K_{i+1} for i=0..6 and i=8..14. All products are interpreted through their binary symplectic labels. These 14 rows equal the submitted JSON. The graph-state label map x↦(x,Γx) is injective; the chosen labels span vectors of even parity in each eight-vertex block. Thus the stabilizer rank is 14 and k=2. Each supplied check has physical weight 6; their total incidence is 84 and maximum qubit degree is 6.
The complete binary calculation below enumerates all 2^14 stabilizers and all 2^18 normalizer vectors. It finds no nonzero normalizer of weight≤4, a nontrivial weight-five logical, and minimum nonzero stabilizer weight 6. Thus the finite matrix has mathematical distance 5. This is an independently reproducible exhaustive argument, not an official Challenge exact-distance certificate: the submission retains its witness-backed upper_bound field.
The graph generators commute with positive graph-state phases. For an adjacent pair, the local XZ and ZX factors have cancelling phases; the canonical positive-Y row equals K_i K_j. The 14 independent rows therefore define a consistent stabilizer without -I.
This also proves non-LC-CSS after arbitrary changes of stabilizer generators. If a local Clifford/permutation image were CSS with check ranks rX,rZ, then rX+rZ=14. Purity of the whole normalizer would make ker(HX) a binary [16,16-rX,≥5] code. Disjoint radius-two Hamming balls have 137 words each, so 2^rX≥137 and rX≥8. Likewise rZ≥8, contradicting rX+rZ=14. This uses the full normalizer, including stabilizers; the occurrence of Y in the displayed checks is not the proof.
A six-vertex squared-cycle block with one matching edge per vertex admits K_i times the full-block Z operator of weight 3, outside the even-block stabilizer subspace. Enlarging that fixed block to C8 and changing its matching was a structural response. The initial C8 choices stayed at d=4; the graph edge-overlap proxy did not reliably predict distance. The matching sweep was not exhaustive for C8 and establishes no infinite-family claim.
GPT-6 Astra and GPT-6.1 Sol, coordinated through OpenAI Codex, supported construction, comparison, independent review and drafting. Official tools: verify/validate_candidate.py, verify/gate_changed.py and the unchanged verify/gf2_fast.cpp accelerator. The independent proof uses standard Python. Only local CPU computation was used; no GPU or LER search was needed. Final CI-depth verification took about 20 CPU seconds. Packaging follows CONTRIBUTING.md's by-hand route; promote.py was not used.
From the repository root, save the following standard-library Python 3.10+ block as a temporary script and run it with codes/16-2-5.json as its only argument. It reconstructs the actual checks, verifies rank and the witness, then exhausts the stabilizer and normalizer. It does not replace the official gate.
# Standard Python 3; run with the submitted JSON as the only argument.
import collections, hashlib, itertools, json, math, sys
raw = open(sys.argv[1], 'rb').read()
doc = json.loads(raw)
n, mask = 16, (1 << 16) - 1
assert (doc['n'], doc['k']) == (16, 2)
def pack(c):
for s in ('X', 'Z'):
assert len(c[s]) == len(set(c[s]))
assert all(0 <= q < n for q in c[s])
return sum(1 << q for q in c['X']) | sum(1 << (n+q) for q in c['Z'])
def wt(v): return ((v & mask) | (v >> n)).bit_count()
def sp(a, b): return (((a & mask) & (b >> n)) ^ ((b & mask) & (a >> n))).bit_count() % 2
def basis(rows):
b = {}
for v in rows:
while v:
p = v.bit_length()-1
if p not in b:
b[p] = v
break
v ^= b[p]
return b
def span(rows):
v = 0
yield v
for j in range(1, 1 << len(rows)):
v ^= rows[(j & -j).bit_length()-1]
yield v
# Two C8-squared blocks; cross-matching swaps only positions 6 and 7.
gamma = [0]*n
for b in (0, 8):
for q in range(8):
for step in (-2, -1, 1, 2):
gamma[b+q] |= 1 << (b+(q+step) % 8)
for q, j in enumerate([0, 1, 2, 3, 4, 5, 7, 6]):
gamma[q] |= 1 << (8+j)
gamma[8+j] |= 1 << q
K = [(1 << q) | (gamma[q] << n) for q in range(n)]
recipe = [K[b+q] ^ K[b+q+1] for b in (0, 8) for q in range(7)]
rows = [pack(c) for c in doc['checks']['S']]
assert rows == recipe and len(basis(rows)) == 14
assert all(not sp(a, b) for a in rows for b in rows)
degree = [sum(((v & mask) | (v >> n)) >> q & 1 for v in rows) for q in range(n)]
assert max(map(wt, rows)) == max(degree) == 6 and sum(degree) == 84
S = set(span(rows))
assert len(S) == 16384
# Nullspace of the 14 symplectic syndrome equations: 18 free variables.
eq = basis([(v >> n) | ((v & mask) << n) for v in rows])
nb = []
for q in range(2*n):
if q in eq: continue
v = 1 << q
for p in sorted(eq):
if (v & eq[p]).bit_count() % 2: v ^= 1 << p
assert all(not sp(v, r) for r in rows)
nb.append(v)
assert len(nb) == 18
histS = collections.Counter(map(wt, S))
histN, histL = collections.Counter(), collections.Counter()
for v in span(nb):
histN[wt(v)] += 1
if v not in S: histL[wt(v)] += 1
assert sum(histN.values()) == 262144
assert sum(histL.values()) == 245760
assert min(histL) == min(w for w in histN if w) == 5
assert min(w for w in histS if w) == 6
E = pack(doc['distance']['P']['witness'])
assert wt(E) == 5 and E not in S and all(not sp(E, r) for r in rows)
assert doc['distance']['d'] == doc['distance']['P']['value'] == 5
# Purity excludes CSS under any local Clifford/permutation or generator change.
assert 1+n+math.comb(n, 2) == 137 > 2**7 # each CSS rank must be >=8
assert 8+8 > 14
# A component of size m<=8 could not distinguish all weight<=2 Pauli errors.
assert all(1+3*m+9*math.comb(m, 2) > 2**m for m in range(1, 9))
print(json.dumps({'sha256': hashlib.sha256(raw).hexdigest(), 'n': n, 'k': 2,
'distance': min(histL), 'min_nonzero_stabilizer_weight': 6,
'checks': 14, 'max_weight': 6, 'degrees': degree,
'S_weight_counts': dict(sorted(histS.items())),
'N_weight_counts': dict(sorted(histN.items())),
'L_weight_counts': dict(sorted(histL.items()))}, indent=2))
Run the official checks from the repository root with its pinned environment:
python verify/qldpc_verify.py codes/16-2-5.json python verify/check_codes_format.py --files codes/16-2-5.json python verify/gate_changed.py --seed 20261017303 codes/16-2-5.json python verify/heuristic_distance.py codes/16-2-5.json --trials 100000 --seed 20261017304 --fast-trials 0 --fold-trials 0
The gate command repeats the refutation battery; a candidate gate's board novelty check must use the pre-submission base catalog to avoid a self-match. The same caution applies when interpreting an already merged entry's dedup.