InftyThink: Breaking the Length Limits of Long-Context Reasoning in Large Language Models
Authors: Yuchen Yan
Yongliang Shen
Yang Liu
Jin Jiang
Mengdi Zhang
Jian Shao
Yueting Zhuang
Venue: ICLR 2026 Poster (2026)
Keywords: LLM Reasoning
Context Management
Efficient Reasoning
Primary area: foundation or frontier models, including LLMs

Abstract: Advanced reasoning in large language models has achieved remarkable performance on challenging tasks, but the prevailing long-context reasoning paradigm faces critical limitations: quadratic computational scaling with sequence length, reasoning constrained by maximum context boundaries, and performance degradation beyond pre-training context windows. Existing approaches primarily compress reasoning chains without addressing the fundamental scaling problem.
To overcome these challenges, we introduce InftyThink, a paradigm that transforms monolithic reasoning into an iterative process with intermediate summarization. By interleaving short reasoning segments with concise progress summaries, our approach enables unbounded reasoning depth while maintaining bounded computational costs. This creates a characteristic sawtooth memory pattern that significantly reduces computational complexity compared to traditional approaches.
Furthermore, we develop a methodology for reconstructing long-context reasoning datasets into our iterative format, transforming OpenR1-Math into 333K training instances. Experiments across multiple model architectures demonstrate that our approach reduces computational costs while improving performance, with Qwen2.5-Math-7B showing 3-11% improvements across MATH500, AIME24, and GPQA_diamond benchmarks. Our work challenges the assumed trade-off between reasoning depth and computational efficiency, providing a more scalable approach to complex reasoning without architectural modifications.

Published as a conference paper at ICLR 2026
INFTYTHINK: BREAKING THE LENGTH LIMITS OF LONG-CONTEXT REASONING IN LARGE LANGUAGE MODELS
Yuchen Yan 1.2- Yongliang Shen', Yang ,iu?, Jin Jiang" Mengdi Zhang". Jian Shao', Yueting Zhuang' 'Zhejiang University "Meituan Group Peking University (yanyachen, syl)eze (rl))zju.edu.co
ABSTRACT
Advanced reasoning in large language models has achieved remarkable perfor- mance on challenging tasks, but the prevailing long-context reasoning paradigm faces critical limitations: quadratic computational scaling with sequence length, rea- soning constrained by maximum context boundaries, and performance degradation beyond pre-training context windows. Existing approaches primarily compress rea- soning chains without addressing the fundamental scaling problem. To overcome these challenges, introduce InftyThink, paradigm that transforms monolithic reasoning into an iterative process with intermediate summarization. By inter- leaving short reasoning segments with concise progress summaries, our approach enables unbounded reasoning depth while maintaining bounded computational costs. This creates characteristic sawtooth memory pattern that significantly duces computational complexity compared to traditional approaches. Furthermore, we develop a methodology for reconstructing long-context reasoning datasets into our iterative format, transforming OpenR 1-Math into 333K training instances. Experiments across multiple model architectures demonstrate that our approach re- duces computational costs while improving performance, with Dwen2.5-Math. showing 3-1 11% improvements across MATH500, AIME24, and GPQA_ diamond benchmarks. Our work challenges the assumed trade-off between reasoning depth and computational efficiency, providing a more scalable approach to complex reasoning without architectural modifications.
GPQA_diamond
Project Page: https://jooreallgiiubbbi//////ii
INTRODUCTION
Recent studies have demonstrated the remarkable reasoning capabilities of large language models
(LLMss) with models like OpenAl ol (OpenAl 2024), DeepSeek-RI (Guuo et al., 2025). Gemini
2.0 Flash Thinking (Google DeepMind, 2025) QwQ (Qwen Team (024). and Kimi- 1.5 (Kimi
Team et al. 2025) surpassing human performance on high-difficulty tasks including mathematical
competitions (Latif al. 2024b a). These advanced reasoning models are typically developed through methodical techniques such as test-time scaling (Chen et al.] 2024 Wan et al.) [2024] Guan et al.
2025 Muennighoff et al. 2025), post-training on long-thought trajectories (Guo et al.| 2025 Ye et al.
2025
Open Thoughts Team 2025), or large-scale reinforcement learning (Guo et al. 2025 Shao
al. 2024) to generate effective reasoning paths that reach correct answers. defining characteristic
of these models is their ability to perform long-contess reasoning, demonstrating advanced cognitive analysis, self-reflection, and error correction (Zeng al. 2024 Zhong al. 2024). This evolution from simpler reasoning patterns to extensive deliberation has significantly improved problem-solving capabilities, particularly for complex challenges requiring multi-step inference.
techniques including intent comprehension, multi-perspeen
"Contribution during internship at Meituan Group.
'Coresponding author.

---

Published as a conference paper at ICLR 2026
Confext Length
Model's max length
Model's max length
MATH500
Context Length
AIME24
Stop reasoning due to length limit
UPQA_diamont
Pass (a55
Infinite reasoning
Vanilla
Prompt length
Prompt length
InftyThink
Total Tokens
Total Tokens
Inference Latency (second)
(a)
(b)
Figure I: (a) Computational complexity comparison between vanilla long-context reasoning (blue, left) and InftyThink (orange, right). The sawtooth pattern of Infty'Think demonstrates how periodic summarization creates a bounded memory footprint, substantially reducing computational costs (smaller area under curve) while enabling deeper reasoning. (b) InftyThiink (+) reduces reasoning latency while simultaneously improving reasoning performance compared to the vanilla long-context reasoning (+).
However, this substantial improvement in reasoning quality comes with significant computational costs (OpenAl 2024 Brown et al. 2024 Snell et al., 2024). The computational complexity of decoder-based LLMs grows quadratically with sequence length, resulting in prohibitive resource re- quirements for form reasoning. This efficiency bottleneck manifests in three primary challenges: First, current reasoning models often generate thousands of tokens even for moderately complex problems (OpenAl 2024 Wang et al.) 2025), creating substantial memory and processing overhead during inference. Second, reasoning processes are constrained by the model's maximum context length (aka. max_lengs fails to reach conclusive answers (See analysis in Appendix E). Third, most LLM architectures are pre-trained with relatively small context windows (4k-8k tokens), causing performance degradation when reasoning extends beyond these boundaries
(Kuratov al. 2024), frequently resulting in truncated reasoning that
(Li et al. 2024b Yuan et al. 2025).
Existing approaches (Pang et al. 2024 Han et al., 2025 Zhang et al., 2025b) to address these limitations have explored various solutions with mixed success. Some methods attempt to compress reasoning chains pest-generation (Xiao et al.] 2023) /Zhang et al., 2023) Chen al. 2025), while others aim to train models to reason more concisely from the outset (Kang et al. 2024] Arora &
Zanette 2025 Liu et al. 2024 Xia et al. 2025). Chain-compression techniques like those employed in CoT Valve (Ma et al. (0225) show promise but require predefined compression ratios during training, limiting their flexibility at inference time. TokenSkip (Xia et al. 2025) reduces redundant tokens by assessing each token's significance, though this impacts the model's 's reasoning performance. LightThinker (Zhang et al.) 20255) employs special tokens to dynamically compress the CoT process into a latent representation but lacks the ability adaptively determine compression requirements for each step. Despite these advances, most approaches still operate within the traditional paradigm of generating single, continuous reasoning chain, which merely attempting make it more compact without addressing the fundamental computational scaling problem (A more detailed review of related work in Appendix C). This raises a critical question: Instead of optimizing within the constraints of monolithic reasoning, could we improve the model's accuracy and efficiency by altering its inherent reasoning paradigm?
In this paper, we propose a fundamentally different approach to long-context reasoning. Rather than viewing reasoning as a single extended process, we introduce InftyThink, a novel paradigm that divides complex reasoning into multiple interrelated short reasoning segments. Each segment remains within a computationally efficient context length while maintaining the coherent flow of thought across iterations. This approach draws inspiration from human cognitive processes, where complex frequently involves breaking problems into manageable parts and summarizing intermediate progress.
2

---

Published as a conference paper at ICLR 2026
The core mechanism of Infty is an iterative process where the model generates partial reason- ing chain, summarizes its current thinking, and builds upon these summaries subsequent iterations. As illustrated in Figure [] traditional approaches (left, blue) face inevitable termination when context length reaches the model's maximum limit, often before completing the reasoning. In contrast, InftyThink (right, orange) creates sawtooth pattern through periodic summarization, enabling bounded reasoning depth while maintaining a bounded memory footprint. This approach both reduces computational complexity (smaller area under the curve) and overeomes the fundamental ceiling on reasoning depth imposed by context length constraints. Beyond computational efficiency, Infty Think offers a crucial advantage: it enables reasoning of arbitrary depth without architectural changes to the underlying model. By summarizing and building upon previous reasoning in manageable segments, models can effectively navigate complex problem spaces that would otherwise exceed context limitations.
To validate our approach, we reconstructed the existing SFT dataset OpenR1-Matte which was distilled from DeepSeck-RI, adapting it to conform to proposed InftyThink paradigm. This recon- struction process transformed the original long-form reasoning examples into multiple interconnected reasoning segments with corresponding summaries. We then fine-tuned multiple base architectures this reconstructed dataset and conducted comprehensive comparisons against traditional single-round long-context reasoning methods. Our experimental results demonstrate consistent improvements across various benchmarks, with Qwen2.5-Man improvement on AIME24, and 9% improvement on GPQA diamond.
showing 2% improvement on MATH500, 11%
Our contributions are summarized as follows:
We introduce Think, which transforms monolithic long-form reasoning into iterative reasoning with summarization, mimicking human working memory patterns and reducing the quadratic computational complexity of wansformer-busee models to more manageable form.
We develop technique to reconstruct existing long-context reasoning datasets (demonstrated on OpenR1 M-athh) into our iterative format, preserving reasoning quality while enabling more efficient computation without specialized architectures.
Across multiple model architectures, our approach achieves significant improvements while sub- stantially reducing computational costs, challenging the assumed rrfe between reasoning depth and efficiency.
2
METHODS
In this section, we present InftyThink, a novel reasoning paradigm that addresses the context limit and computational inefficiency of vanilla long-context reasoning in large reasoning models. First, we formalize our proposed iterative reasoning framework that enables unbounded reasoning depth while maintaining bounded memory footprint (Section 2.I). Then, we detail a principled approach for reconstructing existing long-context reasoning datasets to conform to our paradigm (Section 2.2
2.1 INFTYTHINK REASONING PARADIGM
To address the computational challenges inherent in long-context reasoning, propose InftyThink a novel paradigm that re-imagines how LLMs approach complex reasoning tasks. This paradigm decomposes complex reasoning into series of bounded-length segments with intermediate summa- rization steps, enabling theoretically unlimited reasoning depth without the quadratic computational scaling of traditional approaches. Figure 2 illustrates the key differences between our approach and vanilla reasoning. Below, we first formalize the conventional reasoning approach before presenting our iterative framework.
2.1.1 VANILLA PARADIGM OF LONG-CONTEXT REASONING
Contemporary reasoning models, particularly those in the class DeepSeek-RR and similar architec- tures, rely extended single-round generation for complex reasoning tasks. These models generate content comprising two principal components: a comprchensive "thinking" phase that captures the exploratory reasoning process, followed by "conclusion" phase that distills key insights into
3

---

1), the model builds upon previous reasoning by incorporating the Published as a conference paper at ICLR 2026
Long-context
Question
<think>
</
thinik
Conclusion
CoT
Iter
Question
<think>
</think>
Summary (1)
Iter
Question
Summary (1)
<think>
</think>
Summary (2)
Iter
Question
Summory [2]
<think>
</think>
Summary (3)
Iter n-1
Question
Summary (n-2)
<think>
</think>
Summary (n-1)
Final Iter n
Question
Summary (n-1)
<think>
</think
Conclusion
Figure 2: Illustration Infty versus vanilla long-context reasoning. Upper panel: Vanilla long-context reasoning generates continuous tokens until reaching maximum context length. Lower panel: Our InftyThini approach divides reasoning into multiple iterations. The underlined segments represent content included in the prompt model input, while non-underlined segments show model- generated output. Each iteration in InftyThink consists of: (1) summarizing previous reasoning progress, (2) generating focused reasoning segment within an efficient token budget, and (3) producing concise progress summary. This iterative process enables arbitrarily deep reasoning chains without architectural modifications to the underlying model, while maintaining significantly lower computational complexity compared to traditional approaches.
structured response. This conventional reasoning paradigm can be formalized as:
<I0i>Q< < |A] >sthink> BaaiiikkKKPPP// /Pt/ttink/CCCC
where < <IU)> > and < A are usually special tokens defined in the chat template to mark the dialogue structure, Q denotes the user query, <think> and </think> encapsulate the model's 's reasoning process RPP, and the final conclusion C synthesizes the reasoning into coherent answer. The underlined part represents the model's output, while the rest serves as the prompt input to model.
This established approach, while effective for many problems, faces fundamental limitation: as reasoning complexity increases, the token length of RP grows substantially, often exceeding context window constraints and incurring quadratic computational costs. To address this limitation, introduce InftyThink, paradigm that transforms monolithic reasoning into an iterative process with intermediate summarization steps.
2.1.2 ITERATIVE REASONING WITH SUMMARIZATION: INFTYTHING
In the Infty Think paradigm, reasoning proceeds through multiple connected segments, each main- taining computational efficiency while preserving the coherent progression of thought. The initial reasoning iteration is formalized as:
<IUi> - < ><hhink>>>> Reiee>RPs<//tttt </thin/k
<summary>
where R.,, represents the first segment of reasoning constrained efficient length, and S denotes a concise summary of this segment encapsulated by the special tokens <summary> and summaryy. This summary serves compressed representation of the reasoning state, capturing essential information while discarding unnecessary details.
For subsequent iterations prior summary:
suunnaryy>
where <history> and </history> delimit the previous summary S,-1. which provides critical context for the current reasoning segment RP: Each iteration maintains a bounded token length while building upon accumulated knowledge through the summary mechanism.
4

---

