Papers for

mathematical software developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

All-even point sets in planes and three-dimensional spaces studied

All-even sets in $\mathbb{R}^2$ and $\mathbb{R}^3$

Abstract: Call a finite nonempty point set $S\subset\mathbb{R}^d$ all-even if for every direction $\ell \in \mathbb{P}(\mathbb{R}^d)$, the number of hyperplanes perpendicular to $\ell$ that intersect $S$ is even. In 2026, Francisco Santos presented a question of Juan Benigno Seoane-Sepúlveda on the existence of all-even sets in dimensions $3$ and higher, together with examples of such sets in dimension $2$. Call a set $S\in\mathbb{R}^d$ line-all-even if for every direction $\ell \in \mathbb{P}(\mathbb{R}^d)$ the number of lines parallel to $\ell$ that intersect $S$ is even. As Santos pointed out, every all-even set in $\mathbb{R}^3$ is line-all-even. We conjecture that there exist no line-all-even sets in $\mathbb{R}^3$ that affinely span $\mathbb{R}^3$ We show that our conjecture is equivalent to the statement that every planar all-even set satisfies a certain property, which we call height-rigidity. This property has a natural interpretation in linear algebra terms. Furthermore, we present a hierarchy of properties of planar point sets that imply height-rigidity. We construct several all-even sets in the plane, including some infinite families, and show that all the sets we constructed are height-rigid. In addition, we prove that every all-even set in the plane that can be covered by six or fewer parallel lines is height-rigid.

Wed 28 OctComputational Geometry
The gist
The paper studies special groups of points called all-even sets where every direction sees an even number of planes or lines hitting the points. The authors explore these sets in two and three dimensions and propose that no such sets exist in three-dimensional space that span it fully. They relate this idea to a property called height-rigidity, which they investigate through examples and mathematical equivalences. This work clarifies the structure of these unusual point sets and contributes to understanding geometric configurations.
Open → 2610.38864v1

Semi magic squares and moment conditions reveal new permutation thresholds

Moments of Magic Squares: Line-Sum Conditions, a Permutation Threshold, and Random Energies

Abstract: Every semi-magic square of order $n$ satisfies the axial moment identities $\sum_{i,j}s_{ij}j^m=\sum_{i,j}s_{ij}i^m=M(n)\sum_jj^m$ for all $m\ge1$, where $M(n)=n(n^2+1)/2$. For real matrices the converse requires $1\le m\le n-1$, whereas for arrangements of $\{1,\dots,n^2\}$ fewer moments suffice once $n\ge14$. We define the permutation threshold $k^*(n)$ as the least $k$ such that every arrangement satisfying these identities for $1\le m\le k$ is semi-magic. In terms of the column-sum deviations $γ_j$, the degree-$k$ conditions state that $\sum_jγ_jt^j$ is divisible by $(t-1)^{k+1}$, linking $k^*(n)$ to the Prouhet--Tarry--Escott problem. While Schur's bound on real zeros gives $k^*(n)\le\sqrt{2(n-1)\log(n^4/4)}$, we prove the converse realisability bound $k^*(n)\ge(\sqrt2-o(1))\sqrt n$ (and $k^*(n)\ge(\sqrt6-o(1))\sqrt n$ when $4\mid n$) by perturbing semi-magic squares with complementary row pairs via horizontal swaps. We also show that $k^*(n)=n-1$ for $3\le n\le13$, $k^*(n)=n-2$ for $14\le n\le17$, and $k^*(n)\le n-3$ for $n\ge18$, and determine $k^*(n)$ for $18\le n\le40$ with computer assistance. Finally, at the $k=1$ level of the hierarchy, we specialise the Mantel--Hubert quadratic assignment variance formula to obtain exact means, variances, and limit laws under a uniform random arrangement for the full line-sum energy $E_{\mathrm{full}}$, for the four-term energy $E_4$ combining the first moments and the two diagonals, and for Loly's moment of inertia, and find that $|L_4|=14{,}639{,}440$ arrangements of order $4$ satisfy $E_4=0$.

Wed 28 OctDiscrete Mathematics
The gist
Magic squares are grids of numbers where the sums of rows, columns, and diagonals are equal. The authors studied patterns in these squares using moments, which are like weighted sums. They found the minimum number of moment conditions needed to guarantee a grid is semi-magic, a threshold linked to classical number theory problems. They also analyzed the behavior of random arrangements mathematically and used computers to understand these thresholds for squares up to size 40.
Open → 2610.38386v1

Geometry of the 120-cell revealed by golden number dissections

The 120-Cell Dissected by the Hyperplanes of Its Final Stellation: the golden ring Z[phi] as foundation, from Kramer's seven cells to 2,455,201 cells in 338 orbits

Abstract: The diagonals of a regular pentagon dissect it into eleven pieces and draw a pentagram; the dodecahedron dissected by the twelve face planes of its inner core gives Kramer's seven "elementary cells" of 1982. We define the stellation dissection of a golden regular polytope in any dimension as the dissection of the convex hull of its final regular stellation by the facet hyperplanes of the core, show that the core has phi^(-d) of the inradius of the hull for d = 2, 3, 4, and carry the dissection out for the first time on the 120-cell. The foundation is the arithmetic of the golden ring Z[phi], the ring of integers of Q(sqrt 5): vertices and hyperplanes live in Z[phi]^d, every orientation test is the exact sign of an element of Z[phi], decided with integers, and the pieces are named by sign vectors. We develop this foundation from scratch (conjugation, norm, units, the primes sqrt 5, 2, 3, the exact sign test, the lattice x -> (x, conj x), the vertex modules of the dodecahedron and the 120-cell, the icosian ring) and let it carry the geometry. The definition bifurcates in dimension four: the star cut at depth phi^(-4), a unit, has 2,455,201 cells in 338 orbits of H4; the hereditary cut at depth 1 - phi^(-4) = sqrt 5 / phi^2, a unit times the ramified prime, induces the three-dimensional dissection on every facet and has 8,161 cells in 8 orbits. New here: all vertices of the dodecahedral and of the hereditary dissection lie in the vertex module of the polytope being cut, whereas the star cut needs the denominators 2, 3 and 5; the seven kinds of pieces of the dodecahedron are exactly the I_h-orbits of sign vectors, with stellation layer equal to the number of plus signs. We catalogue the four-dimensional pieces and treat the circumscribed disc, ball and 4-ball. Every number quoted is recomputed exactly by a script whose output is reproduced in an appendix.

