DeepSeek Math V2: Inside the Open Source Model That Beat Google at the Math Olympiad

Introduction

We have reached a weird point in the history of artificial intelligence where an open-source model, released with little fanfare, just quietly broke the ceiling of undergraduate mathematics.

For the last year, we watched the titans battle. Google and OpenAI have been trading blows, saturating benchmarks like the AIME (American Invitational Mathematics Examination). They taught models to be good test-takers. But if you have ever graded a math exam, you know the difference between a student who guesses the right answer and one who actually derives it. Most LLMs are the former. They are probabilistic guessers. Enter DeepSeek Math V2.

Released by the DeepSeek AI team, this model did not just inch past the state-of-the-art. It scored a 118 out of 120 on the Putnam 2024 competition1. To put that in perspective, the highest human score on record for that year was roughly 902. It also grabbed a Gold Medal at the IMO 20253.

What makes DeepSeek Math V2 interesting isn’t just the score. It is the method. They stopped training the model to just “get the answer.” Instead, they trained it to doubt itself. They built a system capable of self-verifiable mathematical reasoning, a shift that might be as important as the transformer architecture itself4.

Let’s tear apart the paper, look at the architecture, and understand why this open-weight model is currently the best open source math LLM you can get your hands on.

1. The Core Breakthrough: What is Self-Verifiable Mathematical Reasoning?

To understand why DeepSeek Math V2 is different, you have to look at how we usually train these things. The conventional recipe for reinforcement learning in AI math models is simple. You give the model a problem. It spits out an answer. If the answer matches the ground truth (say, “42”), you give it a cookie (a positive reward). If it says “43,” you slap it on the wrist.

This works for simple arithmetic. It fails catastrophically for automated theorem proving6. In high-level math, the final answer is often irrelevant or non-existent. The proof is the product. A model can hallucinate a completely insane logical path and stumble upon the correct number by pure luck. Traditional RL reinforces that luck. It teaches the model to be a confident liar.

DeepSeek Math V2 changes the incentive structure. The researchers realized that for a model to be truly capable, it needs to be its own harshest critic. They built a “Verifier”, a secondary logic system trained to look at a proof and assign it a score based on rigor, not just the final output.

The Generator-Verifier Loop

The architecture splits into two distinct roles that play a game against each other:

• The Proof Generator: This is the creative engine. It proposes a step-by-step derivation.
• The Verifier: This acts as the reward model. It evaluates the proof for logical gaps. It doesn’t just say “Right” or “Wrong.” It gives a scalar score: 1 (Rigorous), 0.5 (General idea correct but sloppy), or 0 (Fatal flaws).

This creates a feedback loop. The generator is incentivized to find and resolve its own bugs before it finalizes an answer11. It is the AI equivalent of “checking your work” before handing in the test.

2. Benchmark Breakdown: DeepSeekMath-V2 vs. Gemini DeepThink

The numbers here are aggressive. The team compared DeepSeek Math V2 against the heavy hitters: GPT-5 (as referenced in their charts), Gemini 2.5 Pro, and Claude.

The most telling metric comes from the AI math olympiad results. DeepSeek evaluated their model on the 2024 and 2025 competitions. The results show a clear gap between open-source and closed-source performance.

Here is the breakdown of the competition performance as reported in the paper:

The Putnam result is the outlier that should scare you. The Putnam is notoriously brutal. A median score is often close to zero. DeepSeek Math V2 nearly aced it.

The Head-to-Head

When we look at the DeepSeek vs Gemini matchup, specifically against Gemini DeepThink (Google’s reasoning-heavy model), DeepSeek holds its ground on the benchmarks.

On the IMO-ProofBench (a dataset designed to test formal proof capabilities), DeepSeek Math V2 dominates the “Basic” set and remains competitive on the “Advanced” set.

Data sourced from Figure 3 in the paper.

You can see that on the “Basic” proofs, DeepSeek Math V2 is effectively solved (99%). On the advanced set, it trades blows with Gemini DeepThink, but significantly outperforms standard models like GPT-5 and Claude Sonnet 4, which struggle to break the 20% mark on advanced proofs.

3. How It Was Trained: The “Cold Start” to “Super-Verification” Pipeline

The engineering behind DeepSeek Math V2 is clever because it solves the “Teacher-Student” problem. Usually, if you train a Verifier (the teacher) to grade the Generator (the student), eventually the student becomes smarter than the teacher. The Generator finds proofs so complex that the Verifier can’t tell if they are right or wrong. The training collapses.

DeepSeek solved this with a three-stage pipeline:

Phase 1: The Cold Start

They scraped 17,503 problems from Art of Problem Solving (AoPS) contests. They used a base model (DeepSeek-V3.2-Exp-Thinking) to generate candidate proofs. Since the base model wasn’t great, they asked it to refine its own answers repeatedly. Human experts then scored these proofs to create a “Ground Truth” dataset for the Verifier.

Phase 2: Meta-Verification

This is the cool part. They realized that a Verifier trained on bad data learns to hallucinate errors. It marks correct proofs as wrong just to get a reward.

To fix this, they introduced Meta-Verification. They trained a secondary model to judge the review itself. It asks: “Did the Verifier identify a real error, or is it nitpicking?” This keeps the Verifier honest.

Phase 3: Scaling Compute for Self-Improvement

As the model got smarter, they ran out of hard training data. Humans are too slow to label IMO-level proofs.

So, they automated the labeling. They used the Verifier to analyze thousands of new proofs. If the Verifier was unsure, they scaled up the compute, running 64 independent verification analyses per proof. If the majority agreed, they accepted that as the label.

