# files/ggH — change log

## 2026-09-06 — ggH-evaluate.py: `--sheet +i0`, the physical region s > 0 by the Feynman s → s + i0 continuation along 0 → i → s+i → s, gated at three points against the paper's iterated-integral definition continued the same way (≥ 57 digits, real and imaginary parts); files/ggH MANIFEST.sha256 and this changelog created

- ggH-evaluate.py: a new sheet option. The default `--sheet euclid` is the served
  evaluation, byte for byte: every pre-existing unit of the script is identical with
  all strings masked (33 of 34 units; the `__main__` dispatch is the only changed
  unit, the module docstring the only changed text; 28 units added:
  PHYSICAL_REFERENCES, SHEET_PATH_H, SHEET_PATH_DELTA, SHEET_PATH_ETA, SHEET_SCAN_N,
  PHYS_GATE_BAR, PHYS_GATE_DPS, PHYS_GATE_MARGIN, _ELLIPK_JUMP_SIGN, _theta,
  _r1_cont, _r2_cont, _sqab_cont, _root4_cont, _ellipk_jump_sign, _ellipk_above,
  _zarg_cont, varpi0_cont, K2_cont, _build_rect_path, _path_scan, _G_path,
  evaluate_physical, _phys_bar, _phys_components, _mutate_physical_refs,
  _run_physical_gate_demo, _physical_pair_demo), and the served tiers — the default
  run, `--dps 45`, `--point -0.6 0.9`, `--point -53/70 1/3 --dps 60`, `--sheet
  euclid` — print the served lines byte for byte after masking stamps and walls (5
  pairs, stdout and stderr); `--help` gains the new options only (29 differing
  lines, no served word removed).
- `--sheet +i0 --point S M2` (s > 0, 0 < M² < 4): G1, G2 at s + i0, complex,
  continued from the Euclidean axis along the rectangle 0 → iH → s+iH → s (H = 1) in
  the upper half s'-plane. Every multi-valued factor of varpi0 and K2 is continued
  by a continuous-argument rule (varpi0_cont, K2_cont: sqrt(−s'), sqrt(4−s'), the
  product sqrt(s'−a) sqrt(s'−b) and its fourth root, a = (M+2)², b = (M−2)²; the
  served principal branches are the upper-half-plane limits, and the principal
  fourth root's cut on Re s' = M²+4 is replaced by the continuous-argument root);
  ellipk stays principal, a dense pre-scan (400 samples per segment) asserts its
  argument never crosses the cut (1, ∞) on the path (0 crossings at every gate
  point, printed), and a numerically real argument on the cut is put on its +i0 side
  explicitly. Each straight segment goes through the served certified quadrature
  `_quad_refine` unchanged (its certificate, endpoint clip and clip bias),
  parametrized on [0, 1]; the printed bound is the sum over the three segments.
  Refused by name (exit 2): s ≤ 0 (the Euclidean sheet is the default), M² ≥ 4 (not
  implemented), M² ≤ 0, `--sheet +i0` without `--point` or `--gate`.
- `--sheet +i0 --gate`: three physical-region points vendored with the strings of
  the independent side — the source paper's iterated-integral definition (Eqs
  3.21/3.22 + 3.39–3.42) continued along the same path, K by the complex AGM,
  mp.quad, dps 50 — and gated per component (G1.re, G1.im, G2.re, G2.im) as a
  RAISING gate at 57 digits, the class of the cross floors of record; the strings
  carry 57–58 significant digits and the measured agreement is capped there. The
  gate demo runs at its own precision `--gate-dps` (default 60, the precision of
  record), then the pair dps 30 / 60 at the first point with the raw self-agreement
  gated at 32 digits (the served doubling rule).
