# The 800-term evidence series — verification bank for recurrence claims

These files are the verification data behind Section 4.5 of the mixtures
paper ("Holonomic structure, operators, and a computational negative
result"). They hold the exact evidence series Z(n) of the binomial-mixture
(coin-toss) model along two rays in the count vector U, reduced modulo
word-size primes, together with the records of the overdetermined
recurrence searches that found no scalar operator in the reachable region.
Any future claim of a scalar contiguity recurrence for this family must
annihilate these series before its other properties are worth discussing.

| File | Content |
|---|---|
| `SERIES_800.json` | Z(n), n = 0..800, on the singular ray U = n·(1,4,6,4,1), modulo each of the fourteen largest primes below 2^25 (JSON object: prime → list of 801 residues). |
| `ALLONES_SERIES_800.json` | Z(n), n = 0..800, on the all-ones ray U = n·(1,1,1,1,1), modulo the two largest primes below 2^24. |
| `RESCAN16_SINGULAR_800.json` | Record of the recurrence scan on the singular ray: orders r = 1..16 at two primes, the per-order coefficient-degree cap recorded for each order in its `dcap` field (140 for r ≤ 3, then 132, 110, 94, 82, 72, …, 37 at r = 16), overdetermination margin 8; every entry `"found": false`. |
| `RESCAN16_ALLONES_800.json` | The same scan on the all-ones ray (recorded caps 160 for r ≤ 3, then as above). |
| `SHA256SUMS.txt` | Checksums of the four files above and of this README. |

## Convention

Z(U) is the evidence of the two-component binomial mixture with a uniform
prior at the reduced count vector U = (U_0, …, U_4), U_v the number of
observations with v successes in four tosses, in the normalization of the
evaluator's `Model.coin` (the allocation-sum value without the multinomial
prefactor ∏_v C(4,v)^{U_v}; `full_ml_reduced` in `lsx_direct.py` restores
that prefactor). The residue stored for prime p is Z(n) mod p, i.e.
numerator × denominator^(p−2) mod p, with Z(0) = 1 for the empty sample.

## Checking the bank

From the parent directory, `python3 mixtures-evaluate.py --series`

- verifies the sha256 of the four files against pins carried in the
  script (a tampered or truncated bank fails);
- recomputes the first terms of each ray exactly with the vendored
  allocation-sum engine (`Z_phi` on `Model.coin` in `lsx_direct.py`) —
  n = 0..10 on the singular ray (N ≤ 160) and n = 0..20 on the all-ones ray
  (N ≤ 100) — reduces them modulo every listed prime, and requires every
  residue to match;
- checks the scan records: sixteen orders at two primes per ray, no
  operator found at any order, the per-order caps equal to the values
  recorded in the records (pinned in the script), and the search region
  (r+1)(d+1) ≤ 670. Of these numbers the paper prints only the
  singular-ray endpoints, 140 at r ≤ 3 and 37 at r = 16, and the 670
  bound; the intermediate caps and the all-ones ceiling of 160 are the
  scan records' own entries.

`python3 mixtures-evaluate.py --series --mutate` perturbs one loaded
residue by +1 and must exit nonzero. Independently of the script,
`sha256sum -c SHA256SUMS.txt` run inside this directory must print OK for
every line; treat any mismatch as disqualifying and re-obtain the files.

## Using the bank as a test

A proposed recurrence of order r with polynomial coefficients c_i(n) is
refuted if ∑_i c_i(n) Z(n+i) is nonzero modulo any listed prime for some n
with n + r ≤ 800; it is consistent with the bank only if it annihilates all
801 terms at two or more independent primes on the relevant ray. The scan
records show that no such operator exists with (r+1)(d+1) ≲ 670 — in
particular none of order r ≤ 3 with coefficient degree d ≤ 140 on the
singular ray — so a genuine operator for this family, if one exists, has
coefficient degree beyond that ceiling.

## Regenerating or extending the series

The modular route that produced these terms ships in the Mixalot bundle
(`mixalot/vendor/pilot/zseries.py`, function `Z_coin_modp(U, p)`, a direct
lattice dynamic program modulo p < 2^25): `Z_coin_modp([n, 4n, 6n, 4n, n],
p)` reproduces `SERIES_800.json[p][n]` and `Z_coin_modp([n]*5, p)`
reproduces `ALLONES_SERIES_800.json[p][n]` (checked at build time through
n = 24 on the singular ray and n = 40 on the all-ones ray). Its cost per
term grows quickly with n, so the first
few dozen terms take seconds while the full 800-term run is a long
computation; the production run used an incremental variant of the same
dynamic program (one convolution per step, checkpointed) that is not part
of the bundle. Terms at further primes or beyond n = 800 extend the bank
without changing any existing entry. The raw per-prime lattice arrays from
the production run are not published; their distilled content is exactly
these series.