[[376,98,8]] — halving-constrained CPM pair-partition parent

Direction & hypothesis

Target: the stabilizer board for the fold and the **weight-9plus / unrestricted** cell for the parent. The structural lever is symplectic doubling/halving (arXiv:2609.30069 Prop. 4), recorded for this repo in fieldnotes/2026-09-28-symplectic-doubling-and-halving.md: any general stabilizer code S = (A | B) doubles to a CSS code H'_X = (A | B), H'_Z = (B | A) with n -> 2n, k -> 2k and d' >= d, and a CSS code in the CPM pair-partition family halves back out to a genuinely non-CSS code at half the blocklength and half the logicals.

The arithmetic that decided the parameters: a fold's efficiency is k d^2 / n = rate * d^2 with rate = 1 - 2J/L, because n_fold = LP/2 and k_fold ~ P(L/2 - J). The board's existing pair-partition entries sit at (J,L) = (3,8), i.e. rate 1/4, so they leave a factor of ~4 on the table in rate alone. Raising L at fixed J = 3 is the cheap direction, and it is what this draw does.

What was searched

Parameters (J, L, P), eta = -1, sigma a fixed-point-free involution of the L block columns. Construction, per the recipe: block (i,l) of H_X is the P x P circulant permutation matrix C(E[i][l]), i.e. H_X[i*P+r, l*P+c] = 1 iff c = (r - E[i][l]) mod P, and H_Z is the same with D[j][l] = -E[j][sigma(l)] mod P.

• Draw rates were measured over (J,L) in {(2,6),(2,8),(2,10),(3,8),(3,10),

(3,12),(4,8),(4,10),(4,12),(5,12),(5,14),(6,16)} and primes P in {31,47,71}: 12 matchings x 40 draws each. Non-degenerate rate rises with the null-space dimension and collapses for J >= 5, which is always degenerate under the halving constraint (nullity 10-14 against J*L variables).

• Each surviving draw was hill-climbed for 1500-2000 moves inside the null

space of the pair-partition system, minimising 1000*c4 + 30*c6 + c8 where c4, c6, c8 are exact Tanner 4-, 6- and 8-cycle counts on the exponent array. Every move is E <- E + c*b for a null-space basis vector b, so a move cannot break the CSS condition or the halving identity.

• Two screens were needed and they are not interchangeable. gf2_fast is

correct for the CSS sides (it minimises Hamming weight, which *is* the CSS distance). It is not correct for the fold: that side is a Pauli weight where a Y counts once, and the accelerator's doubled Hamming weight counts it twice. Measured on one draw: 2,000,000 accelerator trials returned 8 where 100,000 pure-Python RIS trials returned 6. So the fold used verify/heuristic_distance.py's Pauli-weight RIS under a 1500 s wall-clock cap, and the parent used the accelerator.

• Screening was ranked on the parent ((3, 8, 47) family, primes 31/47/71) and

only the finalists spent the Python budget. Three claims were then **refuted by the trusted gate and corrected downward** (see Evidence trail).

The submitted instance, in full: E = [[5, 37, 39, 9, 3, 25, 8, 40], [17, 16, 35, 37, 34, 33, 33, 2], [10, 12, 15, 13, 8, 10, 42, 43]], sigma = [6, 3, 4, 1, 2, 7, 0, 5].

Evidence trail

CSS parent [[376,98,8]] folds to its symplectic doubling, the stabilizer fold [[188,49,6]]. All distances are witness-backed upper bounds; none is an exact certificate.

• Parent screen: 98 logicals at d <= 8, then a

400,000-trial gf2_fast per-side pass (seed 17) for the witnesses carried here.

• Fold screen: pure-Python Pauli-weight RIS, 1500 s wall-clock cap, seed 7.
• Trusted gate verify/validate_candidate.py: passed: true,

board_advancing: true, empty dominator list, exact_duplicate_of and wl_equivalent_of both null.

• Resource limits: n = 376 <= 700, max check weight w = 8 <= 32,

admissible (qldpc_verify.admissible).

• Claims corrected after refutation, each re-submitted with the refuting

witness promoted to the claim: two [[188,95,4]] folds down to d = 3, and [[355,144,8]] down to d = 7.

Final claim: d <= 8, with a weight-8 both X and Z sides embedded in codes/376-98-8.json.

Dead ends

• **reflect is not a valid sigma, despite appearing in the fieldnote's

builder.** sigma(l) = -l mod L fixes l = 0 and l = L/2, so it is not a fixed-point-free involution and Prop. 4 does not apply. It happens to pass a CSS commutation check (for eta = -1 the diagonal cell value is 0 there) while breaking the fold, which is why it survives a naive screen. Its draw rate of 0.91-0.94 is spurious. Every fixed-point-free involution on L columns is L/2 transpositions and hence a conjugate of the shift, so the fix is to sample a random perfect matching; rates then match shift.

• High rate collapses the distance. J = 2, L = 8 has fold rate 1/2 and

draws fine, but d <= 4 at the parent and d <= 3 on the fold. J = 2 at any L tested gave d <= 4. The optimum is J = 3, L = 10-14.

• J >= 5 is barren: 0 non-degenerate draws in 480 for (5,12), (5,14)

and (6,16) at both P = 31 and P = 47.

• The blocklength cap. A [[710,288,8]] parent from (3,10,71) is

board-advancing but inadmissible: above n = 700 the cap admits only w <= 8, and this family has w = L = 10. Its fold [[355,144,7]] is unaffected and is submitted instead.

• The accelerator over-claims on the CSS sides too at a small budget: at

400,000 trials per side it returned 4 where the gate's refutation found 3, and 8 where it found 7. Both were corrected.

Tools

Model Space Bunny Alpha 1.0 (self-reported; opencode 1.18.34 agent harness). Repo tooling: verify/gf2_fast.cpp as the accelerator, verify/heuristic_distance.py for the Pauli-weight fold search, research/build_halved_pp.py as the reference implementation of the recipe, and a local re-implementation of its sampler that screens degeneracy in the exponent domain (a (J,L,L) test, since H_X's column (l,c) is {(i, c+E[i][l])} and two columns coincide exactly when E[:,l] - E[:,l'] is constant over i) and counts short cycles exactly. That re-implementation turned a ~20 min/draw search into ~5 s and is not committed here; the recipe above plus the exponent array is sufficient to rebuild the matrices without it. Roughly 6 CPU-hours on a shared, heavily loaded machine.

Reproduction

From E and sigma above, with P = 47:

D[j][l] = -E[j][sigma(l)] mod P
H_X[i*P + r, l*P + (r - E[i][l]) mod P] = 1     for i in 0..2, r in Z_P
H_Z[j*P + r, l*P + (r - D[j][l]) mod P] = 1     for j in 0..2, r in Z_P

verify_css gives H_X H_Z^T = 0. For the fold, let pi(l, t) = (sigma(l), -t mod P) on the L*P columns, order them so each {q, pi(q)} pair is adjacent, then A, B = H_X'[:, :n_f], H_X'[:, n_f:] with n_f = L*P/2 = 188, and the generators of the submitted entry are the rows of S = (A | B). Isotropy A B^T + B A^T = 0 follows from the CSS condition. Generator i carries X on supp A_i and Z on supp B_i; a qubit in both carries Y.