Exact value of a simultaneous one-shot decoding deficit on the causal lattice. Place one independent fair bit at every event of the n-by-n lattice under the product order; each nearest-neighbor future link carries one bit, computed from the causal past of its tail; every 3-by-3 bulk diamond must reconstruct its own nine interior bits from the eight bits crossing its future cut. Counting caps each diamond's success at 1/2. The worst-case gap to that cap, minimized over the full randomized link-consistent causal code class, is zero for n <= 7 and exactly
Delta*(8,3) = 51/512
at the threshold n = 8, with Delta*(n,3) >= 51/512 for every n >= 8 and a certified closed-form floor at every scale ell >= 3. Past the threshold the exact values are open; the certified boxes are
[51/512, 3/16] at n = 9 and at n = 10
and 3/16 is exactly where mixtures of affine codes stop, so the residual width 45/512 is a pure nonlinearity gap.
python3 verify_null_diamond_witness_n8.py null_diamond_witness_n8_v1.json
The verifier is standard-library Python. It reconstructs the sixteen bulk diamonds from the definitions, checks that the declared code is causal and well-formed, recomputes all 256 branch-diamond MAP success counts of the sixteen-branch witness mixture, and certifies that every diamond lands exactly on 205/512 -- deficit 51/512 against the local bound 1/2. It exits nonzero on any mismatch. The data file carries the full witness: the fixed 48-link routing, the twelve-coordinate type structure, and per branch the exact rational weight, the cycle policy, the central truth tables, and the sixteen per-diamond success counts.
verification/ reproduces every number in the paper from the
definitions. Every quantity that decides anything is exact: Fraction and
Python-integer arithmetic in most of the scripts, int64 tensor
contractions in the converse and scale-floor group. Four of the nine
verifiers need NumPy for those contractions --
verify_null_diamond_converse.py,
verify_null_diamond_converse_independent.py,
verify_null_diamond_all_ell.py and
verify_null_diamond_all_ell_samples.py. The other four and the n = 8
witness verifier above are standard-library only. One float64 pass
exists, the ell = 5 scan in verify_null_diamond_all_ell_samples.py: it
selects candidates under an explicit error bound, the winner is then
recomputed in exact integers, and the bound certifies that nothing
outside the candidate window can beat it.
cd verification
python3 -m pytest -q # witness unit tests
python3 verify_null_diamond_converse.py # four-corner floor, n >= 8
python3 verify_null_diamond_converse_independent.py # second, independent converse
python3 verify_null_diamond_all_ell.py # scale-parametric floor, ell >= 3
python3 verify_null_diamond_all_ell_samples.py # onset constants at ell = 4, 5
python3 verify_null_diamond_n10_coordinate.py # deterministic-affine optimum 1/4
python3 verify_null_diamond_affine_mixture.py # n = 9, 10 ceiling 3/16
python3 verify_null_diamond_n10_adjacent_pair.py # offset-one pair: zero control
python3 verify_null_diamond_offset_two_pair.py # offset-two pair: zero control
The converse is a four-corner relaxation: a 95-vertex membership polytope and an exhaustive exact contraction that caps the total corner success at 205/128, giving Delta*(n,3) >= 51/512 for every n >= 8. A second implementation rebuilds it from scratch and agrees. The scale-parametric floor 8c^2 - 16c^3 + 24c^4, c = 2^(2l - l^2) is certified for every ell >= 3, and the nine-block rigidity at n = 10 is checked.
The upper endpoint at n = 9 and n = 10 is 3/16. Two deterministic coordinate codes -- one giving eight distinct own-interior coordinates to the 18 diamonds on one diagonal of each of the nine four-corner blocks, the other its mirror -- mixed with weights 1/2, 1/2, put every one of the 36 bulk diamonds at success exactly 5/16. Restricting both to the initial 9-by-9 sublattice does the same for all 25 diamonds there. Every success is recomputed as an exact MAP probability by direct enumeration, not from a rank formula.
That ceiling is exact for its class. For a deterministic affine code the success exponent is dim(Im M + W) - dim W, and it reaches its maximum only when every cut row is supported inside the diamond's own interior; since cycle-adjacent corners of a block have disjoint interiors and share a cut link, at most two of a block's four corners can saturate. The resulting cap sum_v 2^(e_v) <= 5 * 2^(B-1) gives deficit at least 3/16 for every mixture of affine codes at every n >= 8, met at n = 8, 9, 10. Two further consequences: the 1/4 coordinate code is the exact deterministic-affine optimum, so randomization strictly helps at n = 10; and no affine mixture reaches 51/512, which prices nonlinearity at the threshold at 45/512.
verification/certificates/ holds the DRAT proof for the n = 10
fixed-seed core and the affine-mixture certificate, and
verification/README.md documents each script.
figures/ holds the two manuscript figures and the script that
generates them from the definitions.
The working paper is archived on Zenodo:
DOI: 10.5281/zenodo.21419239 (concept DOI -- resolves to the latest version)
https://doi.org/10.5281/zenodo.21419239
The Zenodo record holds the full text, the supplement, and the rendered PDF. This repository carries the complete verification materials: the n = 8 witness, the converse, the scale-parametric floor, the pair controls, and the n = 9 and n = 10 boxes.
ERRATUM.md records a correction to the proof of Proposition 6.2 in the
v0.2 text. The statement and the constant are unaffected.
Code is MIT (see LICENSE). The witness data file
null_diamond_witness_n8_v1.json and the figures are CC-BY-4.0.