SCALE: Selective Resource Allocation for Overcoming Performance Bottlenecks in Mathematical Test-time Scaling

AI summary

Overview

Research area: Natural Language Processing — inference-time (test-time) compute scaling for mathematical reasoning in large language models.

Technical level: Intermediate. The paper assumes familiarity with chain-of-thought prompting, reasoning models, and inference cost metrics, but its core idea (spend more compute on hard sub-steps, less on easy ones) is intuitive.

Scope: The paper introduces SCALE, a four-stage framework that allocates inference compute per reasoning sub-problem rather than uniformly per problem, and evaluates it both as a prompt-time method for reasoning models and as a synthetic data generator for fine-tuning non-reasoning models.

What This Paper Is About

Current test-time scaling methods spread extra computation evenly across an entire reasoning trace, so trivial arithmetic gets as much budget as the hardest algebraic step. The authors argue this uniform distribution is a bottleneck: resources are wasted on routine operations while solution-critical sub-problems stay under-resourced, so added compute yields diminishing returns. SCALE's goal is to assess each sub-problem's difficulty and route it to either fast "System 1" processing or deliberate "System 2" reasoning, concentrating compute where it actually changes the answer.

Key Contributions

1. Identification of a sub-problem-level allocation bottleneck. The paper names uniform resource allocation within a problem — not just across problems — as the reason existing adaptive methods stop scaling effectively.
2. The SCALE framework. A cognitively inspired, four-stage pipeline (decomposition, difficulty assessment, adaptive mode selection, sequential execution with context propagation) that selects System 1 or System 2 processing per sub-problem using a difficulty threshold.
3. Dual evaluation of versatility. SCALE is tested as a prompt-based enhancement for existing reasoning models and as a synthetic reasoning-trace generator whose outputs fine-tune non-reasoning models.
4. Released artifacts. Code at https://github.com/XiaoYang66/DualThinking and data at https://huggingface.co/datasets/YangXiao-nlp/DualThinking accompany the paper.

Main Findings

• Large gains on the hardest benchmarks. On Qwen3-32B, SCALE improves accuracy by 9.59 percentage points on AIME24 (73.33% to 82.92%) and 13.75 percentage points on AIME25 (57.50% to 71.25%) over zero-shot chain-of-thought (CoT). QwQ improves by 4.40 and 6.88 percentage points on AIME24 and AIME25 respectively.
• Better accuracy with fewer tokens than InftyThink. On AIME25 with Qwen3-32B, SCALE reaches 71.25% using 26,643 total tokens versus InftyThink's 70.00% with 36,640 tokens. Across model-dataset combinations, total token usage is 33–53% lower than InftyThink.
• Finer-grained resource allocation. SCALE achieves 3,550 tokens per iteration (Tpi) versus InftyThink's 5,900 Tpi on Qwen3-32B for AIME24 — a 40% reduction in per-step cost.
• Competitive with Majority Voting at far lower cost. Majority Voting consumes 54,719–88,696 total tokens yet does not consistently outperform SCALE, which uses roughly 2–3× fewer resources.
• Consistent but model-dependent improvements. Across all models and datasets, SCALE averages a 3.41 percentage point improvement over CoT baselines. However, on Distill-Llama-70B and Distill-Qwen-32B, SCALE's gains over CoT are smaller (70.00% to 71.25% and 72.50% to 73.33% on AIME24), and Majority Voting scores higher than SCALE on several of those combinations.
• Scaling behavior tracks sub-problem difficulty distribution. Varying Qwen3-32B's System 2 token limit from 4,096 to 32,768 tokens produces steep, nearly linear gains on AIME24 and AIME25 but a flatter, plateauing curve on AMC23 — which the authors attribute to AIME problems containing a higher proportion of difficult sub-problems.
• Lower thresholds work better. The optimal difficulty threshold is τ = 0.2, giving 78.75% on AIME24 and 63.75% on AIME25, with roughly 75% of sub-problems classified as hard. Accuracy falls as τ rises. Even at τ = 0.5, AIME24 accuracy (74.58%) still exceeds CoT (73.33%).
• Threshold trades accuracy for cost. Raising τ from 0.2 to 0.9 cuts tokens by 63% on AIME24 (22,454 to 8,229) and 71% on AIME25 (23,212 to 6,811), with the hard sub-problem share dropping to 0% at τ = 0.9.
• Fine-tuning gains on non-reasoning models. Using 800 SCALE-generated question-response pairs (filtered from LIMOPro with QwQ), fine-tuned models improve by 4.69 to 39.41 percentage points. Llama3.3-70B-Instruct gains 38.93 points on AIME24 (24.58% to 63.51%), and Qwen2.5-32B-Instruct gains 35.41 points on AIME24 (17.92% to 53.33%). Larger models reach 44–63% accuracy on AIME benchmarks.
• Diminishing returns above a capacity threshold. Within the Qwen2.5 family, 32B and 72B models far outgain the 14B model, but 32B versus 72B differ only slightly on AIME24 (53.33% vs 54.17%).

Methodology in Plain English

SCALE runs a mathematical problem through four stages. First, the model breaks the problem into a sequence of sub-problems with explicit logical dependencies. To reduce the risk of a bad split, it generates several candidate decompositions, compares them on logical correctness, clarity, completeness, and relevance, and picks the best one.

