Papers
Topics
Authors
Recent
Search
2000 character limit reached

The Technological Turn in Mathematics

Published 8 Jul 2026 in math.HO | (2607.07162v1)

Abstract: Quickly evolving technologies, such as Interactive Theorem Provers (ITPs), Automated Theorem Provers (ATPs), and LLMs, all falling under the general heading 'AI for mathematics,' are transforming mathematical practice in profound ways. This chapter explores the implications of these innovations, focusing on their impact on how mathematical knowledge is created and shared. It also discusses how they are reshaping the social dimension of mathematics, altering collaboration dynamics, trust relationships, and the collective production of knowledge. For instance, tools like ITPs facilitate large-scale collaborations and make new types of teamwork possible, where trust is not a necessary ingredient. ITPs also help us mitigate our human fallibility, yet they raise questions about the nature of formalization and the relationship between traditional and formal mathematics. Technologies such as LLMs are reshaping the division of epistemic labour between humans and machines and urge philosophers of mathematics to ask questions about the value of their work.

Summary

  • The paper demonstrates that emerging tools like ITPs, ATPs, and LLMs reshape proof verification and expose new epistemic challenges.
  • It presents a neurosymbolic approach that combines formal logic with statistical models, exemplified by systems such as AlphaGeometry.
  • The study reveals shifts in collaboration and trust, emphasizing the distributed nature of modern mathematical labor and verification.

The Technological Turn in Mathematics: Epistemic and Social Implications

Overview of Technological Integration in Mathematical Practice

This paper provides a comprehensive analysis of the ongoing transformation in mathematical practice driven by evolving computational technologies, specifically Interactive Theorem Provers (ITPs), Automated Theorem Provers (ATPs), and LLMs. The authors argue that the infusion of "AI for mathematics" constitutes a genuine technological turn, impacting both the epistemic foundations and the collective structure of mathematical activity.

Unlike historical uses of computational and mechanized tools, the current transition involves symbolic AI (logic-driven, database-oriented systems) and neural AI (statistical, data-driven, brain-inspired models) as distinct but increasingly intertwined paradigms. The neurosymbolic approach, as exemplified by systems like AlphaGeometry, seeks to leverage the strengths of both traditions. This dual evolution introduces both expanded capabilities and new complexities in mathematical production and verification.

Redefining Proof, Rigor, and Mathematical Fallibility

The rise of ITPs creates structural shifts in notions of proof, rigor, and error detection. While the formalizability of proofs in formal systems has long been considered essential for mathematical rigor, traditional practice relies heavily on community-driven scrutiny of "simil-proofs"—proofs meeting communal standards, but potentially erroneous until thoroughly checked. The explosion of result complexity and scale has outpaced the practical capacity for exhaustive peer verification, exacerbating latent vulnerabilities in the literature.

ITPs, such as Lean, Coq, and Isabelle, can reduce these vulnerabilities by enabling mechanical verification of formalized arguments. High-profile applications include the formal verification of the proofs of the Four Color Theorem and the Kepler Conjecture. The authors highlight that mathematical communities are increasingly normalizing a dual-track system, wherein informal proofs (simil-proofs) are expected to be paired with their formalized counterparts—a trend seen in recent efforts to formalize major results like Fermat’s Last Theorem.

Despite these advances, absolute certainty remains elusive. The authors point out two persistent sources of fallibility:

  • Software bugs within ITPs themselves, occasionally resulting in provably inconsistent statements.
  • The epistemic gap between informal mathematical intent and formal representation, particularly acute in domains where key definitions are subtle or contested.

Transformation of Collaboration and Distributed Mathematical Labor

The technological turn enables new, scalable forms of collaboration, notably reshaping the social dimension of mathematical knowledge production. The move to ITP-facilitated crowdsourcing (e.g., the Equational Theories Project), compared to earlier blog-based initiatives like Polymath, allows for:

  • Large asynchronous participation without the prerequisite of personal trust relationships among collaborators.
  • Systems for modularization, traceability of dependencies, and formal integration of contributions, mitigating errors from mismatched or unvetted individual efforts.

The resulting epistemic structure is a hybrid network where knowledge, verification, and accountability are distributed among humans, software artifacts, and automated agents. This distributed model raises questions concerning the ascription of collective knowledge and responsibility, as traditional distinctions between personal and communal knowledge increasingly break down in practice.

Evolving Notions of Trust and Verification

The authors scrutinize the evolving role of trust in mathematical practice. Traditional models rested on interpersonal trust, justified by the infeasibility of independent verification of all background knowledge. However, the use of ITPs and formal libraries diminishes, though does not eliminate, the epistemic necessity for such trust. Notably:

  • Proof assistants make it plausible for collaborators to "merely rely" on others’ formalized contributions without interpersonal trust.
  • Yet, trust in moderators (e.g., of Mathlib) and infrastructural maintainers, as well as persistent interpersonal commitments during project coordination, remains non-eliminable.

This nuanced analysis casts doubt on any simplistic trust-free ideal, particularly since practical mathematical activity remains riddled with interpersonal and institutional dependencies at organizational and infrastructural levels.

Potentials and Challenges Introduced by Neural AI

Neural AI and LLMs are rapidly advancing from supporting mathematical communication (e.g., LaTeX generation) to producing competitive solutions to mathematical problems, as shown by AlphaProof, Aristotle, and their performance at the IMO and related benchmarks. Neural systems have begun exceeding human-level performance on specific mathematical tasks, even generating new conjectures or providing libraries of candidate proofs.

