AI-Assisted Math Discovery

What is it

AI-Assisted Math Discovery is the use of large language models and formal proof assistants to generate, check, and publish original mathematical results. The technical core is a loop: an LLM proposes lemmas, conjectures, or proof sketches; a formal verifier like Lean 4 (via Mathlib) or a computer-algebra system checks every step; failed proofs feed back as training signal. OpenAI's claim that its models proved the local smoothing conjecture and refuted a long-standing exponential-time hypothesis — combined with the open-sourcing of openai/math — moved this from research curiosity to a reproducible toolchain.

The business significance is that the expensive, scarce part of mathematics is no longer idea generation or even proof checking. Lean 4's mathlib contains roughly 1.5 million lines of verified mathematics, and the verification step is deterministic and cheap to run. What remains scarce is workflow: a way for researchers, quant teams, and engineering groups to run these loops, track results, and integrate them into existing toolchains. That gap is where indie products live. This is not a consumer category. It is a professional tooling category with a small, motivated, well-funded buyer set.

Why now

Three things flipped in the same 18-month window. First, formal verification matured: Lean 4 plus Mathlib is now a credible target for automated proof search, and projects like DeepMind's AlphaProof demonstrated that ML-guided search can reach competition-level results. Second, frontier labs started publishing their math tooling openly — openai/math is the signal here, not the endpoint. When a lab open-sources its harness, it converts a research capability into a developer platform. Third, the economics of inference collapsed enough that running thousands of proof attempts per day costs dollars, not thousands of dollars.

The demand side is also shifting. Quantitative finance, chip design verification, and safety-critical software all need provable properties, and the teams doing that work are small and under-tooled. Meanwhile, academic math departments face flat budgets but rising pressure to produce verifiable results for grant compliance. The 2026-10-29 first-seen date and 100% growth rate indicate the term is at the very start of its adoption curve — early enough that category-defining products are still unbuilt, late enough that the underlying primitives work. That is precisely the window where a two-week MVP can establish a foothold before incumbents notice.

Market Evidence

The evidence base is thin and you should treat it as such. Two independent sources (oschina and GitHub), two total mentions, a trend score of 62/100, and a 100% growth rate. A 100% growth rate on a base of two mentions is arithmetic noise, not a demand signal. The GitHub signal is more meaningful than the news mention: a repository under an OpenAI namespace attracts watchers, forks, and issues, and those are behavioral rather than editorial signals.

The honest read: this is early signal, not validated demand. The stage label "nascent" is accurate. What makes it worth attention despite the thin numbers is the source quality — OpenAI making a mathematical claim of this specificity (proving a named conjecture, refuting a named hypothesis) is falsifiable and therefore credible in a way that generic "AI for X" announcements are not. The market scores of 0/100 across demand, market, and competition should be read as "unmeasured," not "nonexistent."

The test for real versus fleeting: watch whether third-party reproductions appear. If independent researchers reproduce the Lean proofs within 60 days, the category is real. If the claims stay siloed inside OpenAI's own repo, treat it as marketing and wait.

Who's Behind It

The whale is OpenAI, and its role is category legitimizer rather than future monopolist — labs chase frontier results, not $49/month workflow tools. Adjacent whales matter more for competitive dynamics: DeepMind (AlphaProof, AlphaGeometry) has the deepest formal-math research bench; Microsoft Research has invested heavily in Lean and automated theorem proving; and Anthropic's models are widely used in proof-search experiments. None of them ship a developer-facing math discovery product today.

The community layer is where the real gravity sits: the Lean/Mathlib community (thousands of contributors, an active Zulip, and a formalized-mathematics conference circuit), plus the growing set of researchers publishing LLM-plus-verifier papers. These people are your first users and your harshest critics. The tooling vendors — Lean FRO (the nonprofit stewarding Lean 4), and commercial players around formal methods like Galois and AdaCore — are potential partners, not threats. Your competitive risk is not OpenAI building your product; it is a Mathlib-adjacent startup or a well-funded research spinout claiming the workflow layer first.

TAM & Market Size

Be realistic: this is a niche B2B market, not a mass market. The buyer set has four segments. (1) Academic math and CS researchers: roughly 25,000–40,000 active researchers worldwide in relevant fields, of whom perhaps 3,000–5,000 already use Lean or a proof assistant. (2) Formal verification engineers in industry — chip design (Intel, AMD, ARM), aerospace, and safety-critical software — a few thousand practitioners. (3) Quantitative finance research teams, where provable algorithm properties and strategy verification are increasingly valued; maybe 1,000–2,000 relevant desks globally. (4) AI labs and research groups building math-capable models, a few hundred teams with real budgets.