Published as a conference paper at ICLR 2026
new
Partitioo by #tokens based
Question(Q)
RP_
SL
RP
Reasoning Process (RP)
II. Generate summaryy
Vonilla-style
Conclusion(C)
Summary.i
InfryThinkkstylee
Figure 3: Systematic pipeline for reconstructing vanilla-style long-context reasoning data into the mnftyThink-styl format. I. Original reasoning processes are partitioned into optimally sized fragments based on parameter (77). preserving semantic coherence. II. Meta-Llamaa-.3-777 concise yet comprehensive summaries for each reasoning fragment. III. The original fragments and their generated summaries are systematically recombined create InftyThink -ttle training instances that teach the model to reason iteratively.
generates
The final iteration (n) culminates in a conclusion rather than another summary:
<
Throughout these expressions, blue denotes reasoning segments, orange represents intermediate summaries, and green indicates the final conclusion. This formulation elegantly handles edge cases: when problems simple enough be solved in a single iteration, the model bypasses summary generation, defaulting to the vanilla paradigm.
During inference, the model iteratively generates reasoning segments and corresponding summaries, with each summary becoming the context for the subsequent iteration. This process continues until the model produces conclusion instead of summary, signaling completion of the reasoning task. To prevent potential infinite loops, we impose hyperparameter max_iten iters that terminates iteration exceeded, though our empirical results indicate that well-tran trained models naturally converge within reasonable number of iterations.
2.2 DATA RECONSTRUCTION
While our InftyThink paradigm offers a theoretically compelling approach to unbounded reasoning, it requires appropriate training data to enable models to learn this iterative reasoning process. Prior work has established that models can acquire sophisticated reasoning capabilities through supervised fine-tuning data generated by highly capable reasoners (Guo et al.) 2025 open-rl I (025). Building
on this insight, we develop principled methodology for transforming existing long-context reasoning datasets into iterative format.
We select 1 (open-rl 2025 as our source dataset, which is collection of mathematical reasoning generated by DeepSeek-RI response to questions from NuminaMath-1.5 (Jia Li et al. 2025). This dataset spans diverse spectrum of mathematical domains and difficulty levels, from elementary mathematics to competition-level problems, making it ideal testbed for our approach.
In addition, we also performed similar data reconstruction and related experiments on the OpenThoughts (Guha et al. 2025) dataset to demonstrate the robustness of our method. Detailed results are provided in Appendix M We also report the resource consumption of the data construction process in Appendix Gi enabling researchers assess the feasibility of adopting our method.. Our reconstruction pipeline comprises three key stages:
Step I: Reasoning Process Partition For each instance the datasct, we partition the original reasoning process (RP) into segments based on hyperparameter 77 that determines the maxi- mum token length of each segment. Rather than applying arbitrary truncation, we implement a semantically-aware segmentation algorithm: first decompose the reasoning process into semantic
All data usage in this paper is full compliance with the and conditions of the Apache License 2.0.
5

---

Published as a conference paper at ICLR 2026
units by identifying natural breakpoints at sentence paragraph boundaries. These units are then tokenized and sequentially aggregated into segments, optimizing for coherence while ensuring each segment remains below the 7) threshold. This process yields sequence of reasoning segments RP1, .P....., RPa. formally expressed as: Partition[RP,r)
RP1, RP2,....... R.,
(I)
Step II. Summary Generation For each reasoning segment, we generate a concise summary that captures its essential insights and progress toward the solution. To ensure information continuity across iterations, we employ a sophisticated foundation model M (specifically leta-Llama-3.3- provide performance comparison of
70B I0B-Instruct (Grattafiori et al. 2024), and in Appendix summary generation using different foundation models. The experimental results demonstrate that the size of the summarizer model has significant impact on the performance of InftyThink.) with carefully crafted prompting (provided in Appendix Pp:
S summarize M, RP,, (RP.....,RP......
(2)
The summarization model receives not only the current reasoning segment RP; but also all preceding segments and their summaries, enabling it to create summaries that maintain reasoning continuity. In the Appendix ! we further examine the necessity of preserving a global summary throughout the reasoning process. Our analysis substantiates the design choice of constructing S; from the cumulative reasoning trajectory .R.,...., RP.), confirming that this formulation both reasonable and essential for maintaining global coherence in the Infty'Think paradigm.
Step III. Training Instance Construction From the segmented reasoning and generated summaries, construct training instances that teach the model to perform iterative reasoning with summarization. These instances follow the structure of our ahink paradigm:
(Q, SI)
for i = 1, for 1 < i <<< n,
Dj = RP,
(Q,S.-1, M2,, C) for i --i-- n1.
For the initial reasoning step (i = 1), the model learns to generate the first reasoning segment followed by its summary. For intermediate steps (1 < < n), it learns continue reasoning based on previous summaries and generate new summaries. For the final step (i = n1), it learns to produce conclusive answer. This reconstruction process transforms each original example into training instances, where n is the number of reasoning segments. The complete pipeline is illustrated in Figure Applying this methodology the OpenRI-Man -Math dataset with 7-4k, we expand the original 220K examples into 333K training instances, forming our nttyy OpenR1 - dataset. This dataset enables models learn the InftyThink approach through supervised fine-tuning. Since our method generates additional data samples, we provide a detailed discussion in Appendix and and demonstrate that such a comparison both fair and reasonable.
EXPERIMENTS
3.1 SETTINGS
We employ instruction fine-tuning to validate the proposed reasoning paradigm and associated dataset.
Specifically, akin the distilled model discussed in DeepSeek-R1 (Guo al.) 2025). ) training is
conducted on five base models of varying sizes: Qwen2.5-Math-1
Qwen2.5 5-Math--7B (Yang
al. 2024), Qwen2.5-14B, Qwen2.5-32B (Qwen al. 2025), and Meta-Llama-3.1 1-88B (Grattatioii et al. 2024). and two instruct models: 1
and SeepSeek-RI-Disttie Qwen- (Guo al. (025).. Instruction- based fine- fine-tuning is applied using both OpenR -Math (for vanilla) and the newly introduced OpenR --Mthh Inf (for InftyThink). The hyperparameters are configured with 7) set to 4k and max max_ite itters 3 set to 10. The detailed experimental setup is provided in the Appendix [ The trained models are evaluated across multiple benchmarks, including
MATH500 (Hendrycks et al., |021 Lightman et al. 2023). AIME24, and GPQA_diamont (Rein) al. 2024). We also provide evaluations
more challenging benchmarks in Appendix K including AIME25, Math Odyssey (Fang et al. 2025). and AMC23 (mathai 2023). To demonstrate the broad applicability, we also conducted evaluations on code tasks like HumanEval (Chen al. 202 l) and
MBPP (Austin et al. 202I), presented in Appendix Mnd N In addition, we conducted a stability
analysis of the training and evaluation process, and the results are presented in Appendix !

---

Published as a conference paper at ICLR 2026
Table I: Our main experimental results. The results are obtained by sampling the model 16 times with temperature of 0.7. ACC stands for average accuracy(%), TOK stands for average number of generated tokens (K), and LAT stands for average inference wall time seconds.
MATH500
AIME24
GPQA_ diiamond
Average
Model
Train Format
ACC1 TOK LAT ACC1 TOK LAT ACC1 TOK LAT
ACC1 TOK LAT
Base Models
Qwen2.5-Math-L.5B
Vanilla
75.24
5,94
1.42
16.04
16.03
3.75
26.48
10.51
2.44
59.54
7.60
1.79
Infty Think
79.57
6.79
0.80
26.04
20.16
2.88
35.89
10.59
1.83
65.48
8.38
1.17
Qwen2.5-Mat-77
Vanilla
89.51
4.32
1.26
32.92
14.26
4.15
43.94
8.95
2.39
5.99 78.92
74.78
1.69
InftyThink
91.29
4.72
0.76
43.96
22.11
4.66
52.97
9.54
2.63
6.75
1.43
Llama-3,
Vanilla
82.10
5.50
2.58
20.83
16.70
10.01
41.35
10.33
5.02
68.49
7.27
3.55
InftyThinkk
82.28
6.28
2.35
34.17
20.87
12.99
47.51
10.30
4.81
70.84
7.97
3.46
Qwen2.5-14B
Vanilla
93.86
3.88
1,49
48.75
13.87
11.30
57.42
7.71
3.24
82.09
5.33
2.37
InityThink
93.07
3.38
1.43
51.67
18.66
7.11
59.44
9.04
3.08
82.22
5.55
2.11
Qwen2.5-32B
Vanilla
96.24
2.51
1.91
57.11
11.96
13.43
63.45
7.07
4.31
85.71
4.14
3.04
InftyThink
95.75
3.84
1.48
64.38
16.18
8.88
68.18
7.86
4.14
86.93
4.99
2.58
Instruct Models
Swen2.5-Math-11 (-Instruct)
75.11
0.55
0.03
8.54
0.97
0.08
25.32
1.19
0.51
58.82
0.74
0.16
Vanilla
73.99
3.89
1.64
11.67
17.49
5.16
17.77
12.42
3.51
56.13
6.77
2.29
Think
81.10
6,51
0.87
26.04
20.05
3.20
27.87
12.10
2.59
64.35
8.59
1.43
R1-distill- RI-distil--wwen-1.5 Qwen-1.eenn//
85.00
5.25
1.10
22.50
17.92
5.41
37.18
8.29
1.59
69.42
6.59
1.41
Vanilla
85.54
5.07
1.09
24.79
14.03
3.18
34.69
10.01
2.32
69.21
6.78
1.51
InftyThini
88.06
5.75
0.89
29.38
21.37
4.96
35.54
12.80
1.21
71.36
8.31
1.14
3.2
MAIN RESULTS
Table 1 presents our comprehensive evaluation of InftyThiink across five base model architectures and two instruct model architectures of varying scales and specializations. We provide several actual reasoning trajectories of vanilla CoT and InftyThhink style on MATH500, AIME24, and GPQA_diamond the Appendix [ to facilitate clearer understanding of how InftyThink works. Several important patterns emerge from these results that provide insight into how our proposed reasoning paradigm affects model performance.
Consistent Improvements Across Model Families and Scales. Our Think consistently out- performs the vanilla reasoning approach across all model sizes and architectures. Notably, the improvements generalize beyond the Qwen architecture family Meta-Llama-33 -aae--m-m-----8. demonstrating that the benefits of our iterative reasoning paradigm are not architecture-specin but rather represent fundamental improvement in how models approach complex reasoning.
Extended Reasoning Depth and Decreased Inference Latency. InftyThink mitigates the compu- tational overhead associated with the O(n²) complexity of LLMS extended inference lengths by decomposing single long generation into multiple shorter generation steps. This approach con- sistently enhances throughput across LLMs of varying parameter scales. Furthermore, the iterative mechanism inherent in InityThink allows models to efficiently handle extended reasoning tasks, maintaining high inference speed even as the generation length significantly increases. We further discuss this aspect in Appendix [
Scaling Trends with Model Size. We observe an interesting relationship between model scale and the magnitude of improvement from InftyThink. The relative gains are most pronounced in smaller models (e.g., 4.33%, 10.00%, and 9.41% improvements for Qwen2.5-Math- 1.5B on the three benchmarks) and gradually diminish as model size increases, particularly the MATH500 benchmark. This suggests that InftyThink provides a form of algorithmic enhancement that partially compensates for limited model capacity, effectively allowing smaller models to perform more complex reasoning than their size would typically permit.
The iterative summarization mechanism in InftyThink appears effectively mitigate the limitations of traditional long-conte reasoning by enabling more structured exploration of the solution space. The pattern of improvements suggests that our approach particularly benefits complex problems
7

---

Published as a conference paper at ICLR 2026
requiring multi-step reasoning, which are precisely the scenarios where long-conters reasoning is most challenged by computational constraints. Our findings also suggest important implications for model scaling: InftyThink may offer more computationally efficient path to improved reasoning capabilities than simply scaling model size, particularly for smaller models where the relative improvements most pronounced. This could have significant practical implications for deploying advanced reasoning capabilities in resource-constrained environments.
ANALYSIS
4.1
ENDOWING SHORT-CONTEXT MODELS WITH LONG-CONTENT REASONING ABILITY
Many foundational LLMs are pretrained with limited context windows (4k or 8k tokens), yet significant portion of reasoning datasets exceeds these boundaries. Analysis of OpenRI-Mate shows only 54% of samples contain fewer than 4k tokens, and 83% are within 8k tokens (Appendix D) revealing a critical mismatch between model architecture and reasoning requirements.
Table D shows consistent performance improvements when applying InftyThimi across all model configurations. The gains are particularly notable on complex benchmarks like AIME24 and GPQA_diamond, where problems typically require longer reasoning chains that would exceed standard context windows. For instance, Qwen2.5-Math-75 achieves a 11.04% improvement on AIME24 and a 9.03% improvement GPQA _ddamon using approach. These improvements suggest that InftyThint effectively addresses context length limitations by restructuring long reasoning into manageable segments with summarization.
To validate our approach against alternative context extension methods, we implemented RoPE positional encoding interpolation (Su et al. 2023 Chen et al. 2023 kaiokendev 2023), common technique for extending context windows beyond pretraining lengths. While this approach yielded modest improvements, it consistently underperformed compared to InftyThiikk across all benchmarks (detailed results in Appendix Q This comparison is particularly revealing: rather than attempting stretch architectural limitations through embedding manipulation, Infty restructures the reasoning process itself to work within existing constraints.
These findings suggest that InftyThine offers more effective solution to the long-context reasoning challenge than traditional context window extension techniques. By allowing models to periodically summarize and build upon previous reasoning, our approach enables more flexible and adaptable reasoning capabilities that aren't 't bound by fixed architectural constraints. This has important implications for deploying reasoning systems in environments where context length would otherwise be a limiting factor.
4.2 INFLUENCE OF CONTEXT WINDOW SIZE PARAMETER 7]
Parameter plays crucial role in Infty Think, controlling the maximum token length for each reasoning iteration. This parameter creates fundamental tradeoff:: larger values reduce the number of iterations but increase per-iteration computational cost, while smaller values distribute computation more evenly but potentially fragment reasoning.
Table presents performance across three values (2k, 4k, and 6k) on benchmarks, with all configurations consistently outperform the baseline with no clear optimal value across datasets. On MATH500, performance increases marginally with 7), suggesting that longer unin- terrupted reasoning benefits simpler problems.
Table 2: Evaluation results across different GPQA D refers to aPQAA_diamon Experiments are conducted on Qwen2.5-Math.
Method
" MATH500 AIME24 GPQA_D D
Vanilla
89.51
32.92
43.94
These results challenge the intuition that frag- mented reasoning necessarily harms perfor- mance. Even with 7=2k, where reasoning is interrupted every 2k tokens, InftyThink main- tains or improves performance across all benchmarks. This suggests that well-designed summarization mechanisms effectively preserve critical information while discarding redundant computation.
2k 90.84+1.3
38.2945.37
48,9645.02
Infty Think
4k 91.29+1.75
43.96-11.04
52.97+9.03
6k 91.16+1.6
39.29+6.37
49.87+5.93
8

---

Published as a conference paper at ICLR 2026
MATH500
AIMEZ4
GPQA diamond
50
90
16K
1.6
00
40
Accuracy
04
85
8k
20
30
4k
20-
n-
6k
24
11-46
6t
10
0
10
4
10
Iteration
of iteration
of iteration
Figure 4: Model performance across iterations compared vanilla reasoning. Horizontal lines represent vanilla long-context reasoning with different max_new_tokeng settings (4k, 8k, 16k). Curves show InftyThink's accuracy evolution across iterations under different 1) settings (2k, 4k, 6k). The data points in the figure represent the accuracy of the model under each corresponding setting when allowed up to n iterations, including those reasoning trajectories that finished in fewer than iterations. Think rapidly surpasses fixed-length reasoning constraints, with performance continuing to improve beyond traditional token limits. Experiments conducted on Qwen2.5- --t255---
The robustness different 7 values demonstrates that Infty Think's benefits derive primarily from its iterative summarization approach rather than specific segmentation boundaries. This flexibility allows practitioners to select 1y values based on hardware constraints or specific application requirements without significant performance penalties. A larger reduces the number of summarization steps and better leverages existing GPÚ optimizations, while smaller 17 reduces the number of generated tokens per iteration, helping maintain a lower GPU memory footprint.
4.3 PERFORMANCE ACROSS REASONING ITERATION ROUNDS
A defining characteristic of InftyThink is its ability transcend the constraints of maximum context length through iterative reasoning with summarization. Figure quantifics this capability by tracking performance across reasoning iterations and comparing it against traditional reasoning methods with fixed token limits. In Appendix D we report the model's performance dynamics on AIME25, AMC23, and Math Odyssey across inference iterations. The results reveal three key insights:
Progressive performance improvement. Unlike traditional reasoning approaches that hit perfor- mance ceiling determined by their maximum token limit, Infty Think enables continuous improvement through successive iterations. On AIME24, a challenging benchmark, performance steadily increases from iterations 1 through 10 for all settings, demonstrating that complex problems benefit substan- tially from extended reasoning beyond conventional context limits.
Efficiency of iterative summarization. Even with the smaller context setting of ry=2k, InftyThink eventually reaches comparable performance to larger 7) values across all benchmarks. This is particularly evident on AIME24, where by iteration 10, the 7/2k configuration approaches the performance of 76=6 despite using reasoning segments one-third the size. This demonstrates that effective summarization can preserve critical reasoning information even with frequent compression. At different values of 77. as n increases, the model can gradually activate its internal reasoning capabilities and effectively solve the problem. We observe that models with 1p=2k require more iterations to reach the performance level those with y=4k or nk
Etrly-stage performance tradeoffs. Models with larger 1) values (6k) consistently outperform those with smaller segments (2k) in early iterations across all benchmarks. However, this advantage diminishes and sometimes reverses in later iterations, particularly on GPQA diamond where 7=4k eventually surpasses 7=ōk. This suggests that while larger segments provide initial advantages, they may commit the model to reasoning paths that become difficult to revise, whereas smaller segments allow more flexible exploration multiple iterations.

