PaperlayerView exact revision on arXiv

Source-linked AI summary

Ring-Zero: Scaling Zero RL to a Trillion Parameters for Emergent Reasoning

Xinyu Tang, Qianggang Cao, Yurou Liu, Yuliang Zhan, Xiaochong Lan, Yifan Li, Yuchen Yan, Han Peng, Zican Dong, Zhenduo Zhang, Tianshu Wang, Xinyu Kong, Zujie Wen, Wayne Xin Zhao, Zhiqiang Zhang, Jun Zhou

arXiv:2607.12395v2cs.CL

TL;DR

Existing zero-RL studies have largely focused on small models, leaving trillion-parameter training dynamics and emergent reasoning capabilities underexplored. This paper develops a stable pipeline for zero RL at 1T parameters and finds improved capability and efficiency, sequential discovery and sharpening, and spontaneously emerging reasoning behaviors.

  • Problem

    Existing zero-RL studies largely focus on small models, leaving large-scale training dynamics and emergent reasoning capabilities underexplored.

  • Method

    The paper applies zero RL to a pretrained 1T-parameter model using a stable pipeline and evaluates reasoning traces for comprehensibility, reproducibility, and efficiency.

  • Results

    Scaling to 1T parameters improves capability and training efficiency, reveals discovery followed by sharpening, and produces advanced reasoning behaviors without hand-crafted rules.

  • Takeaways & Limitations

    The findings provide evidence that simple scalable computation can support trillion-parameter zero RL and emergent high-quality reasoning behaviors.

  • Takeaways & Limitations

    Zero RL cannot fundamentally transcend concepts and proof techniques absent from the pretrained model’s knowledge and pattern library.

Abstract

from arXiv · show

Reinforcement learning with verifiable rewards without human-annotated data, often referred to as zero RL, has emerged as a powerful paradigm for eliciting chain-of-thought reasoning. However, due to computational constraints, existing studies are largely restricted to small models, leaving the training dynamics and emergent capabilities at a large scale unexplored. To meaningfully explore this frontier, we aim to elicit high-quality reasoning behaviors from the model. However, we find that naive scaling often suffers from poor readability, token redundancy, and a lack of adaptive reasoning depth. To address these challenges, we present a stable and efficient training pipeline, incorporating algorithmic and system optimizations such as clipped importance sampling, training-inference ratio correction, and mixed-precision control. Our experiments offer three key findings that validate the "bitter lesson" of scaling: (1) scaling to 1T parameters significantly enhances sample efficiency and performance ceilings; (2) the training process progresses sequentially through an initial discovery phase followed by a sharpening phase; and (3) the model spontaneously develops advanced cognitive behaviors, including anthropomorphism, structured formatting, self-verification, parallel reasoning, and context anxiety, rendering hand-crafted heuristics redundant. Evaluated on seven mathematical benchmarks, Ring-2.5-1T-Zero achieves competitive performance. Additionally, to assess CoT quality beyond final-answer correctness, we propose a structured evaluation framework across three dimensions: comprehensibility, reproducibility, and efficiency, where our model demonstrates clear advantages in producing structured and concise reasoning traces. By sharing our observed emergent phenomena, we hope to provide the community with deeper insights into scaling behaviors, particularly at the 1-trillion scale.

1 Introduction

Ring-Zero investigates trillion-parameter zero RL for emergent reasoning, arguing that scaling can improve capability ceilings and sample efficiency while enabling advanced reasoning behaviors without human-annotated data. It also introduces a three-dimensional framework for evaluating CoT quality beyond final-answer accuracy.

  • Motivation: Zero RL can cultivate powerful reasoning through trial-and-error reinforcement learning without costly curated reasoning demonstrations.This motivates eliciting reasoning directly from base models rather than relying on human-annotated reasoning data.
  • Motivation: High-quality CoT should be correct, human-readable for verification, and computationally concise for efficient inference.The paper treats the reasoning path itself as important in addition to final-answer correctness.
  • Method: Minor algorithmic and system improvements stabilize and efficiently train Ring-2.5-1T-Zero at the trillion-parameter scale.The cited improvements include clipped importance sampling, training-inference ratio correction, and mixed-precision control.
  • Findings: Scaling to 1T parameters improves sample efficiency and performance ceilings over 104B while supporting autonomous emergence of advanced reasoning strategies.The reported behaviors include anthropomorphism, structured formatting, self-verification, parallel reasoning, and context anxiety, making hand-crafted heuristics redundant.
  • Evaluation: Ring-2.5-1T-Zero achieves competitive performance on seven mathematical benchmarks and produces structured, human-readable, concise traces.The paper evaluates CoT quality through comprehensibility, reproducibility, and efficiency rather than final-answer accuracy alone.