- Measured (one process, a shared host under load, loadavg 115.13 118.52 137.96 at
  launch, CPU quota 200%): `--sheet +i0 --gate` at dps 60, (2, 9/10): G1.re 58.00,
  G1.im 57.73, G2.re 58.00, G2.im 58.00 (floor 57.73 at G1.im; of record 57.73);
  certified |err| ≤ 2.67e-71 / 2.53e-71 (G1 / G2; depths 6/7/6 / 6/7/6 per segment;
  2828 / 2828 evaluations); 5.83 s. `--sheet +i0 --gate` at dps 60, (9/2, 9/10):
  G1.re 58.00, G1.im 57.00, G2.re 58.00, G2.im 58.00 (floor 57.00 at G1.im; of
  record 57.94); certified |err| ≤ 1.74e-72 / 1.51e-72 (G1 / G2; depths 6/8/6 /
  6/8/7 per segment; 4243 / 4950 evaluations); 8.01 s. `--sheet +i0 --gate` at dps
  60, (9/2, 1/3): G1.re 57.84, G1.im 57.00, G2.re 58.00, G2.im 58.00 (floor 57.00 at
  G1.im; of record 57.84); certified |err| ≤ 2.29e-77 / 2.29e-77 (G1 / G2; depths
  7/8/6 / 7/8/7 per segment; 4950 / 5657 evaluations); 9.18 s. Worst floor 57.00 at
  s9o2_M9o10 G1.im; the pair at (2, 9/10): dps 30 → G1.re 58.00, G1.im 57.73, G2.re
  50.88, G2.im 50.19, dps 60 → G1.re 58.00, G1.im 57.73, G2.re 58.00, G2.im 58.00,
  raw self-agreement G1 88.16 / G2 50.74 (bar 32); exit 0, 34.27 s in all (twice:
  identical after masking). `--gate-dps 30` (bar 27): floors 50.19, 51.09, 51.45,
  exit 0, 22.68 s; `--gate-dps 50` (bar 47): floors 57.73, 57.00, 57.00, exit 0,
  32.73 s. `--sheet +i0 --point 2 9/10` (dps 30): 5.45 s, depths 6/6/6, 1956
  evaluations per G; the three points at `--dps 60`: 5.75 / 8.80 / 9.52 s; the 12
  printed 60-digit components equal the dps-60 values of record rounded to the
  printed length (12 of 12; 12 of 12 agree to ≥ 59 digits), the 12 30-digit
  components at dps 30 equal the vendored strings rounded (12 of 12).
- At the served default dps 30 the raw pair reaches the strings' cap on G1
  (57.7–58.0 digits) but only 50.19–51.45 digits on G2 (the certified bound there is
  1e-45 class), which is why the gate demo carries its own precision and its bar
  tracks it as min(57, gate-dps − 3).
- Controls: `--sheet +i0 --gate --mutate-physical` (one digit of one vendored string
  changed in memory) → the gate FAILS by name (19.82 digits at G1.re), exit 1
  (twice); on copies: one digit of the (9/2, 9/10) G2.re string changed in the file
  → FAIL by name at G2.re (24.90 digits), exit 1; the sign of the (2, 9/10) G1.im
  string flipped → FAIL by name at G1.im (-0.30 digits), exit 1. Port controls (21
  checks, PASS): on the Euclidean axis the continued blocks equal the served ones to
  < 1e-37; the from-above limits hold to < 1e-25; the rectangle walked to the
  Euclidean point (−137/100, 9/10) agrees with the served straight path to 41.29 /
  41.38 digits (G1 / G2) with |Im|/|G| 7.15e-122 / 1.5e-60 (bars 30 digits, 1e-38).