Wed 28 OctComputational Geometry
The gist
The paper studies a complex four-dimensional shape known as the 120-cell, dividing it into many smaller pieces using certain geometric planes. The authors use the properties of the 'golden ring,' a special number system based on the golden ratio, as the mathematical foundation. They carefully count and classify over two million resulting pieces, linking these to symmetry groups and smaller shapes inside the 120-cell. This work explores deep connections between geometry, number theory, and symmetry in higher dimensions.
Open → 2610.38369v1

Human and AI team up to find new polynomials with smaller Mahler measure

Breaking the high-degree barrier in Lehmer's problem with a human-AI discovery loop

Abstract: While artificial intelligence has made rapid progress in mathematical reasoning, many open problems depend on structure that is revealed only through large-scale computational exploration and analytical synthesis. One such example is Lehmer's problem from 1933. It asks whether the Mahler measure of an integer polynomial, which measures how far its roots stray from the unit circle, can be made arbitrarily small. Previously, constructing irreducible polynomials with integer coefficients and small Mahler measure has been carried out systematically only for even degrees $d \le 180$. At higher degrees, Boyd's analytical one-parameter family frequently factors, skipping nearly 50% of target degrees and leaving no general construction for arbitrary $d$. Here, we address the high-degree regime through a human-AI discovery loop, in which we extend the conversational prompting with a fast numerical pipeline, an exact symbolic verifier, and large-scale distributed search. The AI agent prototypes numerical and symbolic solvers locally, launches parallel searches across distributed clusters and works with the human researcher to extract and verify mathematical hypotheses. Through this interactive loop, we derive a five-parameter construction, which we call the Generalized Boyd algorithm. It eliminates degree-skipping and constructs irreducible polynomials with Mahler measure strictly below Boyd's limit point $α_1 \approx 1.255434$ for every target degree. Evaluated across all even degrees up to 2000, our approach improves upon six previously published values and holds 99.6% of all best known records. With this work we release the verified dataset of polynomials with minimal Mahler measure across all studied even degrees.

Wed 21 OctArtificial Intelligence
The gist
Lehmer’s problem asks if certain math objects called integer polynomials can have measures (called Mahler measure) that get arbitrarily close to one. The new work uses a loop where humans and AI work together, combining fast numerical methods, exact checks, and large-scale searches to find new constructions of these polynomials. Their approach works for very high degrees, beyond what was done before, and finds many records. This collaboration produces a verified dataset of polynomials with the smallest known Mahler measures for many cases.
Open → 2610.30277v1

Coherent differentiation generalizes derivatives and finite differences using monoid indices

Coherent differentiation with a monoid of degrees: derivatives, Taylor expansion, finite differences...

Abstract: Coherent differentiation has been introduced a few years ago as a refinement of the (categorical semantics of the) differential lambda-calculus and of differential linear logic, compatible with the determinism of computation, and hence in categories where addition of morphisms in the hom-sets is only partially defined. In this setting differentiation is implemented by a kind of ''tangent functor'', with the difference that it maps an object to its object of summable tuples rather to a tangent bundle. In our earlier work, these tuples were pairs in the case of simple differentiation, and families indexed by integers when dealing with Taylor expansion and the Fa{à} di Bruno formula. We push this idea further, considering now tuples indexed by an arbitrary commutative partial monoid satisfying a nonnegativity condition. The monoid structure on these indices plays a crucial role in the definition of the ''differential'' calculus associated with this ''tangent functor''. In that way, and without changing the general categorical infrastructure of coherent differentiation, this theory accommodates new notions of ''differentiation'' of which we describe several instances. Among many others, such notions include various forms of finite differences as well as Taylor expansion truncated at any fixed degree, and finite Taylor expansion of a fixed finite degree with a remainder.

Wed 21 OctLogic in Computer Science
The gist
Differentiation is a way to understand how things change, but traditional methods assume you can always add changes together. This paper talks about a more flexible way, called coherent differentiation, which works even when addition is only partially defined. The authors extend this idea by using sets of indexes called commutative partial monoids to organize the changes, letting them describe many kinds of differentiations, including finite differences and truncated Taylor series. This generalization keeps the mathematical structure but lets the method apply in more situations.
Open → 2610.29874v1

Trust-region radius rules influence optimization step length and cost

A numerical study of radius update rules in trust-region algorithms

Abstract: Part I [arXiv:2606.30202] and Part II establish which trust-region radius update mechanisms can fail and under which hypotheses they must succeed. Neither says where the thresholds sit once a rule runs with real constants, or how the rule interacts with the model Hessian and the subproblem solver. This paper turns them into nine falsifiable claims and settles what it can, on four designed problems where the theory's quantities are computable and on CUTEst, where only aggregate cost is visible. Every mechanism runs in one Julia package written for this study, so two runs differing in one component differ in nothing else. The rule is worth less than the model and more than nothing. Crossing the mechanisms with four model Hessians puts $96.5$ per cent of the variation on the model and $1.6$ on the rule, and the rules separate most under the most accurate model rather than least. Uncapped R-grad is the robust default among the criticality-anchored rules, though the retrospective rule is ahead of it on this collection. No constant escapes the side conditions. For every cap there is a minimiser at which the constraint stays active, and for every anchoring constant a flatness on which escape takes arbitrarily long. The second of these is proved here as well as measured, and the proof uses no property of the model or of the subproblem solution beyond $\|s_k\| \leq Δ_k$. The radius rule governs the length of the step, and so the cost of a run. The model decides the search direction, and with it whether the run converges at all.

Mon 19 OctMathematical Software
The gist
Trust-region algorithms are used to find the best solution to a problem by taking steps within a certain size, called the radius. The authors studied different ways to update this step size, showing that the choice of update rule affects the length of each step and the overall cost of finding a solution. They found that while the model used to decide the step direction matters most, the strategy for changing the radius also has noticeable effects. Their work includes tests on designed problems and a package that lets people compare these rules fairly.
Open → 2610.26134v1

Deep learning identifies topological equivalence of group actions on surfaces

Deep Learning of Topological Equivalence Classes

