Beyond Single-Task: Robust Multi-Task Length Generalization for LLMs
Authors: Yi Hu
Shijia Kang
Haotong Yang
Haotian Xu
Muhan Zhang
Venue: NeurIPS 2025 poster ()
Keywords: length generalization
systematic generalization
algorithmic reasoning
scratchpad
LLM reasoning
Primary area: deep_learning

Abstract: Length generalization—the ability to solve problems longer than those seen during training—remains a critical challenge for large language models (LLMs). Previous work modifies positional encodings (PEs) and data formats to improve length generalization on specific symbolic tasks such as addition and sorting. However, these approaches are fundamentally limited to special tasks, often degrading general language performance. Furthermore, they are typically evaluated on small transformers trained from scratch on single tasks and can cause performance drop when applied during post-training stage of practical LLMs with general capabilities. Hu et al., (2024) proposed Rule-Following Fine-Tuning (RFFT) to improve length generalization in the post-training stage of LLMs. Despite its compatibility with practical models and strong performance, RFFT is proposed for single tasks too, requiring re-training for each individual task with extensive examples. In this paper, we study length generalization in multi-task settings and propose *Meta Rule-Following Fine-Tuning (Meta-RFFT)*, the first framework enabling robust *cross-task* length generalization. 
As our first contribution, we construct a large length generalization dataset containing **86 tasks** spanning code execution, number processing, symbolic and logical reasoning tasks, beyond the common addition or multiplication tasks. Secondly, we show that cross-task length generalization is possible with Meta-RFFT—after training on a large number of tasks and instances, the models achieve remarkable length generalization ability on *unseen* tasks with *minimal fine-tuning or one-shot prompting*. For example, after fine-tuning on 1 to 5 digit addition, our 32B model **achieves 95% accuracy on 30 digit addition**, significantly outperforming the state-of-the-art reasoning models (DeepSeek-R1-671B: 72%; QwQ-32B: 32%), despite never seeing this task during RF-pretraining.

Beyond Single-Task: Robust Multi-Task Length Generalization for LLMs
Yi Hu'!
Shijia Kang"
Haotong Yang' Haotian Xu² Muhan Zhang
'Institute for Artificial Intelligence. Peking University XXiaohongshu Inc.
Abstract
Length generalization- the ability to solve problems longer than those seen during critical challenge for large language models (LLMs). Previous work modifies positional encodings (PEs) and data formats to improve length generalization on specific symbolic tasks such addition and sorting. However, these approaches are fundamentally limited to special tasks, often degrading gen- eral language performance. Furthermore, they are typically evaluated on small transformers trained from scratch on single tasks and can cause performance drop when applied during post-training stage of practical LLMs with general capabilities. Hu et al. [19] proposed Rule- Following Fine-Tuning Tuning (RFFT) improve length generalization the post-training stage of LLMs. Despite its compatibility with practical models and strong performance, RFFT is proposed for single tasks too, requiring re-traiie re-training for each individual task with extensive examples. this paper, we study length generalization in multi-task settings and propose Meta Rule-Following Fine-Tuning (Meta-RFFT) the first framework enabling robust cross-task length generalization. As our first contribution, length generalization dataset containing 86 tasks spanning code execution, num- ber processing, symbolic and logical reasoning, beyond the common addition multiplication tasks. Secondly, we show that cross-task length generalization is possible with Meta-RFFT after training on large number of tasks and instances, the models achieve remarkable length generalization ability on umseen tasks with minimal fine-tuning or one-shot prompting. For example, after fine-tuning on to 5 digit addition, our 32B model achieves 95% % accuracy on 30 digit addition, significantly outperforming the 671B: 72%; QwQ-32B: 32%), despite never seeing this task during RF- Er-tpretrannin. Our code is available at https//github.com/Mii aaaa M/ -FFF.
construct large
reasoning models (DeepSeek -R-
Introduction
Large language models (LLMs) have achieved revolutionary performance in a wide range of tasks,
from natural language understanding and generation complex reasoning [33, 34, 16, 38, 9, 8]. However, they still face challenges when processing some basic tasks seemingly intuitive to humans. One of the challenging problems the length generalization, where Nogueira al. [31], Zhou et al. [58, 60), Anil et al. [1] reveal that transformers suffer from significant performance drop when solution steps exceed the training range, suggesting that models fail to capture the inner mechanism in these reasoning problems. A classic example is long-integer addition: models trained on addition problems with fewer digits often fail to generalize to higher-digit cases.
Equal contribution. Corresponding author. Muhan Zhang cmuhan@pku.edia
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Scratchpad Direct Answer Input
Rule- HulloFol Fine- TuniiTunng
Given integer nun, repearedly up its digsts until the result has only one digit, and return it.
RFFT Input
ueille nue:
num 246 enter the loop
Follow the given rule to solve the question.
given integer "nus"
248,
3.1 One iteration
def add, (sel, nun: intl -> ints
Direct Answer Output
while 9:
cua 0
sun = nux nua //-
while nun: sun + nux 10
Seratchpad Output
nun //= 18
Calculate sux of digits Calculate of digits 14: So answer
nus = sun return nun
0: Given an integer nuy, repeatedly add up
all its digits until the result has only one digit, and return It. The given integer "numt is 248.
240
Vanilla RFFT Results (from Hu et al.. 2024)
24 enter the loop
Liamo-2-78
GPT-35 Turbo
1. Initialize
REFT Output
3.1 One iteration
2. Outer Toop while 98
unreel nue
nun
248 the loop
do not enter
4, Return
Leigi
2.1 One steration
return
Length generatization per perfornance of modett Fine buned on additinn tested adcition operands
digits.
3. Inner loop
5p answer
Figure I:
Comparison of input-output sequences across three methods: direct answer, scratchpad (top left), and RFFT (right), with single-task performance results shown at the bottom left.
Although long chain-of-thougle (CoT) models seem learn plausible reasoning process for some complex tasks such as math code [35, 10, 44, 45, 56, 51], length generalization is still a challenge for them. Even advanced long-CoTT models like DeepSeek-R -1-67 IB and QwQ-32B exhibit unsatisfactory performance in long integer addition, achieving only 72% and 32% accuracy, respectively, on 30-digit problems.
Some prior work improves length generalization by designing specialized positional encodings (PEs) or data formats. [58, 41, 21, 23, 60, 4, 28, 5, 2]. However, these approaches are heavily dependent on specific properties of the objects (like numbers) and thus limited to specialized domains. Besides, these methods are shown to be effective through training small transformers from scratch on single task, yet proven ineffective for fine-tuning on top of pretrained LLMs [52], fundamentally due to their incompatibility with the PEs /ummber formats used for the general corpus. This greatly limits their practical applicability.
Regarding enhancing length generalization in the post-training stage of LLMs, Anil et al. [1] states that direct answer and scratchpad fine-tuning [32] (examples are shown in Figure 1) are not enough to enable robust length generalization. Recently, Hu et al. [19] found that the issue stems from the case- based mechanism of LLM reasoning and proposed
Fine- Fine-Tuning (RFFT) to teach models to follow rules step by step. RFFT represents the first successful effort to solve diverse length generalization tasks using a unified approach. As illustrated in Figure 1, RFFT explicitly incorporates rules into the input, guiding the model to follow them strietly. In contrast, the baseline scratchpad fine-tuning method only provides intermediate computations without conveying the underlying rules, similar to teaching children addition solely through examples, without explaining the principles. By explicitly instructing the model in both the rules and their execution traces, RFFT significantly improves length generalization: GPT-3.5-Turbo fine-tuned on 1-5 digit addition achieves over 95 % accuracy on 12-digit addition, surpassing scratchpad fine-tuning by 40 %.
Despite the compatibility with general tasks and pretrained LLMs, RFFT [19] is proposed for single- task settings, where they prepare data and fine-tune the models on three tasks separately: addition, base-9 addition and last letter concatenation. This setting is impractical for users and limits model generalizability. Users must prepare task-specific sule-following datasets and perform extensive fine-tuning, which is costly process that requires separate models for each task. More critically, tagk RFFT only models the relationship between one specific rule and its instances, failing to leverage the shared struclures and generalization polential across different rules.
In this paper, we investigate the task transferability and generalization of the rule following capacity of models, and propose Meta Rule-Following Fine- Tuninn -FFT). We find that through fine-

---

tuning on a large-scale mule-following dataset with diverse tasks, a model shows positive transferability on unseen tasks with minimal adaptation.
As our first contribution, we collect 86 different length generalization tasks with 310k training samples from four task domains including code execution, number processing, logic and symbolic reasoning, which significantly broadens the previous length generalization tasks which mainly focus on addition, sorting or other basic operations. For each task, we manually annotate the code (or pseudo-code) for each task as its rule, as well as template script that can generate a detailed trajectory process for rule-follooee following for each question. Based on these template scripts, by simply providing the problem variables, the corresponding rule- rule-following trajectory at any desired length can be automatically generated, which can then be used to train models. Finally, we collect 3 31kk training samples on 74 tasks while the other 12 tasks are reserved as test sets.
In the experiments, the models are first fine-tuned on 74 RFFT tasks (we call it rule-following "pretraining "), leading to a fule-following foundation model. Then, the models are further adapted to the downstream task with minimal fine-tuning. These two-stage models show significantly better performance than both baseline models (like direct answer or CoT of reasoning models) and the single-task RFFT models. Specifically, a 32B model fine-tuned on 1-5-digit addition achieves 95 % accuracy on 30-digit addition, vastly outperforming reasoning models of comparable or much larger parameter size Sreepeek--R167111 72%; QwQ-32B: 32% and vanilla RFFT (40%).
Notably, these models with rule-following pretraining can solve unseen tasks with high accuracy with the help of only one example, suggesting these models learn task-generalized in-context rule-following ability. This capacity means these models can be directly used by users who cannot modify model parameters, as long as one example exemplify the rules is provided in the context. At the same time, the model can also generalize to rules written in natural language style.
We further demonstrate that the foundation model robustly acquires shared computational prim- itives (e.g., loop maintenance), which are critical for cross-task generalization. Our experiments reveal that in vanilla RFFT, where models are trained separately for each task, loop maintenance is a primary eтror source. In contrast, Meta-RFFF where models are enhanced by sule-following pretraining on tasks with shared computational structures, exhibits significantly more precise loop maintenance in downstream tasks. These findings confirm that meta-rule-followiie capability stems from mastering transferable computational patterns rather than task-specific ones.
In summary, we construct a large-scale length generalization dataset comprising 86 diverse tasks spanning diverse domains, enabling systematic study of rule-following transferability ($3.2). Our pro- posed Meta-RFFT framework demonstrates that multi-task post-training on 74 tasks facilitates strong length generalization unseen tasks with minimal downstream fine-tuning ($4.2) or even I-shot prompting ($4.3). Crucially, we identify that this transferability stems from models learning shared computational primitives that underlie diverse tasks ($4.2), while maintaining robust performance when rule formats transition from formal code to natural language ($5).
2 Related Work
Length generalization. A series of studies have attempted to tackle this issue by modifying positional encodings (PEs) and data formats [58, 41, 21, 23, 60, 4, 28, 5]. However, these efforts face several key limitations. First, the proposed PEs and data formats are often specifically tailored to symbolic tasks, making them difficult generalize to broader tasks. Second, the methods are typically tested on small-scale models trained from scratch and do not scale well to practical-scale LLMss. Another research direction, including single-task RFFT [19, 17, 52], addresses length generalization by training models on explicit rules and more elaborate reasoning processes.
Case-based reasoning or rule-based reasoning. A central question in understanding LLM rea- soning is whether their strong performance stems from pattern matching or mere memorization (or "case-based reasoning" in Hu al. [19]). or genuine rule acquisition. Recent studies reveal that LLMs often rely on memorized examples and shortcuts rather than systematic reasoning. Studies show they struggle with counterfactual reasoning [49, 54], reason via subgraph matching [13], and depend on nearby examples for math tasks rather than general rules [19]. On the other hand, research on "grokking" [37, 26, 30, 57] suggests that models can learn interpretable rules of arithmetic reasoning
long after overfitting the training set. Yet this phenomenon remains limited to single-tas task settings. It
3

---

is unclear whether rule-based reasoning scales to multitask LLMs. To bridge this gap, we propose Meta-RFFT, which trains models to follow explicit rules across diverse tasks.
Instruction following. Following natural language instructions is a fundamental capability of LLMs. Prior work has introduced numerous datasets to enhance this ability [22, 43, 50, 47], enabling models to leverage their underlying knowledge, interact naturally with users [36], and handle diverse tasks [55]. However, existing models trained on these datasets still struggle to accurately execute complex instructions, primarily due to limited high-quality training data [11]. Consequently, ensuring strict adherence to complex instructions- -or in this paper, precisely following rules to achieve robust length generalization- remmnin open challenge. In our experiments, we use instruction-tune LLMs (c.g., 1ertn-2.5-7B-Instruue and Bwven2.5-32B-Insstrue [39]) as baselines. We further compare Meta-RFFT with standard cerpuuctiooofolowiine fine-tuning on downstream tasks, demonstrating Meta-RFFT's superior performance.
LLMs with programs. Numerous efforts have been made to integrate programs with LLMs to enhance the capabilities of both. LLMs can help with code execution [24] and help developers write code and debug more efficiently [20, 53, 46]. Besides, the formal structure of code helps with task decomposition and enhances LLM reasoning [15, 3, 18, 24, 32].
3 Methods
3.1 Meta Rule-Following Fine-Tuning (Meta-RFFT)
In this section, we first review vanilla RFFT proposed by Hu et al. [19], and introduce Mcta-RFFT.
Vanilla RFFT Hu et al. [19] proposes RFFT, which, as shown in Figure I, includes the rules to solve the task in the input and detailed rule-execution process in the output. We refer to the method from Hu et al. [19] as vanilla RFFT in this paper and identify three key components as follows: (1) the rules required to solve a task must be explicitly provided in the input; (2) before executing an action, the model is required to recite the corresponding rule to ensure precise adherence; and (3) the model must describe the variables modified by the action, detailing their states before and after execution. While we primarily use programmatic representations of rules to ensure elarity and precision, the rules discussed in this paper are not limited to code. In Section 5, we also explore natural language rules and investigate the model's ability transfer rule formats from code to natural language.
Meta- RFFa- As illustrated in Figure 2, Meta- RFFT adopts a two-stage pipeline:
Meta-RFFT Process
Base Model
RF Pretrrarrnnn: REFT 74 tusks length
1) RF-Pretraining: We first fine-tune the model diverse set of mule-following tasks of lengths of 1-15. The tasks span code execution, number processing, symbolic and logic reason- ing, which are detailed in Section 3.2. It should be noted that RF RF-pretraining is supervised fine- tuning process on a large-scale dataset.
Task1: from
Task2: from BBH
T from
Giver an imtoger amuu
Q: you follow these nntrictions, gogg returm the starting point? Alwuy forward. Tahe stops Take steps forward. follows:
Dr coin he Alioe dosee not flip coin.
the still up?
preserstig endernoe
flippng
the non zacro etements..
fellown:
((wit) 2), (forward.
[Paler, Truee)
tasks
SR tasks
2) Downstream Adaptation: The model is then adapted to target tasks via either (i) minimal fine-tuning on 1-5-length samples or (ii) 1 shshot prompting using exemplars of fewer than 5 steps. tasks
RF Foundation Model
Downstream Adaptation: RFFT/ 1-shot ICL on the target
task of length 1-5
Downstream Task: from NUPA
Downstream Task: from LC
Crucially, evaluation is performed seen during RF-pretraining to assess cross-task and even cross-domain transferability.
nambers 123 4567.
Hi
Given number 12345, repootedle add kis digits unell resut? has one
No taok overlap with (1 danaannng
During RF- -rerrrtai,,, the model expected to grasp the shared commonalities and funda- mental rule concepts, such as loop. By leverag- ing these shared structures, Meta-RFFT enables models to adapt to new target tasks with minimal fine-tuning even solve them through few-shot
Target Model
Figure 2: The pipeline of ReFa- LC, BBH, SR and NUPA stands for LeetCode, Big-Bench Hard [42], Symbolic Reasoning [48] and the NUPA Benchmark [52] respectively.

---

prompts. Additionally, training across multiple tasks relieves overfitting the task-speccnf patterns, encouraging the model to transform from case-based reasoning more robust rule-based reasoning.
3.2 Data Construction
To extend the horizon of length generalization, and to facilitate large-scale multi-task training as well as comprehensive evaluation, we find essential to construct a large-scale length gen- eralization dataset. When selecting these tasks, we follow these guiding principles:
Table 1:
The statistics of our dataset. We list the number of tasks collected from each data source and their corresponding split in the RF-pretraining stage or the downstream adaptation stage.
Data Source
RF-Pretrain Adaptation
Total
1) Tasks must inherently require length gener- alization. Specifically, solving the tasks should depend on iterative reasoning. For example, the coin flip task shown in Figure 2 necessitates enu- merating each participant's 's actions to determine the final state of the coin. Here, we use the number of participants to denote "length".
LeetCode
8
NUPA
4
Big-Bench Hard
0
Symbolic Reasoning
0
All Sources
12
2) Tasks should avoid excessive complexity within single iteration. Each iteration should be manageable for the LLM, as our goal is to isolate errors caused by length generalization failures rather than by inherent task complexity. Therefore, we exclude tasks with complex inputs (e.g., graphs, multi-dimensional data) or advanced math operations, which remain challenging for current L.L.s.
Following these principles, we construct dataset covering diverse domains, including code execution, number processing, logical and symbolic reasoning. Our data sources are as follows:
LeetCode Problems.' Since most problems on LeetCode can be scaled with varying input sizes- primarily in terms of length-many of them are naturally suited for evaluating length generalization. For instance, in the task LCC Add Digits ("repeatedly sum all digits in an integer until the result is single digit"), we use the number of digits in the input to denote the inherent "length" of the task. Based on this criterion, we selected 74 tasks from the LeetCode platform.
NUPA. NUPA is a benchmark designed to assess the basic number processing capabilities of LLMs [52]. While many tasks in NUPA are still overly challenging for current LLMs, we select four practical tasks feasible within the context length in terms of RFFT.
Big-Bench Hard. The benchmark includes reasoning tasks considered challenging for LLMS [42].
We select 6 tasks that are suitable for length generalization evaluation.
Symbolic Reasoning, We select "coin flip" and "last letter concatenation" from Wei et al. [48].
For data annotation, we engaged skilled human annotators, undergraduates majoring in Computer Science from top-tier universities the nation, to write Python scripts that generate input-output traces for each task as shown in Figure 1. More detailed traces are shown in Appendix G.1. Fach task is implemented as a Python class to automatically generate samples of any given length. All scripts underwent rigorous code reviews and filtering.
As shown in Table 1, our dataset includes 86 tasks in total, with examples of each domain presented in Appendix C.2, and the detailed description and length definition of each task in Appendix H.
4 Main Results
4.1 Experimental Setup
As introduced Section 1, our Meta-RFFT involves RF-pretraining and downstream adaptation.
As shown in Table 1, in the RF-pretraining stage, we fine-tune the model on 74 tasks, aiming to develop model that can strictly follow rules across multiple tasks and potentially transfer this capability to new tasks. For each task, 300 rule-following samples are generated for each length from 15, resulting in approximately 310k samples in total. We experiment on models of two different sizes: Qwen2.5-7B. In-stucttt and Owen2.5-32BB 32B-Insttuct [39]. The 7B model is fine-tuned with fall-parameter training, while the 32B model fine-tuned with PiSSA [29].
lattp://Deetcodd..ccoprrooe
5

---