- Not implemented or not gated (refused by name where an input can reach it): M² >
  4; the −i0 side (the conjugate by definition, G(s − i0) = conj G(s + i0)); s
  beyond the sunrise threshold (2+M)² and the region Re s > M²+4 (handled by the
  continuous-argument root, no gate point there); M² = 1 (the puncture s_p =
  (4−M²)/3 meets the pseudo-threshold s = M²); the on-threshold point s = M² (varpi0
  singular; a limit, not evaluated); an independent continuation of varpi0 (both
  sides share Eq 3.15's algebraic form and the same path).
- New: MANIFEST.sha256 for the bundle (`sha256sum -c MANIFEST.sha256`; the three
  served files pinned, this changelog the unpinned companion) and this changelog.

## 2026-09-06 — ggH-evaluate.py: POINTS gains one entry of a new kind, the two-precision SELF-reference point (s, M²) = (−7/4, 3/5) — the evaluator's own dps-40 / dps-60 strings, `--point -7/4 3/5` gated against them as a reproduction check (bar min(dps, 40) − 8); never an AMFlow-derived reference; the served tiers byte for byte; MANIFEST.sha256 re-emitted

- ggH-evaluate.py: POINTS gains ONE appended entry of a new kind, 'self' (a dict
  beside the three served oracle tuples): (s, M²) = (−7/4, 3/5), m_t = 1 — a point off
  the three oracle points and off the source paper's own AMFlow points, inside the
  validated domain — carrying the evaluator's OWN dps-40 and dps-60 strings at that
  point, G1 = -0.03936246352578206459683847179562171076812 /
  -0.0393624635257820645968384717956217107681237454198546585688273, G2 =
  -0.05162437237007636315646158543991497971746 /
  -0.0516243723700763631564615854399149797174563427651996145210154, filed as a
  prediction before any other computation there; the two strings agree to 40.02 /
  40.15 digits (G1 / G2; the floor 40.02 at G1). It is a two-precision self-reference,
  never an AMFlow-derived reference; NOT ESTABLISHED: any AMFlow-derived value of G1,
  G2.
- The oracle demo iterates the oracle entries only (`_oracle_points()`: the three
  served tuples — the two reads of POINTS in `_run_gate_demo`), so the self point
  enters no oracle-agreement floor and no verification line: the default run, `--dps
  45`, `--point -0.6 0.9`, `--point -53/70 1/3 --dps 60`, `--sheet euclid`, `--sheet
  +i0 --point 2 9/10` and `--sheet +i0 --gate` print the served lines byte for byte
  after masking stamps and walls (28 of 28 pairs, stdout and stderr; the `[oracle
  floor] ... 22-24 significant digits` and `all legs >= min(dps, 24/24) - 8d` lines
  unchanged); every served unit is identical with all strings masked except POINTS,
  `_run_gate_demo` (those two reads) and the `__main__` dispatch (59 of 62 units; 6
  units added: SELF_REF_CAP, _oracle_points, _self_points, _self_point_at,
  _mutate_self_strings, _self_reference_check; none removed); `--help` gains the new
  option and the extended `--point` sentence only (no served word removed).
- `--point -7/4 3/5` recognises the stored point (`_self_point_at`: exact rational
  match, so `--point -1.75 0.6` matches too) and, after the served value lines, prints
  the self-reference by name — 'a two-precision SELF-reference (the evaluator's own
  dps-40 / dps-60 strings; NOT an AMFlow value; NOT ESTABLISHED against any
  independent reference)' — then gates the RAW run at the requested dps against BOTH
  stored strings as a REPRODUCTION check (`_raise_gate`, bar = min(dps, SELF_REF_CAP)
  − REF_MARGIN = min(dps, 40) − 8, each agreement capped at its string's length).
  Design: the served oracle form min(dps, len(string)) − 8 is NOT applied to this
  point — with the 61-digit dps-60 string it would read 52 digits at dps 60 as if
  independently certified, but the pair certifies 40 (the dps-60 string's digits
  beyond 40 are one run's own output, reproduced, not cross-checked), so the bar never
  rises with dps. The printed value is also compared byte for byte with the stored
  string of the same precision (dps 40 / 60; printed, not gated). Any other
  user-supplied point prints the served 'no stored oracle' line.
- Measured (one process, a shared host under load, CPU quota 200%, GNU time): `--point
  -7/4 3/5 --dps 40` → G1 vs the dps-40 string 40.00 d (cap 40; the printed 40-digit
  value equals the stored string: yes), vs the dps-60 string 60.00 d (cap 60); G2
  40.00 d (equals: yes) / 60.00 d; bar 32; PASS; 0.43 s (twice: identical after
  masking). `--dps 60` → G1 40.00 / 60.00 d (the printed 60-digit value equals the
  stored string: yes), G2 40.00 / 60.00 d (equals: yes); bar 32; PASS; 1.14 s (twice:
  identical after masking). At the served default dps 30: bar 22, floor 40.00 d, G2 vs
  the dps-60 string 49.74 d, PASS, 0.41 s; at dps 20: bar 12, G2 vs the dps-60 string
  40.97 d, PASS. The served bytes at the same point print the same value lines (the
  dps-40 / dps-60 strings themselves) under the 'no stored oracle' line.
- Controls: `--point -7/4 3/5 --dps 40 --mutate-self` (the 20th significant digit of
  the stored dps-60 G1 string changed in memory, +1 mod 10) → the gate FAILS by name
  (19.60 d at G1 vs the dps-60 string), exit 1 (twice; at `--dps 60` the same 19.60
  d); on copies: the 25th significant digit of the stored dps-60 G2 string changed in
  the file → FAIL by name at G2 vs the dps-60 string (24.71 d), exit 1 at dps 40 and
  60, while the default run of that copy is byte-identical to the cured default (the
  self strings enter no default line); the 15th significant digit of the stored dps-40
  G1 string changed in the file → FAIL by name at G1 vs the dps-40 string (14.60 d),
  exit 1. Refused by name (exit 2): `--mutate-self` without `--point`, at a point with
  no stored strings, or with `--sheet +i0`. `--point -0.6 0.9` and `--point -53/70
  1/3` still print the served 'no stored oracle' line.
- Not established, not gated: any AMFlow-derived value of G1, G2 at this or any point
  (the only G1/G2-bearing AMFlow gate needs the source paper's Laporta-to-canonical
  rotation, which is not on record); the self strings are the evaluator's own — a
  reproduction check, not an independent oracle, and they set no oracle floor.
- MANIFEST.sha256 re-emitted by the bundle's generator (the same three pinned rows;
  ggH-evaluate.py's row moves to the new bytes; `sha256sum -c MANIFEST.sha256` OK).

## 2026-09-09 — ggH-evaluate.py: the period varpi0 on the branch of Eq 3.15 as written (the principal root of the product under K's argument, regular at the cusp); the stored reference strings re-issued on that branch; G1 at (-7/4, 3/5) carries the one independent value (the AMFlow towers through the canonical rotation, 57 digits); `--sheet +i0` refused at this revision; MANIFEST.sha256 re-emitted

- THE DEFECT, by object: the served varpi0 (f216bb567e95b1fc) formed the square root under
  K's argument as the product of the two factors' separate principal roots,
  sqrt(s-(M+2)^2) sqrt(s-(M-2)^2) = -sqrt|A| on s < 0, so K's argument sat at 1 - z and the
  period was the logarithmically divergent one: varpi0 at M^2 = 3/5 and s = -1e-2 / -1e-4 /
  -1e-6 / -1e-8 / -1e-12 read 0.660508440279935 / 1.12938920728968 / 1.59603451664775 / 2.06263646140936 / 2.99583905836494.  Eq 3.15 as written (masters.tex
  L81 of the arXiv source, the K(z) convention at L86) takes the principal root of the
  PRODUCT, positive on s < 0: the same readings are 0.31687186373337 / 0.318295385407467 / 0.318309741163839 / 0.31830988473359 / 0.318309886183646 -> 1/pi =
  0.318309886183791, the period regular at s = 0, where the reference fixes its boundary constants and
  where this closed form's G_i(0) = 0 rests.  Both are periods of the same curve, and both
  epsilon-factorise the elliptic sector, which is why every check that shared the period
  (the stored strings, the nine-point agreement with the paper's defining integrals, the
  +i0 gate) passed on either branch.  The first object independent of the period -- the
  auxiliary-mass-flow towers of the family's thirty masters at (s, M^2) = (-7/4, 3/5)
  (Kira 30-master family, goals 40 and 60) read through the canonical rotation of
  arXiv:2501.14435 (ancillary mastersTopo2.m sha256-16 aad3e8f526531932, DOI
  10.5281/zenodo.14843619; the rotation record T sha256-16 16aa355cf8cb52f8) -- decides:
  the weight-one identity of the canonical basis holds on the regular branch and fails on
  the divergent one at the second digit (weight-1 receipt VERIFY_RECEIPT_OF_RECORD_w1_20260909T082255Z.json
  8a8e85a051c2ec9e; weight-0 receipt 3a3893e1d8382366; the tadpole extension
  92cdb8f58b6b7687), and G1 solved from the towers on the regular branch equals this
  closed form's G1 to 57 digits (the two-goal floor; controls failing by the printed
  coefficient).
- THE CURE: ONE mathematical change, in varpi0: `sq_ab = _csqrt((s - (Mr + 2) ** 2) * (s -
  (Mr - 2) ** 2))` under K's argument (the fourth root in the denominator was already the
  principal root of the product).  With every string constant masked, the function bodies
  that differ from the served file are varpi0 and _self_reference_check (the tower
  comparison below) and the `__main__` dispatch (the refusal below); the changed units are
  exactly __main__, _self_reference_check, assign:POINTS, assign:TOWER_CAP (added) and varpi0; every other unit is identical.  The kernels K1, K2, the one-fold form and the certified quadrature stand.
