Exponent Ledgers: Machine-Checked Bookkeeping of Conditional Bounds in L-Function Moment Theory

Many theorems in analytic number theory come in two versions. One version is proved outright. The other assumes an unproven conjecture and gets a sharper result. The link between them is almost always arithmetic on exponents. An input bound of size $x^{\theta}$ passes through a chain of estimates and comes out as an error term $X^{\eta}$ or an interval length $T^{\eta}$. Authors state only the two endpoints: $\theta$ set to the best proven input, and $\theta$ set to the conjectured value. The whole curve $\eta(\theta)$ in between stays implicit. So when someone proves a partial step toward the conjecture, or when the conjecture itself is revised, nobody can say what the downstream theorem becomes without re-deriving it by hand.

We propose extracting, from informal LaTeX proofs, a dependency graph whose edges carry exponent arithmetic rather than bare "this uses that" links. A language-model pipeline builds the graph. An exact rational-arithmetic solver then evaluates the graph and checks it. The graph serves as an exponent ledger: it computes $\eta(\theta)$ for every assumed input, records which named conjectures each final exponent depends on, and can be tested for correctness against the two endpoints the authors themselves published.

Core Claim

In moment papers, the part of the reasoning that ties conjectures to conclusions is a small, decidable layer sitting on top of hard analysis. That layer is exponent bookkeeping: adding exponents when bounds multiply, taking maxima over competing terms, and choosing splitting parameters to balance them. It can be extracted and machine-verified without formalizing any of the analysis beneath it.

Concretely, for a proof with an assumed input exponent $\theta$ and free splitting parameters $\lambda$ (for example the cutoff separating "small" and "large" variables after Möbius inversion), the ledger represents the final exponent as

$$\eta(\theta) = \min_{\lambda} \max_{j} \big( a_j \theta + b_j^{\top} \lambda + c_j \big),$$

where each term $j$ is the exponent contributed by one branch of the argument (the diagonal term, the off-diagonal term, a tail), with rational coefficients $a_j, b_j, c_j$. This form comes from how such proofs combine estimates. Products of bounds add exponents, a sum of terms is dominated by its largest, and authors optimize their parameters. The result is a small linear program that exact arithmetic can solve and check.

The claim is falsifiable within a single paper. A correctly extracted ledger must reproduce both the published unconditional exponent and the published conditional exponent, and it must do so from proof text with those exponents masked out.

Where This Sits Relative to Prior Work

The motivating cases come from the moment literature itself. Huang, Wang and Zhang prove short-interval power moments ($k=3,4,5$) of the Rankin–Selberg Riesz mean error term. Their unconditional result needs $H \ge T^{1+(k-2)/5-k/8+\sqrt{\varepsilon}}$. Assuming the pointwise bound $\Delta_1(x;\varphi)=O(x^{9/8+\varepsilon})$, they reach $H \ge T^{3/4+\sqrt{\varepsilon}/2}$. They give only these two points of what is surely a curve in the assumed exponent.

Shen proves a smoothed first moment of quadratic twists of modular $L$-functions with error $O(X^{1/2+\varepsilon})$, and notes that going further needs the Generalized Riemann Hypothesis or sharper counts of square-free integers. Shen's Theorem 1.4 reduces the shifted-moment Conjecture 1.3 at parameter $h$ to smaller parameters. That is a conjecture-to-conjecture dependency, and a ledger should represent it explicitly.

Alderson and Rubinstein confirm a lower-order $X^{3/4}$ term in the cubic moment numerically. They also stress that its theoretical derivation rests on unproven continuation and growth hypotheses for multiple Dirichlet series. That is exactly the kind of buried premise a ledger should surface. These papers motivate the work. None of them attempts machine-readable tracking.

The method comes from dependency-graph work on informal proofs. Agent-Based Auditing decomposes LaTeX papers into premise–claim–justification steps inside a document-wide graph and detects assumption drift in ML theory papers. DAG-Math enforces a step→justification→parents schema and shows that answer accuracy badly overstates logically closed reasoning. ProofFlow restricts each step's context to its parent nodes when formalizing. We reuse all three designs.

Their edges, however, are qualitative. None of them attaches a quantity to an edge, and none keeps an inventory of named conjectures such as the Generalized Riemann Hypothesis, Lindelöf, or pointwise error bounds. VALG is the closest system in spirit: when an unconditional proof fails, it routes the attempt into conditional theorems. But it works on ML theory, it generates new theorems, and it does not verify results externally.

Two results constrain the design. ProofFlow reports that research-level statements often fail to be semantically faithful even when the formal code compiles, and that Mathlib lacks the relevant concepts. IMProofBench reports 0% on its seven open research questions. Together these argue against formalizing the analysis and against asking models to prove new moments. We therefore verify only the exponent layer, and we produce theorems that interpolate between existing ones rather than frontier results.

Research Program

The pipeline has three stages.

The first stage extracts the graph. Adapting the audit agent, a model splits each proof into nodes. Each node records a bound together with its exponent expression in $\theta$ and the free parameters. It also records its parents, the operation combining them (multiply, sum, substitute a parameter, optimize a parameter), and any named hypothesis it invokes, tagged from a fixed list of conjectures. During extraction, the exponents that appear in theorem statements are masked, so the model must rebuild them from the proof body.

