I believe that the creation of visualization apps to illustrate mathematical or scientific concepts is a particularly favorable use case for modern coding agents, as many of the downside risks attached to other LLM use cases are limited:

1. Not mission-critical. As such apps are not authorative sources of truth and only used for secondary purposes, a small positive error rate in the output can be acceptable.
2. Stand-alone. As the applets are not destined to be incorporated into a larger codebase or literature, the technical debt incurred by delegating all the coding to an LLM agent is bounded.
3. End product is deterministic (and sandboxed). As the applets run on a deterministic language (Javascript), are sandboxed against file or internet access, and do not make any LLM calls at run-time, security and privacy concerns are minimal, and the applet can be maintained without continued premium LLM access or resource-intensive compute.
4. Not replacing primary skills. While deskilling is the tradeoff one accepts when relying on these tools to accelerate output, I am perfectly willing to forego the opportunity to keep my Javascript skills at a high level, as this is a tertiary skill for me at best in my chosen profession. (I continue to manually program in Lean and in Python to keep in practice with programming in general.)
5. Not competing with humans. To my knowledge, there is no existing human effort that is being duplicated by these applets (the activity in this direction appears to have peaked two decades ago).

I would however caution against unrestricted LLM use when one or more of the above five favorable situations is not in effect.

With these points in mind, I have used such an agent to create two further apps. The first app illustrates the “zeta process” that was introduced in my recent paper with Alexeev, Barreto, Li, Lichtman, Price, Shah, and Tang, though it was first discovered by an AI. For each , the zeta distribution is a random natural number with distribution

It has long been known that this distribution has good number-theoretic properties: for instance, the number of times a given prime divides has a geometric distribution of mean . However, the new observation is that these random variables can be chained together into a single stochastic process, which we call the “zeta process”, which is an infinite divisibility chain. I used an agent to create an app to visualize this process:

The underlying process is generated by several exponential random variables at each prime: in the above instantiation of the process, two such variables are visible at the prime , and one variable at the primes . At a given choice of , is formed by collecting all the variables below this threshold (and for which all predecessors also lie below the threshold); in the above illustration, this amounts to one variable at each of the primes , leading to in this case. Additional visualizations in the app display the distribution of each , as well as the distribution of the hitting probability , which among other things can be used to give a quick solution to Erdős problem #1196.

The second app is rather different in nature, and is a somewhat whimsical attempt to display the motion of the heavens, both at “human” scales of space and time, and at more “astronomical” scales (in which the motion of the planets in particular are more apparent). It is very loosely inspired by the game “Katamari Damacy“, in which one absorbs both terrestrial and celestial objects of many different scales. Here is how the app typically looks at a human scale:

And here is how it looks when one’s perspective leaves the Earth’s atmosphere:

(As I did not want to render an entire explorable world in this app, the observer in the app is only limited to changing his or her size, from a human to a creature of comparable size to the Earth itself; they cannot move horizontally on the planet.) At the largest scales of space and time, the classic orrery diagram appears:

After lengthy conversations with the agent, I was able to implement many astronomical phenomena, including phases of the Moon, the effect of Earth’s rotation against the fixed stars (though one can also stabilize one’s view against those stars to see the Earth’s rotation more directly), and so forth.

One byproduct of learning how to use coding agents to create visualization apps is that it now becomes straightforward to convert any figure in one’s papers that had already been generated by code (e.g., in Python) into a more interactive, animated applet.

I can illustrate this with Figure 1 from my recent paper on the Gilbreath conjecture with Chase and Hunter, reproduced below:

This plot displays both exact and numerically simulated values of a certain poorly understood sequence relating to the Gilbreath conjecture, which I will call the “Gilbreath expectation sequence” here for lack of a better name. The definition of the sequence is as follows. Consider a “Gilbreath array” which is an inverted pyramid, where the top entries are independent exponential random variables of mean 1, and all the other entries are the absolute values of the differences of the two entries immediately above it. Thanks to the visualizer app, I can quickly give an example (with ):

The left diagonal entries are then random variables; the sequence are defined to be the expectation of these values. (The process is stationary, so in fact any entry on the row will have expectation .)

If one starts with the first normalized prime gaps (which have expectation about , and are conjecturally distributed asymptotically according to a geometric distribution), then standard conjectures (e.g., the prime tuples conjecture) predict that the row entries should decay like , at least for small . So the Gilbreath conjecture appears to be tied to how fast the sequence decays with .