However, the deployment of LLMs in mathematical reasoning provokes substantive philosophical and practical concerns:

  • Alignment problem: LLMs might not reliably use concepts as humans intend outside training distributions, risking subtle conceptual mismatches.
  • Human verification limits: Human mathematicians are not well attuned to the modes of error characteristic of LLMs; next-token prediction can produce plausible, yet incorrect, “proofs” in ways that elude traditional error-detection heuristics.
  • Hallucination risk: LLMs may persist in producing text beyond the boundary of mathematical validity, potentially generating authoritative-sounding but vacuous content.
  • Overreliance and deskilling: Reliance on AI could erode core mathematical competencies, while the integration of LLM-generated “mathematical spam” poses systemic risks to review and dissemination channels.
  • Environmental and sociopolitical costs: The operation and training of large models have significant environmental footprints, and the provenance of training data raises issues of intellectual property and the commodification of collaboratively produced mathematical resources.

The authors suggest that neurosymbolic hybrid systems, able to combine formal verification with machine learning's generative and inferential capabilities, offer a way forward, but emphasize that caution and nuanced governance are essential to mitigate these multifaceted risks.

Implications and Prospects for the Philosophy and Practice of Mathematics

The technological turn has extended the epistemic division of labor beyond human-only collectives to configurations entangling humans, machines, and software libraries. This marks a substantive shift in the ontology of mathematical knowledge, with agency and authorship now plausibly ascribable to hybrid networks. The social epistemology of mathematics, as well as the philosophy of science, must adapt to these new realities.

The paper does not claim a single paradigm will dominate; instead, the complex interplay between formal verification, automation, and statistical learning is set to define mathematical practice for the foreseeable future. Persistent issues of reliability, fallibility, and translation between formal and informal mathematics are likely to remain central; at the same time, new issues such as AI alignment, the transparency of automated agents, and the governance of collective hybrid knowledge become urgent focal points for ongoing research and institutional policy.

Conclusion

The paper convincingly delineates a technological turn in mathematics that is reshaping not just technical methodologies, but the profound epistemic and social relationships at the heart of the discipline. Formal verification, neural generation, and large-scale collaboration are jointly recalibrating what it means to create, validate, and share mathematical knowledge. The ultimate challenge, both for practitioners and philosophers, is to ensure that methodological advances remain aligned with core values of rigor, transparency, and autonomy in mathematical inquiry, even as the labor of proof and discovery becomes increasingly automated and distributed.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Sign Up to Generate All Videos Subscribe on YouTube

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Sign Up to Generate

Explain it Like I'm 14

The Technological Turn in Mathematics — Explained Simply

What is this paper about?

This paper looks at how new computer tools are changing the way mathematicians do their work. It focuses on three kinds of tools:

  • Interactive Theorem Provers (ITPs): super-strict math “checkers” that verify every tiny step of a proof.
  • Automated Theorem Provers (ATPs): programs that try to find proofs on their own.
  • LLMs: AI systems (like advanced chatbots) that can write and reason in natural language and code.

The authors explain how these tools affect:

  • What counts as a good mathematical argument.
  • How mathematicians work together.
  • Who and what we trust when we say “this math is correct.”

What questions are the authors asking?

To make their main ideas clear, here are the big questions they explore:

  • How do ITPs change our idea of a “proof” and of mathematical rigor?
  • Can computers help catch human mistakes—and what new risks do they bring?
  • How do these tools reshape teamwork in math, especially big, global projects?
  • What role does trust play when people and machines work together?
  • What are the strengths and weaknesses of LLMs for doing real mathematics?

How do they study the problem?

This isn’t a lab experiment. It’s a philosophy and practice overview that:

  • Explains the technologies in plain terms (symbolic AI is logic-like; neural AI is brain-inspired).
  • Uses real cases from modern math:
    • The Four Color Theorem and the Kepler conjecture, where computers helped prove famous results.
    • The “Liquid Tensor Experiment,” where a community used an ITP (Lean) to check a deep proof.
    • The Polymath Projects (crowdsourced math without ITPs) vs. the Equational Theories Project (a large, tool-driven collaboration using Lean and ATPs).
    • Recent AI performances on International Math Olympiad-level problems.
  • Builds arguments about proof, collaboration, and trust from these examples.

Think of it like analyzing how a sports team changes when you add better equipment, new rules, and even robot teammates—and asking what “winning fairly” means in that new world.

What are the main ideas and why do they matter?

