ReasoningReportAdvanced2025~10 min theory

DeepSeek-R1-0528 Report

Same 671B architecture, roughly double the thinking: R1-0528 spends about 23k tokens per AIME question instead of 12k and lifts AIME 2025 from 70.0 to 87.5.

Source

Where this sits

DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement LearningDeepSeek-R1-0528 Report

A mid-cycle version bump of the same reasoning model, published by the model card and API changelog rather than as a paper. It is the clearest public demonstration that thinking length is a tunable resource: the same weights family plus longer traces moved benchmark numbers more than most architectural changes of the era.

AIME 2025 accuracy rises from 70.0 to 87.5, with AIME 2024 moving from 79.8 to 91.4, by spending more thinking tokens per problem (about 12K to 23K on average).
GPQA Diamond improves from 71.5 to 81.0, LiveCodeBench from 63.5 to 73.3, Codeforces-Div1 rating from 1530 to 1930, and SWE-bench Verified from 49.2 to 57.6.
Humanity's Last Exam roughly doubles from 8.5 to 17.7, and HMMT 2025 jumps from 41.7 to 79.4.
Adds JSON output and function-calling support (BFCL_v3_MultiTurn 37.0; Tau-bench 53.5 Airline and 63.9 Retail) and reduces hallucinations.
Distills the new chain of thought into DeepSeek-R1-0528-Qwen3-8B, which scores 86.0 on AIME 2024, ahead of Qwen3-8B by 10 points and matching Qwen3-235B thinking on that benchmark.

What it is

This is not a paper but DeepSeek's official model-and-release report: a Hugging Face model card with evaluation tables plus an API changelog entry. R1, trained in January 2025, was re-post-trained with more compute and algorithmic changes announced only in general terms. The model card reports higher scores across math, code, and general benchmarks, a lower hallucination rate, JSON output and function-calling support, and a distilled 8B student that inherits the R1-0528 chain of thought.

1Theory from first principles

Thinking length is a compute knob

A reasoning model answers a question by spending tokens on a private trace before producing the final answer. Those tokens cost GPU time exactly like output tokens, and they buy something real: more room to try an approach, hit a wall, back up, and verify. R1-0528's headline change is that it uses that budget more generously. On the AIME test set the previous version averaged 12K thinking tokens per question; the new version averages 23K. Accuracy on AIME 2025 rose by 17.5 points. This is inference-time scaling in its simplest form: the model was trained so that it does not stop thinking early.

What the report does and does not say

The card states that the improvement comes from 'leveraging increased computational resources and introducing algorithmic optimization mechanisms during post-training'. That is the whole recipe as far as the public is concerned: more post-training compute, plus unspecified changes to the post-training algorithms. Treat the report as an engineering disclosure of results, not a method paper. What is verifiable is the evaluation table, the sampling configuration (temperature 0.6, top-p 0.95, 16 responses per query, 64K maximum generation length), and the behavioral changes users can observe.

The R1-0528 trade curve: thinking tokens per AIME question grew from about 12K to about 23K, and reported accuracy on AIME 2025 went from 70.0 to 87.5. More inference compute buys accuracy, and the model card treats output-token growth as the mechanism rather than a side effect.

How the card estimates pass@1

pass@1_hat = (1 / 16) * sum_{j=1..16} 1[ answer_j is correct ]

The model card fixes a sampling configuration (temperature 0.6, top-p 0.95) and draws 16 responses per query, then reports the average correctness. This is a Monte-Carlo estimate of the probability that a single sampled answer is right, not a measure of self-consistency. It matters when comparing charts: a number measured this way already includes some of the benefit of sampling, and it is directly sensitive to how much thinking each response is allowed.

Behavioral fixes beyond reasoning

The release note bundles several product-level changes: a reduced hallucination rate, JSON output, function calling, better front-end code generation, and a supported system prompt (users no longer need to prepend a special token to force thinking). The card reports tool-use numbers that R1 did not publish, BFCL_v3_MultiTurn at 37.0 accuracy and Tau-bench at 53.5 (Airline) and 63.9 (Retail). The changelog shows large coding-agent deltas too (Aider-Polyglot 53.3 to 71.6). One entry in the evaluation table moves the other way: SimpleQA correctness slips from 30.1 to 27.8, a reminder that a single release optimizes a mix of objectives rather than dominating every axis.

The distilled student and why it matters

The card also releases DeepSeek-R1-0528-Qwen3-8B, produced by post-training Qwen3 8B Base on chain-of-thought traces from the new model. The student scores 86.0 on AIME 2024 (10 points above Qwen3-8B) and 76.3 on AIME 2025, matching Qwen3-235B thinking on AIME 2024 despite being an 8B dense model. The message is the same as R1's: traces are a transferable artifact, and a smaller model trained on good traces can punch far above its weight class. For practitioners deploying on ordinary hardware, the distilled student is often the more useful release than the 671B teacher.