Second, for each sub-problem the model assigns a difficulty score between 0 and 1, using the original problem and all previously solved sub-problems as context. Third, a threshold τ decides the processing mode: scores at or below τ go to System 1 (fast, direct computation) and scores above τ go to System 2 (deliberate chain-of-thought reasoning). The framework relies on models that already support switching between thinking modes, such as the Qwen3 series and the Claude family; for reasoning-only models like QwQ, the authors pair them with Qwen3's System 1 counterpart for a fair comparison.

Fourth, sub-problems are solved in order, with each step receiving the full accumulated context of prior sub-problems and their solutions. The final answer comes from the last sub-problem's solution.

Evaluation ran in two settings. In the first, SCALE is applied as a prompt to four reasoning models — Qwen3-32B, QwQ, DeepSeek-R1-Distill-Llama-70B, and DeepSeek-R1-Distill-Qwen-32B — against CoT, InftyThink, and Majority Voting baselines. In the second, SCALE runs on QwQ over the LIMOPro problem set, mismatched answers are filtered out to leave 800 curated pairs, and Qwen2.5-14B/32B/72B-Instruct and Llama3.3-70B-Instruct are fine-tuned with LIMOPro's configurations. Benchmarks are AIME24, AIME25, and AMC23; metrics are pass@1 accuracy over eight samples (Acc), tokens per iteration (Tpi), and total tokens per problem (Tok). Inference uses temperature 0.6 and top-p 0.95.

Why This Matters

Impact on research. The paper reframes test-time scaling as an allocation problem rather than a pure budget problem. Its difficulty-threshold analysis and the divergent AIME-versus-AMC23 scaling curves give a concrete, measurable hypothesis for why some benchmarks benefit from more compute and others plateau — a distinction that uniform-scaling baselines do not explain.

Real-world applications:

• Deploying reasoning assistants for mathematics and quantitative coursework, where per-query cost directly limits serving capacity.
• Generating synthetic reasoning traces that upgrade smaller or non-reasoning models without new pretraining.
• Cost-controlled inference where a single threshold knob trades accuracy against token spend within a fixed budget.
• Automated verification or tutoring pipelines that must efficiently handle mixed workloads of routine computation and genuinely hard derivation.

Industry relevance. The 33–53% token reduction relative to InftyThink at equal or better accuracy maps directly to serving cost and latency, which is the practical constraint on running long-chain reasoning models at scale. The threshold table gives operators an explicit dial, which is more actionable than post-hoc length penalties.

Future Directions

• Learned difficulty assessment. The paper uses model-prompted difficulty scoring with a fixed threshold; whether a trained difficulty classifier improves the accuracy-cost frontier is left open.
• Better routing to System 2. Since the best results come from sending roughly 75% of sub-problems to System 2 at τ = 0.2, the framework's efficiency claim rests on a fairly heavy default allocation. Stronger gains may require more precise discrimination of which hard sub-problems actually need deliberation.
• Decomposition quality and error propagation. SCALE selects the best of several decompositions by model-based comparison and then solves sub-problems sequentially, so a bad early sub-problem can contaminate the rest. The paper does not report an analysis of decomposition failure modes.
• Extension beyond mathematics. All reported benchmarks are competition mathematics; whether selective allocation transfers to code generation, scientific reasoning, or other domains with heterogeneous step difficulty is not reported.

Target Audience

Researchers and engineers working on LLM reasoning, inference-time compute scaling, and efficient model serving — particularly those who already use chain-of-thought, iterative reasoning, or self-consistency methods and want finer control over where compute is spent. It is also relevant to practitioners building synthetic reasoning datasets, since the second experimental setting shows SCALE-generated traces can lift non-reasoning models substantially. Readers without background in reasoning models will need to read the baseline descriptions (InftyThink, Majority Voting) to follow the comparisons.

Authors’ abstract

Test-time compute scaling has emerged as a powerful paradigm for enhancing mathematical reasoning in large language models (LLMs) by allocating additional computational resources during inference. However, current methods employ uniform resource distribution across all reasoning sub-problems, creating fundamental bottlenecks where challenging sub-problems receive insufficient attention while routine operations consume disproportionate resources. This uniform allocation creates performance bottlenecks where additional computational resources yield diminishing returns. Inspired by dual-process theory, we propose \textbf{SCALE} (Selective Resource Allocation), a framework that selectively allocates computational resources based on sub-problem difficulty. SCALE operates through four stages: (1) problem decomposition into sequential reasoning sub-problems, (2) difficulty assessment of each sub-problem to distinguish between routine operations and computationally challenging sub-problems, (3) selective processing mode assignment between System 1 for simple sub-problems and System 2 for complex ones, and (4) sequential execution with context propagation. By concentrating resources on challenging sub-problems while processing routine operations efficiently, SCALE achieves substantial performance improvements with superior resource utilization. Extensive experiments demonstrate that SCALE significantly outperforms uniform scaling baselines, achieving accuracy improvements of up to 13.75 percentage points (57.50% to 71.25% on AIME25) while reducing computational costs by 33%-53%, representing a major advance in test-time scaling that addresses fundamental limitations of current approaches.