One can in principle work out each value of as an explicit rational number by performing a certain complicated multivariate integral, but in the paper we only did this for (the orange line in the above figure); for the remaining we performed a Monte Carlo simulation with Gilbreath arrays to obtain a numerical approximation (in blue), which (as per the law of large numbers) agreed well with the theoretical values. A later calculation of Michael Ross extended the theoretical values to , maintaining the good fit:

The asymptotic behavior of the sequence remains mysterious. Clearly, it is not monotonic; in fact we cannot even prove it is bounded. The best we could do in our paper was establish an inequality which, roughly speaking, showed that cannot decay faster than .

In a recent preprint of Ross, these numerics were extended, and a rough empirical prediction

was proposed for some constants and (empirically ), where is the number of 1’s in the binary expansion of ; in particular, it is the fluctuation in this quantity that is intended to explain much of the non-monotonic behavior of . These are now all displayed in the following companion applet, which was a routine matter to generate in about an hour by the coding agent (which by this point has extensive experience with creating such apps, encoded via a “skill” markdown file that it maintains):

The appearance of the quantity may initially appear mysterious, but it is related to Lucas’s theorem, Kummer’s theorem, and the Sierpinski gasket. Consider for instance a Gilbreath array where all the entries are zero except for a single “spike”. Then the following Sierpinski pattern emerges:

Here is what an version of this picture looks like (with the spike positioned at the 32th entry):

The number of 1s in the row is then (if we index the rows starting from zero), which is at least of the same shape as the empirical prediction, albeit with different constants. (This sequence is also known as Gould’s sequence.)

Numerically, we seem to observe fragments of Sierpinski gaskets being generated before decaying (often due to “collisions” with other gaskets):

However, it is not clear to me at all what the asymptotic probabilistic model should be, even heuristically; it does not resemble any random shape model that I am familiar with. But perhaps there are readers more expert in probability theory or statistical physics who may be able to suggest such an asymptotic limit?

(I am writing here in my capacity as Director of Special Projects at IPAM.)

IPAM seeks program proposals from the mathematical, statistical, and scientific communities for long programs, workshops, and summer schools.  Most program proposals are reviewed at IPAM’s Science Advisory Board meeting, held in November each year.  Programs are selected on the basis of their scientific impact and contribution to IPAM’s goals. IPAM is committed to supporting a community where people of all backgrounds and points of view can engage, learn, and thrive.  If you would like to discuss your program ideas and prepare a proposal for IPAM’s consideration, you are encouraged to contact the IPAM Director. For more information visit: https://www.ipam.ucla.edu/propose-a-program/long-programs-2/

I am finding the newly revealed capability to code old applet ideas into reality to be very tempting to sink more time into, though I am certainly encountering the common “vibe coding” experience that the process can produce something that superficially resembles a finished product well before a satisfactory level of testing and review has been completed; indeed, it is the review process which is now the most time-consuming, to the point where I think any further advances in coding agent capability will have little impact on the new bottlenecks in the design process.

In any event, I spent a few hours working to realize a proposal I had made back in 2023 to automatically create diagrams to visually illustrate the logical flow of a given mathematical paper. At the time, Freddie Manners, extrapolating from the half-decent capability of the then-newly released ChatGPT 3.5 at this task, presciently predicted that “by the time a dedicated tool had been completed, the next general purpose engine would be better than it”.

With that in mind, I decided to focus not on the generation of the diagram – which now can be done at various levels of quality by any number of large language models – but on its presentation. The result is the following app, which can take a certain formatted JSON file of dependencies between theorem objects and produce an interactive graph which can be explored, edited and also exported (somewhat lossily) into other standard formats such as SVG, TikZ, quiver, or Mermaid. Here is a screenshot of a diagramming of the celebrated proof by Wang and Zahl of the three-dimensional Kakeya conjecture:

Using an LLM, I generated diagrams for eight papers for demonstration purposes, including for instance a diagram for Wiles’s proof of Fermat’s last theorem, or of Szemeredi’s proof of his famous theorem on arithmetic progressions (which sports a notoriously convoluted such diagram in the original paper), as well as a few papers of my own. If there are other requests to diagram particular papers, I can try to use an LLM to generate more examples; but my intention is for users of the app to create their own such diagrams, either by manually constructing them, or by directing their own AI tools to build the diagram in the required format (which is a JSON, with the precise specification given here).

