🔢 mathematics

A computational algorithm for the Hardy function $Z(t)$ , utilising sub-sequences of generalised cubic Gauss sums, with an overall operational complexity of $O\bigl((t/\varepsilon_t)^{[.25,.3]}(\log t)^{2+o(1)}\bigr)$ , for $t \in [10^{23},10^{35}]$

This paper presents a new computational algorithm for the Hardy function $Z(t)$ that utilizes sub-sequences of generalised cubic Gauss sums to achieve an operational complexity of $O\bigl((t/\varepsilon_t)^{[.25,.3]}(\log t)^{2+o(1)}\bigr)$ for $t \in [10^{23},10^{35}]$ , significantly improving upon previous $O(t^{1/3})$ methods.

Original authors: David Lewis, Ashley Brereton

Published 2026-07-20

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: David Lewis, Ashley Brereton

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to count the number of stars in a galaxy, but the galaxy is made of invisible numbers that dance to a secret rhythm. In the world of mathematics, there is a famous equation called the Riemann Zeta function. It's like the master key to a locked door that holds the secrets of prime numbers—the building blocks of all arithmetic. If you can understand how these numbers are distributed, you unlock a deeper truth about how the universe is structured. However, these numbers are tricky; they only reveal their true nature when you look at them along a very specific, narrow path called the "critical line." To study this path, mathematicians use a special tool called the Hardy function, which acts like a flashlight, turning the complex, wavy math into a real number we can actually measure and count.

For a long time, calculating this flashlight beam was like trying to count every single grain of sand on a beach one by one. It was slow, tedious, and required a massive amount of computer power. In recent years, clever mathematicians found a way to speed things up by grouping the grains of sand into small piles and counting the piles instead of the individual grains. This made the job faster, but the piles were still quite large. The big question remained: Could we group the sand into even bigger, more efficient bundles to make the counting process significantly faster? This is the challenge that the paper by D. M. Lewis and A. R. Brereton tackles. They propose a new, highly sophisticated method that doesn't just count grains or small piles, but organizes the sand into massive, complex structures, potentially making the calculation of these mysterious numbers more efficient than ever before, though with important caveats regarding current practical speed.

The Paper's Big Idea: From Simple Squares to Complex Cubes

The authors of this paper are essentially trying to build a better, faster engine for calculating the Hardy function. To understand their breakthrough, imagine you are trying to predict the path of a ball rolling down a hill. In the old, standard method (known as the Riemann-Siegel formula), you would look at the ball's movement in simple, square steps. It's reliable, but it takes a long time because the steps are small.

A few years ago, researchers discovered a trick: instead of looking at the ball step-by-step, you could group the steps into "quadratic" patterns (think of them as square-shaped blocks). This allowed them to skip ahead, calculating the path much faster. However, the authors of this paper realized that the ball's path wasn't just a simple square; it had a more complex, curvy shape that could be described by "cubic" or even higher-order patterns.

The main finding of this paper is a new mathematical recipe that rewrites the Hardy function using these more complex, "generalized" patterns. Specifically, they show how to break the problem down into sub-sequences of what they call "generalized cubic Gauss sums." Think of a Gauss sum as a special kind of musical chord. The old method used simple two-note chords (quadratic). The new method uses complex, multi-note chords (cubic and higher). The magic of this paper is that they found a way to calculate these complex chords just as quickly as the simple ones, provided the notes in the chord follow a specific, predictable pattern.

How They Did It: The "Portcullis" and the Recursive Ladder

To make this work, the authors had to solve a tricky puzzle. Usually, complex chords are hard to calculate because they don't have a simple "reciprocity" rule—a mathematical shortcut that lets you swap a big, hard problem for a smaller, easier one. Without this rule, you'd have to do all the hard work every time.

However, the authors discovered that the specific chords needed for the Hardy function have a special secret: their higher notes are very quiet and follow a regular, fading pattern. Because of this, they could invent a new kind of "ladder" (a recursive algorithm) that lets them climb down from a huge, complex sum to a tiny, manageable "kernel" sum. They call a key variable in their math the "portcullis," which acts like a gatekeeper, determining how big the groups of numbers can be before the math gets too messy. By carefully tuning this gate, they ensure that the complex cubic (and higher-order) sums can be reduced down to a size where a computer can solve them instantly.

