Google Test’s math-specialized version, DeepThink

Google Is Internally Testing a “Math-Specialized” Version of DeepThink

Google may be building a separate “mathematical brain” for Gemini DeepThink.

On September 16, the source @lyraxana revealed an experimental Google internal model codenamed Mathematica. Its internal API identifier is shown as models/deepthink-mathematica-tf-raw-thoughts. The leaked configuration states that the model is based on DeepThink V3, supports up to 1 million tokens of input context, and has a maximum output of 65,536 tokens per request. It is primarily intended for heavy computation, complex symbolic derivation, and difficult mathematical problems.

As of today (September 18), Google has not officially released the model, nor has it announced pricing, benchmark results, availability, or an API launch plan. The UNSTABLE_EXPERIMENTAL and Teamfood tags in the configuration essentially reveal its current stage: this is not a production-ready model, but an experimental version still being tested internally by Google employees.

The key information revealed so far can be summarized as follows:

| Item | Leaked information | Practical meaning | |---|---|---| | Internal codename | Mathematica | Suspected math-specialized model; not necessarily the final product name | | Model identifier | deepthink-mathematica-tf-raw-thoughts | Points to DeepThink, internal testing, and configuration related to reasoning traces | | Input context | 1 million tokens | Can read large research papers, proof materials, code, and mathematical text in a single request | | Maximum output | 65,536 tokens | Sufficient for generating lengthy derivations, proofs, or verification reports | | Status | UNSTABLE_EXPERIMENTAL | Unstable experimental version; both behavior and interfaces may continue to change | | Testing label | Teamfood | Internal employee testing at Google, similar to the commonly used term “dogfooding” |

A Million Tokens Is Huge, but It Is Not the Most Noteworthy Aspect of This Model

“1 million-token context” is an easy number to highlight in a headline, but it is not Mathematica’s true technical selling point.

Google has accumulated extensive experience with long contexts, and million-token context windows are not appearing for the first time in descriptions of Gemini’s capabilities. For ordinary conversations or a single competition problem, one million tokens may even be excessive: a mathematical Olympiad problem and its complete solution typically require nowhere near that scale.

The scenarios in which mathematical tasks genuinely require a million-token context are usually not about “reading the entire problem,” but about loading an entire, large mathematical workspace into the model:

• Reading a several-hundred-page textbook, research paper, and appendices simultaneously;
• Retrieving definitions, lemmas, and dependency relationships from a formal proof library;
• Analyzing research records containing large numbers of symbolic expressions;
• Tracing back and checking the consistency of proofs spanning thousands of steps;
• Placing natural-language proofs, LaTeX formulas, and formal code in Lean, Coq, or other systems into the same context;
• Jointly processing constraints, historical calculation results, and verification scripts in engineering computations.

This is more like preparing an enormous desk for a mathematician, large enough to spread out an entire project, rather than simply expanding the model’s “brain capacity” by a million slots.

The problem is that a bigger desk does not mean more accurate reasoning. Common failure modes of long-context models include retrieval misalignment, overlooking intermediate conditions, citing nonexistent lemmas, and silently modifying assumptions during extremely long derivations. Such errors are especially fatal in mathematical tasks: an ambiguous statement may not affect the conclusion in ordinary question answering, but a single incorrect quantifier, domain definition, or symbol direction can invalidate an entire proof.

Therefore, whether Mathematica is useful will first depend on whether it can accurately locate constraints and maintain symbolic consistency across a million tokens—not on whether its configuration sheet says “1M.”

The 64K Output Limit Reveals That Google Wants to Do More Than Solve Problems

Compared with the million-token input context, the maximum output length of 65,536 tokens is more worthy of developers’ attention.

Ordinary mathematical question answering rarely requires tens of thousands of output tokens. Such a high limit suggests that Google may want the model to handle long-chain tasks, such as generating complete proofs, presenting multiple solution methods, performing step-by-step verification, or outputting intermediate results that can be passed to formal tools for further checking.