I mentioned in the previous post that for these sorts of visualization apps, which work deterministically for a given set of inputs, the downside risk of LLM use to build the app is acceptably low. For this particular app, there is a complicating factor, which is that while the app does remain deterministic, the data I used to populate the app – namely, the above diagrams – are also LLM-generated. I have done spot checks comparing the diagrams against the source papers, and did not find any errors; however, they are not guaranteed to be 100% accurate, and should only be used as approximations to the logical structure of these papers rather than completely exact representations. (The latter might become deterministically extractable should the results of these papers become formalized in a proof assistant language, but this is not currently the case.) Still, I hope these sorts of diagrams can serve as a helpful initial guide when first trying to read and understand a complex paper.

With the advent of modern coding agents, many visualization projects that I had proposed in the past, but dropped due to the time and complexity of the coding portion of the task, have now become relatively feasible, in that a reasonable quality prototype (suitable for non-mission-critical tasks such as providing secondary visual aids, where it is not absolutely necessary that the product is 100% bug-free) can now be generated in a matter of hours using such tools. I don’t immediately plan to work on my entire backlog of such projects, but I did spend a few hours this weekend on one such project, namely the proposal from this 2016 blog post to visualize random variables as animated quantities, which can be either viewed numerically or displayed as a scatterplot. After some back and forth with the coding agent, I was able to come up with a working app. Here is a screenshot of the app displaying a visualization of Berkson’s paradox, which asserts that independent variables can become correlated to each other after applying a conditioning:

The app in fact is a “compiler” for a small, custom programming language (think of a simplified hybrid of Python and Excel) which allows for the introduction of random variables, manipulates them through operations such as arithmetic operations or conditioning, and then plots them as animations or as text. (The screenshot above is static, but when the app is live, it will update at the indicated speed.)

As always, I would be happy to receive feedback on the app, which I hope can be useful as a visual aid to understand basic probabilistic concepts such as independence or conditioning.

I have been interested in machine-assisted ways to do and teach mathematics from as far back as 1999, when I started coding several applets in Java 1.0, both for my complex analysis and linear algebra courses, as well as to visualize various mathematical objects I was interested in (such as honeycombs or Besicovitch sets). This was moderately successful; but the applets were time-consuming to program. Eventually, the standards for web pages stopped supporting this version of Java, and the applets became non-functional.

However, in the last few days I have begun the process of migrating much of my old web page and blog data to a more maintainable repository, using modern AI assistance. As an experiment, I asked the agent to port my old applets to a modern supported language (we landed on Javascript), and it managed to do so in a matter of hours, with all of my old applets now functional again, with even a few graphical upgrades (for instance, the Besicovitch set applet is now colorized, in contrast to my original monochrome version). I am particularly pleased to see the honeycomb applet that I wrote with Allen Knutson in 1999 come back to life, as this was a particularly tricky one to code by hand:

Notoriously, LLM-based coding agents can create various blatant or subtle bugs in their code; but in the porting of these two dozen or so applets, I could only find one minor bug (the handling of a drag event in one of the complex analysis applets had unwanted behavior when dragging outside of the main box), and in fact the agent identified two bugs in the original code that I was not aware of, so it ended up being a net wash as far as code quality was concerned. In any event, as these applets are meant to be secondary visual aids rather than critical components of a mathematical argument, the downside risk of such bugs is relatively low.

The process was painless enough that I decided to also try coding some new apps, in addition to porting the old ones. Back in 1999 I had an ambitious idea for a visualization tool for special relativity; this was before the release of the software tool Inkscape, but the idea I had in mind was basically “Inkscape, but in Minkowski space”. I had even started writing Java code for this app, but the code complexity became too much for me, and I abandoned the project. However, after a couple hours of “vibe coding” with an AI agent, I was finally able to generate an applet that matched the vision I had back in 1999, which can now be found here. A summary of the conversation I had with the agent to generate this code can be found here (it has been edited down to remove a large number of tedious technical implementation reports). While I have playtested the app somewhat, I would be interested in receiving further feedback on this “alpha” version of the applet, as I am sure (especially given the LLM-generated nature of the code) that there are still some bugs and rough edges to be ironed out.