Here are the key takeaways, explained with everyday analogies where helpful:

  • Proof assistants raise rigor but don’t make certainty perfect.
    • An ITP is like a super-strict code compiler for math: it only accepts proofs that follow every rule exactly.
    • This helps catch human mistakes, especially in long or complicated arguments.
    • But there are caveats:
    • Software can have bugs.
    • “Translation” is tricky: turning an idea from normal math language into a formal version can accidentally change the meaning (like mistranslating a sentence and proving the wrong thing).
    • Bottom line: ITPs greatly increase confidence, but they don’t give absolute, risk-free certainty.
  • “Simil-proof”: what mathematicians often have first.
    • In real life, a new result usually starts as a “simil-proof”: an argument experts believe is correct, though a subtle mistake might still be hiding.
    • ITPs can upgrade many simil-proofs to fully verified formal proofs—but only if the translation is faithful and the software is sound.
  • Big-team math becomes easier and safer with ITPs.
    • Large collaborations can use ITPs to split work into smaller “Lego-like” pieces that fit together reliably.
    • You don’t have to personally know or trust every collaborator, because the checker enforces the rules for everyone.
    • Tools like shared libraries (e.g., Mathlib for Lean), project dashboards, and version control help people all over the world work asynchronously.
    • This “crowdsourced math” can be faster, broader, and more inclusive.
  • Trust doesn’t vanish—it moves and changes.
    • In traditional math, you often rely on other people’s reputations and careful peer review.
    • With ITPs, you lean less on interpersonal trust for correctness and more on:
    • The checking software and its maintainers.
    • Library moderators who approve additions.
    • Project organizers who coordinate tasks.
    • So trust shifts from “do I trust this person’s proof?” to “do I trust the process, the tools, and the infrastructure?”
  • Human–machine “hybrid teams” are the new normal.
    • In projects like the Equational Theories Project, the “team” includes people, proof assistants, automated provers, code, and shared libraries.
    • No single person understands everything; knowledge is spread across the network.
    • Philosophically, that raises questions like: can a group (including tools) “know” a proof, even if no individual knows all parts?
  • LLMs show exciting promise—and real risks.
    • Strengths:
    • They can suggest ideas, examples, and strategies.
    • They can draft formal code for ITPs or help with “autoformalization.”
    • Combined with evaluators or checkers, they can explore huge search spaces and discover patterns (for instance, improved bounds in combinatorics).
    • They’re helpful for literature search in a massive, messy math ecosystem.
    • Risks:
    • Alignment problem: an LLM might subtly use a concept differently than humans do, because it learns from patterns, not from guarantees. A solution might look convincing but be “about” a slightly different definition.
    • Hallucinations and brittle formal code: small errors can break a formal proof, and LLMs can sound confident when they’re wrong.
    • Opaque claims: flashy results (like IMO-level solutions) need careful, transparent testing and peer review to be meaningful.
    • A practical safeguard is to pair LLMs with strict checkers (ITPs/ATPs) or evaluators, so creative guesses get automatically verified.

What does this mean for the future of mathematics?

The authors suggest several likely impacts:

  • New standards of publishing: In some areas, important papers may come with both a human-readable proof and a formal, machine-checked version.
  • More large-scale, open collaboration: Crowdsourced projects will grow, with clearer roles, better tooling, and more global participation.
  • A rethinking of credit and responsibility: If groups (including software) contribute to proofs, we’ll need fair ways to assign credit and ensure accountability.
  • Better safety practices: Audit trails, transparent workflows, and open verification will matter more as tools get stronger.
  • Ongoing role for philosophy: Philosophers can help clarify what “proof,” “knowledge,” and “trust” mean in an age of hybrid human–AI teams—and what we should count as good evidence.

In short, the paper argues that math is entering a “technological turn.” Computers don’t replace human creativity and judgment, but they do change the tools, teamwork, and rules of the game. If we combine human insight with careful verification and thoughtful collaboration, we can do deeper, more reliable mathematics—while staying alert to new kinds of mistakes and new questions about what it means to know something is truly proven.

View Paper Prompt  View All Prompts 

Knowledge Gaps

Knowledge gaps, limitations, and open questions