---

Published as a conference paper at ICLR 2026
4.4 ABLATION ON PROMPT- PROMPT-BASED PIPELINE
Our work introduces a data construction pipeline that converts vanilla CoT-formatted reasoning traces into the InftyThink format. Fine-tuning LLMs these reconstructed datasets enables transition from the vanilla COT paradigm to the iterative InftyThink reasoning paradigm. A central question is the extent to which training contributes this transition. sppcificin.s.ciicclllll.... whether purely prompt-based approach could suffice. That is, can we summarize intermediate reasoning within fixed window, propagate these summaries forward, and induce iterative reasoning without any additional training? To investigate this, we design an ablation experiment to evaluate the necessity of both our data reconstruction method and the fine-tuning process.
Concretely, we take DeepSeek-R 1iiittill-1.5B as the base reasoner model and let it perform standard vanilla-style reasoning. Once the generated reasoning reaches a predefined length 1/, we truncate its output and feed the completed portion into a summarizer model to produce summary. We then prompt the reasoner to continue reasoning conditioned on this summary, iteratively generating new summaries and continuing the reasoning until completion. In our setup, the hyperparameter is fixed at yj4k. We additionally evaluate Qwen2.5-1.55 1.55-tttctt and Hamma..-70B-Innse as summarizers. The full experimental results are presented in Table 3
Table 3: Ablation results (%) of training-free prompt-based iterative reasoning.
Reasoner model
Summarizer model
MATH500
AIME24
GPQA D
Training based approaches
RI-distill- Qwen- 1.5B (luned on OpenRI-Math -aath) InftyThink
85.54
24.79 29.38
34.69
88.06
35.54
Training-free approackes RI -istiill -wlll---eee-- 1.5B (tuned on OpenRI-Math) 1-Math)
RI ---distill-Qwen-- 11..2..5-1.BBInttteee 82.97
83.63
26.85
26.76
20.45
30,92
1emma3.3-70BInsstiee 84.14
26.65
31.88
From our experimental results, directly applying a prompt-based method to implement iterative reasoning leads to slight performance drop. The primary reason is that this inference paradigm is not extensively trained and thus deviates from the patterns the model was exposed to during training. As result, the model may lose important information across multiple reasoning iterations, preventing it from fully leveraging its intrinsic reasoning capability.
In addition, we observe that implementing InftyTTiik via prompt-based approach introduces significantly higher latency compared to a training- based approach. Each iteration requires extracting the current reasoning trace and generating additional summary, which increases the overall computational load during inference and undermines the efficiency gains that Infty Think is designed to provide in reducing inference wall-time.
CONCLUSION
In this paper, we introduced InftyThink, novel reasoning paradigm that transforms monolithic long-context reasoning into an iterative process with periodic summarization. By generating partial reasoning, summarizing current understanding, and building upon these summaries in subsequent iter- ations, our approach effectively addresses the quadratic computational complexity and context length limitations of conventional approaches. Experiments across multiple model architectures demonstrate consistent performance and throughput improvements on challenging reasoning benchmarks, Our analysis confirms that Infty InftyThink not only reduces computational costs but also enables models to transcend their native context window limitations without architectural modifications. We further discuss the limitations of Infty/Think and its future directions Appendix [ Infty'Think paradigm represents a step toward more cognitively plausible AI reasoning through iterative refinement rather than exhaustive single-pass analysis, opening promising avenues for more efficient, flexible reasoning in language models that decouples reasoning depth from computational complexity.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGEMENT
This work was supported by National Natural Science Foundation China (No. 62506332).
ETHICS STATEMENT
This work does not involve human subjects, personal data, or sensitive information. All datasets used in our experiments are publicly available datasets designed for evaluating mathematical reasoning in LLMs. strictly adhered to ethical research practices and did not conduct any data collection that could raise privacy, security, or fairness concerns. Our methods do not introduce risks of harmful applications. To the best our knowledge, this research complies with the ICLR Code of Ethics and poses no foreseeable ethical concerns.
REPRODUCIBILITY STATEMENT
We provide the implementation of InftyThiink in the supplementary materials, including scripts for data paradigm conversion and inference code, to facilitate the adoption our method by researchers. In addition, we will release open-source version of InftyThinke Think-hii-tt data.
Regarding experiments and evaluations, we include detailed descriptions of our training and evaluation procedures in Appendix O enable researchers to reproduce our work.
REFERENCES
Pranjal Aggarwal and Sean Welleck. L1: Controlling how long reasoning model thinks with reinforcement learning. In Second Conference on Language Modeling, August 2025.
Daman Arora and Andrea Zanette. Training language models to reason efficiently. In The Thirty-Ninth Annual Conference Neural Information Processing Systems, October 2025.
Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, et al. Program synthesis with large language models, August 2021.
Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V. Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling, July 2024.
Guoxin Chen, Minpeng Liao, Chengxi Li, and Kai Fan. Alphamath almost zero: Process supervision without process. In The Thirty-Eighth Annual Conference Neural Information Processing Systems, November 2024.
Guoxuan Chen, Han Shi, Jiawei Li, Yihang Gao, Xiaozhe Ren, et al. Sepllm: Accelerate large language models by compressing one segment into one separator. In Forty-Seconde International Conference on Machine Learning, June 2025.
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, et al. Evaluating large language models trained code, July 2021.
Shouyuan Chen, Sherman Wong, Liangjian Chen, and Yuandong Tian. Extending context window of large language models via positional interpolation, June 2023.
Jeffrey Cheng and Benjamin Van Durme. Compressed chain of thought: Efficient reasoning through
dense representations, December 2024.
Meng Fang, Xiangpeng Wan, Fei Lu, Fei Xing, and Kai Zou. Mathodyssey: Benchmarking mathe- matical problem-solvine skills large language models using odyssey math data. Scientific Data, 12(1):1392, August 2025. ISSN 2052-4463. doi:
Jonas Geiping, Sean Michael McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, et al. Scaling up test-time compute with latent reasoning: A recurrent depth approach. The Thirty-Nimth Annual Conference Neural Information Processing Systems, October 2025.

---

Published as a conference paper at ICLR 2026
Google DeepMind. Gemini flash thinking. thinking/, 2025.
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, et al. The llama 3 herd of models, November 2024.
Xinyu Guan, Li Lyna Zhang, Yifei Liu, Ning Shang, Youran Sun, et al. rstar-math: Small Ilms can master math reasoning with self-evolved deep thinking. Forty-Second International Conference on Machine Learning. June 2025.
Etash Kumar Guha, Ryan Marten, Sedrick Keh, Negin Raoof, Georgios Smymis, et al. Openthoughts: Data recipes for reasoning models. In The Fourteenth International Conference Learning Representations, October 2025.
Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, et al. Deepseck-coder: When the large language model meets programming the rise of code intelligence, January 2024.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, et al. Deepseek-rl incentivizes reasoning ilms through reinforcement learning. Nature, (55(888))6633-66 September 2025.
ISSN 1476-4687. doi: 10.
Tingxu Han, Zhenting Wang, Chunrong Fang. Shiyu Zhao, Shiqing Ma, et al. -aket-budgee-aware IIm reasoning. In Findings of the Association for Computational Linguistics: ACL 2025, pp. 14842-24855 Vienna, Austria, July 2025. Association for Computational Linguistics. ISBN doi: 10. 16653/v1/2025.fmm
979-8-891766 194-8-8917-226-55
acl. 1274.
Shibo Hao, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason E. Weston, and Yuandong Tian. Training large language models to reason in a continuous latent space. In Second Conference on Language Modeling, August 2025.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, al. Measuring mathematical problem solving with the math dataset. In Thirty- Fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), August 2021.
Jie Huang and Kevin Chen-Chuan Chang. Towards reasoning in large language models: A survey. In Anna Rogers, Jordan Boyd-Grabes and Naoaki Okazaki (eds.), Findings of the Association for Computational Linguistics: ACL 2023, pp. 1049-1065, Toronto. Canada, July 2023. Association for Computational Linguistics. doi: 10. 10.18853/v1/20222 120.:///i//22.....nnnng--aa aaddingg-acl.67.
Jia LI, Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, et Numinamath- 1.5. htt.://gggggggggacooootttttt////
https:/hugginggacc.. wwt.////oo/////...c. Saaitttttes/AA-MMO//nnmaaaaaa MONN//nnaaaah Februur 2025.
Jin Jiang, Yuchen Yan, Yang Liu, Jianing Wang, Shuai Peng, et al. Logiepro: Improving complex logical reasoning via program-guided learning. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). pp. 26200-26218, Vienna, Austria, July 2025. Association for Computational Linguistics. ISBN 979-8-89176-251--0 doi:
10.18653/w1/2025 a.c.--l--aa acl-long. nol.long.1170. 1270.
kaiokendev. Things i'm learning while training superhot. http://kaiikendee.githhb.iioo 2023.
Yu Kang, Xianghui Sun, Liangyu Chen, and Wei Zou, C3ot: Generating shorter chain-of-thought without compromising effectiveness, December 2024.
Kimi Team, Angang Du, Bofci Gao, Bowei Xing, Changjiu Jiang, et al. Kimi k1.5: Scaling reinforcement learning with 1lms, January 2025.
Yuri Kuratov, Aydar Bulatov, Petr Anokhin, Ivan Rodkin, Dmitry Igorevich Sorokin, Artyom Sorokin, and Mikhail Burtsev. Babilong: Testing the limits of llms with long context reasoning- -n-a-- haystack. In The Fight Conference on Neural Information Processing Systems Datasets and Benchmarks Track, November 2024.
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, et al. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th Symposium on Operating Systems Principles, pp. 611-626. Koblenz Germany, October 2023. ACM. doi: 10. 14553600006.33111666
12

---

Published as a conference paper at ICLR 2026
Ehsan Latif, Yifan Zhou, Shuchen Guo, Yizhu Gao, Lehong Shi, al. A systematic assessment of openai ol op-preveww for higher order thinking in education, October 2024a.
Ehsan Latif, Yifan Zhou, Shuchen Guo, Lehong Shi, Yizhu Gao, et al. Can openai ol outperform humans higher-order cognitive thinking?, December 2024b.
Jia Li, Edward Beeching, Lewis Tunstall, Ben Lipkin, Roman Soletskyi, et al. Numinamath: The largest public dataset ai4maths with 860k pairs of competition math problems and solutions, July 2024a.
Mo Li, Songyang Zhang, Yunxin Liu, and Kai Chen. Needlebench: Can Ilms do retrieval and reasoning in I million context window?, July 2024b.
Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, al. Let's verify step by step. In The Twelfth International Conference on Learning Representations, October 2023.
Tengxiao Liu, Qipeng Guo, Xiangkun Hu, Cheng Jiayang, Yue Zhang, Xipeng Qiu, and Zheng Zhang. Can language models learn to skip steps? In The Hhirty-Eightt Annual Conference on Neural Information Processing Systems, November 2024.
Haotian Luo, Haiying He, Yibo Wang. Jinluan Yang, Rui Liu, et al. Ada-rl: Hybrid-cot via bi-level adaptive reasoning optimization. In The Thirty-Ninth Annual Conference on Neural Information Processing Systems, October 2025.
Shangke Lyu, Linjuan Wu, Yuchen Yan, Xingyu Wu, Hao Li, et al. Hierarchical budget policy optimization for adaptive reasoning, August 2025.
Xinyin Ma, Guangnian Wan, Runpeng Yu, Gongfan Fang, Xinchao Wang, et al. Cot-valve: Length- compressible chain-of-thought tuning. In Proceedings of the 63rd Annual Meeting of the Asso- ciation for Computational Linguistics (Volume 1: Long Papers), pp. 6025-6035, Vienna, Aus- tria, July 2025. Association for Computational Linguistics. ISBN 979- 979-8-89176-25--0 doi: 10.18653/v1/2025 acl- acl-long.300.
mathai. Amc23 datasets hugging face. http://mnggiiiiiieeeedaaasmmaaau
2023.
Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, et al. S1: Simple test-time scaling. In Proceedings the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 20275-20321, Suzhou, China, November 2025. Association for Computational doi: 10. 10.18653/1120255.mmmmm mam.mmmmmmmi..........
https///aeiiigacccooaaass//rrrre Linguistics. ISBN 979- 8-9-888-997-----666
open-rl. 2025.
February
Open Thoughts Team. Open thoughts. open-thoughts, January 2025.
OpenAl. Introducing openai ol. http:://ggggaiicoooeeeemmmmmmmmp 2024.
OpenAl. Learning to reason with llms. http:://oggaaiiccommmmec/eeemttp -itr Ilms/, 2024.
Jianhui Pang, Fanghua Ye, Derek Wong, Xin He, Wanshun Chen, al. Anchor-based large language models. In Findings of the Association for Computational Linguistics: ACI. 2024, pp. 4958 1955-4976. Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 18.1363//v1/ 2024.findings fin.dingg--aa.125.....
Qwen, An Yang. Baosong Yang, Beichen Zhang, Binyuan Hui, et al. Qwen2.5 technical report, January 2025.
Qwen Team. Qwq: Reflect deeply on the boundaries of the unknown. 3ttp:///wwiiiiuubbbooo/oo/////b/
November 2024.
David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, et al. Gpqa: A graduate-level google-proof q&a benchmark. In First Conference on Language Modeling, August 2024.
13

