RERUN_LOG.txt -- re-runs of 10 October 2026, made when the note was written
(Python 3.13.5 with python-flint 0.9.0, gmpy2 2.3.2, mpmath 1.3.0, sympy 1.14.0, numpy 2.5.3, scipy 1.18.1; macOS,
one laptop; one process at a time, at low priority, while other jobs were running on the machine)

"identical": the new output is byte-identical to the recorded file.  "identical up to times": identical after
removing running times and the lines which the shell of the original run had appended to a recorded file.
"passed": the program ended with "TOTAL failures: 0".  "reproduced": the stated number occurs in the new output.

Part 1.  Output of `sh run_quick.sh` (943 seconds).

== writing_stage/ (program written with the note)
passed                check_paper.py (TOTAL failures: 0)
identical             writing_stage/check_paper_output.txt
   [23 s since start]
== original/ (the programs of the note)
identical             original moments_fock_N20.txt (moments from the definition)
identical             original moments_fock_N36.txt (moments from the definition)
identical             original moments_fock_N44.txt (moments from the definition)
   [92 s since start]
identical             original moments_sphere_N44.txt (pivot model, fractions.Fraction)
identical             original moments_sphere_N100.txt (pivot model, fractions.Fraction)
   [115 s since start]
identical             original moments_sphere_upto_N306.txt (rebuilt from the log of the long run)
identical             original integrality_check.txt
identical             original certificate_B.txt (Sturm)
   [116 s since start]
identical up to times original enclose_atom.txt (Theorem 1.2(d): m_0..m_44, m_0..m_200, m_0..m_306)
   [147 s since start]
identical             original window_certificate_N200.txt (K = 100)
identical             original window_certificate_N306.txt (Theorem 1.4, K = 152)
   [199 s since start]
identical             original check_antisymmetric.txt
identical             original guess_recurrence_N306.txt
   [351 s since start]
identical             original identify_c.txt
identical             original check_supersolution.txt (floating point)
   [369 s since start]
identical             original jacobi_analysis_N306.txt (floating point, 80 digits)
   [488 s since start]
== verification_run_A/
identical             A direct_moments_N44.txt (moments from the definition)
passed                A direct_moments.py self-checks
identical up to times A bimonotone_count.txt (Definition 8 of the source, n <= 6)
identical up to times A model_B_n42.txt (pivot model against the direct cumulants)
   [515 s since start]
identical             A check_intertwining.txt (Lemma 8.1 and the intertwining relation, symbolic)
identical             A mutation_test.txt
   [519 s since start]
identical             A certificates.txt (Certificates A and B)
identical             A extra_checks.txt
identical             A model_moments_N160.txt (moments from the cumulants of its long run)
identical             A jacobi_enclosure_N44.txt (enclosure from m_0..m_44)
identical             A jacobi_enclosure_N160.txt (enclosure from m_0..m_160)
identical             A compare_with_claim.txt
identical             A galerkin_summary.txt (table from the recorded Galerkin runs)
   [533 s since start]
identical up to times A lemmaA_check.txt (floating point)
reproduced            A discrete_fock.py 12 2 (top eigenvalue 2.58317083..., as in the recorded table)
   [566 s since start]
== verification_run_B/
identical             B a_counts.txt for 2n <= 16 (Definition 8 of the source, subset DP)
identical             B a_counts.txt for 2n <= 12 (factorized count)
identical             B a_counts.txt for 2n <= 10 (literal enumeration)
   [570 s since start]
identical up to times B b_fock_K22.txt (moments from the definition, to m_44)
identical up to times B b_fock_K24.txt (moments from the definition, to m_48)
   [638 s since start]
identical             B c_literal_N46.txt (pivot model, literal implementation)
   [643 s since start]
identical             B c_fast_N320.txt (pivot model, fast implementation, k_2..k_320)
   [673 s since start]
cumulants: fast implementation k_2..k_320, file of the note k_2..k_306; equal on the 153 common indices 2..306: True
moments rebuilt from the fast cumulants by m_N = sum_j k_j m_(N-j): equal to the 154 moments m_0..m_306 of the note: True
ALL EQUAL
identical             B compare_routes.txt (three routes, source table, files of the note)
   [674 s since start]
identical up to times B d_enclose_atom.txt, all blocks up to k_306 (Theorem 1.2(d))
   [759 s since start]
identical             B e_certificate_B.txt (Certificate B: own Sturm sequence, interval subdivision)
   [760 s since start]
identical up to times B f_window_certificates.txt (Theorem 1.4, K = 100 and K = 152)
   [860 s since start]
identical             B g_jacobi_N306.txt (Jacobi parameters exact; Gauss nodes floating point)
   [865 s since start]
identical up to times B i_guess_recurrence_N560.txt (no recurrence of the listed sizes)
identical up to times B j_remarks_test.txt
identical up to times B j_antisymmetric_test.txt
identical up to times B k_intertwining_test.txt (intertwining relation on 455 monomials)
identical up to times B l_identify.txt
   [872 s since start]
identical up to times B m_beta_fit.txt
identical             B beta_k_N560_30digits.txt (Jacobi parameters beta_1..beta_280)
   [896 s since start]
identical up to times B h_sector_test.txt (exact Rayleigh ratios for other start vectors)
   [904 s since start]
DIFFERENT             B e_lemmaA_test.txt (floating point)
   [943 s since start]
== done: 1 comparison(s) not identical; total time 943 s

Note on the one line "DIFFERENT" in part 1: the recorded file verification_run_B/outputs/e_lemmaA_test.txt ends
with a line "done", which the shell of the original run had appended; the new output does not have this line.
All other lines, that is, all numbers, are identical.  The comparison function of run_quick.sh was then extended
to ignore such a line, and the comparison of the two files was repeated:

identical up to times B e_lemmaA_test.txt (floating point)

Part 2.  Output of `sh run_long.sh` (2548 seconds).  The four window certificates with K = 278 took 421, 428, 437
and 433 seconds; the fast implementation of the model to k_560 took 366 seconds, the enclosure from k_2..k_560
153 seconds, and the program of the note to m_200 (with gmpy2) 159 seconds.

== verification_run_B/, long programs
identical             B c_fast_N560.txt (pivot model, fast implementation, k_2..k_560)
   [366 s since start]
identical up to times B d_enclose_atom.txt, last block (enclosure from k_2..k_560)
   [519 s since start]
identical up to times B f_window_certificates_K278.txt (windows with K = 278, m_0..m_556)
   [2239 s since start]
identical             B g_jacobi_N560.txt (Jacobi parameters to k = 280 exact; Gauss nodes floating point)
   [2311 s since start]
identical up to times B h_sector_deep.txt
   [2389 s since start]
== original/, the pivot model to m_200
identical             original moments_sphere_N200.txt (pivot model to m_200)
   [2548 s since start]
== done: 0 comparison(s) not identical; total time 2548 s

Not run again (recorded outputs of long runs; see README.md): the run of the program of the note to m_306
(original/outputs/moments_sphere_N320.err, 28 minutes); the run of verification run A to k_160
(verification_run_A/outputs/model_B_cumulants_long.txt, 23 minutes); its Galerkin truncations of large dimension
(verification_run_A/outputs/discrete_fock_all_runs.txt; only `discrete_fock.py 12 2` was run again); the counts of
verification run B for 2n = 18 and 20 (verification_run_B/outputs/a_counts_N18_N20_by_first_partner.txt).
