# Numerical evidence for T688

Build run: 20261109T110159Z. This is builder evidence, not an independent
critique or approval. All calculations used agents/sage.sh in the designated
Sage environment. Python 3.12.3, Sage 10.9, numberdb 0.1.10.

Instruction manifest:
`agents/runs/20261109T110159Z-build-skills/manifest.json` (attached as
`skill-manifest.json`). Both archived local and live instructions have SHA-256
`886390324dd1971e381a43cf3b46b822ab0bc67d62f31d8481e29ec79556746b`.
Both were read; they match byte for byte. Source choices follow these copies.

## Values and precision

All 100 values are exact Sage rationals. The table has all five target types
and degrees 1 through 20. There are no approximations, floating-point
coefficients or numerical error bounds to assert. A 100-digit decimal would
weaken an exact rational rather than improve it.

`agents/table-build/dry_run.py` computed the entire enumeration and passed
exactness, named-ring imports, decimal-disguise and entry-prose checks.
The largest written rational is 68 characters, at multidegree (5), d=19:

`272313733853214419087881850261769922004501925400113727301718750/6859`.

The actual flat-record YAML entries block is 8597 bytes. The reusable measure
helper's surrogate-key block estimate is 7.18 KiB; dry_run's longer diagnostic
keys give another estimate. These are size measurements, not a selection quota.

## Main computation

Explicit truncated arrays over QQ implement multiplication, reciprocal,
exponential and composition. With h=G/F, the computation forms

K(x) = kappa / ((1-C*x) F(x)^2 (1+x*h'(x))^3).

It obtains x(q) by iterating x=q*exp(-h(x)), with exact coefficients, then
composes K. The coefficient of q^d divided by d^3 is N_(ell,d). Reversion is
checked by composing the resulting inverse with q(x). Recomputing to degrees
24 and 28 agrees exactly through degree 20 for every target. This checks the
implemented truncation; no cancellation or discarded leading order is hidden.

## Separate second-period computation

The alternate implementation uses Python Fraction arithmetic and its own
series routines, without invoking the generator's arithmetic helpers. It
multiplies the finite products

A_m(rho) = product_i product_(j=1)^(ell_i*m) (j+ell_i*rho)
           / product_(j=1)^m (j+rho)^(r+4), modulo rho^3.

Let F,G,B be its coefficient series in rho^0,rho^1,rho^2. Put
h=G/F and A=B/F-h^2/2. The normalized second logarithmic period satisfies

y2/y0 = (log q)^2/2 + A(x(q)).

Hence K=kappa*(q*d/dq)^2(y2/y0), and Lagrange inversion gives

N_d = (kappa/d^2) [x^(d-1)] A'(x)*exp(-d*h(x)).

This avoids both the main Yukawa denominator formula and compositional
reversion. All 100 values agree exactly. Both calculations share the mirror
system and the established mirror theorem; the comparison is an implementation
check, not a new geometric proof or an independent dataset at degree 20.

## Independent geometry and controls

Before comparisons, nonzero controls check convolution, quotient and
exponential, including exp(x)=1+x+x^2/2+x^3/6 modulo x^4.
The Grassmannian method first reproduces 2875 for the quintic.

For a generic target in P^n, where n=r+3, the number of lines is

[u^n v^(n-1)] (u-v) product_i product_(j=0)^(ell_i)
                         (j*u+(ell_i-j)*v).

This is integration of the top Chern class of the direct sum of symmetric
powers of the tautological dual bundle on Gr(2,n+1). It computes all five
degree-one virtual counts independently of mirror periods:
2875, 1280, 1053, 720, 512. The symmetric-power construction and quintic
control are supported by Macaulay2 Schubert2, “Lines on hypersurfaces”:
https://macaulay2.com/doc/Macaulay2-1.20/share/doc/Macaulay2/Schubert2/html/___Lines_spon_sphypersurfaces.html.
These are generic line counts; special smooth members can have infinitely
many lines, without changing the virtual invariant.

Seventeen values agree exactly with the independently produced torus-localization
outputs of EnumerationCurves: degrees 1,2,3 for each of the five targets, and
degree 4 for the quintic and (2,4). See localization-controls.json and
source-evidence.md. For example N_(5,2)=4876875/8 and
N_(5,3)=8564575000/27. These are compared before multiple-cover subtraction.
Macaulay2 is unavailable in this environment. Its documented outputs were
transcribed and checked; its localization implementation was not run here.

## Identities and coordinate checks

* The partitions of 4 independently reproduce the complete five-target class.
* Factorial-period and first-logarithmic coefficients agree with the T679/T680
  hypergeometric definitions through degree 20: 210 exact coefficient checks.
  This checks z=C*x, all five scale constants, and the template 2.2.4 for (2,4).
* The Yukawa constant equals kappa for every target. The inverse mirror map
  satisfies q(x(q))=q through each computed truncation.
* All 100 Lambert-series coefficients extracted recursively are integers.
  Reassembling their divisor sums gives d^3*N_d at every degree.
* Independent trial-factorization Möbius inversion of every N_d agrees with
  the recursively extracted integer coefficients. This is an identity check,
  not the independent geometric validation of the GW values.

The machine-readable output is retained in offline-evidence.json and
postwrite-evidence.json in the run artifacts. The final read-back outcome is
recorded in readback-evidence.md, attached after the draft is filled. It must
be consulted for submission, verification and audit results.