2 Evaluation Metrics for Chain-of-Thought Quality

The paper argues that final-answer accuracy alone cannot evaluate Chain-of-Thought quality because it treats reasoning as a black box. It therefore introduces a three-dimensional framework measuring comprehensibility, reproducibility, and efficiency.

  • Motivation: Final-answer accuracy evaluates only outcomes, leaving the underlying reasoning process opaque despite CoT traces serving explanatory and intermediate roles.CoT traces provide human-readable explanations and critical intermediate steps for downstream agentic workflows.
  • Evaluation Framework: The framework assesses CoT quality across three dimensions: Comprehensibility, Reproducibility, and Efficiency.These dimensions respectively address readability, learnability of reasoning strategies, and concise problem solving.
  • Comprehensibility: Comprehensibility requires coherent logical flow, explicit causal dependencies, and no hallucinated claims, enabling readers to follow reasoning without excessive cognitive load.It is evaluated through pairwise LLM-as-a-Judge comparisons of traces for the same problem, favoring stronger coherence, clearer articulation, and fewer flaws.
  • Reproducibility: Reproducibility measures whether novices or weaker models can learn generalizable reasoning strategies and achieve comparable task-solving abilities.Knowledge distillation uses the weaker student’s downstream performance gain as a proxy; larger gains indicate richer, more transferable teacher traces.
  • Efficiency: Efficiency measures concise, nonredundant reasoning that preserves clarity and correctness, using the average token count of correct CoT traces.Among valid solutions, fewer tokens indicate a more direct path and support faster inference with lower token costs.

3 Methodology

Ring-Zero uses a minimal multi-stage zero-RL framework that elicits reasoning from a base model, compresses and stabilizes its traces, and teaches adaptive reasoning depth. The methodology also addresses long-context training through mixed-precision control and context-parallelism optimizations.

  • 3.1 Training Pipeline: The framework uses four phases: first-stage RL, self-distillation, second-stage RL, and tier-based training for adaptive reasoning depth.Its design principle is minimalism, introducing optimization elements only when strictly required to guide iterative learning.
  • 3.1.1 First RL Stage: The first RL stage combines clipped importance sampling, KL regularization, and an unnormalized token-level loss to elicit and lengthen reasoning.The method corrects training-inference discrepancies using training-engine logits and caps only excessively large importance weights.
  • 3.1.2–3.1.3 Self-Distillation and Second RL Stage: Self-distillation selects and refines the shortest correct traces, reducing redundant verbosity and accumulated engine discrepancies before the next RL stage.The second RL stage retains clipped-ratio correction but switches to sample-level normalization and removes KL regularization to keep gradients independent of output length.
  • 3.1.4 Tier-Based Training: Tier-based training teaches adaptive compute allocation, encouraging concise responses for trivial queries and extended chain-of-thought generation for complex problems.Responses are conditioned on tier-specific system prompts and truncated at corresponding window sizes.
  • 3.2 System Optimizations: Long-context RL is optimized with mixed-precision control for stability and context parallelism for throughput, addressing numerical instability and communication latency.Standard ring attention introduces sequential communication dependencies that become a severe latency bottleneck as parallelism grows.

4 Experiments