Below is a consolidated list of concrete gaps and unresolved questions that emerge from the paper’s analysis of ITPs, ATPs, and LLMs in mathematical practice.

  • Develop rigorous methodologies to verify translation fidelity between informal statements and their formal counterparts, including tooling to detect hidden assumptions and concept drift in formal definitions.
  • Quantify and mitigate technological fallibility in the ITP stack: empirical bug incidence studies, adoption of small verified kernels, checker diversity, proof replay across independent systems, and hardware/software redundancy.
  • Establish interoperable proof-exchange standards and mechanically verified translations across foundationally distinct systems (e.g., Lean/Coq/Isabelle), with empirical validation of cross-port reliability.
  • Design transparent governance for community formal libraries (e.g., Mathlib): moderation accountability, conflict-of-interest policies, contributor vetting, and decision logs.
  • Implement supply-chain security for formal libraries: code signing, reproducible builds, continuous integration proof validation, and adversarial threat modeling.
  • Create sustainability plans for large formal libraries: versioning and migration tooling (e.g., Lean3→Lean4), deprecation strategies, long-term archiving, and bit-rot mitigation.
  • Build cost–benefit and risk models to guide when a simil-proof should be paired with a formal counterpart (by subfield/problem class), and formulate corresponding journal and funding policies.
  • Define standardized, auditable evaluation protocols for AI math systems (e.g., IMO-style): time/resource limits, single-agent constraints, leakage audits, compute disclosures, and independent replication harnesses.
  • Construct end-to-end autoformalization benchmarks with ground-truth alignments, covering statements, definitions, and proofs, robust to notation and idiomatic variability (especially in geometry, analysis, and category theory).
  • Create methods to ensure definitional alignment in formalizations: specification-based test suites, equivalence proofs to canonical definitions, round-trip paraphrase checks, and model validation on canonical examples/counterexamples.
  • Build explainability tools that convert formal proofs into faithful, human-surveyable narratives; define metrics for readability, conceptual alignment, and pedagogical quality.
  • Design safe-by-construction workflows for LLM-assisted formalization: interaction protocols, hallucination guards, lemma provenance tracking, and automatic cross-checks with ATPs/ITPs.
  • Detect and prevent AI-induced error propagation: anomaly detectors for overly short or suspiciously easy proofs, sandboxing and elevated review for AI-generated contributions, and policy for decontamination/rollback.
  • Conduct comparative empirical studies of error rates, review times, and downstream reliability of informal, computer-assisted, and fully formal proofs across diverse subfields.
  • Clarify credit, authorship, and responsibility in hybrid human–machine collaborations; standardize citation of software, datasets, models, and prompts; delineate accountability for errors.
  • Evaluate sociological impacts of “trust-minimizing” workflows: whether they democratize participation or centralize influence in library maintainers and tool vendors; study effects on collaboration patterns and inclusion.
  • Develop education and training frameworks that integrate formalization with traditional proof pedagogy; create guidelines to prevent counterproductive overreliance on LLMs in learning.
  • Assess equity and access: measure barriers from compute costs, tooling complexity, language, and onboarding; design interventions to broaden participation globally and in under-resourced institutions.
  • Formulate ethical and policy frameworks for disclosure and peer review of AI-assisted results: required release of prompts, seeds, code, and artifacts; handling proprietary models in reproducible research.
  • Establish data governance for LLMs in mathematics: legally clean training corpora, deduplication and leakage detection, documentation of sources, and strategies for notation normalization and harmonization.
  • Quantify confidence in formally verified results under translation risk by composing uncertainty budgets across kernel correctness, formalization fidelity, and interpretive ambiguity.
  • Build tooling for dependency visualization, concept maps, and project management in massive formalizations to help regain conceptual overview in highly modular developments.
  • Produce comparative playbooks for neurosymbolic pipelines (LLMs+ATPs+ITPs): ablation studies, task allocation heuristics, and criteria for when to invoke which component.
  • Run longitudinal studies of how AI tools shape problem selection, proof styles, and mathematical creativity; identify domains most altered by AI assistance.
  • Create standards for archiving and citing formal artifacts: persistent identifiers, rich metadata schemas (including intended semantics and definitional choices), and journal/platform integration.
  • Automate “spec-to-proof” workflows: structured capture of informal intent from mathematicians, traceability links from theorems to specifications, and conformance checking.
  • Operationalize multi-assistant verification protocols: proof replay in independent kernels, N-version checking, and cross-theory redundancy for critical results.
  • Give a clearer formal characterization and practical diagnostic criteria for “simil-proofs”; develop pre-formalization tools that flag likely gaps or non-local dependencies.
  • Improve human–computer interfaces for crowdsourced formalization: conflict-aware version control, contributor dashboards, role allocation, load balancing, and onboarding assistants.
  • Publish and maintain open benchmark suites derived from ETP-style projects (including unresolved finite-magma implications) to drive reproducible comparisons of tools and workflows.
  • Establish guidelines for LLM-aided literature search: audit trails, hallucination suppression, recall/precision evaluation against curated ground truth, and robust prior-art attribution.
View Paper Prompt  View All Prompts 

Practical Applications

Immediate Applications