---

Published as a conference paper at ICLR 2026
Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, al. Code Ilama: Open foundation models for code, January 2024.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models, February 2024.
Xuan Shen, Yizhou Wang, Xiangxi Shi, Yanzhi Wang, Pu Zhao, and Jiuxiang Gu. Efficient reasoning with hidden thinking, January 2025.
Charlie Victor Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling Ilm test-time compute opti- mally can be more effective than scaling parameters for reasoning. In The Thirteenth International Conference Learning Representations, October 2024.
Jianlin Su, Yu Lu, Shengfeng Pan, Ahmed Murtadha, Bo Wen, and Yunfeng Liu. Roformer: Enhanced transformer with rotary position embedding, November 2023.
Jiankai Sun, Chuanyang Zheng, Enze Xie, Zhengying Liu, Ruihang Chu, et al. A survey of reasoning with foundation models, January 2024.
Ziyu Wan, Xidong Feng, Muning Wen, Stephen Marcus McAleer, Ying Wen, Weinan Zhang, and Jun Wang. Alphazero-like tree-search can guide large language model decoding and training. In Proceedings of the s1 International Conference on Machine Learning, volume 235 of ICM1.'24, pp. 49890-49920, Vienna, Austria, July 2024. JMLR.org.
Yue Wang, Qiuzhi Liu, Jiahao Xu, Tian Liang, Xingyu Chen, et al. Thoughts are all over the place: On the underthinking of long reasoning models. The Thirty-Ninth Annual Conference on Neural Information Processing Systems, October 2025.
Xingyu Wu, Yuchen Yan, Shangke Lyu, Linjuan Wu, Yiwen Qiu, al. Lapo: Internalizing reasoning efficiency via length-adaptive policy optmizzaiin, August 2025.
Heming Xia, Chak Tou Leong, Wenjie Wang, Yongqi Li, Wenjie Li, al. Tokenskip: Controllable
th-huuht compression in llms. In Proceedings of the 2025 Conference on Empirical Methods Natural Language Processing, pp. 3351-3363, Suzhou, China, November 2025. Association for Computational Linguistics. ISBN 979-8-8999 8-766363-7766666
doi: 10. 10.18653/v1/2025.
emnlp-main.16s.
Guangxuan Xiao, Yuandong Tian, Beidi Chen, Song Han, and Mike Lewis. Efficient streaming language models with attention sinks. In The Twelfth International Conference on Learning Representations, October 2023.
Yuchen Yan, Jin Jiang, Yang Liu, Yixin Cao, Xin Xu, et al. S^3cmath: Spontaneous step-level self-correction makes large language models better mathematical reasoners. Proceedings of the AAAI Conference on Artificial Intelligence, 39(24):25588-22 25596, April 2025. ISSN 2374-3468.
doi: 10.1609/aaii.v3999 39924..34799.
Yuchen Yan, Liang Jiang, Jin Jiang, Shuaicheng Li, Zujie Wen, et al. Inftythink:: Effective and efficient infinite-horizen reasoning via reinforcement learning, February 2026.
An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, al. Qwen2.5-matt technical report: Toward mathematical expert model via self-improvemmntt September 2024.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, September 2022.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik R. Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. In SeventhS Conference Neural Information Processing Systems, November 2023.
Yixin Ye, Zhen Huang, Yang Xiao, Ethan Chern, Shijie Xia, and Pengfei Liu. Limo: Less more for reasoning. In Second Conference Language Modeling, August 2025.
14

---

Published as a conference paper at ICLR 2026
Longhui Yu, Weisen Jiang, Han Shi, Jincheng Yu, Zhengying Liu, et al. Metamath: Bootstrap your own mathematical questions for large language models. In The Tweifth International Conference on Learning Representations, October 2023.
Tao Yuan, Xuefei Ning, Dong Zhou, Zhijie Yang. Shiyao Li, al. Lv-eval: A balanced long-context benchmark with 5 length levels up to 256k. In Second Conference on Language Modeling, August 2025.
Zhiyuan Zeng, Qinyuan Cheng, Zhangyue Yin, Wang, Shimin Li, al. Scaling of search and learning: A roadmap reproduce ol from reinforcement learning perspective, December 2024.
Jiajie Zhang, Nianyi Lin, Lei Hou, Ling Feng, Juanzi Li, al. Adaptthink: Reasoning models can learn when to think. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 3716-3730, Suzhou, China, November 2025a. Association for Computational Linguistics. ISBN 979-8-89176-332-66 doi: 10. 00.18653/v1/20222 1/066///12222...mmmmmmminm wwn.-mmain.nnnnnm.m.mmm 184.
Jintian Zhang, Yuqi Zhu, Mengshu Sun, Yujie Luo, Shuofei Qiao, et al. Lightthinker: Thinking step-by-step compression. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 13307-13328, Suzhou, China, November 2025b. Association for Computational Linguistics. ISBN 979-8-89 111-8-8-997--332--- doi: 1/2211663//222255502 12255
Zhenyu Zhang, Ying Sheng, Tianyi Zhou, Tianlong Chen, Lianmin Zheng, et al. H2o: Heavy-hitter oracle for efficient generative inference of large language models. In Thirry-Sevnnth Conference on Neural Information Processing Systems, November 2023.
Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Sun, Jeff Huang, et al. Sglang: Efficient execution of structured language model programs. In The Thirty-Eighth Annual Conference on Neural Information Processing Systems, November 2024.
Tianyang Zhong, Zhengliang Liu, Yi Pan, Yutong Zhang, Yifan Zhou, et al. Evaluation of openai ol: Opportunitics and challenges of agi, September 2024.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, et al. Least-to-most prompting enables complex reasoning in large language models. In The Eleventh International Conference on Learning Representations, September 2022.
Wangchunshu Zhou, Yuchen Eleanor Jiang, Peng Cui, Tiannan Wang, Zhenxin Xiao, et al. Recur- rentgpt: Interactive generation of (arbitrarily) long text, May 2023.
15

---

Published as a conference paper at ICLR 2026
CONTENTS
Introduction
2
Methods
2.1
Infty Think Reasoning Paradigm
2.1.1
Vanilla Paradigm of Cong-Context Reasoning
2.1.2
Iterative Reasoning with Summarization: Infty Think
2.2
Data Reconstruction
3
Experiments
3.1
Settings
3.2
Main Results
4
Analysis
4.1
Endowing Short-context Models with Long-context Reasoning Ability
Influence of Context Window Size Parameter
8
4.3
Performance across Reasoning Iteration Rounds
Ablation prompt-based pipeline
10
5
Conclusion
10
LLM Usage Declaration
18
Discussion
18
Related Works
18
Reasoning Large Language Models
18
Compression of L.LM's Reasoning Process
19
Iterative Methods in LLMS
19
Token Length Distribution of OpenRI-Math
20
Context Hit Phenomenon Analysis
20
Ablation Study on Summarizer Models
21
Data Construction Efficiency
21
Experiments of Aligned Data Quantity
21
Ablation Study Summarization Contexts During Data Construction
22
Training and Evaluation Stability
22
16

---

Published as a conference paper at ICLR 2026
K Extended Main Evaluation Results
23
Extended Evaluation Results across Iterations
24
M Experiments with Thoughts
24
Applicability across Domains
25
Experiment Settings
25
Prompts for Summary Generation
25
Experiment Details for RoPE-Scaled Models
25
R
Discussion about Inference-time Computational Cost
26
R.1
Efficiency Analysis using L as a Proxy
26
R.2 Efficiency Analysis using FLOPs
28
R.3
Computational Cost across Different
28
S
Comparison to RI with Length Penalty
29
Details of TOK and LAT Metrics Calculation
Token metric calculation
31
Latency metric calculation
Case Study
31
U.I
An example on MATH500
31
U.2
An example AIME24
34
U.3
An example on Diamond
38
17

---

Published as a conference paper at ICLR 2026
A LLM USAGE DECLARATION
In writing this paper, we only used LLMs for polishing. The generation of ideas in this work did not involve any assistance from LLMs. The experimental design and manuscript writing were not directly produced by LLMs either. The models were used solely as polishing tool: specifically, we first drafted the manuscript, then refined with the help of an LLM, and finally the authors conducted another round of verification after polishing.
B DISCUSSION
Alignment with Human Reasoning InftyThink's iterative reasoning approach shares interesting parallels with human problem-solving strategies. Humans rarely solve complex problems through single, exhaustive thought process but instead work through incremental steps, summarizing intermediate progress, and building on previous insights. The strong performance of our approach, particularly complex problems, suggests that structuring Al reasoning better align with these natural problem-solving patterns may yield both efficiency and effectiveness benefits. This connection between iterative reasoning with summarization and improved performance offers potential insights for developing more effective Al reasoning systems.
Adaptive Reasoning Depth Unlike conventional reasoning approaches with fixed computational budgets, InftyThink can adaptively allocate computational resources based on problem difficulty. Our analysis in Section 4.3 shows that simpler problems (e.g., MATH500) reach ceiling performance with fewer iterations, while more complex problems (in AIME24 and GPQA diamond) benefit from extended reasoning. This adaptive depth capability has important implications for practical deployment, as it enables efficient resource allocation across heterogeneous problem sets without requiring predetermined computation limits.
Limitations Despite its advantages, Infty faces several limitations. First, the quality of reasoning depends heavily the model's summarization capabilities -pori summarization can lead to information loss that hinders subsequent reasoning. Second, breaking reasoning into segments might disrupt the coherent flow of thought for certain problem types that benefit from maintaining a complete chain of reasoning. Finally, while our approach reduces computational complexity, introduces additional inference steps that may increase latency in time-sensitive applications.
Future Directions Several promising directions could extend this work. First, integrating reinforce- ment learning techniques such as GRPO could help models better learn when and what to summarize, potentially improving information retention across iterations Yan et al., 2026). Second, exploring variable-length reasoning segments that adapt based on problem complexity could further optimize the tradeoff between computational efficiency and reasoning coherence. Third, applying Infty Think to multi-modal reasoning tasks could expand its applicability to domains requiring integration of visual, textual, and numerical reasoning. Finally, investigating how to parallelize different reasoning paths within the Infty Thfkk framework could further accelerate complex problem-solving.
C RELATED WORKS
C.I REASONING OF LARGE LANGUAGE MODELS
Reasoning ability is one of the fundamental competencies of large language models(LLMss), reflecting their capacity to tackle complex challenges in the human domain. Currently, LLMs demonstrate impressive performance across various reasoning tasks, including commonsense reasoning, mathemat- ical reasoning, code reasoning, logical reasoning and etc. The reasoning capabilities of these models can be enhanced at several stages during training (Huang Chang 2023 Sun et al.) 2024). For
instance, during pre-training, the inclusion of extensive reasoning related knowledge and examples helps the model to learn reasoning patterns from the data (Shao et al. 2024 Guo et al. 2024 Rozière
et al. 2024). Similarly, in the supervised fine-tuning phase, incorporating high-quality reasoning question-answer answer pairs can further refine the model's reasoning patterns and enhance its capabilities (Li
et al. 2024a Yan et al. 2025 Yu al. 2023 Tiang al. 2025). In the reinforcement learning
18

---

Published as a conference paper at ICLR 2026
phase, the model's reasoning is monitored and guided through feedback on outcome processes, providing additional improvements (Guo et al. 2025 Shao et al., (024). The release of OpenAl's ol (OpenAl 2024) marked significant breakthrough in the reasoning abilities of LLMs. OpenAI ol demonstrated long-context reasoning capabilities, where the model utilized extended chains of thought to integrate planning. self-correction, and other cognitive functions, significantly boosting its reasoning performance (Zeng et al. (0024). More recently. DeepSeek-RI, an open-source ol-like reasoning model, has exhibited comparable reasoning abilities. Furthermore, distilled data from DeepSeek-Re R1 enables smaller LLMs to also acquire long-context reasoning skills (Guo et al. 2025 Ye et al. 2025 Open Thoughts Team 2025).
C.2 COMPRESSION OF LLM'S 'S REASONING PROCESS
Current research on compressing the Chain-of-Thouur (CoT) process to accelerate large language model (LLM) inference is primarily categorized into two approaches: CoT token compression and KV cache compression. CoT token compression enhances inference efficiency by reducing the number of tokens generated by the model. This approach can be further subdivided into discrete text token compression and continuous latent token compression methods. Discrete text token compression employs straightforward strategies such as prompt engineering (Han et al. 2025), instruction fine- tuning (Kang al., 2024), and reinforcement learning (Arora & 7anettt 2025 train models to produce more concise reasoning processes. Within this category, the skip-tokens method (Liu cct [224] Xia al.) 2025) enables the model to intelligently skip unimportant tokens during inference, thereby achieving acceleration. In contrast, continuous latent token compression (Cheng & Durme 2024, Geiping et al., 2025 Hao et al. 2025 Shen et al.) 2025) explores a more innovative approach by attempting to compress reasoning steps into continuous latent representations. This allows LLMs to perform effective inference without explicitly generating discrete word tokens. On the other hand, KV cache compression optimizes inference performance by reducing the storage requirements and computational load of the KV cache. This approach mainly includes two types of methods: training- ffree and training- baaddd Training-free KV cache management strategies enhance efficiency by selectively retaining key tokens. The criteria for selection include prioritizing initial and most recent tokens for their temporal relevance (Xiao et al.] (023), identifying tokens with significant historical attention (Zhang et al.) 2023), or selecting tokens based on structural cues such as punctuation marks (Chen al. (025). Training-based KV cache management (Pang al.. [0224] Zhang et al. (0255) involves introducing special tokens and training LLMs to compress important historical information into these tokens, thereby achieving KV cache merging. This method instructs the model on when to perform compression during the training phase and applies corresponding interventions during the inference phase. With the application of reinforcement learning (RL) in large language models (LLMs), researchers have also employed RI. to achieve efficient reasoning. typical approach to incorporate penalties on the length of model generations into the reward design (Aggarwal & Welleck 2025 Arora & Zanette 2025 Kimi Team et al. 2025 Luo et al. 20255 Lyu et al. 2025 Wu et al. 2025) Zhang et al., 2025a). By dynamically penalizing the length of the model's 's reasoning, the overall reasoning length can be effectively reduced. However, this also suppresses the model's 'ss exploration space when tackling difficult problems.
C.3 ITERATIVE METHOSS IN LLMS
Large language models (LLMs) often face the problem of context window length limitations in generation tasks. For example, in novel generation, when the model produces millions of tokens, such issues frequently arise. This is because LLMs are typically trained with fixed context window, and once the generation exceeds this limit, performance degradation often occurs. An intuitive approach to periodically summarize the content generated by the model, condensing ultra-long text while preserving the core semantic information, thereby reducing token usage. RecurrentGPT (Zhou et al.) iterative generation method that maintains both long-term and short-term
2023) is a prompting-basd memory, continuously updating the model's 's current task in an attempt to address the issue of limited context window in long-form generation tasks. Tree-of-Thought. (Yao et al. 2023) decomposes problem into multiple subproblems, performs verification at each subproblem, and selects the optimal path to obtain a more reliable reasoning trajectory. which could be used as a test-time scaling method that improves performance through exploration and verification ReAct (Yao et al.) 2022) explores the domain of tool-use by integrating reasoning into the model's 's action space to enhance its tool-calling capabilities, and during tool usage, the model needs to iteratively plan, summarize, reason,
19