Experiments show that Ring-2.5-1T-Zero achieves strong zero-RL reasoning through staged training, scaling, and adaptive inference, while producing readable, transferable, and token-efficient CoT traces. The results also identify stability requirements and length inertia as central challenges in large-scale RL training.

  • Performance and training stages: 84.2% accuracy on AIME 2026 is achieved by First Stage RL without human-annotated data, using a curriculum that expands the response window from 4k to 64k tokens.Importance ratio correction contributes to stable and efficient training.
  • Performance and training stages: Multi-stage training improves reasoning by combining self-distillation, sample-level loss, and tier-based training to develop adaptive reasoning depth.Supervision progresses from token-level First Stage RL to sample-level Second Stage RL, with self-distillation serving as an anchor.
  • Adaptive inference and scaling: Low (TT=4k) and Medium (TT=16k) inference modes reduce latency and compute costs while maintaining competitive performance, despite a slight Third Stage RL decline.The three tiers—Low, Medium, and High—provide control over reasoning depth during inference.
  • Adaptive inference and scaling: Scaling from 104-billion-parameter Ring-2.5-flash-Zero to 1-trillion-parameter Ring-2.5-1T-Zero disproportionately improves Zero RL performance, especially on harder benchmarks.The results indicate that larger models better use internal knowledge to navigate the search space.
  • CoT quality and transfer: 5.8-point gain on Qwen-32B (78.4 vs. 72.6) and 4.5-point gain on Llama-70B (74.5 vs. 70.0) are obtained using 100K samples versus DeepSeek-R1’s 800K.The model’s step-segmented traces outperform DeepSeek-R1 counterparts in distillation, indicating stronger transfer and sample efficiency.
  • CoT quality and transfer: 6,368 tokens is the average length on mutually solved AIME problems, less than half that of other models, while traces are structured, readable, reproducible, and efficient.The 1T model spontaneously uses markers such as Step 1: and Step 2: and exhibits trial-and-error, self-reflection, and parallel reasoning.
  • Training stability: Removing the KL penalty causes log-probability divergence, entropy collapse, and reward failure, whereas retaining it keeps training metrics stable.Engine mismatch is also problematic: the standard ratio collapses within roughly 800 steps, while clipped importance-ratio thresholding delays collapse.
  • Training stability: Length inertia makes sequence length expand unconditionally, because token-level optimization rewards longer outputs even when simple questions are solved on the first rollout.Loose formatting permits trailing garbled text, whereas requiring EOS prevents degenerate length growth.

5 Discussion

The discussion finds that trillion-parameter scaling improves zero RL’s performance ceiling and sample efficiency, while training progresses from discovering new reasoning patterns to sharpening existing capabilities. It also identifies training-data, capacity, context-window, and pretrained-prior constraints, and highlights structured CoT evaluation, adaptive reasoning modes, and emergent cognitive strategies.

  • Model scale: After 3,600 steps, Ring-2.5-1T-Zero-I reaches 89.06% on AIME 2024 and 83.28% on AIME 2025, versus 71.72% and 63.54% for Ring-2.5-flash-Zero.The 1T model also improves reasoning faster throughout training and maintains a higher performance ceiling.
  • Training dynamics: Pass@1024 rises early and plateaus, whereas pass@1 continues climbing, indicating discovery of dormant reasoning patterns followed by capability sharpening.Pass@1024 measures whether at least one of 1024 samples solves a problem correctly.
  • Limitations: The training-data distribution need not mirror the real world’s long tail, because excess trivial problems waste computation and stall learning.The discussion identifies a mismatch between natural data frequency and the distribution that is optimal for RL training.
  • Limitations: Zero RL is bounded by model capacity, a 64k context window, and pretrained priors that limit which concepts and proof techniques it can bootstrap.The paper argues that larger models improve ceilings and learning speed, longer contexts enable multi-step derivations, and RL cannot invent absent pretrained knowledge.
  • Contributions: The paper evaluates chain-of-thought quality through comprehensibility, reproducibility, and efficiency, rather than final-answer accuracy alone.It also uses a multi-stage self-iterative pipeline with multiple reasoning modes that adapt reasoning depth to problem complexity.
  • Emergent behaviors: Without human-annotated data, Ring-2.5-1T-Zero spontaneously develops anthropomorphism, structured formatting, self-verification, parallel reasoning, and context anxiety.These emergent strategies reduce the need for complex hand-crafted reasoning pipelines.

6 A Bitter Lesson

The model spontaneously develops structured reasoning behaviors without specialized prompting or human-designed heuristics. These behaviors include anthropomorphic traces, explicit organization, parallel exploration, self-verification, and context anxiety.

  • Anthropomorphic reasoning: The model exhibits anthropomorphic reasoning traces, including simulated frustration, slacking, guesswork, self-praise, and playful banter.The authors hypothesize these behaviors reflect corpus-induced artifacts that mimic human cognitive friction and emotional dynamics.
  • Structured formatting: Without formatting instructions beyond “reason step by step,” the model organizes thoughts into structured, pedagogically clear traces with numbering, phase transitions, and summaries.The passage frames this structure as an emergent strategy for organizing long-context attention rather than a behavior taught through human annotations.
  • Parallel reasoning: The model spontaneously branches into alternative strategies, compares outcomes, and commits only when multiple independent lines of evidence converge.This behavior is characterized as a self-contained “Tree-of-Thought” search within a single linear rollout.
  • Context anxiety: As it approaches its perceived token limit, the model exhibits context anxiety by aborting complex reasoning, prioritizing structural completeness, and forcing a heuristic guess.The passage describes this as a flawed strategic response to formatting failures receiving zero reward while guessing retains a non-zero success probability.
  • Self-verification: The model spontaneously verifies intermediate derivations by re-examining assumptions, cross-checking formulas, and substituting results into original constraints.The passage attributes these checks to a learned necessity to secure the final correctness reward, without human-designed verification procedures.