Abstract: We demonstrate an application of deep learning to the problem of identifying whether two generating vectors correspond to topologically equivalent finite group actions on Riemann surfaces, showing how architectures developed for semantic understanding have use for pure mathematical problems. In doing so we discuss how desired algebraic structure influences model design, and explore which structural properties of topological equivalence classes the model has successfully learnt.

Thu 15 OctMachine Learning
The gist
This work shows how deep learning can help tell when two mathematical descriptions of shapes called Riemann surfaces are essentially the same from a topological point of view. The authors use neural network techniques originally made for understanding language and images to solve a pure math problem involving finite group actions. They also explain how the structure of the mathematical objects influenced their design of the deep learning model. Lastly, they analyze what features the model learned about these topological equivalence classes.
Open → 2610.21981v1

Continuous archimedean t-norms recovered from values along increasing curves

Reconstruction of continuous Archimedean t-norms from their section along an increasing curve

Abstract: The completion problem for continuous and Archimedean triangular norms (t-norms for short) consists in describing all the operators that take predefined values on a given subset of the unit square, and it reveals how much of a t-norm is determined by partial information. In this paper, we focus on the case where this subset is a parametric curve. We first formulate the problem in terms of the functional equation satisfied by an additive generator, and we then restrict our attention to curves of the form $(x,p(x))$ with $p$ continuous and increasing, which include the classical diagonal and horizontal section cases. We determine when the known values are compatible with a continuous and Archimedean t-norm, and we show that every completion is obtained by choosing the additive generator on a subinterval and reconstructing it elsewhere from the values on the curve. This description is recursive in general and becomes a closed formula under additional conditions, recovering the two classical results as particular cases. The completions are not unique, and we give examples with infinitely many t-norms sharing the same section along a curve. Finally, we combine our results with the reconstruction of a t-norm from its values above a level curve, which determines exactly the additive generator on that subinterval, so that the two pieces of information are complementary and together determine a unique completion.

Wed 14 OctLogic in Computer Science
The gist
This paper studies how much can be known about a special kind of mathematical operation called a continuous Archimedean t-norm from knowing its values just along a curve in a square. The authors show how to reconstruct the whole operation if you have some information from a curve defined by a function that goes up continuously. While the reconstruction is not always unique, they describe how to find all possible completions and under what conditions a unique solution emerges. They also combine these findings with previous results to pinpoint cases where two types of partial information together identify a t-norm exactly.
Open → 2610.20874v1

Polynomial activation networks become identifiable with high degree

Linear Independence of Polynomial Compositions with Bounded Input Degree

Abstract: We prove the weak composition-independence conjectures of Kohn, Marchetti, Massarenti and Mella. The proof uses deformations of rational curves and a single kernel of the linearized equation. Riemann-Roch gives a contradiction from tangent fields with controlled poles. By settling these conjectures, we prove that a neural network with a general polynomial activation function of sufficiently large degree is identifiable.

Wed 14 OctMachine Learning
The gist
This paper proves some long-standing math questions about how compositions of polynomials behave when their inputs have limited complexity. The authors show that neural networks using general polynomial activation functions of sufficiently large degree have a unique structure that can be identified. This means such networks can be better understood and analyzed mathematically. Their approach uses advanced geometry tools like curve deformations and fields on surfaces to reach this conclusion.
Open → 2610.20825v1

Formalised key theorems from Annals of Mathematics published dataset

A dataset of formalised theorem statements from the Annals of Mathematics

Abstract: Recent progress in autoformalisation of mathematics using AI has been impressive. Measuring this progress requires datasets of formal statements that are both hard and trustworthy. We present AnnalsChallenge: 50 formalised theorem statements written by hand in Lean 4 using Mathlib. Each is the main result of a paper published in the Annals of Mathematics since 2020. Every formalisation was manually reviewed and then audited by AI. We release them without formalised proofs.

Tue 13 OctArtificial Intelligence
The gist
Formalising mathematical statements precisely is important for using AI to check and understand complex math. The authors created a set of 50 main theorems from recent top math papers, written carefully in a formal language called Lean 4. These theorems were reviewed by both humans and AI to ensure accuracy. The dataset includes statements but not the full proofs, providing a challenging resource to test AI tools that work on complex math.
Open → 2610.18301v1

Infinite new approximations for Euler's constant from matrix methods

An Infinite Family of Apéry-like Recurrences for Euler's Constant

Abstract: Euler's constant $γ$, also known as the Euler-Mascheroni constant, remains one of the most elusive constants in mathematics. Despite extensive study, its irrationality is still unproven, and Apéry-like approximations of it are remarkably scarce. We present a novel identity that expresses $γ$ in terms of a Meijer G-function and its first few derivatives. This identity is then generalized and used to systematically generate infinitely many Apéry-like approximations of $γ$ using a Conservative Matrix Field construction based on the Meijer G-function.

Fri 9 OctSymbolic Computation
The gist
Euler's constant is a special number in math that is very hard to understand, especially whether it is irrational or not. The authors found a new mathematical formula that links this constant to a special function called the Meijer G-function and its derivatives. Using this formula, they created a method to generate infinitely many approximations similar to famous ones by Apéry. These new approximations are built using matrix constructions tied to this special function. This work expands the toolbox for approximating this elusive constant.
Open → 2610.13919v1

Machine learning finds new link invariants and unknotting moves

Computations of the slice genus and the unknotting number of links via machine learning

Abstract: Links are disjoint unions of circles smoothly embedded in $S^3$. We use reinforcement learning and Bayesian optimisation to obtain new upper bounds on several link invariants that are not known to be algorithmically computable: the slice genus and the unknotting number for links, and the strong slice genus for algebraically split links. We also compute lower bounds using known invariants. Combining the upper and lower bounds, we obtain new exact values in many cases. Our unknotting agents can reproduce the non-additivity of the unknotting number for several counterexamples due to Brittenham and Hermiller, in some cases finding new unknotting trajectories.

Wed 7 OctMachine Learning
The gist
Some shapes made by looping and linking circles in 3D space can be very complicated, and mathematicians want to measure their complexity using numbers called invariants. Two important invariants, the slice genus and the unknotting number, are usually very hard to calculate. The authors used AI techniques like reinforcement learning and Bayesian optimization to find new upper limits on these numbers for many such shapes. They combined these results with known lower limits to exactly determine these invariants for many cases, and even found new ways to simplify these shapes.
Open → 2610.10206v1