After writing my blog post on the Gilbreath conjecture paper earlier today, I realized that I could similarly ask the agent to code a visualization tool for the Gilbreath conjecture to accompany the paper and blog post. After another few hours of conversation, this is now done; you can try out the visualization here. Again, the procedure was quite painless (see this transcript of the process), and I think I may add such interactive visualizations as supplements for future papers; as such supplements are not mission-critical to the core of the paper, I again feel that the downside risk of using guided interaction with LLM agents to generate such visualizations is acceptable.

Zachary Chase, Zach Hunter and I have uploaded to the arXiv our preprint Gilbreath’s conjecture: a Cramér random model and a deterministic analysis. This paper is motivated by a notorious conjecture of Gilbreath (also proposed eighty years prior by Proth), which one can state as follows: if one starts with the sequence of primes and repeatedly takes absolute differences of consecutive terms, then the first term of each subsequent row is always :

Coming from a PDE background, I like to think of this conjecture as a (discrete) nonlinear “wave equation” problem, where the primes are the “initial data”, the downward direction in the above pyramid is the arrow of “time”, and the “equation of motion” is that the value of the “scalar field” at any given point in “spacetime” is the absolute difference of the values of the two points directly above it. We will informally refer to solutions to such an “equation” as “Gilbreath arrays”.

Numerically, the conjecture has been verified for the first rows by Odlyzko. Asymptotically, the conjecture can be heuristically justified as follows. Firstly, because all primes other than are odd, it is easy to see that the first term of each row is odd, while all other terms are even. Next, if one starts with the first primes for some large and takes initial differences, then the prime number theorem tells us that the average size of the next row is about , and Cramér’s conjecture predicts that the maximum size should be . With each new row, the maximum size can only decrease (since for any natural numbers ), and so one would expect it likely on each row that the maximum size should drop by at least (unless it has already reached ). Since there are rows to go before one reaches the end, it seems extremely likely that the maximum size should drop down to at most by then, at which point the result is forced from parity reasons.

However, it seems well beyond current technology to try to make these heuristics rigorous; even the first step of proving Cramér’s conjecture is far out of reach. In our paper, we consider two more feasible directions:

• What is a realistic probabilistic model of the primes, and can one confirm the (asymptotic version of the) conjecture almost surely for such a model?
• Can one use deterministic arguments to reduce the (asymptotic) Gilbreath conjecture to more tractable looking (and heuristically plausible) statements about iterated differences of primes?

Let us first discuss the question of analyzing probabilistic models. One can strip away the first row and initialize using prime gaps rather than primes; it is convenient to also strip away the aforementioned parity structure, by eliminating the initial gap , and dividing all remaining gaps by , so that one now works with an initial sequence with no parity bias. The conjecture is now equivalent to the first row always being -valued:

The Cramér model suggests that the first normalized prime gaps should behave like geometric random variables of mean about . My co-author, Zachary Chase, established an analogue of the Gilbreath conjecture for a more slowly growing model. Here is a special case of his main theorem:

Theorem 1 Suppose the initial row entries of a Gilbreath array are drawn independently from a uniform distribution on for some . Then almost surely, all but finitely many of the rows have a -valued first entry.

The Cramér model morally corresponds to a value of comparable to , which is too large for the above theorem to apply. However, we were able to improve the argument, basically allowing to be anything of size . Furthermore, it was not necessary that the distribution be uniform: the important hypothesis was that the distribution not be concentrated in any -separated set, such as the even numbers, the odd numbers, or the multiples of . (See the paper for the precise formulation of “non-concentrated”.) Such a hypothesis is needed since if for instance all initial entries were divisible by , then this property would propagate down the array, and it would become extremely unlikely that the initial values would remain -valued. Our hypotheses are obeyed by the Cramér random model, and so we obtain a heuristic confirmation of the original Gilbreath conjecture for the primes.

One can informally explain our proof of the above result as follows. We consider the portion of the array generated by the first values for some large . Suppose that at some point deep in this portion of the array, a value that is larger than is attained. Then the two values above must satisfy the equation . So, either one of these values is at least , or one of them is and the other is . If one iterates this observation, one sees that is the base of an upside-down triangle of values, topped off by at least one location where the value is at least . If one iterates that observation in turn, we see that forms the base of a “tower” of upside-down triangles stacked atop each other, with the number of such triangles bounded by the maximum size of the initial data (in the “backwards light cone” of ). In the regime, it turns out that the number (or “entropy”) of such towers is subexponential in . So if we can show that each tower only can be created with an exponentially small probability, we can conclude by the standard techniques of the union bound and the Borel–Cantelli lemma.