This creates a flywheel. The Verifier labels data -> The Generator gets smarter -> The Generator creates harder proofs -> The Verifier scales compute to label them.

4. How to Use DeepSeek Math V2: A Python Code Tutorial

You want to run this. I know you do.

DeepSeek Math V2 is built on the DeepSeek-V3.2-Exp-Base architecture. While the paper describes a massive training pipeline, the inference usage follows the standard Hugging Face transformers pattern.

Note: This is likely a massive model (MoE). You will need significant VRAM or a multi-GPU setup to run the full weights. 4-bit quantization is your friend here.

Here is how you spin it up in python:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Define the model ID
model_id = "deepseek-ai/DeepSeek-Math-V2"

# Check for GPU availability
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Loading model on {device}...")

# Load tokenizer and model
# Trust remote code is often required for DeepSeek's custom MoE architectures
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, 
    torch_dtype=torch.bfloat16, 
    device_map="auto", 
    trust_remote_code=True
)

# The prompt template is crucial for theorem proving
# We want to trigger the "Chain of Thought" style reasoning
problem_text = "Prove that for all positive integers n, 3^(2n) + 7 is divisible by 8."

prompt = f"""## Problem
{problem_text}

## Instruction
Please provide a rigorous proof. Your response should include a step-by-step solution followed by a self-evaluation of your own logic.
"""

inputs = tokenizer(prompt, return_tensors="pt").to(device)

# Generate the proof
# We use a high max_length because proofs are verbose
outputs = model.generate(
    **inputs, 
    max_new_tokens=2048, 
    temperature=0.6,    # Lower temperature for rigorous logic
    top_p=0.95
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)

print("-" * 20)
print("DeepSeek Math V2 Proof:")
print(response)

The output won’t just be the answer. Because of how DeepSeek Math V2 was trained, it tends to structure its response in two parts: the Solution and the Self-Evaluation22222222. Watch for the model explicitly critiquing its own steps in the output log.

5. Step-by-Step: Using the Model for Research (Agent Mode)

If you are using DeepSeek Math V2 for actual research or complex problem solving, you shouldn’t just run it once (zero-shot). The paper details a “Sequential Refinement” strategy that drastically improves performance.

This is essentially running the model in “Agent Mode.”

The Workflow

1. Generate Initial Proof: Feed the problem to the model.
2. Self-Verify: The model outputs a self-evaluation score (e.g., “Score: 0.5”).
3. Refinement Loop: If the score is not 1.0, you feed the output back into the model with a prompt like: “You identified issues in your previous step. Please refine the proof to address them.”.

In their experiments on the IMO Shortlist 2024, performance jumped significantly when allowing the model to refine its work up to 8 times.

When you write your wrapper code, implement a while loop. Check the model’s self-assigned score in the \boxed{} token26. If it’s not \boxed{1}, loop it again. This mimics the self-verifiable mathematical reasoning process used during training.

6. Limitations: What Can’t It Do?

It is easy to get hyped by a 118/120 Putnam score, but we need to remain grounded. DeepSeek Math V2 is not a magic oracle.

First, the model still struggles with the absolute hardest tier of problems. While it solved 5 out of 6 IMO 2025 problems, it hits a wall on the most “creative” open problems that require intuitive leaps rather than just rigorous derivation.

Second, the paper highlights that the model requires scaled test-time compute to achieve these results28. The headline scores aren’t from a single quick prompt. They come from generating 64 candidate proofs, running 64 verifications on each, and selecting the best one. This is computationally expensive. If you are running this on a single A100, you might not replicate the Gold Medal performance immediately.

Third, there is the risk of “false confidence.” While the Verifier reduces hallucinations, it doesn’t eliminate them. The model can still write a very convincing, academic-sounding proof that contains a subtle logical fallacy which the internal verifier fails to catch.

7. The Open Source Impact: Why This Matters for AI Research

The release of DeepSeek Math V2 under an Apache 2.0 license is a strategic move that shifts the center of gravity in AI research.

For the last two years, the narrative has been that only closed labs (Google DeepMind, OpenAI) have the compute and data to solve automated theorem proving. DeepSeek has proven that wrong.

By open-sourcing the weights, they allow researchers to:

• Dissect the Verifier: We can now study how a model detects logical errors.
• Fine-tune for Specific Domains: You can take this math-heavy model and fine-tune it for formal verification languages like Lean or Isabelle.
• Build Better Agents: The “Generator-Verifier” architecture is a blueprint for any agentic workflow, not just math. It applies to coding, legal analysis, and scientific hypothesis generation.

This model serves as a foundational block for the next generation of reinforcement learning in AI. It moves us away from RLHF (which relies on human vibes) to RLAIF (Reinforcement Learning from AI Feedback) based on objective logical correctness.

8. Conclusion: The Future of Verified AI

We are transitioning from the era of “Chatbots” to the era of “Reasoners.” DeepSeek Math V2 demonstrates that self-verifiable mathematical reasoning is solvable. We don’t need AGI to get rigorous math; we just need to teach models to be humble. We need them to evaluate their own outputs with the scrutiny of a tired professor grading a midterm.

The gap between “Best Open Source” and “Best Closed Source” is vanishing. With DeepSeek Math V2, you have a model that can sit for the Putnam and beat 99% of human undergraduates.

If you have the hardware, download the weights. Don’t just ask it to add numbers. Ask it to prove something. And when it tells you the proof is wrong and fixes it, remember that this is the behavior we have been waiting for. The best open source math LLM is here, and it is ready to check its own work.

Citation Note: All citations refer to the “DeepSeekMath-V2” research paper provided in the source documents.