---

Published as a conference paper at ICLR 2026
and generate. Least-to-me to-ttst (Zhou et al. 2022) solves simpler subproblems first provide useful context for solving more complex ones later. Through an iterative generation process, the model can effectively leverage its contextual information to perform efficient reasoning and generation.
D TOKEN LENGTH DISTRIBUTION OF OPENR -MHTH
To analyze the characteristics of the OpenRI-Mate dataset, we tokenized all data using the Qwen2.5- Math-7B tokenizer and computed the distribution. As shown in Figure 54% of the samples in OpenRI-Man are shorter than 4k tokens, 83% are shorter than 8k tokens, and the vast majority fall below 16k tokens.
70k
1.0
60k
0.83
-0.8
Cumulative Frequency
Samples
40k
0.54
0.6
30k
0.4
10k
0.0
16k
# of Tokens (Question + Answer)
Figure 5: Token distribution of OpenRI-Math. The statistics are obtained using the tokenizer of
Qwen2.5-Mathe
E CONTEXT HIT PHENOMENON ANALYSIS
To demonstrate the practical effectiveness of Infty InftyThink, analyzed how vanilla long-comm cong-context reasoning utilizes context length, aiming to identify how much context is required and thereby illustrate that Infty'Think improves model performance by expanding the reasoning window.
We define a metric called hit rate to measure the proportion of unfinished reasoning within a given max_new_ new_tokens window. the model outputs an <eos> token within the allotted tokens, consider the reasoning complete; otherwise, it is treated as unfinished.
We evaluated this metric based the vanilla CoT inference results of Owen2.5-Math-1135 Shown in Figure g under the 16k maximum length constraint, 32% of the cases in AIME24 reached this limit, indicating that the model could not complete certain challenging problems within 16k tokens.
Morcover, even when the constraint was relaxed to 32k (which substantially reduces model efficiency), 10% of the cases MATH500 were still bounded by the length. These findings support Infty Think's motivation: extending reasoning length while preserving high inference efficiency.
Table 4: Accuracy and context hit rate of vanilla CoT under different max__eew _ww__newwtsstttte
max fex__ne__toeen
MATH500
AIME24
16k
75.24 (18%)
16.04 (32%)
26.48 (16%)
32k
77.82 (10%)
18.79 (6%)
28.33 (0%)
20

---

Published as a conference paper at ICLR 2026
F ABLATION STUDY ON SUMMARIZER MODELS
In our main experiments, we employed 1lmm--333-70B 70---nttttccttttt to generate summaries of reasoning process segments, which were then used to construct ufftyThink-style data. Given the scale of this model, one might question whether its additional capacity introduces unfair advantages. To address this concern, we conducted an ablation study using summarizers of varying sizes (Qwen2.5- Btt////1.5B-Intrrie
(Qwen et al. 2025)), keeping the training setup identical across conditions. The results, presented in Table 5 show that summarizer size has only negligible effect on final performance.
These results indicate that the observed improvements primarily attributable to the Infty Think reasoning paradigm itself, rather than any supplementary knowledge contributed by the summarizer model. This underscores the paradigm's 's high usability and robustness across different summarizer configurations.
Table 5: Performance comparison across different summarizer models and their data construction efficiency. Here NVIDIA A100-80G for summary generation.
Summarizer
MATH500
AIME24
GPQA D
Construction Efficiency
75.24
16.04
26.48
1aama-3.3-70B-Inttte
79.57
26.04
35.89
6.4 GPU hours per Ik samples
Owen2.5-32B-Innee
80.12
22.74
34.13
3.1 GPU hours per 1K samples
(wen2.5-7B-Insteee
80.71
23.96
35.04
0.5 GPU hours per Ik samples
Qwen2.5-1.5B-Inse
79.65
23.56
32.73
0.2 GPU hours per Ik samples
G DATA CONSTRUCTION EFFICIENCY
In this paper, we propose an automated pipeline that rapidly converts vanilla long-context CoT data into InftyThie Think-style data. To help researchers estimate the cost of migrating their own data into the InftyThink format, we provide an efficiency comparison using summarization models of different sizes, as shown in Table
can be observed that even when using a relatively small 1.5B model to generate summaries for constructing training data, the final trained model still achieves substantial improvements. The 1.5B model enables fast and low-cost transformation of data into the desired format, which reduces cost for researchers to construct Infty naftyThink-styy data and demonstrates the robustness of our method.
H EXPERIMENTS OF ALIGNED DATA QUANTITY
In our main experiments, we applied the proposed method to convert 220K vanilla-style OpenR1- Math samples into 333K Infty Think-style samples, which introduced an inconsistency in the number of training examples. We provide an explanation and analysis of this discrepancy to demonstrate the fairness of our comparisons.
We would like to emphasize that the 333k Infty Think data and the 220k OpenR1-Main data share the same set of queries. Due InftyThink's segmentation mechanism, a single example from OpenR1-Math is split into multiple segments. However, the total reasoning content across these segments remains consistent with that the original example. The only additional tokens introduced by Infty Think are the generated summaries, which are relatively short compared to the overall reasoning content. Since we packed samples during training, the total number of training steps between Infty Think and vanilla are very close (6543 vs. 6257), suggesting that the total training tokens differs by less than 5%. We believe this makes the comparison both reasonable and fair.
To further support our claim, downsampled the InftyThink-aa data to 220k and oversampled the vamilla data to 333k, and carried out two sets of comparison experiments, and the results are shown in T
21

---

Published as a conference paper at ICLR 2026
Table Performance of models trained on down-sampled InftyThink-style data and over-sampled vanilla-style data.
Data
MATH500
AIME24
GPQA Li0mood
vanilla, 220k InftyThink, 333k
75.24
16.04
26.48
79.57
26.04
35.89
vanilla, oversample, 333k
75.88
14.37
24.72
InftyThink, downsample, 220k
79.49
26.04
36.08
The experimental results indicate that neither over-sampling nor down-sampling affects the conclu- sions drawn from our original experiments, with all performance variations falling within expected fluctuation ranges.
I ABLATION STUDY ON SUMMARIZATION CONTEXTS DURING DATA CONSTRUCTION
When constructing the summaries, each S; is generated by prompting an LLM to summarize the entire reasoning process from RP: through RP.. In the InftyTTink reasoning paradigm, starting from the 2nd reasoning iteration, the model receives the summary produced in the previous iteration and generates new summary for the current iteration. For example, when producing S2, the model conditions on S1 as part of the context. Leveraging this property, we expect S2 to retain the key information from S1, thereby maintaining global reasoning history.
Therefore, in our data construction pipeline, when generating S;-1, we summarize (RP,,.... RP:-1) and construct the corresponding data pairs. In this way, at every iteration of InftyThink reasoning, the model can access historical conclusions across the entire reasoning trajectory through the summaries, achieving context compression while preserving essential information.
To verify the effectiveness of this approach, we conducted an additional experiment during the rebuttal phase. Specifically, replaced the summary of (RP..... RP:-1) with summary generated solely from RP;-1, keeping all other conditions unchanged, and compared against both vanilla and InftyThink. Think. The experiment was run Qwen2.5-Math-11.5
Table 7: Ablation results of different summarization context during data construction.
Method
MATH500
AIME24
GPQA_dianee diamond
Vanilla CoT
75.24
16.04
26.48
Infty (global summary)
79.57
26.04
35.89
InftyThink (local summary)
77.18
19.48
29.78
We observe that eliminating this design results in a measurable decline in reasoning performance. This degradation arises because, without the proposed mechanism, the model gradually loses access to key intermediate conclusions over multiple iterations, leaving later reasoning steps inadequately grounded. In contrast, our approach preserves these critical intermediate insights throughout the iterative process, thereby providing stronger support for subsequent reasoning and ultimately improving overall model performance.
J TRAINING AND EVALUATION STABILITY
To validate the reliability of our experimental results, we designed additional verification experiments to ensure that the observed fluctuations fall within reasonable range, thereby not affecting overall conclusions. Our verification of experimental stability is divided into two aspects: model training and model evaluation.
22

---

Published as a conference paper at ICLR 2026
Model training. In this work, most of our experiments based on SFT, where repeated training may lead to certain fluctuations. To investigate the fluctuation range. we conducted three runs under the same experimental settings and observed the variation interval. The detailed results are shown in Table g
Table 8: Performance (%) comparison across multiple runs.
Model
Method
MATH500 (Run1/2/3)
AIME24 (Run1/2/3)
GPQA (Rum1/2/3)
Qwen2,5-Math-
Vanilla
74.58 73.09 73.59
12.92 10.62 11.87
22.82 23.61 22.57
InftyThink
80.75 / 79.25 78.92
25.96 25.21 23.96
35.67 / 37.59 35.67
Qwen2.5-Math-77
Vanilla
89.51 88.48 89.69
32,92/ 33.05/ 32.60
43.94 43.88 44.188
Infty Think
91.29 /9.03 /91.88
43.96/ 43.27/ 43.72
52.97 / 52.45 53.51
From our experimental results, the accuracy fluctuation caused by single training run is approxi- mately 1-2 percentage points. In contrast, the performance gain brought by Infty InftyThink over vanilla CoT significantly exceeds this range, thereby demonstrating the effectiveness of InftyTTink.
Model evaluation. Since LLM generation inherently involves degree of randomness, also accounted for this factor during evaluation and attempted to minimize potential bias in conclusions caused by generation uncertainty. Specifically, for all evaluations, we report the averaged values of ACC/TOK/LAT across multiple samples, For sampling, we used temperat ure of 0.7 and top_p of 0.95, generating 16 samples per instance and computing the average metrics.
K EXTENDED MAIN EVALUATION RESULTS
To further demonstrate the effectiveness of our method on more challenging reasoning datasets, in addition to the results presented in Table we also compared the performance vanilla CoT and InftyThink on three difficult mathematical reasoning benchmarks: AIME25, AMC23, and Math Odyssey. The experimental results reported in Table
Table 9: Our extended experimental results. The results obtained by sampling the model 16 times with temperature of 0.7. ACC stands for average accuracy(%), TOK stands for average number of generated tokens (K), and LAT stands for average inference wall time in seconds.
AIME25
Math Odyssey
AMC23
Average
Model
Train Format
ACC1 TOK LAT) ACC1 TOK LAT ACC1 TOK LAT, ACCT TOK LAT
Base Models
Qwen2.5-Math-11.
Vanilla
16.67
15.00
3.95
50.90
9.47
2.46
42.34
11.00
2.51
47.92
2.56
Infty
26.25
16.39
2.38
57.97
10.75
1.53
53.12
12.59
1.85
55.47
11.28
1.61
Qwen2.5-Math-78
Vanilla
36.88
13.91
3.84
65.28
7.88
2.40
77.50
8.15
2.06
64.49
2.46
Infty Think
36.25
18.21
2.90
73.23
9.23
1.95
77.81
10.77
2.23
71.21
2.04
Qwen2.5-14BB
Vanilla
37.29 14.45
9.28
75.79
7.11
3.43
86.72
7.13
2.81
74.23
7.59
3.76
InfiyThink
7.75
75.16
8.97
2.97
88.44
8.22
74.33
3.28
Qwen2.5-32B
Vanilla
51.67
12.60
9.98
80.06
6.25
4.25
93.44
6.04
3.39
79.37
6.65
4.55
InftyThint Think
56.46
17.12
11.93
79.96
7.43
3.51
94.22
7.14
6.28
79.67
8.04
4.30
Instruct Models
3.33
0.82
0.05
53.39
0.73
0.05
53.59
0.72
0.05
50.
0.73
0.05
(-Instruct)
Vanilla
17.71
16.96
4.97
51.19
10.00
2.86
45.67
12.94
3.87
48.52
10.71
3.09
Infty Think
34.58
19.77
2.83
62.15
11.18
1.78
68.44
11.21
1.89
60.90
11.75
1.86
R RI-distill-Qwent -uaiill-Qeee-L.B///
31.04
13.98
3.27
62.48
9.46
2.46
71.72
9.43
2.13
61.23
9.75
2.48
Vanilla
24.58
16.52
4,03
63.08
8.46
2.07
67.03
9.99
2.31
60.91
9.12
2.22
Infty Think
35.21
19.27
3.07
65.79
10.92
1.94
67.97
11.28
1.77
63.98
11.50
2.00
As shown in the table, our Think approach consistently achieves improvements across multiple challenging mathematical reasoning benchmarks, thereby validating the effectiveness of our method.
23

---