- THE STORED STRINGS RE-ISSUED (the data that follows from the cure): the three Euclidean
  reference tuples and the (-7/4, 3/5) self strings are this evaluator's own runs of
  2026-09-09 (dps 60 with the two-depth agreement against dps 90 recorded per point; the
  self pair at dps 40 / 60), from the values receipt REF_VALUES_cured_20260909T083451Z.json (sha256-16 54ce6e0780aa304e; the served
  wrong-branch values beside it in SERVED_VALUES_wrongbranch_20260909T083451Z.json, for the record only).  The paper's printed reference
  values at (s, M^2) = (-1/2, 9/10) are now G1 = -0.006031453..., G2 = -0.044362525... (dps 60; two-depth
  agreement 163.33 / 81.58 digits).  The planted-digit control: the 20th significant digit of
  the dps-60 G1 string at that point changed in memory -> its agreement with the dps-90
  value falls from 61.40 to 19.78 digits (FAIL by name at the bar 62).  The words that called
  the strings 'oracle' (the paper's Eqs 3.17/3.18 at dps 50) are gone: those values were on
  the superseded branch, and the nine-point, two-route agreement they recorded was a
  consistency of the closed form with its own definition on that branch, not an oracle
  match.  The demo's closing lines now state the two-depth floor over the nine points (81
  digits), the agreement with the paper's defining integrals there (61 digits, a separate
  transcription and quadrature), and the tower count.