The second stage evaluates. An exact rational linear-programming solver computes $\eta(\theta)$ symbolically as a piecewise-linear function. It also lists the conjecture nodes on which each linear piece depends.

The third stage checks consistency. It evaluates $\eta$ at the paper's stated unconditional input and at its conjectured input, and compares both against the published exponents. Any mismatch is localized to the smallest set of edges whose correction restores agreement, and that set is handed back for re-extraction or flagged for a human.

The corpus is new, because the file lists no benchmark for graduate-level analytic number theory. We will assemble papers that contain paired conditional and unconditional theorems about moments and error terms. The three papers above are the seed. We add further dual-tier results, such as the conditional Euler–Kronecker growth results under Elliott–Halberstam in Hong et al., to test whether the method carries beyond moment problems. Number theorists will annotate gold exponent functions and conjecture attributions for a held-out subset.

Baselines

The naive reference point is to read the endpoints straight off the theorem statements and interpolate linearly between them. It requires no proof reading at all. It is correct whenever $\eta$ happens to be a single linear piece, so beating it is necessary before the ledger has shown anything. We score it with the same metrics on the same held-out interpolation queries.

The strongest existing method is the Agent-Based Auditing pipeline, run unchanged on our corpus. We then prompt it to report, for each theorem, which unproven hypotheses it uses and how the final exponent depends on them. It is the strongest competitor because it already builds document-wide dependency graphs and catches assumption drift. On its own ML-theory audit set it flagged 25 errors, 23 of them (92%) verified, while a whole-paper LLM judge found 5. For exponent-function recovery, conjecture attribution, or any number-theory corpus, no reported result was found on Lacuna.

For a fair comparison, it gets the same underlying model, the same masked inputs, and the same per-paper budget of model calls. We aim to stay near that paper's roughly $5 per paper. Beating it means matching both published endpoints on substantially more theorems, and reaching higher accuracy on the interpolated exponents.

The key ablation keeps our extraction and conjecture tags but removes the numeric annotations on edges. A language model then derives $\eta(\theta)$ from the qualitative graph in free text, with no solver. This isolates whether exact exponent arithmetic, as opposed to graph structure alone, drives the gains. A second ablation removes the endpoint-consistency repair loop, to measure how much of the accuracy comes from self-checking against published results.

Why not just…?

Why not just ask a frontier model to list each theorem's assumptions and derive the dependence? For listing named conjectures, this may well work nearly as well as our pipeline, and we take that possibility seriously. The attribution metric is reported separately for exactly this reason. The claim that it fails concerns quantitative dependence. DAG-Math finds only 17.0% perfectly closed reasoning against 52.4% answer accuracy on AIME 2025, and the audit paper reports that a whole-paper judge loses track of long-range dependencies. The masked-endpoint experiment decides the question. If a monolithic prompt reproduces both endpoints as often as the ledger does, the solver layer is unnecessary, and we would say so.

Why not just have an expert do the bookkeeping by hand? Experts do this routinely for single papers, and the expert annotations are our ground truth, so the method does not claim to beat careful humans. Its value lies in re-running the whole corpus automatically when an input bound improves. The arithmetic is also checked exactly rather than on paper. The corpus-wide propagation experiment below measures this directly.

Why not just formalize the proofs in Lean? Mathlib lacks half-integral-weight forms, Voronoï summation, and Epstein zeta functions, and full formalization costs about ten times the effort of informal proof. ProofFlow also shows that research-level statements lose faithfulness even when the code compiles. The ledger formalizes only the layer that can be decided, and it leaves the analytic lemmas as trusted, tagged nodes. The honest cost is that the analysis itself stays unverified. The ledger certifies bookkeeping, not correctness.

Proposed Experiments

The decisive check is endpoint reproduction under masking. On each paired theorem, we ask whether the extracted $\eta$ matches the published unconditional exponent and the published conditional one. For Huang et al. the targets are $1+(k-2)/5-k/8$ and $3/4$ for each $k \in \{3,4,5\}$. For Shen the target is the exponent $1/2$, along with the attribution of any improvement to the Generalized Riemann Hypothesis or to square-free counting. A paper counts as passed only if both endpoints match exactly in rational arithmetic, with no credit for approximate agreement.

A second check tests interpolation. For intermediate $\theta$, expert annotators derive the true exponent by hand for a held-out sample. We report exact-match rate and absolute exponent error, and we compare against linear interpolation. The ledger earns its keep only where $\eta$ has kinks that linear interpolation misses.

A third check tests conjecture attribution. We measure precision and recall of named-hypothesis tags against expert labels. The labels include buried premises such as the multiple-Dirichlet-series hypotheses behind the $X^{3/4}$ term, and the conjecture chain in Shen's Theorem 1.4.

Finally, a propagation study substitutes improved hypothetical inputs across the whole corpus at once. It reports which downstream exponents move. Experts spot-check each reported change for plausibility.

A negative outcome would also be informative. Suppose extraction fails mainly because authors hide parameter choices in phrases like "choosing $Y$ optimally." Then the bottleneck is how proofs are written rather than the models, and the propagation study would identify which proof steps need more explicit writing.