# Weight-5 census clearing of the X(3,6) moment expansion, and a second exact derivation of (Q5, R5) Draft appendix material. All claims are exact-arithmetic statements unless explicitly labeled otherwise; every machine-checked step lists its artifact (paths relative to the weight-five record's own directory; those files are the record's working files and are not part of this bundle). Format and objects follow the weight-3/4 appendix (`PROOF_W4W3.md`, in this bundle), whose Lemmas 1-2 (ray-form lemma; ray-form coordinates x_1..x_14, common denominator D(x) = x_1..x_14 L15 L16 of degree 16) are reused verbatim — the fan, rays and kappa forms at weight 5 are identical. ## 1. Setting The weight-5 moment coefficient of the X(3,6) string integral expands as c_5(s) = sum_k W_k(s) C_k over 364 census slots: 357 numeric constants in 13 families (V1-V3; five 2-d pair families; Gd composites; TL/TG triples; DD, DT, TT 3-d composites; F4 4-d shapes), plus the derived slots K2, A = eta2*eta3, B = eta2*L2, and four EE slots (eta2 x recorded exact E_p), with K2 = (45/8) zeta5, A = (3/8) zeta2 zeta3, B = (1/8) zeta2 zeta3, EE_p = (e_p/2) zeta2 zeta3 exactly (`../w5_jul9/derivation_w5.md`). Each weight W_k(s) is a rational function, homogeneous of degree 1. **Lemma A (symbolic census).** For every subcone c and slot k there is an explicit polynomial n_{c,k}(x) of total degree 5 (in the F4 slots the four kappas cancel P_c exactly, so those numerators are k_1 k_2 k_3 k_4 s_t) with W_k(s) = sum_c n_{c,k}(x(s))/P_c(x(s)). *Machine:* 4814 per-cone numerators, 240914 terms (`s4_symcensus.py` -> `symcensus_w5.json.gz`); the assembled weights equal the RECORDED `census_w5.json` (fan-hashed; the file used by both the assembly and the relation-collapse computation) EXACTLY at s* for all 364 slots, and equal a parameterized verbatim copy of the census generator EXACTLY at two fresh random rational points (`s4a_gate.json`). Write T_k(x) := sum_c n_{c,k}(x) (D/P_c)(x), so W_k = T_k/D (degree 17 over degree 16, homogeneous of degree 1). ## 2. Theorem 1 (weight-function collapse; unconditional) The 364 polynomials T_k span a 147-dimensional space over Q. Explicitly, with the 147 pivot slots listed in `s4_relations.json.gz`, there are 217 dependency identities T_k(x) = sum_{p in pivots} a_{kp} T_p(x) identically in x, with exact rational a_{kp} (`s4_dependencies.json`). Consequently, identically in s, c_5(s) = sum_{p=1..147} (T_p(x)/D(x)) * v_p, v_p := value of the explicit direction-vector V_p, where V_p = sum_g c_{gp} g is an exact rational vector over the emission direction space (Section 3), computed by exact contraction of the engine table with the dependencies (no discovery step enters the proof). *Machine:* the 217 dependencies were DISCOVERED by modular evaluation (three 30-bit primes, 385 random points, identical pivot sets) and then each PROVEN by exact sparse expansion of T_k - sum_p a_{kp} T_p to the empty polynomial — 217/217 expansions identically zero, plain Fraction arithmetic, no sampling in the proof step (`s4_clear.py` -> `s4_report.json`); FORM 5 reproduces the three largest expansions and a nonzero control (`s4c_form_oracle.json`). Every identity USED downstream is in the verified 217-list. Linear independence of the 147 pivot T_p is certified at the modular-evaluation level only (three independent 30-bit primes, 385 points, identical pivot sets — a surviving dependency would have to vanish at all points mod all three primes); it enters only the per-pivot uniqueness reading of the corollary below, not the displayed identity. **Corollary (per-pivot value identities).** Granting only that c_5(s) = Q5(s) zeta5 + R5(s) zeta2zeta3 for SOME rational functions Q5, R5 in the span of the weight functions (the relation-collapse computation's verdict), linear independence of the T_p forces, for every pivot p, v_p = q_p zeta5 + r_p zeta2zeta3 with rational q_p, r_p — 147 explicit value identities among Z_0inf hyperlogarithm atoms (Section 4 determines all q_p, r_p exactly). ## 3. The engine direction space (declared table) Every census constant was evaluated SYMBOLICALLY by the HyperFLINT hyperlogarithm engine (tropsub CLI): the t -> T/(1+T) Euler-form recipe of the feasibility probe, strict->algebraic_letters->carry LR cascade, divergence checks ON, factored Log ratios; 345/357 on the standard chart, 2 (TT#302, TT#311) on the t -> T/(2+T) chart for the first axis after a Phase-6b engine crash on every order/tier of the standard chart, 10 detected as exactly zero at the integrand level (the fit ladder's ten `derived-zero` constants — free structural cross-check). Emissions are lists of terms (rational-or-mzv coefficient) x (product of Z_0inf words) over per-constant alphabets: rational letters, plus 18 quadratic-root letter pairs (five real: disc 5, 20; eleven complex: disc -3, -4, -12; golden-type letters of X(3,6)) and, in exactly one constant (TT#309), a nested algebraic tower kept as opaque exact atoms. The DECLARED TABLE gamma assigns each constant an exact vector over directions (m, w): m a monomial in {Log2, Log3, Log5, mzv_*} and w a single canonicalized word. Canonicalization (all exact): (i) products of words -> single words by the shuffle character property (Z_0inf regularized values are constant terms of the log-z polynomial; constant terms of polynomial products multiply); (ii) the exact rescaling identity, derived from P_w(L) = sum_k L^k/k! Z(tail^k w) (z d/dz strips the first letter): Z(w) = sum_k (-log lambda)^k/k! Z(tail^k(w/lambda)), applied with the canonical scale lambda = min-modulus rational letter, verified against two independent hand computations; (iii) integer-letter words reduced by the engine's own `evaluate_periods` table (2291 words cached; each reduction is an engine-level exact statement). Weight grading: all 9296 resulting directions have total weight exactly 5 (machine assert; `s3_gamma.py` -> `gamma_table.json.gz`, `s3_report.json`). TT#302 carries eight branch-tracking terms proportional to (Log 2 - i pi delta); only the real part enters the table and the bracket is checked numerically (Section 5). **Measured obstruction (reported, load-bearing for scope).** The emissions are NOT cross-constant canonical modulo (i)-(iii): of the 768 collapse relations, only 111 hold coordinate-wise on the table; the 657 nonzero residuals span a rank-154 sublattice of value-zero vectors whose members mix rational-letter words across alphabets and carry explicit mzv_5 / mzv_2*mzv_3 components. These are precisely Z_0inf inversion/path-splitting identities outside the implemented reducer — the engine's named "Phase 6c" scope gap. The residual basis is recorded as the explicit target list for that tool task. ## 4. Theorem 2 (exact Q5, R5; conditional as stated) Reducing every V_p modulo the residual span of Section 3 eliminates ALL non-{zeta5, zeta2zeta3} directions — including TT#309's tower atoms — with zero leftover atoms in all 147 pivots, yielding exact q_p, r_p and Q5 = 186226736168150016850683715530527178330620596354050107981300029 / 517709214178375471886365676494189670344949814926540363169600 R5 = -18362008992388018348457015844183891745446782460310232297964060067 / 33651098921594405672613768972122328572421737970225123606024000 byte-identical to the relation-collapse computation's fractions (`s5b_aux.py` -> `s5b_aux.json`). **Conditionality.** This derivation consumes: (a) the engine emissions (each numerically checked per constant, Section 5); (b) the exact symbolic census (checked exactly, Lemma A); (c) the 768 collapse relations AS INTEGER VECTORS (each carried its own acceptance checks in the collapse chain: two-precision residuals 124-135d, pigeonhole capacity margin >= n log10(2H) + 30, independent lo-leg verification, planted/negative controls). It consumes NO quadrature values, NO PSLQ fits, and NO numeric word evaluations: the fractions come out of pure symbol algebra plus the integer relation lattice. The collapse computation derived the same fractions from quadrature values + the fitted constants + the same relations. The two derivations share the relation lattice and the census, and are disjoint in their value substrates; byte-equality of both 64-digit-height fractions is the campaign's capstone cross-check. **What is NOT claimed.** A derivation of (Q5, R5) independent of the relation lattice was attempted and is REFUSED: without the Phase-6c reducer the emission atoms carry hidden zeta content, and the naive zeta-coefficients of the V_p give different (wrong) fractions — both fractions and diffs are recorded, unreconciled, in `s5_qr.json`. The refusal is a named tool gap with a recorded identity target list, not a mathematical obstruction: building the reducer upgrades Theorem 2 to a fits-free, relations-free derivation. ## 5. Numerical grounding of the engine table Each of the 346 nonzero, tower-free emissions is checked against its recorded two-leg quadrature value (hi/lo legs, 39-206 usable digits): the emission is evaluated as sum of coef x prod Z_0inf(word) with word values from the tool's own ginac ladder recipe (G(w; 10^(E0+Sj)), Lagrange extrapolation of the log-z polynomial to L = 0; control Z(0,-1) = zeta2 at 114.9d); bars: min(80, usable-5) for 1d/2d constants at 110 digits, min(35, usable-5) for 3-d at 55, min(30, usable-5) for F4 at 50 — all at or above the campaign's >= 30-digit floor, with the recorded values themselves carrying the two-leg 39-206d control. Complex conjugate-pair letters and positive (on-path, side-of-pole) letters are evaluated complex; totals must be real to the check bar. RESULT: 5587/5587 word evaluations (0 failures; wall 4136 s at 64 processes) and **346/346 checks PASS** (`s2_gates.json` and its run log). TT#302's branch-tracking bracket vanishes at 4.0e-55 relative (its real part agrees to 47 digits, bar 35); TT#311 agrees to 47 digits. TT#309 is not word-checked (tower atoms have no standalone evaluator) — its row is grounded through the relation lattice, five of whose members constrain it directly against checked constants. VALUE-LEVEL CLOSURE: assembling c5(s*) through the engine route (exact census weights x engine word-form values; the single non-engine value is TT#309's recorded leg, flagged) reproduces the recorded two-leg c5 AND Q5 zeta5 + R5 zeta2zeta3 with the byte-matched fractions to 46.0 floored digits, imaginary residual null at 53 digits (`s2b_c5check.json`). ## 6. Structural and numerical controls - Dependency proofs are exact expansions; the discovery layer (modular evaluation) cannot inject error (a wrong a_{kp} fails the expansion). - Three independent primes agree on rank and pivots. - The ten integrand-level zeros coincide exactly with the fit ladder's ten derived-zero constants. - The weight-5 grading of all 9296 directions is asserted exactly. - The nonzero control: the z5/z2z3 rows of the reduced pivots do NOT vanish (Q5, R5 != 0), and no residual of the relation lattice is supported on {zeta5, zeta2zeta3} alone (checked; a zeta-only residual would signal basket degeneracy). - Engine failure modes were exercised and documented: Phase-6b crashes (chart change cures), algebraic letter towers (one constant, quarantined from numeric checking, carried exactly), branch-tracking delta terms (one constant, bracket separated and checked numerically zero at 4e-55). - INCIDENT (caught by the checks, as designed): the t -> T/(k+T) chart rescues initially omitted the per-axis Jacobian factor k in dt/t = k dT/(T(k+T)); both chart-rescued constants failed their S2 checks at 0 matched digits (a clean factor 2), were fixed, re-checked at 47 digits, and the whole exact chain re-run. The byte-exact Q5/R5 was UNCHANGED before/after — as predicted by the invariance of the reduction under rescaling any single row whose atoms are unique to it (the row enters the pivots and the residual span identically) — but the table is only VALUE-correct after the fix. A check designed to certify emissions caught a transcription bug in the computing code.