- THE INDEPENDENT VALUE: the self dict at (-7/4, 3/5) carries G1_tower = -0.0358645527526950092775026693495725089948727420043683178959548 (57 digits of
  record; the weight-1 receipt key $.keys.PAP.(2)_row20_G1_solve_and_controls.G1_solved_by_goal.g60,
  N_int_floor 57); `--point -7/4 3/5` gates the run against it (a RAISING gate at bar
  min(dps, 57) - 8, beside the self-string reproduction gate); the cured G1 at dps 90 agrees
  with it to 61.36 digits.  G2 has no independent value yet (it does not enter the
  weight-one layer; the weight-two check is pending).
- `--sheet +i0` REFUSED at this revision (argparse error, exit 2): the continuation rule
  (_sqab_cont and its base sheet) and the three vendored physical-region strings were built
  from the superseded branch on the Euclidean axis; the physical sheet is re-derived from
  the cured branch in a separate succession with its own independent side.  The
  continuation code stays in the file for that succession.
- ggH-expression.md: the period line written with the product root and the branch stated;
  the Verification section restated (the independent check at the tower point; the
  evaluator's own consistency at the nine points).  _snippet.md unchanged.
- Superseded copy beside: superseded_f216bb567e95b1fc/ (the five served files byte for
  byte, SHA256SUMS).  MANIFEST.sha256 re-emitted in the bundle's own form (the three pinned
  rows; ggH-evaluate.py and ggH-expression.md move to the new bytes).