The following items can be deployed today with existing tools and workflows, drawing directly on the chapter’s analysis of ITPs, ATPs, LLMs, crowdsourcing, and the changing trust dynamics in mathematical practice.

  • Bold: High-assurance software and hardware verification
    • Sectors: software, aerospace, automotive, medical devices, cybersecurity, finance
    • What: Use ITPs to formally verify safety-critical components, protocols, optimizing compilers, and numerical kernels; integrate machine-checkable proofs into CI/CD.
    • Tools/workflows: Lean, Coq/Rocq, Isabelle/HOL, F*/Dafny, SMT/SAT (e.g., Z3, CVC5), CompCert; proof obligations + CI gates; proof-carrying code artifacts.
    • Assumptions/dependencies: Expertise in formal methods; kernel soundness; library coverage; standards alignment (e.g., DO-333, ISO 26262, IEC 62304).
  • Bold: Cryptographic protocol and smart-contract audits with formal guarantees
    • Sectors: security, web3, fintech, payments
    • What: Mechanically verify protocol properties (confidentiality, liveness, consensus) and economic invariants; reduce reliance on reputation-based trust.
    • Tools/workflows: Coq/Rocq, Isabelle, F*, EasyCrypt, Tamarin, Certora/K frameworks; reproducible proof artifacts.
    • Assumptions/dependencies: Accurate threat models (side-channels, timing); up-to-date libraries; audit trail and governance for proof updates.
  • Bold: Reproducible math publishing with formal artifacts
    • Sectors: academia, scholarly communication
    • What: Pair “simil-proofs” with formal counterparts for key results; journals accept repositories with formal code and dependency graphs.
    • Tools/workflows: Lean/Mathlib, Isabelle Archive of Formal Proofs, Rocq; blueprint methodology; containerized artifacts (Docker/Nix); artifact-evaluation in peer review.
    • Assumptions/dependencies: Editorial policies; reviewer training; incentives for authors; stable library versions.
  • Bold: Large-scale, trust-minimized research collaborations
    • Sectors: academia, open science
    • What: Organize projects following the Equational Theories Project model—decompose tasks, formalize contributions, and verify automatically so trust is not a bottleneck.
    • Tools/workflows: Lean + Mathlib, GitHub, Zulip, proof dashboards, dependency tracking, ATP integrations (Vampire, Z3, Duper).
    • Assumptions/dependencies: Maintainer capacity; governance for merges; contributor onboarding; kernel reliability.
  • Bold: LLM-assisted “vibe formalization” for researchers and advanced students
    • Sectors: academia, education, software
    • What: Translate informal proofs into formal ones with LLM co-pilots; reduce the barrier to entry for formalization while preserving mechanical checking.
    • Tools/workflows: General-purpose LLMs paired with Lean/Coq; interactive prompts; iterative repair loops; blueprint-driven decomposition.
    • Assumptions/dependencies: LLM accuracy; clear separation of suggestion vs verification; data privacy; compute cost.
  • Bold: Proof exploration assistants integrated with ITPs/ATPs
    • Sectors: academia, software
    • What: Suggest lemmas, proof strategies, counterexamples; triage proof obligations; auto-discharge routine subgoals while humans guide structure.
    • Tools/workflows: Lean + Duper/Vampire/Z3; tactic learning; auto-suggest in IDEs; neurosymbolic search for subproblems.
    • Assumptions/dependencies: Stable APIs; benchmark suites; human-in-the-loop oversight.
  • Bold: Semantic literature search and mapping for mathematics
    • Sectors: academia, R&D
    • What: Use LLMs and embeddings to find near-duplicate results across notation/terminology, preventing rediscovery and surfacing “hidden” prior art (e.g., Erdos problems curation).
    • Tools/workflows: Vector search over arXiv/MathSciNet; citation-graph enrichment; human adjudication; provenance logging.
    • Assumptions/dependencies: Access to full texts (licensing); hallucination filters; bias checks; living knowledge graphs.
  • Bold: Curriculum updates for “trust and verification” in mathematics
    • Sectors: education, policy
    • What: Teach the distinction between simil-proofs and formal proofs; introduce proof assistants and collaborative verification practices.
    • Tools/workflows: Course modules with Lean/Isabelle labs; sandboxed CI for assignments; peer code review of proofs.
    • Assumptions/dependencies: Teacher training; lab time and infrastructure; curated problem sets.
  • Bold: Governance for AI math benchmarks and competitions
    • Sectors: policy, academia, AI labs
    • What: Adopt auditable protocols for IMO-style evaluations (time limits, compute caps, single-agent constraints, full logs, public artifacts) to prevent “unverifiable” claims.
    • Tools/workflows: Benchmark governance boards; secure logging; artifact release requirements; third-party evaluation.
    • Assumptions/dependencies: Organizer buy-in; reproducibility infrastructure; shared metrics.
  • Bold: Institutional policies for AI use in research and teaching
    • Sectors: academia, industry R&D
    • What: Define when AI-generated arguments are acceptable, when human checks are required, and when formal verification is mandated; codify authorship/credit in hybrid teams.
    • Tools/workflows: AI usage statements; audit trails; disclosure forms; credit taxonomies for human–machine collaborations.
    • Assumptions/dependencies: Legal/IP clarity; IRB-like oversight for AI; consensus on authorship norms.
  • Bold: Formal validation of numerical algorithms in engineering pipelines
    • Sectors: engineering, energy, HPC
    • What: Verify error bounds, stability, and convergence for algorithms used in simulation/optimization; reduce propagation of subtle mathematical errors.
    • Tools/workflows: CoqInterval, Flocq, HOL-Light analysis libraries; regression plus proof gates.
    • Assumptions/dependencies: Performance overhead tolerance; adequate formal libraries; modeling of floating-point realities.
  • Bold: Risk triage using “coverage-supported belief” concepts
    • Sectors: research management, compliance
    • What: Prioritize formal verification and additional checking for results with high dependency centrality or high downstream safety impact.
    • Tools/workflows: Dependency graphs; risk scoring; verification roadmaps; dashboards.
    • Assumptions/dependencies: Metadata quality; organizational incentives; maintainers for critical libraries.

Long-Term Applications

