# Ancillary files

Data accompanying "Irreducible multiple zeta values of depth three in four-edge modular graph functions" (M. D. Schwartz): the complete Laurent
polynomials of the two-vertex four-edge modular graph functions at weights 7-12 (the main text prints four of the forty-nine and
Appendix E five more; all are here), the 83 formulas for the single-valued depth-three multiple zeta values at weights 11-21
(Appendix C.5 prints eleven; all are here), and the single-valuedness certificates of the twenty-six deep coefficients of
transcendental weights 19 and 21 (Section 4.5 of the paper; one of them is printed as Eq. (69); all are here) together with the f-alphabet
images of the basis generators (Appendix C.2) and a script that verifies the certificates by substitution.

## Files

| file | sha256 (first 16) | size |
|---|---|---|
| check_svcert_anc.py | 0e029125e44c9409 | 17691 bytes |
| laurent_C4_w7-12.json | 3fe88bf3ffde9eab | 113540 bytes |
| laurent_C4_w7-12.tex | 0ce08e2607e9a1d7 | 86978 bytes |
| laurent_C4_w7-12.txt | 713325fcdd465ea3 | 67762 bytes |
| supplement.tex | 2c6e1775a2f38eb3 | 1211 bytes |
| sv_certificates_w19-21.json | 9f5504a545911621 | 141353 bytes |
| sv_certificates_w19-21.txt | ff4f00b69fb144a1 | 88610 bytes |
| zsv_depth3_w11-21.json | eb9b9960859794c9 | 64525 bytes |
| zsv_depth3_w11-21.tex | 0678859427a4d357 | 61747 bytes |
| zsv_depth3_w11-21.txt | e92b4d1c15dd3b62 | 45541 bytes |

- `laurent_C4_w7-12.txt` / `.json`: all 49 functions C_{a,b,c,d}, a>=b>=c>=d>=1, a+b+c+d = w = 7..12; 740 coefficients, one for
  each Laurent power y^k, 1-w <= k <= w, to which at least one term of the sector sums (Eq. (18) of the paper) contributes by the power
  count (Eq. (24)); Figure 1 of the paper shows which powers these are. Of the 740, 724 are nonzero (one line / one JSON entry each)
  and 16 cancel exactly (omitted here; the cells marked zero in that figure). A power absent for a listed function has vanishing coefficient.
- `zsv_depth3_w11-21.txt` / `.json`: the 83 values zeta_sv(a,b,c), a,b,c odd >= 3, a+b+c = 11..21 (3,6,10,15,21,28 per weight),
  each labeled `extracted` (61) or `derived` (22), as in Table 2 and Appendix C of the paper.
- `laurent_C4_w7-12.tex`, `zsv_depth3_w11-21.tex`: the same data typeset (LaTeX fragments, the typeset appendix sources of the paper; 45 numbered displays labeled
  LP<abcd>, the four functions shown in the main text excluded; 83 formulas grouped by weight). `supplement.tex` wraps both
  into a stand-alone document: `pdflatex supplement.tex`.
- `sv_certificates_w19-21.json` / `.txt`: the 26 single-valuedness certificates, the 49 weight-19/21 zeta_sv values in the reduced basis,
  42 double-shuffle reductions and the f-alphabet images of the 32 basis generators (section 'Single-valuedness certificates' below);
  `check_svcert_anc.py` verifies them from the JSON files alone (`python3 check_svcert_anc.py`).

## Conventions

- y = pi Im(tau); C_{a,b,c,d}(tau) = sum_k c_k y^k + O(e^{-2y}); c_k has transcendental weight w-k.
- Multiple zeta values in the ascending convention zeta(n_1,...,n_r) = sum_{0<k_1<...<k_r} k_1^{-n_1}...k_r^{-n_r}
  (Eq. (8) of the paper; the convention of Brown, arXiv:1309.5309, eq. (7.4)). zeta(n) is a single zeta value;
  even zeta values are written as powers of zeta(2).
- Text syntax: `*` product, `^` power, integer coefficients over one common denominator per coefficient, `( ... )/den`,
  exactly as computed (not reduced to lowest terms). Readable by any computer-algebra system after renaming `zeta`.
- Every c_k with k != 3-w is a polynomial in odd zeta values. The coefficient c_{3-w} (transcendental weight 2w-3) has depth
  at most three and is given reduced modulo the regularized double-shuffle relations of depth <= 3; the depth-three
  generators that occur are, by weight,
    11: zeta(3,3,5)
    13: zeta(3,3,7), zeta(3,5,5)
    15: zeta(3,3,9), zeta(3,5,7)
    17: zeta(3,3,11), zeta(3,5,9), zeta(5,3,9), zeta(3,7,7)
    19: zeta(3,3,13), zeta(3,5,11), zeta(5,3,11), zeta(3,7,9), zeta(5,5,9)
    21: zeta(3,3,15), zeta(3,5,13), zeta(5,3,13), zeta(3,7,11), zeta(5,5,11), zeta(7,3,11)
  (1,2,2,4,5,6 of them, the Broadhurst-Kreimer numbers); the depth-two generators that occur are zeta(3,5), zeta(3,7),
  zeta(3,9), zeta(3,11), zeta(5,9), zeta(3,13), zeta(5,11).