Bolzano system solves hundreds of open math problems automatically

From Expert-Guided Proof Search to Automated Open-Problem Solving

Abstract: Large language models are increasingly contributing to mathematical research, where progress often depends on efficient proof search, incremental improvements and careful verification. We describe Bolzano, a multi-agent open-source system that uses parallel prover agents with a verifier agent and maintains a human-readable research state. Initial manual use on expert-selected problems yielded 8 results whose proofs were checked by domain experts. Motivated by these case studies, we ran Bolzano without problem-specific human guidance on about 3,800 open problems extracted from four sets of papers, solving about 200 open problems. One experiment used papers accepted to STOC 2026, a top conference in theoretical computer science. There, we answered four questions raised in the papers, as confirmed by their authors.

Wed 7 OctArtificial IntelligenceComputation and Language
The gist
Finding mathematical proofs can be very tricky and usually requires expert knowledge. The authors built Bolzano, a system where multiple automated proof solvers work together, checking each other's results and recording progress understandably. Initially, experts guided the system to solve some tough problems and confirmed the proofs. Later, Bolzano worked on thousands of open problems without human hints and solved around 200, including some from top computer science papers confirmed by the original authors.
Open → 2610.09769v1

Riemann zeta function zeros found mostly distinct simple and on critical line

More than 83.9% of the zeros of the Riemann zeta function are distinct and more than 67.35% are simple and on the critical line

Abstract: Let N(T) count the nontrivial zeros of the Riemann zeta function up to height T with multiplicity, N_d(T) the distinct ones, and N_0^s(T) those that are simple and on the critical line. We prove liminf N_d(T)/N(T) >= 1645064/1960733 = 0.83900...; earlier work proves 0.83699..., and a report we have not verified claims 0.83805.... Hence more than 67.80% are simple. Also liminf N_0^s(T)/N(T) >= 0.67353...; earlier work proves 0.67250..., and reports we have not verified claim 0.673492. Two estimates of Lamzouri are improved: at least 88.93% of the zeros are simple or on the critical line, and the proportions of simple zeros and of zeros on the line average at least 83.67%. By the unconditional form of Montgomery's pair-correlation theorem the energy, a sum of a test function over pairs of zeros, is known asymptotically. A zero of multiplicity d contributes d^2 to it and nearby zeros contribute too, so a lower bound for such pairs leaves less energy for multiple zeros. The proof has three steps. First, for zeros at least a fixed fraction of the mean spacing apart, a large sieve inequality lets their pairs be used in full, with multiplicities. Second, their contribution is bounded below by a computer-assisted inequality for seven or eight consecutive zeros which distinguishes simple and double zeros. Its correction terms telescope, as increments of a storage function. Third, the test function is chosen to make this contribution large, at the cost of more energy. We also prove upper limits for what such inequalities can give with the two main test functions. The lower bounds and these limits are proved in Lean 4, analytic inputs included. The proofs use three axioms beyond those of Mathlib, one per inequality. Each records that a search program returned true; Lean's kernel does not check the run itself. This work is an experiment in AI-assisted mathematical research.

Tue 6 OctLogic in Computer Science
The gist
The paper studies the zeros of the Riemann zeta function, which are important in number theory. It proves that over 83.9% of these zeros are distinct and more than 67.35% are simple and lie on a special critical line. To reach these results, the authors use a combination of mathematical inequalities, computer-assisted verification, and improvements on previous estimates. Their approach involves analyzing how zeros contribute to a particular energy sum and uses a formal proof system with some AI-assisted checks. This work improves known percentages about the distribution and nature of the zeros, important for understanding fundamental properties of prime numbers.
Open → 2610.08965v1

Isabelle ML metaprogramming teaches automatic polynomial degree estimation

A First Introduction to Isabelle/ML Metaprogramming: Automatic Estimation of Polynomial Degrees

Abstract: This article offers an introduction to metaprogramming in Isabelle/HOL for beginners, based on a running example for working with multivariate polynomials. The example is motivated by our formalisation of universal Diophantine pairs. We describe the implementation of the poly_degree command, which computes upper bounds on the total degrees of multivariate polynomials and automatically proves their correctness. The complete metaprogram handles a variety of special cases but herein we present a simplified version for the sake of exposition. We describe our development process and design decisions; our goal is to offer a small and self-contained tutorial on Isabelle/ML, for mathematicians who want to get started with metaprogramming.

Tue 6 OctLogic in Computer Science
The gist
Figuring out how complicated a polynomial is by measuring its degree can be tricky, especially with many variables. The authors show how to use Isabelle/HOL, a tool for checking math proofs, to write a program that automatically finds an upper limit on these degrees and proves the result is correct. They focus on making a clear introduction for mathematicians new to programming in Isabelle’s ML language. Their example involves multivariate polynomials linked to specific number theory problems known as Diophantine pairs.
Open → 2610.08359v1

Efficient algorithms verify special abelian surfaces in cryptography

Supersingularity and Superspeciality Verification of Abelian Surfaces

Abstract: Supersingular abelian surfaces are essential in isogeny-based cryptography. Despite this, we have no efficient algorithm to verify if a given abelian surface is supersingular. In this work, we initiate this research topic by giving an efficient Monte Carlo algorithm to verify if an abelian surface over $\mathbb{F}_p$ is supersingular in $O(\log p)$ with negligible failure probability, and an efficient conclusive algorithm if the order is smooth. We derive this algorithm by a careful analysis on the structure of supersingular Jacobians over $\mathbb{F}_p$. Furthermore, we derive efficient algorithms to verify if an abelian variety of any dimension is minimal or maximal, and to verify if a Jacobian of any dimension is superspecial.

Thu 1 OctCryptography and Security
The gist
It is important to check if certain mathematical objects called abelian surfaces have a special property (supersingularity) used in cryptography. Before this work, no fast method existed to do this verification. The authors developed a quick probabilistic algorithm and a certain conclusive one under some conditions that can efficiently tell if an abelian surface is supersingular. They also created ways to verify related properties for similar objects in higher dimensions.
Open → 2610.01924v1

Skill evolution improves lean theorem provers with mutation techniques

