Non-integrable Ising chain at hx = J with longitudinal disorder

Outcome

TfP verified Submission sub_xth78vw5cj (method.py, art_t8ol7w6qyi) in run vrn_0ipx1gn2us. Score: 1.5627e-15 mean per-instance max |error|, against a baseline of 0.1828. The larger-size sanity run passed, and the sandbox stage took about 249 s in total. The 20-site probe error is reported separately by the checker; locally it was 1.8e-15.

Approach

• Chains with n ≤ 20: exact state-vector dynamics built from the instance terms. Z/ZZ strings form a diagonal energy vector, and X fields are applied as axis flips. exp(-iHt) uses a Chebyshev/Bessel expansion with a 1e-16 coefficient cutoff. One expansion covers each 2.0-time-unit window of outputs. The spectral bounds come from 30 real Lanczos iterations plus a margin of 5% + 1.0, clipped to the Gershgorin bounds. A norm guard falls back to Gershgorin bounds. The recurrence is split into 4 chunks over the two leading qubits and run on 4 threads.
• Chains with n > 20 (only the 32-site sanity run): second-order TEBD with chi ≤ 64, dt = 0.05 and a wall-clock guard.
• No training, fitting, or lookup of reference traces.

Key learnings

• Runtime, not accuracy, is the whole problem. A naive per-step expansion took 30 s per 18-site case, which overruns the budget. Chunk threading brought it to 10.5 s. Multi-time windows brought it to 5.5 s, so the suite took 57 s locally against a 240 s budget. The probe took 22 s against 60 s.
• On a fair start, Lanczos bounds are about 35% narrower than Gershgorin bounds, which cuts the number of matvecs proportionally.
• TEBD with chi = 64 is good to 7e-4 for t ≤ 5 but reaches about 0.045 by t ≈ 10 on this chaotic chain. Use it only for the sanity run.

Environment notes

• MCP resources/read failed client-side (missing ttlMs/cacheScope), so the Skill package could not be read. I fetched the reference inputs via their download_url and checked the hashes; all matched.
• The tfp verify preflight was skipped because the workspace rules forbid downloading and running scripts.

Advice for the next attempt

Exact dynamics already reaches machine precision here. Remaining room is only in speed or memory (for example numba or a Krylov variant), or in a better approximate method for chains larger than 20 sites.

Phase finished. Submission sub_xth78vw5cj binds method.py (art_t8ol7w6qyi, sha256 a28b7422…, identical to the locally benchmarked file). Verification vrn_0ipx1gn2us was queued at the time of writing.

Speed-ups that mattered:

1. One Chebyshev expansion shared across all output times in a 2.0-unit window (4 outputs). Each extra output costs one axpy per order instead of a fresh expansion with its own ~20-term overhead. This cut runtime about 2× (10.5 s → 5.5 s per 18-site case).
2. The state is chunked over the 2 leading qubits, with 4 threads (numpy releases the GIL). Each worker writes only its own chunk. Flips on the leading qubits read the partner chunk.
3. Lanczos runs on a real start vector (H is real), halving its cost.

TEBD fallback check (own harness tebd_check.py): on scored case 0 (18 sites), chi ≤ 64 and dt = 0.05 give max error 7e-4 for t ≤ 5, 0.043 for t ≤ 10, and 0.045 overall. A synthetic 32-site instance ran in 74 s, finite and within bounds.

The tfp verify preflight was skipped: the workspace rules forbid downloading and running scripts.

Local benchmark (4 vCPU container, numpy 2.4.6 / scipy 1.17.1, own harness bench.py comparing simulate output with traces.cases[*].trace):

• Naive version (complex128, one Chebyshev expansion per 0.5 time step, single-threaded numpy axis-flip matvec): max abs error per instance 5e-16 – 2e-15 on all 10 scored 18-site cases, but ~30 s per instance (302 s total > 240 s budget).
• Chunk-parallel version (state split over the 2 leading qubits, 4 threads, fused recurrence out = 2Hs u1 - u0, scaled diagonal folded in): ~10.5 s per instance, same accuracy.
• Spectral data: Lanczos extremal estimates ~[-24.1, 23.7] at n=18 and ~[-26.8, 26.0] at n=20; Gershgorin bounds are ~50% wider, so Lanczos bounds (+5% +1.0 margin) cut matvec count accordingly. Single-thread H apply: 17 ms (n=18), 66 ms (n=20).

Next: multi-time Chebyshev windows (one expansion serving several output times), real-arithmetic Lanczos, and a norm guard that redoes a step with Gershgorin bounds if the expansion is not unitary to 1e-8 — to fit the 20-site probe in 60 s with margin.

No prior Attempts or Notes on this Problem (search_notes / list_attempts empty).

Environment issues: the Skill package (skv_jd5ndfn6y3) and reference Resources could not be read through the MCP resource tool in this client (client-side schema error on resources/read: missing ttlMs/cacheScope). I fetched the three reference inputs via their signed download_url instead and checked sha256 against the bound content hashes (all match). Interface taken from the problem statement + verifier contract: PRIORS dict and simulate(instance, times) returning (times x sites); instance dicts in traces.json carry terms (coeff, {site: pauli}), initial_state.bits (bit 0 => +1), n_sites.

Plan: the scored suite is 18 sites (2^18 amplitudes), so exact dynamics is affordable. Build H from terms generically (diagonal Z/ZZ part as an energy vector, X fields applied by axis flips), propagate with a Chebyshev expansion of exp(-iH dt) between output times, using Lanczos-estimated spectral bounds. For the 32-site runtime/sanity instance, exact is impossible; use a 2nd-order TEBD MPS with capped bond dimension and a wall-clock guard. No training, no lookup of reference traces.