The biggest difference between a mathematical reasoning model and a general-purpose chat model is not whether it can write formulas, but whether it can break down a complex problem into verifiable steps. A typical workflow might include:

1. Rewriting the natural-language problem as explicit mathematical constraints;
2. Identifying the relevant field and selecting appropriate tools, such as algebraic elimination, modular arithmetic, or combinatorial construction;
3. Exploring multiple candidate reasoning paths;
4. Eliminating contradictory, circular, or unclosed paths;
5. Substituting the final answer back into the problem and checking boundary conditions and counterexamples;
6. Generating results suitable for human readers or formal systems to consume.

Long outputs can accommodate these processes, but they also create very real cost concerns. Reasoning models are not necessarily better simply because they produce longer outputs. If a model uses 50,000 tokens to complete a proof that could have been finished in 5,000, it may merely be better at consuming compute, rather than more intelligent.

For API developers, the metrics that ultimately matter should include at least:

• Correct-answer rates and strict proof pass rates;
• The relationship between reasoning-token usage and result quality;
• Time to first token and total response latency;
• Whether controllable Thinking budgets are supported;
• Whether the model can call calculators, Python, CAS tools, or formal verifiers;
• Retrieval accuracy and condition retention under long-context settings;
• Stability of results across repeated samplings of the same problem.

Without external verification, 64K output could simply mean a more expensive and harder-to-debug hallucination.

“Math-Specialized” Does Not Mean Simply Changing the System Prompt

Judging from the internal identifier, Mathematica is likely not merely a wrapper mode, but a math-specialized variant of DeepThink V3. However, in the absence of an official technical report, outsiders still cannot confirm exactly which components Google has modified.

A genuinely math-specialized model could involve several types of changes:

1. Adjustments to Training Data and Task Distribution

Increasing the proportion of competition problems, research-level proofs, symbolic computation, formal mathematics, and error-correction traces would allow the model not merely to memorize problem types, but to learn how to maintain state throughout long derivations.

2. Increased Test-Time Compute

The core of the DeepThink approach is generally not to immediately provide the first answer, but to allow the model to explore multiple candidate solutions and then select a result through filtering, comparison, or verification. This is similar to having a student try several methods on scratch paper instead of immediately giving an answer upon seeing the problem.

3. Introduction of Verifiable Rewards

Mathematics has the advantage that many results can be checked automatically. Numerical answers can be substituted back into equations, symbolic expressions can be simplified, programs can be executed, and formal proofs can be verified by a kernel. Compared with open-ended writing, which relies heavily on human preferences, mathematical tasks are better suited to training models through result verification.

4. Tool Integration

Large models are good at proposing methods, but specialized tools are often more reliable for high-precision large-number calculations, complex integration, matrix operations, and formal proofs. An ideal mathematical model should know when to reason on its own, when to call a computational system, and how to verify the results returned by that system.

Therefore, Mathematica’s upper bound depends not only on the base model’s parameters, but also on whether Google has integrated search, verification, tool calling, and long-context organization into a complete system.

“Raw Thoughts” Are Attention-Grabbing, but Should Not Be Mistaken for a Product Capability

The leaked model identifier contains raw-thoughts, and related test screenshots show the model producing numerous emotional exclamations while solving a complex Diophantine equation. This material is highly shareable, but its technical significance is limited.

First, so-called Raw Thoughts may simply be an internal debugging field, unedited reasoning draft, or intermediate trace in an experimental system. It does not mean that a future official product will expose its complete chain of thought to users.

Second, a model appearing excited does not mean that its proof is correct. The number of exclamation marks has no relationship to mathematical reliability. What is genuinely valuable to developers is not seeing how the model “talks to itself,” but obtaining:

• Verifiable key reasoning steps;
• Clearly cited definitions and theorems;
• Executable calculation procedures;
• Proof objects that can be verified by external tools;
• Explanations of uncertainty and reasons for failure.