SkillEvoLean: Mutation-enhanced skill evolution for Lean provers

Abstract: Skill evolution offers a promising way to improve large language model agents without updating their parameters, but its use in formal theorem proving remains underexplored. Existing methods mainly target natural-language reasoning, improving skills by analyzing successful and failed trajectories and incrementally revising solving strategies. Although the Lean verifier provides reliable execution feedback, when all sampled trajectories fail, existing skill evolution methods lack successful trajectories from which to infer effective update directions. Furthermore, these methods also focus mainly on the root instruction file, thus underexploring the evolution of reference knowledge including mathematical concepts and proving techniques. To address these limitations, we propose a mutation-enhanced skill self-evolution framework for building skill-augmented Lean provers. The framework jointly evolves a high-level solving policy and its reference knowledge through progressive and mutation-based updates. Progressive evolution derives local improvements from successful and failed trajectories, while mutation is triggered when no complete proof can be generated, sampling mathematical concepts to produce and select new skill candidates under verifier feedback. We evaluate our method on MiniF2F, PutnamBench, the 2025 International Mathematical Olympiad (IMO 2025), and the 2026 USA Mathematical Olympiad (USAMO 2026). Under the same backbone model, trajectorysampling budget, and test-time compute, our method achieves proof success rates of 100.0%, 90.6%, 4/6, and 4/6, respectively, with GPT-5.5, outperforming the baseline methods. Further analysis shows that concept-guided mutation outperforms random-text-guided mutation by 6.9 and 8.2 percentage points on MiniF2F and PutnamBench, respectively, while solving one additional problem on both IMO 2025 and USAMO 2026.

Thu 1 OctMachine Learning
The gist
Teaching computers to solve math problems can be tricky when they keep failing and have no examples to learn from. The authors created a way for the Lean theorem prover to improve its problem-solving skills by making smart changes when it gets stuck, rather than just copying past successes. They tested this approach on challenging math problem sets and found it worked better than earlier methods. This helps computers get better at proving math ideas without changing their core programming.
Open → 2610.01799v1

Linear differential equations with rational coefficients can be found efficiently

Rational linear forms of linearizable ordinary differential equations

Abstract: Every scalar ordinary differential equation of order at least three with rational right-hand side that is locally linearizable by a point transformation admits a linear form with rational coefficients over the same coefficient field. We prove this by restricting the derived symmetry algebra to a coordinate line and recovering a scalar differential operator from rational symmetry-jet data. The construction uses differential elimination and linear algebra; it does not require the symmetry generators or a linearizing transformation to be solved for. A single integer parameter suffices to choose the line.

Thu 1 OctSymbolic Computation
The gist
The paper shows that certain complicated equations involving derivatives can always be rewritten in a simpler, linear form if their terms come from rational functions. The authors provide a way to find this simpler form without directly solving the usually hard problem of finding symmetry or transformations. Their method uses algebra and calculus tools to do this with just one parameter choice, making the process more manageable.
Open → 2610.01338v1

Evolving prover interfaces improve automated math proof efficiency

Growing an Agent/Prover Interface: Evolutionary Tool Design for Cost-Efficient Theorem Proving in Rocq and Lean

Abstract: Recent achievements in AI-assisted mathematics require intensive interaction of agents with proof assistants to generate machine-checked proof certificates. Agents interact with proof assistants such as Rocq or Lean through an interface that controls what the agent receives from the prover and the cost of these interactions. Today, these interfaces are adapted from tools designed for humans and not optimized for agents. We propose an evolutionary method where a frontier model incrementally proposes new features and only keeps the ones that improve the overall performance of smaller models. We demonstrate the effectiveness of our method by growing, on a curated set of mathematical problems, \rme, a new MCP server for the Rocq prover. On the held-out \texttt{test} split of miniF2F-Rocq, an agent equipped with \rme outperforms both the baseline that only exposes the Rocq compiler and an established MCP server, across four models from two families, in success rate, cost per solve, and time per solve. Although evolved for Rocq, the resulting server transfers to Lean, improving cost and time per solve on a subset of PutnamBench. We release \rme and its port to Lean.

Wed 30 SeptArtificial Intelligence
The gist
Proving math problems using computers needs a way for AI agents to talk with software that checks the proofs. The usual tools are made for humans, not these AI agents, making the process slower and costlier. The paper’s authors used a method that tries new interface features step-by-step and keeps only the improvements. They created a new tool for a prover named Rocq, which made AI agents solve math problems more successfully, faster, and cheaper. This tool also worked well when used with a different prover called Lean.
Open → 2609.39544v1

Lean 4 formalizes key group theory algorithms for exact computation

Machine-Checked Computational Group Theory in Lean 4: Operational Schreier-Sims Stabilizer Chains, BSGS Sifting, and Backtrack Ordered Partitions

Abstract: We present gap-lean4-port (Release v0.2.0), a machine-checked formalization of foundational algorithms in computational discrete algebra and permutation group theory within the Lean 4 interactive theorem prover and Mathlib4. While modern proof assistants feature extensive abstract algebraic hierarchies, constructive and operational permutation group algorithms, such as Charles Sims' 1970 Schreier-Sims algorithm, transversal tree lookups, and backtrack ordered partition refinement, have remained largely unformalized in dependent type theory. Here, we formalize the operational algorithmic core of the Groups, Algorithms, Programming (GAP) system library across four foundational modules, proving 35 machine-checked theorems with zero unproven conjectures (sorry) and zero custom axioms under standard Lean 4 foundations (propext, Classical.choice, Quot.sound). We machine-check: (1) Schreier-Sims stabilizer chain hierarchies (StabLevel, StabChain) and the invariance of incremental transversal tree extensions (extendSchreierPoint_invariant); (2) single-level and multi-level Schreier sifting reductions (siftOneLevel, siftFull), proving that full sifting strictly fixes all base points (siftFull_fixes_all_basePoints); (3) constructive soundness and completeness of Base and Strong Generating Set (BSGS) membership testing (membershipTestKnownBase_iff_mem); (4) backtrack ordered partition cell refinement (splitCellByPred), proving mutual cell disjointness, union conservation, and exact cardinality preservation; (5) cyclotomic extension rings Z/nZ(eps_m) and machine-check GAP's exact size theorem |Z/nZ(eps_m)| = n^m; and (6) executable Bezout inverses via Extended Euclidean GCD (Nat.gcdA) over residue rings Z/nZ. The entire codebase compiles deterministically under 'lake build RequestProject' and is openly available at https://github.com/pCwOrM/gap-lean4-port.

