WorksComputer Science
Autonomous AI Agents Systematically Diverge From Human Preferences in Proof Formalization
Abstract
Artificial intelligence (AI) systems have ushered in a new age of proof abundance, but helping humans understand these proofs requires new attention to the differences in how AI agents and humans pursue a proof-making task. We present "simulated collaboration", a methodology that allows us to examine two key questions: (1) the relative attention AI agents pay to surface syntax or, conversely, deeper underlying semantics, and (2) how and where AI agent preferences for what to do next diverge from human preferences. On a set of nine major human collaborations in Lean with 4.7M definitions across more than 6K commits, we find that, over the course of proof construction, AI agents (1) are far more strongly drawn than humans to explicitly marked gaps; (2) show a relative aversion to densely connected proof centers and to complex or surprising proof goals; and (3) are relatively attracted to surprising proof bodies, which they tend to regularize toward baseline. Our results highlight important blind spots and potential interventions for future human-AI collaboration in mathematics.
Introduction
The use of proof assistants in mathematical reasoning has become increasingly popular and is now a core part of many recent successes in AI-enabled mathematics [e.g., Ope26a; Ale+26; Alp26; Ope26b]. One reason for this lies in the way people interact with these systems, which enable humans to decompose a theorem into a system of elaborately specified subproblems, each of which can in turn be resolved, in a formally verifiable fashion, by systematic search.
However, the fact that a proof is found in such a system tells us little about how the AI system resolved the formal statement or what subproblems it chose to visit and why. As has become increasingly apparent, the proofs that AI systems discover may not align with human concepts [18], and can be verbose, circuitous, redundant [5, 40], misformalized [9], and may even exploit holes in the proof assistant kernel itself [17]. These systems may solve problems, but such limitations of “problem-solving for problem-solving’s sake” have long been recognized in the mathematical community [e.g., Gow02; Thu06], and have now become a key point of contention [e.g., Avi26; Kon26; Abo+26; KT26; Lei26; Avi+26; Adv26], with even the proponents of AI in mathematics calling for “AI assistance in formalization that preserves high-level human control and agency over the proof discovery process” [16].
With this goal in mind, effective collaboration between humans and AIs becomes contingent on a fundamental question:
In particular, many visions for “Math 2.0” suggest that AI agents should serve as aligned collaborators that work towards the long-term goals of human mathematicians. In this collaborative setting, choosing what to work on next – which sub-lemma to resolve, which theorem to formalize next – has wide-ranging consequences.
Agents whose preferences and behavior differ from those of humans can be beneficial and complementary to human understanding, resolving laborious but straightforward statements, or formalizing definitions. But not all complementarities are beneficial: agents who are in some way misaligned can produce costly mismatches between intuition and formal code, which can in turn introduce subtle errors and distortions of human intent, redirect human effort into “AI-friendly” styles, and frustrate human desires to establish correspondences between the formal reasoning of a proof assistant and the conceptual structure of the proofs they are supposed to implement.
These questions are brought to the fore when agents are given freedom in what subproblems to attack: giving over the choice of the next step involves renouncing, in part, a key aspect of human agency. As agents become more capable, we expect this kind of unguided “help me” request to become increasingly common. Existing evaluations of AI agents in formal mathematics, however, have been unable to probe behavior in this unrestricted regime because they test performance on pre-selected problems where there is a clear, and human-chosen, prescription for what to work on. As a result, we know little about what AI agents attend to when the choice of what to work on is left to them, and how an AI agent’s preferences differ from human ones.
At the broadest level, when we study this question, a key distinction is between the syntax of a proof – the organization of its textual form – and its semantics – the mathematical content that form represents. First, there is strong evidence to indicate that syntax plays an outsized role in how AI systems behave. Source code is repetitive and predictable, so neural models exploit such surface regularities as shortcuts in place of the intended task. As such, the mathematical reasoning of LLMs degrades when names or numbers are modified in ways that leave the underlying problem unchanged, with their accuracy depending on how probable the task and its text are under the training distribution. As it turns out, LLM-based provers for Lean are no exception: a prover may succeed almost every time on one formulation of a theorem but mostly fail on a semantically equivalent one, and a statement’s surprise under the prover is a useful signal of which formulations it will solve. Second, language models trained on code can learn internal representations of program semantics that go beyond its surface form. However, in contrast to cases which have an obvious and efficient physical representation that can be shared by both human and machine, the representations that can be induced from complex data may be far less identifiable and far more variable, particularly in the case of expert mathematical performance [51]. How the two aspects drive an agent’s choice of the next step is, therefore, an open question – and one with direct consequences for whether that choice complements or conflicts with humans.
For these reasons, our work here addresses two related research questions:
RQ1. To what extent in mathematical collaboration do AI agents respond to and work with the surface syntax of a proof, or, conversely, attend to some underlying semantics?
RQ2. To what extent do these preferences of AI agents either match or differ from those of human experts?
To address these questions, we present the simulated collaboration method as shown in Figure 1 (see Methods for full details). Like previous work [61], we replay the full histories of human collaborations, but we leave the choice of the next step to the agent under a deliberately broad objective, so that where an agent chooses to work becomes the outcome of interest rather than an input. Simulated collaboration draws on a large database of human formal proof-making – Git repositories that track the activities of human collaborations as they formalize a proof over time – and allows us to compare the differences between the observed human actions and the actions that would have been taken by an AI prompted to “take the next step”. We compare the human baseline to three modern models (Claude Opus 4.6, Google Gemini 3.1 Pro, and GPT-5.2).