These opportunities need further research, scaling, standardization, or cultural change. They extend the chapter’s themes on hybrid epistemic networks, translation risks, and neurosymbolic advances.

  • Bold: Formal counterparts as norms for flagship theorems
    • Sectors: academia, publishing
    • What: Require a machine-checked version (or partial formal core) for results in areas prone to long or computation-heavy proofs; journals grant badges for formal artifacts.
    • Dependencies: Mature libraries across subfields; auto/interactive formalization pipelines; reviewer capacity.
  • Bold: A national/international “Mathematics Infrastructure” corpus
    • Sectors: academia, policy
    • What: Publicly funded, continuously maintained, machine-checked library of core mathematics (a “Mathlib++”), with curation, provenance, and versioning.
    • Dependencies: Long-term funding; cross-foundation interoperability; stable governance; educational pipelines.
  • Bold: Neurosymbolic “mathematician agents” producing end-to-end, verified proofs
    • Sectors: software, academia
    • What: Agents that propose conjectures, search proofs, and emit Lean/Isabelle code that checks; humans curate and guide high-level programs of work.
    • Dependencies: Alignment to human concepts; translation safeguards; compute/data; evaluation standards beyond training data.
  • Bold: Autoformalization at scale for mathematical text and code
    • Sectors: academia, education, publishing
    • What: IDEs and authoring tools that incrementally convert informal text into formal statements and proofs with interactive repair; “spell-check for proofs.”
    • Dependencies: Robust parsers; interactive UX; domain-specific libraries; stable kernel interfaces.
  • Bold: Social-machine platforms generalized beyond mathematics
    • Sectors: physics, economics, computational social science
    • What: Hybrid human–AI infrastructures to co-develop formal models, derivations, and proofs of properties (e.g., equilibrium existence, conservation laws).
    • Dependencies: Domain formalization maturity; verified numerical–symbolic bridges; incentives for formal artifacts.
  • Bold: Proof-carrying research publications and automated refereeing
    • Sectors: academia, policy
    • What: Journals and funders mandate machine-checkable proof artifacts, auto-ref checks, and reproducible pipelines for math-heavy results.
    • Dependencies: Standard proof-packaging formats; legal/IP frameworks; artifact escrow.
  • Bold: Regulatory certification of AI-proved results in safety-critical systems
    • Sectors: automotive, aerospace, healthcare, energy
    • What: Certification regimes accept formally verified mathematical properties (control invariants, dose-calculation bounds) derived by AI+ITP pipelines.
    • Dependencies: Sector standards; liability clarity; regulator expertise; adversarial testing.
  • Bold: Proof-of-compliance in law and finance
    • Sectors: govtech, regtech, finance
    • What: Codify regulations and contracts in formal languages; continuous formal audits; proof-carrying smart contracts for obligations and risk limits.
    • Dependencies: Formal legal ontologies; change-management for evolving laws; human–formal translation governance.
  • Bold: Personal math copilots with verifiable backends
    • Sectors: daily life, education
    • What: Consumer-grade assistants that solve homework, taxes, or budget math with a verifiable proof trail; adjustable strictness from “explain-like-I’m-5” to “Lean proof.”
    • Dependencies: Cost-effective verification; privacy; age-appropriate UX; curriculum alignment.
  • Bold: Credentialing and assessment built on formal proof artifacts
    • Sectors: education, professional certification
    • What: Auto-graded, machine-checked proof assignments; micro-credentials for formal skills; portable proof portfolios.
    • Dependencies: Scalable infrastructure; accessibility; anti-cheating measures; equitable access.
  • Bold: Marketplaces for modularized proof tasks and credit allocation
    • Sectors: academia, OSS ecosystems
    • What: Bounty platforms splitting a large proof into microtasks with verified merges and transparent contributor credit.
    • Dependencies: Quality control; anti-plagiarism; contributor governance; sustainable funding.
  • Bold: Provenance and attestation ledgers for mathematical knowledge
    • Sectors: academia, policy, software supply chain
    • What: Cryptographically signed proof artifacts, kernel hashes, and dependency attestations; supply-chain security for math libraries.
    • Dependencies: PKI standards; kernel diversity and audits; long-term archival.
  • Bold: Sector-specific formalization of clinical guidelines and calculators
    • Sectors: healthcare
    • What: Mechanically verified medication dosing rules, risk scores, and pathway logic; integrated into CDS systems to reduce errors.
    • Dependencies: Clinically faithful models; liability frameworks; interoperability with EHRs.
  • Bold: Verified numerical kernels for grids, optimization, and robotics
    • Sectors: energy, logistics, robotics
    • What: Formally verified solvers and control laws with certified bounds; regulation may eventually mandate such assurances.
    • Dependencies: Libraries for hybrid/continuous systems; performance parity; co-verification with hardware-in-the-loop.
  • Bold: Independent, standards-setting bodies for math-AI evaluations
    • Sectors: policy, AI labs, academia
    • What: Neutral institutions define fair, auditable protocols for math reasoning benchmarks; require public artifacts and third-party verification.
    • Dependencies: Funding; lab participation; enforceable rules; community consensus.

Cross-cutting assumptions and dependencies

Across both horizons, feasibility hinges on:

  • Kernel soundness and diversity: independent audit of small trusted kernels; bug bounties; multi-kernel redundancy.
  • Translation fidelity: systematic checks that formalized definitions match intended informal ones; domain expert “semantic reviews.”
  • Library depth and coverage: sustained investments in Mathlib/AFP and domain libraries (analysis, geometry, algebraic topology, hybrid systems).
  • Human capital and incentives: training programs, tenure/promotion credit for formalization, maintainers funded as research infrastructure.
  • Governance and ethics: disclosure of AI assistance; clear authorship/credit in hybrid teams; reproducibility and auditability as norms.
  • Access and equity: reduce compute and licensing barriers; privacy-preserving workflows; inclusive education pathways.
View Paper Prompt  View All Prompts 