Published as a conference paper at ICLR 2026
L EXTENDED EVALUATION RESULTS ACROSS ITERATIONS
In Section analyze the performance trajectory of InftyThink across multiple benchmarks the number of reasoning iterations increases. Specifically, we observe that InftyThink on relatively simple benchmarks (e.g.. MATH500), whereas exhibits continuous improvement on more challenging benchmarks (e.g.. AIME24). To further validate this observation, we additionally plotted the same curves on three high-difficulty mathematical reasoning benchmarks, AIME25, Math Odyssey, and AMC23, as shown in Figure 6
Think quickly converges
AIME25
Math Odyssey
AMC23
58
35
56-
$5.0
Accuracy
30
54
52.5
52
50.0
25
50
20-
40-
46
6
10
10
of iteration
of iteration
of iteration
Figure 6: Model performance (%) across reasoning iterations.
From the figure above, we can observe that for relatively more difficult problems, performance has saturated. Specifically, when comparing the 10th iteration to the 5th iteration, AIME shows an improvement of approximately 5%, Math Odyssey shows a 2% improvement, and AMC23 shows 3% improvement.
M EXPERIMENTS WITH OPEN-THOUGHTY
In this paper, we conducted all experiments on the OpenRI dataset. To demonstrate the transferability of our approach, we additionally performed data reconstruction another dataset, OpenThoughts, to obtain Infty Think--tttt OpenThought data and carried out corresponding training experiments. We also evaluated the model on several datasets discussed in this paper, and the experimental results are presented in Table 10
Table 10: Experimental results with OpenThouughs training data. The results are obtained by sampling the model 16 times with temperature of 0.7. ACC stands for average accuracy(%), TOK stands for average number of generated tokens (K), and LAT stands for average inference wall time in seconds.
MATH500
AIME24
GPQA diamond
Average
Model
Train Format
ACC1
TOK LAT| ACC1 TOK LAT, ACC1 TOK LAT),
ACC
TOK LAT]
Qwen2.5-Math-1.58
Vanilla
70.25
6.99
1.82
10.42 17.36
4.67
22.03 10.92
2.64
54.67
8.49
2.16
InftyTThink
77.16
7.24
0.96
26.46 21.84
3.62 26.20 11.33
1.74
61.21
8.96
1.28
AIME25
Math Odyssey
AMC23
Average
Train Format
ACC1 TOK LAT] ACC1 TOK LAT] ACC
TOK LAT]
ACC7 TOK LAT
Vanilla
18.75 14.82
3.60
49.29 10.55
45.94
12.90
11.03
3,06
InftyThink
31.46 23.17 4.68 57.36
11.27
2.40 61.41
16.13
4.20
56.02 12.47 2.71
From the above experimental results, can observe the general applicability of the proposed framework. Across different datasets, InftyThink consistently yields improvements. For example, the average accuracy increases by 7-8 percentage points, while the average latency decreases by approximately 30%-40%. These results demonstrate the strong performance of Infty Think and provide support for researchers adopt and transfer the Infty'Think paradigm.
24

---

Published as a conference paper at ICLR 2026
N APPLICABILITY ACROSS DOMAINS
Most of the evaluation datasets in this paper focus on mathematical and scientific reasoning. To further demonstrate the robustness of our method, we additionally conducted evaluations on code reasoning datasets. Specifically, we used the model trained in Appendix Mo evaluate on HumanEval (Plus) and MBPP (Plus). Since the Thoughs dataset includes code reasoning tasks, such evaluations are justified. The detailed results are reported in Table
Table 11: Experimental results of OpenThoughts variants HumanEval and MBPP benchmarks.
Data
pass @ (HumanEvall -Plus)
pass @ 1 (MBPP -Plus)
OpeniThoughht--aniin Open'l Open'/hoouhts-Inflyy Think
36.59 / 32.32
43.3 / 36.2
46.95 40.85
48.2 / 39.7
From the experimental results, we can see that InftyTThink also brings improvements on code reasoning tasks, with an 8-10% gain on HumanEval and a 3-5% gain on MBPP. This demonstrates the broad applicability of InftyThink.
O EXPERIMENT SETTINGS
For the training process, we utilize the Megatron-LM framework. The supervised fine-tuning is performed for 3 epochs, with a maximum sequence length of 16,384 tokens. The batch size is set to 32, the initial learning rate is lc-5, and the warmup ratio is set at 0.03. The learning rate follows a cosine decay schedule to reach zero. To accelerate training, we pack all SFT samples to the maximum sequence length. Each packed sample retains its original positional embeddings, and attention values are computed independently for each instance. All experiments are conducted on 256 Ascend H910B-64G NPUs.
For models trained on OpenR MaMth, we conduct standard single-round inference with a maximum output length of 32,768 tokens. For models trained OpenR 1 apply the proposed Infty Think reasoning paradigm, performing multi-round iterative inference with a maximum of 10 iters and single-round maximum reasoning length of 8,192 tokens. To mitigate potential fluctuations in the evaluation results, each evaluation case is sampled 16 times with temperature setting of 0.7, and the average accuracy computed. All inferences are executed using vLLMM (Kwon et al. (023) vl-engine on NVIDIA A100-80G GPUs. For models with 1.5B parameters, inference is performed on GPU, for 7B/SB models, inference is performed on 2 GPUs, while for models with 14B and 32B parameters, inference is performed on 4 GPUs.
P PROMPTS FOR SUMMARY GENERATION
In Figure 7
we present the prompt used for summary generation. The prompt shown in the figure follows the chat template of -lama--33-70BB- Ins-ruut For other summarizers, the corresponding chat template should be replaced to achieve the desired performance.
Q EXPERIMENT DETAILS FOR ROPE-SCALED MODELS
We apply linear interpolation RoPE with scale factor of 8, extending the context window of Qwen2.5-Mor - from 4k to 32k. The model is then trained using the same methodology as in the main experiment. The results presented in Table T2
25

---

Published as a conference paper at ICLR 2026
Prompts for Summary Generation
<[begin_of_text| httpr//ff_..t////ssststtteeeeeee http:///ee..eeeeeeerrsesss/ee/e/ htwps//emeeeeeedeeee____dddddddd
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
Please list what you have achieved in your last response. Note that you should only output the summarization. You should list all the key steps and important Intermediate conclusion. Please list them with re: </eot_id|><
 hew.deerdd/assssstaanniieppppppp
Figure 7: Prompt for generating summary of reasoning process fragment. A multi-turn dialogue approach is employed to generate the summary. The light-colored section in the figure represents the chat template, while the dark-colored section corresponds the input we designed.
Table 12: Comparison results RoPE linear interpolation experiments (%).
Data
Positional Embedding
MATH500
AIME24
GPQA diamond
OpenRI-Math
raw
89.51
32.92
43.94
linear scale to 32k
90.91+1400
30.63-2.29
48.26+5.32
OpenR I-Math-Inf
raw
91.29+1.78
43.96-11.04
52.97+9.03
R DISCUSSION ABOUT INFERENCE-TIME COMPUTATIONAL CoST
R.1 EFFICIENCY ANALYSIS USING L PROXY
Contemporary LLMs face fundamental efficiency bottleneck due to the quadratic (O(n²) computa- tional scaling of attention with sequence length. InftyThink addresses this by decomposing reasoning into shorter segments with periodic summarization.
Figure demoontteesssssttess that Infty Think (red line) consistently achieves higher accuracy than traditional reasoning (gray line) under equivalent computational budgets. This advantage increases with problem complexity, becoming most prominent on AIME24 and GPQA diamond benchmarks. Simulta- ncously, the blue line shows that InftyThink makes for complex problems where traditional approaches struggle to maintain performance scaling. By avoiding the quadratic growth pattern of traditional reasoning, Infty'hiink fundamentally improves the relationship between computation and reasoning performance, offering a promising direction for deploying advanced reasoning resource-constrained environments.
efficient of each token, particularly
To quantitatively analyze the computational cost of our proposed Infty Think during inference, we introduce two key metrics; the total token count and the of squared token counts. Specifically, for an iterative generation process with iterations, we define the token count at each step as:
Tokens; [tokenize(Question))
tokenize(S;-11) tokenize(PP) RP.)) tokenize(S:)
where [tokenize(z)) indicates the number of tokens after tokenization of string In particular, the number of tokens generated during the first inference step is:
Tokens; tokenize (uanniio(uustionn) [tokenize (ooenize(Ss))
As the final inference step generate a conclusion instead of a summary, the token count during the final inference step is defined as:
Tokens, BakkenizeQQuestion + tokenizzeS.--i)] + Mooennize(PP)) RP:)] + tookeize(Concllusion))
26

---

Published as a conference paper at ICLR 2026
MATH500
AIME24
GPQA diamond 8K"
Σ
tokenss Ok?
46
12K?
16k?
OK?
4k²
8k'
12k?
16k
DK?
4k'
12k"
16k²
40
90
35
80
30
(%6
70
60
10
tokens
0k
4k
8k 12k 16k
0k
8k 1.2k 16k
4k 8kk 12k
16k
Figure 8: Accuracy across various benchmarks under different computational scales. The gray line represents traditional long-context reasoning trained on OpenR The two colored lines correspond to InftyThink, with the blue line indicating the total number of tokens computed by the model and the red line representing the squared sum of tokens computed across multiple inference iterations. The gray line can simultancously represent the effects of traditional long-context reasoning in both dimensions. Comparing the gray line with the blue line illustrates the accuracy trend as the model reasons over a certain number of tokens, while the comparison between the gray line and the red line reflects the relationship between computational cost (with O(n²) complexity) and accuracy. Experiments are conducted on Qwen2.5-Math-75
The first metric, the total sum of tokens, is defined as:
Σ Tokens
Σ Tokens;, i E [1,
The second metric, the sum of squared token counts, is defined as:
Σ Tokens² = Σ Tokens i [1,n]
For standard long-conter, reasoning task with single generation, where 1, the relationship ( Tokens) Σ Tokens holds.
In Figure g we illustrate the relationship between these metrics by employing a dual-axis design. The lower axis (colored in blue) tracks the first metric, Tokens, while the upper axis (colored in red) represents the second metrie, Σ Tokens?, with its scale being the square of the lower axis.
Σ Tokens holds, allowing to depict both metries using single curve, shown gray line. In contrast, for Infty we differentiate the two metrics by employing distinct lines, each colored to correspond with its respective axis.
For traditional long-contex: reasoning, the theoretical relationship
Σ Tokens)
To plot the curve shown in the figure, we calculate the number of correct instances at specific token thresholds. Specifically, we set eight token thresholds: 2k, 4k, 6k, 8k, 10k, 12k, 14k, and 16k. We select all the correct completions from the evaluation, tokenize them, and then count how many samples fall under each of these thresholds. The accuracy computed by dividing the number of samples for each threshold by the total number of completions.
There are two ways to analyze this figure. The first approach is compare the accuracy for the same computational cost, by fixing the value of and comparing the corresponding y values. The second approach to compare the computational cost for the same accuracy, by fixing the value of y and comparing the corresponding values.
We would like to emphasize that the computational complexity calculations provided above were based on the most rigorous methodology. However, in practical applications, inference frameworks like vLLM (Kwon et al., 2023) and sglang (Zheng et al.) 2024) already support prefix-cachinn which climinates the need recompute the attention values of the question during each inference. Despite this, under the strictest computational model, Infty Think demonstrates superior efficiency, underscoring the effectiveness of the proposed approach.
27

---

Published as a conference paper at ICLR 2026
R.2 EFFICIENCY ANALYSIS USING FLOPS
To more precisely assess the theoretical computation required during inference, we analyze how the performance of the vanilla approach and InftyThink changes under varying FLOPs budgets. FLOPs quantify the floating-poimt operations incurred during inference, corresponding to the total number of multiplications and additions executed by the model.
For our analysis, we disregard the length of the initial prompt and compute only the forward-pass cost incurred during autoregressive token generation using a KV-cache. The total FLOPs are decomposed into three components. The first component, denoted as Fb, represents the base FLOPs for every generated token. The second component, Pa. corresponds to attention computation, whose cost grows quadratically with the number of generated tokens. The third component, Fy. arises from the LM-head projection and scales linearly with the number of generated tokens.
Let L be the number of layers in the LLM, d the hidden size, de the intermediate size of the FFN, V the vocabulary size, and the number of generated tokens. The three FLOPs components can then be approximated
Fb (T& + Gdd,), F. = 2dLT(T 1), F, = 2dVT
Under the vanilla CoT paradigm, the FLOPs given by:
F Fg + F..
For InftyThink which decomposes a long reasoning trajectory into iterative segments, the total computational cost is:
F
where F; denotes the FLOPs incurred in the i-th iteration.
As the total FLOPs include both linear and quadratic complexity terms with respect to the generated length T, we analyze how accuracy scales with computational cost across models of different sizes. The base models we study include Owen2.5-Math-77 and Qwen2.5-32B. Their architectural configurations shown in the Table [3]
Figure 9 reports how accuracy varies with FLOPs for vanilla CoT and Infty Think across multiple benchmarks. Under equivalent FLOPs budget, InftyTTiink achieves consistently higher accuracy than vanilla COT.. This effect is more pronounced for smaller LLMs. Our analysis indicates that, in small models, the quadratic component of the computational complexity dominates the overall FLOPs, making reductions in sequence length particularly impactful. In larger models, however, the FFN computation becomes the primary cost, and the quadratic term only overtakes it when the generated sequence becomes extremely long. Consequently, Infty Think exhibits the most significant efficiency improvements in settings where generation lengths are sufficiently large surpass the FFN-dominated regime.
Table 13: Model architectural configurations across LLMs.
Model
Layers (L.)
Hidden Size (d)
Intermediate Size (d_i)
Vocab Size (V)
1ren2.5-Math-77
28
3584
18944
152064
Qwen2.5-32H
64
5120
27648
152064
R.3 COMPUTATIONAL COST ACROSS DIFFERENT ?)
In order to compare the trade-off between computational cost and performance at different values of 77, we also plotted the variations of these two metrics with accuracy for different y values, as shown in Figure 10 and II Specifically, the choice demonstrates a clear trade-off with performance. Smaller 77 values lead to higher reasoning efficiency in the early stages, whereas larger 17 values result in improved reasoning performance. Based on our observations, among the comparisons = 2k,
1 4k, and y 6k, 1) 2k strikes the optimal balance between these factors.
28

---

Published as a conference paper at ICLR 2026
MATH500
AIME24
GPQA diamond
90
80
15
80
20
50
5-
10
x100
GPQA diamond
90
80
Accuracy
40
30
2.5
5.0
7.5
10.0
12.5x10
2.5
3.0
7.5
10.0
12.5x10ff
2.5
5.0
7.5
10.0
12.5x10
InftyThink
Figure 9: Accuracy(%) across various benchmarks under different FLOPs. The top three subfigures show the curves for Qwen2.5-Math-7B, while the bottom three subfigures correspond to Qwen2.5- 32B.
COMPARISON TO RL WITH LENGTH PENALTY
To further demonstrate the effectiveness of our proposed approach, we compare it with range RL methods based on length-penalty. These methods aim to achieve efficient reasoning by introducing penalties on generation length into the reward systems, thereby reducing the number of tokens produced during reasoning.
Table 14: Performance comparison MATH500 and AIME24 benchmarks.
Method
Base model
Training
MATH500
AIME24
Merging-OA.
DeepSeck-RI-dinn
---diistll--wenn--....
Free
79.00 (-7.08)
17.33 (-10.66)
Thinkless
RL
81.34 (-4.16)
27.33 (-0.61)
НВPO
DeepSeek-RR-disstil---eeee
RL
80.40 (-1.20)
AdaR1
RL
80.80 (-0.20)
AdaptThink
DeepSeek-
ReepSeck-RI-distille
RL
82.00 (+1.40)
31.00 (+1.60)
TLMRE
RL
85.00 (+4.40)
29.20 (-0.20)
InftyThink
SFT
88.06 (+3.06) 29.38 (+6.88)
As shown in Table 14, it can be observed that InftyThink achieves comparable performance among related works in terms of absolute results. We acknowledge that different studies may adopt slightly inconsistent evaluation metrics; therefore, parentheses. Notably, some efficient reasoning approaches result in performance degradation, whereas Think achieves the largest performance improvement while maintaining efficiency.
have indicated the claimed performance gains in
Regarding efficiency metrics, most prior works measure efficiency based solely on the number of generated tokens. However, inftyThink not only generates more tokens, but also reduces inference wall time. Moreover, not all these models are open-source, so we are unable to evaluate their inference wall time in environment.
29