## 2026-09-09 — ggH-evaluate.py: G2 gains its independent value at (-7/4, 3/5) — the AMFlow towers one layer deeper (the weight-two identity of the canonical basis) fix G2 to 48 digits as the rotation's symbol, which is one quarter of the printed Eq 3.18; the file's G2 stays Eq 3.18 with the regular period; MANIFEST.sha256 re-emitted

- THE OBJECT: the deep towers (goals 40 and 60, raw eps^+1; 1e36786e60244a02 / 970668178ba1d049) through the same
  rotation, the weight-two layer of the canonical basis on rows 23 (the G2 row) and 19 (the
  G1 control), receipt VERIFY_RECEIPT_OF_RECORD_w2_20260909T085358Z.json fce73585b00fcbb4.  The identity on
  row 23 holds (51.8 / 64.4 digits at the two goals) only when the ancillary's G2 symbol is one
  quarter of the paper's printed Eq 3.18: the normalisation solved from the towers is
  0.25 to 29.8 digits (the receipts' print floor); with the printed normalisation the identity
  fails at 3 digits (FAIL by name: row 23 (weight 2) identity {'g40': 3.4, 'g60': 3.4} d, G2 solved-vs-evaluator {'g40': 0.2, 'g60': 0.2} d).  The reference's text (eq:g2), its kernel table and its notebook all
  define G2 as printed; its rotation and the kernels carrying the symbol use a quarter of it —
  a discrepancy inside the reference, stated here as fact.  G2 solved from the towers on row
  23 = -0.0096233967688779351300582794614977112... (two-goal agreement 48.3 digits, the count of record 48) = 1/4 x this file's G2 at
  the point (-0.0384935870755117405202331178459908451...); G1 re-established one layer deeper at 49 digits (row 19).  Every control
  fails by name (the G2 shift and digit controls by the printed coefficient; the kernel-order
  swap, the base-point shift, p = 2 and the superseded period).  The normalisation controls, each its own assembly (receipt key (7)): c = 1/4 PASS at 51.8 digits; c = 1/2, 1 (the printed prefactor), 2, 4 FAIL at 3.6 / 3.1 / 2.7 / 2.4 digits.
- THE PERIOD'S OVERALL NORMALISATION IS NOT FIXED BY THE TOWERS: with varpi0, G1 and G2 all
  scaled by the same constant the identities hold digit for digit (the lambda control:
  PASS at 51.8 digits, receipt key (7) LPI_W2), so the counts 57 (G1) and 48 (G2) are established RELATIVE TO the period as
  Eq 3.15 defines it (masters.tex L81, two pi in the denominator), which this file
  implements and which the paper's Eqs 3.17/3.18 use.  A record finding beside the quarter,
  attributed to nothing of ours: the reference's notebook varpi0 input cell carries ONE pi in
  its denominator where its Eq 3.15 carries two (its root under K's argument is the single
  root of the product, the regular branch); this file follows Eq 3.15 as printed, and the
  re-issued reference values at (-1/2, 9/10) stand as that definition.
- THE FILE: the self dict at (-7/4, 3/5) gains G2_tower (the symbol value, 48 digits, the
  factor 1/4 and its relation stated in words); `--point -7/4 3/5` compares this file's G2
  times 1/4 with it (a RAISING gate at bar min(dps, 48) - 8, beside the G1 gate); the
  docstring, the demo's closing lines and ggH-expression.md's Verification carry the G2
  clause.  No mathematical change: varpi0, K1, K2 and the quadrature are the 2026-09-09 branch
  succession's bytes; G2 as printed in the file is the paper's Eq 3.18 (no factor absorbed).
- Superseded copy beside: superseded_f216bb567e95b1fc/ (the served bundle, byte for byte, with its own
  CHANGES / MANIFEST / SHA256SUMS / README); the intermediate staging of 08:38 (evaluator 3b2bb2c6de333af2) was
  never served and is not beside this bundle.  MANIFEST.sha256 re-emitted by the bundle's generator of record.

- The values data file beside this bundle: REF_VALUES_cured_20260909T083451Z.json (served sha256 35c240df8c8b86c31686489f60d3e7d55138d75b03eae8807e3442551d869e0f), vendored_from the emitted receipt sha256 54ce6e0780aa304e380beb311a2603af6c12b1ff1ff25e6dcfbd146a28264c41 with its top-level host field re-cut to "withheld" and its five absolute path fields (evaluator.stageA_path, evaluator.served_path, twin.path, weight1_receipt.path, PRODUCER.script) re-cut to the basename plus the sha256 of the file each names, every other byte as emitted.  The page links it; MANIFEST.sha256 pins it.

## 2026-09-11 — MANIFEST.sha256: the ggH-evaluate.py role sentence names the two independent tower gates at (-7/4, 3/5) once, and the PRODUCER line names its generator; comment lines only, every sha256 row unchanged

- `MANIFEST.sha256` 7f65f53bcee14d23 -> 87dd819efb47aab4, re-emitted by gen_ggh_manifest_v4.py (= v3, the 2026-09-09 cure's generator, + two comment
  changes + `--v3-form`, which reproduces the served manifest except the stamp).  (1) The `ggH-evaluate.py` role sentence: the
  2026-09-09 cure inserted 'the self-check at (s, M^2) = (-7/4, 3/5) gates G1 against the auxiliary-mass-flow tower value (57
  digits) and G2 x 1/4 against the tower value of the rotation's symbol (48 digits; the quarter stated in the file)' but kept the
  earlier tail 'against the one independent value, G1 from the auxiliary-mass-flow towers through the canonical rotation of arXiv:2501.14435 (57 digits)',
  so the sentence still closed as if G1 were the only independent gate; the tail now reads 'against those two independent tower values (the auxiliary-mass-flow towers of the family through the canonical rotation of arXiv:2501.14435: G1 directly, G2 one layer deeper as the rotation's symbol)'.  The two figures stay
  where the inserted clause put them and are the file's own (TOWER_CAP = 57; the G2 tower entry's digits 48).  (2) The PRODUCER line
  named gen_ggh_manifest_v2.py although the v3 generator emitted the served bytes (its literal was not advanced); it now names v4
  and the lineage.  The four sha256 rows, the other three role lines and the companion line are byte for byte; `sha256sum -c
  MANIFEST.sha256` exit 0 (4 rows); `superseded_f216bb567e95b1fc/SHA256SUMS` exit 0 (untouched).