7 Related Work

Prior work established RLVR and zero RL as paradigms for eliciting reasoning in large language models, while systems research developed parallelism and memory-partitioning strategies for trillion-parameter training.

  • Reasoning with RLVR: RLVR has become a powerful paradigm for unlocking reasoning capabilities in large language models.The passage identifies RLVR as the broader paradigm motivating this line of work.
  • Reasoning with RLVR: DeepSeekMath introduced GRPO, which removes the need for a separate critic model through group-level relative rewards.GRPO relies on relative rewards computed at the group level.
  • Reasoning with RLVR: DeepSeek-R1 showed that pure RL applied directly to base models can spontaneously incentivize emergent chain-of-thought reasoning.This work established the zero RL approach described in the passage.
  • Large-scale training systems: Megatron-LM pioneered tensor and pipeline parallelism for training massive model architectures.These parallelism strategies are identified as foundational for large-scale model training.
  • Large-scale training systems: ZeRO reduced memory redundancy by partitioning optimizer states across devices.The passage presents optimizer-state partitioning as a major memory-efficiency contribution.

8 Conclusion … Ring-Zero (3301 tokens)

Ring-Zero concludes that simple engineering scaled zero RL to 1T parameters, yielding faster learning, stronger performance, emergent reasoning behaviors, and clearer, more efficient reasoning traces. The accompanying example illustrates this reasoning through prefix-sum reformulation and residue-class counting.

  • 8 Conclusion: Simple changes—clipped importance sampling, training-inference ratio correction, and mixed-precision control—enabled a stable, efficient zero-RL pipeline for a pretrained 1T-parameter model.The conclusion states that complex engineering and human-designed rules were unnecessary for scaling.
  • 8 Conclusion: 1T scaling improved model capability and training efficiency, with the 1T model learning faster and performing better than smaller models.The conclusion presents this as evidence for the bitter lesson that scalable computation can outperform complex human rules.
  • 8 Conclusion: The 1T model independently developed anthropomorphism, structured formatting, self-verification, parallel exploration, and context anxiety, making hand-crafted rules unnecessary.These behaviors are described as emergent advanced reasoning behaviors.
  • 8 Conclusion: Ring-2.5-1T-Zero was evaluated on readability, reproducibility, and efficiency, consistently producing clear, concise, and highly readable solutions.The conclusion also reports strong results on seven mathematical benchmarks.
  • A Comparison of Our CoT with Other Models: Compared with other frontier models, the model generated Chain-of-Thought traces with high token efficiency and a clearer, highly structured format.This comparison focuses on the quality and organization of reasoning traces rather than only final-answer performance.
  • Question: The example asks for the greatest sequence length under total sum 2019 while forbidding any number or consecutive-number sum equal to 40.It requests step-by-step reasoning and a boxed final answer.
  • Ring-Zero (3301 tokens): The solution reformulates the constraint using prefix sums, then counts residue-mod-40 chains where adjacent selections are restricted.Because 2019 = 50 × 40 + 19, residues 0–19 form chains of 51 elements and residues 20–39 form chains of 50; each chain permits at most ⌈k/2⌉ selections.

Claude Opus 4.7 (Summary: 790 tokens) · Gemini 3.1 Pro (Summary: 1014 tokens) · GLM 5.1 (39192 tokens)