Tue 29 SeptLogic in Computer ScienceSymbolic Computation
The gist
Complex math methods for studying symmetrical structures in groups have long been hard to check by computers. The authors used a tool called Lean 4 to precisely verify fundamental algorithms for working with permutation groups, ensuring no mistakes in their logical steps. They translated important building blocks from a popular math software (GAP) into this formal system, proving 35 key properties rigorously. This makes it easier to trust computations involving these groups and helps build reliable mathematical software.
Open → 2609.38492v1

AI agent rediscovers geometric invariant with high precision fitting

Can an AI Agent Rediscover a Blaschke-Curve Invariant?

Abstract: We study generalized Blaschke curves as a controlled environment for AI-assisted mathematical rediscovery. For one fixed degree-four Blaschke product, an agent receives numerical coordinates of the six pair-lines determined by each of 80 boundary configurations. The target theorem is withheld from the task instructions. The saved research log reports rejected geometric hypotheses and a homogeneous cubic fitted to polygon sides. Its frozen coefficients predict 480 lines from 80 unseen parameter values, with a recorded RMS scale-free residual of $8.88\times10^{-17}$. Discovery-set diagonals provide an out-of-fit consistency check, not a fully held-out test. A separate one-configuration run reports insufficient evidence for invariance. A post-review deterministic degree-search baseline also recovers the cubic, so the experiment does not establish an advantage over polynomial fitting. We present this single-instance case study as a protocol for separating conjecture, numerical validation, and proof, with explicit limitations concerning agent metadata, prior knowledge, and reproducibility.

Tue 29 SeptArtificial Intelligence
The gist
Finding hidden mathematical patterns is hard, but this study explores how an AI can help rediscover them without being told what to look for. The AI was given many examples of special curves and their related lines, then tried out ideas to explain what patterns might hold. It ended up fitting a very accurate mathematical formula predicting new lines almost perfectly. However, the AI’s result did not clearly beat a simpler traditional method, so the study focuses on how to carefully distinguish guessing from proof. The authors suggest their work as a method to organize how AI helps in math research, noting limits on evidence and reproducibility.
Open → 2609.38369v1

Formal library supports language generation in the limit research

GenLimitLib: A Formal Library for Language Generation in the Limit and AI-Assisted Mathematical Research

Abstract: We present GenLimitLib, a source-aligned Lean 4 library for language generation in the limit. Introduced by Kleinberg and Mullainathan at NeurIPS 2024, language generation in the limit studies a theoretical question motivated by LLMs: how to generate valid new strings from observed examples. This young and rapidly evolving field offers a natural testbed for studying large-scale formalization. GenLimitLib contains formal developments for 30 papers. It extracts shared definitions and reusable proof components while preserving paper-specific assumptions and statements, and records relationships across papers. In this way, GenLimitLib provides a concrete and structured view of the literature. We show through mathematical case studies and LLM experiments how our library can support both human mathematical research and AI-assisted research. Our Library: https://github.com/pengzhang91/generation-in-the-limit-lib.

Tue 29 SeptMachine LearningLogic in Computer Science
The gist
Language generation in the limit studies how to create new valid strings based on examples, inspired by large language models. The authors created GenLimitLib, a formal Lean 4 library that organizes and proves key concepts from 30 related research papers. This library helps researchers by structuring shared definitions and proofs while keeping each paper’s unique assumptions clear. The authors also show how their library supports both human and AI-assisted mathematical research through examples and experiments.
Open → 2609.36663v1

Solver Agent framework enables AI calculations for physics and geometry

Solver Agent: an Agentic AI Framework for Theoretical Physics Computations Applied to F-theory Uplifts of O3-planes and S-folds

Abstract: We introduce Solver Agent, an AI framework based on large language models for calculations and proofs in mathematics and theoretical physics. The solution process is tracked through a persistent ledger that records assumptions, derivations, and computations. A central agent delegates tasks to specialized sub-agents, while independent agents verify both intermediate steps and the final result. This setup improves the traceability, reproducibility, and verification of computer-assisted calculations. Applying Solver Agent, we study global F-theory uplifts of Type IIB orientifolds and their S-fold generalizations. We establish sufficient conditions for Weierstrass models over projective threefolds with terminal $\mathbb{Z}_k$ quotient singularities ($k\in\{2,3,4,6\}$) to give $\mathbb{Q}$-factorial projective elliptically fibered Calabi-Yau fourfolds with isolated Gorenstein terminal quotient singularities. These geometries realize O3-planes and S-folds, where local D3-brane probes of the latter yield four-dimensional $\mathcal{N}=3$ superconformal field theories. Using stringy invariants, we derive fixed-point contributions to Hodge data and Euler characteristics, and show that these Euler corrections determine the localized D3-brane charges required for tadpole cancellation. We illustrate these results using toric hypersurface constructions, where a single three-dimensional polytope determines both the Type IIB Calabi-Yau threefold and the F-theory base; here, the orientifold double cover naturally forms a bisection of an alternative genus-one-fibered uplift with discrete $\mathbb{Z}_2$ gauge symmetry. Finally, we provide methods for toric computations and four-form flux analysis in four-dimensional $\mathcal{N}=1$ compactifications with non-abelian gauge sectors.

Mon 28 SeptArtificial Intelligence
The gist
Calculations in advanced math and physics, especially string theory, can be very complex and hard to follow. The authors created Solver Agent, an AI system that tracks every step it takes in calculations, making it easier to check and reproduce results. They used this system to study exotic shapes in string theory that relate to physical phenomena called O3-planes and S-folds. Their work helps understand symmetries and charges in these theories, offering new ways to perform related computations.
Open → 2609.35958v1

Specialized knowledge helps smaller models solve more math problems

When Does Structured Knowledge Help Neural Theorem Proving?