Figure 1. Summary of our experimental setup. After downloading a Lean formalization repository, we remove all merge commits and all commits in which no Lean file was modified. For each of the total remaining human parent commits, written as , an agent is called to “take the next step”, producing an artificial child state . In our analysis, we then compare the human-authored child state to using a set of features extracted from each.
Using this methodology, we find the following:
AI agents respond primarily to surface-level markers of explicit proof gaps (RQ1). Definitions containing a
sorrymarker account for 59–92% of AI agent modifications, against 19% of human modifications, and the probability that an AI agent modifies a definition falls markedly with its distance to the nearestsorrymarker. AI agents also modify larger definitions less often than humans, and their edits are larger and less often connected to other definitions edited in the same commit.Where AI agents go beyond syntax, their modifications concentrate on different regions of the dependency graph than human modifications (RQ2). AI agents preferentially modify definitions near the “edges” of a proof – either close to, or far from, the leaves and roots – compared to humans, who tend more to modify definitions in the denser intermediate regions.
AI agents are attracted to high-surprise proofs and act to regularize that surprise toward baseline (RQ2). AI agents preferentially modify definitions whose bodies have high per-token surprise, and their modifications reduce it strongly towards baseline; human modifications leave the aggregate surprise of their definitions (almost) unchanged.
Results
We present our results in two parts. First, we summarize the high-level statistics of our dataset on edit shares – i.e., how many definitions are added or modified – and volumes – i.e., the total number of characters added or modified. We then look at the driving preferences behind which definitions actors choose to edit, relying primarily on a logistic regression model that predicts whether the actor in question (human or agent) will choose that definition to edit. The model uses features of the definitions available in the parent commit as predictors, based on syntactic and semantic properties of the definition in question; see Methods for detailed information on statistical analyses.
Our syntactic predictors are definition length and the presence of “sorry” markers; a sorry is a special Lean keyword that allows a proof to compile in the absence of a complete proof. Syntactic predictors track the most obvious surface-level features of the proof.
Our semantic predictors track the more substantive ways a proof knits together. They come in two forms: network position and surprise. The steps in any Lean proof are composed of a series of definitions, such as intermediate lemmas, that draw on each other in a way that (roughly) induces an acyclic graph. Some definitions serve as leaves (e.g., axioms) that, in turn, are drawn upon by more elaborate definitions, all the way up to the final desideratum. For each definition in the largest weakly connected component of this graph, we track its maximum shortest-path distance to all accessible leaves, and its distance to the nearest (significant) root.
For measuring surprise, we track the per-token surprise of the definition’s “type signature” – equivalent to a problem statement – and body – how the definition currently attempts to resolve the problem statement. Informally, high-surprise signatures are unexpected problem statements (in the context in which they appear), while high-surprise bodies are unexpected ways to prove those problem statements (again, in the context in which they appear).
Summary Statistics: How much do actors edit?
Table 1 shows the overall edit shares of the human and AI agents aggregated across all nine repositories. At the broadest level, all actors are within an order of magnitude of each other, suggesting that our broad “take the next step” prompt triggers roughly similar levels of activity.
| Actor | Added | Modified | Removed | Total | ||||||
| Count | % | Median chars. | Count | % | Median chars. | Count | % | Median chars. | Count | |
| Human | 10,618 | 0.90 | 133 | 6,975 | 0.59 | 20 | 4,913 | 0.41 | 129 | 1,185,143 |
| Claude | 4,640 | 0.39 | 171 | 6,178 | 0.52 | 149.5 | 408 | 0.03 | 81 | 1,176,797 |
| Gemini | 1,974 | 0.17 | 193 | 4,876 | 0.42 | 84 | 618 | 0.05 | 104 | 1,174,808 |
| Codex | 2,056 | 0.17 | 135 | 1,394 | 0.12 | 103 | 57 | 0.00 | 110 | 1,175,224 |
| Overall | 19,288 | 0.41 | 145 | 19,423 | 0.41 | 72 | 5,996 | 0.13 | 120 | 4,711,972 |
Table 1. The number and per-actor percentage of definitions that were Added, Modified, or Removed, aggregated across all commits we consider. The three categories are mutually exclusive, with the remaining definitions left unchanged. Median chars. gives the median number of characters inserted plus deleted across the signature and body. Total is the number of definitions for the actor across all commits, including unchanged definitions.
At the same time, we do see systematic differences. Humans have the highest overall rates of addition (0.90%), modification (0.59%), and removal (0.41%). As such, their combined edit share is 1.90%, which is higher than 0.95% for Claude, 0.64% for Gemini, and 0.30% for Codex. These differences are significant overall (, ) and pairwise against Gemini () and Codex (), but not against Claude (), whose per-commit edit share varies widely from commit to commit.
The largest difference lies in how actors remove code. Agents almost never delete code, while humans are eight to eighty-six times as likely to remove definitions (all ). There is also a difference in the rate of additions between humans and agents. Humans add 10,618 definitions, compared with at most 4,640 additions by an agent (Claude).
Previous research from software engineering suggests that such patterns may correspond both to mundane tasks, such as code refactoring, and to creative changes in approaches to problem solving [36, 45, 28]. In contrast, fewer removals and additions show that agent edits are more monolithic – i.e., they are larger and involve fewer definitions – which may result in code structures that are less understandable, in line with concerns raised by mathematicians [7] and previous research [40].
Corroborating the previous evidence of more monolithic changes, when agents modify an existing definition, their edits tend to be larger. As shown in Table 1, the overall median number of characters modified is 20 for humans, compared with 84 for Gemini (150 for Claude and 103 for Codex). These differences are significant across all human–agent comparisons (Gaussian mixed model of log edit size, Holm-corrected for Gemini and for Claude and Codex).
Modification Preferences: Where do actors change the existing proof?
We report results from a logistic regression model, shown in Figure 2, which provides a clear account of four basic differences between what features are associated with human and AI modification behavior.

Figure 2. Fixed-effect coefficients (log-odds, 95% Wald CIs) for our model from Section A.4 with the underlying numerical data shown in Table 6. Human shows the baseline coefficients for the human actor (filled: ; hollow: n.s.). The remaining panels show each AI actor’s deviation from that baseline, given by predictor actor interaction coefficients.
| Predictor | Human | Claude | Gemini | Codex |
| Intercept | ||||
| Has sorry | ||||
| Surprise, signature (rank) | ||||
| Surprise, body (rank) | ||||
| Max leaf (rank) | ||||
| Max leaf (rank) | ||||
| Root distance (rank) | ||||
| Root distance (rank) | ||||
| Size (rank) | ||||
| Previously modified | ||||
| (edited) | ||||
| AUC (fixed effects) | ||||
| AUC (with random effects) |
Table 6. Fixed-effect coefficients corresponding to Figure 2, main text.
Syntactic Preferences
In particular, and compared to humans, we find first that AI agents focus on filling local gaps – AI agents are strongly attracted to editing definitions with explicit sorry markers. This preference is clearly for the syntactic sorry marker itself, rather than something that is associated with a problem area, as can be seen by the effect of distance from sorry, shown in Figure 3. All three agents show stronger-than-human preferences for editing a definition with a sorry, and a much stronger-than-human decline in preference as one moves away from the sorry in the dependency graph.

Figure 3. Modification share as a function of minimum distance to a sorry across actors. The leftmost panel shows each distance’s share of all available definitions. The remaining panels show the share of each actor’s modifications.
In a similar vein, we find that while humans are strongly attracted to editing the longer definitions (), agent deviations from this human preference are large and negative (, and for Claude, Gemini and Codex).
As Figure 2 shows, there are many potential drivers of the attention of AI agents, of which focusing on sorry markers is only one. Yet, regarding outcomes, working on sorry-carrying definitions is one of the strongest signals of AI agents compared to humans. For all three agents, at least 59% of their edits involved definitions that contained at least one sorry (Claude, 92%; Gemini, 80%; Codex, 59%), compared to just 19% of the human edits. These preferences have knock-on effects. For example, while human edits often involve neighboring regions of the dependency graph (62% of human edits are to definitions connected to another definition that was edited), AI agents are far more likely to make isolated edits (77%, 69%, 82% for Claude, Gemini, and Codex, respectively) that do not connect to any other definitions edited in the same commit.
In short, and perhaps uncharitably, these AI agents, despite their sophistication, retain much of the flair of autocomplete systems of earlier eras. Informally, our results suggest that AI agents prefer to work on things that show basic textual features of being more obviously underdeveloped – either relatively short, or with gaps that are explicitly marked by sorries. More often than not, they see taking the next step as a matter of attending to simple, isolated places in the code that carry clear signals that there is something to do.
Semantic Preferences
Relative to humans, AI agents may prefer shorter definitions and sorry markers, but as can be seen in Figure 2, they also show systematic preferences for the semantic features of the repositories they are pointed at – preferences that both mimic, and magnify, tendencies that their human parallels show. Agents do not edit all sorries, and even the most assiduous sorry-editor, Claude, attacks about a tenth of the sorry-bearing definitions available (10% pooled over commits, 18% on average per commit).
In particular, the quadratic fit on the maximum shortest distance to a leaf (Max leaf) and shortest distance to a main root (Root distance) is a proxy for how far a given definition sits from the peripheries of the dependency graph. We observe a negative coefficient on Max leaf and a positive coefficient on its square across all actors, implying a U-shaped relationship: for humans the minimum of the curve is at the lowest observed ranks (10th percentile, the leaves themselves) and the curve rises steadily with distance into the graph. In contrast, edit probability for the AI agents is at a minimum for definitions one (Codex, 38th percentile) to three (Gemini, 42nd; Claude, 52nd) dependency steps above a leaf, rising in both directions.
The second positional measure, Root distance, has the same structure. While humans show a weak preference to edit definitions close to a project’s main roots, AI agents show a strong U-shaped response whose minimum sits around three steps from a main root (Gemini, 42nd percentile; Codex, 47th; Claude, 53rd), and whose curvature is significantly stronger than the human one (deviations on the squared term +0.94, +0.94 and +4.84 for Claude, Gemini and Codex; all ). These results persist in simpler regressions with either Max leaf or Root distance alone.
Taken together, or separately, these results show that AI agents strongly prefer to modify near the logical boundaries of a proof, either near the bottom (“axiomward”; lower percentile) or top (far from those leaves; higher percentile) of the graph. Informally, both signals amount to a preference for more peripheral engagement with the problem at hand – AI agents prefer, far more strongly, to work backwards from the final theorem, to work forwards from the axioms, and to avoid the more densely connected parts of the argument in the middle. Humans show some of these tendencies, but at a much weaker rate; humans have weaker preferences for the extremes, and are more comfortable going into the thick of the action, working far more on the intermediate lemmas that turn more basic facts into definitions that higher-level stages of the proof rely on.
The second main semantic difference is that all three AI agents show a strong tendency to preferentially attack high-surprise proof bodies. The outcomes of this preference can be seen in Figure 4, which reveals a critical downstream effect of this preference: AI agents tend to regularize proofs towards an LLM standard. This effect holds when considering sorry and non-sorry bodies separately; see Appendix Table 5.

