PJFP.com

Pursuit of Joy, Fulfillment, and Purpose

Tag: reasoning models

  • OpenAI’s Astra Model Just Solved Ten Open Math Problems for $2,000: Sphere Packing, Connes’s Rigidity Conjecture, Non-Sofic Groups and Seven More

    On August 1, 2026, OpenAI published Ten advances in mathematics and theoretical computer science, a 249-page collection of research results produced by an internal version of Astra, its next major model. Every problem in the collection had been open with no progress on the main result for at least a decade, and most for far longer. The compute bill to find all ten solutions was roughly $2,000. That number, more than any individual theorem, is the part of this announcement that should stop you cold.

    TLDR

    OpenAI released ten new mathematical results generated by an unreleased internal model called Astra, spanning high-dimensional geometry, coding theory, group theory, operator algebras, arithmetic circuit complexity, quantum complexity, lattice cryptography, convex geometry, Ramsey theory and extremal combinatorics. The headline items include the first improvement since 1978 to the general high-dimensional sphere-packing exponent, the first improvements since 1977 and 1978 to the MRRW and Kabatianskii-Levenshtein bounds for binary and spherical codes, the construction of an explicit non-sofic group that kills the soficity conjecture, a disproof of Connes’s rigidity conjecture for property-(T) group von Neumann algebras, new circuit and formula lower bounds for the permanent, an exponential parallel repetition theorem for all two-player entangled quantum games that had been open since 2004, n^(1/400) hardness of approximation for the Euclidean closest vector problem via a direct 3SAT reduction that never invokes the PCP theorem, the sharp (n+1)^n/n! bound in Ehrhart’s volume conjecture in every dimension, a superexponential lower bound proving R_k(3) = k^Θ(k) and settling Erdős problem 183, and counterexamples to both the Erdős-Simonovits compactness conjecture and Erdős’s degeneracy conjecture. The model generated the arguments, humans prepared the manuscripts alongside the same model, and the model then formalized each argument in a Lean certificate, released publicly on GitHub together with narrated walkthroughs of the model’s reasoning. OpenAI explicitly declined to claim human authorship, framing attribution as a question the mathematical community has to answer and nodding to the signers of the Leiden Declaration on AI and Mathematics.

    Thoughts

    The $2,000 figure is the whole story compressed into four digits. A single one of these results, in the ordinary run of mathematics, represents a career milestone. The sphere-packing exponent had not moved since 1978. The MRRW coding bound had not moved since 1977. The soficity conjecture had been open since Gromov raised the approximation property in 1999 and Weiss named it in 2000, and the field’s best hope was a conditional route through permutation stability hypotheses that nobody had proved. Ten of these, at once, for the price of a used motorcycle. Whatever you believed about the trajectory of AI in research mathematics on July 31, the marginal cost of a decade-old open problem is now a number you can put on a purchase order.

    What makes the collection hard to wave away is the Lean formalization. The standard and entirely reasonable objection to machine-generated mathematics is that a language model produces confident, fluent, subtly wrong arguments, and that checking them costs more expert time than they save. A Lean certificate collapses that objection. The proof either compiles against the kernel or it does not. OpenAI put the certificates in a public repository, which means the verification burden on the community is not “read 249 pages of von Neumann algebra and try to find the hole” but “run the checker.” That does not settle whether the arguments are illuminating, well-motivated, or the kind of mathematics anyone wanted. It does settle whether they are true, and that is the part people were most worried about.

    Look at the actual character of the proofs and something more interesting shows up than “the machine brute-forced it.” The closest vector problem result gets n^(1/400) hardness through a direct reduction from 3SAT using Reed-Solomon power-sum constraints over a characteristic-two field, and it deliberately does not route through the PCP theorem or the Projection Games Conjecture. That is a structurally unusual choice, the kind a human specialist might avoid because the field’s toolkit points elsewhere. The Ehrhart proof imports Bergman kernels and Berndtsson’s positivity theorem from complex geometry to settle a lattice-point question in convex geometry. The Ramsey result adapts saturated-matrix machinery originally built for zero-error list decoding. These are cross-domain transplants. Whatever Astra is doing, it appears to be less constrained by disciplinary habit than the people who have been staring at these problems.

    OpenAI’s attribution paragraph deserves more attention than it will get. The company states flatly that claiming human authorship for a proof generated entirely by an AI system would misrepresent both the system’s contribution and the nature of genuine human intellectual work. That is a real position, taken at a moment when the commercially convenient move would have been to blur the line, list a few human co-authors, and let the papers slide into journals with the usual byline. Instead they named the model as the source of the arguments and kept responsibility for correctness. Compare that to the flood of quietly AI-assisted preprints already circulating with no disclosure at all, and OpenAI’s posture is the more honest one. The Leiden Declaration, published in June 2026 and endorsed by the International Mathematical Union, exists precisely because the community saw this coming and wanted values stated before the fact rather than after.

    The uncomfortable question the release does not answer is what mathematicians are for now. Erdős offered $250 for the value of the multicolor Ramsey limit and $100 for merely deciding whether it was finite. Those prizes encoded a belief about how hard the problem was and how long it would take a human community to get there. A model settled the finiteness question for a rounding error on an API bill. The optimistic reading, and OpenAI leans on it, is that these results are seeds: the community engages with them, places them in context, and builds new research on the ideas. The pessimistic reading is that “engaging deeply with the results” is a demotion from producing them. My guess is that the honest answer is neither, and that mathematics becomes a field where taste, problem selection and interpretation are the scarce human contributions while derivation is not. That is a smaller job than the one mathematicians signed up for, and it is still a real one.

    Key Takeaways

    • OpenAI published ten new results in mathematics and theoretical computer science on August 1, 2026, all generated by an internal version of Astra, its next major model, which has not been publicly released.
    • Every problem in the collection had been open with no progress on the main result for at least ten years, and in most cases for considerably longer than that.
    • The total token cost to find all ten solutions would have been roughly $2,000 at Sol API rates, a figure OpenAI disclosed directly in the announcement.
    • The workflow was three-stage: the model generated the mathematical arguments, humans prepared the arguments into manuscripts with help from the same model, and the model then formalized each argument as a Lean certificate.
    • The Lean 4 formalizations are published in a public GitHub repository at openai/ten-proofs, so any reader can machine-check the proofs rather than take the claims on trust.
    • OpenAI also released a narration of the model’s thinking process for each of the ten solutions, described as reasoning walkthroughs.
    • Result 1, high-dimensional sphere packing: the exact exponential decay rate of the Cohn-Elkies linear program is determined, giving LP_d^(1/d) converging to sqrt(e/2π) and the density bound Δ_d ≤ 2^(-(0.6044…+o(1))d).
    • That sphere-packing exponent is the first improvement since 1978, when Kabatianskii and Levenshtein established 0.59905576, with subsequent work improving only lower-order factors.
    • The matching lower bound in the same chapter proves that no Cohn-Elkies auxiliary function can ever improve the exponent further, which closes the method rather than merely advancing it.
    • The same chapter settles the Fourier sign-uncertainty problem asymptotically, proving that both the positive and negative eigenvalue uncertainty radii are (1/π + o(1))·sqrt(d), confirming a conjecture of Cohn and Gonçalves.
    • Result 2, binary and spherical codes: exponentially improved upper bounds on the maximum size of binary codes at any prescribed minimum distance, plus analogous results for high-dimensional spherical codes.
    • These are the first improvements to the general high-dimensional coding exponents since the McEliece-Rodemich-Rumsey-Welch bound of 1977 and the Kabatianskii-Levenshtein bound of 1978.
    • The coding technique attaches a moving subspace to each code point rather than a single vector, producing scalar two-point certificates whose strength scales with the projection rank D/d_E.
    • Result 3, non-sofic groups: the unit group of the binary Leavitt algebra over the two-element field is proved not sofic, disproving the soficity conjecture outright.
    • Soficity asks whether every finite piece of a countable group’s multiplication table can be approximated by permutations of a finite set, a property Gromov introduced in 1999 and Weiss named in 2000.
    • Prior routes to a non-sofic group all required unproved permutation-stability hypotheses. This proof requires none of them.
    • The soficity proof combines Kun’s expander decomposition for property-(T) groups, the Kun-Thom centralizer obstruction, and a contradiction forcing Thompson’s group V to be locally embeddable into finite groups.
    • Result 4, Connes’s rigidity conjecture: infinitely many pairwise nonisomorphic, mutually commensurable, finitely generated ICC property-(T) groups are constructed sharing a single group von Neumann algebra.
    • Connes posed the conjecture in his 1994 monograph as Problem 1, asking whether the group factor of an ICC property-(T) group determines the group up to isomorphism. It does not.
    • The same construction answers Popa’s finite-to-one question in the negative and shows his countable-to-one bound from the 2006 Madrid ICM address is sharp.
    • The trick behind the counterexample is elementary in outline: binary carry puts different compact abelian group structures on the same probability space with the same Haar measure and the same group action.
    • Result 5, arithmetic circuit complexity: division-free circuits computing the n by n permanent require Ω(n^2 log log n) gates, breaking through the trivial Ω(n^2) barrier.
    • Arithmetic formulas for the permanent require Ω(n^4 / log n) variable-labeled leaves, improving the classical Ω(n^3) bound, and the result survives even when division is allowed.
    • The circuit bound works by constructing an affine specialization whose gradient vanishes on a low-dimensional set, then applying Bézout’s inequality against reverse-mode differentiation.
    • The paper explicitly explains why both arguments exploit properties specific to the permanent and do not transfer to the determinant, which is important because the determinant has polynomial-size circuits.
    • Result 6, quantum parallel repetition: exponential decay is proved for every finite two-player entangled game with entangled value below 1, resolving the quantum analogue of Raz’s 1995 theorem.
    • The quantum question was noted as open by 2004. Yuen proved only polynomial decay in 2016, and Bavarian, Vidick and Yuen got exponential decay only for anchored games obtained by modifying the original game.
    • The new bound is exp(-c·ε^13/(ε + log|A||B|)·n), and the paper concedes the exponent 13 is almost certainly not optimal while insisting the qualitative exponential decay is the point.
    • The key new ingredient is a postselection-stable quantum sampleability estimate that avoids the inverse dependence on the conditioning event probability that blocked earlier attempts.
    • Result 7, closest vector problem: a deterministic polynomial-time many-one reduction from 3SAT gives n^(1/400)-factor hardness for the Euclidean closest vector problem.
    • The reduction uses no randomization, no gap-producing PCP, and no Projection Games Conjecture, which makes it methodologically unusual for a hardness-of-approximation result of this strength.
    • The same construction yields n^(1/200) hardness for binary nearest codeword and syndrome decoding, and n^(1/(200p)) for closest vector in every fixed rational ℓ_p norm.
    • Lattice problems underpin NIST-standardized post-quantum key encapsulation and digital signatures, so results mapping which approximation regimes remain intractable have direct relevance to deployed cryptography.
    • Result 8, Ehrhart’s volume conjecture: the sharp bound (n+1)^n/n! is proved in every dimension for convex bodies whose barycenter is their only interior lattice point.
    • Ehrhart asked the question in 1964 and proved it only for planar bodies and for simplices. The best prior general bound was roughly 4^n·e^(-cn), which is exponentially far from sharp.
    • The Ehrhart proof runs through complex geometry, using Berman-Berndtsson transport, lattice Bergman spaces, and Berndtsson’s positivity theorem to make a partition-function logarithm convex.
    • Result 9, multicolor Ramsey numbers: R_k(3) ≥ (c·k^(1/3)/log k)^k, which combined with the classical factorial upper bound establishes R_k(3) = k^Θ(k).
    • The previous best lower bound was 380^(k/5), merely exponential. The gap between exponential lower bounds and factorial upper bounds had been highlighted repeatedly by Conlon, Fox and Sudakov.
    • Erdős offered $250 for determining the growth limit and $100 for merely deciding whether it is finite. The new result shows the limit is infinite, settling Erdős problem 183.
    • A direct corollary: the Shannon capacity of graphs with independence number 2 is unbounded, so Shannon capacity cannot be bounded above by any function of the independence number.
    • Result 10, extremal graph theory: a finite family of connected bipartite graphs is constructed with ex(n, F) = O(n^(4/3 – 1/48)) while every individual member has ex(n, F) = Ω(n^(4/3)), disproving the Erdős-Simonovits compactness conjecture.
    • A second construction gives a fixed connected bipartite 2-degenerate graph H with ex(n, H) ≥ c·n^(3/2+ε), disproving Erdős’s degeneracy conjecture at r = 2 and refuting a related implication Janzer’s 2023 work had left open.
    • This is not OpenAI’s first mathematical result. In May 2026 the company shared an AI-generated disproof of the Erdős unit-distance conjecture, found while evaluating an unreleased model.
    • That May disproof has already generated follow-on human research, including work by Bloom, Sawin, Schildkraut and Zhelezov showing the sum-product conjecture is false for real numbers, and papers by Pohoata, by Saha, Xu and Ye, by Goh and Hatami, and by Lee, Pohoata and Zhu.
    • OpenAI states that attribution should honestly reflect how a result was produced, and explicitly refuses to claim human authorship for proofs its system generated.
    • The announcement names the Leiden Declaration on AI and Mathematics, published June 2026 and endorsed by the International Mathematical Union, and says OpenAI has deep respect for those concerned about AI’s impact on the field.
    • The release is paired with ChatGPT for Academic Researchers, an initiative providing 100,000 scientists and mathematicians with free access to OpenAI’s best models.
    • Sebastien Bubeck, announcing the work publicly, framed it as ten Astra proofs released complete with Lean certificates and chain-of-thought walkthroughs for each.

    Detailed Summary

    What OpenAI actually released and how it was produced

    The publication is a 249-page document titled Ten Advances in Mathematics and Theoretical Computer Science, authored by OpenAI and subtitled as a collection of research papers by an internal model. Each of the ten results occupies its own chapter, complete with abstract, table of contents, full proof, and bibliography, formatted exactly as a standalone research paper would be. The pipeline OpenAI describes has three distinct steps and it matters that they are distinct. First, an internal version of Astra found the mathematical arguments while being evaluated on open research problems during development. Second, humans prepared those arguments into publishable manuscripts, working with the same model. Third, the model formalized each argument in Lean, producing certificates that OpenAI released alongside the paper in a public GitHub repository. On top of that, OpenAI published narrations of the model’s own reasoning process for each solution, which is the closest thing anyone has offered to an audit trail for machine-discovered mathematics.

    The cost disclosure is unusual and deliberate. OpenAI states that the total tokens required to find these solutions would run roughly $2,000 at Sol API rates. Read that against the selection criterion, which is that every problem had seen no progress on its main result for at least a decade, and the implication is not subtle. The company is not claiming a lucky hit on a single famous conjecture. It is claiming that a decade-stale open problem in research mathematics now has a marginal discovery cost in the low hundreds of dollars, across eight distinct subfields simultaneously.

    Sphere packing and the first movement of an exponent since 1978

    Sphere packing asks how densely identical balls can fill Euclidean space. In dimensions 8 and 24 the answer is spectacular and known, thanks to Viazovska’s proof that the E8 lattice is optimal and the subsequent Leech lattice result by Cohn, Kumar, Miller, Radchenko and Viazovska. In high dimensions the picture has been much murkier. The Fourier-analytic linear programming method of Gorbachev and Cohn-Elkies gives an upper bound on density, and Cohn and Zhao proved it is always at least as strong as the classical Kabatianskii-Levenshtein spherical-code bound, but nobody knew whether it actually beat the classical exponent.

    Chapter 1 answers that exactly. The linear program’s optimal density bound, taken to the d-th root, converges to sqrt(e/2π), confirming a conjecture of Afkhami-Jeddi, Cohn, Hartman, de Laat and Tajdini. In exponent terms the packing density is bounded by 2^(-(0.6044…+o(1))d), which beats the 1978 Kabatianskii-Levenshtein exponent of 0.59905576. That is the first improvement to the general high-dimensional sphere-packing exponent in 48 years. The result cuts both ways, though: the matching lower bound proves that no Cohn-Elkies auxiliary function can push the exponent further, so the method is now exhausted rather than merely advanced. The same chapter also nails the Fourier eigenfunction sign-uncertainty constants asymptotically, showing that both the positive and negative eigenvalue radii grow like sqrt(d)/π, which resolves a conjecture of Cohn and Gonçalves and connects to the spinless modular bootstrap in physics.

    Codes, and a technique that moves the subspace with the point

    Chapter 2 attacks the closely related question of how many codewords you can pack at a given minimum distance, for both binary codes on the Hamming cube and spherical codes on the sphere. The reigning general bounds are MRRW from 1977 for binary codes and Kabatianskii-Levenshtein from 1978 for spherical codes, both derived from Delsarte’s two-point linear programs. The new construction improves both exponents strictly, for every fixed relative distance and every fixed maximum inner product, which makes it the first improvement to either in nearly half a century.

    The mechanism is worth understanding because it is conceptually clean. In the classical spectral construction, each retained harmonic space contributes a single vector attached to a code point. The new approach attaches an entire subspace to each point, living inside a common ambient space, and crucially the subspaces move with the points: any symmetry carrying point x to point y carries the subspace at x to the subspace at y. The overlap of the corresponding projections remains a scalar function of distance, so the certificate stays a two-point object rather than escalating to the matrix-valued three-point semidefinite programs of Bachoc and Vallentin. An exponentially large projection rank then improves the rate. As a bonus, taking the maximum inner product to 1 recovers the sphere-packing exponent of Chapter 1 as a limiting case, so the two results independently confirm each other.

    Non-sofic groups and Connes’s rigidity conjecture

    Chapters 3 and 4 are the two results most likely to reorganize their fields. A countable group is sofic if every finite portion of its multiplication table can be approximated by permutations of a finite set: multiplication holds almost everywhere and no nonidentity element fixes too much. Gromov introduced the property in his work on symbolic dynamics, Weiss named sofic groups and asked whether a non-sofic one exists, and the question calcified into the soficity conjecture. Chapter 3 constructs one explicitly, proving that the unit group of the binary Leavitt algebra over the two-element field is not sofic. Prior conditional routes, through flexible permutation stability of PSL_d(Z) or central extensions of p-adic lattices, all rested on hypotheses nobody had proved. This proof requires none, building instead on Kun’s expander decomposition for property-(T) groups and the Kun-Thom centralizer obstruction, then deriving a contradiction from the fact that elementary groups over the Leavitt algebra would force Thompson’s group V to be locally embeddable into finite groups.

    Chapter 4 disproves Connes’s rigidity conjecture, which appeared as Problem 1 in his 1994 monograph and asked whether the group von Neumann algebra of an ICC property-(T) group determines the group. Property (T) was expected to prevent the collapse seen in the amenable case, where Connes’s classification theorem forces every amenable ICC group to share the hyperfinite II_1 factor. The counterexample constructs a countably infinite family of pairwise nonisomorphic, mutually commensurable, finitely generated ICC property-(T) groups all having the same group factor. The idea driving it is almost embarrassingly concrete: on the four-point probability space, coordinatewise addition gives the Klein four-group while a binary carry rule gives Z/4Z, and both carry the same uniform Haar measure. Globalize that carry and you get different compact group structures on one measured space with one group action, which the crossed product cannot distinguish. As a second consequence, Popa’s finite-to-one question is answered negatively and his countable-to-one bound from the Madrid ICM is shown to be sharp.

    Complexity theory: the permanent, quantum games, and lattices

    Chapter 5 attacks the central problem of algebraic complexity theory, whether the permanent admits polynomial-size arithmetic circuits. It does not settle that, but it moves two long-static bounds. For division-free circuits with unrestricted reuse of intermediate values, the permanent requires Ω(n^2 log log n) gates, which finally beats the trivial “it depends on all n^2 variables” bound. For formulas, it requires Ω(n^4 / log n) variable-labeled leaves, up from the classical Ω(n^3), and the bound survives when valid divisions are permitted. The circuit argument constructs an affine specialization of the permanent whose gradient vanishes on a small set, then plays Bézout’s inequality against the fact that reverse-mode differentiation computes a gradient with only a constant-factor blowup. The formula argument charges algebraically independent coefficients to distinct occurrences of selected variables and sums over entry-disjoint matchings. A full section is devoted to explaining why neither argument transfers to the determinant, which matters, because the determinant does have small circuits and any technique that proved otherwise would be wrong.

    Chapter 6 resolves quantum parallel repetition. Raz proved in 1995 that repeating a classical two-player game n times in parallel drives the winning probability down exponentially whenever the original value is below 1. Whether the same holds when the players share entanglement was noted as open by 2004 and stayed open. Special classes fell along the way: XOR games, unique games, projection games, free games, anchored games. The general case did not. Yuen’s 2016 theorem gave polynomial rather than exponential decay. The new theorem gives exponential decay for every finite two-player one-round entangled game, with the rate depending on the soundness gap to the thirteenth power. The paper is candid that 13 is an artifact of a quantum correlated-sampling lemma and not the truth, and that the qualitative result is what matters. The technical unlock is a postselection-stable sampleability estimate that dodges the inverse dependence on the conditioning event’s probability.

    Chapter 7 gives n^(1/400)-factor NP-hardness for approximating the Euclidean closest vector problem, along with n^(1/200) for binary nearest codeword and syndrome decoding, and n^(1/(200p)) for closest vector in any fixed rational ℓ_p norm. What distinguishes it is the route. Hardness-of-approximation results in this range normally go through the PCP theorem or assume the Projection Games Conjecture. This one is a direct, deterministic, many-one reduction from 3SAT, encoding assignments through Reed-Solomon power-sum constraints over a characteristic-two field and converting the resulting binary affine system into an integer lattice by coordinatewise reduction modulo two. Soundness comes from reconstructing separable root sets from power sums over a rational function field. Since lattice assumptions underpin the NIST post-quantum standards, mapping which approximation regimes stay intractable is not purely academic housekeeping.

    Convex geometry, Ramsey numbers, and extremal graphs

    Chapter 8 settles Ehrhart’s volume conjecture from 1964: among convex bodies whose barycenter is their only interior lattice point, the centered simplex maximizes volume, and the sharp bound is (n+1)^n/n! in every dimension. Ehrhart himself got the planar case and the simplex case. For general centered bodies the best available was roughly 4^n with progressively better subexponential corrections, most recently combining work of Campos, van Hintum, Morris and Tiba with Klartag and Lehec’s solution of Bourgain’s slicing problem, still leaving an exponential gap. The proof imports machinery from complex geometry. A Berman-Berndtsson transport potential turns the body into a weighted space on the complex torus, the unique-interior-lattice-point hypothesis becomes the statement that a certain holomorphic space contains only constants, a filtration by vanishing order at a fixed point produces a ray of potentials, and Berndtsson’s positivity theorem makes the log partition function convex. Bounding its initial slope from both sides pins the constant.

    Chapter 9 proves that the multicolor Ramsey number for triangles grows superexponentially: R_k(3) is at least (c·k^(1/3)/log k)^k, which together with the classical factorial upper bound gives R_k(3) = k^Θ(k) and shows the limit of R_k(3)^(1/k) is infinite. Prior lower bounds came from tensoring small triangle-free colorings and sum-free partitions, topping out at 380^(k/5), merely exponential. Graham, Rothschild and Spencer recorded the superexponential growth question in Ramsey Theory, Conlon, Fox and Sudakov highlighted the gap, and Erdős attached prize money: $250 for the limit’s value, $100 for deciding whether it is finite. The construction adapts random-matrix and coordinate-covering ingredients from Alon, Ben-Eliezer, Shangguan and Tamo, themselves descended from zero-error list decoding work, and builds the coloring recursively with palettes recording which colors are missing from each block. The Ramsey-Shannon correspondence then delivers a striking corollary: there are graphs with independence number 2 and arbitrarily large Shannon capacity, so Shannon capacity is not bounded by any function of the independence number.

    Chapter 10 delivers two counterexamples in extremal graph theory. The Erdős-Simonovits compactness conjecture asks whether forbidding a finite family of graphs, each containing a cycle, can reduce the extremal number by more than a constant factor relative to forbidding some individual member. The answer is yes: a family built from subdivided complete bipartite templates has ex(n, F) = O(n^(4/3 – 1/48)) while every member individually has ex(n, F) = Ω(n^(4/3)), with the lower bounds coming from incidence graphs of generalized quadrangles. Separately, Erdős conjectured that every fixed bipartite r-degenerate graph satisfies ex(n, H) = O(n^(2 – 1/r)). A layered construction, with a vertex adjoined for every pair in the preceding layer, plus a sampled Hamming-distance bipartite graph and an entropy potential argument, produces a 2-degenerate H with ex(n, H) ≥ c·n^(3/2+ε). That kills the r = 2 case and also refutes the forward implication of a related Erdős conjecture that Janzer had only partially addressed in 2023.

    The attribution question OpenAI chose to raise

    The section OpenAI titled “Responsibility to the mathematical community” is short and unusually direct. It acknowledges that systems capable of contributing to mathematical research raise questions a technology company cannot answer alone, and it names the signers of the Leiden Declaration on AI and Mathematics as people whose concerns the company respects. The declaration, published in June 2026 out of a 2025 Lorentz Center workshop at Leiden University, was authored by sixteen mathematicians, signed by roughly fifteen hundred people, and endorsed by the International Mathematical Union. It exists because the community anticipated exactly this moment.

    OpenAI’s stated position is that attribution should reflect how a result was actually produced, and that claiming human authorship for a machine-generated proof would misrepresent both sides of the ledger. The company takes responsibility for correctness, having helped prepare the manuscripts and formalize the proofs, while assigning the mathematical arguments to the system. It then asks the community to engage with the results, contextualize them, and build on the ideas. Pair that with ChatGPT for Academic Researchers, which puts free access to OpenAI’s best models in the hands of 100,000 scientists and mathematicians, and the strategy is legible: publish the results with verifiable certificates, decline the authorship credit, and distribute the tool broadly enough that the field adapts around it rather than against it.

    Notable Quotes

    “Today, we are sharing a selection of ten results to problems that have been open and have seen no progress on the main result for at least a decade, and in most cases much longer.”

    OpenAI, setting the selection criterion for the ten problems

    “The total number of tokens needed to find solutions to these problems would cost roughly $2,000 at Sol API rates.”

    OpenAI, disclosing the compute cost of ten decade-old open problems

    “We believe attribution should honestly reflect how a result was produced: claiming human authorship for a proof generated entirely by an AI system would misrepresent both the system’s contribution and the nature of genuine human intellectual work.”

    OpenAI, on why the papers do not carry human bylines

    “We helped prepare the manuscripts and formalize the proofs in Lean, and we take responsibility for their correctness, while the mathematical arguments themselves were generated by our system.”

    OpenAI, drawing the line between human contribution and machine contribution

    “The emergence of systems capable of contributing to mathematical research raises questions that cannot be answered by a technology company alone.”

    OpenAI, opening its section on responsibility to the mathematical community

    “This is the first improvement since 1978 to the general sphere-packing exponent.”

    Chapter 1 of the paper, on a bound that had not moved in 48 years

    “These are the first improvements to the respective general high-dimensional exponents since 1977 and 1978.”

    Chapter 2, on the binary and spherical code bounds

    “The central point is that the decay is exponential for every finite entangled game.”

    Chapter 6, conceding that the exponent 13 is not optimal while defending the result

    “In particular, the Shannon capacity of graphs with independence number 2 is unbounded.”

    Chapter 9, on the information-theory corollary of the Ramsey lower bound

    “We hope the mathematical community will engage deeply with these results, place them in context, and bring the ideas behind them to life through new research and discovery.”

    OpenAI, closing the announcement

    Read the full announcement at OpenAI’s publication page, and check the proofs yourself: the Lean 4 certificates for all ten results are public.

    Related Reading

  • Inkling: Thinking Machines Lab Releases Its First Open-Weights Model, a 975B Multimodal Mixture-of-Experts With Controllable Thinking Effort That Can Fine-Tune Itself on Tinker

    Thinking Machines Lab, the AI startup founded by former OpenAI CTO Mira Murati, has released Inkling, its first open-weights model trained from scratch. Inkling is a 975 billion parameter Mixture-of-Experts transformer (41B active) with a context window of up to 1 million tokens, native multimodal reasoning over text, images, and audio, and a dial for controllable thinking effort. The lab is explicit that Inkling is not the strongest model in the world. It is pitched as something arguably more useful: a broad, balanced, customizable foundation you can fine-tune on Tinker, with the full weights on Hugging Face. The announcement even includes a demo where Inkling fine-tunes itself and swaps in its own new weights.

    TLDR

    Thinking Machines Lab released Inkling, a 975B-total, 41B-active Mixture-of-Experts model pretrained on 45 trillion tokens of text, images, audio, and video, alongside a preview of Inkling-Small (276B total, 12B active). The release covers the model’s generalist benchmark profile across reasoning, agentic coding, tool use, vision, and audio; a controllable thinking effort setting that lets developers trade performance against tokens (matching Nemotron 3 Ultra on Terminal Bench 2.1 at roughly a third of the tokens); an encoder-free multimodal architecture using dMel spectrograms and hMLP image patches; a training recipe combining Muon and Adam with weight decay coupled to the learning rate; RL scaled past 30 million rollouts with log-linearly improving reasoning and an emergent compression of the chain of thought; an epistemics push covering calibration, forecasting (where it beats several frontier models), abstention, and censorship resistance; the strongest FORTRESS adversarial safety score among compared open-weights models; a headline-grabbing demo of the model fine-tuning itself into a lipogram assistant via Tinker; and day-one availability on Tinker (at a 50% discount), Hugging Face, and inference partners including Together, Fireworks, Modal, Databricks, Baseten, vLLM, SGLang, and llama.cpp.

    Thoughts

    The most striking thing about this launch is its honesty. Nearly every frontier release leads with a claim to be the best at something, and the fine print walks it back. Thinking Machines Lab says plainly that Inkling is not the strongest model available, open or closed, and then makes the case that “strongest” is the wrong axis for most real buyers. If you are going to run a model millions of times inside a product, what you care about is the cost curve, the adaptability, and whether you can shape it to your workflow. That framing conveniently matches their business (Tinker sells fine-tuning), but it also matches how production AI actually gets deployed, where cost and latency are binding constraints and a benchmark crown is trivia.

    The self-fine-tuning demo deserves more attention than it will probably get. Asked to become a lipogram assistant that never uses the letter “e” (a behavior prompting alone cannot reliably produce), Inkling wrote its own training objective and scoring function, generated its own synthetic data, launched the run on Tinker, evaluated the result against its base self, and then staged a weight swap so the improved checkpoint took over the session. That is a closed loop of specify, train, evaluate, and self-update, packaged as a cute product demo. The loop is the primitive behind every serious conversation about recursive self-improvement, and here it is running as a marketing asset with a 27 minute wall clock. The gap between “toy objective” and “economically meaningful objective” is now a question of reward design, not plumbing.

    Controllable thinking effort is the feature I expect developers to care about most. Instead of publishing a single score, TML publishes a curve: sweep the effort setting from 0.2 to 0.99 and watch performance trade against generated tokens. Inkling reportedly matches Nemotron 3 Ultra on Terminal Bench 2.1 while spending about a third of the tokens. Benchmarks reported as single points hide exactly this, and a model that reaches a target score cheaply beats a model that scores two points higher at triple the cost in any high-volume workload. Expect effort curves to become standard marketing for open models, the way context length became standard a couple of years ago.

    The epistemics section is quietly the most differentiated part of the release. TML trained calibration directly, running RL against proper scoring rules on resolved real-world questions, and pairing a rubric grader with a claims grader that does agentic web search to verify each factual assertion. The result is a model that beats GPT-5.5 and Claude Opus 4.8 on ForecastBench without search and holds its own on Prophet Arena. A model that knows when to say “I don’t know” is more useful across messy real-world domains than one that confabulates confidently, and it is notable that a lab whose stated mission is extending human will and judgment treats calibrated uncertainty as a first-class training target rather than a safety afterthought. The censorship-resistance training, validated on Cognition’s Propaganda and Censorship Eval, extends the same idea: trustworthiness as a capability you train, not a policy you bolt on.

    Finally, the open-weights safety tension is handled with unusual candor. Inkling posts the strongest adversarial FORTRESS score among the open models compared while keeping benign over-refusal low, and it was tested externally for CBRN, cyber, and loss-of-control capabilities. But everyone in this space knows fine-tuning can strip safety behavior from open weights, and TML ships a fine-tuning platform for this exact model. Their acknowledgment that they are actively studying how safety behavior survives fine-tuning on Tinker is the right thing to say, and it is also the open question that will define whether “safe open weights” is a coherent category at all.

    Key Takeaways

    • Inkling is Thinking Machines Lab’s first from-scratch, open-weights model: a Mixture-of-Experts transformer with 975B total parameters, 41B active, and a context window up to 1M tokens.
    • It was pretrained on 45 trillion tokens spanning text, images, audio, and video, and reasons natively over text, images, and audio without separate encoders.
    • A preview of Inkling-Small ships alongside it: a 276B-parameter MoE with just 12B active parameters that matches or beats its larger sibling on several benchmarks thanks to an improved pretraining recipe.
    • TML explicitly positions Inkling as a base for customization rather than the strongest overall model, leaning on multimodality, efficient thinking, and Tinker fine-tuning as the differentiators.
    • The launch demo shows Inkling fine-tuning itself: it wrote its own training objective and data, ran the job through the Tinker API, evaluated the result, and hot-swapped to its own new weights inside the OpenCode harness.
    • The self-fine-tuning target was a lipogram assistant that never uses the letter “e,” a behavior chosen precisely because prompting alone cannot reliably achieve it; the full loop completed in about 27 minutes.
    • Controllable thinking effort is a core feature: a setting swept from 0.2 to 0.99 traces a full performance-versus-tokens curve instead of a single benchmark point.
    • On Terminal Bench 2.1, Inkling matches Nemotron 3 Ultra’s score at roughly one third of the generated tokens, the release’s flagship efficiency claim.
    • Inkling was trained to run inside a variety of coding and agent harnesses, with tool sets and schemas randomized during training to reduce sensitivity to any particular harness.
    • On Design Arena’s blinded human-evaluated Agentic Web Dev leaderboard, Inkling scores 1257, among the strongest open-weights models and tied with Claude Opus 4.6.
    • Headline benchmark scores at effort 0.99 include SWEBench Verified 77.6%, SWEBench Pro Public 54.3%, Terminal Bench 2.1 63.8%, GPQA Diamond 87.2%, AIME 2026 97.1%, and HLE 29.7% text-only (46.0% with tools).
    • Agentic and general scores include MCP Atlas 74.1%, Tau 3 Banking 23.7%, and BrowseComp 77.1% with context management.
    • Vision results are strong for an open model: MMMU Pro 73.5%, CharXiv RQ 78.1%, rising to 82.0% when the model uses a Python tool for zooming and cropping during visual reasoning.
    • Audio results place it among the strongest open-weights audio models: VoiceBench 91.4%, MMAU 77.2%, and Audio MC 56.6%, well ahead of Qwen3-Omni and Nemotron Nano-Omni on the last.
    • The multimodal stack is encoder-free: audio enters as discrete dMel spectrograms and images as 40×40 pixel patches through a four-layer hMLP, both passed through a lightweight embedding layer and processed jointly with text tokens.
    • The MoE design largely follows DeepSeek-V3: 256 routed experts plus 2 shared experts per layer, 6 routed experts active per token, with a sigmoid router and auxiliary-loss-free load balancing.
    • Attention interleaves sliding-window and global layers at a 5:1 ratio with 8 KV heads, and uses a learned relative positional embedding instead of RoPE, which TML found extrapolates better to long sequences.
    • Short convolutions are applied after the key and value projections and on the attention and MLP residual branch outputs, an unusual architectural touch aimed at efficiency and long-context performance.
    • Training used a hybrid optimizer strategy, Muon for large matrix weights and Adam for everything else, with weight decay coupled to the square of the learning rate to keep weight magnitudes stable.
    • Post-training was bootstrapped with a small SFT phase on synthetic data generated by open-weights models including Kimi K2.5, with the large majority of compute spent on large-scale RL.
    • RL was scaled past 30 million rollouts across two long continuous runs, with reasoning performance on a held-out aggregate (AIME, HLE, GPQA, and others) improving log-linearly throughout.
    • Effort control was trained by varying the system message and per-token cost across rollouts, teaching the model to modulate its own thinking budget.
    • An emergent effect appeared during RL: the chain of thought compressed over training, dropping articles and connectives into a telegraphic style, driven purely by efficiency pressure rather than any targeted reward.
    • Inkling was TML’s first major training effort and ran on NVIDIA GB300 NVL72 systems; the lab says future models will push compute scale further across pretraining and RL.
    • Calibration was trained directly with RL against proper scoring rules on a large corpus of resolved real-world questions, treating well-placed confidence as a capability rather than a byproduct.
    • On ForecastBench without search, Inkling’s Brier Index of 61.1 beats GPT-5.5 (59.1) and Claude Opus 4.8 (54.6), and it stays competitive with search enabled and on Prophet Arena.
    • Instruction following was trained with two automated graders working together: a rubric grader scoring against a checklist and a claims grader that verifies each factual claim via agentic web search, improving helpfulness and reducing hallucination simultaneously.
    • Abstention-aware rewards on short-form factual QA taught the model to answer when confident and hedge or decline when not, with some prompts explicitly forcing or forbidding hedging so the user’s preference wins.
    • Inkling was trained to answer directly on topics subject to censorship, and Cognition’s Propaganda and Censorship Eval found strong censorship non-compliance.
    • On FORTRESS, Inkling posts the strongest adversarial refusal score (78.0%) of any compared open-weights model while keeping benign compliance high (95.9%), and scores 98.6% on StrongREJECT.
    • Safety testing covered CBRN, cyber, and loss-of-control capabilities plus human-AI threat vectors like sycophancy, vulnerable users, and manipulation, verified by commissioned external testers.
    • Inkling is available for fine-tuning on Tinker today with 64K and 256K context options at a 50% limited-time discount, plus a free Inkling Playground chat interface in the Tinker console.
    • Full weights are on Hugging Face, including an NVFP4 checkpoint for efficient inference on NVIDIA Blackwell, with API availability via Together, Fireworks, Modal, Databricks, and Baseten and inference support in SGLang, vLLM, TokenSpeed, and llama.cpp.
    • TML frames Inkling as the first in a family and as the intended background reasoning model for its previously announced real-time interaction models system.

    Detailed Summary

    What Inkling Is and Why It Exists

    Thinking Machines Lab frames its mission as building AI that extends human will and judgment, and Inkling as the logical next step after shipping the Tinker customization platform, previewing an interaction-focused AI system, and publishing research. Inkling is a Mixture-of-Experts transformer with 975B total and 41B active parameters, a context window up to 1M tokens, and pretraining on 45 trillion tokens of mixed text, image, audio, and video data. The lab is upfront that it is not the strongest model available. The pitch is breadth plus adaptability: a generalist trained across agentic, reasoning, coding, instruction-following, factuality, vision, and audio tasks rather than tuned to dominate one leaderboard, offered with full weights so people can make it their own. It launches with a preview sibling, Inkling-Small, at 276B total and 12B active parameters.

    The Self-Fine-Tuning Demo

    To demonstrate what customization means, TML asked Inkling to fine-tune itself. Running inside the OpenCode harness with access to Tinker, the model was told to become a lipogram assistant that never uses the letter “e.” Inkling drafted the plan, wrote an objective file with a scoring function (any response containing “e” scores zero), generated synthetic training data, launched a supervised fine-tuning run through the Tinker API, evaluated the checkpoint against its base self, and then staged a self-update so the supervisor relaunched the session on the new weights. The pipeline passed in about 27 minutes, and the updated model answered a test question about launching an LLM without a single “e.” It is a whimsical objective wrapped around a serious primitive: a model autonomously specifying, running, and adopting its own weight updates.

    Agentic Coding and Tool Use

    TML trained Inkling to operate inside many coding and agent harnesses, randomizing tool sets and schemas during training so the model does not overfit to one environment. The release showcases three demos: a one-shot job-application web app that then hosts an embedded browser-use agent operating its own interface; a nine-page, cohesively designed PDF food and travel journal produced from a single editorial prompt with web-verified details; and a server-authoritative multiplayer snake game refined over 40 iterations of feedback from GPT Codex acting as a reviewer. On benchmarks, Inkling posts 77.6% on SWEBench Verified, 54.3% on SWEBench Pro Public, and 63.8% on Terminal Bench 2.1, competitive within the open-weights field, and 1257 on Design Arena’s human-judged web dev leaderboard, in the same band as Claude Opus 4.6.

    Controllable Thinking Effort

    Rather than reporting a single operating point, TML sweeps Inkling’s effort setting from 0.2 to 0.99 and plots score against mean generated tokens on Terminal Bench 2.1, HLE, and IFBench, with competitors shown at their default settings. The headline result is efficiency: Inkling reaches Nemotron 3 Ultra’s Terminal Bench score at roughly a third of the tokens. The argument is that cost and latency are binding constraints in production, especially for interactive collaboration, so the full cost curve, not the peak score, is what developers should evaluate. Effort can be set from within the agent harness, and the ability was trained by varying system messages and per-token costs across RL rollouts.

    Native Multimodality Without Encoders

    Inkling is designed to serve as the background reasoning model for TML’s interaction models system, which requires real-time voice and vision collaboration. The multimodal components are trained from scratch with an encoder-free architecture: audio arrives as discrete dMel spectrograms and images as 40×40 pixel patches through a four-layer hMLP, both mapped through a lightweight embedding layer and processed jointly with text. The model transcribes speech, follows spoken instructions, reasons over long recordings, and answers questions about charts and diagrams, optionally using a Python tool to zoom and crop images mid-reasoning. Scores like 91.4% on VoiceBench and 82.0% on CharXiv RQ with Python place it among the strongest open-weights multimodal models, though still behind Gemini 3.1 Pro.

    Epistemics: Calibration, Forecasting, and Censorship Resistance

    TML groups calibration, instruction following, and censorship resistance under the banner of epistemics. Calibration was trained with RL against proper scoring rules on resolved real-world questions, and it shows: Inkling’s ForecastBench Brier Index of 61.1 without search beats GPT-5.5 and Claude Opus 4.8, and its Prophet Arena score sits close to the frontier. Instruction following used two complementary automated graders, a rubric checklist and a claims grader that verifies factual assertions through agentic web search, so recall-spraying to hack rubrics gets penalized by the factuality check. Targeted abstention-aware QA datasets taught the model to say “I don’t know” or give hedged best guesses when appropriate, while still complying when a user demands a forced guess. Finally, the model was trained to answer directly on censorship-prone topics, with Cognition’s Propaganda and Censorship Eval finding strong non-compliance with censorship patterns.

    Safety for an Open-Weights Release

    Inkling was trained to an internal behavioral spec across all modalities and then checked by commissioned external safety testers. Evaluations covered dangerous capabilities (CBRN, cyber, loss of control) and human-AI threat vectors including sycophancy, vulnerable users, and harmful manipulation. On FORTRESS, which pairs adversarial harmful requests with benign look-alikes, Inkling posts the strongest adversarial score among the compared open models (78.0%) without collapsing on the benign side (95.9%), and it scores 98.6% on StrongREJECT. TML acknowledges the open question hanging over every open-weights release: how safety behavior holds up under fine-tuning, which it says it is actively studying on Tinker.

    Architecture and Training Recipe

    The MoE layout follows DeepSeek-V3: 256 routed experts and 2 shared experts per layer with 6 routed experts active per token, a sigmoid-based router, and auxiliary-loss-free load balancing. Attention interleaves sliding-window and global layers 5:1 with 8 KV heads, and positions are encoded with a learned relative positional embedding that TML found outperforms and out-extrapolates RoPE. Short convolutions appear after the key and value projections and on residual branch outputs. Optimization was hybrid, Muon for large matrices and Adam elsewhere, with hyperparameter schedules drawn from the lab’s modular manifolds research and weight decay coupled to the square of the learning rate to keep weight norms stable. Post-training bootstrapped from a small SFT phase on synthetic data from open models including Kimi K2.5, then spent the bulk of compute on large-scale RL. Everything ran on NVIDIA GB300 NVL72 systems.

    RL at Scale and the Emergent Compression of Thought

    TML scaled asynchronous RL past 30 million rollouts across two long continuous runs, with performance on a held-out aggregate of reasoning evals improving log-linearly the whole way. Along the way an unplanned behavior emerged: the chain of thought became progressively more concise, shedding grammatical overhead into a telegraphic style (“We need to understand” becomes “We need determine”) while remaining comprehensible and leaving final answers unaffected. No reward targeted this; token efficiency pressure alone drove the compression, echoing an observation Cognition made while training SWE-1.7. It is a vivid example of optimization discovering its own shorthand.

    Inkling-Small

    The preview of Inkling-Small is arguably the sleeper story: with 12B active parameters against Inkling’s 41B, it matches or exceeds the larger model on a surprising number of benchmarks, including GPQA Diamond (88.3% vs 87.2%), IFBench (83.4% vs 79.8%), and CharXiv RQ with Python (83.4% vs 82.0%). TML attributes this to pretraining data and recipe improvements made after the big model trained, with both models sharing the same post-training stack. The clearest gaps favoring big Inkling are factuality (SimpleQA 43.9% vs 20.9%), Terminal Bench, and Tau 3 Banking. Full weights for Inkling-Small will be released once testing finishes, and its cost and latency profile targets high-volume workloads like coding, LLM grading, and synthetic data generation.

    Availability and the Ecosystem Play

    Inkling is on Tinker today with 64K and 256K context options at a limited-time 50% discount, plus a free Inkling Playground chat interface with integrated web search in the Tinker console so developers can get a feel for the model before committing to a run. The cookbook gained native Inkling support and three new audio recipes, and a new tml-renderer handles chat templates, tool calls, reasoning content, and multimodal inputs. Deployment partnerships span Together, Fireworks, Modal, Databricks, and Baseten for APIs; RadixArk for SGLang and Miles; Inferact for vLLM; Lightseek for TokenSpeed; Unsloth for llama.cpp; and Hugging Face for transformers integration. Full weights are on Hugging Face in both the original checkpoint and an NVFP4 checkpoint for NVIDIA Blackwell inference.

    Notable Quotes

    “Our mission is to build AI that extends human will and judgment.”

    Thinking Machines Lab, opening the Inkling announcement

    The company’s north star, and the lens through which the whole release (customization, calibration, open weights) is framed.

    “Inkling is not the strongest overall model available today, open or closed. Instead, a combination of qualities makes it a good open-weights base for customization: multimodal capabilities, efficient thinking, and availability on Tinker for fine-tuning.”

    Thinking Machines Lab, positioning the release

    A rare piece of launch-day honesty from a frontier lab, and the strategic thesis of the whole release.

    “Picking the right base model to fine-tune is a qualitative judgment that combines measurable benchmarks with the unique feel of a model that comes from playing with it.”

    Thinking Machines Lab, on why the Inkling Playground exists

    An argument that vibes are data, from the lab that built a playground into a fine-tuning console.

    “Cost and latency are often binding constraints in real-world applications, and low latency in particular is crucial for enabling collaboration and improvement through iteration.”

    Thinking Machines Lab, on controllable thinking effort

    The case for evaluating models on their full effort-versus-performance curve instead of a single benchmark point.

    “A model that’s confident in every answer it gives, including when it’s missing info and confabulates, forces the user to double-check everything.”

    Thinking Machines Lab, on why calibration was a training target

    The clearest one-line justification for treating calibrated uncertainty as a capability rather than a nicety.

    “Together, the two graders improve helpfulness and reduce hallucination at the same time, rather than trading one for the other.”

    Thinking Machines Lab, on pairing a rubric grader with a web-searching claims grader

    A neat solution to rubric hacking: verify every claim with agentic search so spraying plausible facts stops paying.

    “Safety is crucial for open-weights models. We’re continuing to study safety behavior and capability uplift in customizable models, including how safety behavior is impacted by fine-tuning on Tinker.”

    Thinking Machines Lab, on the open question of fine-tunable safety

    The acknowledgment that safety trained into open weights must survive the very customization the product sells.

    “Inkling is just the start: our first release in a model family we will continue to build on.”

    Thinking Machines Lab, on the roadmap

    Together with the GB300 compute note, a clear signal that larger and stronger family members are coming.

    Read the full announcement, including the interactive demos, effort curves, and complete benchmark tables, on the Thinking Machines Lab blog.

    Related Reading