Abstract: Does structured mathematical knowledge help LLMs prove theorems in Lean 4? If so, for which models, and does the answer vary by problem? Formal libraries such as Mathlib encode 285,000+ verified theorems with syntactic dependencies, but the semantic layer mathematicians rely on for discovery (analogies, generalizations, cross-domain bridges) remains implicit. We introduce MathAgent, which builds this layer as a knowledge graph, MathKG, and uses it to augment LLM theorem provers. MathKG connects 364 Mathlib theorems and definitions by 9,434 typed semantic edges inferred via LLM-based relation extraction anchored to verified Mathlib declarations. We run a controlled ablation across four augmentation modes (no context, knowledge-graph context, Mathlib retrieval, both) and five models: Qwen3-8B/32B, their Lean-specialized derivatives Goedel-Prover-V2-8B/32B, and Claude Sonnet 4.6, on miniF2F, plus PutnamBench and MathOlympiadBench for Sonnet. Three findings emerge. (i) Specialization dominates augmentation: Lean fine-tuning adds 33-38 percentage points of solve rate in every mode, and a specialized 8B model beats a $4\times$ larger general one by 29-35 points, while no augmentation mode improves solve rate by more than 3 points. (ii) Augmentation is capability-conditioned: knowledge-graph context helps small models but hurts large ones, with the specialized model gaining more relative to its general base at every scale. (iii) Yet the augmentation modes solve different problems: an oracle selecting the best mode per problem solves 6% to 58% more than the unaugmented prover, a complementarity effect that strengthens on harder problems (32% more on PutnamBench). These results motivate adaptive strategies that select augmentation by model capability and problem. Code, data, and artifacts are available at https://github.com/sarehnabi/mathagent

Mon 28 SeptArtificial IntelligenceMachine LearningLogic in Computer Science
The gist
This paper studies when adding structured math knowledge helps AI models prove theorems. The authors show that AI models trained specifically for math proofs solve many more problems than just adding extra math facts. Smaller models benefit more from this added knowledge than bigger ones. Also, different ways of adding knowledge help solve different problems, suggesting tailored approaches could improve results.
Open → 2609.34460v1

Symbolic regression improved by linking expression parts to their behaviors

SNIP++: Fine-Grained Symbolic-Numerical Alignment for Symbolic Regression

Abstract: Mathematical expressions and the numerical behavior they produce are two views of the same underlying function, and connecting them is central to scientific discovery. Symbolic Regression (SR) relies on this connection directly: it searches for an expression that reproduces a given behavior. Recent multi-modal models learn this connection by embedding symbolic expressions and their numerical behavior in a shared representation space. We show that this embedding space is only globally aligned: complete expressions correspond to complete behaviors, but the contribution of individual parts of an expression is not represented. This granularity gap leaves the model unable to tell how a local edit to an expression changes its behavior, the central operation in SR. We introduce a compositional alignment method that closes this gap: a structural positional encoding exposes the substructure of an expression to the encoder, and a multi-granularity contrastive objective grounds each subexpression in the behavior it produces before propagating this grounding to the full expression. The resulting representations close much of the modality gap between symbolic and numerical embeddings, reliably distinguish the effects of local edits that the original alignment cannot, and transfer to external SR corpora.

Fri 25 SeptNeural and Evolutionary ComputingArtificial IntelligenceMachine Learning
The gist
Symbolic regression tries to find math formulas that explain observed numbers. The paper’s authors point out that previous AI models link whole formulas to their outputs but don’t understand which parts of a formula cause which effects. They build a new method that breaks down formulas into smaller pieces, linking each to its own behavior before combining them. This lets the model better see how small changes in formulas change the results, helping it work more accurately.
Open → 2609.31965v1

Formalizing Carlesons theorem using the Lean proof assistant

Formalizing Carleson's Theorem in Lean

Abstract: We present the formalization of Carleson's theorem in the proof assistant Lean. This paper describes the mathematical content, organization of the project, the blueprint, and the main design decisions behind the formalization. It is the result of a large collaborative effort, written and developed in public.

Fri 25 SeptLogic in Computer Science
The gist
Carleson's theorem is a complex mathematical statement that can be challenging to verify by hand. The authors used a tool called Lean, which helps check proofs with computer assistance, to fully formalize this theorem. This means they converted the entire proof into a precise language that a computer can verify without mistakes. Their work involved an extensive collaborative effort and thoughtful planning to organize the project effectively.
Open → 2609.31334v1

Knottedgraph enables scalable topological analysis of complex scientific networks

KnottedGraph: Scalable knotted-graph topology for scientific and mathematical discovery

Abstract: Scientific data span heterogeneous structures, including coordinates, networks, surfaces, volumes and fields, yet their topology can be quantified within a common framework through graph connectivity, cycle structure, genus and spatial embedding. Graph- and homology-based summaries do not determine spatial embedding, while standard knot and link polynomials require extensions to accommodate branching graphs. Here, we introduce KnottedGraph, a computational framework that converts such scientific representations to knotted graphs that retain graph connectivity and spatial embedding together. It constructs projected diagrams and PD codes, enabling various topological analyses, including Yamada-polynomial evaluation for topological classification. For scalable exact evaluation, it combines partial resolutions that leave the same unresolved connections and optimizes their processing order; the resulting algorithm is verified against published topological invariants of knotted graphs with up to 500 crossings. This scalability enables us to introduce an LLM-assisted mathematical-discovery methodology, in which computational topological data generated across knotted-graph families are used to identify candidate closed-form formulas. With this approach, we identify analytical Yamada-polynomials for generic graph motif families exhibiting Abelian and non-Abelian word sequences. Together, these scalable capabilities make knotted-graph topology computationally accessible across scientific domains, enabling large-scale classification and introducing a route from topological data to LLM-assisted AI4Math discovery.

Fri 25 SeptMathematical SoftwareComputational GeometrySymbolic Computation
The gist
Scientific data often involves complex shapes and connections that are hard to study all at once. The authors created KnottedGraph, a tool that turns these complex data structures into knotted graphs that keep both how parts connect and their 3D layout. This makes it possible to perform advanced mathematical analyses to classify and understand these structures more easily. Their method is efficient enough to handle very complex graphs and helps discover new mathematical formulas with the help of AI.
Open → 2609.31152v1

Explicit 27 by 27 by 27 tensor disproves Comons conjecture

A 27 x 27 x 27 counterexample to Comon's conjecture

