🔢 mathematics

Residual-adaptive truncation in an arbitrary-order tangent iteration for $\pi$ : quadratic growth of the accuracy exponent

This paper introduces a residual-adaptive truncation rule for an arbitrary-order tangent iteration to compute $\pi$ , which leverages the alternating arctangent series to achieve quadratic growth in the decimal accuracy exponent, thereby enabling the rapid convergence from a single Chudnovsky approximation to over one million correct decimal places.

Original authors: Shih-Han Wang

Published 2026-09-16

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Shih-Han Wang

Original paper licensed under CC BY 4.0 (https://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

The quest to calculate the number pi, the ratio of a circle's circumference to its diameter, has long served as a proving ground for the most powerful tools of mathematics. While the number itself is simple to define, its infinite, non-repeating decimal expansion makes it a perfect test case for how we handle complex calculations. For centuries, mathematicians have relied on two main strategies to find more digits of pi. The first involves adding up long lists of numbers in a series, where each new term adds a fixed, predictable amount of accuracy. The second strategy uses iterative methods, where a computer starts with a rough guess and repeatedly refines it. In these iterative approaches, the goal is usually to double the number of correct digits with every single step, a process known as quadratic convergence. While these methods are incredibly fast, they typically follow a rigid script: the formula used to improve the guess stays the same, even as the guess becomes more precise.

A new study by Shih-Han Wang at Virginia Tech challenges the idea that the script must remain rigid. The research introduces a method where the calculation itself changes its behavior based on how close it is to the answer. Instead of using a fixed formula, the method looks at the current error—the difference between the current guess and the true value of pi—and uses that error to decide how many terms to include in the next calculation step. This creates a self-adjusting system where the speed of improvement accelerates dramatically as the calculation gets better. The study demonstrates that this approach does not just double the number of correct digits; it squares the number of correct digits with each step, leading to an explosion of precision that far outpaces traditional fixed-order methods.

The core of this work lies in a specific mathematical relationship involving the tangent function. When a number is very close to pi, its tangent value is extremely small, and this small value acts as a direct measure of the error. The researcher realized that the size of this error could be used to determine exactly how many correction terms are needed to fix the guess. In a standard method, a mathematician might decide to use a formula that corrects the first ten terms of an expansion, regardless of whether the current guess is off by a tiny fraction or a large amount. In Wang's adaptive method, the computer checks the size of the error first. If the error is large, it uses a short correction. If the error is tiny, it automatically switches to a much longer, more detailed correction. This decision is made at every single step, making the process non-stationary, meaning the rules of the game change as the game progresses.

The results of this adaptive strategy are mathematically profound. The study proves that if a calculation has a certain number of correct digits, the next step will produce a number of correct digits that is roughly the square of the previous count. To put this in perspective, if a calculation has achieved 10 correct digits, the next step would jump to approximately 100 correct digits. If it reaches 1,000 correct digits, the following step would leap to one million. This is a fundamental shift from the linear or quadratic growth seen in other high-speed algorithms. The paper shows that this growth is not just a theoretical possibility but a proven mathematical law for this specific type of iteration, provided the starting guess is already reasonably close to the true value.

To verify these findings, the researcher ran a numerical experiment starting with a well-known approximation of pi derived from the Chudnovsky formula. The initial guess was accurate to about 13 decimal places. After the first adaptive step, the accuracy jumped to roughly 385 correct digits. The second step pushed the precision to nearly 300,000 correct digits. The third step was so powerful that it theoretically produced over 100 billion correct digits, a number so vast that the computer could only verify the first one million digits against a known reference standard. The fact that the first million digits matched the reference perfectly confirmed that the theoretical predictions were accurate. The method successfully generated a sequence of approximations that grew in precision exactly as the mathematical model predicted, moving from thousands to millions of digits in just a few iterations.

This work distinguishes itself from other high-speed methods by its flexibility. While other algorithms might be designed to have a fixed "order" of convergence, such as doubling or tripling the digits each time, this method has no fixed order. Instead, its order of convergence grows automatically as the calculation improves. The study clarifies that this does not mean the method is infinitely fast in a practical sense, as the cost of performing the calculations also increases with the number of digits. However, in terms of the mathematical relationship between the current error and the next error, the improvement is faster than any fixed power of the current error. The research provides a rigorous proof that the error in the next step becomes vanishingly small compared to any fixed power of the current error, a property that sets it apart from all previously known fixed-order iterations.

The study also addresses the boundaries of its own success. The method relies on the starting guess being within a specific range of the true value of pi, specifically within a quarter of a radian. Fortunately, the starting point used in the experiment, derived from the Chudnovsky formula, falls well within this safe zone. Once the calculation enters this zone, the method guarantees that it will stay there and continue to improve. The paper does not claim to solve the problem of finding pi from a random starting point, but rather offers a highly efficient engine for refining a guess that is already close. It also notes that while the mathematical convergence is spectacular, the actual time it takes to run these calculations on a computer depends on how efficiently the computer can handle the massive number of digits involved, a separate engineering challenge.

Ultimately, this research offers a new way of thinking about how we refine numerical answers. It suggests that when a correction formula is available in a flexible form, the current error can be used not just to measure progress, but to dictate the strategy for the next move. By letting the error determine the depth of the correction, the method transforms a standard iterative process into a self-accelerating system. The findings are supported by both rigorous mathematical proof and direct numerical verification, showing that the number of correct digits can indeed grow at a rate that squares the previous accuracy. This approach opens a new avenue for high-precision arithmetic, demonstrating that the path to extreme accuracy can be paved by algorithms that adapt their own rules as they go.

Technical Summary: Residual-Adaptive Truncation in an Arbitrary-Order Tangent Iteration for $\pi$

Problem Statement
The computation of $\pi$ serves as a benchmark for the interplay between analytic identities, nonlinear iteration, and high-precision arithmetic. While series-based methods (e.g., Chudnovsky) offer linear growth in correct digits per term, and fixed-order iterative methods (e.g., Brent–Salamin or Labelle's tangent iterations) offer algebraic convergence orders, there is a gap in methods where the convergence order itself adapts automatically to the current accuracy. Specifically, existing arbitrary-order constructions require an externally prescribed integer order $p$ , resulting in a fixed algebraic convergence rate. This paper addresses whether the truncation depth of a tangent-based iteration can be selected directly from the current residual, allowing the error-correction exponent to increase automatically as the approximation improves.

Methodology
The proposed method utilizes the local identity $\pi = x - \arctan(\tan x)$ , valid for $x$ in the principal branch near $\pi$ . Let $x_n$ be an approximation to $\pi$ with error $e_n = x_n - \pi$ . The tangent residual is defined as $t_n = \tan x_n = \tan e_n$ . Since $e_n = \arctan t_n$ , the error can be expressed as the tail of the Maclaurin series for $\arctan t_n$ .

The core innovation is a residual-adaptive truncation rule:

Residual Accuracy Exponent: Define $\rho_n = -\log_{10} |t_n|$ .
Adaptive Truncation Index: Set the truncation depth $d_n = \max\{1, \lfloor \rho_n \rfloor\}$ . This index represents the decimal order of magnitude of the current residual.
Iteration Step: The next iterate is computed by subtracting the first $d_n + 1$ terms of the $\arctan$ series:
$x_{n+1} = x_n - \sum_{j=0}^{d_n} \frac{(-1)^j t_n^{2j+1}}{2j+1}$
The new error $e_{n+1}$ corresponds exactly to the omitted tail of the alternating series, starting at the power $2d_n + 3$ .

Key Contributions

Nonstationary Iteration Scheme: The paper introduces a nonstationary iteration where the analytic form of the update remains constant, but the truncation depth $d_n$ varies at every step based on the magnitude of the tangent residual.
Rigorous Error Analysis: By leveraging the alternating series remainder theorem, the author derives an exact tail representation for the new error. This yields a uniform asymptotic remainder bound:
$|e_{n+1}| \leq \frac{|t_n|^{2d_n+3}}{2d_n+3}$
Quadratic Growth of Accuracy Exponent: The primary theoretical result is the derivation of the recurrence relation for the decimal accuracy exponent $D_n = -\log_{10} |e_n|$ . The paper proves that as $e_n \to 0$ :
$D_{n+1} = 2D_n^2 + O(D_n)$
A refined expansion is provided to resolve floor-induced linear terms and logarithmic corrections.
Super-Algebraic Convergence: It is demonstrated that for any fixed $r > 0$ , the ratio $|e_{n+1}|/|e_n|^r \to 0$ . This implies the method converges faster than any fixed algebraic order, though the author distinguishes this mathematical convergence from computational complexity.
Branch Invariance: The paper proves that once an iterate enters the interval $|x_n - \pi| < \pi/4$ , all subsequent iterates remain on the same inverse-tangent branch, ensuring the validity of the principal branch identity throughout the process.

Results
The method was numerically validated starting from a one-term Chudnovsky approximation ( $x_0$ ). The observed convergence matched theoretical predictions with high precision:

Iteration 0 to 1: Accuracy grew from $\approx 13$ digits to $\approx 385$ digits.
Iteration 1 to 2: Accuracy grew from $\approx 385$ digits to $\approx 297,686$ digits.
Iteration 2 to 3: The theoretical prediction suggests an accuracy exponent of $\approx 1.77 \times 10^{11}$ . The computed iterate $x_3$ was verified to agree with an independent reference (Trueb's 22.4-trillion-digit dataset) through at least 1,000,000 decimal places.
The numerical data confirmed the quadratic growth law $D_{n+1} \approx 2D_n^2$ and the validity of the adaptive truncation rule.

Significance and Claims
The paper claims significance in establishing a closed-form recurrence for the accuracy exponent that arises naturally from coupling the truncation depth to the residual magnitude.

Mathematical Convergence: The method achieves an outer-iteration count of $O(\log \log N)$ to reach an accuracy exponent $N$ once the asymptotic regime is entered, which is superior to the $O(\log N)$ required by fixed-order methods.
Distinction from Complexity: The author explicitly states that this result concerns mathematical convergence, not computational complexity. They do not claim wall-clock superiority over optimized Chudnovsky or AGM-based methods, noting that the high-precision evaluation of transcendental residuals and the summation of many terms carry their own arithmetic costs.
General Principle: The work illustrates a general principle: when an arbitrary-order correction is available in a single analytic expansion, the current residual can be used not only to estimate the error but also to determine the truncation depth, converting a fixed-order family into a nonstationary scheme with quadratic accuracy growth.

The paper concludes that while the quadratic law is a consequence of the specific linear schedule $d_n \sim \rho_n$ , the explicit residual-controlled truncation rule and its rigorous error analysis represent a novel contribution to the theory of nonlinear root finding for $\pi$ .

Technical Summary: Residual-Adaptive Truncation in an Arbitrary-Order Tangent Iteration for π\piπ

More like this

Technical Summary: Residual-Adaptive Truncation in an Arbitrary-Order Tangent Iteration for $\pi$