Figure 4. Average per-token surprise under DeepSeek-Prover-V2-7B for definitions containing at least one sorry before (•) and after (○) modification with 95% bootstrapped intervals. The dashed line marks the mean surprise over all parent-state definitions. AI agents are systematically drawn to high-surprise bodies, and their modifications lower the surprise of those bodies. Marker: ∗∗∗ .
In addition, all three agents also show significant relative tendencies to avoid high-surprise signatures. Informally, the stranger the proof goal appears, relative to an LLM standard, the less likely AI agents are to modify the body. The relative attraction to surprising bodies and aversion to surprising signatures hold regardless of which model is used to score surprise (Appendix Table 4).
Discussion
Our simulated collaboration method reveals strong and systematic deviations, with both high statistical significance and large effect sizes, from human behavior. Nearly all of these deviations are found across all three models.
These deviations come in two distinct forms, which we can broadly characterize as those that come from (1) the system’s interpretation of overt sorry signals as implicit requests for assistance and primary targets for modification, and (2) differences between the system’s and the human’s understanding of the overall proof structure. These edits are done in such a way that (3) agents regularize the surprise of the proof down towards the baseline.
Agents are sorry autofillers
The first class of deviations comes from how agents interpret sorry markers. For a human collaborator, a sorry is as much a placeholder as a planning device [53 Zhu+26], as it records a decision to defer a proof step so that work can proceed elsewhere. There may be several reasons to defer a definition. It can be a routine but laborious proof, it might be expected to follow from results not yet formalized [15], or it can depend on choices about the shape of the argument that are yet to be made.
Agents, by contrast, treat each sorry marker as an open request for assistance. We find that at least 59% of every agent’s modifications involve a definition that contains a sorry, while for humans, this fraction drops to only about a fifth of their modifications. Under a prompt as minimal as our “take the next step” instructions, this reading is arguably not unreasonable. As far as the Lean compiler is concerned, a complete formalization requires that no sorry remains, and these markers are the only explicit statement of what is left to do. Therefore, the agents adopt the most literal operationalization of progress available to them, which produces the result that agents fill the gaps that humans have chosen to defer.
Proofs are also not single-unit structures. Definitions, say, one step removed from a sorry are very much a part of the same unfinished argument, because they either supply the argument’s inputs – represented as outgoing edges in the dependency graph – or use its conclusion (incoming edges). Yet, we find that agents are attracted to the sorry markers themselves, rather than to the regions around the proofs they mark.
In contrast, human edits are much better spread across the graph, with their largest share targeting definitions at a distance of two steps. Presumably, if collaborators understand the sorry as a symptom of an incomplete argument – rather than the root cause of it – they can reasonably be expected to work on its neighborhood, building out its argument and scaffolding, for example by restating a lemma that makes the gap easier to resolve, or by noticing that a downstream use requires a stronger statement.
We also saw that humans are more strongly drawn to editing larger definitions. In a mature formalization project, these definitions are likely to be substantial, hard-won proofs where most of the mathematical work is concentrated. By contrast, agents barely remove existing code and add things at a much lower rate, suggesting that they treat the existing codebase as fixed scaffolding to be completed rather than as a work-in-progress artifact to be revised. In addition, when agents do edit, their changes tend to be larger and more isolated from one another. We find that roughly three quarters of agent-edited definitions share no dependency with any other definition edited in the same commit, compared to about one-third for humans.
To summarize, a typical human commit tends to contain small, targeted edits to a connected region of the proof. A typical agent commit is a self-contained block of proof text dropped into a single gap – a proof “autofiller”.
For collaboration, these findings can cut both ways. On the one hand, they suggest a natural division of labor that may foster human–AI complementarity [23]: closing specific, local gaps can be tedious work that humans already defer, and agents are evidently willing to take it on. On the other hand, humans’ decision to defer something is itself informative, and agents appear blind to it, which in turn can have downstream consequences.
A sorry may mark a definition that is expected to change, is known to be false as stated, or has an eventual proof that is meant to come from an external result not yet available, among other possibilities. Such autofilling with large, disconnected proof bodies risks producing exactly the kind of verbose and hard-to-understand artifacts that mathematicians warn against [7, 40]. In our data, there is good evidence that much of the sorry-filling is indeed premature; a significant fraction of the time, a declaration with a sorry chosen for editing later evolves into a definition with a new signature – between 25% (Codex) and 48% (Claude) of the time.
To promote beneficial complementarity, in other words, we ought to explore how agents can recognize whether gaps ought to be filled at all, shifting agents towards reasoning about why such gaps exist in the first place.
Agents edit the periphery
Broadly speaking, the second class of deviations comes from AI agents preferring to attend to the “edges” of a proof, near the axioms or roots, and to avoid the complex middles. There are a number of underlying drivers that might lead to these preferences.
The most parsimonious explanation is that, given our minimal prompt, such definitions constitute the low-hanging fruit of the proof process. Where sorry-filling provides the ready-made marker of what could ostensibly be considered a useful next step, the dependency relationships and the type-signature complexity provide a signal of what is a feasible next step. This interpretation, however, does not yet explain why the agents seem to consider peripheral, low-clustering nodes easy to prove.
In particular, agents may be drawn to these regions because they provide better matches to training data: shorter definitions are more likely to be closer matches to Lean code that exists elsewhere on purely combinatorial grounds.
In addition, less-connected clusters of definitions are less likely to have complex type signatures or to call on definitions that themselves have complex signatures. This is because, compared to edges near leaf nodes, the center of the proof contains a long accumulation of decisions that combine axioms and external dependencies that ought to make it more idiosyncratic and thus more difficult for the agent to find reliable next steps to take. Near the top, meanwhile, the proof structure is expected to simplify again, as the intermediate lemmas are cashed out in favor of statements that match the final type signature.
More broadly, the asymmetry between humans and agents matters because the center of the dependency graph is where a proof’s core ideas are expected to appear. It is exactly these intermediate lemmas, and the choices of how to state and prove them, that make a formal proof correspond to a particular human proof rather than merely to some proof [18].
Mathematicians have long held that the value of a proof lies as much in the understanding it conveys as in the certainty of its conclusion [57, 6]. An agent whose contributions cluster towards the axioms, or the top-level theorem boundaries, leaves this middle layer, and with it the work through which such understanding is built, to its human collaborators.
As in the case of sorry-filling, such a division of labor may in fact be beneficial. A process in which agents can write foundational definitions and assemble final theorems while humans develop the intermediate arguments could be complementary and consistent with mathematicians’ desire for agency and understanding [16]. On the other hand, such an approach would mean that the agents would not participate in the work that mathematicians find most valuable. In turn, this would mean that effective human–AI workflows would need to study and account for this asymmetry rather than assume it away.
Agents are proof regularizers
Our final result concerns AI agents’ non-human preferences for surprise. That AI agents have a relative preference against high-surprise signatures is consistent with many of the same things that can explain their preferences for the edges and low-connectivity regions of a proof: high-surprise signatures indicate places where human decision-making has produced ideas and constructions that are likely to exceed an agent’s training data, and well-designed agents ought to be expected to avoid precisely these harder problems.
As above, of course, avoiding high-surprise signatures may be a net positive for complementary collaborations; while we might hope that an agent is able to make sense of an idiosyncratic signature, it is wise for it to avoid editing a proof when it cannot.
High-surprise bodies pose a different problem. In these cases, unusual proof styles appear to provide another signal of low-hanging fruit and agents appear to be willing to bring these unusual bodies into a more regularized form. It is difficult, however, to see this seek-out-and-regularize instinct at the proof-body level as a net positive for human–AI workflows. The phenomenon of “LLM homogenization” [29, 13] has led to concerns about the emergence of a monocultural artificial hivemind [31]; our findings show that LLMs not only homogenize text but also appear to actively look for unusual places to smooth out.
Broader Lessons
The overall picture provided by our results is one of complementarity. At both the semantic and syntactic levels, agents respond strongly to features that humans consider less important and are content, at least for a time, to ignore.
This is not necessarily a good thing for the human culture of proof-making, however. In the case of surprise regularization, for example, there are natural concerns that increasing reliance may drive the products of human–AI collaborations away from the unusual and idiosyncratic methods that may drive advances in both proof-making and Lean development.
Even in cases where complementarity suggests the potential for the peaceful coexistence of human actors and AI agents, the second-order effects are more worrying. Our results show that AI agents actively avoid assisting on definitions with particular properties – surprising type signatures, say, or those in the center of a proof. Consider, then, “lazy” human mathematicians who want to shift increasing amounts of work over to an AI agent. A natural, and indeed incentivized, thing for those mathematicians to do is to learn to construct and knit their definitions together in ways that make those AI-aversive properties less common – to make their proof style more AI-friendly – so that the agents they recruit are more willing to contribute.
Our work suggests what such a resulting proof style, optimized for agent engagement, would look like. Definition bodies would tend to be shorter, less densely connected, and closer to leaves and roots, and both their goals and their final texts would be more predictable relative to training data baselines. While these choices might aid agents in finding ways to take the next step, they might, inadvertently, frustrate human goals of synthesis, diversity, and innovation.
Limitations. Several limitations must be considered when interpreting our results. First, our dependency graphs come from a heuristic lexical parser rather than from the Lean compiler itself. We have validated this parser, and while it shows a high degree of reliability (Appendix § 9), the reconstruction is not exact. Even an optimal parser would, however, mix together dependencies that are immediately cognitively accessible to a human with those that come from subtle interactions at compilation time; how to track all, and only, the dependencies that are human-visible remains an open question.
Second, all nine repositories are public and predate the models we test, so their later states may appear in the agents’ training data. Our work, however, still establishes a lower bound on the difference between human and AI-agent preferences because unnoticed use of one of our AI agents in the raw data should reduce the human–AI differences we observe. The differences we observe, and the resulting concerns we raise, are thus conservative. Our work also treats “the human” as a single actor – but the repositories we study have between 1 and 61 contributors with likely different roles. Particular humans are expected to deviate in any number of ways, and our results here refer to the human average.
Third, our work has excluded merge commits, because a merge combines work developed separately, often by several contributors over an extended period, and so does not correspond to a single decision about the next step. The work behind a large merge commit takes place somewhat behind the scenes; we did not attempt to trace these merges back to individual forks, in part because the meaning of a commit in a private fork is far more variable, and less interpretable.
Fourth, and by necessity, our regression analyses are correlational. To establish truly causal relationships would require direct interventions on the parent state, such as inserting or removing sorry markers – but such interventions would, in turn, lead to highly non-natural stimuli. Our results provide information on how human–AI collaborations might evolve, but cannot be used to simulate the evolution of a repository over long periods.
Data and Code Availability
Our full dataset, containing the nine repositories after simulated collaborations, as well as the codebase for analyzing the resulting data is at https://github.com/gyevnarb/proof-divergence.
Generative AI Usage Statement
The authors declare the use of generative AI in the research and writing process. According to the GAIDeT taxonomy [52], the following tasks were delegated to GAI tools under full human supervision: code generation, process automation, data collection, data cleaning, data analysis, and visualization. The GAI tools used were GPT-5.2 and GPT-6 by OpenAI, Claude Opus 4.6 by Anthropic, Gemini 3.1 Pro by Google DeepMind, Goedel-Prover-V2-32B, Kimina-Prover-72B, and DeepSeek-Prover-V2-7B. Responsibility for the final manuscript lies entirely with the authors. GAI tools are not listed as authors and do not bear responsibility for the final outcomes.
Acknowledgements
This work was supported by Grant 63750 from the John Templeton Foundation, the Survival and Flourishing Fund, and by the Institute for Complex Social Dynamics at Carnegie Mellon University. This work used Bridges-2 at Pittsburgh Supercomputing Center through allocation MTH260032 from the Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support (ACCESS) program, which is supported by National Science Foundation grants #2138259, #2138286, #2138307, #2137603, and #2138296.
References
Methods
To answer our research questions, we curate a set of intellectually significant, extended examples of human–human mathematical collaboration: nine formalization projects written in the programming language Lean [44] – listed in Table 2. These projects are available as public, open-source repositories which give us access not just to each project’s final form but to its full history through the sequence of commits that produced it. The project repositories we study contain up to approximately 1,800 commits and tens to thousands of function definitions – such as theorems and axioms – produced by teams of up to 61 (at the time of writing), primarily human, collaborators, many of whom are highly respected members of both the mathematics and formalization communities.
| Repo | Mathematical Topic | LoC | Editors | Commits | Years |
| apap | Arithmetic progressions, almost periodicity [19, 11] | 7,509 | 11 | 472 | 3.26 |
| duality | Linear-optimization duality (Farkas) [20] | 2,582 | 1 | 177 | 1.91 |
| finlin | Linearity of functions on finite sets [8] | 2,055 | 2 | 57 | 0.66 |
| flt | Fermat’s Last Theorem [14] | 28,031 | 61 | 1,614 | 2.57 |
| ordsemi | Hölder’s theorem for ordered semigroups [50] | 3,438 | 2 | 125 | 1.88 |
| pdl | Propositional Dynamic Logic [21, 12] | 23,873 | 13 | 1,041 | 2.70 |
| pfr | Polynomial Freiman–Ruzsa conjecture [54, 24] | 21,452 | 36 | 1,768 | 2.59 |
| sphere | Sphere packing in 8 dimensions [10, 26] | 22,303 | 25 | 1,074 | 2.29 |
| zeta | Irrationality of [39] | 4,157 | 2 | 133 | 2.17 |
| Mean | – | 12,822.22 | 17 | 717.89 | 2.22 |
Table 2. Overview of the nine Lean formalization repositories we analyze. The column LoC shows the lines of code measured across all files of the final commit of the project, excluding external dependencies. The column Editors shows the total number of contributors to the repository. The column Commits counts the number of commits in the repository, and Years shows the age of the repository in years. All data were taken from the projects’ GitHub repositories on 15 June 2026.
Importantly, the commit histories of most of these repositories date back several years (mean 2.22 years). As such, they track the collaborative work of many of the field’s most accomplished and dedicated practitioners, rather than autonomous AI agents which became capable of research-level mathematics in 2026.
Simulated Collaboration
Our overall experimental setup is shown in Figure 1. After downloading a repository, we list – in order from oldest to newest – all commits on the main working branch of the repository. From this list we filter out each commit which is either a merge – joining different, often unrelated working branches of the repository – or where no Lean files were modified by the human collaborators. A commit at – written as , also called a child state – in our curated dataset of repositories captures what a particular human mathematician thought and did in response to both their understanding of what ought to be done next and the parent state of the repository . As such, each state is, in practice, a commit in a Git repository, which allows an actor to inspect the full edit history of the project, while we manually remove access to all subsequent states to prevent agents from looking up the next step. At each relevant human commit of a Lean codebase, we prompt an AI agent – in our experiments, Claude Code with Claude Opus 4.6, Codex with GPT-5.2, and Gemini CLI with Gemini 3.1 Pro – to produce its own discrete continuation. The resulting AI commit, , is the product of whatever understanding the machine could glean of the project’s needs from the combination of and the particular prompt we provide. Our goal is to analyze the differences between how a human advanced the project at time from the parent state , and how an AI agent did so in , where is the agent’s commit. This setup enables us to make a direct comparison between the human way of mathematical work and the machine way, in a fashion we call simulated collaboration.
A key free variable in this method is the prompt we provide. Users are free to range from requesting surgically targeted interventions on a single line, to broad requests for large-scale advances. In this study, we use an extremely minimal prompt, “take the next step towards completing the project”, shown in Listing 1, which has the benefits of simplicity and validity regardless of project content. We note that no stopping condition was specified: agents were allowed to run as long as they saw fit without computational budget constraints.
Listing 1: General template for the “take the next step” prompt of our study.
I am working on a Lean 4 formalization of {problem_name}. Take the next step in advancing
↪ this project by editing or adding your changes to the codebase. Summarize your changes
↪ briefly in a markdown file called CHANGES.md
Once the prompt is chosen, however, there are clear quantitative signals to track, which we capture with a range of features extracted from the child states. In particular, because the projects are written in Lean, the dependency relationships among definitions form a hierarchy running from axioms to final theorems. This structure lets us pinpoint, among other things, which stages of the arguments are more or less developed, and track mathematically meaningful differences in how humans and AI agents choose to advance the mathematics at hand. Over the commit histories of all nine repositories, this process generates a dataset of more than 4.7 million nodes connected by 10.8 million edges which we analyze statistically.
The Syntax and Semantics of Lean
Lean is an extensible functional programming language with a wide range of keywords and components. A proof in Lean – a snippet of which is shown in Figure 5a – consists primarily of definitions. These are the logical building blocks of a proof, such as basic axioms, intermediate lemmas, and high-level theorems.

