# Build evidence for T593

The run constructs Specific heats of finite Ising rectangles at critical
coupling, a private draft. It stores c=C/(mn k_B), with the factor K_c^2
included, for all 15 pairs 2 <= m <= n <= 6. The geometry and zero-field
slice follow the family in numberdb-data issue 232. No publication or offer
for review is performed by this build.

## Policy and source record

Read the exact local and live skills archived under
`agents/runs/20261028T232356Z-build-skills/manifest.json`.
Both archived versions and the source canonical skill have SHA-256
`28ecbeeccb0c5e5d6eb541b5a5b0f88aec47b154374d909085116d34f5629199`.
The manifest reports `ready`, with no unavailable version. Its two digest
records are also attached in `skill-evidence.json`. The independent critique
must supply its own argument-selection assessment and fingerprint; this
build evidence is not an acceptance sidecar.

The normalized specific heat is checked against Wu, Zheng, Izmailian and Guo,
arXiv:1308.2040, Section II equations (1)-(5), and Section III's square-lattice
critical coupling. Peters and Regts, arXiv:1810.01699, equations (1.1)-(1.2),
supplies the cut-polynomial convention. The run retains downloaded copies
and SHA-256 digests in `sources.json`. No asymptotic-fit coefficients are used
to compute these finite-system values.

## Numerical construction and checks actually run

`generate.py` uses integer row transfer to build F_mn(b), counting every spin
assignment by its number d of disagreeing bonds. At b=sqrt(2)-1, the first
two moments give 4 K_c^2 Var(d)/(mn). All divisions use Sage balls; all count
arithmetic is exact. The exact integer coefficient arrays are attached in
`counts.json` as reproducibility output, not input.

`checks.py` uses a separate graph representation. A planar rectangle's bounded
square faces form a basis of its cycle space. Their XOR combinations enumerate
every even edge subset once; the largest case enumerates 2^25 subsets. The
high-temperature expansion converts that independent enumerator into F_mn(b).
Every coefficient agrees, on all 15 rectangles. Checks confirm the cycle-space
cardinality, F(0)=2, F(1)=2^(mn), degree, reciprocal symmetry, and rotation.

For all nine rectangles with mn <= 16, direct enumeration of all spin
assignments checks the full (number of negative spins, number of disagreeing
bonds) histogram. A separate bivariate row transfer checks, on all 15 shapes,
P(z,1)=(1+z)^N, P(z,0)=1+z^N, spin-reversal symmetry and agreement with F(b).
At zero coupling, the exact count data give <B>=0 and Var(B)=E.

Using the independent polynomial, checks recompute Var(B) exactly in
Q(sqrt(2)), in the embedding sqrt(2)>0. A separate 600-bit logarithm gives
independent heat enclosures. For every entry, these enclosures lie strictly
inside the interval represented by the 100-significant-digit serialization.
The derivative formula in the document is also evaluated with 600-bit balls
and agrees with these values. Finiteness and accuracy are checked before any
ball comparison. The 2x2 exact variance is 40/9, giving
c_22=(5/18) log(1+sqrt(2))^2.

Known-answer controls precede the tests: the four-cycle cut polynomial is
2+12b^2+2b^4, its even-subgraph polynomial is 1+t^4, and its full spin count is
checked. A one-bond system, outside the stored domain, gives
c=K_c^2 sech(K_c)^2/2. Both independent methods pass these controls.

`agents/table-build/dry_run.py` was run through the required `agents/sage.sh`
wrapper. It found 15 entries, no exactness or prose failure, no exact numbers
disguised as decimals, and named Sage imports. The shared `agrees_with` helper
also compared exact coefficient arrays, and `exactness` checked both arrays
and real-ball values. No `sage.all` import is used.

## Precision, size and runtime measurements

- Working field: 429 bits, including 96 guard bits beyond 100 decimal digits.
- Minimum measured relative accuracy: 416 bits (about 125 decimal digits).
- Independent field: 600 bits; every independent result exceeds 500 accurate bits.
- Stored values: 100 significant digits; longest decimal is 102 characters.
- Dry-run ball display: at most 145 characters; approximate block size 2.8 KiB.
- The full initial independent run took 12.889 seconds after Sage startup.
- Environment: SageMath 10.9, Python 3.12.3, numberdb 0.1.10, gmpy2 2.3.0.

The first attempt used an unsupported `rel_accuracy_bits` method name. This
Sage exposes `RealBall.accuracy()`. The corrected checks ran in full; there
was no numerical disagreement or precision reduction. Raw run logs are
preserved in the build-work directory. This file describes pre-fill evidence;
the build handoff separately records authenticated readback, full generator
verification and the website audit.