Digits
Zeroes
Hamming Distance
LC Crewler Folder
1.0
1.0
Accurecy
0.8
0.6
044
0.4
0.2
0.0
Dig
Chunk Array
String Sequence
1.0
Accurey
25
20
NUPA Get Digit Integer
NUPA Intager
MIPA Digit Max Intogirr
Langth intage
Accuncy
Vanilla RFFT
Direct Antwer
Scratchoad
10
3.7
20
25
20
10
22
20
Length
Length
Longtth
Length
Figure 3: Length generalization performance of direct answer, scratchpad, vanilla RFFT and Meta- RFFT on LeetCode and NUPA tasks. The shaded region represents the in-distribution test results (length < 5), while the unshaded background corresponds to out-of-distribun lengths (length 2 6). Here the base model is 1eenn...-7B-Isstruee
In the downstream adaptation stage, we evaluate the models on 4 NUPA tasks and 8 LeetCode tasks of appropriate difficulty and practical significance respectively. The description of each downstream task is provided in Appendix C.3. We first train the models on data of lengths from to 5 and then test their performance generalization performance. For each task, we generate 1,000 samples for each length from to 5, resulting in total of 5k training samples. Both the 7B and 32B models are fine-tuned through PiSSA in the downstream adaptation stage. We evaluate models on 100 samples per length per task. Detailed training hy perraaaraeeeess are provided in Appendix D.
nut-of-distribution (OOD) lengths from 6 to 30 to evaluate the length
Baselines We use three baseline fine-tuning methods for comparison: direct answer, scratchpad, and vanilla RFFT. The input-output sequences are shown in Figure 1. The base model is fine-tuned directly on the target task lengths from 1 to 5. To ensure fairness, all baseline methods the identical downstream adaptation settings of Meta-RFFT including training samples and steps. For long-CoT models, we evaluate using the same input prompts as the direct answer and scratchpad baselines in Figure 1, with temperature=0 and mox_tokee=24.000,
4.2 Meta-RFFT Enhances Task- Bask-Transferabl Length Generalization
The length generalization perfor- mance of Qwen-2.5-7B-Innsine trained with direct answer, scratchpad, vanilla RFFT and Meta-RFFT is shown in Figure 3; the results of Qwen-2.5-32B-IIntteee
Table Overall metrics of performance of different methods across all 12 test tasks. Here, ACC Len30 measures average accuracy at length 30; Max_Len 90% Len_90% represents maximum
length sustaining 290% accuracy averaged across tasks.
are shown in Figure 9 in Appendix F. Besides, we provide two unified metrics to give overall performance compar- ison across all tasks: ACC_Len30 which measures the average accu- racy at length 30 across tasks; and Max Len 90%, which represents the maximum length (averaged across tasks) where the model maintains 2 90% accuracy. The overall performance summarized in Table 2.
LeC31enn3
Max_Iee Lee____%________
DeepSeck-R.1-611 QwQ-32B
0.84
19.17
0.79
19.33
Tine-Tuned Models
7B model
32B model
7B model
32B model
Direct Answer
0.16
0.30
6:00
12.67
Scratchpad
0.30
0.41
7.50
11.17
Vanilla RFFT
0.40
0.67
9.33
18.17
Meta-RFFT
0.77
0.98
21.17
30.00
Overall, Meta-RFFT consistently outperforms other methods in length generalization for both 7B and 32B models. The 7B Meta-RFFT model exhibits slower performance decline as sequence length increases, whereas direct answer, scratchpad, and vanilla RFFT suffer sharper drops when extrap-

---

(Loop Errnns)
Relative #lteration Error
Error Percentage (%)
60
Meta RIFT (Non-lop lo op Emrrs)
Meta RFFT
50
Vanilia RFFT Emross
1.5
Vanilla RFFT
Vonilia RFFT (kon-loop Emrrs)
40
1.0
30-
20
0.5
10
0.0
Ads Diats
Bove Zeroes
Hamming Datance
Crowter Lag Faider
ARemate Digit Sum
Chunk Army
Smiigg Sequence
Villd Palindttem
Add Digits
Move Zeres
Hamming Distance
Crawter Log Felder
Altemate Digit Sum
Chunk Army
string Sequence
Valld Palinstrome
(a) Error distribution in downstream tasks.
(b) Relative error of the loop count.
Figure 4: Error analysis of vanilla RFFT and Meta-RFFT models.
olating to longer sequences. Notably, the 32B model with Meta-RFFT achieves a Max_Les -00% of 30.00, as shown in Table 2, demonstrating stable performance up to 6x the training length. This suggests that the advantages of Meta-RFFT can be further developed with stronger base models.
Against cutting-edge long-CoT models, the 32B Meta-RFFT model improves ACC_ by 14% over DeepSeek- DeepSeek-R1-671B
R1-671B (84%) and 19% over QwQ-32B (79%). Max Len Laae_LL___9999000 90%, surpasses both by over 10 lengths, underscoring superior robustness in length generalization. To provide insights for why cutting-edge long-CoT CoT models fail in such seemingly intuitive tasks, such as long-integer addition, we provide an example eтror case of DeepSeek- R1--611161111 IB in Table 13 in Appendix F. More detailed results of long-CoT models are shown in Figure in Appendix F.2.
Error analysis: how does Meta-RFFT help length generalization? We analyze the errors of both vanilla RFFT and Meta-RFFT models and identify a primary cause of failure in length generalization: incorrect loop maintenance. Specifically, models often either terminate loops too early or fail exit them, leading to repeated outputs until the context window limit is reached. As shown in Figure 4(a), errors due to incorrect loop counts form a substantial portion of total errors.
We hypothesize that RF-pretranning exposes the model to numerous rule-following examples involving loop control, enabling
learn this sub-skill effectively. To test this, we measure the relative error between predicted and true iteration counts (Figure 4(b)). Meta-RFFTT models exhibit significantly lower loop count errors than vanilla RFFT across tasks, confirming our hypothesis.
This reduction demonstrates that RF-peetraining improves the model's ability to manage iterative reasoning, which directly contributes enhanced length generalization. Overall, the results indicate that length generalization transferability arises from mastering transferable computational patterns rather than task-specific ones.
Analysis of Meta-RFFT's performance advantage over vanilla RFFT To understand why Meta- RFFT outperforms vanilla RFFT, we analyze their performance and training dynamics. Training curves during the downstream adaptation stage for both 7B and 32B models are shown in Figures 13 and 14 (Appendix E.4). Meta-RFFT models start with lower initial training loss, as their first- stage pretraining familiarizes them with the rule-following paradigm, which aids faster adaptation. Notably, while both methods eventually reach similar training loss levels in most tasks, Meta-RFFF consistently achieves better length generalization. This suggests that vanilla RFFT's limitations are not due to insufficient training. We further validate this by evaluating an intermediate Meta- RFFT checkpoint (Meta-RFFF) RFFT-ckk6F))) which has higher training loss than the converged vanilla RFFT. Even so, Meta-RFFTTccpttel outperforms vanilla RFFT (Figures 13, 17), confirming that Meta-RFFT's advantage arises from improved systematic generalization, rather than simply better fitting to training data.
7

---