Abstract: We report an explicit construction of a 27 x 27 x 27 symmetric tensor with rational entries that has tensor rank 55 over the rational numbers and symmetric tensor rank 56 over the complex numbers, providing a small counterexample to Comon's conjecture over the rational, real, and complex numbers. The construction follows the framework of symmetric adjoins introduced by Shitov. The primary technical contribution of this work is to prove a special case of Conjecture 6 appearing in Shitov's seminal 2018 work.

Wed 23 SeptData Structures and Algorithms
The gist
Comon's conjecture suggested that certain ways of measuring complexity in symmetric tensors would always match up. This paper finds a small, explicit example where those measurements differ, contradicting the conjecture. The authors build on previous theoretical ideas to prove a specific special case that leads to this counterexample. This result clarifies how symmetric tensors can behave in ways previously thought impossible.
Open → 2609.28292v1

Multidimensional shift spaces achieved using substitution sequences

Pimp my fixpoint: sofic realization of multidimensional substitution-based shift spaces

Abstract: In symbolic dynamics, the fixed-point construction from arXiv:0910.2415 defines shift spaces of finite type whose configurations embed infinite hierarchies of tilings. This article provides a "black box" abstraction of this method phrased in terms of substitutions and $S$-adic limit spaces operating over sequences of increasingly large alphabets. By quantifying the amount of information computed by the substitutions at each level, and using a suitable parallel model of computation, we provide a simple positive criterion of multidimensional soficity that generalizes classical examples from the literature.

Wed 23 SeptDiscrete Mathematics
The gist
Some math problems study patterns that repeat in complicated ways across many directions. This paper explains a new way to build these patterns using sequences of substitutions that grow in size, making it easier to understand and recognize certain complex patterns called sofic shift spaces. The authors give a clear rule that shows when these patterns can be described by simpler, more manageable models. Their work extends earlier examples and helps identify new classes of these patterns in multiple dimensions.
Open → 2609.28207v1

Neural methods find forces causing 3D fluid flow breakdowns

The Neural Forcing for Three-Dimensional Incompressible Navier-Stokes finite time blowup

Abstract: We present a two-part neural framework for forced three-dimensional incompressible Navier--Stokes flow. Part~I develops the computational forcing system. A physics-informed neural model generates structured external-force trajectories, candidates are optimized through differentiable PDE rollouts or PPO-Clip, and selected forcings are frozen and checked by independent fixed-force replay. Part~II provides the mathematical certification layer. It separates neural candidate discovery from continuum analysis, derives integrated reciprocal-vorticity criteria that imply Riccati-type growth and finite-time loss of smooth continuation, develops a validated computational-to-continuum transfer strategy, and establishes a conditional positive-probability closure for a nondegenerate neural output law. The proof is complete at the continuum level.

Sun 20 SeptMachine Learning
The gist
The paper addresses how certain forces can cause three-dimensional fluid flow to become unstable and break down in a short time. The authors created a two-part method: first, they use neural networks to design and test forces that might trigger this breakdown. Then, they apply rigorous math to prove these forces can cause the fluid’s smooth behavior to fail. This work helps bridge computer experiments with strict mathematical analysis for fluid dynamics.
Open → 2609.23934v1

Exact Euclidean shortest vector problem is NP-hard for cyclic lattices

Euclidean SVP is NP-hard for Cyclic Lattices

Abstract: We prove that exact Euclidean SVP is NP-hard under deterministic polynomial-time many-one reductions for full-rank cyclic integer lattices, equivalently full-rank ideals of $R_N:=\mathbb{Z}[X]/(X^N-1)$ in the coefficient norm. Hardness holds with $N=q-1$ for a varying odd prime $q$. As an application, we prove the same hardness for the algebraic class of NTRU-form lattices $\{(x,z)\in R_N^2:Hx\equiv z\pmod{QR_N}\}$, where $H,Q$ are unrestricted inputs. The decision problems are NP-complete, and the exact search problems are NP-hard under polynomial-time Turing reductions. No hardness claim is made for cryptographic NTRU parameter subclasses or key-generation distributions.

Tue 15 SeptComputational Complexity
The gist
Finding the shortest vector in certain special mathematical grids called cyclic lattices is very hard for computers to solve exactly. The authors showed that this problem is as hard as the toughest problems known in computer science (NP-hard), meaning no fast method is likely to exist. They also proved this for a related type of lattice used in cryptography known as NTRU-form lattices. However, this result does not claim hardness for the parameter choices typically used in practical cryptographic systems.
Open → 2609.16711v1

Oriented matroids counterexamples break longstanding combinatorics conjectures

Neither simpliciality nor mutation connectivity: conjectures of Las Vergnas and Cordovil-Las Vergnas fail

Abstract: We construct a simple rank-$7$ oriented matroid on $24$ elements with no simplicial tope, disproving the Las Vergnas simplex conjecture from 1980. We then show that the mutation graph on uniform oriented matroids is disconnected for infinitely many values of rank $r$ and ground-set size $n$, disproving the Cordovil--Las Vergnas conjecture from 1988.

Mon 14 SeptDiscrete Mathematics
The gist
Some old ideas in math thought every special shape called an oriented matroid had a simple kind of face, but this paper shows a counterexample where none exist. It also shows that certain transformations between these shapes can't always connect all shapes, disproving another guess from decades ago. The authors built specific examples proving these old beliefs wrong.
Open → 2609.15850v1

Mathematics fields invited to help make AI safer and more controllable

Math for AI safety: an invitation for mathematicians

Abstract: Artificial intelligence threatens to outrun human understanding and control. New mathematics is needed to design AI that is legible, steerable, and cooperative with humanity. I organize this invitation by mathematical field, so you can turn straight to your own: logic and game theory for cooperation; probability for agency and world-models; algebra and representation theory for learned features; analysis and geometry for generalization and training dynamics. Each section ends with an open problem that is accessible to a working mathematician with no prior experience in AI safety.

Mon 14 SeptArtificial Intelligence
The gist
AI systems might become too complex for people to understand or control easily. The authors explain how different areas of mathematics—like logic, probability, algebra, and geometry—can help create AI that humans can better understand, guide, and cooperate with. They organize the discussion by math topic and suggest open problems in each area to encourage mathematicians to get involved. This approach aims to build AI systems that are safer and more aligned with human values.
Open → 2609.15289v1