- `ggH-evaluate.py` (8bd237e643557bfd), `ggH-expression.md`, `_snippet.md`, `REF_VALUES_cured_20260909T083451Z.json` and the superseded copy:
  unchanged, not re-run (no script or data byte moves; `--help` on these bytes exit 0, 0:00.65).  `python3 -m py_compile` over the
  2 served .py: pass.
- NOT done here, stated: the `ggH-expression.md` role words ('the period varpi0 with its branch stated', the 2026-09-09 staging's
  wording) are left as served -- a wording call for the page owner, not a defect of fact.

## 2026-09-11 — _snippet.md and ggH-expression.md: G1, G2 worded as the source's defining integrals (arXiv:2501.14435, Eqs. 3.17–3.18) re-evaluated here, no longer as 'the eMPL closed form the paper deferred to future work' (four wording pairs); MANIFEST.sha256 re-emitted by gen_ggh_manifest_v5.py; no evaluator, value, data or pin change

- Why.  The page and the write-up (Sec. 2.12; Table 2 row 18, 'known (its Eqs. 3.17–3.18, re-evaluated)') describe G1, G2 as the two
  transcendental functions the source defines in its Eqs. 3.17/3.18, re-evaluated here as the one-fold integrals
  G_i(s) = int_0^s K_i varpi0 ds'; what the source leaves to future work is the elliptic-multiple-polylogarithm form of the
  canonical master integrals themselves, which is not attempted here.  The bundle's two prose files still carried the earlier
  wording ('the eMPL closed form the paper deferred'); this entry re-words them, byte-exact pairs, and nothing else.