Price tolerance is high per seat because the alternative is expensive PhD time. A researcher billing at $100+/hour will pay $50–200/month for a tool that saves hours weekly. Institutional budgets are lumpier: a university lab can absorb $5,000–20,000/year; an industry verification team can absorb $50,000+/year for a team license. The demand score of 0/100 reflects zero measured demand, not zero willingness to pay. Bottom-up, a realistic serviceable market is $50–150M annually — small, but enough to build a profitable company, which is exactly the right size for an indie founder.

Competitive Landscape

Direct competition is nearly absent at the workflow layer. What exists: proof assistant IDEs (Lean's own tooling, VS Code extensions), research prototypes from labs, and general-purpose coding assistants (GitHub Copilot, Cursor) that can write Lean but cannot run verification loops, manage conjecture libraries, or track proof provenance. Competition score of 0/100 is literal — there is no established product doing "AI proposes, verifier checks, results are tracked and exportable."

That gap is real but fragile. Your differentiation must be the loop, not the model: anyone can call an LLM API, but few will build the verifier orchestration, the failed-attempt memory, and the result-tracking layer that makes repeated discovery sessions productive. Big Tech entry risk is moderate: if OpenAI or DeepMind ships a polished math-discovery product, you have roughly 6–12 months before distribution advantage crushes a generic offering. Your defense is vertical depth — own a specific niche (e.g., combinatorics for quant finance, or Lean proof repair for verification engineers) where a generalist product is too shallow. Do not compete on model quality. Compete on workflow fit and result provenance.

Business Model

Recommendation: seat-based SaaS with a usage-metered tier, not pure subscription and not freemium-with-unlimited-inference. Inference costs are real and variable; unlimited plans will bleed you. Structure:

• Free tier: 20 verification runs/month, 1 project, community support. Purpose is funnel, not revenue.
• Pro ($79/month per seat): 500 runs/month, unlimited projects, proof history, export to Lean/Mathlib format, API access with rate limits.
• Team ($399/month for 5 seats): shared conjecture libraries, role-based access, audit logs, priority queue.
• Enterprise (custom, target $25,000–60,000/year): on-prem or VPC deployment, SSO, dedicated support. This is where formal-verification teams in industry actually buy.

Why this fits: researchers expense individual seats easily; institutions buy team plans; industry needs compliance features and will pay 10x. Avoid one-time licenses — the value is continuous (new model versions, growing proof libraries).

12-month forecast (conservative/base/optimistic): conservative 40 paying seats averaging $90 = ~$3,600 MRR by month 12; base 150 seats = ~$13,500 MRR; optimistic 400 seats plus two enterprise deals = ~$45,000 MRR. CAC estimate: $150–400 via academic community outreach and conference presence (low paid-ad viability in this niche). Payback: 2–5 months on Pro seats, under 3 months on team plans. The model only works if you keep inference cost per run under ~$0.15.

MVP Blueprint

Build in 5–7 days. Core loop only: submit a conjecture or problem statement → system generates N candidate proof sketches via LLM → each is translated to Lean 4 and checked against Mathlib → results are stored with pass/fail and the verifier's error output → user sees a ranked list of attempts and can export any successful proof.

Cut ruthlessly: no fine-tuning, no custom model hosting, no collaborative editing, no mobile app, no elaborate dashboard. One web form, one results table, one export button.

Tech stack: Next.js or SvelteKit frontend; Python FastAPI backend (the Lean and LLM ecosystem is Python-first); Postgres for attempt storage; a job queue (Redis plus Celery or RQ) because verification runs take seconds to minutes; Lean 4 installed in a container per job for isolation; OpenAI or Anthropic API for generation. Deploy the Lean container on a cheap VM or Fly.io — do not attempt serverless for long-running verification.

Fastest path to launch: day 1–2, Lean container plus verifier wrapper; day 3, LLM generation and Lean translation prompt; day 4, job queue and storage; day 5, minimal UI; day 6, Stripe checkout and usage metering; day 7, deploy and post to the Lean Zulip and r/math. The API product is a thin wrapper over the same backend — ship it in week 2 once the loop is stable. Estimated dev effort is genuinely small because the hard part (Lean, Mathlib, models) is already built by others.

Commercial Opportunities

1. Proof-repair service for formal verification teams. Engineers with broken or incomplete Lean proofs — common in chip and safety-critical verification — pay for automated repair suggestions. Target: verification engineers at semiconductor and aerospace firms. Expected $8,000–20,000 MRR at 20–40 seats plus one enterprise pilot. Beats alternatives because existing tools (Lean IDE, Copilot) offer no verifier-in-the-loop repair.

2. Conjecture lab for quant research. A workspace where quant teams state properties of trading algorithms or risk models and get machine-generated, formally checked candidates for further investigation. Target: quant researchers at funds and prop shops. Expected $10,000–30,000 MRR across 5–10 team accounts at $399–1,500/month. Beats generic AI chat because provenance and verifiability are the product.

3. Curriculum and benchmark licensing for universities. Sell departments a hosted environment plus graded exercise sets with auto-verified solutions. Target: math and CS departments. Expected $3,000–8,000 MRR from 10–20 department licenses at $300–500/month. Beats building in-house because Lean infrastructure is painful to maintain.

Product Ideas

🥇 ProofLoop — "Submit a conjecture, get verified proof attempts in minutes." Target: Lean-using researchers and verification engineers. Why now: the verifier-plus-LLM loop is finally cheap and reliable, and no product packages it as a repeatable workflow. This is the MVP above, productized.

🥈 Lemma Ledger — "A versioned, searchable library of every proof attempt your team has made." Target: research labs and industry verification teams that lose institutional knowledge when PhDs graduate. Why now: as AI generates thousands of attempts, the record of what was tried becomes the asset. Pairs naturally with ProofLoop as an upsell.

🥉 MathCI — "Continuous verification for mathematical claims in your codebase or papers." Target: engineering teams embedding formal specs and academic groups preparing submissions. Why now: CI for proofs is an obvious need with no dedicated product; a GitHub App that runs Lean checks on every push is a narrow but sticky wedge.

Rank by priority: ProofLoop first because it is the core loop and the fastest to build; Lemma Ledger second because it creates retention; MathCI third because it needs distribution partnerships.

SEO Opportunity

Search volume is tiny today — "Lean 4 AI proof" and "automated theorem proving tool" see low hundreds of monthly searches — but the trend line is up and SEO difficulty is effectively 0/100 because almost no commercial content targets this space. Long-tail keywords worth owning: "Lean 4 proof automation," "AI theorem prover API," "verify Lean proof with LLM," "Mathlib proof search tool," and "formal verification AI assistant." Strategy: publish technical tutorials that rank by being genuinely useful to the Lean community — "How to run 100 proof attempts overnight" — rather than keyword-stuffed landing pages. Community credibility drives this channel more than volume.

Risk Assessment

Top risk is that the thesis is wrong at the root: the OpenAI claims may not reproduce independently, in which case the category deflates within a quarter. Validate by checking whether third-party Lean proofs appear in public repos within 60 days.

Second risk is market timing: the buyer set is small and slow-moving, and academics adopt tools over years, not weeks. If you need revenue in 90 days, this is the wrong category.

Third risk is platform absorption: OpenAI, DeepMind, or a well-funded spinout ships the workflow layer and your differentiation evaporates. Mitigate by going vertical fast.

Cheap validation: build the Lean-plus-LLM loop as a throwaway script, run it on 20 real open problems from the Lean community's "unsolved" list, and post results to the Lean Zulip asking whether people would pay for this as a service. If you get fewer than 10 substantive replies or zero "how do I pay" responses, walk away. Set a hard 30-day checkpoint: if you cannot get 5 design partners or 3 pre-orders, stop.

Action Plan

Today: clone openai/math, run the examples, and time a verification loop end to end. Confirm you can get Lean 4 plus Mathlib running in a container in under two hours.

Week 1: build the throwaway validation script described above; run 20 real problems; post findings to the Lean Zulip and r/math with a clear "would you pay $79/month for this" question. Simultaneously draft the ProofLoop landing page with a waitlist.

Month 1: if signal confirms (10+ substantive replies, 5+ waitlist signups from researchers), build the MVP per the blueprint, ship the Stripe-metered Pro tier, and recruit 3 design partners at a discounted $39/month. Target first $500 MRR.

Month 3: target 20 paying seats (~$1,600 MRR), ship Lemma Ledger as an upsell, and start one enterprise conversation with a formal-verification team. If MRR is under $500 and design partners are not using the product weekly, pivot to the Proof-Repair niche or exit the category.

Related Terms

Formal Verification — the parent discipline; AI-Assisted Math Discovery is its generative frontier, and demand for verification engineers is the bridge to real budgets. AI for Science — the broader wave (protein folding, materials discovery) that gives this category its narrative and investor interest. Lean 4 / Mathlib — the technical substrate; its growth rate is the best leading indicator for this entire market. Watch Mathlib contributor counts monthly as your single best demand proxy.