The Claude Opus 4.7 and Gemini 3.1 Pro excerpts solve the maximization problem by converting forbidden consecutive sums into a prefix-sum selection problem and partitioning values modulo 40. Their reported construction yields a maximum sequence length of 1019.

  • Claude Opus 4.7 (Summary: 790 tokens): Claude partitions the values into residue classes modulo 40, where each class forms a chain whose adjacent elements differ by 40.The independent-set formulation is applied separately to these chains.
  • Claude Opus 4.7 (Summary: 790 tokens): 1020 is the maximum subset size, computed as 20 · 26 + 20 · 25 from twenty chains of lengths 51 and twenty chains of lengths 50.The chain contributions are ⌈51/2⌉ = 26 and ⌈50/2⌉ = 25.
  • Claude Opus 4.7 (Summary: 790 tokens): Claude exhibits attainability with 25 blocks containing 39 ones followed by 41, plus 19 additional ones.The construction has length 25 · 40 + 19 = 1019 and sum 25(39 + 41) + 19 = 2019.
  • Gemini 3.1 Pro (Summary: 1014 tokens): Gemini reports 51 elements for residues 0 through 19 and 50 elements for residues 20 through 39 after partitioning modulo 40.Each residue class is treated as a path graph, whose maximum independent set has size ⌈k/2⌉.
  • Gemini 3.1 Pro (Summary: 1014 tokens): Gemini independently states that no consecutive sub-sum equals 40 exactly when no two partial sums differ by 40.It then frames the task as selecting the largest subset of {0,…,2019} containing both endpoints.

(Very long reasoning process with multiple false starts and corrections.) · Qwen 3.5 (6807 tokens) · Doubao 2.0 (5122 tokens)

The reasoning converges on a maximum sequence length of 1019 by separating runs of ones with numbers at least 41. Multiple failed constructions and an independent-set formulation support the same optimum.

  • (Very long reasoning process with multiple false starts and corrections.): Any separator between blocks of ones must be at least 41, because every smaller separator can combine with preceding ones to total 40.Attempts using separators 2 and 3 fail because 38 + 2 and 37 + 3 equal 40.
  • (Very long reasoning process with multiple false starts and corrections.): Using 25 separators of 41 with blocks of at most 39 ones satisfies the length constraint and leaves 19 ones appended safely.The construction uses 1000 numbers summing to 2000, followed by 19 additional ones.
  • (Very long reasoning process with multiple false starts and corrections.): The resulting construction has length 1019, establishing a feasible sequence that avoids any contiguous subsequence summing to 40.Its separators contribute at least 41, while each one-block contains at most 39 ones.
  • (Very long reasoning process with multiple false starts and corrections.): A proposed length-1020 arrangement with 999 twos and 21 ones fails because twenty consecutive twos sum to 40.The passage also notes that a pigeonhole argument forces a run of at least 46 twos.
  • (Very long reasoning process with multiple false starts and corrections.): The optimization bounds the number of separators by 2019 − 41k ≤ 39(k + 1), yielding k ≥ 24.75 and therefore k = 25.With k separators, the attainable length is 2019 − 40k.
  • Qwen 3.5 (6807 tokens): Residues 0–19 contribute 20 × 26 vertices and residues 20–39 contribute 20 × 25, totaling 1020 selected prefix sums.Subtracting one from the number of selected prefix sums gives the greatest sequence length, 1019.

(Includes extended thinking process.) · MiniMax 2.7 (23201 tokens) · (Extended thinking with detailed exploration of multiple approaches.)

The solution maximizes sequence length by separating blocks of small numbers with 41s, deriving that at least 25 separators are necessary. A construction with 25 separators attains length 1019 while summing to 2019.

  • (Includes extended thinking process.): Using the smallest positive integer 1 as much as possible maximizes the sequence length.Any non-1 number below 40 is forbidden because it can combine with consecutive 1s to sum to 40.
  • (Includes extended thinking process.): 25 separators are necessary because 2019 − 41k ≤ 39(k + 1) implies k ≥ 25.With k separators of value 41, the remaining ones must fit into k + 1 blocks of at most 39 ones.
  • (Extended thinking with detailed exploration of multiple approaches.): Numbers greater than 40 serve as separators because any subarray crossing one has sum above 40.The construction therefore uses 41s to divide runs of 1s into blocks.
  • (Extended thinking with detailed exploration of multiple approaches.): Each block of at most 39 ones has maximum subarray sum 39, so it cannot contain a subarray summing to 40.This establishes the block-size constraint used in the optimization.
  • (Extended thinking with detailed exploration of multiple approaches.): The resulting construction contains 25 full blocks of 39 ones, separated by 41s, followed by a final block of 19 ones.This arrangement saturates the separator lower bound while respecting the block constraint.

B LLM-as-a-Judge Evaluation Prompts · Comprehensibility Evaluation Prompt