At this point we use the following elementary observation. Suppose that some finite Gilbreath array coming from say initial data has been generated, and consider the effect of adding a new value to the initial data, which then triggers iterations of the absolute value difference operation for various values of until one reaches the new bottom vertex of the array. This difference operation has the property that the preimage of any -separated set is still -separated. Iterating this, we see that the set of values that make iterate to a -valued bottom vertex is also -separated. So as long as the distribution of avoids -separated sets, one can iterate this observation in to show that it is exponentially rare that large triangles of -valued vertices can be created.

We also consider an asymptotic continuous random model, in which the initial data are not natural numbers, but instead independently random non-negative real numbers with an exponential distribution, which we can normalize to have mean ; this heuristically is an approximate model for the Gilbreath array generated by the first normalized prime gaps, after dividing by the mean . In this normalized model, each entry of the row ends up having the same mean . The first few values of can be computed explicitly

However, the asymptotic behavior of remains unclear to us. We were able to show an inequality for any , indicating that cannot decay faster than , but we do not know whether this is the true decay rate. In any case a decay rate of (which is very weakly supported by numerical evidence) is consistent with the Gilbreath conjecture, as it would indicate that the Gilbreath array from the first prime gaps should end up being almost entirely -valued by merely steps, well before the steps needed to reach the bottom of the array.

Now we turn to deterministic analysis of Gilbreath arrays. Suppose we found some initial data that did not grow too quickly (e.g., one had a Cramér-type bound ), but still iterated to a final value that was not . What features of the initial data could generate such a failure of a Gilbreath-type conjecture? One way in which the conjecture could fail is if the Gilbreath iteration somehow produced a reasonably long consecutive string of zeroes (say, longer than ), as then the next few iterations would not act to decrease the magnitude of the non-zero entries bordering this string of zeroes. Such a scenario would be heuristically rate, as the parity of each element of the array can be worked out explicitly using the parity identity , and so constant-parity sequences of length say should be almost surely non-existent asymptotically by standard probabilistic heuristics.

Another bad scenario is if the Gilbreath iteration, after some medium number of iterations, produced an extremely long consecutive block (say of length ) which was entirely -valued for some . This block would then persist as a -block for a large number of iterations (equal to the length of the block), thus potentially delaying for a significant time the drop-down of the maximal value to below . For odd , one can use the parity analysis alluded to earlier to argue that the formation of such a block is extremely unlikely; but for even , we can only use such heuristics if we make strong assumptions of joint independence, as we did in the probabilistic analysis in our paper.

In any event, we were able to use purely elementary methods to establish an “inverse theorem” that states, roughly speaking, that the above two scenarios are the only ways in which a Gilbreath array can fail to have a -valued first entry. This basically arises from a more careful analysis of the towers of triangles alluded to earlier. (A previous argument involved considering ways to pack a large triangle by smaller triangles, leading to a MathOverflow question which was nicely answered by Fedja Nazarov and Anders Martinsson, but we later managed to optimize the argument to the point where the answer to this packing question was no longer needed.) So this in principle reduces the (deterministic) Gilbreath conjecture to several more tractable-looking (though complicated to state) assertions, though proving those latter statements seems well out of reach at the moment.

Suppose that one has a set of points in the plane, which we will think of as the complex plane . Let denote the number of unit distances determined by these points, i.e., pairs of points whose displacement obeys the equation

(It makes little difference for the asymptotics, but we will count the pair separately from here.)

The Erdös unit distance problem asks, for a given large number , what is the largest possible value of amongst all sets of cardinality ?

For instance, if one takes to be equally spaced collinear points with unit spacing, one can obtain a linear construction with . Erdös observed that one can improve this construction asymptotically:

Theorem 1 (Erdös construction) There exists point sets of arbitrarily large cardinality such that for some absolute constant .

In fact, in the construction one could take arbitrarily close to . Erdös famously asked whether had to be bounded above by ; and for decades there was significant effort expended on upper bounding , with the best known upper bound being , established by by Spencer, Szemerédi, and Trotter in 1984. We will note here that it seems extremely difficult to improve this upper bound. One reason for this is that if one replaces the equation (1) with the superficially similar equation