- zsv file: zeta_sv(a,b,c) = 2 zeta(a,b,c) + correction. Through weight 17 the correction contains only zeta(2)^j times
  odd-zeta monomials and single zeta values times depth-two values; from weight 19 it also contains depth-three values of the
  same weight (kept apart from the leading term even when zeta(a,b,c) itself recurs), and at weight 21 also zeta(2)^j times
  depth-two and depth-three values. The (5,3,5) entry is Eq. (34) of the paper with zeta(8) = (24/175) zeta(2)^4.
- To pass from a main-text expression for c_{3-w} in terms of zeta_sv(a,b,c) (e.g. Eq. (33)) to the form in the
  Laurent file, substitute the zsv formulas and reduce with the double-shuffle relations; for the functions of Table 1 the
  coefficient of a depth-three generator zeta(a,b,c) in the Laurent file is twice the tabulated coordinate on zeta_sv(a,b,c).

## Single-valuedness certificates

- `sv_certificates_w19-21.json` / `.txt`: for each of the 26 deep coefficients c_{3-w} of transcendental weight 19 (the eleven
  functions of weight 11) and 21 (the fifteen of weight 12), the exact decomposition c_{3-w} = sum_i q_i zeta_sv(a_i,b_i,c_i) +
  (odd-zeta monomials) with rational q_i that certifies its single-valuedness (Section 4.5 of the paper; the C_{8,1,1,1} entry is
  Eq. (69)): eleven terms at weight 19, all zeta_sv values, and fourteen at weight 21, eleven zeta_sv values and three odd-zeta
  monomials. A decomposition is not unique, the zeta_sv values of one weight being rationally related; the file gives the one
  obtained by the elimination described in the paper.
- The same file carries what is needed to check a certificate by substitution alone: the 49 values zeta_sv(a,b,c) of weights
  19 and 21 rewritten in the reduced basis in which the Laurent file gives c_{3-w} (`zsv_reduced`), and the reductions to that
  basis of the 42 multiple-zeta-value monomials of the weight-19 and 21 formulas of `zsv_depth3_w11-21` that are not basis
  monomials (`reductions`; consequences of the regularized double-shuffle relations in depth at most three). Substituting
  `zsv_reduced` into a decomposition returns the Laurent coefficient monomial by monomial; substituting `reductions` into a
  formula returns its `zsv_reduced` entry. The reductions are the one ingredient taken from the computation rather than
  re-derived by the check.
- It also lists the f-alphabet images phi(x) of the 32 depth-two and depth-three generators of the basis through weight 21
  (`phi`; word -> rational coefficient), computed by the decomposition rule Eq. (67) of the paper. Conventions: a key
  `f3 f5 f11` is the word f_3 f_5 f_11, a leading `f2^j` a power of the commuting generator f_2; phi(zeta(n)) = f_n, phi(zeta(2)) = f_2,
  phi multiplicative with the shuffle product. The words are the reversals of Brown's: the last letter is the one a derivation
  strips, and in this orientation the single-valued map Eq. (10) reads sv(w) = sum_{w=uv} (u reversed) shuffle v, sv(f_2) = 0.
  One normalization is fixed beyond Brown's formula, the absence of a pure power of f_2 in the image of each even-weight generator;
  no formula and no certificate in these files depends on it. With the table, phi(zeta_sv(a,b,c)) = sv(phi(zeta(a,b,c))) holds
  word by word for all 49 weight-19 and 21 triples, which the check script verifies.
- To verify: `python3 check_svcert_anc.py --anc .` (exact rational arithmetic; uses only the three JSON files) performs the two
  substitutions for all 26 certificates and all 49 values, the phi/sv consistency check, the term counts, and, given the
  paper source, the comparison of the C_{8,1,1,1} entry with Eq. (69).

## Generation and checks

All files are written by one script from the exact output of the symbolic reduction (Laurent data) and from the stored
formula tables (zsv data), the same inputs from which the typeset appendices are generated. Before writing, the script
re-parses each text and JSON file into exact rationals and compares it with the source data monomial by monomial (49 functions,
740 coefficients; 83 formulas), checks the counts above, checks that the C_{2,2,2,2} record reproduces the nine coefficients
printed in the paper, checks that the .tex fragments are identical in body to the typeset appendix sources, and builds the certificate
file from the exact records of the membership computation, confirming while doing so that every decomposition reproduces its
Laurent coefficient and every reduced zeta_sv value agrees with the computation's own reduction; it then runs `check_svcert_anc.py`
on the result (all checks pass). Generated 2026-09-28T16:39:13Z.