---

Published as a conference paper at ICLR 2026
MATH500
AIME24
GPQA diamond
35
40
(80
70
20
10
15
20
Etokons
4k
8k
12c
16k
0K
44
8k
12k
16k
0K
4k
8k
12k
16c
50
40
(8)
70
30-
20
60-
20-
10
EtokensPok?
12k²
16k.
8K?
12k"
16K
06'
86-
126
16K
0 2k
0 4k o=
Figure 10: Accuracy(%) across various benchmarks under different computational scales on different settings. The three subplots above illustrate the relationship between Σ Tokens and accuracy, while the three subplots below depict the relationship between Σ Tokens" and accuracy. Experiments are conducted on Qwen2.5-Math-77
MATH500
AIME24
GPOA diamond
90
50
50
80
Accuracy
20
60
20-
10
50
10
Ytokens
16k
12k
10k
4k
12k
10k
70
60
90
80
50
40
Accuracy
40
30-
60
20
20
10
50
10
Etokens' o22
422
822
1227
1667
062
412
862
122"
16k
022
427
822
12x7
1622
()
0-
Figure 11: Accuracy($) (6) across various benchmarks under different computational scales on different ? settings. The three subplots above illustrate the relationship between Σ Tokens and accuracy, while the three subplots below depict the relationship between Σ Tokens" and accuracy. Experiments conducted on Qwen2.5-32B.
30

---

Published as a conference paper at ICLR 2026
T DETAILS OF TOK AND LAT METRICS CALCULATION
T.1 TOKEN METRIC CALCULATION
In this paper, the TOK metric uniformly denotes the total number of tokens actually generated during inference. For vanilla CoT, we compute TOK as:
TOK [tokenize(RP))] [ooeenize(Conllusionn]]
For InftyThink, TOK corresponds the full token budget consumed across all reasoning segments, summaries, and the final conclusion:
TOK
tokenize [RP.) tokenize(S.)] + [tokenize(ooncuusion]]
This formulation guarantees fair and consistent comparison between InftyThink and vanilla CoT with respect to actual token generation.
T.2 LATENCY METRIC CALCULATION
We adopt simple method to compute inference latency. Specifically, for evaluating a single model on given dataset, suppose the dataset contains test samples, and each sample undergoes reasoning runs to compute the average accuracy. We denote the timestamp before the first sample starts as 41, and the timestamp after the last sample finishes 122 The latency metric is then calculated as:
12 f
LAT
m
This metric measures the average time cost (in seconds) of a single generation.
U CASE STUDY
To better demonstrate the performance gap and differences in reasoning patterns between Infty Think and vanilla CoT reasoning, we provide the reasoning traces of models trained Qwen2.5-Math 7B for MATH500, AIME24, and GQPA_Diamond, along with an analysis of where InftyThink's improvements originate. Because the model's reasoning tokens are excessively long, the <ommited> marker to omit intermediate outputs.
U.1 AN EXAMPLE ON MATH500
MATH500 benchmark for mathematical reasoning the elementary education level but with relatively high difficulty. Below, we provide an example of actual model reasoning, including both the vanilla and ThfntT reasoning modes. In this example, InftyThink performs two iterations of reasoning. The summary produced in the first iteration is passed to the second iteration as history. In the second iteration, the model does not generate a summary and completes the entire reasoning process.
MATH500
Question:
Denali and Nate work for a dog walking business and are paid for each dog they walk. Denali is responsible for $16$ dogs and Nate is responsible for $12s dogs. Under the company' s new policy, they will be assigned or unassigned new dogs in groups of $x$ dogs. The ratio of Denali's pay to Nate's s pay would be the same if Denali started walking $4x$ more dogs and Mate stayed at $12$ dogs or if 9x$ of Nate's dogs were reassigned to Denali, Find $x$ if $x\\negos.
31

---

Published as a conference paper at ICLR 2026
Vanilla Long-CoT: (7188 tokens for thinking, 521 tokens for conclusion)
<think>
Okay, let's try to figure out this problem. So, Denali and Nate are working for dog walking business. Denali walks 16 dogs, and Nate walks assigned or unassigned dogs in groups of x. The ratio of Denali's s pay to Nate's s pay would the same in two different scenarios. One scenario is if Denali starts walking 4x more dogs and Nate stays at 12 dogs. The other scenario is if x of Nate's dogs are reassigned to Denali. We need to find x, given that x isn't zero.
dogs. Under the new policy, they are
<ommited>
Yes, that's correct. So, the answer is 5.
**Final Answer++
The value of X \) \boxed(5).
</think>
Denalí and Nate are assigned or unassigned dogs groups of \ V). The ratio of Denali's pay to Nate's pay must be the same in two different scenarios.
<ommited>
The value of \( x A) is (5))).
InftyThink@ Iterl: (4235 tokens for thinking, 290 tokens for summarization)
<think>
Okay, let's s see. The problem is about Denali and Nate being paid based on the number of dogs they walk. Denali has 16 dogs, and Nate has 12. The company is changing the policy where they can assign or unassign dogs in groups of x dogs. So, the question is asking for the value of x if the ratio of Denali's pay Nate's s pay remains the same under two different scenarios.
First, I need to understand what exactly is being asked here. The key points are:
1. The original ratio of their pay is based on the number of dogs they each walk. So, if Denali walks 16 dogs and Nate walks 12, their pay ratio is 16:12, which simplifies to 4:3.
<ommited>
But they only have 16 dogs. So, 4x $\les 16, x $\le$ 4. similarly, in the second scenario, assigning x dogs from Nate to Denali, so Nate has 12 x dogs, and Denali has 16 + x dogs. So, $\le$ 12 and $1le$ 16. So, $\les 12. </think> <summary>
* Set up the original ratio of Denali's pay to Nate's pay 16:12 4:3.
32

---

Published as a conference paper at ICLR 2026
Identified the two scenarios: Denali walks 16 + 4x dogs and Nate stays at 12 dogs, or x dogs are reassigned from Nate to Denali.
* Set up equations based on the acenarios: (16 4x) /12 4/3 and (16 (12 x) 4/3.
* Solved both equations and found that both give x 0, which is invalid.
* Re-examined the problem statement. and confirmed that the ratio of their pay is proportional the number dogs they walk.
Considered alternative interpretations, such as the ratio being of their pay, but concluded that the pay is proportional to the number of dogs.
Analyzed the constraints on such as x $1le$ and x $\les 12, based on the number of dogs they can be assigned.
Identified the issue with the problem statement that leads to no valid solution.
Explored different approaches, including reinterpreting the problem and considering the maximum number of dogs they can be assigned.
* Concluded that the problem as stated has no solution, but the problem states find x $neg$ 0, indicating potential error in the problem. statement or interpretation. </summary>
InftyThink@ lter2: (3372 tokens for thinking, 595 tokens for conclusion)
<think>
Alternatively, maybe the problem is in another language and there's s translation error. Alternatively, maybe the problem is from source where is allowed to be a variable that can be any real number, but the answer is x=0, which is invalid. But the problem says $ineqs so this is confusing.
Wait, maybe I made mistake in setting up the equations. Let me check again.
First scenario: Denali walks 16 +4x dogs, Nate walks 12 dogs. Pay ratio: (16 +4x) /12 =4/3.
<ommited>
Second scenario: Denali walks 16 +5=21 dogs, Nate walks 12 -5=7 dogs. Pay ratio 21/7=3. So ratio remains same. Therefore, x=5.
Therefore, the answer is 5. So the problem must have typo or mistranslation, but given the information, x=5 is the answer.
**Final Answer** \bboxed(5)
</think>
Denali is responsible for 16 dogs and Nate is responsible for 12 dogs. Under the new policy, they can be assigned dogs in groups of \ x V.. The ratio of Denali's pay to Nate's pay must be the same in two scenarios: either Denali walks \ 4x
33

---

Published as a conference paper at ICLR 2026
\) more dogs and Nate stays at 12 dogs, or \ x A) dogs are reassigned from Nate to Denali.
1. **First Scenario*:: Denali walks \ 16 4x \) dogs and Nate walks 12 dogs. The ratio of their pay is:
<ommited>
This gives x V or \1 x V. Since V Aneg 0 V), the valid solution is (( x = V.
Thus, the final answer is: A[
(5)
U.2 AN EXAMPLE ON AIME24
AIME24 is competition-level high-difficulty mathematicall-ressoninn benchmark. Below, we provide an example of actual model reasoning traces, including both the vanilla and InftyThink reasoning modes. In this example, Infty'Think performs iterations. The summary from the first iteration is passed to the second iteration history, the summary from the second iteration is passed to the third iteration as history, and so on. In the fourth iteration, the model no longer produces summary and completes the entire reasoning process.
AIME24
Question:
Every morning Aya goes for a $98-kilometer-oong walk and stops at coffee shop afterwards. When she walks at constant speed of Ss$ kilometers per hour, the walk takes her 4 hours, including $tş minutes spent in the coffee shop. When she walks $s+2$ kilometers per hour, the walk takes her hours and 24 minutes, including $tş minutes spent in the coffee shop.
Suppose Aya walks at $s+)frac(11 (2)5 kilometers per hour. Find the number of minutes the walk takes her, including the $tş minutes spent in the coffee shop.
Vanilla Long-CoT: (13172 tokens for thinking, 911 tokens for conclusion)
<think>
Okay, let's s see. So the problem is about Aya's s walking time. When she walks at speed km/h, the total time (including the coffee shop time) is hours. When she increases her speed to 8+2 km/h, the total time becomes hours and 24 minutes. We need to find the time it takes her when she walks at s + 1/2 km/h, including the coffee shop time.
<ommited>
Therefore, the answer Aboxed (204)
**Final Answer** \boxed(204)
</think>
34

---

Published as a conference paper at ICLR 2026
Given that Aya walks a Loki walk and stops at a coffee shop after 4 hours (including ( t \ minutes spent in the coffee shop), we need to find the number of minutes the walk takes her when she walks at A \Erac(1) V) kilometers per hour.
<ommited>
Thus, the number of minutes the walk takes her, including the \ A) minutes spent in the coffee shop, is \(booxd \
InftyThink@ Iterl: (4307 tokens for thinking, 274 tokens for summarization)
<think>
Okay, Aya walks kilometers every morning, but the time she spends walking and the time she spends in the coffee shop depends on her walking speed. The problem gives two different scenarios: when she walks at speed km/h, it takes her 4 hours total, including wa walks faster at (s 2) km/h, it takes her 2 hours and 24 the
minutes in the coffee shop. When she
minutes total, still including the same t minutes coffee shop. Then need to find out how long the walk takes when she walks at (s 0.5) km/h, including the minutes in the coffee shop.
<ommited>
But in the second approach, the left side is 9/s 9/ + 96 hours? Wait, no. Wait, in the second approach, 240 - is 9/s, so 9/s 240
in minutes, so 240
Then, 240
is in minutes, so 9/s is in minutes. Then, 9/s - ( + 2) is also minutes. Then, 1.6 hours is 96 minutes. so 9/s (/ + 2) 96 minutes. So in the second approach, the units are minutes. So 9/s is in minutes, (/ 2) is in minutes, so their difference is 96 minutes. So that's correct. </think>
<summary>
* Set up two equations based on the given information: 4
/60 9/s and 2.4 t/60 9/ (s 2)
* Derived the equation ( + 2) = 11.25 from the first method
Derived the equation ( method
0.1875 from the second
Found the value Found the value of t to be 24 minutes using the first method * Verified the result using the second method, which gave a conflicting result for (ss + 2)
to be 2.5 km/h using the first method
* Identified the discrepancy between the two methods and recognized the need to re-examine the calculations * Re checkheced the units and equations for both methods Confirmed that the second method should give the correct
result, but the discrepancy remains
Recognized that the left side of the equation should be in the same unit as the right side
Noted that the second method should give 9/s 9/ 2) 96 minutes, which is equivalent to 1.6 hours
35

---

Published as a conference paper at ICLR 2026
* Concluded that there is a mistake in one of the approaches, but the correct method is still unclear. </summary>
InftyThink@li Iter2: (4159 tokens for thinking, 377 tokens for summarization)
<think>
Wait, perhaps the error is in the second method. Let's try to solve the problem using a different. approach.
Let's denote the time taken by walking at s+0.5 km/h as T hours, including minutes. We need find
<ommited>
But how?
Wait, the problem says that when she walks at s 0.5 km/h, the walk takes her hours and 24 minutes, including t minutes spent in the coffee shop. Therefore, T 2 hours and 24 minutes 144 minutes. Therefore, the equation is:
9/(s 0.5) + t/60 144
</think>
<summary>
* Set two equations based on the given information: 4 t
/60 9/s and 2.4 t/60 9/ (s 2)
* Derived the equation ( + 2) = 11.25 from the first method
* Derived the equation s + 2) 0.1875 from the second
method, which was found to be incorrect
* Found the value of s to be 2.5 km/h using the first method Found the value of to be 24 minutes using the first method * Attempted to solve the problem using the second method, but encountered inconsi stencies
* Re-exami ned the problem and found that the time spent in the coffee shop is the same in both cases, which is minutes * Derived the equation 9/s - 9/ 2) - 1.6 hours, which represents the difference in walking time * Found that the total time difference is 1.6 hours, which is equal to 9/s 9/ 2)
* Computed the walking time at 0.5 km/h to be approximately 175.2857 minutes, which is inconsistent with the previous result * Found that the error lies in the calculation of T, which minutes
should be 144 minutes, not
* Derived the equation (/ + 0.5) t/60 = 144, which represents the total time at s 0.5 km/h
* Substituted the values of s and t into the equation and found that it does not hold, indicating a mistake the previous steps.
</summary>
InflyThink@le Iter3: (4079 tokens for thinking, 343 tokens for summarization)
<think>
Wait, no. Wait, the total time at s +0.5 5 is 144 minutes, which includes the coffee shop time t. So, the walking time is 144 t. Therefore:
36

---