(i.e., replace the unit circle by a standard parabola), then the bound is best possible, as can be seen by taking to be a rectangle in the Gaussian integers of width and height . Hence any improvement of the bound would have to exploit some special property of the unit circle that is not shared by the parabola.

It came as some surprise recently when a team from OpenAI resolved the question of Erdös:

Theorem 2 (OpenAI construction) There exists point sets of arbitrarily large cardinality such that for some absolute constant .

The optimal value of is still unknown, but the best upper and lower bounds on are tracked at this page; currently we know that .

The construction in Theorem 2 is a heavily modified version of that in Theorem 1, and uses some non-trivial amount of algebraic number theory, in particular the device of Golod–Shafarevich towers of field extensions. However, it was later observed using the Mythos AI that one could get a weaker bound with less algebraic number theory, which after optimizing parameters yields the following intermediate result between Theorem 1 and Theorem 2:

Theorem 3 (Mythos construction) There exists point sets of arbitrarily large cardinality such that for some absolute constant .

Furthermore, by inserting Golod–Shafarevich towers back into the Mythos construction, one can recover the full strength of Theorem 2.

These results already have a number of expositions; see for instance this article of Alon et al., or this blog post of Bloom. As an exercise for myself, I recently spent some time trying to “digest” these constructions and place them on a common footing, with an emphasis on trying to find the minimal route to either heuristically or rigorously recovering these results relying on as little algebraic number theory as possible. The post here is a writeup of this exercise. (Disclosure: AI tools were useful for providing initial summaries of these arguments, as well as on explaining various fundamentals of algebraic number theory to me.)

The first (trivial) observation is that one can use rescaling to replace the unit distance by any other fixed distance. In particular, for any positive real , if we let denote the number of pairs whose displacement obeys the equation

then it is clear that any construction of a point set with a given value of can be rescaled to another point set of the same cardinality with the corresponding value of . It turns out to be convenient to work with values of that are asymptotically large, for instance the product of several large primes.

All the constructions of good point sets basically involve taking all the elements of a certain ring of algebraic integers up to some height. In the original construction of Erdös, was chosen to be the ring of Gaussian integers , but in fact any ring of integers in a non-trivial bounded degree field extension of would suffice to recover Theorem 1 (though always with the constant not exceeding ). To go beyond this, one has to start considering number fields of unbounded degree. As it turns out, the field extensions arising from Golod–Shafarevich towers are the most efficient for this purpose, and lead to Theorem 2; but one can work with the more elementary construction of number fields generated by many square roots of medium-sized primes, and this suffices for the intermediate result in Theorem 3.

The numerology can be explained as follows. Take to be a ring of integers in some number field of degree , and suppose for sake of argument that is the product of (rational) primes , which for simplicity we will assume to all have comparable magnitude, thus for some and all . Thus, is roughly of the size of . In practice one wants to impose some additional “splitting” conditions on these primes , but the prime number theorem, as well as variants such as the Chebotarev density theorem, suggest that we should be able to keep reasonably close to in size; for instance, if we select primes greedily then we can have . In particular we expect to have in practice.

By construction, splits into the product of rational primes. Moving up to the degree extension, one can optimistically hope that splits further into the product of primes in . Using conjugation symmetry, these primes might split into conjugate pairs . By selecting one element from each pair and multiplying, this generates solutions to (3) in . These solutions will of course have complex magnitude ; one can optimistically hope that they in fact have “height” in some sense.

To take advantage of this, take to be the set of points in of height . As has rank , we therefore expect the size of this set to be roughly

(For this heuristic discussion I will be deliberately vague about what the symbol means.) Meanwhile, using our solutions to (3), we expect to have

But this can be clarified by the heuristic (4). Taking logarithms, we expect to have

In the regime where the degree of the number field is held fixed, we thus expect to exhibit logarithmic type growth in , and on inserting this back into (5) we (heuristically) recover Theorem 1 (with the natural constant ). In fact it is not hard to turn the above heuristics into a rigorous argument, by setting equal the Gaussian integers and selecting all the primes to be , so that they split completely in by the Fermat two-square theorem.

But if one can permit the degree to grow in the construction, and in particular be superpolynomial in , then the above heuristics suggest that we can start improving upon Theorem 1 , and even get all the way to Theorem 2 if we can make the degree go to infinity while keeping the number of primes fixed.