LC Add Digits
Zeroes
Hamming Distance
LC Crawier Log Folder
1.2
1.0
Accurary
5-
0.8
0.5
0.6
64
0.4
0.4
0.2
Digit Sum
Chunk Array
String Sequence
Palindrome
1.-
5.8
0.8
0.8
Accorey
10
20
Digit intager
NUPA Intager
NUPA Digit Max Integer
NURA Langth Intager
Accunry
RF Pe-Pretraine I-shot
0.2
10
20
20
20
20
20
20
Length
Length
Length
Longth
Figure 5: The I-shot performance of the base model (Qwenn255-7B-Imstrrcc)) and the RF-pretrained model (RE-pretrained Qwen-2.5-7BBInssruue
4.3
In-Context Learning
To enhance Meta-RFFT to be more user-friendly, we explore ICL settings in the downstream adaptation stage, as shown in Figure 2.
Experimental Settings To enable the model to adapt to the in-context learning (ICL) paradigm, where few-shot exemplars are provided within the input, include 1-shot exemplar in each training sample. In-context learning requires the model to establish stronger correspondences between rules and execution traces, as it must learn robustly follow a new rule from just a single exemplar. To improve this, we augment the training data with synthetic tasks, each assigned a unique rule, This approach increases task diversity and encourages the model to rely on the provided rules during training. Specifically, we manually design 22 code snippets and their corresponding rule-following outputs (details Appendix G.2). For each sample, rules are dynamically composed by randomly selecting snippets, which enables arbitrary task generation with varied rules and outputs. Using this method, we create 100k synthetic samples and combine them with 310k samples from 74 tasks in Figure 2 to form the final ICI. training dataset in the RF- RF-pretraining stage.
Results The ICL performance of 7B models is shown in Figure 5, with results of 32B models in Figure 10 in Appendix E.1. For both model sizes, the RF-pretrained model significantly outperforms the base model on downstream tasks in the 1-shot setting. Notably, the 32B model achieves Max Len 90% of 28.5, an improvement of 14.5 over the base model and even 10.3 over the vanilla RFFT model which is fine-tuned on downstream tasks. Crucially, this means an RF-pretrained model can achieve robust length generalization on unseen tasks with only one exemplar, which is particularly valuable property for real-world deployment where task-specific fine-tuning is too costly.
5 Analysis
What about following natural language rules? We use rules represented by Python programs in the previous sections due their clarity, conciseness, and low ambiguity. However, rules can be expressed in various forms, and in everyday life, natural language is another primary medium for representing rules. We further investigate whether models trained on code-based rules during RF- pretraining can adapt to downstream tasks involving natural language- based rules. More specifically. to investigate whether the superior performance of Meta-RFFF on target tasks truly stems from genuine understanding of general rules rather than overfitting to specific code statements like pop () and insert () during the RF-ppetraiiing stage, we evaluate its adaptation to natural language rules in downstream tasks. Crucially, while Meta-RFFT is pretrained on code-based rules, we use natural language rules for fine-tuning the downstream adaptation stage, ensuring no overlap in specific statements. An example of natural language rule is provided in Appendix G.3.
8

---

LC Add Digits (NL Rules)
NUPA Add Integer
1.00
1.00
Accuracy
0.75
Accuracy
0.75
0.50
0.50
Meta-RFFT Vanilla RFFT
Meta-RFF RFFT
0.25
0.25
0.00
0.00
0
10
20
30
0
10
20
30
Length
Length
Figure 6: Vanilla RFFT and Meta-RFFT re- sults LCC Add Digits. Here the model is Qwen2.5-7B-Instte
Figure 7: The performance of the Qwen2.5- 7B after Meta-RFFT and RL on integer addi- tion.
As shown in Figure 6, Meta-RFFT still significantly outperforms vanilla RFFT on LC Add Digits across lengths 12-30. This confirms that Meta-RFFT's advantage arises not from memorizing code syntax but from acquiring meta rulc-following capability that enhances length generalization.
What about reinforeement learning for rule following? While reinforcement learning (RL) has shown success in general reasoning, argue that SFT is better suited for enforeing strict rule-following behavior. Unlike RL with outcome reward, which only optimizes for final-answe correctness, SFT directly maximizes the likelihood of the model generating rule-compliant intermedi- ate reasoning steps, which is crucial for strict rule adherence. To validate this, we optimize the base model using Proximal Policy Optimization (PPO) [40]. We provide training details in Appendix D.3. The RL variant achieves lower accuracy, confirming that pure outcome supervision fails to ensure rule compliance, as shown Figure 7. Instead of learning rule-following behavior, the model tends to shortcut to direct answers, impairing generalization to longer reasoning chains (see Table 14 in Appendix for example error traces). Moreover, while RL training requires 64 H800 GPU hours per task, our Meta-RFFT method achieves better performance in just 2.4-4.4 GPU hours, demonstrating significantly higher efficiency. The detailed training compute are listed in Table 8 in Appendix D.2.
Comparison to instruction following Pre- vious studies have focused on enhancing the instruction-followiie capabilities of LLMs [22, 43, 50, 47], fundamental ability for their prac- tical application. However, existing instruction- following models still struggle to adhere to com- plex rules. In the length generalization scenarios, as the inherent "length" of a problem increases, the corresponding rules grow more complex, and models often fail to strictly follow these rules strictly. We compare current
Table 3: Overall comparison between Meta-RFFT and Tulu3. The base model is Llama3.1-8B.
ACC_Lenss (1)
Max_Len Lex_Len__9% (f)
Tulu3 Meta-RFFT
0.16
0.67
0.38
11.67
current instruction- instruction -ostuutioo-follooinng methods and Meta-RFFT from two perspectives.
First, in our previous experiments, including fine-tuning (7B: Figure 3, 32B: Figure 9) and ICL (7B: Figure 5. 32B: Figure 10), our baselines are advanced instruction-tuneet models (Qwen2.5-7B- However, they exhibit poor length generalization performance,
Instruct and Swwen.55-32B-Inttreue especially when provided with 1-shot rule-following exemplar, they fail to strictly adhere to the given rules. In contrast, after Meta-RFFT, these models demonstrate significant improvements.
Second, we compare Meta-RFFT and instruction tuning with Llama-3.1-88 1-BB [16] as the base model. For instruction tuning, evaluate 1.1ma-3.1-Tulu-3 1-8B [22], version fine-tuned the Tulu3 dataset to enhance instruction following, with 1 1-shot prompting to provide a rule-following exemplar. As Table 3 shows, the instruction- tuned model fails to consistently follow rules during reasoning, while Meta-RFFT achieves significantly better performance. Full results are in Figure 12 (Appendix E.3).
Generalization to practical tasks To validate the practical value of Meta-RFFT beyond sym- bolic tasks, we evaluate our method on real-world scenario: the Airline Baggage Cost Es- timation task from Zhou et al. [59]. This task requires models to interpret and apply natu- ral language regulations- capability that cannot be fully reduced to formal code execution.

---

We train models on samples with length 1-8, and report test accuracy on both in-distribution lengths (2-8) and OOD lengths (10-16). As shown in Figure 8, Meta-RFFT significantly outperforms vanilla RFFT in the practical do- main, while current LLMs perform poorly on it, and even strong models like Claude-3.5 and o opreview degrade rapidly with task length growing.
RuleArena Airline
Meta-AFFT
Vanilla RFFT
Accuracy
al -review
0.6
Claude-335
Qwen 2.5-728
0.2
Impact of Meta-RFFT on general model capabilities The extensive RF-pretraining involved in Meta-RFFT in- troduces a potential risk of distribution shift, which can lead to catastrophic forgetting [14, 27] of the model's gen- eral capabilities. However, this issue can typically be mitigated by mixing some pretraining corpus during fine-tuning.
20
30
Length
Figure 8: Length generalization perfor- mance on the airline task.
To preserve the model's general capabilities, we augmented the meta-nule-folloving fine-tuning data with training samples from the GSM8K mathematical reasoning dataset [7]. Specifically, for each training example in GSM8K, we use the base model Dwee2.5-7B-Instruue to generate 10 candidate answers and filter the correct responses the training set, forming filtered dataset of 7182 samples.
The results on length generalization (averaged across 8 LeetCode tasks) are shown in Table 4, and the performance on GSM8K test set are shown in Table 5. We observe that merely mixing 7k samples (compared 310k Meta-RFFT data) effectively recovers the model's 's reasoning performance on GSM8K, while maintaining the strong multi-task length generalization ability. Notably, Meta-RFFT still significantly outperforms vanilla RFFT, demonstrating that general capabilities can be preserved with minimal additional data.
We extend this analysis other domains, including common-senss reasoning (ARC [6]) and instruction-followin alignment (Alpaca-Eval [25]). The results, presented in Appendix E.8 (Ta- bles 12 and 11), consistently show that all evaluated general capabilities can be recovered with minimal fine-tuning data while the model retains robust length generalization.
Table 4: Length generalization performance of Meta- RFFT trained with mixed data.
Table 5: Performance on GSM8K test set of Meta-RFFT trained with mixed data.
ACC, Len30 (1)
Max Len_90% (1)
GSMSK ACC
Vanilla RFFT
0.34
7.00
Meta-RFFT
0.82
22.75
Base Model Meta-RFFT
87.95
w/ GSM8K
0.79
21.25
87.80
6 Conclusion
We make an initial attempt to enhance cross-task length generalization in the post-training stage of LLMs. To this end, we construct large-scale length generalization dataset comprising 86 diverse tasks spanning diverse domains, which significantly expands length generalization research beyond traditional tasks like addition and sorting. Our experiments show that Meta-RFFT on tasks facilitates strong length generalization unseen tasks with minimal downstream fine-tuning I-shot prompting, even surpassing advanced long-CoT models. Through extensive analysis, we show that this transferability arises from the model's ability to learn shared computational primitives rather than relying on task-speciiic patterns. Additionally, we verify that models pretrained on code-based rules successfully adapt natural language rules in downstream tasks.
these
Acknowledgment
This work is supported by the National Key R&D Program of China (2022ZD0160300), Kun- peng& Ascend Center of Excellence, Peking University, and CCF-Tencent Rhino-Bine Open Research Fund.
10

---

References
[1] Cem Anil, Yuhuai Wu, Anders Andreassen, Aitor Lewkowycz, Vedant Misra, Vinay Ramasesh, Ambrose Slone, Guy Gur-Ari, Ethan Dyer, and Behnam Neyshabur. Exploring length gener- alization in large language models. Advances in Neural Information Processing Systems, 35: 38546-38556, 2022.
[2] Pranjal Awasthi and Anupam Gupta. Improving length-generalizzatonn in transformers via task hinting, 2023. URL httph:ttp//// / http///axxvvvv. org. (wrgg/abs223111 00726.
[3] Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. Program of thoughts prompt- ing: Disentangling computation from reasoning for numerical reasoning tasks. Transactions on Machine Learning Research, 2023.
[4] Hanseul Cho, Jaeyoung Cha, Pranjal Awasthi, Srinadh Bhojanapalli, Anupam Gupta, and Chulhee Yun. Position coupling: Improving length generalization of arithmetic transformers using task structure. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024.
[5] Hanseul Cho, Jaeyoung Cha, Srinadh Bhojanapalli, and Chulhee Yun. Arithmetic transformers bength-generalee in both operand length and count. In The Thirteenth International Conference on Learning Representations, 2024.
[6] Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint
2018.
[7] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprint I0.12210 2021.
[8] DeepSeek-AI. Deepseek Ilm: Scaling open-source language models with longtermism, 2024.
URL https:////aaat /aapiv///////////aaeeeeeeeeiaava http//aaxvvvvooorree/e wwwp:/iwwwrr/ab//200000 029544.
[9] DeepSeck-AL. Deepseek-v3 technical report, 2024. URL https://arxiv, wrgg/bs////a///////
9437.
[10] DeepSeek-AI. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning, 2025. URL
[11] Guanting Dong, Keming Lu, Chengpeng Li, Tingyu Xia, Bowen Yu, Chang Zhou, and Jingren Zhou. Self-play with execution feedback: Improving instruction-folloiing capabilities of large language models. arXiv preprint arXiv:2406. /3542, 2024.
[12] Yann Dubois, Balázs Galambosi, Percy Liang, and Tatsunori Hashimoto. Length-controlled alpacaeval: A simple way debias automatic evaluators. arXiv preprint arXiv:2404.04475, 2024.
[13] Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Sean Welleck, Peter West, Chandra Bhagavatula, Ronan Le Bras, et Faith and fate: Limits of transformers compositionality. Advances in Neural Information Processing Systems, 36: 70293-70332, 2023.
[14] Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 128-:188 1999.
[15] Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: Frogram-aides language models. In International Conference Machine Learning, pages 10764-10799. PMLR, 2023.
[16] Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. The llama 3 herd of models, 2024. URL https: // arxiv org/ abs/2407 21783.
11

---

[17] Kaiying Hou, David Brandfonbrener, Sham Kakade, Samy Jelassi, and Eran Malach. Universal length generalization with turing programs, 2024. URL https://arxiv www//og////////ooo abs/2407 3310.
[18] Yi Hu, Haotong Yang. Zhouchen Lin, and Muhan Zhang. Code prompting: a neural symbolic method for complex reasoning in large language models, 2023. URL abs/2305. 18507.
htt//xxxvv.o////// org/
[19] Yi Hu, Xiaojuan Tang, Haotong Yang, and Muhan Zhang. Case-based or rule-based: How do transformers do the math? In Forty-first International Conference on Machine Learning, 2024,
[20] Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real- world github issues? In 12th International Conference on Learning Representations, ICLR 2024, 2024.
[21] Amirhossein Kazemnejad, Inkit Padhi, Karthikeyan Natesan Ramamurthy, Payel Das, and Siva Reddy. The impact of positional encoding length generalization in transformers. Advances in Neural Information Processing Systems, 36:24892 244228, 2023.
[22] Nathan Lambert, Jacob Morrison, Valentina Pyatkin, Shengyi Huang, Hamish Ivison, Faeze Brahman, Lester James V Miranda, Alisa Liu, Nouha Dziri, Shane Lyu, al. Tulu 3: Pushing frontiers in open language model post-training arXiv preprint 1xXi:2441.15122 2024.
[23] Nayoung Lee, Kartik Sreenivasan, Jason Lee, Kangwook Lee, and DImitris Papailiopou- los. Teaching arithmetic to small transformers. In International Conference Learning Representations. ICLR 2024, 2024.
[24] Chengshu Li, Jacky Liang, Andy Zeng, Xinyun Chen, Karol Hausman, Dorsa Sadigh, Sergey Levine, Li Fei-Fei, Fei Xia, and Brian Ichter. Chain of code: Reasoning with language model-augmented code emulator. In International Conference on Machine Learning, pages 28259-28211 PMLR, 2024.
(25] Xuechen Li, Tianyi Zhang, Yann Dubois, Rohan Taori, Ishaan Gulrajani, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Alpacaeval: An automatic evaluator of instruction-oolloiinn models. https:/ //gi wiggtu...aa.. com/:attu-laaaaaaaaaaa cttp://tttttttaaaaaaaaaaaeeeaaaa 5 2023.
[26] Ziming Liu, Ouail Kitouni, Niklas S Nolte, Eric Michaud, Max Tegmark, and Mike Williams. Towards understanding grokking: An effective theory of representation learning. Advances in Neural Information Processing Systems, 35:34651-34663, 2022.
[27] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109-165. Elsevier, 1989.
[28] Sean McLeish, Arpit Bansal, Alex Stein, Neel Jain, John Kirchenbauer, Brian Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, Jonas Geiping, Avi Schwarzschild, et al. Transformers can do arithmetic with the right embeddings. Advances in Neural Information Processing Systems, 37:108012-10804.. 2024.
[29] Fanxu Meng. Zhaohui Wang, and Muhan Zhang. Pissa: vectors adaptation of large language models. Advances in Neural Information Processing Systems, 17:131038-1122111 121072, 2024.
Principal singular values and singular
[30] Neel Nanda, Lawrence Chan, Tom Lieberum, Jess Smith, and Jacob Steinhardt. Progress measures for grokking via mechanistic interpretability. In The Eleventh International Conference on Learning Representations.
[31] Rodrigo Nogueira, Zhiying Jiang, and Jimmy Lin. Investigating the limitations of transformers with simple arithmetic tasks, 2021. URL https::///atttttt a21002 13019.
[32] Maxwell Nye, Anders Johan Andreassen, Guy Gur-Ari, Henryk Michalewski, Jacob Austin, David Bieber, David Dohan, Aitor Lewkowycz. Maarten Bosma, David Luan, et al. Show your work: Scratchpads for intermediate computation with language models. In Deep Learning for Code Workshop, 2021.
12

---

[33] OpenAl. Introducing chatgpt, 2022. https://openal: cttp:////ccooooo///ooocoocgololt chatppt.
[34] OpenAl. Gpt-4 technical report, 2023.
[35] OpenAL. Learning to reason with 1ms,, 2024. URL /ttpa//rr/////ppaaaca////////rar
com/index/learnin
g- to-reeson- 1itss.
[36] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35:27730-27744, 2022.
[37] Alethea Power, Yuri Burda, Harri Edwards, Igor Babuschkin, and Vedant Misra. Grokking: Gen- eralization beyond overfitting on small algorithmic datasets. arXiv preprint wrXiv:2201.02177. 2022.
[38] Qwen Team. Qwen2.5 technical report, 2025. URL /
[39]
Qwen Team.
Qwen2.5 technical report, January 2025.
[40] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint vrXiv:1707.06447 2017.
[41] Ruoqi Shen, Sébastien Bubeck, Ronen Eldan, Yin Tat Lee, Yuanzhi Li, and Yi Zhang. Positional description matters for transformers arithmetic, 2023.
[42] Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc V Le, Ed H Chi. Denny Zhou, al. Challenging big-bench tasks and whether chain-of oiiin--o-thouuee thought can solve them. In ACL (Findings), 2023.
[43] Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Alpaca: A strong, replicable instruction -orllwiinn-folowinng model, 2023. URL https: //ct:m....mm//m/ stanf ord. addu/2023/03/111 13/ alpaca. html.
[44] Kimi Team. Kimi k1.5: Scaling reinforcement learning with Ilms, 2025. URL https: //arxiv. argg/bss/5011 12599.
[45] Jun Wang, Meng Fang, Ziyu Wan, Muning Wen, Jiachen Zhu, Anjie Liu, Ziqin Gong, Yan Song, Lei Chen, Lionel M. Ni, Linyi Yang, Ying Wen, and Weinan Zhang. Openr: An open source framework for advanced reasoning with large language models, 2024. URL https://arxiv wwwpsiivv.rr//oooooooeoo
09961..
[46] Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, al. Openhands: An open platform for ai software developers as generalist agents. In The Thirteenth International Conference on Learning Representations, 2024.
[47] Yizhong Wang, Swaroop Mishra, Pegah Alipoormolabashi, Yeganeh Kordi, Amirreza Mirzaci, Atharva Naik, Arjun Ashok, Arut Selvan Dhanasekaran, Anjana Arunkumar, David Stap, et al. Superr-naturalinstruciooo Generalization via declarative instructions on 1600+ nip tasks. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing. pages 5085-5109, 2022.
[48] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoe Le, Denny Zhou, et al. Chain-of-thoow prompting elicits reasoning in large language models. Advances neural information processing systems, 35:24824 24444224-44877, 2022.
[49] Zhaofeng Wu, Linlu Qiu, Alexis Ross, Ekin Akyürek, Boyuan Chen, Bailin Wang, Najoung Kim, Jacob Andreas, and Yoon Kim. Reasoning or reciting? exploring the capabilities and limitations of language models through counterfactual tasks. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguisties: Human Language Technologies (Volume 1: Long Papers), pages 1819-1862, 2024.
13

---

[50] Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. Wizardlm: Empowering large language models follow complex instructions. arXiv preprint arXiv:2304. 12244, 2023.
[51] Haotian Xu, Xing Wu, Weinong Wang, Zhongzhi Li, Da Zheng, Boyuan Chen, Yi Hu, Shijia Kang, Jiaming Ji, Yingying Zhang, et al. Redstar: Does scaling long-cot data unlock better slow-reasoning systems?, 2025. URL https: //arxv/ org/ abs/2501. 11284.
[52] Haotong Yang, Yi Hu, Shijia Kang, Zhouchen Lin, and Muhan Zhang. Number cookbook: Number understanding of language models and how to improve it. ArXiv, abs/2411.03766 2024. URL https: //ppi.apppaa//a semanticscholar D 1T: 273850412.
[53] John Yang, Carlos E Jimenez, Alex L Zhang, Kilian Lieret, Joyce Yang, Xindi Wu, Ori Press, Niklas Muennighoff, Gabriel Synnaeve, Karthik R Narasimhan, et al. Swe-bench multimodal: Do ai systems generalize visual software domains? In The Thirteenth International Confer- ence on Learning Representations, 2024.
[54] Chiyuan Zhang, Daphne Ippolito. Katherine Lee, Matthew Jagielski, Florian Tramèr, and Nicholas Carlini. Counterfactual memorization neural language models. Advances in Neural Information Processing Systems, 36:39321-39366 2023.
[55] Shengyu Zhang, Linfeng Dong, Xiaoya Li, Sen Zhang, Xiaofei Sun, Shuhe Wang, Jiwei Li, Runyi Hu, Tianwei Zhang, Fei Wu, et al. Instruction tuning for large language models: A survey. arXiv preprint arXiv:2308. 10792, 2023.
[56] Yu Zhao, Huifeng Yin, Bo Zeng. Hao Wang. Tianqi Shi, Chenyang Lyu, Longyue Wang, Weihua Luo, and Kaifu Zhang. Marco-ol: Towards open reasoning models for open-ended solutions, 14405.
2024. URL https: /tte::///rriii //wxxvixvv./ wwwg/aa////eeo.eeooooo
[57] Ziqian Zhong, Ziming Liu, Max Tegmark, and Jacob Andreas. The clock and the pizza: Two stories in mechanistic explanation of neural networks. Advances in neural information processing systems, 36:27223-27250, 2023.
[58] Hattie Zhou, Arwen Bradley, Etai Littwin, Noam Razin, Omid Saremi, Joshua M Susskind, Samy Bengio, and Preetum Nakkiran. What algorithms can transformers learn? a study in length generalization. In The Twelfth International Conference on Learning Representations. 2023.
[59] Ruiwen Zhou, Wenyue Hua, Liangming Pan, Sitao Cheng. Xiaobao Wu, En Yu, and William Yang Wang. Rulearena: A benchmark for rule-guided reasoning with lims in real-world scenarios. arXiv preprint arXiv:2412.00 08977,, 2024.
[60] Yongchao Zhou, Uri Alon, Xinyun Chen, Xuezhi Wang, Rishabh Agarwal, and Denny Zhou. Transformers can achieve length generalization but not robustly. In ICLR 2024 Workshop on Mathematical and Empirical Understanding of Foundation Models.
14

---

List of appendices
Limitations
16
B Impact Statements
16
Dataset Overview
16
C.I Data Annotations
16
C.2 Rule-Following Input Examples
16
C.3 Downstream Tasks Description
16
D Training Details
18
D.1 Training Hyperparameters
18
D.2 Compute Resources
18
D.3 Reinforcement Learning Settings
19
Additional Results
19
E.1
Results of 32B Models
19
E.2
Length Generalization of Long-CoT Models
20
E.3
Comparison between Meta-RFFT and Instruction Following
21
E.4
Training Curves
E.5
Effects of Data Dize on RF-pretraining and Downstream Adaptation
23
E,6
Effects of Number of Tasks in RF-Pretraining Stage
24
E.7 Effects of RF-pretraining Tasks Downstream Performance.
24
E.8 Effects of Meta-RFFT on General Model Capabilities
F
Error Cases
25
F.1
Error Case of DeepSeek-RI on Addition
25
F.2 Error Case of Models Trained with RI.
25
G Dataset Construction
27
G.1 Rule-following Dataset Annotation
27
G.2 Synthetic Data Generation
29
G.3 Natural Language Rules
31
Details of All Tasks
34
15

---

Appendices
A Limitations
In this work, we construct a large-scale length generalization dataset spanning diverse tasks and propose Meta-RFFT to enhance cross-task length generalization in LLMs. While this serves as an initial step toward understanding multi-task length generalization LLMs, our current study has several limitations. First, to isolate errors attributable to length generalization failures (rather than inherent task complexity), we restrict our experiments to controlled settings involving code execution, numerical processing, and symbolic / logical reasoning tasks. Consequently, our framework does not yet address more complex, real-world long-horizon reasoning domains, such as legal judgment generation or multi-step workflow execution. Furthermore, defining "length" as metric for problem complexity in such practical scenarios remains an open challenge. Extending length generalization to these domains, where models trained simpler instances must generalize harder problems, presents promising direction for future research.
B Impact Statements
Our work focuses on establishing a relationship between rules and their corresponding instances within LLMs. We aim to enhance model performance on downstream tasks by training the base model on a wide range rule-following tasks. Current training strategies fall short in enabling models fully grasp the rules that humans have summarized proposed that exist in the pre-training corpus. As result, while LLMs can easily recall rules, they often struggle to apply these rules strictly specific instances. Our proposed Meta-RFFF takes initial step towards strengthening models into meta rule followers, development that is crucial for improving both the reasoning capabilities and learning efficiency of these models.
Teaching LLMs to follow rules also aligns with societal demands. By ensuring that LLMs can reliably adhere to rules, contribute to the development of AI systems that are more aligned with human values, ethical standards, and practical applications, ultimately fostering trust and safety in their deployment.
C Dataset Overview
C.1 Data Annotations
We engaged skilled human annotators (undergraduate students majoring in Computer Science from top-tier universities) to write Python scripts generating input-output traces for each task. Each task was implemented as a Python class to enable automated sample generation at specified lengths.
Prior to annotation, we conducted detailed training session using 12 exemplar tasks to ensure consistency and quality. Annotators received step-by-step tutoring and were required to pass qualifying test sample task before proceeding.
Following annotation, all scripts underwent rigorous validation, including manual code review and automated filtering, to eliminate errors. All annotators were compensated fairly for their work.
C.2 Rule-Following Input Examples
We present a question example for each reasoning domain in Table
C.3 Downstream Tasks Description
The descriptions of 12 selected downstream tasks are listed as follows:
LC Add Digits: Given an integer, repeatedly sum its digits until the result is single digit,
L.C Move Zeroes: Given list of integers, move all zeros to the end while preserving the relative order of the non-zero elements.
16

---

Table 6: Input example in rule-following format for each category.
LectCode
NUPA
Follow the given rule to solve the question.
Follow the given rule to solve the question.
rule:
nule:
def moveZeros (nums):
def
add (numl, num2):
num zero 0
result =
result []
carry
while numa
Main Loop
number = nums.
while numi or num2:
if number 1= 0:
digit1 int (numl (-1]) if numi
result... append (number)
else 0
else:
digit2 int (num2 (-1]) if num2
num_zero
else 0
i 0
total digiti + digit2 + carry
while i num_zero:
result... append (0)
result (total
i return result
result
carry total//10
numl num1 [: if num1 else
Q: Given integer array [0, 16), move all zeros to the end while preserving the relative order non-zero elements.
numl
num2 num2 if num2 else num2
if carry:
result str (carry) + result result result 1strip ('0') '0' return result
Q: Add two numbers: 123 4567.
Big-Bench Hard
Symbolic Reasoning
Follow the given rule to solve the question.
Follow the given rule to solve the question. nule:
rule:
def navigate (moves)
def coin coin_flip flip(ffippfp):
Initialize Location
# Initialize Coin State
[0,
heads_up True # Main Loop
# Main Loop
while moves:
while flips:
move
pop (0)
flip flips pop
if move [0] ":eft":
flip:
[0]
move [1]
heads_up up not heads_up
elif move [0] = "right":
elae:
loc [0] += move
pass
elif move [0]
"forvard":
heads_up
loc [1]
move
Q: A coin heads up. Carrillo does not flip the coin. Cunningham flips the coin. Is the coin still heads up? In short, the situation 2 people flipping coins is as follows: [False, True].
elif move [0]
"backward":
loc [1] - move [1]
return loc == [0, o]
Q: you follow these instructions, do you return to the starting point? Always face forward. Take steps left. Take 2 steps forward. In short, the moves are as follows: [C'eeft, 2). ('forward', 2)).
17

---

The Hamming distance between two integers is the number of positions which the corresponding bits are different. Given two integers binary representation. return their Hamming distance.
LC Hamming Distance:
LC Crawler Log Folder:
Determine the final folder after performing the operations in the given list, where // moves up one level, / stays in the current folder, and x/ moves into folder x.
LC Alternate Digit Sum: Given positive integer where the most significant digit has positive sign, and each subsequent digit has the opposite sign of its adjacent digit, return the sum of these signed digits.
L.C Chunk Array: Given array and chunk size, split the array into subarrays of given size.
Given a target string, return a list of all strings that appear on the screen in order, using the minimum key presses. Key 1 appends "a" to the string, and Key changes the last character to its next letter in the alphabet.
LC String Sequence:
LC Valid Palindrome: Given string s, return true if it is a palindrome after removing all non-alphanumerie characters and converting it to lowercase; otherwise, return false.
NUPA Get Digit Integer: Get the digit at the given position (from left right, starting from O).
NUPA Add Integer: Add two integers.
NUPA Digit Max Integer: Compare two numbers digit by digit and return the larger digit each position, treating any missing digits as
NUPA Length Integer: Find total number of digits of the given integer.
D Training Details
D.1 Training Hyperparameters
Table 7 shows the training parameters for the RF-pretraining stage and the adaptation stage of the Qwen-7B and Qwen-32B models. the RF-pretraining stage, we use data samples with length of from the training set the validation set and the early stop strategy is applied based on the validation loss, which results in different training steps. Considering carly stopping, the number of training data samples for the 7B and 32B models in the RF-pretraining stage is 179k and 205k, respectively.
Since the RF- RF-pretraining stage involves fine-tuning across numerous tasks, we train more model pa- rameters during this stage. The 7B model uses full parameter fine-tuning, while due to computational resource constraints, the 32B model employs PiSSA with large rank of 32. In the adaptation stage, where fine-tuning is performed on different target tasks, we use PiSSA with a relatively small rank
Table 7: The training hyperparameters for the RF-pretraining stage and the adaptation stage.
RF- RF-Pretrain
Adaptation
Hyperparameters
Qwen-7B
Qwen-32B
Qwen-7B
Qwen-32B
Training Steps
800
700
156
156
Num of Epoch
Learning Rate
lc-5
Batch Size
256
32
Fine-Tuning Method fine-tune
PiSSA
PISSA Rank
32
D.2 Compute Resources
We list the training compute of RF-pretraining and downstream fine-tuning in Table 8. We conduct all the experiments NVIDIA H800 Tensor Core GPUs.
While Meta RFFT does require initial pretraining, our analysis shows becomes significantly more efficient than vanilla REFT when deployed across multiple tasks.
18

---

For the 7B model, the pretraining cost becomes justified after just 42 downstream tasks-a a threshold quickly exceeded in practice. For 32B model, the number is 72.
Computation Efficiency:
Data Efficiency: Meta-RFFT eliminates the need for task-specific fine-tuning data. Meta-RFFT works in the context of in-context learning with just the rule and one demonstration.
Table 8: Training compute of RF-errnrinn and downstream fine-tuning of both 7B and 32B models.
Model
Training Stage
Training hours
GPU Num
GPU Memory
GPU hours
7B
RF-pretrain downstream
18
8
80G
144.0
7B
0.6~
4
80G
2.4-v444
32B
RF-pretrain
22.3
32
80G
713.6
32B
downstream
2.0~3.0
4
80G
8.0~12.00
D.3
Reinforcement Learning Settings
We utilize Proximal Policy Optimization (PPO) without KL-regularization as our reinforcement learning algorithm. PPO updates the policy parameters to maximize the expected cumulative reward, while simultaneously updating the value function parameters ø by minimizing the value loss.
This is achieved by optimizing the following objective functions:
To(oe())) As, clip Tew (ar(s))
To(0e((() 1 e, e, 11 A.)]. (1)
(0) a
min
Tew (a (s)))))
Tvalue (
(x))
E or
(Vo(s)) R₂)²
We provide outcome reward, where the model receives reward of 1 only when its output answer completely correct, and otherwise. Key hyperparameters used in our implementation are listed in Table 9.
Table 9; Training Hyperparameters for PPO.
Hyperparameter
Value
Actor Learning Rate
le-6
Critic Learning Rate
9c-6
Train Batch Size
1024
Rollout Batch Size
256
GAE parameter
1.0
Discount Factor 7
1.0
Clipping Parameter
0.2
KI. Coefficient
0.0
E
Additional Results
E.1 Results of 32B Models
Fine-tuning results. In Figure 9, we list the length generalization performance of Qwen-2.5- 32B-Instruct fine-tuned through the following methods: direct answer, scratchpud, vanilla RFFT and Melu-RFFT. MeIu-RFFT significantly outperforms the rest of the methods, showing that rule- following is a meta ability that can be mastered by large-scale RF-pretrain and can benefit length generalization greatly.
19

---

Digits
Zeroes
Hamming Distance
Crawler Folder
2.0
1.0
Accuracy
5-
0.8
0.6
04
0.4
0.2
0.0
Dig
Array
Sequence
Accurey
20
Digit Intager
NUPA Intager
Digit Max Intog
Langth Intage
Arcuncy
Vanilla REFT
Direct Antwer
Scratchoad
10
30
20
15
20
50
22
20
Length
Longth
Lengtth
Length
Figure Length generalization performance of direct answer, scratchpad, vanilla RFFT and Meta-RFFT on LectCode and NUPA tasks. Here the experiments are all conducted on Qwen-2.5- 32B-Instruct.
In-context learning results. In Figure 10, we show the in-context learning performance of both the base model and the RF-pretrained model. Here, the base model we use Qwen-2.5-2 2.5-322-Innstruct The RF-pretrained model outperforms the base model by a large margin in the context of 1-shot learning on downstream tasks. RF-pretraining shows a positive transfer to the in-context rule-following capabilities in downstream tasks.
LC Add Digits
LC Move Zeroes
LC Hamming Distance
LC Crawler Log Folder
1.0
1.0
1.0
3.0
Accuncy
5.0
0.5
0.0
0.0
0.5
0.6
0.6
0.1
0.4
0.6
0.2
02
0.2
6.0
0.0
LC Altemaat Digit
Chunk
Stringgg Sequence
Valld Palindrame
1.0
6.8
0.5
Acourey
54
Integer
Integer
Digit Integer
Length Integer
Accurary
RF Pretralned shot Base 1-chot
Length
Length
Longth
Longth
Figure 10: The figure shows the 1-shot performance of the base model (Qwenn2.5-32B-Insttre and the RF-pretrained model (RF-pretrained Qwen-2.5-32B- Instructt...
E.2 Length Generalization of Long-CoTT Models
In Figure 11, we show the length generalization performance long-CoT models, including DeepSeek-R1 -671B, Seepseee--R--istill--e and QwQ-32B. Meta-RFFFT-enhancee Qwen-32B shows superior performance regarding length generalization with comparable or even much smaller parameter size.
20

---

Digits
Zeroes
Hamming Distance
Crawler Folder
2.0
1.0
Accuraty
0.8
0.6
04
0.4
0.2
0.0
Array
Sequence
Accurey
Digit Integer
NUPA Intager
MIPA Digit Max Intagiar
Langth intage
Arcuracy
QWQ 328
R3-072B
10
25
3.7
20
15
20
50
22 10
Length
Length
Lenggth
Length
Figure 11: Length generalization performance long-CoT models, including DeepSeek-RI ---ckk------B... SrepSeck-R--Distiie and QwQ-32B.
E.3
Comparison between Meta-RFFT and Instruction Following
We show the performance Meta-RFFT-enhanced 3lama-3.1-8B and the same model after instruction-tuning Tulu3 in Figure 12. For Meta-RFFT, we fine-tune the model on samples of lengths from to 5.
Digits
Hamming
Log
Accurey
10
15
25
25
20
20 LC Chunk Arrey
10
25
20 LC String Sequence
12
15
50
10
25
25
20
LC Altemate Dig Sum
LC Valid Palindrome
Accoury
10
25
10
70
20
10
10
10
NUPA Got Digit Integer
NUPA Add Intager
MIPA Digit Max Intog
NURA Langth Intog
3.0
Accuracy
Mett RFFT
Tulu3
0.2
0.2
50
15
0.0
20
0.0
25
50
0.0
25
25
Longth
Length
Longth
Longth
Figure 12: Comparison between Meta-RFFT and instruction following method Tulu3, using Llama- 3.B-8B as the base model.
E.4 Training Curves
We show the training loss curves of the downstream adaptation stage of the 7B base model and the 32B base model respectively Figure 13, Figure 14. The figures show that models trained with Meta-RFFT exhibit lower initial training loss compared to vanilla RFFT, as the former is already familiar with the rule-following paradigm due the first-stage pretraining. This allows Meta-RFFT models to fit the training samples more quickly during the adaptation stage. As training progresses, the training loss vanilla RFFT and Meta-RFFT models converges to similar levels most tasks. This indicates that the gap in length generalization performance between MFFT-RFFT and vanilla
21

---

RFFT is not due to the latter's s in- ability to fit the training data. More detailed discussions are put in Section 4.2.
Add
LC
Hamming
Crowler Folder
Virilla-AFF
graneg
MetsAIFT
150
150
25
77
100
125
152
1.00
25
50
75
102
325
150
LC Alternate Digit Sum
LC Chunk Arryy
LC String Sequence
Volld Palindrome
130
130
23
300
125
152
100
50
75
100
129
135
MUPA Get Digit Integer
NUPA Add Integer
NUPA Digit Max Integer
MUPA Length Integer
Taminn 1332
0.5
50
75
120
125
150
25
50
100 Num of Steps
75
125
153
75
150
125
150
25
50
75
100
125
150
Num of Steps
Nurn of Steps
Num of Steps
Figure 13: Training curves of Qwen2.5-7B-Innstrue in the downstream adaptation stage LeetCode tasks and NUPA tasks. The figure shows both the training curves of vanilla RFFT and the second training stage of Meta-RFFT.
Move
Hamminn
Log
0.5
0.5
Vanilla RFFT Meta&FET
1.0-
0.35
0.2
120
LC Altemate Digit
ChunkArray
String Sequence
LC Valid Palindrome
Traiing lozs
0.4
0.2
0.2
0.0
0.2
120
162
150
150
153
100
150
NUPA Get Digit integer
NUPA Add Integer
NUPA Digit Max Integer
NUPA Length integer
1.0
2.0
0.2
0.0
3.5
0.0
0.0
120
302
250
130
202
200
125
Num Steps
Mam Steps
Num Steps
Num of Steps
Figure 14: Training curves of Owen2.5-32B-Inm Instruct in the downstream adaptation stage LeetCode tasks and NUPA tasks. The figure shows both the training curves of vanilla RFFT and the second training stage of Meta-RFFT.
Besides, we conduct repeated experiments in the stage of downstream fine-tuning. We show the training curves different random seeds 7B RF-pretrained models the adaptation stage training in Figure 15, indicating that the adaptation stage training is stable across different seeds.
22

---

LC Add Dighs
LC Move Zeroes
LC Hamming Distance
LC Crowler Log Folder
Seed-42
Tranip
seed-250120
22
100
153
50
75
102
150
Alternate Digit Sum
String Sequence
Volld Palindromne
Tainrg
130
Digit Integer
Integer
Integer
Length Integer
Tariin
1.0
0.5
0.0
Figure 15: Training curves the adaptation stage of Meta-RFFT using different random seeds. Here we show the results of Qwen2.5-7BBInsttuu.
E.5 Effects of Data Dize on RF-pretraining and Downstream Adaptation
The effect of the data size in RF-pretraining We select several checkpoints from the RF- pretraining stage after the training loss has converged and perform downstream adaptation these checkpoints. The performance presented in Figure 16. In the early stages, training progresses, the model's final performance gradually improves. However, after reaching a certain number of steps, the model's performance stabilizes and no longer shows significant improvement. The models do not show signs of "grokking" during the RF-pretrrining stage.
these checkpoints on the corresponding tasks after fine-tuning is
The effect of the data size in downstream adaptation For the downstream adaptation stage, also analyze the effects of data size on performance. We select several checkpoints after the training presented in Figure 16. Similar to the
loss has converged. The results of these checkpoints RF-pretraining stage, in the early phases, the model's performance improves as the data size increases. However, after reaching certain number of steps, the model's performance stabilizes and no longer shows significant improvement, with no evidence of grokking observed.
For RF-pretraining stage, we select several checkpoints after the training loss has converged and perform downstream adaptation on these checkpoints. The length generalization performance of these checkpoints
LC Add Digits
LC Move Zeroes
Hamming Distance
LC Crawler Log Folder
1.00
1.00
202
1.00
Accurasj
0.75
352
6.25
0.25
125
6.25
5.92
10
15
10
0.00
10
15
25
25
10
2.0
10
15
10
20
25
30
LC Altemate Digit Sum
LC Chunk Arra
LC String Sequence
LGC. Valid Polindroma
1.00
Accuriyy
2.52
Steps
0.50
150
0.50
Stops 600
Steps 800
Length
Length
Length
Length
Figure 16: Effects of training steps in the RF-pretraining stage.
23

---

LC Add
LC Move
Hamming Distance
Crawler Folder
1.2
100
202
2.00
Acouras)
6.75
0.75
6.75
6:25
0.25
5.2
0.25
0.00
2.00
10
15
20
10
15
30
30
15
10
LC Alternate Digit Sum
LC Chunk Array
LC String Sequence
LG Valid Palindrome
Accracy
0.52
Steps
0.50
250
6.50
Stops 140
Stops 156
13
Longth
Length
Length
Length
Figure 17: Effects of training steps in the downstream adaptation stage of Meta-RFFT.
E.6 Effects of Number of Tasks in RF- RF-Pretraining Stage
We show in Figure 18 that when fine-tuned with only task in RF-pretraining stage, the model does not perform as well as Meta-RFFT-ed on 74 diverse tasks. This demonstrates that to enable robust multi-task length generalization, large-scale length generalization dataset necessary.
Hamming
Crawler
1.0
2.8
Accuneyy
2.6
3.4
3.4
0.2
3.0
Alternate
Array
Sequence
Palindrome
Accuacy
NURA Get Digit Integer
NUPA Add Integer
NUPA Digit Max Integer
NUPA Length Integer
Arconayy
Meta RFFT
task
0.0
3.0
20
20
Length
Length
Length
Length
Figure 18: Performance when RF-pretrained on single task versus 74 diverse tasks, showing the benefit of large-scale multi-task pretraining for length generalization.
E.7 Effects of RF Erepttraiinnn Tasks on Downstream Performance
The RF-pretraining stage originally includes tasks from three datasets: LeetCode, Big-Bench Hard, and Symbolic Reasoning. To assess the impact of RF- RF-preeraining tasks on downstream performance, conduct ablation where the model is RF -r-pretrddded only on the LeetCode subset.
Here we evaluate on downstream tasks, including LeetCode tasks (Move Zeros Valid Palin- drome) and 2 NUPA tasks (Add Integer & Digit Max Integer), all of which are unseen during RF-pretraining.
The results are shown in Table 10. We observe a slight performance drop when excluding Big-Bench Hard and Symbolic Reasoning, likely due reduced task diversity during pretraining.
E.8 Effeets of Meta-RFFT on General Model Capabilities
Similar to our experiments on GSM8K introduced Section 5, we mix general data into the downstream fine-tuning alongside the original rule-following data to show that general ability

---

Table 10: Results of Meta-RFFT with LeetCode-only pretraining on multiple downstream bench- marks.
Model
ACC Len30 (%)
Max 90% %
Results on LCC and NUPA
Meta-RFFT (complete pretrain dataset)
56.0
16.0
Mcta-RFFT (LeetCode only)
51.0
12.5
Vanilla RFFT
19.0
5.5
Results SR and BBH
Meta-RFFT (LectCode only)
68.0
20.7
Vanilla RFFT
37.0
9.3
preserved. The results of the model's general ability are shown in Table 11, and the length generalization results are shown in Table 12.
Regarding length generalization results, we test on 2 downstream task: LCC Valid Palindrome and NUPA Add Integer. Our findings indicate that incorporating 6,872 samples from ARC [6] and 8,000 samples from Alpaca-Eval [25] effectively restored the model's performance on these general benchmarks while maintaining robust multi-task length generalization.
On Alpaca-Eval. we observed significant increase in the standard win rate. However, this improve- ment partially attributable the model producing longer outputs, which are favored by this metric. To provide more balanced assessment, we also report the length-controlled win rate introduced by Dubois et al. [12].
Table 11: Evaluation of the general capabilities of Meta-RFFT with mixed training ARC and Alpaca-Eval.
Table 12: Length generalization performance of Meta-RFFT with mixed finetuning that incorpo- rates general data.
Model
ARC
Alpaca-Eval
ACC LVC_Len30ccm
Max_Lev 90% (1)
Acc
Win Rate
Controlled Win Rate
Length
Vanilla RFFT
0.20
1.0
Mcta-RFFT
0,58
8.0
Model
w/ ARC
0.63
8.0
RFFT
88.92
23.54
23.90
w/ Alpaca
0.60
8.0
Error Cases
F1
Error Case of DeepSeek-R1 on Addition
In Table 13, we present an eтrоr case where DeepSeek-RI fails to correctly solve a 30-digit integer addition problem. this case, RI makes two mistakes: (1) incorrect splitting: RI attempts to split the 30-digit integer into two parts, including 17-digit segment and a 13-digit segment. However, the first segment actually contains 18 digits, and the two parts overlap by one digit. Despite this mistake in the reasoning trace, RI miraculously corrects the eτror in the final answer; (2) copying error: R.1 makes an copy error the final answer, copying "771 1" to "7771".
F.2 Error Case of Models Trained with RL
While RL has shown success in general reasoning, argue that SFT is better suited for enforcing strict rule-following behavior. Unlike RL with outcome reward, which only optimizes for final- answer correctness, SFT directly maximizes the likelihood of the model generating rule-compliant intermediate reasoning steps, which crucial for strict adherence to structured rules.
We use RI (PPO) to optimize rule-following, The model does not learn rule-following behavior and instead exhibit tendencies to answer directly, thus fails to generalize to longer answers, shown in Table 14.
25

---

Table 13: An enror example of DeepSeek-Ro R1 on long integer addition. We only show the summariza- tion part as the thinking part is too long. R1 tricks itself during splitting the 30-digit number.
Input
Output
Q: Add two numbers: 8898509165985 +
To add the numbers 8898509165988 and 897653763 8976537611946888877777 19468384488888 3426157006, we need to align them properly and perform the addition step by step, considering carryovers.
Identify
digits The first number is 13 digits:
each number:
+ 8,898, ,09,, 188,
The second number is 30 digits:
897 763, 194 685 878 813 426 157,
2. Split the second number into two parts: The first 17 digits:
897 653 763, 19,, 685 878 (here R1 list 18 digits)
The last 13 digits: 8,813, 426, ,06
3. Add the first number to the last 13 digits of + the second number:
Last 13 digits of the second number:
4 8,813,428 111,,42 ,06,006
First number: 8, 8,898, 509 165,
4. Perform the addition of the last 13 digits: Align and add the digits from right to left, 4 considering carryovers:
8, 8,898 509, 165,, ,85 8,813 157, 150,000
17 17,711, 935 322 9911
,21,991
The result of adding these 13-digit numbers 17,711,993 322, 991, 391,,,,,,,2,,91, which digit number. This results in 4 carryover of to the higher digits.
14-
5. Adjust the first part of the second number: The first 17 digits of second number: 4 897,653, 19,,66,66,,9,,68,, 878 (still 18 digits) Add the carryover 1: 897 653 763 194, , 878 4 + +1 897, , 194, 685 879
6. Combine the adjusted first part with the S result of the addition: The adjusted first part:
4 897 ,66,,66,,,111 794, 6894,685,87
The last 13 digits of the sum (after
4 removing the carryover):
4 7,711,938, 322,991
7. Concatenate the results:
final result 897 653 763, 194 185,,85,, 685,,,86888 879 + folloved by 7,711, 935, 322, 991, which
+ gives the 30 30-digit number.
The result of the addition is: $9765776199451188711993999999
Correct answer should be:
89763776194458887119339999
26

---

Table 14: An error example of Qwen2.5-7B-RL, which is Qwen2.5-7B trained by RL on rule- following samples.
Input
Output
Follow the given rule to solve the question.
The given rule defines a function add (num1, num2) that adds two numbers represented strings. will use this function to add the two given numbers:
rule:
def add (num1, num2):
result =
carry
95924418734444122228777773111113 and
Main Loop
440884190197 05944776754441177721877666666333
while numl or num2:
digitl = int (numl [-1]) if numi
4 else
digit2
(num2 [-1]) if num2
4 else
Correct answer should be: 59924776774434177226644444666666
total = digit1 digit2 + carry
result = str (total110) + result
carry total//10
numl numi [ if numi else numi [:-1] if num2 else num2
num2 = num2 [
if carry:
result str (carry) result result result. 1etripp or '0' return result
Q: Add two numbers:
35944737774411771217777733111113 9101 440884190197.
G Dataset Construction
G.1 Rule-following Dataset Annotation
To generate the rule-following output for each task, the rules necessary to accomplish the task first need be provided in the input (examples shown Table 6), which can be generated by L.M. Subsequently, a data generation script is manually written for each task to produce the intermediate execution steps of the rule for any given input. With the fule-following output generation script and the input data generator, an arbitrary number of data samples can be generated. Here is an example of one data sample in the rule-following format.
Prompt:
Follow the given rule to solve the question.
Rule:
def add_digits (self, num: int) -> int:
while num sum =
while num:
sum += num % 10
num //=
num
return num
Q: Given an integer number 15, repeatedly add up all its digits until the result has only one digit.
Response:
27

---

1. Initialize
num = 15
2. Outer loop
while num 9:
num = 15
enter the loop
2.1 One iteration
sum 0
3. Inner loop
while num:
num 15
enter the loop
3.1 One iteration
sum num 10
num //= 10
num 15
num % 10 =
sum =0
now,
0 5 = num // // 10
while num:
num = 1
enter the loop 3.1 One iteration
+= num 10
num //= 10
num % 10 =
sum 5
now,
sum = + 6 num // 10=0
while num:
num 0
do not enter
num sum
sum 6
now,
num 6
while num 9:
num 6 do not enter 4. Return
return num
num = 6
So the answer is
28

---

G.2 Synthetic Data Generation
22 maittll code snippets are as below:
0: "if listi:\A An
listi O,, listi [0] += OO",
1: "if listi:\n
2: "if listi:\n
var = listl.pop(0) \n
1ist2. apppnd (var)", "var", append (var)",
"if listi:\n
var listl.pop()
(1istl.insert(O, O))" 5: "Listi.sort(",,
6: "List1.reverse))"
7: "listl li:ti[l:] if listl else listi",
"if list2:\n list1. insert list2(0]) \nelse: list1. instrin O)",
9: "val -iist[[-]] if list2 else (Anllit1 appeediv.
10: "if listi and list2 and listi[0] > list2[0] listi.pop(0))
11: "if listl and list2 and listi[-1] < list2[-1]:An listl.pop()"
12: "if listi:\n
13: listi and list2:\n liati.pop(0)",
14: "if listi and 1isti[0] % 2 0:An listi.pop(0)",
15: "if listi and listi[0] % 2 == 1:An list1.pop(O))
16: "if len (llist)) > lennnnist) : An
listl.pop())",
17: "if listl and listi[0] On listi.pop(0)",
18: listi and listi < O: listl.pop(0)",
19: "if 1ist2:\n append (oppp.)))0))))))))
20: "if listi:\m list1.pop()",
21: "if list2:\n 1ist2.pop()"
To further enhance rule diversity, we replace list1 and list2 with meaningless random strings in each sampled snippet. Here is prompt synthetic data sample with one-shot example:
Here is I example:
Follow the given rule to solve the question.
rule:
def process_list (ywhm, erep):
while ywhm and erep:
if yuhm: ywhm.popl
erep = erep[1:] if erep else erep if erep and erep % 0: erep (0))
if erep and erep[o] [0] % 1: erep erep-pop(0)
if erep:
erep (op(p))())
if ywhm:
ywhm. p)p
val [-1] if erep else 53
ywhm append
if erep:
var erep (0) ywhm. append (var)
return ywhm
Q: Given two lists, ywhm [3] and erep [50, 31], what is the final value of ywhm?
Initialize ywhm = [3]
29

---

erep = [50, 31]
2 Main loop
while ywhm and erep:
ywhm [3]
erep [50, 31]
enter the loop
2.1 One iteration:
if ywhm:
ywhm pop ()
ywhm= [3]
enter if
now,
ywhm = =0
erep erep [1:] if erep else erep
erep [50, 31]
now,
erep [31]
if erep and erep[O] 2 0: erep.pon (0)
erep [31] erep[0] % = 31 % 2 0= do not enter if
erep and erep[o] [0] 2 krep.pop(0)
erep [31]
crep[0] = 31 % 2
enter if
now,
erep=
if erep:
crep.pop(O)
erep []
do not enter if
ywhm: ywhm. ()p
ywhm=
do not enter
val erep [-1] if erep else 53 ywhm append (val)
erep= val = 53
ywhm =
now. ywhm [53]
if erep:
pop (0)
ywhm. avaand
erep = 0] do not enter if
30

---

while ywhm and erep:
ywhm = [53] erep [] do not enter
return ywhm
So the answer is [53]
Follow the above examples to answer the following question: rule:
def parresss_lsstyyhphe
eonx)
while cybez and eonx:
eonx. conx.reverse. () if eonx:
cybez. insert eonx(o])
else:
cybez. insert (0, 63)
if cybez and cybez [o] 9:
cybez.
if eonx:
eonx[-1] +=
if cybez and cybez [o] 2 == 1:
cybez. (0)(()
if
eonx[0] += 96
if cybez and cybez [o] 2 0: sybez.pop(()
if cybez:
cybez. ()
return cybez
Q: Given two lists, cybez = [31, 22, 95, 74, 70, 55, 39, 22, 77] and conx [53, 70, 50, 28, 15, 81, 92, 6), what is the final value of cybez?
G.3 Natural Language Rules
To generate rule-following output in natural language, we first convert code-formatted rules into natural language descriptions. The remaining process is the same as generating the output for the code rule. To ensure clarity and avoid ambiguity, each line prefixed with a number. An example of rule-following output in natural language is provided below.
Prompt:
Follow the given rule solve the question.
Rule:
1. Begin outer loop:
1.1 Check whether the number is single-digit number. If it is
not, enter the outer loop; otherwise, the loop is over, go to
step (2).
1.2 One iteration:
1.2.1 Initialize the sum the digits of the number in this iteration as sum equals 0.
1.2.2 Begin inner loop to calculate the digit sum:
31

---

1.2.2.1 Check whether the number is 0. If the number is not 0, enter the inner loop; otherwise, the loop is over, go to step (1.2.3). 1.2.2.2 One iteration:
1.2.2.2.1 Find the last digit of the number and add it b sum.
1.2.2.2.2 Remove the last digit from the number.
1.2.2.3 Return to the start the inner 1oop. 1.2.3 After calculating the sum of all digits, update the number with the value of sum.
1.3 Return to the start of the outer loop.
2. Return the remaining
number.
Q: Given an integer number 32, repeatedly add up all its digits until the result has only one digit.
Response:
The number is 32. Begin the process.
1. Begin outer loop:
1.1 Check whether the number is a single-digit number. is not, enter the outer loop; otherwise, the loop is over, go to step (2).
The number is 32, which is not single-digit number. Enter the outer loop.
1.2 One iteration:
1.2.1 Initialize the sum of the digits of the number in this iteration equals 0.
Initialize =.
1.2.2 Begin inner loop calculate the digit sum 1.2.2.1 Check whether the number is 0. the number is not 0, enter the inner loop; otherwise, the loop is over, go step (1.2.3).
The number is 32, which is not O. Enter the inner loop.
1.2.2.2 One iteration:
1.2.2.2.1 Find the last digit of the number and add it to sum.
number 32, the last digit of the number is 2. Add it to sum, sum = 0 2 2.
1.2.2.2.2 Remove the last digit from the number.
Remove the last digit from the number, number = 32 // 10 = 3.
1.2.2.3 Return to the start of the inner loop.
Back to the start of the inner loop.
1.2.2 Begin inner loop to calculate the digit sum:
1.2.2.1 Check whether the number is 0. If the number is not 0, enter - the inner loop; otherwise, the loop is over, to step (1.2.3).
The number is 3, which is not 0. Enter the inner loop.
1.2.2.2 One iteration:
1.2.2.2.1 Find the last digit the number and add sum.
number=33 the last digit of the number is 3. Add sum, sum 2
1.2.2.2.2 Remove the last digit
the number.
Remove the last digit from the number, number 3 // 10 0.
1.2.2.3 Return to the start of the inner loop.
32

---

Back to the start of the inner loop.
1.2.2 Begin inner loop to calculate the digit sum: 1.2.2.1 Check whether the number is 0. If the number is not 0, enter - the inner loop; otherwise, the loop is over, go to step (1.2.3).
The number is 0. The loop is over. Go to step (1.2.3).
1.2.3 After calculating the sum of all digits, update the number with - the value sum.
sum 5. Update the number with the value of sum, so number 5 now.
1.3 Return to the start of the outer loop.
Back to the start of the outer loop.
1.
Begin outer loop:
1.1 Check whether the number is a mangle-digis number. If it is not, enter the outer loop; otherwise, the loop is over, go to step (2).
The number is which is single-digit number. The loop is over. Go to step (2).
Return remaining single-das -digit number.
The number So the answer 5.
33

---

H
Details of All 86 Tasks
Split
Domain
Task
Description
Length Definition
Reference URL
Name
RF- pretrain
LeetCode Ic 2__2
We are passing pillow back and forth along line of n people for certain time, returning the final holder's position after directional changes at each end.
the number of people
https://leet
code cwm/
blems/pass
he he-pillow/de scription/
RF- pretrain
LeetCode lc_2129
If the length the word is or letters, change all letters to lowercase. If the length of the word is or more letters, change the first letter uppercase and the rest to lowercase.
the number of characters in the word
https:
//leetcode.c
om/ om/problems/ capitalize-t he-title/des
cription/
RF-
LeetCode lc lc_2210
Given a O-indexed integer array "nums", find out the number of hills and valleys in the array. An index is part of hill in nums if the closest non-equal neighbors of are smaller than nums[i]]. Similarly, part of a valley in nums if the closest non-equal neighbors of i are larger than nums[i]
the length of the array
https:
pretrain
//leetcode.c
om om/problems/
count-hills-a nd-valleys-i
index is
n-an-array/d
escription/
RF- pretrain
LeetCode 824
If a word begins with vowel, append "ma" the end of the word.If word begins with a consonant (i.e., not vowel), remove the first letter and append it to the end, then add "ma". Add one letter "a" to the end each word per its word index in the sentence, starting with 1. What's 's the final sentence representing the conversion from sentence to Goat Latin?
the number of words
https:
//leetcode.c c om/ om/problems/ goat-latin/a escription/
RF- pretrain
LeetCode Ic 2103
Given a string rings of length 2n that describes the n rings that are placed onto the rods. Every two characters in rings forms a color color-position pair that is used to describe each ring. How many are the number of rods that have all three colors of rings on them?
the number of rings
https://leet code com/ pro blems ttems/rrings nd-rods desc ription/
Continue next page...
34

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
lc_2899
Given integer array nums where nums [i] either a positive integer or -1. We need to find for cach -1 the respective positive integer, which we call the last visited integer. To achieve this goal, let's define two empty arrays: seen and ans. Start iterating from the beginning of the array nums.
the length of the array
https:
/ //leetcode. c om/ mm/problems/ last- -integers/de scription/
If positive integer is encountered, prepend to the front of seen.
If is encountered, let k be the number of consecutive -Is seen so far (including the current-l)
If k S. length of seen, append the k-th element of seen to ans.
If k > length of seen, append to ans.
Return the array ans.
RF-
LeetCode lc_2833
Find the furthest point from origin after given moves.
the number of moves
https://leet
pretrain
code. com/ pro
blems/fur st-point- n-origin/dese ription/
RF- pretrain
LeetCode lc_2057
Given a O-indexed integer array nums, What's the smallest index i of nums such that mod 10 == nums[i]?
the length of the array
https:
//leetcode.
om/ om/problems/
smallest-ind ind
ex- ex-with-equal
-value/
RF- pretrain
LeetCode Ic ic_953
Given a sequence words written in the alien language, and the order of the alphabet, return true and only if the given words are sorted lexicographically this alien language.
the number of words
https://leet
code.com/pm.
blems/verify
ing-an-alien
-dictionary/ description/
RF- pretrain
LeetCode lc lc_2785
Given O-indexed string s, permute get a new string such that: All consonants remain in their original places. The vowels must be sorted in the nondecreasing order of their ASCII values.
the length of the string
https:
//leetcode.c c om/ ht/pproblems/ sort-vowels, n-a-string/
RF- pretrain
LeetCode lc 2460
Conduct specific operations to array: perform sequential operations on the array merge adjacent equal elements by doubling one and zeroing the other, then moving all zeros to the end.
the length of the array
attps://leet
code. com/pro
blems bappsyap
perations-t. o-an-array/d escription/
Continue next page...
35

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
lc_2682
There are friends, sitting in circle and numbered from order, playing the sircular game. Start at 1st friend and end at 1st friend receive the ball again. What is the serial number the friend who hasn't caught the ball?
the number of people given by:
https:
in clockwise
/ //leetcoee.
om/ cm/problems/
find-the-
ers-of-the-
dom.choice( (inge(1,lenghl))
ircular-gamel
description/
RF-
LeetCode Ic 1694
Reformat the given phone number into right format.
the number of characters of the phone number string
https:
pretrain
/ //leetcode.c om/ propplos///////o/oo reformat- pho ne-number/de scription/
RF- pretrain
LeetCode lc_890
Given a list of strings words and a string pattern, return list of words[i] that match pattern. You may return the answer in any order.
the number of words
https:
//leetcode.c
om/ om/problems/
find-and-rep
lace-pattern
/description/
RF- pretrain
LeetCode lc_2390
Given a string s containing lowercase English letters and "*" return the string obtained by removing all "*" and the character that comes before "*"
the length of
https://leet
the string
mode.com/pg
blems/removi
ng-stars-fro
m-a-string/
RF-
LeetCode Ic lc_2418
A list of names and heights are gigureFiiure out the order of names by their heights.
the number of people
https://leet
pretrain
code. comppro
blems/sort-t
he-people/de
scription/
RF- pretrain
LeetCode le_1909
Given array nums. Can one element to make it increasing?
the length of the array
https:
//leetcode.C c
om/problems/
remove-one-6
lement-to-mak
e e-the-array-s
trictly-incre
asing/descri
ption/
RF- pretrain
LeetCode Ic 1704
Decide whether the number vowels in the first half of the string is equal to the number of vowels in the second half of the string.
the length of half of the
https:
//leetcode.
string
om/ om/problems/
determine-i f-string hal ves-are-all alike /description
Continue next page...
36

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
lc_1823
Try to find the winner of the circular game. Rule: the kth person next to the start person will be kicked off the game. Find the last person left in the game.
the number of people
https:
//leetcode. c om/problems/ find-the- win ner-of-the-c ircular-game/
RF- pretrain
LeetCode lc_2810
Your laptop keyboard is faulty, and whenever you type character 'i' on it, it reverses the string that you have written. Typing other characters works as expected. You are given 0-indexed string s, and you type each character of using your faulty keyboard. Return the final string that will be present on your laptop screen.
the number of characters in the string (we assure there is only one "i" in the string)
https://leet
code. code.compry com/pro
blems/faulty keyboard/de
scription/
RF-
LeetCode
lc lc_2645
Given a string word which you can insert letters "a", "b" or "c" anywhere and any number of times, return the minimum number of letters that must be inserted so that word becomes valid. A string is called valid if it can be formed by concatenating the string "abe" several times.
the length of the string
https://leet code code.com/ pro blema/mi emmmmmmimmu m additions o --make-valid -string/
pretrain
RF- pretrain
LeetCode
lc lc_2609
Find the longest balanced substring in given string. A substring of is considered balanced if all zeroes before ones and the number of zeroes is inside the
the length of the string
https://leet
com/poo
blems/find-t
he-longest-b
equal the number of substring. Notice that the empty substring is considered balanced substring.
alanced-subat
ring-of-a-bin
ary-string/de
scription/
RF- pretrain
LeetCode lc_2423
Return true if it is possible to remove one letter so that the frequency all letters in word is equal, and false otherwise.
the length of the string
https:
//leetcode.c c om/ om/ mm/problems/ remove-lette
/
z-to-equaliz e e-frequency/d escription/
RF- pretrain
LeetCode lc 2185
Return the words that start with given prefix.
the number of words
https:
//leetcode.c
om/ om/problems/
counting-
ds-with-a-giv
en-prefix/de
scription/
RF- pretrain
LeetCode lc_2496
Given an array "strs" of alphanumeric strings, return the maximum value of any string in strs by referring some specific rule.
the length of the array
https:
//leetcode.c
om/ mmmproobless/
moximum-valuus
of-a-strih
g ar-ray /description/
Continue page...
37

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
Ic_1275
A play Tic Tac Toe Game with B. A started first. Given the moves, judge who is the winner of the Tic Tac Toe Game
the number of moves
https:
/ //leetcode. c om/ om/problems/ find-winner-o
n-a-tic-tac-t oe-game/des ription/
RF-
LeetCode Ic 1576
Given a string containing only English letters and the "?" character. Convert all the "?" characters into letters such that the final string does not contain any consecutive repeating characters.
the length of the string
https:
pretrain
//leetcode.c
om/ om/problems/
replace-all-s
to-avoid-con
secutive-rep
eating-chary
cters/descri
ption/
RF- pretrain
LeetCode lc_1041
On an infinite plane, robot initially stands (0, 0) and faces north. "G": go straight I unit. "L": turn 90 degrees to the left. "R": turn 90 degrees to the right. The robot performs the instructions given order, and repeats them forever. Return True if and only if there exists circle the plane such that the robot never leaves the circle.
the number of instructions
https:
//leetcode.c om/ eapproblems/ robot- bounded -in circcr/deeeeee scription/
RF- pretrain
LeetCode
lc le_2078
There are houses evenly lined up on the street, and each house beautifully painted. You given 0-indexed integer array colors of length n, where colors[i] represents the color of the ith house. Return the maximum distance between houses with different colors. The distance between the ith and jth houses abs(i j), where abs(x) is the absolute value of x.
the number of houses
https://leet
code. code.com/pr com/pro blems/txo-fur thest-house s-with-diffe rent description/
rent-cold coltscolors/
RF- pretrain
LeetCode le 2016
Given O-indexed integer array nums of size n, find the maximum difference between nums[i] and nums[j] (i.e., numslj]- nums(i)), such that O <= <<j and nums[i] nums[j].
the length of the array
https:
//leetcode. om/ om/problems/ maximum- diffe rence-between
-increasing-e Coments/desc ription/
RF- pretrain
LeetCode lc_3271
Conduct hash transformation the given string.
the length of the string length ran- dom.randin((2.4)
https:
//leetcode. c om/ om/problems/ hash-divided -stringddssc ription/
Continue next page...
38

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
lc_2529
Given array nums sorted in non-decreasing order, find the maximum between the number of positive integers and the number of negative integers.
the length of the array
https://leet
code. com/pre
blems/maximu
m- m-count-of-p
ositive-integ
er-and-negat
ive-integer/d escription/
RF-
LeetCode Ic lc_2047
Given a string sentence. What is the number of valid words?
the number of words
https:
pretrain
/ //leetcode.c c om/ om/problems/ number-of-val
id-words-in-
-sentence/de
scription/
RF-
LeetCode lc_2828
Dtermine whether string is acronym of given words
the number of words
https://leet
pretrain
code.com/pr
blems/check-i
f-a-string-1
s s-an- a-an-acoo
-of -f-wwrds/des
cription/
RF-
LeetCode lc_2404
Find out the most frequent even element in the given array.
the length of the array
https://leet
pretrain
code. pro blems/most-f requent-
n- n-element/des cription/
RF- pretrain
LeetCode lc_2678
Given a 0-indexed array of strings details. Each element of details provides information about a given passenger compressed into string of length 15. The eleventh and twelfth digits represent the ages of the person. What the number of the olders?
the length of the array
https:
//leetcode.c
om/ om/problems/
number-of-see
ior-citizems/
description/
RF- pretrain
LeetCode Ic_674
Return the length of the longest continuous increasing subsequence.
the length of the array
Ittps://leet code. code.com/pe pro blems/longes t-continuou
s s-increasin
g-subsequence
/description/
RF- pretrain
LeetCode lc_605
Given integer array flowerbed containing 0's and I's, where 0 means empty and 1 means not empty, and an integer n, return true if new flowers can be planted in the flowerbed without violating the no-adjacent-flost rule and false otherwise.
the length of the array
https://leet
code.
code.com/pry com/pro
blems/can-a
ce-flovers/d
escription/
Continue on next page..
39

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF-
LeetCode
lc_290
Given pattern and string s, find if follows the same pattern. (e.g., pattern ="abba", "dog cat cat dog" true)
the number of words the string
https:
pretrain
/ //letcode.c c om/problems/ word-patters /description/
RF- pretrain
LeetCode lc_414
Given an integer array nums, return the third distinct maximum number in this array. If the third maximum does not exist, return the maximum number.
the length of the array
https:
//leetcode.
om/ probbless/
haird-maximum
number/desc
ription/
RF-
LeetCode lc lc_388
What's the length of the longest absolute path to file in the abstracted file system? If there is file in the system, return O.
the depth of the file system
https://leet
pretrain
code. code.com/pp pro
blems/
t-absolute-f
ile-path/
RF- pretrain
LeetCode lc_434
Given a string s, What's s the number of segments in the string? A segment is defined to be contiguous sequence of non-space characters.
the number of segments
https:
//leetcode.
om/ om/ om/problems/
number-of-sen
ments-in-a-8
tring/descri
ption/
RF- pretrain
LeetCode lc_228
Give a sorted unique integer array, return the smallest sorted list of ranges that cover all the numbers in the array exactly.and extra integer being covered. (e.g., nums [0.1,2.4.5,7] + ["0->2"," """="""""""",""""""
first generate array of given length, then remove the repeated element
https://leet
code, com/prr
blems/summe y y-ranges/der /esc ription/
RF- pretrain
LeetCode Ic_448
Given an array nums of integers where nums is permutation of the numbers in the range [1, n]. return an array of all the integers in the range [1, n] that do not appear in nums.
the length of the array
https://leet
code.com/pe
blems/find-a
11-numbers-d
isappeared-1
n-an-array/d
escription/
RF- pretrain
LeetCode lc_242
Determine whether the one word can be converted into another word through alphabetical order adjustment
the number of letters of the word
https:
//leetcode.c
om/ ht//problems/
valid-anagram /description/
RF-
LeetCode lc_268
Given array nums containing distinct numbers in the range [0, n]. return the only number in the range that is missing from the array.
length https://leet
pretrain
code.com/pi cwm/pro pro blems/missin g g-number/ / desc ription/
Continue on next page...
40

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode lc_383
Given two strings rranomNote"" and "magazine" return true "ransomNote" can be constructed by using the letters from magazine" and false otherwise. Each letter in magazine can only be used once in ransomNote.
the length of the string magazine"
https:
/ //leetcode. om/ hnmproblemm/ ransom- note/ description/
RF- pretrain
LeetCode lc_682
You are keeping the scores for a baseball game with strange rules, At the beginning of the game, you start with empty record. You are given a list of strings operations, where operations[i] is the ith operation you must apply to the record.
the number of operations
nttps://les
code comeccompppp bl blems/bsseba 11 11-game/dese ription/
RF-
LeetCode lc_387
Given string find the first non-repeating character in it and return its index. If does not exist, return-1,
the length of the string
https: //leetcode.C c om/ om/ htm/problems// first-uniqu
pretrain
e-character-i n- n-a-string/de
scription/
RF- pretrain
LeetCode lc_345
Given a string s, reverse only all the vowels in the string and return it. And the vowels can appear in both lower and upper cases, more than once.
the length of the string
https://leet
code com/pro
blems/revers
e-vowels-of-a
-string/desc
ription/
RF-
LeetCode lc 192
Given two strings "s" and 't' return true if s is subsequence of tt" t², or false otherwise.
the length of string "t"
https://leet
pretrain
code. com/pro
blems/is-sub
sequence/des
cription/
RF- pretrain
LeetCode lc_705
Design a HashSet without using any built-in hash table libraries. Given operations, return list of result of each step.
the number of operations
https://leet
code. com/pro
blems/design
hashset/descr iption/
RF- pretrain
LeetCode lc_796
Given two strings and goal, return true if and only if can become goal after some number of shifts on A shift consists of moving the leftmost character of to the rightmost position.
the length of the string
https://leet
code.
bl blems/rotate
strrin/dess
ription/
RF- pretrain
LeetCode 1c. lc_2562
Given an integer array, compute the concatenation value by repeatedly adding the concatenation of the first and last elements (or the single remaining element) until the array empty, then returning the total value.
the length of the array
https:
//leetcode.c c om/ mm/problems/ find-the- arr ay cy-concate tion-value/d escription/
Continue on next page...
41

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
1c_1417
Given alphanumeric string (containing lowercase letters and digits), rearrange it such that no two adjacent characters are of the same type (no two letters two digits in row). Return the reformatted string if possible; otherwise, return empty string.
the length of the string
https:
/ //leetcode. c om/ hnmproblems/ reformat the -stringdesc ription/
RF-
LeetCode lc_520
Given a string word, return true if the usage of capitals in it is right.
the length of the string
https://leet
pretrain
code. code.com/pr" com/pro
blems/detech
capital/descr
iption/
RF- pretrain
LeetCode lc_557
Given string reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
the length of the string
https://leet
code.com/pe
blems/revers
e e-words-in-a
string-iii/d
escription/
RF- pretrain
LeetCode lc_541
Given a string and integer k, reverse the first k characters for every 2k characters counting from the start the string.
the length of the string
https://leet
code. com/pro
blems/revers e e-string-ii/ description/
RF-
LeetCode lc_485
Given a binary array nums, return the maximum number of consecutive 1 in the array.
the length of the array
https:
pretrain
//leetcode.
om/problems/
max-consecuti
ve-ones/desc
ription/
RF-
LeetCode lc_344
Write function that reverses string. The input string is given as an array of characters
the length of the string
https://leet
pretrain
code.com/pre com/pro
blems/revers
e-string/dest /esc
ription/
RF-
LeetCode lc_500
Given an array of strings words, return the words that can be typed using letters the alphabet on only one row of American keyboard.
the number of words
https:
pretrain
//leetcode.c
om/ om/problems/ keyboard-row /description/
RF- pretrain
LeetCode lc_482
Reformat the given license key string by removing all dashes, converting letters to uppercase, and grouping the characters into segments of length k (except possibly the first group), separated by dashes.
the length of the string
https:
//leetcode.c
om/ cm/problems/
license-ken key-f ormatting/de scription/
RF- pretrain
LeetCode Ic 196
An array is monotonic it is either monotone increasing monotone decreasing Given an integer array nums, return true if the given array is monotonic, or false otherwise.
the length of the array
ttps://leetco
de com/probl ems/monoton
aarray/descc iption/ Continue next page...
42

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF- pretrain
LeetCode
Ic_551
Given a string representing an attendance record for student where each character signifies whether the student was absent, late, or present on that day. Return true if the student is eligible for an attendance award, or false otherwise.
the length of the string
https://leet
code code.com/pp pro blems/studes t- t-attnndanc e-record-i/ i/d escription/
RF-
LeetCode Ic 1556
Given an integer n, add a dot (".") as the thousands separator and return in string format.
the number is given by random.randin(( 1000,
https://leet code com pro blems/thouse nd ad-separator /description/
pretrain
1000+ 10**le)gth)
RF- pretrain
LeetCode lc_2869
You are given an array nums of positive integers and integer k. In one operation, you can remove the last element of the array and add it to your collection. Return the minimum number of operations needed to collect elements 1, ..... k.
the array and k is given by:
https:
code c pro bl ema ems/minimu m operation s to collect el emments/de scription/
nums ran- dom.sample((i
for i in range(1. length+1)]*2,
k=int(length* *1aoonghh*1100 1.9))
k= ran- dom.randint(3, length)
downstream LeetCode lc_258 (Add Digits)
Given integer, repeatedly sum its digits until the result is a single digit.
the number of digits in the integer
https:
//leetcode. c om/ cm/problems/ add-
scription/
downstream LeetCode lc_283 (Move Zeros)
Given a list integers, move all zeros to the end while preserving the relative order of the non-zero elements.
the length of the list
https:
//leetcode.c
om/problems/
move-zeroes/
description/
downstream LeetCode
Ic 125 (Valid Palin-
Given a string return true if it is palindrome after removing non-alphanumeric characters and converting it to lowercase; otherwise, return false.
half length of the string
https://leet
code code.com/pr com/pro blems/valid-p alindrome/da
drome)
scription/
downstream LeetCode 2544
Given positive integer where the most significant digit has a positive sign, and each subsequent digit has the opposite sign of its adjacent digit, return the sum of these signed digits.
the number of digits in the integer
https:
(Alter- nate Digit Sum)
//leetcode.c c om/ om/ cm/problems/ alternating-d igit-sum/des cription/
Continue next page...
43

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
downstream LeetCode
lc_1598
Determine the final folder after performing the operations in the given list, where .// moves up level, // stays in the current folder, and x/ moves into folder x.
the number of operations
https://leet
(Crawler
code com/pro
Log Folder)
blems/crawl.
x-log-folder/ description/
downstream LeetCode
Ic l__3324 (String Se- quence)
Given a target string, return list of all strings that appear on the screen in order, using the minimum key presses. Key appends "a" to the string, and Key changes the last character to its next letter in the alphabet.
The sum of each letter's ASCII code minus 96 in the target string should equal its length. For example: given input "abc', the length is 1+2+3=6.
https://leet
code.com/pry com/pro
blems/find-t
he sequenceoo
f-strings-app
eared-on-the
-screen/
downstream LeetCode Ic 2677 (Chunk Array)
Given array and chunk size, split the array into subarrays given size.
the length of the array
https:
//leetcode.c c om/ mm/problems/ Bhunk-array. escription/
downstream LeetCode
lc_461
The Hamming distance between integers is the number of positions at which the corresponding bits are different. Given two integers in binary representation, return their Hamming distance.
The bit length of the integers
https://leet
(Ham- ming Dis-
code. code.com/pp com/pro blems/hammin
g g-distance/de scription/
tance)
downstream NUPA
Get
Given a number and an integer i, return the i-th digit.
the number of digits in the given number
https://arxiv
Digit Integer
org/abs/2411 .03766
downstream NUPA
Add Integer
Add the two given integers together.
the maximum of the number of digits of the two given numbers
https://arxiv.
org/abs/2411
.03766
downstream NUPA
Digit
Compare two numbers digit by digit and return the larger digit at each position, treating any missing digits as 0.
the number of digits in the given number
https://arxiv.
Max Integer
org/abs/2411
.03766
downstream
NUPA
Length Integer
Return the total length (i.e., the number of digits) of a number.
the number of https://arxiv.
digits in the given number
org/abs/2411
.03766
RF-
BBH
Dyck
Determine whether given sequence of parentheses forms valid, properly nested structure according to Dyck language rules.
the number of bracket pairs
https://arxiv. org/abs/2211
pretrain
Lan- guages
.09261
Continue on next page...
44

---

Split
Domain
Task Name
Description
Length Definition
Reference URL
RF-
BBH
HyperbatonGiven a sentence with scrambled adjectives, determine whether their current order follows grammatical rules.
the number of adjectives
https://arxiv. org/abs/2210 .09261
pretrain
RF-
BBH
Navigate
Follow a set of directional instructions to determine the final position.
the number of instructions
https://arxiv.
pretrain
org/abs/2210 .09261
RF-
BBH
Object
Accurately count the number of specified objects.
the number of given objects
https://arxiv,
pretrain
Count-
oxg/abs/2210
ing
.99261
RF-
BBH
Reverse
Given a python list, return it in the exact opposite order.
the length of the list
https://arxiv.
pretrain
List
org/abs/2210
.09261
RF-
BBH
Word
Sort given list of words in strict dictionary order.
the number of words
pretrain
Sorting
org/abs/2210
.09261
RF-
Symbolic
Coin Flip
Given a series of operations, answer whether coin still heads up after people either flip or don't 't flip the coin. (e.g., "A coin is heads up. Phoebe flips the coin. Osvaldo does not flip the coin. Is the coin still heads up?" - "no")
the number of people who flip the coin
https://arxin:
pretrain
Reason- ing
org/abs /20b
.19903
RF- pretrain
Symbolic Reason- ing
Last
Given a list words, concatenate the last letters of each word and return the string. (e.g., "Amy Brown" - "yn")
the number of words
https:
Letter
org/abs/220 .11903
Con-
catena- tion
45

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
We list the contributions explicitly in the abstract and introduction.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results be expected to generalize other settings.
is fine include aspirational goals as motivation as long is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification:
We discuss the limitations of our work in Appendix A.
Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification. asymptotic approximations only holding locally). The authors should reflect how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low images are taken in low lighting. Or speech-to-text system might be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach address problems of privacy and faimess.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't 't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
46

---

Justification: We primarily focus on empirical results rather than theoretical analysis. The paper does not present formal theoretical results requiring mathematical proofs. All claims are supported with sufficient experimental evidence.
Guidelines:
The answer NA means that the paper does not include theoretical results. All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but they appear in the supplemental material, the authors are encouraged provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should properly referenced.
4. Experimental result reproducibility
Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Question:
Answer: [Yes]
Justification: We introduce our methods clearly in Section 3.1, and demonstrate the process our data construction pipeline in Section 3.2.
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, a No answer this question will not perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution a specific model and empirical evaluation, may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make it clear how reproduce that algorithm.
(b) If the contribution is primarily
model architecture, the paper should describe the architecture clearly and fully.
(c) the contribution is a new model (e.g., a large language model), then there should either be way access this model for reproducing the results way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
(d) We recognize that reprodueibility may be tricky in some cases, in which authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers have some path reproducing verifying the results.
5. Open access to data and code
47

---

Does the paper provide open access to the data and code, with sufficient instruc- tions faithfully reproduce the main experimental results, as described in supplemental material?
Question:
Answer: [Yes]
Justification:
We provide code for reproducibility supplemental material.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please the NeurIPS code and data submission guidelines (https://nips. cc/pu
blic/g /aaic/uuides/oodSuubiiieee wwweessuiniisiioooolllooo
for more details.
While we encourage the release of code and data, we understand that this might not be possible, "No" an acceptable answer. Papers cannot be rejected simply for including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https:
/ //wpp..ccppubaiii wttpccccpppppcpcceeeeeeecc /
/Cooeeuboeeeeeeee ssisnnoilll.o mnooiccy) for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing much information possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification:
We show the training details in Section 4.1 and Appendix D.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, as supplemental material.
7. Experiment statistical significance
Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Question:
Answer: [Yes]
Justification: For finetuning results during downstream adaptation, report error bars, as shown in Figure 3 and Figure 9. For ICL results, we set the temperature and perform greedy decoding, which is deterministic process.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confi- dence intervals, or statistical significance tests, least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall with given experimental conditions).
48

---

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
should be clear whether the error bar is the standard deviation or the standard error of the mean.
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables figures symmetric error bars that would yield results that are out range (c.g. negative emror rates).
If error bars reported in tables plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification:
We provide the information on the computer resources in Appendix D.2.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that NeurIPS Code of Ethics https: : http///eerpp//eeeeee/ee cc cc/ppblic/Ethiiiiccceceeeeoooeee httpppiiicectiiccttteeeeeeeeeeee
didn't 't make it into the paper).
9. Code ethics
Question: Does the research conducted in the paper conform, in every respect, with the
Answer: [Yes]
Justification:
We strictly follow the NeurlPS Code of Ethics.
Guidelines:
The answer NA means that the authors have reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special cireumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g., if there is special consid- eration due to laws or regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
We discuss the socictal impacts in Appendix B.
Guidelines:
The answer NA means that there is no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
49

---

The conference expects that many papers will be foundational research and not tied particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms monitor how system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification: We do not release new LLMs. Instead, finetune LLMs that are already released with safeguards.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper. properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification: All external assets (code, data, and models) used in this work properly credited to their original creators, with clear citations to their respective sources.
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, possible, include URI
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (c.g.. website), the copyright and terms of service of that source should be provided.
assets are released, the license, copyright information, and terms of use the package should be provided. For popular datasets, paperswi thcode. com/ datassss has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
50

---

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if has changed) should be provided.
this information is not available online, the authors are encouraged to reach out to the asset's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification: We provide code for introduced length generalization dataset and include documentation alongside the code.
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset is used.
At submission time, remember anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
Answer: [Yes]
Justification: The paper describes the data annotation process in Appendix C.1.
Guidelines:
The answer NA means that the paper does involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included in the main paper.
According the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or equivalent approval/review based the requirements of your country or institution) were obtained?
Answer: [Yes]
Our study involved human annotators for data construction tasks. All par- ticipants were fairly compensated, and the annotation process adhered to our institution's ethical guidelines.
Justification:
Guidelines:
The answer NA means that the paper does not involve crowdsourcing research with human subjects.
Depending the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
51