Figure 5. Lean 4 syntax (a) and dependency graph (b) based on the proof that infinitely many primes exist.
For our purposes, each definition consists of two major parts: the type signature and the body. The type signature specifies what needs to be proven – informally, it is the (sub)problem statement for that particular stage of the larger proof. The body provides the actual proof of the subproblem. It usually consists of (1) a sequence of tactics, meta-programming macros that implement actions in the proof; and (2) other definitions, hopefully but not necessarily already proven, that the tactics combine in novel ways.
A crucial keyword in Lean is the sorry marker. Placing a sorry in the body of a definition amounts to an instruction to the Lean compiler to count the relevant definition (or a subpart) as already proven. This keyword then enables a human to leave one part of a proof unfinished, while making progress on later parts. Each sorry marker provides a clear syntactic signal of a proof gap, and serves as our primary signal of a surface-level feature that might attract attention from either a human or an AI agent.
Part of the power of Lean lies in the ability to build on previously proven definitions and theorems, and the foundation of this power is a community-maintained library called Mathlib [56]. A proof in Lean is ultimately an intricately connected graph of definitions, forming a complex, directed dependency graph between Mathlib, the proof authors’ own definitions, and further potential dependencies; an example of such a dependency graph is shown in Figure 5b.
A node in a dependency graph corresponds to any definition, while two nodes , are connected by an edge if definition references . Definitions may reference previous ones both in their type signature and in their body. They can also call themselves recursively, meaning that dependency graphs are not necessarily directed acyclic graphs.
We call a node a leaf if it does not reference any other definitions. Leaves are, therefore, often fundamental, low-level definitions, such as basic statements or axioms. Conversely, a root node is not referenced by anything else, and these often correspond to high-level theorem statements and the frontier of what the project has been able to achieve. In Figure 5a, for example, is_prime is a leaf, and is referenced by dvd_factorial in its type signature. While definitions may sometimes be isolated from each other, a project’s dependency graph is usually dominated by a large weakly connected component.
In contrast to the syntactic nature of the sorry signal, the emergent network structure of a proof provides a signal of its definitions’ semantics: the network position of a definition tells us how closely it relates to other nodes – e.g., is it a core part of a complex argument or a more peripheral special case – and its position in the chain of reasoning – e.g., is it towards the base of the argument, like the definition is_prime, or is it further along, like the use of the factorial in dvd_factorial.
Operationalizing Syntactic and Semantic Development
We compare each human commit and agent commit with their shared human parent . Definitions across commits are matched based on a fully qualified name that includes their declaration kind (i.e., theorem, lemma, def, etc.), file name, namespace, and name. We call a definition added if its identifier is present in the child but absent from the parent, and removed if it is present in the parent but absent from the child. We call a definition modified if it already exists in the parent and its parsed type signature or body changes. If a definition is neither added, removed, nor modified, then it is unchanged. We use the term edited as a blanket term that refers to additions, modifications, and removals. We treat renaming as first a removal followed by an addition.
We use a validated lexical parser – see Appendix § 9 for full details on parsing – to extract the definitions and their dependency relationships from every Lean file in a commit. From this data, we extract the following features to compare human and agent proving behavior.
Syntactic features. To calculate the edit share of an actor in a commit, we divide the number of edited definitions by the total number of definitions. We measure definition size as the combined character count of its parsed type signature and body. To measure edit size, we align the old and new text separately for each part using a character-level diff, then sum the characters inserted and deleted. A replacement contributes both a deletion and an insertion. A modification is body-only when the body changes but the signature does not, and vice versa for signature-only modifications. We count every occurrence of sorry markers in the parsed body. As a secondary analysis, we calculate the shortest distance from each definition to any sorry-carrying node, ignoring edge direction.
Semantic features. We extract features for each definition from the dependency graph of a commit as follows. First, to extract the graph itself, we create a node for each definition and an edge if the parser identifies a reference to in the signature or body of . Repeated references produce a single edge, and dependencies outside the repository are excluded (e.g., Mathlib). Such an analysis reveals a great deal about the conceptual organization of a proof, and basic graph-theoretic features of a dependency graph help us understand how, for example, modularities in graph structure enable apparently complex arguments to produce structured understanding [58].
A key semantic question is where in the proof the actor (human, or AI) chooses to intervene. We measure this in two ways. First, the maximum shortest distance to a leaf (“max leaf”) is the longest path among all shortest paths to reachable nodes with no outgoing edges. In rare cases, there is a dependency cycle in a leaf position (i.e., a strongly connected set of nodes with no outgoing edges); we compute the shortest distance to any node in such terminal cycles. This measure is zero for a leaf node or terminal cycle.
Max leaf measures how far into a proof, from the axiom level, the actor chooses to intervene. We can also measure the converse—how far from the “theorem” point an actor chooses to intervene. “Theorem” here is in quotes because there may be many top-level definitions in a proof in development; points which currently are not used as dependencies by anything else, but represent the furthest along the proof has developed. There are also (we find) a large number of nodes that nothing else depends on but that correspond to abandoned or otherwise uninteresting lines of development; these nodes are roots (i.e., they are not called by any other definitions in the repository) but do not, on inspection, correspond to the frontier of the proof’s development.
In order to identify the theorem-like definitions among the roots, we first measure the transitive closure of each root node in the largest connected component – i.e., all the nodes that that root node calls upon, or that are called upon by those nodes, and so on. We begin with the root node with the largest transitive closure, and add, in a greedy fashion, additional root nodes until the total size of the transitive closure of all the root nodes so far increases by less than 5%. This heuristic allows us to capture the set of “main” root nodes, while dropping the roots that are simply by-products of testing and experimentation.
Having identified the main root nodes, we can then compute the undirected shortest distance to a main root (“Root distance”). This distance is undirected because in some cases (e.g., a root that was not selected as a main root on the basis of closure) reaching a main root requires going, for a small number of steps, in the direction of dependencies. Root distance and max leaf are, naturally, anticorrelated (), but not perfectly so, because of how the graph can widen as one moves from axiom to theorem. We include both in our analysis.
Finally, we measure the per-token surprise of both a definition’s body and its type signature. This is computed using a language model fine-tuned for proof-completion tasks with Lean 4. Per-token surprise is calculated for non-comment tokens only and using, for context, the full contents of the file so far; in rare cases, a file is longer than the model’s context window. These longer files are scored in chunks of whole declarations of at most 24,000 tokens, each preceded by up to 12,000 tokens of the file as context.
If, for example, the type signature in question is located between tokens and (inclusive), then the surprise is
where is the th token and is the list of the preceding context tokens. High surprise means that the tokens are more improbable under the model; the core probability, , is computed using three models, DeepSeek-Prover-V2-7B, Kimina-Prover-72B, and Goedel-Prover-V2-32B. Goedel and Kimina are based on the Qwen architecture, while DeepSeek-Prover is based on the LLaMA architecture. All three models lead to essentially the same conclusions; DeepSeek-Prover-V2-7B provides the best fit under AIC for our main regression, and so we present its results in the main text.
When used in a regression model, all of these continuous predictors are converted to ranks computed once per parent commit over the definitions in the largest weakly connected component. Regression models use predictors based on features of the parent graph restricted to definitions in its largest weakly connected component.
Statistical Methods and Regression Analysis
Our analysis focuses on identifying which definitions are chosen for modification by the different actors. We first characterize the related behavior of actors using descriptive statistics and comparisons. Unless otherwise noted, all -values reported are based on a beta-binomial model which controls for differences between commits and between repositories, and allows the difference in edit shares between actors to vary by repository. Pairwise differences are tested with Wald tests and we use Holm correction to account for multiple testing.
We also seek to understand the main driving factors behind the observed modification behaviors, which we model using logistic regression. At a high level, we fit a binomial logistic mixed-effects model using the R programming language, specifically the glmmTMB package. Our model predicts whether a parent-state definition is modified in the child state. We restrict the input data to definitions in the largest connected component of the shared parent graph, as otherwise structural measures may be biased unnecessarily. Overall, this restriction removes approximately 12.2% of definitions across all repositories and commits.
Our fixed-effects predictors are features calculated from the parent state: the presence of sorry markers, Max leaf and Root distance and their squares, surprise over the type signature and the body, definition size, and an indicator of previous modification. We choose these features for their interpretability; they are largely decorrelated with each other (see Figure 6) and the VIFs range from 1.00 (previously modified) to 1.37 (body surprise).

