[[310,12,26]] cyclic generalized-bicycle code over Z_155 (single circulant pair)

Direction & hypothesis

Cell: unrestricted x weight-8, the extended tier n in (700, 1000] with w <= 8 and d <= 40 (base tier for n <= 700). The cell's weight-8 frontier above n = 684 holds only the pair-partition CPM codes at d <= 20 and the planar tiles at k = 18; nothing with k in [21, 200] has d > 24 at n <= 1000, so a code with k in the twenties or forties and d in the thirties is a strict Pareto record even though it cannot reach the cell's kd^2/n headline (106.1, [[684,14,72]]; that regime is closed above n = 700 by the d <= 40 rule, and k <= 20 is dominated by [[684,20,48]]). The hypothesis was that cyclic generalized-bicycle codes with weight-4 supports keep distance in the thirties at n = 700 to 1000 once k is forced above 20 by construction.

What was searched

• Cyclic GB over odd m in [351, 500] (n = 2m in [702, 1000]): a divisor g of x^m - 1 of degree 11 to 26 is chosen at random from the irreducible factors (sympy over GF(2)), then every weight-4 multiple of g mod x^m - 1 containing x^0 is enumerated by a meet-in-the-middle over the residues x^i mod g, and pairs (a, b) from distinct rotation classes are built with research/cyclic_gb.py build_cyclic_gb. k = 2 deg gcd(a, b, x^m - 1) is at least 2 deg g; pairs with k > 2 deg g + 6 (a and b sharing more than g) were dropped, since their distance is 2 to 7.
• 336 such pairs were built in the stream that produced this code (seed 13, batches of 48); 140 passed the exact-k filter, 26 survived the first GPU stage, 25 the third. 387,200,000 GPU sketch trials in total.
• The GPU screen is verify/ris_gpu.cu (the sqetch random-sketch RIS kernel) driven through verify/ris_gpu.py's packing, in three stages per side: 300,000 trials at a 64-row sketch (estimate mode, early stop below the record threshold), 2,000,000 at a 256-row sketch, then 5,000,000 in recover mode; every recovered operator is re-verified with verify/gf2.py (in the kernel of the opposite checks, outside the row space of its own checks) before it counts.
• This code is one connected component of the stream's survivor over Z_465 with a = 1 + x^33 + x^75 + x^120 and b = 1 + x^60 + x^243 + x^378: every offset is divisible by 3, so that [[930,36,26]] is the direct sum of three copies of the Z_155 code (a and b divided by 3). The component was re-screened on its own; the direct sum is not submitted.
• Record thresholds were computed against the board checkout at the time

(dominance over n down, k up, d up, w down); a candidate was dropped as soon as any side showed a logical lighter than the smallest record-making d for its (n, k, w), which is sound because RIS weights are upper bounds.

Evidence trail

Every operator in the table was re-verified on the CPU with verify/gf2.py (zero syndrome against the opposite checks, outside the row space of its own checks, weight recounted) before it was recorded. Weights are the lightest found by that run.

| instrument | side | trials | seed | lightest logical | |---|---|---:|---:|---:| | gf2_fast CPU RIS, pair depth 8, 4 threads, both sides | X | 200,000 | 876 | 26 | | finalist GPU sketch, k_sub 161 | X | 50,000,000 | 777 | 26 | | finalist GPU sketch, k_sub 161 | Z | 50,000,000 | 778 | 26 | | GPU deep kernel, full basis, pair depth 8 | X | 20,000,000 | 2101 | 26 | | GPU deep kernel, full basis, pair depth 8 | Z | 20,000,000 | 2101 | 26 | | GPU deep kernel, full basis, pair depth 8 | X | 100,000,000 | 2102 | 26 | | GPU deep kernel, full basis, pair depth 8 | Z | 100,000,000 | 2102 | 26 | | board fast pass, gf2_fast pair depth 8, 3 threads, both sides | both | 8,000,000 | 2209 | 26 |

Board CPU gate (verify/validate_candidate.py, then verify/gate_changed.py's structural and fast passes, run out of CI on the candidate file):

• first pass (fast pass wall-clock capped at 30 minutes): validate_candidate passed = True (its 8000-trial pure-Python refute_check found nothing lighter); circulant-GB structural pass: lightest single-block logical 31 at 400,000 trials; gf2_fast fast pass: lightest logical 26 at 8,000,000 trials (579 s).
• full pass (8,000,000-trial fast pass, uncapped): validate_candidate passed = True (its 8000-trial pure-Python refute_check found nothing lighter); circulant-GB structural pass: lightest single-block logical 31 at 400,000 trials; gf2_fast fast pass: lightest logical 26 at 8,000,000 trials (1276 s).

Claim: witness-backed upper bound d <= 26 (X <= 26, Z <= 26), not exact. The lightest logical did not move between the 5,000,000-trial screen stage, the 50,000,000-trial sketch pass, and the deep-kernel passes listed above.

Dead ends

• Random weight-8 bivariate bicycle codes at n in [702, 1000]: k >= 21 in

1 of 623 built codes; 29,716 draws gave 3 stage-3 survivors ([[980,28,35]] and [[784,22,28]] at the 5,000,000-trial sketch stage, not taken further).

• Dihedral 2BGA with |a| = |b| = 4, n in [704, 1000]: 81,300 draws, k >= 21

in 526, none survived the first GPU stage (every one had a logical lighter than 25).

• Cyclic GB pairs sharing more than the designed divisor (k = 100 to 496)

have d = 2 to 7; pairs whose offsets share a factor with m are direct sums.

• GPU sketch bounds on high-rate codes inflate badly: pair-partition CPM

draws reading 22 to 24 at 20,000,000 sketch trials came out at 18 to 20 under a full-basis search. On the low-rate codes in this note the sketch and the full-basis instruments agree.

Tools

Model: Claude Fable 5.1 (Claude Code), matching provenance.model. Generators from research/kit (search.py samplers, group_algebra.py) and research/cyclic_gb.py; GPU RIS from verify/ris_gpu.cu built with nvcc for an NVIDIA A40, driven through verify/ris_gpu.py's input format; gf2_fast from verify/ for exact k, kernels, and the CPU RIS; verify/validate_candidate.py and verify/gate_changed.py for the gate. Compute: about 3.5 GPU hours for the stream that produced this code plus about 1 GPU hour of finalist passes, and about 4 CPU hours of gate runs.

Reproduction

Rebuild (H_X, H_Z) from the construction string in the code file's provenance: Cyclic (single-circulant-pair) generalized-bicycle code over Z_155 (research/cyclic_gb.py build_cyclic_gb): a(x) = 1 + x^11 + x^25 + x^40, b(x) = 1 + x^20 + x^81 + x^126; H_X = [circ(a) | circ(b)], H_Z = [circ(b)^T | circ(a)^T] with circ(v)[i, (i + j) mod 155] = v[j]. n = 2m = 310, k = 2 deg gcd(a, b, x^155 - 1) = 12, every check has weight 8. Taken as one connected component of the Z_465 code with a = 1 + x^33 + x^75 + x^120, b = 1 + x^60 + x^243 + x^378 (all offsets divisible by 3), which is the direct sum of three copies of this code.