back to table · edit · history · where entries came from · files · download
5899 bytes, as of the version from 2026-10-28 23:47 (current). Recorded here, not run.
# 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.
## Authenticated readback and final audit
After the single fill, `verify(sample=None)` returned 15/15 matched, with
zero differing, missing or extra entries. The entire independent checks.py
run was repeated on the authenticated API document and passed for every
stored decimal, including the explicit four-cycle closed form. The selected
identities and their lexicographic order exactly match the generator.
`readback-result.json` and its full console log are retained with the run.
The first readback attempt recognized annotated leaves but not the bare
string leaves returned in this document. Its selection assertion stopped
before any comparison. The reader now handles both shapes, and the complete
rerun passed. No numeric value was changed.
The website audit reports `clean: true` and an empty findings list. Its only
earlier finding concerned definition length; moving the graph and coupling
conventions into Comments resolved it. The Sage documentation link was also
corrected to its verified rings_numerical address. The final attachments are
read back byte-for-byte and their SHA-256 values retained in the handoff.