- `_snippet.md` 2a87e86c44e8ad59d23ed2d035819548e7dde5f1f741c729661e919f5bdd76af ->
  a10ba9e7eb17fba6bb63d28b33e3cdcd2868da71f11e178430a660b2131c7e4f: line 1, 'The two elliptic masters of families 2 and 5 — computed in arXiv:2501.14435 as iterated integrals over bespoke elliptic kernels, and re-expressed here in the closed elliptic-polylogarithm form the paper deferred to future work —'
  -> 'The two transcendental functions $G_1, G_2$ of families 2 and 5 — defined in arXiv:2501.14435 (its Eqs. 3.17–3.18) and re-evaluated here —' (the sentence the page carries).  13 lines before and after; every other line byte for byte.
- `ggH-expression.md` c0c5afd5d1fb8cf0a5bea4658b702e93e36f41631de0bc8ff60789221cb4aa5c ->
  f616aed0f149ea1aacfe778e7e575af8e2f24f98455d2e43e47ac416ceea1420: line 1 (the title) ') — the eMPL closed form' -> ') — the source's defining integrals, re-evaluated';
  line 9 '(the eMPL closed form the paper explicitly defers to future work, Sec. 3.5),'
  -> '(the source's own definitions, its Eqs. 3.17/3.18, re-evaluated here; the eMPL form of the canonical master integrals themselves, which the source leaves to future work, is not attempted),';
  line 24 'These are one-fold elliptic multiple polylogarithms: the kernel is the'
  -> 'In the language of elliptic multiple polylogarithms each is a single iterated integral: the kernel is the'.
  85 lines before and after; every other line byte for byte (line 9 is not re-wrapped: 188 characters, the pair applied as given).
- `MANIFEST.sha256` 87dd819efb47aab4 -> c6820f91a7c8d8a9, re-emitted by gen_ggh_manifest_v5.py (= gen_ggh_manifest_v4.py, which emitted the previous
  manifest, + this leg: the `_snippet.md` and `ggH-expression.md` rows re-hashed; the `ggH-expression.md` role words
  'the one-fold closed form' -> 'the one-fold integral form (the source's Eqs. 3.17/3.18, re-evaluated)', since the old words paraphrased the retired title;
  the PRODUCER line carries the previous lineage text unchanged with a v5 clause naming this leg appended; `--v4-form` regenerates the previous manifest except the stamp).  The `ggH-evaluate.py` and
  `REF_VALUES_cured_20260909T083451Z.json` rows, the header, verify, evaluator-role, snippet-role, data-role and companion lines are
  byte for byte; `sha256sum -c MANIFEST.sha256` exit 0 (4 rows OK); `superseded_f216bb567e95b1fc/SHA256SUMS` exit 0 (6 rows OK; that copy is
  untouched -- its `_snippet.md` row names the copy's own file, which keeps the previous snippet bytes 2a87e86c44e8ad59).
- `ggH-evaluate.py` (8bd237e643557bfd): unchanged -- no value path, reference string, pin or tier moves; not re-run (`--help` on the bytes beside the
  re-worded files exit 0, 0:00.16).  `python3 -m py_compile` over the 2 served .py: exit 0.  `REF_VALUES_cured_20260909T083451Z.json`
  and the superseded copy: unchanged.
- NOT done here, stated.  (1) The evaluator's own text keeps the earlier wording at 3 sites (line 3 'evaluate the eMPL closed form and check it against packaged refere...'; line 5 'Closed form (BootLoops, DE-transport closure of the form deferred ...'; line 552 'gg->H eMPL closed form: G_i(s) = int_0^s K_i varpi0 ds'   (dps={dp...'):
  a byte move of `ggH-evaluate.py` is outside this entry (no value question is involved) and waits for a later succession of that
  file; the MANIFEST role line for `ggH-evaluate.py` likewise still says 'from the one-fold closed form G_i(s) = ...'.
  (2) `ggH-expression.md` keeps 'closed form' as a plain noun for G_i(s) = int_0^s K_i varpi0 ds' at line 68, line 79, line 80 (its verification
  section); those lines are not among the ordered pairs.  (3) The page itself (outside this bundle) already carries the new sentence.