---

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors adhere the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.
Question:
Answer: [Yes]
Justification: We study the length generalization performance of LLMs and propose framework of training LLMs to enhance their length generalization.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non-standard components.
Please refer to our LLM policy for what should or should not be described.
52


Reviews:
[{"review_id": "2409huIz4w", "reviewer": "Reviewer_VnFA", "summary": "This paper proposes Meta-RFFT, enhancing length generalization in LLMs. Compared to previous methods like positional encodings, direct answer, scratchpad fine-tuning and RFFT, Meta-RFFT focus on rule based reasoning not case based and multi tasks setting to validate the generalization. \n\nThe authors construct a dataset with 86 diverse tasks and use Meta-RFFT to fine-tune models, enabling them to generalize unseen tasks with minimal adaptation.(minimal fine-tuning or one-shot ICL).\n\nExperiments show significant improvements over baselines (e.g. with a 32B model achieving 95% accuracy on 30-digit addition while training on 1-5-digit addition). The success is attributed to learning shared computational primitives across tasks(rule based reasoning not case-based). And models Meta-pretrained on code-based rules could adapt to natural language rules, demonstrating versatility.", "questions": "1.Following Weakness, the main computational primtive in this paper is loop maintenance? Any other primitives? If not, then I think this may not be an efficient way to learn rule-based reasoning, since Long-CoT models actually do a good job in Table 2.\n\n2.Does META-RFFT fine-tuning affect the general capabilities of models, such as knowledge or mathematics?\n\n3.I think reinforcement learning is actually very suitable for tasks in paper. Because it has clear state transitions and reward signals, maybe process supervision is more suitable for these tasks.\n\n4.By the way, is it normal to have reference in the abstract?(line 9)", "limitations": "yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 4, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Strengths:\n\n1.This paper presents solid work and the writing is good for ideas and organizations that are easy to understand.\n\n2.The experiment setup in paper is complete and fair, and there are a lot of training dynamic, result figures and tables to support the author's claims.\n\n3.The results are significantly improved compared to the baselines.\n\nWeaknesses:\n\n1.One of my main concerns is novelty. In fact, the multi-task training to promote generalization has been deep explored in other domains.\n\n2.Following Weakness 1, the approach in this paper is to apply multi-task learning on some specific tasks' length generalization problem (although the paper mentions four datasets, they are basically digital and symbolic processing. How about multi step math problems?)", "was_revised": true, "final_justification": "The author's reply addressed most of my concerns, especially the novelty of multi-task learning. And the authors also showed in rebuttal that Meta-RFFT can be used in applications beyond symbolic reasoning and the general capabilities of LLM can be maintained through training with a small amount of additional data. So I maintain the rating and raise my confidence score.", "rebuttal": "We sincerely appreciate the reviewer’s insightful and positive feedback! We hope the following responses will fully address your concerns and further clarify our contributions.\n\n# W1:\nWe fully acknowledge that multi-task training is a well-established concept across many domains. However, our work introduces a novel perspective by being the first to explore **cross-task transfer of length generalization** through multi-task training. Length generalization presents a unique challenge due to its inherent out-of-distribution (OOD) nature—models are trained on short sequences but must generalize to much longer ones. We show through experiments that **traditional multi-task methods like instruction tuning (e.g., Tulu3 in Table 3) fail under such conditions**, since the reasoning steps required at test time go far beyond those seen during training.\n\nBesides, while the original RFFT framework showed that explicitly providing rules improves rule-based reasoning in single-task settings, our contribution is to **scale this approach to multi-task training** across a large number of (rule, rule-execution trace) pairs. This enables the model to acquire a **meta rule-following capability**, allowing it to generalize to **unseen tasks** by transferring reasoning skills across tasks. We are, to the best of our knowledge, the first to systematically study this form of **cross-task OOD generalization** in LLMs. We also provide a mechanistic explanation: the transferability stems from the model’s ability to learn shared **computational primitives**, such as loop maintenance, which are essential across tasks.\n\nMoreover, previous studies on length generalization [2–5] has **largely been restricted to single-task, small-scale** settings, often using transformers **trained from scratch**. However, a key strength of large language models lies in their ability to handle a wide range of diverse tasks within a single model. Our work aligns with this core advantage: we explore length generalization in a **multi-task, post-training setting, using pretrained LLMs**. Our method enables generalization across tasks and lengths, making it far more practical and scalable for real-world use.\n# W2:\nWe thank the reviewer for raising this important point. We agree that going beyond symbolic or formally codable tasks is crucial for evaluating real-world reasoning.\n\n1. **Additional experiments on more complex tasks**\n    * To validate the practical value of Meta-RFFT beyond symbolic tasks, we additionally conduct experiments and evaluate it on a real-world scenario: **the Airline Baggage Cost Estimation task** from [1].\n\n    * This task asks the model to compute the total travel cost for one or more passengers, including flight fare and baggage fees. The rules which are based on American Airlines' policy are complex, depending on cabin class, flight route, number of bags, and bag dimensions. Solving it **requires understanding and applying natural language regulations, which go beyond what can be fully captured in formal code**. We use pseudo-code rules in this task and test whether the model can perform length generalization.\n\n    * This task illustrates a practical setting for length generalization, where the model must apply multiple interrelated rules over long reasoning chains. Current LLMs perform poorly on it, and even strong models like Claude-3.5 and o1-preview degrade rapidly with input length (see the table below, the results are from [1]).\n\n    * We train models on samples with length 1–8, and report test accuracy on OOD lengths 10-16. As shown below, **Meta-RFFT significantly outperforms vanilla RFFT in the practical domain**:\n\n    | length       | 2    | 4    | 6    | 8    | 10   | 12   | 14   | 16   |\n    |--------------|------|------|------|------|------|------|------|------|\n    | Vanilla RFFT | 0.94 | 0.72 | 0.78 | 0.56 | 0.44 | 0.16 | 0.00 | 0.08 |\n    | Meta-RFFT    | 1.00 | 1.00 | 0.92 | 0.90 | 0.74 | 0.38 | 0.24 | 0.26 |\n\n    | length                     | 5    | 8    | 11   |\n    |----------------------------|------|------|------|\n    | Qwen-2.5-72B (0-shot)      | 0.01 | 0.01 | 0.00 |\n    | Qwen-2.5-72B (1-shot)      | 0.19 | 0.10 | 0.01 |\n    | Claude-3.5 Sonnet (0-shot) | 0.04 | 0.00 | 0.01 |\n    | Claude-3.5 Sonnet (1-shot) | 0.29 | 0.30 | 0.11 |\n    | o1-preview (0-shot)        | 0.54 | 0.37 | 0.21 |\n    | o1-preview (1-shot)        | 0.63 | 0.55 | 0.46 |\n\n\n2. **Why we choose symbolic tasks in our paper** \n    * We agree that extending our method to real-world, complex tasks is a valuable future direction. In this paper, we intentionally focus on controlled tasks to clearly isolate the challenges of length generalization, independent of task complexity of each step. This setup follows the standard in prior studies [2–5]. Notably, even when individual steps are simple, length generalization remains highly challenging for LLMs. For example, DeepSeek-R1-671B achieves only 72% accuracy on 30-digit addition, despite the task’s apparent simplicity to humans. This demonstrates that length generalization is a fundamental and non-trivial ability, separate from broader reasoning complexity.\n    * Furthermore, defining \"length\" in complex real-world tasks is non-trivial. Our framework does not yet include large-scale real-world tasks, but we view this as a critical next step.\n3. **Our contribution towards real-world settings**\n    * Our work bridges the gap between prior small-scale, single-task studies and practical LLMs. We demonstrate, for the first time, that multi-task rule-following training enables cross-task transfer of length generalization, marking an essential step toward scaling to more realistic, multi-step tasks.\n\n[1] Zhou et al., RULEARENA: A Benchmark for Rule-Guided Reasoning with LLMs in Real-World Scenarios, 2025.\n\n[2] Anil et al., Exploring length generalization in large language models, 2022.\n\n[3] Zhou et al., What algorithms can transformers learn?, 2023.\n\n[4] Zhou et al., Transformers can achieve length generalization but not robustly, 2024.\n\n[5] Hu et al., Case-Based or Rule-Based: How Do Transformers Do the Math?, 2024.\n\n---\n# Q1,3:\nWe find the reviewer’s suggestion to explore RL for rule-following tasks highly insightful, and in fact, we have conducted preliminary investigations along this line.\n\n1. **On computational primitives:**\n   While loop maintenance is indeed a core challenge for length generalization, our model also learns other common primitives such as `if-else` logic and operations on `lists` and `strings`. These structures are broadly shared across tasks and essential for handling symbolic and algorithmic reasoning. Meta-RFFT leverages these shared patterns to improve cross-task generalization.\n\n2. **On reinforcement learning:**\n   * **Outcome reward:**\n     We find SFT more effective than outcome-based RL for rule-following tasks. RL optimizes only for final correctness, while SFT directly trains the model to generate rule-compliant intermediate steps. As shown in Figure 7, RL fails to capture the process structure and underperforms Meta-RFFT (see error case of R1 in Table 9). Moreover, Meta-RFFT outperforms advanced long-CoT models like DeepSeek-R1-671B and QwQ-32B (Table 2), despite being smaller (see error case of R1 in Table 8).\n   * **Process reward:**\n     We strongly agree that this is a valuable idea. Supervising rule execution with process-level rewards could enhance improve rule adherence and generalization, and we consider it a promising direction for future research.\n\n# Q2:\nWe appreciate the reviewer for pointing out this important and practical concern.\n\nMeta-RFFT involves substantial RF-pretraining, which indeed can affect the model’s general capabilities due to distribution shift, known as catastrophic forgetting. But typically this is easily addressed by mixing some pretraining corpus during fine-tuning.\n\nTo verify this, we conduct a supplementary experiment. As we don't have access to the pretraining data, we mix GSM8K training data into downstream finetuning alongside the original meta-rule-following data to verify that the reasoning ability on GSM8K can be kept after RFFT. More specifically, for each training example in GSM8K, we use Qwen2.5-7B-Instruct to generate 10 candidate answers and filter the corrrect traces as the training set, forming a filtered GSM8K dataset of 7182 samples.\n\nThe results on length generalization (averaged across 8 LeetCode tasks) and GSM8K test accuracy are shown below. We observe that merely mixing 7k samples (compared to 310k Meta-RFFT data) effectively recovers the model’s reasoning performance on GSM8K, while maintaining the strong multi-task length generalization ability. Notably, Meta-RFFT still significantly outperforms vanilla RFFT, demonstrating that **general capabilities can be preserved with minimal additional data**.\n\n|       | ACC_Len30 | Max_Len_90% |\n|---------|-----------|-------------|\n| vanilla RFFT                | 0.34      | 7.00        |\n| Meta-RFFT                   | 0.82      | 22.75       |\n| Meta-RFFT with general data | 0.79      | 21.25       |\n\n|        | GSM8K Test ACC |\n|------------------|----------|\n| Qwen2.5-7B-Instruct  |  87.95%   |\n| Qwen2.5-7B-Instruct (Meta-RFFT with general data) |           87.80%     |\n# Q4:\nWhile we have seen references included in some abstracts, we look into the convention and find that abstracts are generally expected to be self-contained and citation-free. We will revise our abstract accordingly to remove the reference."}, {"review_id": "Azou5j8Ij3", "reviewer": "Reviewer_5dGj", "summary": "The authors aim to improve the model’s generalization ability on downstream tasks by leveraging meta-learning over a carefully constructed dataset of more than 80 reasoning tasks. This approach not only enhances generalization but also alleviates the burden of understanding complex rules during downstream fine-tuning. By improving upon the original RFFT framework, the proposed method achieves better performance in rule-based learning.", "questions": "1. It is unclear how the relative error reported in Figure 4 is computed. A more precise definition or formula would help in understanding the performance implications.\n2. I would like to see results on more complex algorithmic problems, such as shortest path computation, or tasks that are difficult to describe using simple while loops. This would provide stronger evidence for the model’s generalization ability.\n3. In the task design, can the length parameter be interpreted as the input size n in algorithmic complexity analysis? If so, is it appropriate to mix linear-complexity and quadratic-complexity tasks with the same length value during the first-stage training? This could potentially bias the model’s learning.\n\nIf these concerns can be addressed—particularly through clarification and additional experiments—I would be willing to consider raising my score.", "limitations": "1.The proposed method demonstrates strong performance on tasks that can be decomposed into multiple similar iterations. However, it lacks discussion or evaluation on reasoning problems beyond this class, such as tasks with non-iterative or structurally diverse reasoning patterns.\n2.The paper lacks a more detailed explanation of how length is defined across different tasks, which makes it difficult to interpret the consistency and generality of the length generalization results.", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 3, "originality": 3, "strengths_and_weaknesses": "Strengths：\n1. The paper is clearly written and easy to follow, and the problem it addresses has strong practical significance.\n2. The authors construct a complex and diverse multi-task dataset to enhance the model's generalization capabilities.\n3. The experiments are extensive and well-designed, with thorough analysis and convincing empirical support for the conclusions.\n\nWeaknesses：\n1.In most of the training samples presented in the paper, the provided rules remain largely within the scope of “mathematical” or “formally codable” tasks. The study of reasoning capabilities in language models should not be limited to such types of problems.\n2. The algorithmic tasks selected from LeetCode are relatively simple, and the evaluation lacks coverage of more complex or challenging tasks.", "was_revised": true, "final_justification": "The authors' rebuttal satisfactorily addressed most of my initial concerns, especially regarding the definition of the relative error and  more estimation task in reality. I have updated my score accordingly. However, I still find the approach based on mixed complexity somewhat problematic, as it introduces ambiguity in interpreting the model's performance.", "rebuttal": "We sincerely appreciate the reviewer’s insightful and constructive feedback! We hope our responses below address your concerns and help clarify our key contributions.\n\n# W1,2; Q2:\n\nWe thank the reviewer for raising this important point. We agree that going beyond symbolic or formally codable tasks is crucial for evaluating real-world reasoning. Below, we clarify our task choices and how our work sets the stage for broader generalization.\n\n1. **Additional experiments on more complex tasks**\n    * To validate the practical value of Meta-RFFT beyond symbolic tasks, we additionally conduct experiments and evaluate it on a real-world scenario: **the Airline Baggage Cost Estimation task** from [1].\n\n    * This task asks the model to compute the total travel cost for one or more passengers, including flight fare and baggage fees. The rules which are based on American Airlines' policy are complex, depending on cabin class, flight route, number of bags, and bag dimensions. Solving it **requires understanding and applying natural language regulations, which go beyond what can be fully captured in formal code**. We use pseudo-code rules in this task and test whether the model can perform length generalization.\n\n    * This task illustrates a practical setting for length generalization, where the model must apply multiple interrelated rules over long reasoning chains. Current LLMs perform poorly on it, and even strong models like Claude-3.5 and o1-preview degrade rapidly with input length (see the table below).\n\n    * We train models on samples with length 1–8, and report test accuracy on OOD lengths 10-16. As shown below, **Meta-RFFT significantly outperforms vanilla RFFT in the practical domain**:\n\n    | length       | 2    | 4    | 6    | 8    | 10   | 12   | 14   | 16   |\n    |--------------|------|------|------|------|------|------|------|------|\n    | Vanilla RFFT | 0.94 | 0.72 | 0.78 | 0.56 | 0.44 | 0.16 | 0.00 | 0.08 |\n    | Meta-RFFT    | 1.00 | 1.00 | 0.92 | 0.90 | 0.74 | 0.38 | 0.24 | 0.26 |\n\n    | length                     | 5    | 8    | 11   |\n    |----------------------------|------|------|------|\n    | Qwen-2.5-72B (0-shot)      | 0.01 | 0.01 | 0.00 |\n    | Qwen-2.5-72B (1-shot)      | 0.19 | 0.10 | 0.01 |\n    | Claude-3.5 Sonnet (0-shot) | 0.04 | 0.00 | 0.01 |\n    | Claude-3.5 Sonnet (1-shot) | 0.29 | 0.30 | 0.11 |\n    | o1-preview (0-shot)        | 0.54 | 0.37 | 0.21 |\n    | o1-preview (1-shot)        | 0.63 | 0.55 | 0.46 |\n\n\n2. **Why we choose symbolic tasks in our paper** \n    * We agree that extending our method to real-world, complex tasks is a valuable future direction. In this paper, we intentionally focus on controlled tasks to clearly isolate the challenges of length generalization, independent of task complexity of each step. This setup follows the standard in prior studies [2–5]. Notably, even when individual steps are simple, length generalization remains highly challenging for LLMs. For example, DeepSeek-R1-671B achieves only 72% accuracy on 30-digit addition, despite the task’s apparent simplicity to humans. This demonstrates that **length generalization is a fundamental and non-trivial ability, separate from broader reasoning complexity**.\n    * Furthermore, defining \"length\" in complex real-world tasks is non-trivial. Our framework does not yet include large-scale real-world tasks, but we view this as a critical next step.\n3. **Our contribution towards real-world settings**\n    * Our work bridges the gap between prior small-scale, single-task studies and practical LLMs. We demonstrate, for the first time, that multi-task rule-following training enables cross-task transfer of length generalization, marking an essential step toward scaling to more realistic, multi-step tasks.\n\n[1] Zhou et al., RULEARENA: A Benchmark for Rule-Guided Reasoning with LLMs in Real-World Scenarios, 2025.\n\n[2] Anil et al., Exploring length generalization in large language models, 2022.\n\n[3] Zhou et al., What algorithms can transformers learn?, 2023.\n\n[4] Zhou et al., Transformers can achieve length generalization but not robustly, 2024.\n\n[5] Hu et al., Case-Based or Rule-Based: How Do Transformers Do the Math?, 2024.\n\n---\n# Q1:\nWe apologize for the lack of clarity. In Figure 4(b), we report the **relative error in loop counts**, defined as:\n\n$$\n\\text{relative-error} = \\frac{\\left|\\text{ground-truth-loop-num} - \\text{model-loop-num}\\right|}{\\text{ground-truth-loop-num}}\n$$\n\nFor each task, the reported value is the **average relative error** computed over test cases of input lengths from 2 to 30 (in increments of 2), with **50 samples per length**.\n\nWe will revise the text to include this definition for clarity.\n\n# Q3:\nThank you for the insightful question.\n\nYes, in our task design, the length parameter can be roughly interpreted as the input size $n$ in algorithmic complexity terms. For example, in the word sorting task, length corresponds to the number of words ($O(n^2)$), while in coin flip, it denotes the number of flips ($O(n)$).\n\nHowever, during training, we do not provide the model with explicit length values. As shown in the RFFT input format (e.g., Figure 1, right), the model is not required to be aware of the value of $n$. Instead, it learns to manage loop entry and exit based on conditions, not on fixed input lengths. This design encourages length-agnostic reasoning and prevents overfitting to specific lengths seen during training.\n\nEmpirically, despite training on tasks of mixed complexity, the model generalizes well across downstream tasks of varying complexity, outperforming all baselines. This suggests that the mixed training does not bias the model in practice."}, {"review_id": "4ail20Ll1d", "reviewer": "Reviewer_AGZE", "summary": "The paper introduces Meta Rule-Following Fine-Tuning (Meta-RFFT), a framework to enhance length generalization in large language models (LLMs). Unlike prior single-task approaches, Meta-RFFT fine-tunes models on a diverse dataset of 86 tasks (spanning code execution, number processing, and logical reasoning), enabling cross-task transfer of rule-following skills. Key contributions include constructing a 310k-sample dataset, demonstrating that Meta-RFFT outperforms state-of-the-art models (e.g., 95% accuracy on 30-digit addition vs. 72% for DeepSeek-R1-671B), and showing that models learn shared computational primitives (e.g., loop maintenance) rather than task-specific patterns. The framework supports one-shot prompting and adapts to natural language rules, reducing the need for extensive task-specific training.", "questions": "NA", "limitations": "Yes.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Strength: \n\nThis work makes clear contributions against previous work: \n(1) Meta-RFFT addresses a critical gap in prior work by enabling LLMs to generalize across tasks with minimal fine-tuning, the model achieves robust performance on unseen lengths by leveraging shared reasoning patterns.\n(2) Extensive experiments across model sizes (7B–32B) and tasks (e.g., LeetCode, NUPA) validate its superiority, error analysis shows Meta-RFFT reduces loop-related errors by 50% compared to single-task methods, confirming its focus on generalizable reasoning.\n(3) The large, diverse dataset and automated rule-trajectory generation streamline training, while the framework’s compatibility with practical LLMs (e.g., Qwen-2.5) enhances real-world applicability.\n\nWeakness: \nEven though this work has clear strengths, I have several concerns. \n\n1. Limited Real-World OOD Generalization and Evaluation\nThe framework primarily evaluates structured tasks (e.g., arithmetic, code execution) and lacks rigorous testing on unstructured, real-world scenarios like article writing, deep research tasks, etc. The dataset requires the question to be answered by specific rules simplifies the creation but also increase the gap between these synthetic tasks and real-world applications. I think the LLM developers may not be very interested in improving length generalization on digit addition.\n\n2. High Computational Overhead for Multi-Task Pretraining\nMeta-RFFT requires substantial compute resources for RF-pretraining: 144–713.6 GPU hours for 7B–32B models, which may be inaccessible to researchers with limited infrastructure. While downstream fine-tuning is efficient (2.4–12 GPU hours per task), the upfront cost of multi-task pretraining poses a barrier to adoption for small teams or academic labs .\n\n3. While the paper positions Meta-RFFT as a solution for length generalization, its core contribution—multi-task rule transfer—seems a bit off from the length generalization focus.", "was_revised": true, "final_justification": "I was mainly concerned about the method's generalization to real-world tasks and its high computational cost. The author's rebuttal resolves most of my concern and thus I raise my score.", "rebuttal": "We sincerely thank the reviewer for recognizing our key contributions, including **cross-task generalization**, **strong empirical results**, and **practical scalability**. We hope the following responses help address your remaining concerns.\n\n# W1:\nThis is a valid and important concern. While our current evaluation focuses on structured tasks, the goal is to establish a foundation for robust generalization that can eventually transfer to more complex and unstructured real-world settings. Below, we explain the rationale behind our task choices and how they connect to broader applications.\n\n1. **Additional experiments on more complex tasks**\n    * To validate the practical value of Meta-RFFT beyond symbolic tasks, we additionally conduct experiments and evaluate it on a real-world scenario: **the Airline Baggage Cost Estimation task** from [1].\n\n    * This task asks the model to compute the total travel cost for one or more passengers, including flight fare and baggage fees. The rules which are based on American Airlines' policy are complex, depending on cabin class, flight route, number of bags, and bag dimensions. Solving it **requires understanding and applying natural language regulations, which go beyond what can be fully captured in formal code**. We use pseudo-code rules in this task and test whether the model can perform length generalization.\n\n    * This task illustrates a practical setting for length generalization, where the model must apply multiple interrelated rules over long reasoning chains. Current LLMs perform poorly on it, and even strong models like Claude-3.5 and o1-preview degrade rapidly with input length (see the table below).\n\n    * We train models on samples with length 1–8, and test on OOD lengths 10–16. As shown below, **Meta-RFFT significantly outperforms vanilla RFFT in the practical domain**:\n\n    | length       | 2    | 4    | 6    | 8    | 10   | 12   | 14   | 16   |\n    |--------------|------|------|------|------|------|------|------|------|\n    | Vanilla RFFT | 0.94 | 0.72 | 0.78 | 0.56 | 0.44 | 0.16 | 0.00 | 0.08 |\n    | Meta-RFFT    | 1.00 | 1.00 | 0.92 | 0.90 | 0.74 | 0.38 | 0.24 | 0.26 |\n\n    | length                     | 5    | 8    | 11   |\n    |----------------------------|------|------|------|\n    | Qwen-2.5-72B (0-shot)      | 0.01 | 0.01 | 0.00 |\n    | Qwen-2.5-72B (1-shot)      | 0.19 | 0.10 | 0.01 |\n    | Claude-3.5 Sonnet (0-shot) | 0.04 | 0.00 | 0.01 |\n    | Claude-3.5 Sonnet (1-shot) | 0.29 | 0.30 | 0.11 |\n    | o1-preview (0-shot)        | 0.54 | 0.37 | 0.21 |\n    | o1-preview (1-shot)        | 0.63 | 0.55 | 0.46 |\n\n\n2. **Why we choose symbolic tasks in our paper** \n    * We agree that extending our method to real-world, complex tasks is a valuable future direction. In this paper, we intentionally focus on controlled tasks to clearly isolate the challenges of length generalization, independent of task complexity of each step. This setup follows the standard in prior studies [2–5]. Notably, even when individual steps are simple, length generalization remains highly challenging for LLMs. For example, DeepSeek-R1-671B achieves only 72% accuracy on 30-digit addition, despite the task’s apparent simplicity to humans. This demonstrates that **length generalization is a fundamental and non-trivial ability, separate from broader reasoning complexity**.\n    * Furthermore, we also acknowledge the challenge of defining \"length\" in unstructured real-world tasks. Extending our framework to such domains is a key direction we plan to pursue.\n3. **Our contribution towards real-world settings**\n    * Our work bridges the gap between prior small-scale, single-task studies and practical LLMs. We show that multi-task rule-following training enables transferable length generalization, including to unseen tasks. This provides a scalable path toward improving reliability in multi-step, real-world reasoning.\n# W2:\nThank you for highlighting this important practical consideration. We’d like to address your concern as follows:\n\n1. **Reducing pretraining cost with fewer steps:**\n   As shown in Figure 15 (Appendix E.5), the model’s performance improves steadily with more RF-pretraining steps, but even **partial pretraining (e.g., fewer steps)** yields notable gains over vanilla RFFT. This provides a **flexible trade-off** for users with limited resources: by reducing pretraining steps, one can still achieve meaningful improvements in length generalization.\n\n2. **Cost amortization across tasks:**\n   While Meta-RFFT incurs an upfront cost (144 GPU-hours for 7B; 713.6 for 32B), it becomes **significantly more efficient than vanilla RFFT** when applied across multiple tasks. Since Meta-RFFT enables **positive transfer via 1-shot prompting** on **unseen tasks**, it reduces the need for downstream fine-tuning altogether. For example, with downstream adaptation costing just 2.4–4.4 GPU-hours per task (7B), the pretraining cost is amortized after only **\\~42 tasks**—a threshold quickly exceeded in practice. For the 32B model, the breakeven point is **\\~72 tasks**. This makes Meta-RFFT cost-effective for large-scale multi-task deployment. We will also open-source the Meta-RFFT checkpoints for efficient downstream applications. \n   \n|Model|Training Stage|Training hours|GPU Num|GPU Memory|GPU hours|\n|-|-|-|-|-|-|\n|7B|RF-pretrain|18|8|80G|144.0|\n|7B|downstream|0.6~1.1|4|80G|2.4~4.4|\n|32B|RF-pretrain|22.3|32|80G|713.6|\n|32B|downstream|2.0~3.0|4|80G|8.0~12.0|\n# W3:\nWe would like to clarify how **multi-task rule transfer and length generalization are closely connected** in our work.\n\nAs identified in [5], poor length generalization in LLMs stems from reliance on **case-based reasoning**, where models memorize shallow patterns instead of learning genuine rules. For example, models memorize addition results within 5-digit numbers by seeing a large number of training examples in this range, but do not capture the underlying digit-by-digit with carry-over addition rules (which are the key for generalization to infinite lengths), thus fail to solve 10-digit addition problems. RFFT addresses this by providing explicit rules and execution traces, enabling the model to adopt **rule-based reasoning**, which significantly improves out-of-distribution (OOD) generalization.\n\nOur key contribution builds on this by **scaling rule-based reasoning to the multi-task setting**. By training on a large number of (rule, execution trace) pairs from diverse tasks, Meta-RFFT equips the model with a **meta rule-following ability**—allowing it to **transfer rule-following behavior across tasks**. Crucially, this enables the model to generalize not only to longer inputs but also to **unseen tasks**.\n\nThus, while Meta-RFFT introduces multi-task rule transfer, its primary goal remains to improve **length generalization in a more generalizable and scalable way**. We also provide a mechanistic explanation: this transferability emerges from learning **shared computational primitives** (e.g., loop maintenance), which are essential for both length generalization and cross-task generalization.\n\nIn this sense, multi-task rule transfer is not a departure from our focus on length generalization, but a natural and scalable extension of it.\n\n---\n[1] Zhou et al., RULEARENA: A Benchmark for Rule-Guided Reasoning with LLMs in Real-World Scenarios, 2025.\n\n[2] Anil et al., Exploring length generalization in large language models, 2022.\n\n[3] Zhou et al., What algorithms can transformers learn?, 2023.\n\n[4] Zhou et al., Transformers can achieve length generalization but not robustly, 2024.\n\n[5] Hu et al., Case-Based or Rule-Based: How Do Transformers Do the Math?, 2024."}, {"review_id": "Ud2xZ0vMNs", "reviewer": "Reviewer_tbVk", "summary": "This paper introduces **Meta-RFFT**, a length-aware SFT approach that explicitly teaches the model to follow step-by-step rules. After mastering these rules, the model generalises to longer and more complex scenarios, and experiments show strong transfer to unseen tasks.", "questions": "1. Will the authors release the codebase?\nI believe the task construction pipeline is highly valuable for the community. Releasing the codebase would greatly facilitate future research and adoption of the proposed benchmark.\n\n2. Can the proposed approach be extended to reinforcement learning frameworks?\nReinforcement learning is often considered to offer better generalization capabilities. It would be interesting to see whether this dataset can be adapted for RL settings, and whether RL-based models demonstrate stronger compositional generalization across tasks. I would be particularly curious to compare the performance of RL models on such benchmarks.\n\n3. Can we authors do some ablation study on evaluating how performance scales with number of composed sub-tasks?\nI believe not all subtasks contribute equally to performance gains. A systematic analysis of how accuracy changes, whether it degrades or holds up as the number of composed tasks increases from two to three or four would further support the paper’s claims about compositional generalization.", "limitations": "Yes.", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "**Strengths**\n\n1. The paper presents a thorough experimental study across a diverse set of tasks and model scales. The consistently strong results highlight the promise of the proposed method.\n2. The authors’ data-synthesis and evaluation pipeline is itself a valuable asset. Open-sourcing this codebase would greatly benefit the community.\n3. The proposed method for enhancing meta-thinking in reasoning tasks is both insightful and valuable.\n\n**Weakness / Future Work**\n\n* The current approach is framed within supervised fine-tuning (SFT). Because reinforcement learning (RL) can naturally capture meta-information during training, it would be interesting to see whether the method can be generalized to RL in future work.", "was_revised": false, "final_justification": "", "rebuttal": "We sincerely appreciate the reviewer’s insightful and constructive feedback! We hope the following responses will further address your concerns.\n\n# W1, Q2:\nWe find the reviewer’s suggestion to explore RL for rule-following tasks highly insightful, and in fact, we have conducted preliminary investigations along this line.\n\nIn our current work, we explore a baseline using RL **with outcome rewards** through experiments. While outcome-reward RL has achieved success in general reasoning, we find it **less suited for strict rule-following**. Unlike supervised fine-tuning (SFT), which directly maximizes the likelihood of generating rule-compliant intermediate steps, outcome-based RL optimizes only for the final answer. For tasks with **explicit human-defined rules**, we believe **explicitly teaching the rule** is more effective than relying on model's exploration.\n\nEmpirically, as shown in Figure 7, the RL-trained model underperforms Meta-RFFT. Without supervision of intermediate steps, it struggles to follow rules reliably (see Table 9 for an error case). Besides, Meta-RFFT significantly outperforms long-CoT models like DeepSeek-R1-671B and QwQ-32B on length generalization tasks (see R1's error case in Table 8).\n\nThat said, we strongly agree with the reviewer tbVk (and reviewer VnFA) that **RL, especially multi-task RL with process-level rewards** is a promising future direction.\n\n# Q1:\nYes, we appreciate your interest! The data construction code is already included in the supplementary material, and we will release the full codebase, including task generation scripts and training pipelines, to support future research and adoption.\n\n# Q3:\nWe appreciate your insightful suggestion and have conducted the following ablation study.\n\nIn the current paper, the RF-pretraining stage includes tasks from three datasets: LeetCode, Big-Bench Hard, and Symbolic Reasoning. To assess the impact of the number of composed tasks, we conduct an ablation where the model is RF-pretrained **only on the LeetCode subset**.\n\nDue to resource constraints, we evaluate on 4 downstream tasks, including 2 LeetCode tasks (Move Zeros & Valid Palindrome) and 2 NUPA tasks (Add Integer & Digit Max Integer), all of which are unseen during RF-pretraining.\n\nThe results are shown below. We observe **a slight performance drop** when excluding Big-Bench Hard and Symbolic Reasoning, likely due to reduced task diversity during pretraining:\n\n|                             | ACC_Len30 | Max_Len_90% |\n|-----------------------------|-----------|-------------|\n| Meta-RFFT (complete pretrain dataset)                 | 0.56      | 16.0       |\n| Meta-RFFT (LeetCode only)   | 0.51      | 12.5       |"}, {"review_id": "W34LZqIjP2", "reviewer": "Reviewer_MTxe", "summary": "This paper studies the problem of length generalization of LLM in multi-task setting, they introduce Meta-RFFT—an extension of RFFT that teaches a model to internalise general, code-style rules across 74 diverse tasks and then reuse that know-how on completely new problems. After this rule-following “pre-training”, a 32-billion-parameter model needs only a handful of short examples—or even a single in-context demonstration—to solve much longer versions of unseen tasks with near-perfect accuracy. Error analysis shows the win comes largely from mastering loop control, a transferable primitive that vanilla, single-task fine-tuning never really learns.", "questions": "Refer to weaknesses", "limitations": "N.A.", "rating": 3, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "**Strengths:**\n\n1. The problem being studied in this paper is new and interesting.\n\n2. This paper shows strong empirical performances in length generalization compared to baselines.\n\n3. This paper is overall very well written and easy to follow. \n\n4. This paper proposes a data construction pipeline for length generalization tasks, which could be of interest to practitioners. \n\n**Weaknesses:**\n\n1. The contribution, compared to the most relevant work - RFFT, seems incremental; this paper simply generalizes the problem to a multi-task setting, with very few actual technical contributions.\n\n2. This is mainly a heuristic paper and does not introduce any new insights to the problem; some claimed insight, such as learning transferrable patterns is beneficial for multi-task learning, is, in fact, commonly known principles in areas such as Domain Generalization, Multi-task Learning, as well as Instruction Tuning.\n\n3. The authors did not report how Meta-RFFT will hurt the model's performances on other metrics, such as common knowledge, reasoning, and preference alignment. Since the task being considered in this paper is relatively narrow, a significant gain of the length generalization capability at the dispense of other capabilities of the LLM is highly unfavorable.\n\n4. The objective of this study is somewhat confusing to me - are authors trying to improve the out-of-task length generalization ability of the LLM, or are they simply improving the coverage of the fine-tuning dataset? Because it seems that the tasks authors are evaluating are precisely the same as the datasets you constructed, in that case, this paper seems trivial compared to RFFT since it just improves the coverage of the training data and does not truly generalizes to unseen tasks. In real-world practices, you cannot enumerate all possible tasks at the training time, so a sensible evaluation, in my opinion, is to evaluate how generalizable the patterns you learned to the unseen tasks.", "was_revised": true, "final_justification": "After reading the authors’ rebuttal and engaging in a thorough discussion, I believe my original concerns regarding W3 and W4 have been resolved.\n\nHowever, I am still slightly leaning towards rejection, as W1 and W2 persist even after discussions with the authors. Specifically:\n(i) in my view, the contribution compared to the most relevant work [1] is not significant enough for a NeurIPS publication; and (ii) there is a lack of a systematic and scientific approach for constructing datasets for cross-task length generalization—the principles argued by the authors remain vague and subjective.\n\nLastly, I feel the scope of this paper aligns more closely with the D&B track rather than the main track.\n\n[1] Case-based or rule-based: How do transformers do the math? ICML 2024.", "rebuttal": "We sincerely appreciate the reviewer’s constructive feedback. We hope the following responses will fully address your concerns and further clarify our contributions.\n\n# W1:\nWe would like to clarify the contribution and novelty of our work as follows:\n1. **First work to explore cross-task length generalization**\n    * We fully acknowledge that multi-task training is a well-established concept across many domains. However, our work introduces a novel perspective by being the first to explore **cross-task transfer of length generalization** through multi-task training. Length generalization presents a unique challenge due to its inherent **out-of-distribution (OOD)** nature—models are trained on short sequences but must generalize to much longer ones. We show through experiments that traditional multi-task methods like instruction tuning (e.g., Tulu3 in Table 3) fail under such conditions, since the reasoning steps required at test time go far beyond those seen during training.\n2. **Meta rule-following through multi-task training**\n    * While multi-task training itself is not new, our key insight is that training on a large number of (rule, execution trace) pairs teaches the model to **internalize transferable, rule-based reasoning patterns** through shared computation primitives, such as loop maintainence. This results in a **meta rule-following capability** that supports length generalization across diverse tasks. For example, our RF-pretrained 32B model achieves **95% accuracy on 30-digit addition**, even though it has never seen that task during training—dramatically outperforming much larger models like DeepSeek-R1-671B (72%) and QwQ-32B (32%).\n3. **Why training on many rules matters**\n    * Humans have developed an extensive array of rules throughout history, encompassing both natural laws and regulatory frameworks. For instance, the rules for integer addition are clearly outlined in textbooks, on wikis, and within computer programs. Although these rules may be present within the large training corpus during pretraining for LLMs, current training methods fail to fully leverage them. The **relationships** between the “rules” and their corresponding “instances” remain **inadequately modeled**. As a result, while recalling rules is relatively straightforward for models, they **struggle to apply these rules** to specific instances. This results in failures to generalize in length on seemingly simple problems. Meta-RFFT addresses this by explicitly linking rules and step-by-step executions across many tasks, encouraging cross-task rule-based reasoning. The idea of modeling the relationship between rules and rule-execution traces is novel beyond RFFT.\n4. **Key technical contribution beyond RFFT**\n    * We collect 86 diverse tasks spanning code execution, number processing, logic, and symbolic reasoning—far beyond the 3 tasks used in RFFT—and generate 310k rule-following samples for RF-pretraining across 74 of these tasks.\n    * Through this, the model learns a meta rule-following ability: it can solve unseen tasks with only 1-shot prompting, as shown in Section 4.3 (Figures 5 & 9). This enables **in-context transfer** of rule-following behavior, reducing or even **eliminating the need for downstream fine-tuning**—greatly enhancing the practicality and usability of our approach over RFFT.\n    * Besides, the RF-pretrained model demonstrates superior performance in various downstream tasks to vanilla RFFT.\n5. **Beyond prior length generalization literature**\n    * Previous studies on length generalization focus on **single-task, small-scale** transformers **trained from scratch**. These models, despite generalizing well in certain tasks, have little generic language ability. Our work aligns with LLM's core multi-task advantage and explore length generalization in a **multi-task, post-training** setting, using **pretrained LLMs**. \n\n# W2:\nIndeed, learning transferable patterns aids generalization is a well-established principle in areas such as Domain Generalization and Instruction Tuning, but what are the \"transferrable patterns\" and how to find them for specific scenarios such as length generalization, matter much more than the principle itself. In this regard, we respectfully argue that our work innovatively introduces a **new insight specific to the problem of length generalization** in large language models: that learning explicit, transferable **rule-following patterns** via multi-task training significantly enhances **OOD generalization on unseen tasks**, which is a direction not addressed in prior work. In other words, our work answers it is the \"rules\" and their underlying loop structure that make the transfer happen.\n\nBy explicitly teaching rules and execution traces across many tasks, Meta-RFFT enables models to internalize meta-level computation strategies, such as loop maintenance, that generalize both across lengths and tasks. This is not merely multi-task learning—it is **the first demonstration of cross-task transfer in length generalization**, enabled by explicit rule-based supervision at scale.\n\nWe believe this is a meaningful insight with practical implications for building LLMs that generalize more robustly in reasoning-intensive scenarios.\n# W3:\nWe appreciate the reviewer for pointing out this important and practical concern.\n\nMeta-RFFT involves substantial RF-pretraining, which indeed can affect the model’s general capabilities due to distribution shift, known as catastrophic forgetting. But typically this is easily addressed by mixing some pretraining corpus during fine-tuning.\n\nTo verify this, we conduct a supplementary experiment. As we don't have access to the pretraining data, we mix GSM8K training data into downstream finetuning alongside the original meta-rule-following data to verify that the reasoning ability on GSM8K can be kept after RFFT. More specifically, for each training example in GSM8K, we use Qwen2.5-7B-Instruct to generate 10 candidate answers and filter the corrrect traces as the training set, forming a filtered GSM8K dataset of 7182 samples.\n\nThe results on length generalization (averaged across 8 LeetCode tasks) and GSM8K test accuracy are shown below. We observe that merely mixing 7k samples (compared to 310k Meta-RFFT data) effectively recovers the model’s reasoning performance on GSM8K, while maintaining the strong multi-task length generalization ability. Notably, Meta-RFFT still significantly outperforms vanilla RFFT, demonstrating that **general capabilities can be preserved with minimal additional data**.\n\n|   | ACC_Len30 | Max_Len_90% |\n|---|----|---|\n| vanilla RFFT  | 0.34   | 7.00    |\n| Meta-RFFT    | 0.82    | 22.75   |\n| Meta-RFFT with general data | 0.79      | 21.25       |\n\n|   | GSM8K Test ACC |\n|---|---|\n| Qwen2.5-7B-Instruct  |  87.95%   |\n| Qwen2.5-7B-Instruct (Meta-RFFT with general data) | 87.80%     |\n\n# W4:\nWe’d like to clarify a key point: **the evaluation tasks are entirely distinct from the training tasks**, and the focus of this paper is precisely on **generalizing to unseen tasks and unseen lengths**, not merely expanding training coverage. Besides, we conduct additional experiments on a real-world task **the Airline Baggage Cost Estimation task**, which is very different from the tasks in our paper and show the results below.\n\n* As shown in Figure 2, the 12 evaluation tasks (8 from LeetCode, 4 from NUPA in Figure 3) have **no overlap** with the 74 tasks used during RF-pretraining. We will make this clearer in the revision.\n* In particular, the NUPA tasks, used solely for evaluation, are completely held out during RF-pretraining—yet the model generalizes well to these tasks after minimal adaptation.\n* In the downstream adaptation setting, the model is fine-tuned only on lengths 1–5 and then tested on unseen lengths 6–30, to assess true **OOD length generalization**.\n* Beyond that, we also evaluate the model’s ability to handle **unseen tasks via 1-shot in-context learning**, without any fine-tuning. As shown in Figure 5 (7B) and Figure 9 (32B, Appendix E.1), the RF-pretrained model can directly adapt to new tasks with only a single example, achieving strong performance and robust length generalization.\n\nIn short, **Meta-RFFT is explicitly designed and evaluated for generalization to tasks and lengths never seen during training**—in stark contrast to simply expanding dataset coverage. We show that it enables LLMs to:\n* (a) **extrapolate to longer input lengths** (length generalization); and\n* (b) **adapt to entirely unseen tasks** through minimal examples (cross-task transfer).\n\n---\n## Further Results on Real-World Task\nTo validate the practical value of Meta-RFFT beyond symbolic tasks, we additionally conduct experiments on a real-world scenario: **the Airline Baggage Cost Estimation task** from [1].\n\nThis task asks the model to compute the total travel cost for passengers according to American Airlines' policy. Solving it **requires understanding and applying natural language regulations, which go beyond what can be fully captured in formal code**. Current LLMs perform poorly on it, and even strong models like Claude-3.5 and o1-preview degrade rapidly with input length (see the table below).\n\nWe train models on samples with length 1-8, and report test accuracy on OOD lengths 10-16. As shown below, **Meta-RFFT significantly outperforms vanilla RFFT in the practical domain**:\n\n| length| 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 |\n|---|---|---|---|---|---|---|---|---|\n| Vanilla RFFT | 0.94 | 0.72 | 0.78 | 0.56 | 0.44 | 0.16 | 0.00 | 0.08 |\n| Meta-RFFT    | 1.00 | 1.00 | 0.92 | 0.90 | 0.74 | 0.38 | 0.24 | 0.26 |\n\n| length  | 5 | 8 | 11|\n|---|---|---|---|\n| Claude-3.5 Sonnet (0-shot) | 0.04 | 0.00 | 0.01 |\n| Claude-3.5 Sonnet (1-shot) | 0.29 | 0.30 | 0.11 |\n| o1-preview (0-shot) | 0.54 | 0.37 | 0.21 |\n| o1-preview (1-shot)| 0.63 | 0.55 | 0.46 |\n\n\n[1] Zhou et al., RULEARENA: A Benchmark for Rule-Guided Reasoning with LLMs in Real-World Scenarios, 2025."}]

Author rebuttal:

Meta-review: This paper presents work on length generalization in large language models. It introduces Meta-RFFT, a multi-task fine-tuning framework that enables robust cross-task generalization. A new dataset of 86 tasks, spanning symbolic reasoning, code execution, and number processing, has been curated. Experiments also demonstrate strong performance gain.

The work is well motivated, with comprehensive empirical results. It receives the comments of five reviewers. During the review process, reviewers raised concerns in (1) limited task types; (2) mixed complexity in training; (3) the framework overhead; (4) the extension to reinforcement learning strategy. A detailed rebuttal is provided to address them. Four of five reviewers are finally positive about this work. One reviewer is a bit negative, mainly due to the concern about the technical contribution of this work. 

AC has carefully reviewed the paper and the reviewers’ comments, and considers that this paper can provide enough valuable insights to the research field and meets the acceptance line. The authors are encouraged to incorporate the reviewers’ constructive feedback in the final version to further strengthen the clarity and impact of this work.
Decision: Accept (poster)