2Inside the paper

What this report is

An official model card plus API changelog entry dated 2025-05-28, not a peer-reviewed paper. The primary source is the Hugging Face model card for DeepSeek-R1-0528; the API changelog confirms the deepseek-reasoner upgrade and the token-cost warning.

Key idea to look for while reading

Two threads: the evaluation table (what improved and by how much) and the mechanism sentence (more post-training compute plus algorithmic optimization, with thinking depth on AIME roughly doubling). The Qwen3-8B distillation section is the most transferable part of the report.

Evidence the report provides

AIME 2025: 70.0 to 87.5. AIME 2024: 79.8 to 91.4. GPQA Diamond: 71.5 to 81.0. LiveCodeBench (2408-2505): 63.5 to 73.3. Codeforces-Div1 rating: 1530 to 1930. SWE Verified: 49.2 to 57.6. Aider-Polyglot: 53.3 to 71.6. HMMT 2025: 41.7 to 79.4. Humanity's Last Exam: 8.5 to 17.7. Thinking tokens on AIME: about 12K to about 23K. The distilled Qwen3-8B student: 86.0 on AIME 2024 and 76.3 on AIME 2025.

Limits and caveats

There is no method section, so the improvements cannot be attributed to specific training changes from public information. The API changelog itself warns that complex reasoning tasks may consume more tokens than the legacy version, which is a real serving-cost change. SimpleQA regressed (30.1 to 27.8), so hallucination reduction is not uniform. Benchmark scores use sampling with 16 responses per query at 64K max generation, so they are not single-pass numbers.

Practitioner takeaway

Before swapping a reasoning model for its mid-cycle upgrade, measure three things: accuracy on your task, average thinking tokens per request, and behavior on the axes you care about that regressed somewhere (here, SimpleQA). Budget for longer traces because they are the mechanism, not an accident. And if the full model is too large to serve, the distilled student built from the same traces is frequently the better deployment target.

3Implementation check

0 of 4 questions answered

1.The model card attributes the AIME 2025 jump to increased post-training compute plus algorithmic changes. Which observation directly supports the thinking-depth explanation?
2.What is the practical cost implication of R1-0528's improvement for a serving system?
3.Why does DeepSeek train an 8B student on R1-0528's chain of thought instead of running RL on the 8B base directly?
4.The evaluation table shows SimpleQA dropping from 30.1 to 27.8 while most benchmarks improve. What is the right conclusion?

4Build it yourself

Thinking Budget vs Accuracy

Starter1-2 hours

Simulate a reasoner whose thinking steps try techniques with replacement: a longer trace raises the chance of hitting a correct approach with sharply diminishing returns. Find where the accuracy curve flattens, the toy version of comparing 12k and 23k thinking tokens.

Milestones

Define the task: 40 techniques, 3 correct, each thinking step tries one technique at random.
Implement success for a fixed budget.
Average over 400 runs per budget so the estimate is stable.
Implement flatten_budget with a 0.05 tolerance.
Print the curve for budgets 1 through 80 and find the knee.
Re-run with 1 and with 6 correct techniques and compare the curves.

Starter code

python · editable

import random

TECHNIQUES, CORRECT, SEEDS = 40, 3, 400
BUDGETS = [1, 5, 10, 20, 40, 80]

def success(budget, rng):
    # TODO: each thinking step tries one technique (sampling with
    # replacement); success if any of the first CORRECT techniques comes up.
    return 0

def accuracy(budget):
    # TODO: average success(budget, rng) over SEEDS runs of a fixed-seed rng.
    return 0.0

def flatten_budget(curve, tol=0.05):
    # TODO: first budget whose accuracy gain over the previous budget is
    # below tol; return -1 when the curve never flattens.
    return -1

def main():
    curve = [(b, accuracy(b)) for b in BUDGETS]
    for budget, acc in curve:
        print("budget", budget, "accuracy", round(acc, 3))
    print("returns flatten at budget", flatten_budget(curve))
    # EXPECTED: after the TODOs, 0.095, 0.330, 0.505, 0.800, 0.960, 0.995
    # and flatten at 80; the unfilled starter prints zeros and -1.

main()

Runs locally in your browser.

Success criteria

Accuracy rises from under 0.1 at budget 1 to above 0.99 at budget 80.
The first gain below the 0.05 tolerance appears at budget 80.
With one correct technique the same budgets score lower everywhere, so the curve depends on both budget and hit rate.

Stretch goals

Add overthinking: after each failure a step has a small chance to derail the trace, then find the accuracy peak.
Allow steps to revisit earlier techniques with fixed probability and measure the effect.
Give the reasoner a biased technique order and show how a better prior shifts the curve left.

Problems

5Keep going

previousDeepSeek-Prover-V2: Advancing Formal Mathematical Reasoning via Reinforcement Learning for Subgoal Decomposition nextDeepSeekMath-V2: Towards Self-Verifiable Mathematical Reasoning