Figure 6. Pairwise Pearson correlations between our (rank-normalized) syntactic and semantic features, and the modification outcome, pooled across actors and repositories.
Every predictor interacts with each actor, allowing both the intercept and the coefficients to vary by actor. We take humans as the reference category, so an agent’s coefficients are represented as deviations from the corresponding human coefficients. Finally, our random effects comprise actor-specific intercepts within repositories and a shared intercept for each repository–commit block. Using R notation, our model is succinctly expressed as:
is_modified ~
(has_sorry + p_is_modified +
max_leaf_r + I(max_leaf_r^2) +
max_root_r + I(max_root_r^2) +
surprise_type_r + surprise_body_r +
length_r) * Actor +
diag(0 + Actor | repo) + (1 | repo:commit)
Lexical parsing of Lean files
While a simple dependency graph as in Figure 5b can be easily read off by human eyes, the projects we consider grow to enormous complexity and Lean’s metaprogramming abilities mean that the only way to establish this graph with certainty is to compile the code in Lean’s own parsed environments. This is, unfortunately, not possible at the scale required, for two reasons.
First, obtaining a built Lean environment requires that the project compile and be error-free, but this is rarely the case for either the work-in-progress repositories or the changes made by AI agents. Second, even if the project is error-free, doing so for many tens of thousands of commit stages is prohibitive in both time and compute; builds must be pegged to a particular version of both Lean and Mathlib, and can require minutes to hours of compilation time and many gigabytes of storage.
Therefore, we use our own lexical parser, based on a combination of regular expressions and heuristics, which is scalable and applies uniformly to every commit whether or not it compiles. This parser is approximate and its use may introduce measurement errors. To quantify this error, we validate its outputs against ground truth taken from the Lean 4 compiler itself as follows.
For each of the nine repositories, we build the full project at its final commit and load the resulting environment. This environment provides the ground truth record of what each definition depends on. We restrict attention to repository-internal targets, since references to Mathlib or the core library – between 82%
| Repository | Modules | Definitions | Dependency edges | Degree rank corr. | Graph features | ||||||||
| LCC | % | ||||||||||||
| apap | 40/40 | 835 | 0.998 | 2,173 | 0.812 | 0.830 | 0.821 | 0.79 | 0.84 | 0.70 | 0.20 | 91 | |
| duality | 7/7 | 184 | 1.000 | 951 | 0.979 | 0.432 | 0.600 | 0.80 | 0.57 | 0.62 | 0.30 | 99 | |
| finlin | 2/2 | 15 | 1.000 | 25 | 1.000 | 1.000 | 1.000 | 1.00 | 1.00 | 1.00 | 1.00 | 100 | |
| flt | 171/174 | 1,845 | 1.000 | 5,117 | 0.715 | 0.532 | 0.610 | 0.76 | 0.64 | 0.50 | 0.32 | 80 | |
| ordsemi | 16/16 | 228 | 1.000 | 1,122 | 0.986 | 0.608 | 0.752 | 0.84 | 0.88 | 0.84 | 0.67 | 98 | |
| pdl | 29/34 | 967 | 1.000 | 5,890 | 0.916 | 0.429 | 0.585 | 0.75 | 0.77 | 0.69 | 0.65 | 96 | |
| pfr | 71/71 | 1,010 | 0.997 | 4,383 | 0.884 | 0.710 | 0.787 | 0.93 | 0.77 | 0.92 | 0.43 | 94 | |
| sphere | 88/88 | 1,614 | 0.999 | 4,700 | 0.936 | 0.761 | 0.839 | 0.85 | 0.85 | 0.86 | 0.60 | 84 | |
| zeta | 8/8 | 131 | 1.000 | 287 | 0.948 | 0.951 | 0.950 | 0.97 | 0.96 | 0.76 | 0.92 | 98 | |
| Pooled | 432/440 | 6,829 | 0.999 | 24,648 | 0.862 | 0.614 | 0.717 | — | — | — | — | — |
Table 3. Our parser’s accuracy compared against the Lean 4 compiler ground truth. shows the number of definitions or dependency edges. measures the recovery of named definitions or the edges between them. and measure the precision and recall of the recovery of edges between definitions. are the Spearman rank-correlations between our parser’s and the compiler’s dependency graph out/in-degrees, the correlations with Max leaf and Root distance, and LCC the fraction of the largest weakly connected component recovered.
and 99% of all references – lie outside the graph we study in our experiments. We report precision, recall, and at two levels: the definitions and dependency edges. The first level asks whether the lexical parser recovers the same set of named objects as the Lean environment. The second level asks whether the parser recovers the same dependencies between the identified definitions. Because our analyses rest on graph-structural features rather than on individual edges, we also report Spearman rank correlations between the parser and the compiler out- and in-degrees, written as and .
Our parser is essentially exact at identifying definitions ( over 6,829 declarations), so the nodes of our graphs are reliable. Edge recovery has high precision and moderate recall (, ): the dependencies we report are almost always real, but the parser systematically under-counts them.
The two position measures the regression uses are (mostly) reproduced well. The max leaf distance is recovered well ( to 1.00 across projects; 0.50 to 0.92 in the four largest), as is membership of the giant component (80 to 100% of declarations). The root distance is noisier ( to 1.00; 0.32 to 0.65 in the four largest). Root distance can vary from ground truth for two reasons: in the selection of the “main” root set, and in the computation of the minimum paths.
Much of the shortfall in recall is intrinsic to the way Lean 4 works. By a token-matching heuristic, roughly a quarter (24%) of the dependencies identified by the kernel are never written by name in the declaration’s text but introduced during elaboration (instance synthesis, variable binders, coercions), and a further 2.6% are expressed only through notation declared in the repository; among the dependencies that are written by name, recall is 0.84. Given the goals of this work – an analysis of how humans and AI agents work with the source text of a repository – the written dependency structure is the relevant target, but we do not treat this heuristic as a bound on what a lexical parser could recover.
Additional Tables
Tables 4 to 6 report further results and exact numbers underlying our figures in § 2.
| Predictor | DeepSeek-Prover-V2-7B | Goedel-Prover-V2-32B | Kimina-Prover-72B | |
| Surprise, signature | Human | |||
| Claude | ||||
| Gemini | ||||
| Codex | ||||
| Surprise, body | Human | |||
| Claude | ||||
| Gemini | ||||
| Codex | ||||
| Log-likelihood | ||||
| AIC |
Table 4. Sensitivity of the coefficients for surprise in Figure 2 to the language model used to score surprise. Each column refits the same model, but with surprise ranks computed under different LLMs. Log-likelihoods are comparable across columns.
| Actor | Parent body | Goedel-Prover-V2-32B | Kimina-Prover-72B | DeepSeek-Prover-V2-7B |
| Human | with sorry | |||
| without sorry | ||||
| Claude | with sorry | |||
| without sorry | ||||
| Gemini | with sorry | |||
| without sorry | ||||
| Codex | with sorry | |||
| without sorry |
Table 5. Change in surprise over definition body after a modification (nats per token), split by whether the definition contained a sorry in the parent commit, and by each language model used to score surprise. Errors are cluster-bootstrapped standard errors over commits, with the number of definitions shown in parentheses.
References
- [5]P. S. Ammanamanchi, S. Bhat, and S. Biderman. “Faults in Our Formal Benchmarking: Dataset Defects and Evaluation Failures in Lean Theorem Proving”. In: Proceedings of the 43rd International Conference on Machine Learning (ICML). 2026. arXiv: 2606.29493 [cs.AI].arxiv.org/abs/2606.29493
- [6]J. Avigad. Mathematicians in the Age of AI. Apr. 6, 2026. arXiv: 2603.03684 [math.HO]. URL: http://arxiv.org/abs/2603.03684. Pre-published.
- [7]A. Avila, M. Bhargava, C. Birkar, P. Deligne, Y. Deng, S. Donaldson, H. Duminil-Copin, A. Figalli, M. Hairer, J. Huh, M. Kontsevich, E. Lindenstrauss, P.-L. Lions, J. Maynard, C. McMullen, S. Mori, B. C. Ngô, A. Okounkov, P. Scholze, S. Smirnov, T. Tao, M. Viazovska, C. Villani, W. Werner, and E. Zelmanov. A Severe Misalignment of AI in Mathematics. Sept. 11, 2026. URL: https://zenodo.org/doi/10.5281/zenodo.22737750. Pre-published.DOI
- [8]R. Bacik. A Linear Representation for Functions on Finite Sets. 2025. arXiv: 2510.20167.arxiv.org/abs/2510.20167
- [10]C. Birkbeck, S. Hariharan, S. Lee, B. Mehta, M. Viazovska, et al. Sphere Packing in Lean. GitHub repository. 2024. S. Hariharan, C. Birkbeck, S. Lee, H. K. G. Ma, B. Mehta, A. Poiroux, and M. Viazovska. Progress in Formalizing Sphere Packing in Dimension 8. 2026. arXiv: 2604.23468.
- [11]T. F. Bloom and O. Sisask. The Kelley–Meka Bounds for Sets Free of Three-Term Arithmetic Progressions. 2023. arXiv: 2302.07211 [math.NT].DOI
- [12]M. Borzechowski, M. Gattinger, H. H. Hansen, R. Ramanayake, V. Trucco Dalmas, and Y. Venema. Propositional Dynamic Logic Has Craig Interpolation. A Tableau-Based Proof. 2025. arXiv: 2503.13276.arxiv.org/abs/2503.13276
- [13]G. Burtch. “The Hitchhiker’s Guide to Monoculture”. In: arXiv preprint arXiv:2607.13077 (2026).arxiv.org/abs/2607.13077
- [14]K. Buzzard et al. The Fermat’s Last Theorem Project. GitHub repository. 2023.
- [15]K. Buzzard. On the Ingredients for Fermat. VaNTAGe seminar. MIT. Apr. 30, 2024. URL: https://math.mit.edu/~drew/vantage/BuzzardSlides.pdf (visited on 10/15/2026).
- [16]K. M. Collins, S. Frieder, J. Bayer, J. Loader, J. Lim, P. Song, F. Zaiser, L. Zhou, S. Li, S. Looi, J. B. Tenenbaum, U. Bhatt, A. Weller, J. Hernandez-Orallo, C. E. Freer, V. Chen, and I. Sucholutsky. Human Agency in Initial Human-AI Proof Formalization Workflows. Aug. 2026. eprint: 2606.04273 (cs.AI).arxiv.org/abs/2606.04273
- [17]L. de Moura. Postmortem for Kernel Soundness Bug #14576. Aug. 1, 2026. URL: https://leodemoura.github.io/blog/2026-8-1-postmortem-for-kernel-soundness-bug-14576/.
- [18]S. DeDeo and E. Duede. A Correspondence Problem for Mathematical Proof. Mar. 18, 2026. arXiv: 2603.13680 [math.HO]. URL: http://arxiv.org/abs/2603.13680. Pre-published.
- [19]Y. Dillies et al. APAP: Arithmetic Progressions – Almost Periodicity. Formalisation of the Kelley–Meka Bound on Roth Numbers. GitHub repository. 2023. T. F. Bloom and O. Sisask. The Kelley–Meka Bounds for Sets Free of Three-Term Arithmetic Progressions. 2023. arXiv: 2302.07211 [math.NT].
- [20]M. Dvorak and V. Kolmogorov. “Duality Theory in Linear Optimization and Its Extensions – Formally Verified”. In: Annals of Formalized Mathematics 2, 14253 (Mar. 13, 2026).arxiv.org/abs/2409.08119
- [21]M. Gattinger, A. Nicodemus, D. dos Santos Gomes, N. Cohen, W. Bosman, M. Gignoux, H. Wang, E. Yaron, X. Yang, and J. Sorkin. Tableaux for Propositional Dynamic Logic in Lean 4. GitHub repository. 2023. M. Borzechowski, M. Gattinger, H. H. Hansen, R. Ramanayake, V. Trucco Dalmas, and Y. Venema. Propositional Dynamic Logic Has Craig Interpolation. A Tableau-Based Proof. 2025. arXiv: 2503.13276.
- [23]C. Gonzalez and H. Heidari. “A Cognitive Approach to Human–AI Complementarity in Dynamic Decision-Making”. In: Nature Reviews Psychology 4.12 (Dec. 2025), pp. 808–822.DOI
- [24]W. T. Gowers, B. Green, F. Manners, and T. Tao. “On a Conjecture of Marton”. In: Annals of Mathematics 201.2 (2025), pp. 515–549. arXiv: 2311.05762.arxiv.org/abs/2311.05762
- [26]S. Hariharan, C. Birkbeck, S. Lee, H. K. G. Ma, B. Mehta, A. Poiroux, and M. Viazovska. Progress in Formalizing Sphere Packing in Dimension 8. 2026. arXiv: 2604.23468.arxiv.org/abs/2604.23468
- [28]M. C. Jadud and B. Dorn. “Aggregate Compilation Behavior: Findings and Implications from 27,698 Users”. In: Proceedings of the Eleventh Annual International Conference on International Computing Education Research. ICER ’15. New York, NY, USA: Association for Computing Machinery, Aug. 9, 2015, pp. 131–139.
- [29]S. Jain, J. Lanchantin, M. Nickel, C. Ross, K. Ullrich, A. Wilson, and J. Watson-Daniels. “Task-Dependent Evaluation of LLM Output Homogenization: A Taxonomy-Guided Framework”. In: arXiv preprint arXiv:2509.21267 (2025).arxiv.org/abs/2509.21267
- [31]L. Jiang, Y. Chai, M. Li, M. Liu, R. Fok, N. Dziri, Y. Tsvetkov, M. Sap, and Y. Choi. “Artificial hivemind: The open-ended homogeneity of language models (and beyond)”. In: Advances in Neural Information Processing Systems 38 (2026).arxiv.org/abs/2510.22954
- [36]Y. Lafhal, Z. Sharafi, and M. Amini. “Attention to Innovation: Linking Developer Gaze and Coding Approaches”. In: Proceedings of the 2026 34th IEEE/ACM International Conference on Program Comprehension. ICPC ’26. New York, NY, USA: Association for Computing Machinery, July 29, 2026, pp. 433–437.DOI
- [39]J. Liu, J. Zhang, and L. Zhi. A Formal Proof of the Irrationality of ζ(3) in Lean 4. 2025. arXiv: 2503.07625 [math.NT].arxiv.org/abs/2503.07625
- [40]J. Lu, S. Kong, R. Stehling, K. Yang, Z. Wang, W. Sun, and W. Chen. Lean Refactor: Multi-Objective Controllable Proof Optimization via Agentic Strategy Search. May 18, 2026. arXiv: 2605.20244 [cs.LO]. URL: http://arxiv.org/abs/2605.20244. Pre-published.
- [44]L. de Moura and S. Ullrich. “The Lean 4 Theorem Prover and Programming Language”. In: Automated Deduction – CADE 28. Ed. by A. Platzer and G. Sutcliffe. Vol. 12699. Lecture Notes in Computer Science. Cham: Springer, 2021, pp. 625–635.DOI
- [45]H. Mozannar, G. Bansal, A. Fourney, and E. Horvitz. “Reading Between the Lines: Modeling User Behavior and Costs in AI-Assisted Programming”. In: Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems. CHI ’24. New York, NY, USA: Association for Computing Machinery, May 11, 2024, pp. 1–16.arxiv.org/abs/2210.14306
- [50]E. Paul. OrderedSemigroups. Formalization of Hölder’s Theorem for Ordered Semigroups and Groups. GitHub repository. 2024.
- [51]E. Stenberg Hartviksen and P. Ø. Haavold. “Differences between Experts in Mathematical Problem Solving”. In: Thinking Skills and Creativity 58 (Dec. 1, 2025), p. 101875.
- [52]Y. Suchikova, N. Tsybuliak, J. A. Teixeira da Silva, and S. Nazarovets. “GAIDeT (Generative AI Delegation Taxonomy): A Taxonomy for Humans to Delegate Tasks to Generative Artificial Intelligence in Scientific Research and Publishing”. In: Accountability in Research 33.3 (Apr. 2026), p. 2544331.DOI
- [53]T. Tao. Formalizing the Proof of PFR in Lean4 Using Blueprint: A Short Tour. What’s New (blog). Nov. 18, 2023. URL: https://terrytao.wordpress.com/2023/11/18/formalizing-the-proof-of-pfr-in-lean4-using-blueprint-a-short-tour/ (visited on 10/15/2026).
- [54]T. Tao et al. The Polynomial Freiman–Ruzsa Conjecture. GitHub repository. 2023. W. T. Gowers, B. Green, F. Manners, and T. Tao. “On a Conjecture of Marton”. In: Annals of Mathematics 201.2 (2025), pp. 515–549. arXiv: 2311.05762.
- [56]The mathlib community. “The Lean Mathematical Library”. In: Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs. CPP 2020. New York, NY, USA: Association for Computing Machinery, Jan. 22, 2020, pp. 367–381.
- [57]W. P. Thurston. “On Proof and Progress in Mathematics”. In: 18 Unconventional Essays on the Nature of Mathematics. Ed. by R. Hersh. New York, NY: Springer, 2006, pp. 37–55.
- [58]S. Viteri and S. DeDeo. “Epistemic phase transitions in mathematical proofs”. In: Cognition 225 (2022), p. 105120.DOI
- [61]H. Xin, L. Li, X. Jin, J. Fleuriot, and W. Li. APE-Bench: Evaluating Automated Proof Engineering for Formal Math Libraries. Feb. 2, 2026. arXiv: 2504.19110 [cs.CL]. URL: http://arxiv.org/abs/2504.19110. Pre-published.