Glossary

  • AlphaGeometry: A DeepMind neuro-symbolic model for guiding symbolic deduction in geometry. "DeepMind's AlphaGeometry model is described by Trinh et al. (2024) as 'a neuro-symbolic system that uses a neural LLM, trained from scratch on our large-scale synthetic data, to guide a symbolic deduction engine through infinite branching points in challenging problems' (Trinh et al. 2024, 476)."
  • AlphaProof: A DeepMind neural theorem-proving system that integrates large neural networks with reinforcement learning to find formal proofs. "A notable neural AI model is DeepMind's AlphaProof, a neural theorem-proving system that integrates large neural networks with reinforcement learning to find proofs."
  • Aristotle: A neural AI model used to search for formal proofs in theorem provers. "This problem can be exacerbated when interactive theorem provers are paired with neural AI systems, such as Aristotle."
  • Artificial Intelligence in mathematics: An umbrella term covering ITPs, ATPs, and LLMs applied to mathematical practice. "'Artificial Intelligence in mathematics' is an umbrella term encompassing a wide range of different tools."
  • Automated Theorem Provers (ATPs): Software that automatically searches for proofs using symbolic reasoning. "Automated Theorem Provers such as Vampire, Mace, Duper, Z3, MagmaEgg, and Prove9, were used to automate large parts of the mathematics."
  • Autoformalisation: Automatic translation of informal mathematics into a formal language for verification. "For example, Wu et al. (2022) gave an early attempt at autoformalisation of mathematical statements into the formal language of Isabelle."
  • Boolean Pythagorean triples problem: A combinatorial decision problem solved via massive SAT computations. "The symbolic tradition has numerous milestone successes, such as Heule, Kullmann, and Marek's (2016) 200-terabyte solution to the Boolean Pythagorean triples problem."
  • Cap set problem: A combinatorial number theory problem about sets avoiding 3-term arithmetic progressions in vector spaces over finite fields. "Romera-Paredes et al. (2024) report using an LLM as part of a system called FunSearch to achieve new lower bounds for some versions of the cap set problem."
  • Classification of Finite Simple Groups: A monumental collaborative proof classifying all finite simple groups. "While there have been examples of large collaborations without substantial dependence on ITPs, most notably the enormous proof of the Classification of Finite Simple Groups (Habgood-Coote and Tanswell 2023; Steingart 2012), these have the problem that it is inevitable that errors will arise in such a large (simil-)proof."
  • Coq: An interactive theorem prover based on dependent type theory. "Examples of such systems are Lean, Coq (and its recent development, Rocq Prover), and Isabelle."
  • Coverage-supported belief: A social-epistemic notion where confidence in correctness is grounded in community coverage. "That is, this would be what Goldberg (2011) calls a coverage-supported belief."
  • Crowdsourcing: Large-scale participative online collaboration to tackle mathematical tasks. "According to a systematic overview of definitions, crowdsourcing refers to 'a type of participative online activity in which an individual, an institution, a non-profit organization, or company proposes to a group of individuals of varying knowledge, heterogeneity, and number, via a flexible open call, the voluntary undertaking of a task' (Estelles-Arolas and González-Ladrón-de-Guevara 2012, 197)."
  • Deep learning: Neural network-based statistical learning from large datasets, increasingly applied to mathematics. "With the rapid rise of LLMs and deep learning, the ability of these systems to do mathematics is in the spotlight."
  • Dependent type theory: A foundational system where types can depend on terms, underpinning Coq and Lean. "Coq and Lean are based on dependent type theory."
  • Differential geometry: A field studying smooth manifolds and related structures using calculus and geometry. "For instance, in certain mathematical domains, such as differential geometry, it is non-trivial to define the main objects of study in their full generality."
  • Density Hales-Jewett theorem: A major result in Ramsey theory targeted by an early Polymath project. "He proposed an open, online, collaborative effort to give a new, elementary proof of the Density Hales-Jewett theorem (Gowers 2010; Gowers and Nielsen 2009)."
  • Equational laws: Algebraic identities stated in terms of a binary operation. "Equational laws are then laws stated using the operation, e.g., Commutativity is the law x + y = yo x, and Tarski's axiom is the law x = y o (z (x (yoz)))."
  • Equational theories: Collections of equational laws studied for consistency and implications. "Different equational laws can be combined together to form equational theories, but only some of these will be consistent."
  • Equational Theories Project (ETP): A large-scale, Lean-based crowdsourcing project mapping implications among equational theories of magmas. "In September 2024. Terence Tao, who had been frequently involved in the Polymath Projects, proposed a crowdsourced project he called the Equational Theories Project (ETP)."
  • Fermat's Last Theorem: The statement that there are no integer solutions to xn + yn = zn for n > 2; its proof is being formalized in Lean. "A high-profile project currently underway led by Kevin Buzzard aims to provide a full formalization of Andrew Wiles and Richard Taylor's proof of Fermat's Last Theorem."
  • Formal verification: Mechanically checking the correctness of formalized mathematical or software proofs. "[F]ormal verification only certifies that a formalized argument establishes a formal mathematical statement, but does not rule out errors in translation between the formal statement and the original intended statement."
  • Four Color Theorem: The theorem that any planar map can be colored with four colors; a landmark computer-assisted and later formally verified proof. "They proved the Four Color Theorem with the aid of a computer."
  • FunSearch: A system combining LLM-generated programs with evaluation to discover new mathematical results. "Romera-Paredes et al. (2024) report using an LLM as part of a system called FunSearch to achieve new lower bounds for some versions of the cap set problem."
  • GOFAI: “Good Old-Fashioned AI,” the logic-based symbolic AI paradigm. "symbolic AI, sometimes called 'Good Old-Fashioned AI' (GOFAI), grew out of the mathematical logic tradition and its influence on early computer science."
  • Hadwiger-Nelson problem: A graph coloring problem about the chromatic number of the plane. "By now there have been sixteen Polymath Projects, with the last one, on making progress on the Hadwiger-Nelson problem, finished in 2021."
  • Higher-order logic: A logical foundation allowing quantification over functions and predicates, used by Isabelle. "Isabelle is primarily based on higher-order logic."
  • International Mathematical Olympiad (IMO): The premier international high school math competition used as a benchmark for AI systems. "DeepMind reports (Hubert et al. 2025) that AlphaProof, combined with AlphaGeometry 2 (another of DeepMind's Al agents, focused on solving geometry problems), was able to achieve a result equivalent to a Silver Medal at the 2024. International Mathematical Olympiad (IMO)."
  • Isabelle: An interactive theorem prover, often used as a target for autoformalisation. "For example, Wu et al. (2022) gave an early attempt at autoformalisation of mathematical statements into the formal language of Isabelle."
  • Kepler conjecture: The statement that the densest sphere packing in three dimensions is the face-centered cubic packing; formally verified. "Another early breakthrough is Thomas Hales' verification of his proof of the Kepler conjecture."
  • Knot invariant: A quantity preserved under ambient isotopy, used to distinguish knots. "An early result in this direction is the discovery in knot theory of a new knot invariant (Davis 2021)."
  • LLMs: Transformer-based generative models trained on text/code, increasingly used in mathematical tasks. "In particular, the development of neural AI has witnessed a breakthrough since the popularization of LLMs such as ChatGPT at the end of 2022."
  • Lean: A modern interactive theorem prover based on dependent type theory and supported by the Mathlib library. "Lean was used for verification."
  • Lean blueprint: A project-management and documentation system for organizing Lean formalizations. "Patrick Massot's Lean blueprint system was used for project management."
  • Lie groups: Smooth manifolds with a compatible group structure central to many areas of mathematics. "or manifolds endowed with additional structure such as Lie groups"
  • Liquid Tensor Experiment: A Lean-based community effort to formalize results in condensed mathematics initiated by Scholze. "The Lean community responded enthusiastically and started the Liquid Tensor Experiment, which was extremely successful."
  • Magmas: Sets equipped with a single binary operation, used as the algebraic setting of the ETP. "The project was about magmas: a set M with a binary operation .: M x M -> M."
  • Mathlib: The main mathematical library for Lean that supports large-scale formalization. "Lean's library Mathlib."
  • Metamath: A proof verification system with explicit variable handling requirements. "it relies on a quirk of the proof verification system used (Metamath), which requires you to explicitly prohibit certain variable substitutions."
  • Neural AI: Brain-inspired AI paradigm using neural networks and statistical learning. "Neural AI is instead based on neural networks, loosely inspired by the structure of the human brain."
  • Neurosymbolic approach: A hybrid method combining neural learning with symbolic reasoning. "It should be noted that there is the possibility (and hope) of combining the two approaches with a neurosymbolic approach, combining the advantages of neural AI with the rigorous reasoning that underlies symbolic Al."
  • Peano arithmetic: A first-order axiomatic system for the natural numbers. "Patrick Brosnan's computer-verified 'proof' of the inconsistency of Peano arithmetic."
  • Polynomial Freiman-Ruzsa (PFR) conjecture: A conjecture in additive combinatorics about structure in sets with small sumsets. "a preprint containing a simil- proof of the Polynomial Freiman-Ruzsa (PFR) conjecture over F2 (Gowers et al. 2024)"
  • Proof assistants: Software tools (ITPs) that help construct and check formal proofs. "Interactive Theorem Provers (also called 'proof assistants') to check the correctness of their proofs."
  • Reinforcement learning (RL): An AI training paradigm based on reward signals, used to learn proof strategies. "It is an 'agent that learns to find formal proofs through RL [reinforcement learning] by training on millions of auto-formalized problems' (Hubert et al. 2025, 1)."
  • Rocq Prover: A recent development of Coq, an interactive theorem prover. "Coq (and its recent development, Rocq Prover)"
  • Sidon sets: Sets with pairwise sums all distinct, studied in additive combinatorics. "the recent 'vibe formalisation' of a proof about Sidon sets by Alexeev and Mixon (2025)"
  • Simil-proof: A community-standard argument treated as a proof, possibly with subtle errors. "a mathematician needs to have a 'simil-proof,' that is, an argument that conforms to the inferential standards of a legitimate mathematical community"
  • Social machine (of mathematics): A hybrid epistemic network of people, computers, and archives collaborating on math. "mathematics as a social machine"
  • Symbolic AI: Logic-based AI paradigm leveraging explicit representations and inference. "symbolic AI, sometimes called 'Good Old-Fashioned Al' (GOFAI), grew out of the mathematical logic tradition and its influence on early computer science."
  • Tarski's axiom: A specific equational law used in the ETP context. "Tarski's axiom is the law x = y o (z (x (yoz)))."
  • Transformer architecture: The neural network architecture underlying modern LLMs. "the transformer architecture used by LLMs."
  • Trust-free ideal of mathematics: The ideal that mathematicians verify all results themselves without interpersonal trust. "the trust-free ideal of mathematics"
  • Wittgenstein's rule-following problem: A philosophical challenge about how rules are determined and followed beyond finite examples. "As in Wittgenstein's rule-following problem, the fact that the LLMs are only trained on finitely many instances of seeing a mathematical concept being used means that their statistical predictions of how it will continue to be used may well fail"
  • Z3: A widely used SMT solver employed as an automated reasoning tool in the ETP. "Automated Theorem Provers such as Vampire, Mace, Duper, Z3, MagmaEgg, and Prove9, were used to automate large parts of the mathematics."
View Paper Prompt  View All Prompts 

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Generate Now

Collections

Sign up for free to add this paper to one or more collections.

Sign Up

Tweets

Sign up for free to view the 1 tweet with 41 likes about this paper.

Sign Up for Free