Over the past two years, model providers have increasingly tended to hide raw chains of thought, offering only simplified reasoning summaries or supporting evidence for results. This is partly related to safety and training-data protection, and partly because raw traces are often lengthy and disorganized, making them unsuitable for direct product output. Even if Mathematica is officially launched, it may not retain the raw-thoughts interface format.

Why Would Google Build a Separate Mathematical Model?

Google has previously introduced the Gemini DeepThink IMO mode for advanced mathematical competitions. Continued testing of a math-specialized model now suggests that its goals may be shifting from “competition performance” toward longer, more complex, and more tool-oriented mathematical workflows.

This direction has three practical benefits.

First, mathematics is a high-density test of whether reasoning models are genuinely improving. Answers are usually unambiguous, derivations can be checked, and models have limited ability to conceal errors through linguistic style alone.

Second, mathematical ability can transfer to coding, scientific research, and engineering design. Program debugging, algorithm analysis, chip verification, and physical modeling all fundamentally require long-chain constraint reasoning.

Third, Google has full-stack capabilities spanning models, TPUs, search, and tool systems. DeepThink can consume more reasoning compute, long contexts can accommodate complete materials, and external tools can verify the results. This looks more like a sustainable product direction than simply increasing parameter counts.

However, being “math-specialized” also means a narrower range of applications and higher inference costs. If the model shows clear improvements only on a small number of competition benchmarks but cannot reliably handle ambiguous definitions, incomplete information, and cross-document references in real research, it will remain merely a polished demo.

Developers Do Not Need to Rush to Adapt

There is currently no evidence that Mathematica has entered public preview, nor is there a confirmed official API model name. API aggregation platforms, including OpenAI Hub, naturally do not yet offer a stable, publicly callable version. There is no practical value in writing routing, budget, or fallback logic around the leaked identifier at this stage.

If Google officially opens access later, developers should pay closer attention to several interface-level questions:

• Will the million-token context be available by default, or require a whitelist?
• How will DeepThink reasoning costs be calculated?
• Will the 65,536-token output limit apply to all requests?
• Will structured answers, tool calling, and streaming output be supported?
• Can the reasoning budget be limited by the caller?
• Will mathematical verification or citation tracing be provided?
• Will data be used for training, and how will enterprise requests be isolated?
• If an extremely long task fails, how will the tokens already consumed be billed?

Cost is especially important. A million-token input combined with tens of thousands of tokens of reasoning output could turn a single request into a heavyweight task, even if the unit price is not high. In production environments, a more sensible approach is usually to retrieve first, compress next, and then reason, rather than indiscriminately stuffing every document into the context.

Assessment: Worth Watching, but It Is Too Early to Call It “Google’s Most Powerful Mathematical Model”

The signal released by Mathematica is clear: Google is attempting to turn DeepThink from a high-compute reasoning mode into a specialized system for mathematical and symbolic tasks. A million-token input context and 64K output provide a sufficiently broad interface boundary for long proofs, formal mathematics, and analysis of large scientific documents.

But what can currently be confirmed is still limited to a set of internal configurations and testing traces. There is no official technical report, public benchmark, third-party reproduction, pricing information, or latency data. Defining it as the “most powerful mathematical model” would still require at least three things: verifiable accuracy, stability on real-world tasks, and an acceptable reasoning cost.

What is truly worth waiting for is not whether it can produce longer chains of thought, but whether Google can make those processes machine-verifiable.

If Mathematica ultimately turns out to be merely a Gemini that is more willing to produce lengthy derivations, its value will be limited. If it can genuinely connect million-token contexts, parallel search, symbolic tools, and formal verification, its impact will extend beyond mathematical competitions to a broad range of high-value scenarios, including code verification, research assistance, and engineering computation.

Sources

• ITHome: Google’s Most Powerful Mathematical Reasoning AI Model Revealed, with a 1 Million-Token Context — Summarizes leaked information including Mathematica’s internal identifier, context window, output limit, and Teamfood testing status.
• Zhihu: Background Information on Gemini’s Long-Context Capabilities — Used to understand Google’s historical work on long-context experiments and model capability expansion; some unofficial data should still be treated with caution.