The paper presents a detailed mathematical derivation showing that this new method works. They provide a formula that expresses the Hardy function as a sum of these generalized Gauss sums. They also derive an asymptotic expression that includes an error term, denoted as $O(\varepsilon_t)$ , showing that the errors introduced by their shortcuts are theoretically small and controllable, provided certain assumptions about the parameters hold true.

The Results: A Faster Way to Count (In Theory)

The paper suggests that by using this new method, the theoretical computational cost (the amount of work a computer has to do) can be reduced significantly. While the old "square" method took time proportional to the square root of the number being calculated ( $O(\sqrt{t})$ ), and the previous "quadratic" method took time proportional to the cube root ( $O(t^{1/3})$ ), this new approach aims for an even lower exponent.

The authors claim their new algorithm has an operational complexity of roughly $O((t\varepsilon_t)^{[0.25, 0.3]} (\log(t))^{2+o(1)})$ . In plain English, this means that as the numbers get bigger, the time it takes to calculate them grows much more slowly than with previous methods. For the range of numbers they tested ( $t$ between $10^{23}$ and $10^{35}$ ), the theory suggests a substantial speed-up.

They support this theoretical claim with "sample computations," which are practical tests showing that the math works in the real world. They demonstrate that their recursive scheme can indeed handle these complex cubic sums rapidly in these specific instances. However, they are careful to note a crucial distinction: while the theory is solid, the full practical implementation for all possible scenarios is a complex engineering task. The paper explicitly notes that a similar previous cubic algorithm offered "little practical improvement" for computationally feasible values due to heavy pre-processing requirements. Therefore, while this new method offers a promising theoretical path to "lightning fast" calculations, realizing that speed in the real world requires overcoming significant implementation hurdles that are not yet fully resolved.

What This Means for the Future

The paper doesn't just offer a faster calculator; it opens a door to new theoretical possibilities. The authors suggest that if we can compute the Hardy function this quickly, we might eventually be able to prove tighter bounds on how fast the function grows. This is a deep theoretical question in mathematics that has stumped experts for decades.

In summary, Lewis and Brereton have taken a difficult math problem, identified a hidden pattern in the complexity of the numbers, and built a new tool to exploit that pattern. They replaced simple square blocks with complex, multi-layered structures that can be processed much faster in theory. While the full potential of this method is still being explored and practical speed-ups remain to be fully realized, the paper provides a strong, mathematically rigorous foundation for a new era of speed in computing the secrets of prime numbers. It's a reminder that sometimes, to go faster, you don't just run harder; you change the shape of the road you're running on.

Technical Summary: A Computational Algorithm for the Hardy Function $Z(t)$ Utilising Sub-Sequences of Generalised Cubic Gauss Sums

Problem Statement
The computation of the Hardy function $Z(t)$ , which represents the Riemann zeta function $\zeta(s)$ along the critical line $s = 1/2 + it$, is fundamental to understanding the distribution of prime numbers. Historically, the Riemann-Siegel formula has been the standard method, requiring an operational complexity of $O(\sqrt{t})$ . While recent advancements by Hiary (2011) and others reduced this to $O(t^{1/3 + o(1)})$ by decomposing the formula into sequences of quadratic Gauss sums, the authors posit that further reductions in operational complexity are theoretically possible. The primary obstacle to achieving faster algorithms (e.g., approaching $O(t^{1/4})$ ) is the lack of general reciprocity formulae for higher-order (cubic or $m$ -th order) Gauss sums, which prevents the recursive reduction techniques used for quadratic sums from being directly applied.

Methodology
The paper proposes a novel framework that expresses $Z(t)$ as a sum of sub-sequences of generalised $m$ -th order Gauss sums, with a specific focus on the cubic case ( $m=3$ ). The methodology proceeds through three main stages:

Asymptotic Formulation:
Starting from an exact representation of $Z(t)$ involving Kummer's functions and Euler's integral formulation, the authors derive an asymptotic expression. By analyzing the integral $BC(\alpha_E, t, j)$ via saddle-point methods (introducing a "portcullis" variable $p_c$ ), they demonstrate that the Hardy function can be approximated by a series of generalised Gauss sums of the form:
$S_{M_t^-}(\Phi_1, \dots, \Phi_m) = \sum_{k=0}^{M_t^-} \exp\left[2\pi i \left( \Phi_1 k + \Phi_2 k^2 + \dots + \Phi_m k^m \right)\right]$
Crucially, the coefficients $\Phi_l$ for $l \geq 3$ are shown to be small, scaling as $\Phi_l = O(t^{(2-l)/2})$ . This specific structural characteristic distinguishes these sums from general higher-order Gauss sums.
Recursive Computation Algorithm:
The paper addresses the computational difficulty of higher-order sums by developing a recursive algorithm (denoted MGS) based on the Euler-Maclaurin summation formula and contour integration.
- Unlike general higher-order sums, the smallness of the coefficients $\Phi_{l \geq 3}$ allows the authors to delay the increase in the order of the sum during recursive reduction.
- The algorithm utilizes a reciprocity-like formula derived via contour deformation around saddle points. It monitors a remainder term $E_m$ to ensure the order of the sum does not increase prematurely.
- This allows the reduction of a sum of length $N$ to a "kernel" sum of length $K \ll N$ in $O(\log(N/K))$ iterations, similar to the quadratic case but adapted for the specific asymptotic behavior of the $Z(t)$ coefficients.
Collection Size and Error Control:
The authors derive specific bounds for the collection size $M_t$ (the length of the Gauss sum subsequences) to ensure the truncation error remains within a tolerance $\epsilon_t$ . They provide distinct formulas for $M_t$ depending on whether the parameter $(p_c - 1)$ is large or small, ensuring the validity of the asymptotic expansion across the entire computational range.

Key Contributions

Theoretical Formulation: The paper establishes a rigorous asymptotic expression for $Z(t)$ in terms of generalised $m$ -th order Gauss sums (Eq. 62), extending previous work limited to quadratic sums.
Algorithmic Innovation: It presents a recursive computational scheme capable of evaluating these specific higher-order sums rapidly. The key insight is that the structural constraints of the $Z(t)$ formulation (small higher-order coefficients) bypass the usual barriers preventing the recursive reduction of non-quadratic Gauss sums.
Complexity Reduction: The paper derives a computational algorithm with an overall operational complexity of $O((t \epsilon_t)^{[0.25, 0.3]} (\log t)^{2+o(1)})$ for $t \in [10^{23}, 10^{35}]$ . This represents a theoretical improvement over the $O(t^{1/3})$ methods currently in use.

Results
The paper provides a detailed derivation of the coefficients $\Phi_l$ and the polynomial patterns (related to Pascal's triangle) governing the expansion of the integral phases. It demonstrates that for the specific parameterisation of $Z(t)$ , the higher-order terms in the phase expansion are sufficiently small to allow for rapid computation. Sample computations are cited as lending practical support to the findings, confirming that the recursive scheme yields high-accuracy estimates.

Significance
The authors claim that this work constitutes a significant extension of existing methodologies for computing the Riemann zeta function. By successfully formulating $Z(t)$ in terms of generalised Gauss sums and devising a method to compute them efficiently, the paper opens the door to algorithms with lower operational complexity than the $O(t^{1/3})$ barrier. The authors suggest that such advances could theoretically reduce the exponent bounding the growth of $Z(t)$ (currently $c \approx 32/205$ ) and offer a more efficient path for high-precision calculations of the zeta function, although they note that practical implementation for very large $t$ involves pre-processing constraints. The work is presented as a foundational step toward "much faster operational algorithms" beyond the current state of the art.

The Paper's Big Idea: From Simple Squares to Complex Cubes

How They Did It: The "Portcullis" and the Recursive Ladder

The Results: A Faster Way to Count (In Theory)

What This Means for the Future

More like this