Published as a conference paper at ICLR 2026
144 9/ (s +0.5)
<ommited>
Therefore, the walking time at s+2 is 2.4 t/60 hours, which is 2.4 t/60 hours. But walking time is also 9/ (s+2) hours. Therefore:
9/(s+2)=2.4 - t/60
</think>
<summary>
Set up two equations based on the given information:
/60 9/s and 2.4 t/60 = 9/ (s + 2) * Derived the equation (s + 2) 11.25 from the first two equations
* Solved for s and found s 2.5 km/h
Found the value of to be 24 minutes
* Attempted to solve for the time when walking at a + 0.5 km/h, but encountered inconsistencies
* Re-exami ned the problem and found that the key is to find the time spent in the coffee shop, t, which is the same in both cases
Set up equations based on the walking times and + 0.5 km/h
km/h km/h is 144 minutes 0.5 km/h to be 144 minutes, which includes t minutes in the coffee shop
* Found that the walking time at
Calculated the total time at
Found that the answer is 2 hours and 24 minutes plus t minutes, but this leads to inconsistencies Re-exami ned the interpretation of the problem and found that the error is in the assumption that t is the same in both cases
* Attempted to find t using the equations from the first two cases, but still encountered inconsistencies
Derived the equation (/ + 2) = 2.4 t/60, which relates the walking time at </summary>
*
km/h to t.
InftyThink@@ Iter4: (2459 tokens for thinking, 435 tokens for conclusion)
<think>
But we also have from the first case:
9/3 =4 t/60
<ommited tedx
But wait, 1et check once again. If s=2.5 km/h, then +0.5=3 km/h. The walking time is 9/3-3 hours-180 minutes. Adding t=24 minutes gives 204 minutes. Therefore, the answer is 204. So, the answer is \boxed(204).
**Final Answwr** \boxed(204)
</think>
37

---

Published as a conference paper at ICLR 2026
Aya's s walk and coffee shop time can be modeled with the following equations:
1. When walking at \l s V km/h, the total time is hours,
including 24 minutes (which is ( \frac (trac(24]) (24) (60) 0.4 \ hours in the coffee shop:
<ommited>
Adding the 24 minutes spent in the coffee shop:
|[
180 24 = 204 \text minutes} \]
Thus, the number of minutes the walk takes her, including the 24 minutes spent in the coffee shop, is \/bboxed(204)V)
U.3 AN EXAMPLE ON GPQA DIAMOND
GPQA_ diommnda is challenging scientific reasoning benchmark. Below, present example of real model inference under both the vanilla and InftyThink reasoning modes. In this case, executes only single iteration, matching the behavior of the vanilla setting, because the task does not demand extensive token-level reasoning. After completing its internal thinking process, the model outputs conclusion directly, without invoking iterative multi-step reasoning.
GPQA Diamond
Question:
Two quantum states with energies and E2 have lifetime of 10^-9 sec and 10--8 sec, respectively. We want to clearly distinguish these two energy levels. Which one of the following options could be their energy difference so that they can be clearly resolved?
A) 10a-9 ev
B) 10^-11 eV
C) 10--4 ev
D) 10 ev
Vanilla Long-CoT: (5219 tokens for thinking, 571 tokens for conclusion)
<think>
Okay, so I need to figure out which energy di fffferncc between two states allows them to be clearly resolved based their lifetimes. The problem gives two lifetimes: one is 10a-9 seconds and the other is 100-8 seconds. The question is asking which of the given options (A to D) could be the energy difference so that the two states can be distinguished.
<ommited>
Therefore, the correct answer is C.
**Final Answer**
38

---

Published as a conference paper at ICLR 2026
\boxed(C)
</think>
To determine the energy difference required to resolve two quantum states with lifetimes \(10^(-9)V) seconds and (-10")-8) seconds, we use the Heisenberg uncertainty principle in the form \(Deelt E \edot \Delta \geq \frac H2)pi)\), where (hh) is Planck's constant. The minimum energy difference (\Delta E [[\text(min))) required to resolve the states is given by:
<ommited>
Comparing these values to \66.58 Atimes 10 (-7) ev, we find that (1 Atimes (0-(-4)X) ev (option с) is the largest and thus can be resolved, while the others are smaller.
M[
\boxed(C)
\]
InftyThink@ Iterl: (2159 tokens for thinking, 562 tokens for summarization)
<think>
Okay, I have this problem here about two quant states with energies E1 and E2, and their lifetimes are 10^-9 seconds and 10*-8 seconds respectively. The question is asking which of the given options could be their energy difference so that they can be clearly resolved, The options are A) 10a-9 ev, 10^-11 eV, C) 100-4 eV, D) 10--8 eV. Hmm, let me think about how approach this.
<ommited>
Sc 3.29 x 10a-12 ev less than all the given options except A. Wait, but A is 10--9 ev. 3.29 10a-12 eV is
0.00000000000329 ev, which is 3.29 x 10--12 eV, which is much less than 10"-9 ev (which is 1 10--9 eV). So 3.29 10--12 ev is 0.00000000000329 ev, which is 3.29 x 10--12 eV, which is 3.29 10>-12 10"-9 3.29 x 10"-3 ev less than 10--9 ev. so the required $\DeltašE is 3.29 x 10--12 ev, which is 3.29 x 10--3 ev less than 10--9 ev. So 3.29 10--12 eV is way smaller than 10a-9 eV, so option A's required SADeltaSE is way smaller than what's given. Therefore, option A' $\DeltašE is too low to be resolved. So only option C' $ADeltašE is 10--4 ev, which is 100 million times larger than the required 3.29 x 101-12 ev. So yes, option C is possible.
Therefore, the answer is C) 10--4 eV. </think>
тo determine the energy difference that allows clear resolution between two quantum states with lifetimes
\(10~(-9)\) and \(10A(-8)\) s, use the Heisenberg uncertainty principle relating energy uncertainty (M(Deetta E \)) and time uncertainty (\(Deeta t\)):
Commited>
39

---

Published as a conference paper at ICLR 2026
**Answer:** \boxed(C)
40


Reviews:
[{"review_id": "Bf9FjElHGs", "reviewer": "Reviewer_wn6o", "summary": "InftyThink proposes an iterative reasoning paradigm for large language models that breaks long, monolithic reasoning chains into multiple short segments with intermediate summarizations, enabling theoretically unbounded reasoning depth while keeping computational costs bounded. Experiments on different benchmarks and multi model architectures show that this approach improves reasoning accuracy and reduces inference latency, effectively overcoming context-length and efficiency limitations.", "questions": "See the Weaknesses.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "1. This paper proposes a novel paradigm that controls context length through iterative summarization, thereby overcoming the limitation of maximum context boundaries. The idea is both intuitive and reasonable, and the authors further construct corresponding datasets to enable models to acquire this capability.\n2. Comprehensive experiments across different datasets and models demonstrate that this method improves model accuracy while reducing inference time, and it consistently proves effective across various model architectures.\n3. The experiments on reasoning iteration rounds demonstrate that the proposed method can, to some extent, overcome the constraints of maximum context length.", "weaknesses": "1. During inference, the method shortens the context through summarization, which in turn reduces reasoning time. Although Table 1 provides evidence of this effect, the reduction in inference time is not particularly significant, and the paper lacks further analysis (e.g., detailed statistics showing the actual number of tokens used per reasoning step compared to the vanilla approach).\n2. At each reasoning step, the model should only have access to \\(S_{i-1}\\). Why, when constructing the SFT data in Equation (2), is it based on \\(RP_1, \\ldots, RP_{i-1}\\) rather than \\(S_{i-1}\\)?\n3. In Figure 4, how are the different iterations obtained? My understanding is that the model generates multiple reasoning steps adaptively. Could you provide the inference prompt? In addition, the paper lacks some visualization analysis, such as a concrete example illustrating the model’s reasoning process.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "t1sAis8C1p", "reviewer": "Reviewer_xrFD", "summary": "The paper introduces an iterative summarization strategy that compresses earlier reasoning traces in real time. This strategy keeps the live context short, cuts computing costs, and, as demonstrated by evaluation on three math (MATH500, AIME24, and GPQA) and other benchmarks, improves task accuracy compared to vanilla CoT.", "questions": "Please address weaknesses as questions.\n\n- Why is InftyThink's latency higher than that of vanilla CoT on AIME24 for Llama-3.1-8B and R1-distill-Qwen-7B?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The idea is very clear, well motivated, and easy to follow.\n- The proposed approach allows models to “think” longer while maintaining a limited context size, reducing GPU RAM memory requirements.\n- Informative appendix with many details, extra experiments, and analyses.", "weaknesses": "- There is no prompting-only pipeline ablation: it’s unclear how much of the gain comes from training on specific data rather than the summarize-and-continue procedure itself. How would your trained method (InftyThink) compare to a prompting-only pipeline on the same base model: run CoT, pause at fixed steps, prompt the model to summarize, feed the summary back, and continue without any extra fine-tuning. This would help isolate the value added by training and highlight the general impact of the proposed iterative reasoning approach.\n- Source of metrics gains is unclear. Some baselines return no answer due to context limits (according to Appendix E, Qwen2.5-Math-1.5B hits context limit in 18% samples on MATH500 and AIME24 in 32% samples). It is not clear how much of the improvement comes from (a) solving previously unanswered cases vs. (b) better reasoning on cases vanilla CoT did answer incorrectly.\n- The paper does not clearly show the break-even point where the method becomes faster/cheaper than vanilla CoT. The method adds generation of summaries, so the total number of tokens for InftyThink are roughly len(question) + len(summaries) + len(CoTs), which exceeds vanilla len(question) + len(CoTs). Where is the breaking point at which InftyThink becomes faster in latency / tokens per second than vanilla CoT?\n- Using n^2 tokens as a proxy for inference cost can be misleading (Appendix Q). In practice, compute is often dominated by FFN layers at shorter contexts, with quadratic attention dominating only at larger contexts. A comparison in FLOPs or measured latency would be more convincing.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "DM9tKlrV8E", "reviewer": "Reviewer_39tg", "summary": "This paper introduces InftyThink, which is a paradigm for turning monolithic reasoning traces into a sequence of short reasoning segments interleaved with summaries of all previous reasoning segments, incrementally and iteratively generated. This idea of \"summarize\" and \"reason\" pairs can be used for reconstructing existing reasoning datasets in this iterative format.\n\nThe authors empirically investigate this approach for five base models of various sizes (1.5B to 32B parameters) they train.\n\nFor training they also reconstruct OpenR1-Math, using a larger model for the summarization (or comparable-sized ones: Appendix F) of the reasoning segments they partition the traces into.\n\nThey test their accuracy on MATH500, AIME 2024 and GPQA Diamond benchmarks (main text) and they report on performance benefits when compared to the vanilla models' case with performance gains most notable for smaller sizes. A discussion on the impact of eta (segment length) in evolving performance across summarizations further augments the analysis of the method.", "questions": "- Partitioning the reasoning process is very important: on the one hand skewed partition sizes can lead to variable \"compression\" factors in generated summaries or skewed summaries (that could fail to fit into fixed context window sizes (eta)); on the other hand these imbalanced partitions could well be those that are semantically most reasonable. How do you plan to approach this? Fixed larger contexts? Smaller contexts? Variable contexts driven by semantics and heuristics for deciding semantic boundaries?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- Excellent motivation and intuition.\n\n- The sawtooth memory pattern offers a bounded memory footprint which is highly desired in applications.", "weaknesses": "- Requires a specialized data reconstruction pipeline for training, which in turn necessitates the use of an LLM (e.g. for summarization), so not a simple/lightweight process (even for the very small summarizers in Table 4 (Line 994)).", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "ehL94t6lgq", "reviewer": "Reviewer_xfMt", "summary": "The paper proposes InftyThink, an iterative long-context reasoning method for LLMs. Instead of generating one long chain-of-thought, the model reasons in bounded segments of length η (e.g. 2K/4K/6K tokens), summarizes progress, and continues conditioning mostly on the summary. This is meant to (i) let models “think” for arbitrarily many steps, (ii) avoid quadratic attention over extremely long contexts, and (iii) improve reasoning accuracy at lower compute cost. The authors reconstruct a large supervised dataset (OpenR1-Math-Inf) by segmenting long math reasoning traces and adding summaries, and fine-tune various backbones (Qwen2.5-Math 1.5B/7B/etc., Llama-3.1-8B) on that data. They report higher accuracy on MATH500, AIME24, and GPQA_diamond, while claiming equal or lower latency compared to vanilla long-CoT decoding.", "questions": "1. How exactly were the latency numbers in Table 1 measured for vanilla vs. InftyThink? Were both sides run under identical inference infrastructure?\n\n2. Why does InftyThink emit more total tokens but run faster? Please provide a step-by-step cost model and per-iteration timing.\n\n3. What η and max_iterations were used for each model in Table 1? Were they tuned per task?\n\n4. Please provide accuracy variance / CIs for at least the Table 1.\n\n5. Figure 4. Why does η=2K match or outperform η=4K/6K at the same effective token budget? Is this simply because shorter segments force more frequent summarization (which the model has been trained to do well), or something else?", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "1. The core idea (periodic summarize-and-continue instead of one monolithic chain) is simple, intuitive, and architecturally lightweight — no special long-context transformer, just inference protocol + supervised finetuning.\n\n2. The data pipeline that turns 220K long solutions into 333K iterative traces is clearly described and likely reusable for others training math/logic models.\n\n3. Reported gains are consistent across multiple model sizes and families, especially on harder benchmarks like AIME24 and GPQA_diamond where deep multi-step reasoning matters.", "weaknesses": "1. Table 1 shows that in overall InftyThink emits more tokens per problem than vanilla (e.g. Qwen2.5-Math-1.5B on MATH500: 5.94K → 6.79K tokens), yet the reported latency drops (1.42s → 0.80s). This is confusing. How this translates to practical setup is unclear.\n\n2. The InftyThink models depend critically on two hyperparameters: segment size η (they denote it like 2K/4K/6K) and max_iterations. Those exact values for each reported model are not given in Table 1. This makes it hard to reproduce or even interpret the latency numbers and token budget, since they obviously depend on η and how many iterations you unroll.\n\n3. No variance / confidence intervals are provided in Table 1. For some benchmarks the absolute gain is only ~1–2%, which could easily fall within noise. The paper references “stability” in the appendix but does not surface it in the main results.\n\n4. Figure 4 compares η = 2K / 4K / 6K. Converted to “total tokens generated,” the 2K model matches 4K and even beats 6K at similar total token counts. In other words, shorter segments with more iterations can be as good or better than longer segments, at roughly the same total text budget. This is surprising and important: it hints that extremely short steps plus good summaries may dominate, which would strongly shape how people deploy the method. The paper surfaces the curve, but gives almost no analysis of why 2K can keep up with or beat 4K/6K at equal effective cost. That missing discussion leaves open whether η is actually a tuning knob or just an implementation artifact.\n\n\nI think that the pitch of longer reasoning with less latency and better accuracy, drop-in for any LLM is very strong, but the evidence for the latency/computation story is currently incomplete, and several presentation issues (Table 1 hyperparameters, missing variance, lack of explanation for Figure 4 behavior) are significant for an ICLR acceptance.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)