If one naively tries this approach by forcing all the primes to split completely in a very high degree number field, one runs into significant technical difficulties, not least of which is the need to obtain good error terms in the Chebotarev density theorem, which touches upon such difficult questions as the Generalized Riemann Hypothesis and the existence of Siegel zeroes. From an algebraic number theory perspective, this is related to the breakdown of unique factorization in such number fields, as measured by the class group. The size of this group is in turn controlled by the discriminant of the field, as per the fundamental theorem of Minkowski in this subject.

But one can hope that the arguments are robust enough to tolerate a little bit of breakdown in unique factorization, so long as the class group is not too large. The most natural way to do this is to use all the standard machinery of algebraic number theory, such as the unique factorization of ideals. But there turns out to be a more elementary (though largely equivalent) approach, which is to weaken the target equation (3) to a congruence equation

This condition does not pin down the value of completely, but so long as we can keep the height of not too much larger than , it does restrict to a sufficiently small set of possible values that a simple application of the pigeonhole principle can allow one to conclude.

In order for this strategy to work well, one needs to locate high-degree number fields of controlled discriminant for which it is relatively easy to at least partially split one’s rational primes into ideals in this field . It turns out that requiring the field to have a tower structure and admit complex multiplication (which basically amounts to it including ) is already sufficient to get a satisfactory amount of splitting. To control discriminants, the most efficient choices are the Golod–Shafarevich towers, for which the (root) discriminant stays bounded; but a more naive choice of a tower of quadratic extensions also gives reasonable control on discriminants and is sufficient to establish Theorem 3.

The three constructions thus sit on a continuum, with the key differences being the selection of the key parameters (the number of primes multiplied together) and (the degree). The Erdös construction keeps the degree fixed and sends the number of primes to infinity. The OpenAI construction does the opposite, keeping the set of primes fixed but sending the degree to infinity. The Mythos construction is a compromise, in which the degree and the number of primes both go to infinity in a coupled fashion. In particular, one could easily imagine an alternate timeline of events in which the Mythos construction was the first to be discovered (by either humans or AI) after the Erdos construction as a reasonably natural modification of the latter, and then subsequently refined (again either by humans or AI) to the OpenAI construction once the significance of Golod–Shafarevich towers was realized.

In this recent paper of Pohoata, the terms “horizontal amplification” and “vertical amplification” were proposed for the technique of constructing large configurations by increasing and , thus the Erdös construction becomes a paradigm for horizontal amplification while the OpenAI construction becomes a paradigm for vertical amplification (and the Mythos construction utilizes both types of amplification). See also this paper of Bloom-Sawin-Schildkraut-Zhelezov for another recent application of vertical amplification.

— 1. Some more details —

Here we sketch how the quadratic extension approach can recover Theorem 3.

As indicated above, we will work with a product of (rational) primes of size . Our only requirements of these primes, beyond their size, will be that they are distinct and equal to mod , so that they split in the Gaussian integers. By the prime number theorem in arithmetic progressions, this allows us to take as small as , so in particular .

To construct , we start by taking distinct medium-sized (rational) primes of size for some medium-sized parameter (eventually, when we optimize parameters, we will take to be a small multiple of ). We will not need any further properties of these primes, so by the prime number theorem we can take as small as , so in particular . We will take to be larger than , so that the primes are distinct from the primes .

We will work in the number field
generated by and real square roots . For instance, if and , a typical element in this field would take the form

In this particular example, the ring of integers would consist of those elements (8) for which are rational integers. In general, the ring of integers can be slightly larger than this, but for our purposes we can just work with the “naive” ring of integers generated by and . A typical element of this ring then looks like

where are rational integers and we adopt the convention that . Let us define the (naive) height of such a ring element to be . Then the number of elements of of height at most is as long as is sufficiently large (again I will be vague about what means here).

Our main goal is to find a large number of solutions in to the congruence equation (7). As per the usual Minkowski embedding based on the various ways to embed into or , it is convenient to think of as a lattice in a -dimensional vector space, which (due to the presence of , which excludes purely real embeddings) is naturally thought of as the product of copies of . For instance, in the running example, one can identify a ring element with an element

of , and with this embedding becomes a lattice in . In general, the embedding of into is essentially the Walsh–Fourier transform, weighted by the various square roots of . (The appearance of the Walsh-Fourier transform reflects the fact that the specific number field we are working with is an abelian Galois extension with Galois group .) Because of this, one can readily compute the covolume of the lattice, which up to lower order terms is basically , which with our construction can be crudely bounded by . As long as we keep small compared to , this covolume will be small compared to and will end up being a lower order term.

