# Arb is 10

April 5, 2022

Arb is 10 years old today — happy birthday Arb!

The README in the first commit, dated April 5, 2012, describes Arb as "an experimental C library implementing arbitrary-precision ball arithmetic on top of FLINT" ... "Planned future additions include more functions, complex numbers, polynomial balls, and matrix balls." This first commit includes asymptotically fast algorithms for computing $\pi$, Euler's constants $\gamma$ and zeta constants $\zeta(n)$ and was accompanied by a blog post titled "high-precision ball arithmetic" discussing the implementation results.

A decade and 2550 commits later, Arb contains almost exactly 200,000 lines of code (199498 lines of C source according to sloccount) and over 2000 functions. Perhaps 85% of Arb is my own work, the rest coming from a dozen or so occasional (but excellent) contributors.

Here is an attempt to summarize the highlights from the last 10 years:

• 2013: I present Arb at ISSAC in Boston (winning the best software demo award), and the extended abstract is published in ACM Communications in Computer Algebra.
• 2013: version 1.0: there are already a lot of features in place (asymptotically fast and accurate polynomial arithmetic; most standard transcendental functions implemented for complex variables; standard linear algebra functionality; real root isolation; numerical integration using Taylor series).
• 2013: first interesting computations with Arb: testing asymptotics of Keiper-Li coefficients and Stieltjes constants to record heights (both to index $n = 10^5$).
• 2014: new record computation of the partition function: I use Arb to compute the 11-billion digit integer $p(10^{20})$, beating my previous record set with FLINT.
• 2014: I defend my PhD thesis.
• 2014: version 2.0: complete rewrite of the core types and arithmetic, speeding up Arb by roughly a factor two.
• 2014: I move to Bordeaux to start a postdoc in the LFANT team (I get a permanent position the next year), working on certified complex arithmetic for number theory. Modular forms and elliptic functions added to Arb.
• 2015: complete rewrite of elementary functions for a huge speedup up to ~1000 digits; this work is published in an ARITH paper.
• 2015: Arb is now a standard package in SageMath (RealBall, ComplexBall).
• 2015: Julia wrapper for Arb in Nemo.jl.
• 2015: Arb gets hypergeometric functions (1F1, 2F1, Bessel, etc.).
• 2016: version 2.9: a huge "minor" release which in retrospect maybe should have been called 3.0. License changed from GPL to LGPL; about a million new functions; the first really major contributions by developers other than myself (new linear algebra functions by Alex Griffing; Dirichlet L-functions by Pascal Molin).
• 2016: Marc Mezzarobba's rigorous implementation of D-finite functions in SageMath notably uses Arb.
• 2017: the official Arb paper is published in IEEE Transactions on Computers. As of today, it has 147 citations (another 60 for the extended abstract from 2013).
• 2017: major new feature: a new, extremely efficient engine for rigorous numerical integration (with fast computation of Gauss-Legendre nodes developed in joint work with Marc Mezzarobba).
• 2018: the 15th PolyMath project improves the bound for the De Bruijn-Newman constant to $\Lambda \le 0.22$, using (among many other things) computations done with Arb. The mysterious D.H.J. Polymath contributes several functions to Arb, including an efficient implementation of Turing's algorithm for counting and isolating zeros of the Riemann zeta function.
• 2018: major linear algebra speedup and support for computing matrix eigenvalues; the paper on fast dot products and matrix multiplication receives the best paper award at ARITH the next year.
• 2019: Arb is used in an increasing number of applications to provide rigorous numerical parts of mathematical proofs. For example, Javier Gómez-Serrano and Gerard Orriols use Arb in their proof that any three eigenvalues do not determine a triangle.
• 2020: Dave Platt and Tim Trudgian verify the Riemann hypothesis to record height $3 \cdot 10^{12}$. Their computations use Arb.
• 2020: I start Calcium, a library for exact real and complex arithmetic which uses Arb for the numerical side of things.
• 2021: Arb has a small part in the new ANR NuSCAP ("Numerical Safety for Computer-Aided Proofs") project led by Nicolas Brisebarre. (This is the first time I have some grant money in my own name to help with Arb development.)
• 2021: I spend months rewriting the gamma function in Arb, annoyed that it was using more CPU cycles than necessary. (Not the first time I spend months on one function, but this time with a vengeance since gamma is my favorite!)
• 2021: Wolfram Mathematica 13 uses Arb (CenteredInterval).
• 2022: Maple 2022 uses Arb (RealBox, ComplexBox).
• 2022: the latest version is 2.22. New features include better enclosures for hypergeometric functions and asymptotically faster evaluation of Bernoulli numbers and special L-function values.

Please let me know if some particularly important application is missing from this list! People send me nice emails from time to time saying "I used Arb to do X and Y and it works really well", but I never bothered to make a list. I have omitted many minor features from the highlight list; see the "history and changes" section in the documentation and previous posts on this blog for details.

What are my thoughts today? 10 years pass extremely fast. The latter 5 years especially. When I started Arb, I had no idea what I was doing. I still have no idea what I'm doing; the only difference is that I have gray hairs now.

What about Arb has been successful, or not successful? I could discuss various technical aspects, but on a higher level, one of my goals from the start has been to show that ball arithmetic is a better paradigm than ordinary floating-point arithmetic (as well as classical interval arithmetic) for many of the calculations with real and complex numbers needed in computer algebra systems, number theory software and the like. This idea has now percolated to the point where it is pretty well established in the research community, in no small part thanks to Arb. (This vision for ball arithmetic is really due to Joris van der Hoeven, though I arrived there more or less independently.)

There are still many applications where Arb could be used to significant benefit, but for various reasons isn't. One reason is that Arb is a relatively large dependency (especially when you include FLINT), and it is therefore not something every other mathematical software project might want to add as a dependency (unlike GMP or BLAS, say). I should probably put more effort into accessibility. Not just making Arb more accessible as software, but also getting the good algorithms and design ideas out there for other software to implement as well.

A slight disappointment is that I have failed to attract any students or postdocs to work on Arb so far, probably in part because I have not been proactive enough, probably in part because the subject area is inherently very niche and not applied (prospective PhD students around here are much more interested in things like cryptography and quantum computers). This is in part a funding issue; I don't have grants to hire people, so even if the perfect candidate appeared today, I would not be able to promise anything since any recruiting would be on the national Inria budget (again in competition with things like cryptography and quantum computers).

Anyway, Arb development continues, and we will see where things are in another 10 years...