The paper evaluates reasoning-trace quality with an LLM-as-a-Judge pairwise protocol focused on comprehensibility. Judges assess logical coherence, causal explicitness, and hallucination absence while controlling position bias and returning structured verdicts.

  • B LLM-as-a-Judge Evaluation Prompts: An LLM-as-a-Judge protocol evaluates the intrinsic quality of reasoning traces through pairwise comparisons.Each comparison presents one math problem and two competing model traces.
  • B LLM-as-a-Judge Evaluation Prompts: The judge assesses logical coherence, causal explicitness, and the absence of hallucinations.These criteria target smooth reasoning progression, explicit dependencies, and reliable traces.
  • B LLM-as-a-Judge Evaluation Prompts: Model A and Model B are randomly shuffled to eliminate position bias before judgment.The judge then issues a structured verdict of A, Tie, or B.
  • Comprehensibility Evaluation Prompt: Comprehensibility measures whether a human reader can follow and fully understand reasoning steps without external context or repeated reading.The evaluation compares traces generated by different models for the same math problem.
  • Comprehensibility Evaluation Prompt: Logical coherence requires each step to follow naturally, while causal explicitness requires explaining why each intermediate result is derived.The prompt checks for abrupt jumps, non-sequiturs, unexplained transitions, and missing logical connections.
  • Comprehensibility Evaluation Prompt: The verdict options are A, Tie, or B, indicating which trace is clearer, better structured, or more reliable.A Tie means neither trace has a meaningful comprehensibility advantage.
  • Comprehensibility Evaluation Prompt: Judges focus on reasoning-process comprehensibility rather than final-answer correctness, and evaluate clarity independently of trace length.They consider mathematically literate readers and choose the easier-to-follow trace when both contain errors.
  • Comprehensibility Evaluation Prompt: The required output contains a 2-4 sentence comparative analysis and a verdict restricted to A, Tie, or B.Inputs comprise the problem and the two model reasoning traces.

C Showcase of Our Reasoning Traces · AIME 2026

Ring-2.5-1T-Zero autonomously generates highly structured, readable CoT traces without external formatting supervision. The AIME 2026 example demonstrates a modular reduction, character-sum filtering, symmetry reductions, and tuple-count evaluation.

  • C Showcase of Our Reasoning Traces: Ring-2.5-1T-Zero produces highly structured and readable derivations without external formatting supervision.
  • AIME 2026: The AIME 2026 trace asks for ordered 7-tuples over {1, 2, 3} satisfying two congruence conditions modulo 3.
  • AIME 2026: The solution reduces each a_k to b_k = a_k mod 3 and defines S(b) and P modulo 3 to represent the two constraints.
  • AIME 2026: A double character-sum filter with ω = e2πi/3 is applied to enforce S ≡ 0 and P ≡ 0 modulo 3.
  • AIME 2026: The bijection b_k 7→ 2b_k and complex conjugation reduce the character sums to three real values requiring computation.
  • AIME 2026: Symmetry of P maps residue classes 1 and 2 bijectively, forcing n_1 = n_2 while n_0 + 2n_1 = 2187.
  • AIME 2026: The trace explicitly records Σ(0, 0) = 37 = 2187 as part of the remaining character-sum evaluations.

HMMT Feb 2026 · IMO AnswerBench

The section develops a divisor-lattice solution to the HMMT problem, obtaining minimum 499, and begins a graph-theoretic model for the IMO AnswerBench marketplace problem.

  • HMMT Feb 2026: Setting i = j yields |A_i| = i, while d | n implies A_d ⊆ A_n, so the sets form the divisor lattice of 250.The intersection condition gives |A_d ∩ A_n| = d = |A_d|.
  • HMMT Feb 2026: Möbius inversion decomposes each A_n into atoms B_d of size φ(d), with A_n formed by the union of atoms indexed by divisors of n.For 250 = 2 · 5^3, the eight atom sizes are 1, 1, 4, 4, 20, 20, 100, and 100.
  • HMMT Feb 2026: Because the atom sizes sum to 250, the integers {1, . . . , 250} can be assigned across the atoms, reducing the objective to choosing their filling order.Contiguous blocks minimize each atom’s maximum for its ordinal position.
  • HMMT Feb 2026: 499 is the resulting minimum of ∑d|250 max A_d.The sum is 1 + 2 + 6 + 10 + 30 + 50 + 150 + 250 = 499.
  • IMO AnswerBench: For the marketplace problem, each merchant’s k increasing transactions is modeled as k edges on n = 7396 stalls.The increasing constraint is incorporated into the transaction-graph model.
  • IMO AnswerBench: The increasing transaction constraint forces each merchant’s graph to be a forest, giving c = n − k connected components.This establishes the graph-theoretic structure used to analyze shared connectivity.
Loading 2607.12395v2…