The reason we care about the covolume (whichis essentially the square root of the discriminant) is because of Minkowski’s theorem, which we will use in this crude form: Minkowski’s theorem: any lattice in a -dimensional space of covolume will contain a non-zero lattice vector of length . Thus for instance will contain some vector of length , and any sublattice of of index will contain a vector of length , and thus also of height by inverting the Walsh-Fourier transform.

Anyway, suppose that we can find some sublattice (in fact, they will be ideals, but we will not need this) of for which we can obtain the inclusion

that is to say one has for all . Then clearly any element of will obey the congruence (7). An obvious choice of would be , but this is way too sparse: this lattice has index in , so the shortest vector one can hope to locate in it will have height , which is too large for our purposes. Instead, we would like to have index (which is the smallest it can be while still yielding the inclusion (9)); then will contain a non-zero element of height , which means that is equal to times an element of of height . The number of such elements is , which will end up being a lower order term that we can easily pigeonhole away.

We claim that we can find at least different sublattices of index that obey (9). To verify this claim, it is a straightforward matter to use the Chinese remainder theorem to work “prime by prime”. Indeed, it suffices to show for each of the primes dividing , that there are different sublattices of of index that obey the inclusion

We can descend now to the finite ring , which is a -dimensional vector space over the finite field . The complex conjugation operation descends to an involution on this vector space, and we are looking for subspaces of dimension with the property that

So now we just need to understand the structure of . The general Wedderburn–Artin theorem tells us that this ring is the product of finite fields, but we can be much more explicit here in this specific situation. Exactly as Minkowski embedding maps rings in number fields into product of copies of and associated to the real and complex embeddings of the ring, we can also embed into a product of copies of and , depending on how we assign square roots to or in or the quadratic extension . We can illustrate this with the running example. As mod , the square roots of in stay in . Suppose first that also splits into square roots in . Then we can embed into by mapping

By counting elements we see that this embedding is in fact an isomorphism. If instead does not split, so that now lie in , then we can embed into by mapping

thus we drop half of the previous embeddings as being conjugate to the half that we retain. Again, counting shows that this is an isomorphism.

In general, one can show that is isomorphic to either (if all the split in ) or (if at least one of the does not split). Furthermore, in the former case the copies of organize into conjugate pairs (corresponding to flipping to ), and in the latter case the copies of organize into conjugate pairs. By selecting one element from each conjugate pair, and taking to be the joint kernel of such elements, we can generate either or different subspaces of dimension with the desired property that . By the aforementioned Chinese remainder argument, this gives the claimed lattices of index .

Invoking Minkowski’s theorem, this now generates non-zero vectors of height obeying (7). There is a technical issue that some of these vectors could conceivably collide with each other; however there is a further Chinese remainder theorem argument (which I will omit here) that shows that any such can belong to at most such lattices. So the number of distinct generated by this argument is at least , and by pigeonholing one can now also get at least at least solutions to the equation

of height for some of height . As long as we select

then the type factors can be neglected, and we approximately have

up to lower order terms. If we choose to be a small multiple of , then we soon calculate that , and we recover Theorem 3.

Theorem of the Day has 'new acquisitions': Theorems no. 247-248

Theorem of the Day has 'new acquisitions': Theorems no. 249-251

Theorem of the Day has 'new acquisitions': Theorem no. 228, 229, 230, by R.A. Fisher, Poncelet and Ore

Theorem of the Day has 'new acquisitions': Theorem no. 231, 232, 233, 234

Theorem of the Day has 'new acquisitions': Theorem no. 235, 236, 237

Theorem of the Day has 'new acquisitions': Theorem no. 238 and 239

Theorem of the Day has 'new acquisitions': Theorem no. 240 and 241

Theorem of the Day has a 'new acquisition': Theorem no. 242, the Polya-Redfield Enumeration Theorem

Theorem of the Day has 'new acquisitions': Theorems no. 243-246

Theorem of the Day has a 'new acquisitions': Theorem no. 227, Cauchy's Theorem in Group Theory

Theorem of the Day has a 'new acquisitions': Theorem no. 226, Wolstenholme's Theorem

Theorem of the Day has 'new acquisitions': Theorem no. 223, 224, 225, by Tutte, Green and Regiomontanus