AbstRaL: Augmenting LLMs' Reasoning by Reinforcing Abstract Thinking
Authors: Silin Gao
Antoine Bosselut
Samy Bengio
Emmanuel Abbe
Venue: ICLR 2026 Poster (2026)
Keywords: large language models
abstract reasoning
robustness
reinforcement learning
Primary area: reinforcement learning

Abstract: Recent studies have shown that large language models (LLMs), especially smaller ones, often lack robustness in grade school math (GSM)  reasoning. In particular, they tend to experience performance drops when faced with distribution shifts, such as changes to numerical or nominal variables, or insertions of distracting clauses. A possible strategy to address this involves generating synthetic data to further "instantiate" reasoning problems on potential variations. In this work, we instead focus on the strategy of ``abstracting'' reasoning problems. This not only helps counteract distribution shifts but also facilitates the connection to symbolic tools for deriving solutions. Focusing on GSM, we find that this abstraction process is better acquired through reinforcement learning (RL) than just supervised fine-tuning, which often fails to produce faithful abstractions. Our method, AbstRaL---which promotes abstract reasoning in LLMs using RL on granular abstraction data---significantly mitigates performance degradation on recent GSM perturbation benchmarks. Besides, improving GSM robustness via AbstRaL is shown to also implicitly benefit LLMs' capabilities on OOD mathematical and general reasoning tasks, indicating that abstract thinking broadly enables better generalizability.

Published as a conference paper at ICLR 2026
ABSTRAL: AUGMENTING LLMs' REASONING BY REINFORCING ABSTRACT THINKING
Silin Gao Antoine Bosselut", Same Bengio ., Emmanuel Abbe
Apple 2EPFL
ABSTRACT
Recent studies have shown that large language models (LLMs), especially smaller ones, often lack robustness in grade school math (GSM) reasoning. In particular, they tend experience performance drops when faced with distribution shifts, such as changes to numerical or nominal variables, or insertions of distracting clauses. A possible strategy address this involves generating synthetic data further "instantiate" reasoning problems on potential variations. In this work, we instead focus on the strategy of "abstracting" reasoning problems. This not only helps counteract distribution shifts but also facilitates the connection to symbolic tools for deriving solutions. Focusing on GSM, we find that this abstraction process is better acquired through reinforcement learning (RL) than just supervised fine- tuning. which often fails to produce faithful abstractions. Our method, AbstRaL- which promotes abstract reasoning in LLMs using RL granular abstraction data-signi signi-ignnficaatly mitigates performance degradation on recent GSM perturbation benchmarks. Besides, improving GSM robustness via AbstRaL is shown also implicitly benefit LLMs' capabilities on OOD mathematical and general reasoning tasks, indicating that abstract thinking broadly enables better generalizability.
INTRODUCTION
The ability of reasoning, which involves the integration of knowledge to derive dynamic conclusions rather than direct recourse memorized information (e.g.. Yu et al. 2024 Abbe al. 2024), is an
essential quality for artificial general intelligence (Zhong et al. 2024a). Toward this end, recently
developed large language models (LLMs) have been equipped with impressive reasoning capabilities,
either scoped for general purpose (Guo et al. 2025 Yang et al. 2024a Grattatiori et al. 2024) or in
specialized domains such as mathematics (Shao et al.) 2024 Yang al. (2024b).
However, most LLMs, especially smaller one: still face the challenge of robustness when rea- soning, revealing considerable room for improvement in out-of-distribution (OOD) generalization. In particular, recent works (Mirzadeh et al. 2025 Li et al. 2024) have shown that even in simple
GSM tasks, LLMs suffer performance degradation when facing perturbations and distribution shifts. LLMs can be prone to reasoning errors on instantiation shifts such as when numerical or nominal variables GSM ques- tion are altered, even though the LLMs can respond to the original question correctly. On more challenging interferential shifts, where distracting (topic-related but uscless) condition added, L.LSs suffer even more drastic performance drops.
X
A
Y
X
To improve the robustness of reasoning, a possible learning strategy (Boix-Adserà et al. 2024) is to synthesize more in- stances of reasoning problem that are varied in surface-form contexts but follow the same high-level reasoning schema rep- resented by an abstraction of the problem. this paper, instead of scaling up the training instances (can be computationally expensive). we teach LLMs to directly learn an abstraction underlying reasoning problems and thereby learn reason in a manner
Figure 1: Two paraphrased queries X and X, having same solution Y. can be both handled by common abstraction A.
Work done during internship at Apple. verified by our analysis in $5.1

---

Published as a conference paper at ICLR 2026
Original Reasoning Problem
Vary Relevant Conditions
Reasoning Accuracy of LLMs
Vary Problem
Add Distracting Conditions
0.72
AbstRaction Learning (AbstRaL):
0.68
in0=12, in1=2
0.64
Symbolic Tools
outO
0.6
Input: Li 12, Jung 2 years older.
Abstraction: inO=in1-out0
Output: Jung is 14 years old.
0.56 Without AbstRaL.
How old Jung?
LLMs
With AbstRaL.
Our AbstRaction Learning (AbstRal.) method effectively improves GSM reasoning robustness of LLMs, especially facing the variations of relevant input conditions and the interference of distracting conditions. We present average accuracy all our tested LLMs on GSM-Plus (Li et 2024), including the original GSM8K testing set (Original Reasoning Problem), the testing sets with numerical variations (Vary Relevant Conditions), averaged across three portions (digit expansion, integer-decimal-factiin conversion and numerical substitution), the testing set with problem rephras- ing (Vary Problem Contexts) and with distractor insertion (Add Distracting Conditions).
Figure 2:
Our work is rooted in the abstract reasoning literature (Hong al. 2024 Dutta al. 2024| Gao al., 2025). with a new granular reinforced abstraction learning scheme that promotes the robustness and generalizability aspects of reasoning.
that is invariant to contextual distribution shifts.
We propose the reinforced AbstRaction Learning framework, AbstRaL, as shown in Figure 2| which first teaches LLMs to generate mathematical abstraction of input GSM problem, and then connects the abstraction with symbolic tools to stably derive the output solution, regardless of the specific input contexts. The learning of abstraction relies on our shanullary-decompoee (GranulAR) data ($3. distilled from an oracle LLM,, which integrates symbolic reasoning within socratic problem decomposition (Shridhar al.] 2023) and chain-of-thoup (CoT) explanations (Wei cct al. 2022). On top of supervised fine-tuning (SFT), AbstRaL uses reinforcement learning (RL) with set of model-free rewards ($3.2 to further improve the faithfulness of generated abstraction.
Abstract Reasoning
We tested AbstRaL on two benchmarks that evaluate the robustness of GSM reasoning ($5.1). GSM-Symbolic (Mirzadeh et al.) (025) and GSM-Plus (Li et al. 2024). Experimental results various seed LLMs consistently demonstrate that AbstRaL effectively improves the GSM reasoning robustness of L.MMs. As shown in Figure AbstRal. almost reverts the performance drop of L.MMs caused by variations relevant input conditions, and also significantly mitigates the interference of distracting conditions added to the perturbed testing samples. Furthermore, we find that LLMs trained with AbstRaL demonstrate improved zero-shot performances on a wide range of OOD tasks within and beyond the math domain ($..2,. such as AIME (MAA 2024) and BBH (Suzgun 2023). This indicates that, more interestingly, AbstRaL's 's learning of abstract thinking in the GSM domain can implicitly benefit more general reasoning capabilities of LLMs.
LEARNING STRATEGIES TO IMPROVE REASONING ROBUSTNESS
We assume that every reasoning data sample, consisting of input question (or query) X' and output answer (or response) y, is an instantiation of an underlying symbolic abstraction A that represents high-level reasoning schema. For example, according how much older he is than Li, is based the abstract arithmetic rule of adding two numbers. A robust reasoner is supposed to master the abstraction A, and therefore stably give a faithful answer any question X' implicitly derived from A. rather than overfitting to only subset of instances of AA and vulnerable to distribution shifts that go beyond the subset.
Figure 3 the problem of calculating Jung's 's age,
A common strategy improve the reasoning robustness of LLMs is to augment the learning data by synthesizing more instances {(X', )"),,,
)) (X" """" ...) of abstraction A, with paraphrasing (Gan & Ng 2019 Zhou al. 2024) templates (Boix-Adserà al. 2024). For example, shown in
2

---

Published as a conference paper at ICLR 2026
Zhou 15 years old. 5 years older than Zhou. How old Wu? x"
Y': Wu + 5 20 years old.
(a) Robustifying by Instantiation
Y"
Synthetic Data Augmentation
Input
Output
(Hidden) Abstraction
X: Li is 12 years old. Jung is years older then Li. How old Jung?
Jung 12 2 14 years old.
ioutto
out0-14
Abstract Thinking
(b) Robustifying by Abstraction (Our AbstRal)
in0-12 in1-2
(4)
x is [in0] years old. Jung is [in1]
y Jung is <xinO+in1
A: in0+in1=outo
years older then Li. How old Jung?
=out0>> old.
Figure 3: Learning strategies to improve reasoning robustness with respect to distribution shifts. (a)
Augmenting the amount of learning data by synthesizing more reasoning instances. (b) Directly learning to construct the underlying abstraction based on the input, including: (1) condition recogni- tion, (2) abstract reasoning, (3) abstraction retrieval and (4) symbolic derivation.
Figure (a), the names and numbers appearing in an instance can be replaced with other values to create a new instance, which has different problem context and input conditions. but follows the same abstract arithmetic rule. As verified by previous study (Boix-Adsers et al., 2024), this learning strategy requires a large amount of synthetic data augmentation, to effectively boost LLMs' grasp of the high-level abstraction, thus being able to resist the interference of surface-form variations.
In this work, instead, we focus on the strategy of abstract thinking (Hong et al. 2024 Gao et al. 2025), which teaches LLMs to directly learn the abstraction underlying each instance (Y). and connect A with symbolic tools such
equation solver, to steadily derive the answer ) to the question X, as illustrated in Figure (b). Without scaling up the training data, our direct learning of abstraction still effectively improves the robustness of GSM reasoning, due to the modeling of more general reasoning patterns represented by the abstraction. We introduce our method in detail in $
ABSTRAL: REINFORCED ABSTRACTION LEARNING FRAMEWORK
Figure 3 (b) illustrates our AbstRaL framework that incentivizes LLMs' abstract thinking in GSM problem solving, which consists of four steps.
(1) Condition Recognition We first parse the input GSM question X' to identify conditions C that can be used to answer the question, and formulate C with abstract symbols, which represent the input variables in abstraction A. For example, in the problem shown in Figure the numbers 12 and 2 given in the question are used to derive the answer, which are assigned the symbols in0 and inl, respectively. Then the abstract input question, denoted as X is constructed, by replacing the specific texts (or values) A' with their assigned abstract symbols C, enclosed in square brackets. This step be performed by either symbolic tool, e.g., regex- matching script that searches numerical values, or a neural parser designed by prompting an LLM
constructed GranulAR data ($3.1 to teach LLMs abstract reasoning on GSM problems, based on SFT and RI an abstract answer ) to the abstract question A In YAA LLMs quote input variables in A by their assigned abstract symbols, and also use abstract symbols to represent derived output variables, such the math derivation result outO in Figure (b), enclosed in double angle brackets.
(2) Abstract Reasoning We then
($3.2). In particular, L.LMs are tasked to generate
We introduce the specific experimental implementations of proposed framework in
3

---

Published as a conference paper at ICLR 2026
X: Zhong is trice o as U. is years old. Chang's s brother Jung is years older than Chang. How is Jung?
(Socratic old Zhang old. Jung?
Symbolic Derivation
[ (1) Condition Recognition
Abstract Reasoning Rewriting] [ by
x-4 Zhang [ind] old. Zhang's botherr (122) than
Li
y (Grndaetydacompood Abstract Reewsningg::
inOa int mound
e:
List of sub questions How oid Zrang? How old Jung?
in0=2
Jung?
How old Zhung? Li fit1] years Zhang (in]] times us old as lú, so Zrang is <sin0"in -out0>>>>>>>>>> yeara old.
in1=12 in2-2
e: inOm2
int-12
Instance Rewriting
How isd Jung" dhang is loutti years ald, jung is [In2] years older than chang, so Junn exout@-inzwoutt>> years
Abstraction
Verificttion
answer is (out1)
Figure 4: Overview of GranulAR training data construction, which consists of an instance rewriting procedure to rewrite existing socratic CoT data (X, into fine-grained abstract reasoning data (XA, C, A)), followed by answer verification procedure to check the correctness of rewriting.
(3) Abstraction Retrieval Based on the abstract answer yM, we then retrieve the abstraction A that is de-contextualized from the instance (X,)) Similar to the condition recognition, the retrieval of A can also be done with a regex- megex-natching tool or a LLM with specific prompts.
(4) Symbolic Derivation We finally use the abstraction A. along with the input conditions C, to derive the real answer to the question. This derivation can be accomplished by either a rule-based symbolic parser, e.g. equation solver for arithmetic, or neural (LLM) symbolic reasoner.
Our framework decomposes the task of inferring A from X' into a fine-grre seee-graied pipeline X - X D + A. which facilitates the learning of this task. Nevertheless, the core abstract reasoning step of inferring Y-A from X still non-trivial, which requires fine- grained abstract reasoning data and proper reinforcement learning achieve robust inferences, described below.
3.1 GRANULARLY-DECOME
ABSTRACT REASONING (GRANULAR) DATA
Motivations LLMs have learned various fine- fine-griiedd reasoning strategies at either the pre-training (Yang et al., 2024c| Chen et al. 2025b) or the post-training (Kumar et al. 2025) phase, such as chain- of-thought (CoT) (Wei et al. [0022 and socratic problem decomposition (Shridhar al., 2023) as representatives. In our GranulAR training data, we integrate abstract reasoning with these pre-learned strategies, which enables LLMs gradually construct the abstraction in fine-grained reasoning chain, as shown in Figure D Such data format is close to the pre-training or the post-training data distribution, and therefore eases the difficulty of equipping LLMs with abstract thinking.
GranulAR Format The answer ) of GranulAR first decomposes the question 2'A into a list of sub-questions, which enables holistic planning of step-by-step reasoning. Based on that, Y answers each sub-question with CoT and abstract symbols, where it first quotes relevant input conditions answers to previous sub-questions), and then derives the answer with quoted symbols. Finally, D draws conclusion to clarify which output abstract symbol represents the final answer.
Data Construction Figure illustrates how we construct the GranulAR training data. We first conduct the condition recognition described in $ to formulate the conditions C from the question X and creates the abstract question A Based on that, we prompt an oracle I.I. to rewrite the gold socratic CoT answer ) into desired abstract answer )AA The abstract question X is also fed into the oracle LLM, to complement the problem contexts and clarify the abstract symbols input variables. Given the distilled abstract answer yA, then conduct the abstraction retrieval to get the de-contextualized abstraction A. Finally, the symbolic derivation step is performed to verify whether A along with C can derive the correct final answer stated in y We only keep the rewritten instances that pass the answer verification.
3.2 LEARNING OF ABSTRACT REASONING
Previous study (Gao et al. 2025) has shown that LLMs are poor at following in- context demonstrations to reason in abstract manner, indicating that the learning of abstract reasoning requires training with proper supervision, rather than relying on only in-context instructions and examples. A straightforward way is to train LLMSs with supervised fine-tuning (SFT). However,
Motivations
4

---

Published as a conference paper at ICLR 2026
: Zhang is [in0] times as old ar U. Liss (in1] years oid. Zhong's brother Jung is [in2) years older than Zhong. How old Jung?
gx:
EditDistance (R, ) =
Zhang is scin0"int= -outt>>>> years old.
Zhang is scin0"int=oute" years old. Jung <<cutt+in2moutts> cló. The 'inal
Jung is >-cout0"inbzoutt>>> The fnna answer out1.
max (Len(A)) Len(d
10
(26).
(red pans emoneous)
Tsymbolic
1.5 2/100
(tokenizad);
[tokenizad];
[in,, iinn, m, outo, <space>, outō, +, ind, v, outi]
C: ind=2
IF out1 26
ELSE
[nnO, in1,, outO, <space>, outO, +, in2: outi)
Model Generation
int=12
in2=2
Taasver
25
Tonouer
Reference
Figure 5: Illustration of the abstraction rewards in our reinforcement learning approach, including the symbolic distance reward I' l'symbolic and the answer correctness reward T'nswer-
although SFT on abstract data can teach LLMs decent abstract reasoning formats, its auto-regressive training objective also forces LLMs to learn the specific contexts of each training sample. This hinders LLMs from learning more general abstract thinking strategy, which leads to frequent test-time failure of generating an abstraction that is aligned with the problem, skewed by the new contexts in the testing data $ as shown by our results in $5.1 Therefore, we propose to conduct reinforcement learning (RL) top of SFT, augment LLMs' capability of constructing faithful abstractions.
Fine- Tine-Tuning We fine-tune LLMs to auto-regressively generate our constructed Granu- IAR answer YA based the input question A simply with the causal language modeling loss of predicting each token in ):A based on former tokens.
Supervised
Reinforcement Learning with Abstraction Rewards
On top of SFT, develop RL approach to further improve the faithfulness of abstraction generated by LLMs. Our RL approach proposes new of rewards to closely rate the generated abstraction two aspects. First, given the model created abstraction Á retrieved from its generated answer y:4, we perform the symbolic derivation to check whether A can derive the correct final answer (denoted as Ans) with the conditions C given in the gold reference. If yes, a positive reward l'orrect (hyperparameter) granted the model, otherwise zero reward is given. We denote this answer correctness reward as Tanswer (A, C, Ans). Second, we more granularly measure how À is aligned with the expected abstraction A retrieved from the gold answer 3:A, Specifically, we split A and A into lists of symbolic tokens, where each token is either an abstract symbol (created in C, ) or yd) that represents an input or output variable (such in0), or pre-defined operator that connects variables (such as =) separates derivations (such as (space)), as shown in Figure
Based on that, we calculate a symbolic distance reward:
T ssymbatic (A, A) = Tmaz
EditDistance (,) max oa Len(a)
where Tmaz denotes the maximum reward hyperparameter, EditDistancee .A) denotes the list-wise edit distance (Levenshtein et al. 1966) between tokenized abstractions and A. and Len(-) calculates the length of list, used for normalizing the edit distance into the range of distance reward granted to the model if A is closer (or more similar) to A, which gives the model more fine-grained learning signal of how far away it is from creating the correct abstraction. Figure shows an example case our abstraction rewards. Note that our proposed rewards do not require pre- traitri reward model, but just comparison to the gold reference. We plug our abstraction rewards with GRPO (Shao et al. 2024). an advanced RL algorithm for incentivizing reasoning capability in The formulation of GRPO with rewards is described in Appendix
A higher symbolic
LLMs (Guo et al. 2025
EXPERIMENTAL SETTINGS
(Grattafiori et al. 2024) model with few-shot examples to accomplish the first condition recognition step of A
Implementation of AbstRaL Framework We prompt Llama-3.3-700
OOn the other hand, learning to directly generate de de-contextualized abstraction is rather hard for LLMs that are pre-trained on mostly contextualized natural language corpus, verified by our analysis in $5.I which motivates of fine-grained framework still incorporate contexts in the learning of abstract reasoning.
5

---

Published as a conference paper at ICLR 2026
Based that, we tune various LLMs on constructed GranulAR data ($3.1), with our SFT and RL scheme ($3.2), to perform the core abstract reasoning step. Our tested LLMs include Llama3 model series (Grattafion et al. 2024), Qwen2.5 model series (ang et al. 2024a) and Mathstral-7BB. In the abstraction retrieval step, we simply use a regex-matching script to extract all math derivations that are enclosed in double angle brackets in the abstract answer, which form the abstraction. We use SymPy equation solver to perform the symbolic derivation, which derives the final answer. For GranulAR training data construction, we use Llama-3.3-70B- 300--tett the oracle LLM, and prompt it with few-shot examples to rewrite the training samples in the socratic version of GSM8K (Cobbe et al., 202T) from OpenAI. More implementation details are included in Appendix B
Baseline Methods We compare AbstRaL to several baseline reasoning methods, including 8-shot CoT prompting (CoT-8S), 8-shot Program-of-Thought (Chen et al. 2022) prompting (PoTT-8)), RI. with non-rewritten (socratic C GSM8K training data (CoT--LL,, and other abstract reasoning
methods CoA (Gao et al. 2025). J AoT (Hong et al., (024) and SyReLM (Dutta et al. 2024). We
include more details of baseline methods in Appendix C
Evaluation Datasets We evaluate our method on two datasets that are commonly used for testing GSM reasoning robustness: GSM-Symbolic (Mirzadeh et al., 2025) and GSM-Plus eti 2024).
GSM-Symbolic manually constructs problem templates from 100 GSM8K testing samples, and uses the templates to create new problems where the numbers or names both in the original problem are varied to different values, denoted as Vary Num., Vary Name and Vary Both, respectively. We follow GSM-Symbolic conduct 50 rounds of evaluation, each round creating problem from each template (so models are tested on 100 new problems per round), and measure the average performance across these 50 rounds, i.e., the mean (with standard deviation) of accuracy, and check whether matches the performance on the original 100 (Origin 100) GSM8K problems. GSM-Plus creates different variations of the full GSM8K testing set instead, where each varied testing set contains all 1319 GSM8K testing problems. For each type of variation, 1 varied sample is created for each original problem, which leads to a single round of evaluation per variation. Our tested GSM-Plus variations include digit expansion (Digit Ex.) that adds more digits to number (e.g., from 16 to 1600), integerddecimal-fracee
conversion (Int-Dec-Fra) that changes the type of a number (e.g.. from 2 to 2.5), numerical substitution (Num. Sub.) that replaces number with another same-digit one (e.g., from 16 to 20), rephrasing the question to check problem understanding (Rephrase), and distractor insertion (Distract) that adds topic-relate but useless conditions, compared with model performance on the Original GSM8K testing set.
5
EXPERIMENTAL RESULTS
5.1 GSM REASONING ROBUSTNESS
Table [shows shows some of our representative evaluation results on GSM-Symbolic and GSM-Plus datasets. We report the performances of the smallest and the strongest LLMs tested in our experiments, which are -...2..--.5B-Insiiiii
and Qwen2.5-Math-77 7B-hthht-nnttt respectively. Results on other LLMs and on some data portions of GSM-Symbolic ( (Vary Num. and Vary Name) and GSM-Plus (Digit Ex., Int-Dec-Fra and Num. Sub.) are included in Appendix D which draw the same conclusion.
On GSM-Symbolic, we find that AbstRal. effectively improves the reasoning robustness of all tested LLMs ranging from 0.5B to 7B (or 8B) sizes, with respect to the variations of both numbers and names (Vary Both), demonstrating better generalization to distribution shifts. Specifically, compared to baseline methods, LLMs with AbstRal. achieve consistently better (mean) accuracy on Vary Both samples, with overall lower standard deviation across different testing rounds. Besides, LLMs with AbstRaL suffer less performance drop (A) when transferring from Origin 100 to Vary Both, especially compared CoT and PoT methods that do not use any abstract reasoning. Interestingly, on some large-size (7B or 8B) LLMs. although AbstRaL scores lower than CoT-8S and CoT-RL on Origin 100, it outperforms these CoT methods on Vary Both perturbed samples. This implies that learning with AbstRaL may mitigate LLMs' overfitting to the existing input conditions, caused by potential data contamination (Magar & Schwartz 2022
Xu et al. 2024) at pre-training or post-training stage.
We also did pilot study of training M. with non-socratic CoT data, which achieves similar results.

---

Published as a conference paper at ICLR 2026
Table 1: Evaluation results of GSM reasoning robustness, measured by the accuracy (%) of final answer. A denotes the relative percentage of drop comparing performance on Vary Both to perfor- mance on Origin 100. Num. Pert. denotes the average performance on the three GSM-Plus testing sets that perturb input numbers (i.e., Digit Ex., Int-Dec-Fra and Num. Sub.). Best results on each model are bold, where lower is better for A. Standard deviation (std) of multi-round evaluation results on Vary Both are in brackets, where lowest std on each model are underlined.
GSM-Symbolic
GSM-Plus
Model
Method
Vary Both
Origin 100
A
Num. Pert.
Rephrase Distract
Original
CoT-8S
(0.033))
38.0
10.6
34.8
43.6
22.7
42.4
PoT-8S
27.0 (0.035)
31.0
12.8
28.7
36.3
19.4
35.5
CoT-RI.
32.3 (0.032)
35.0
7.77
30.9
40.8
15.2
38.0
Qwen2.5-0.5B-Imeet
CoA
28.7 (0.026)
29.0
0.97
26.0
31.6
12.7
30.3
AoT
27.8 (0.029)
29.0
4.21
32.1
30.7
SyReLM
36.8 (0.030)
39.0
5.54
38.7
41.6
21.1
41.5
AbstRaL
44.6 (0.025)
44.0
-1.27
46.7
46.3
36.5
46.7
CoT-8S
87.7 (0.023)
95.0
7.73
84.1
90.5
91.8
PoT-8S
86.7 (0.023)
91.0
4.77
82.8
87.9
75.1
87.6
CoT-RL
88.1 (0.021)
96.0
8.21
86.0
90.4
81.5
93,4
Swen2.5-Math-7B-Bee
CoA
69.7 (0.033)
71.0
1.83
71.8
76.4
57.1
78.1
AoT
(0.032))
72.0
2.17
71.7
76.7
56.6
77.9
SyReLM
87.7 (0.026)
90.0
2.56
84.4
88.6
76.0
AbstRaL
90.2 (0.016)
91.0
0.86
89.1
89.9
82.3
89.2
Similarly GSM-Plus, AbstRaL almost reverts the performance degradation caused by variations of input numbers (Num. Pert.), and also maintains robustness to contextual variations (Rephrase) comparable baseline methods. More interestingly, AbstRal significantly mitigates the interference of distracting conditions added to the problems (Distract), while by comparison, LLMs with baseline reasoning methods all score more drastically lower when transferring from Original Distract. AbstRal''s improvement on Distract is largely due to learning on its manuuarly--dcompooo reasoning (GranulAR) data (verified in our ablation study below), which enables overall planning of the reasoning steps and then rethinking of useful input conditions at each reasoning step.
abstract
Ablation Study One natural concern of method is whether the improvements of AbstRaL are due to the learning of abstract reasoning, or just because of integrating powerful symbolic tools, iee. Llama-3.3- 3.33-70BB-nntrun retrieval and SymPy equation solver for symbolic derivation. To clarify this, conduct ablation study (w/o Tools), which replaces all above symbolic tools our framework with the LLM itself, to accomplish each step of our pipeline with step-specific prompts. Results in Table show that LLMs without additional tools suffer only minor performance drop, indicating that the learning of abstract reasoning in our framework is the major contributor the improvements.
prompted for condition recognition, regex-matching script for abstraction
We also investigate the effect of using AbstRaL's pipeline to construct the abstraction within contexts, i..,, X' X ) + A, by testing ablated framework (w/o Contexts), where LLMs trained (with SFT and the same RL approach) to directly generate the abstraction .A based on the abstract input question X',, i.e., + X processing it by abstraction retrieval. As shown in Table 2 LLMs that learn inferences without intermediate contexts fall far behind the unablated ones. This indicates that narrowing down the gap between symbolic abstraction and natural language is important to faithful abstract thinking.
without explicitly generating y: and post-
Our third ablation studies the contribution of RL in AbstRaL, by totally ablating the RL (w/o RL) or removing only the symbolic distance reward (w/o sssymbotic). On both the original and perturbed testing sets, we find that L.LMs without RI. score far lower than reinforcement-eerneee ones. Without Teymbolic that hints how close the generated abstraction is to the correct one, LLMs also suffer significant performance drop, and thus under-perfore the prompting baseline (CoT-8S). These findings demonstrate that acquiring faithful abstract reasoning requires careful learning, e.g., via proper RL approach and a milestone-stye style reward that closely monitors the progress learning.
Lastly, ablate the meauulary-decompprt training data format. We alter the gold abstract answer YA in our training data back to the standard socratic CoT format (as shown in Figure where remove listing sub-questions the start of
abstract reasoning (w/o GranulAR) used AbstRaL's

---

Published as a conference paper at ICLR 2026
Table 2: Ablation study results of GSM reasoning robustness.
GyM-Symbolie
GSM-Plus Rephruse
Model
Method
Vary Both Origin 100
A
Num. Pert.
Distract
Original
AbstRal,
44.6
44.0
-1.27
46.7
46.3
36.5
46.7
w/o Tools
43.6
44.0
0.86
46.0
45.6
Qwen2.5-0.5B-Il
w/o Contexts
23.1
30.0
23.1
27.0
28.8
16.5
28.7
w/o RL
29.6
36.0
17.9
38.0
32.3
28.3
35.7
w/o Pagembeii
37.6
39.0
3.59
41.7
40.0
31.3
38.8
w/o GranulAR
42.6
42.0
-1.48
42.4
42.3
23.6
42.4
AbstRaL
90.2
91.0
0.86
89.1
89.9
82.3
89.2
w/o Tools
90.0
91.0
1.14
88.6
90.4
81.8
88.9
w/o Contexts
Qwen2.5 1-125---tth-BBBB Instruct
w/o RL
78.5
82.0
4.22
82.1
80.0
74.5
82.3
w/o Fagmbooii
87.0
4.34
85.8
82.3
78.1
85.9
w/o GranulAR
88.1
89.0
0.97
88.4
89.8
88.6
Table Zero-shot evaluation results on OOD math datasets. Best results each model are bold.
GSM Train
Minerva MATH
SAT-
AIME-
Gaokao-
College- Math
Model
Method
MATH
Math
24
SVAMP
ASDiv
MAWPS
2023
TABMWP
AQUA
Oni-SFT
5.5
0wc.2.5-0.58
COT-RL
19.2
5.5
43.8
0.0
45.2
64.2
84.4
16.6
33.1
16.2
26.4
Innttrcct
CoA
31.6
5.5
43.8
0.0
39.8
54.0
60.1
23.9
46.2
27.8
30.7
AhaRal.
34.7
7.4
62.5
0.0
62.7
77.4
89.8
29.1
50.1
28.5
32,7
Ori-SIT
83.5
34,6
90.6
13.3
93.5
95.3
98.5
67.5
93.9
47.1
74.4
Qwen2.5 Math
CoT-RL
82.9
35.7
89.8
10.0
92.5
94.9
98.1
67.5
89.2
65.4
-7B-Instruct
CoA
83.7
34.6
90.0
12.7
93.1
95.1
98.3
67.0
92.9
47.2
72.8
AbstRaL
83,9
16.7
94.3
68.3
93.9
74.8
reasoning chain and quoting of input conditions at each reasoning step, while just keep the abstract derivations that forms the abstraction AA LLMs trained on this ablated data suffer drastic performance drop on the Distract testing set, indicating that they are vulnerable to useless distractors. This verifies that our adopted fine-grained reasoning format plays an essential role in identifying interference conditions, due to planning the reasoning steps and useful input conditions in each step.
5.2 GENERALIZATION TO OOD TASKS
AbstRaL's 's learning of abstract thinking GSM problems also improves general reasoning capabilities of LLMs, rather than overfitting LLMs to GSM-specific tasks. We verify this by testing LLMs zero-shot generalizability on a wide range of OOD datasets beyond GSM8K, including other math datasets MATH (Hendrycks et al. (2221) Minerva MATH (Lewkowyez et al. (022)). LAT-Math from AGIEval (Zhong et al. (0044b), AIME24 (MAA) 2024). SVAMP (Patel et | ASDiv (Miao al. 2020). MAWPS (Koncel-Kedziorse
al.
2016), Gaokao-2021 (Liao et al., 2024), TABMWP 2024) and AQUA (Ling et al. 2017). 7 and general
[Lu et al. 2022), College-Man (Tang et al.
reasoning datasets MMLU (Hendrycks et 2020). BBH (Suzgun et 2023). ARC-Challenge (Clark et al. 2018) and OoenBo (Mihaylov et al. 2018). We compare Qwen models trained with AbstRaL to the original model checkpoints that are already fine-tuned on GSM8K in post-training, denoted as Ori-SFT. We also compare AbstRaL to the baseline method CoT-RL, which improves the original GSM8K performance of Owen2.5-Main -------a-----tte In-Inttuttt, and to the baseline CoA, which achieves second-best GSM reasoning robustness (based on the ranking of A).
Table and 4 present our zero-shot generalization results on OOD math and general reasoning datasets, respectively. AbstRaL consistently outperforms baseline methods across all the tested OOD datasets, even though the GSM reasoning scheme learned AbstRaL training may not be directly applicable to solving the OOD tasks. This indicates that learning the abstract thinking underlying GSM can already implicitly benefit other mathematical reasoning and more general reasoning of
LLMs. By contrast, Qwen models trained with CoT-RL and CoA cannot stably improve upon the original checkpoints (Ori-SFT), showing that acquiring such "implicit benefit" from GSM needs more careful learning via AbstRal..
8

---

Published as a conference paper at ICLR 2026
Table 4: sero-shot evaluation results other OOD datasets. Best results each model are bold.
GSM Train
MMLU
ARC-
OpenBook-
Model
BBH
Method
STEM
Social Humanities
Other
Challenge
QA
Ori-SFT
37.5
51.5
41.6
49.7
21.0
33.3
33.6
CoT-RL
38,5
50.8
41.2
49.1
23.2
32.2
33.2
1ren2.55-..B-Instrree
CoA
38.5
50.8
41.9
49.3
21.8
32.6
33.6
AbstRaL
38,8
53.5
42.2
50.7
26.3
33.8
34.6
Ori-SFT
68.4
82.5
63.2
76.4
43.7
51.9
48.8
CoT-RL
68.5
81.5
63.0
74.4
46.0
52.0
47.0
Qwen2.5-Math S----MMa------ntttue BB-Inrructt
CoA
68.5
81.7
63.3
75.5
42.9
51.0
48.4
AbstRaL
68.6
82.7
63.8
76.5
54.8
52.3
49.4
5.3 DISCUSSION
Theoretically, why AbstRaL leads better reasoning robustness and generalizability" The abstractions studied in AbstRaL are high-level inference structures that serve as scaffolds for reason- ing, and robust generalization of LLM reasoning requires understanding of such abstractions (Chen et al., 2025a Saitta et al. 2013). which is improved by AbstRaL's learning. Abstract thinking is also an essential component of general fluid intelligence (Chollei 2019), and AbstRaL's reinforcement of abstract thinking also improves such intelligence of LLMs, which naturally contributes to better generalizability of LLM reasoning. In line with the globality degree (Abbe et al. 2024) theory, AbstRaL sets intermediate learning step (the problem abstraction) that is likely useful to reach the final step (answering the question). This may narrow down the globality degree, i.e., distribution gap between the input and the output of the reasoning task, and reduce the chance of modeling shallow reasoning patterns or shortcuts. It would be an interesting future work to establish these formally.
Whether the improvements of AbstRaL simply rely on distilling superior reasoning capabilities to perform the input
from the oracle LLM? We use an oracle L.MM allama-3.3-70B-Inss. condition recognition and GranulAR training data construction. However, AbstRal. does not necessarily rely on this strong oracle LLM, and a weaker LLM can be used as the oracle instead.
We clarify that both input condition recognition and GranulAR data construction in AbstRaL are based on re-writing the existing Socratic CoT data. The oracle LLM only serves to re-write the surface-form format of existing reasoning traces, i.e., replacing real numerical values with abstract symbols and arraragiing the decomposed sub-question answering. Therefore, the improvements of our framework are not due to distilling more superior reasoning knowledge from the oracle LLM,, but due to the AbstRal. learning scheme itself.
We have verified in our ablation study (Table w/o Tools) that replacing the oracle LLM with the reasoning LLM itself to conduct input condition recognition results in only minor performance drop. Furthermore, we have tested use a weaker LLM, 1--aaa-..-----Istteee reasoning traces and conduct AbstRaL training based that, which achieves roughly the same scores on our tested GSM perturbation and OOD datasets. These justify that it's mainly the better learning of abstract reasoning that contributes to the improvements of AbstRaL.
to re-write our GranulAR
Why LLMs, which are also trained on code and structured languages besides natural language corpora, still fall short of predicting de-contextualized abstractions? In ablation study (Table w/o Contexts), we have verified that it is still hard for LLMs to generate GSM abstractions without intermediate contexts. We assume that this is because most reasoning data samples LLM pre-training and post-training corpora are still in natural language format (e.g., CoT traces), and thus LLMs might fall short of integrating multi step reasoning capabilities within the abstract symbolic format, which may be less frequently seen in the reasoning training data samples.
RELATED WORK
Reasoning Robustness Recent advances in LLM reasoning have also spotted considerable robust- ness challenges (Yu et al. 2025), reflected by benchmarks in symbolic reasoning, such as logical
(Bao al. 2023) and mathematical (Sundaram et al. 2024 [i et al. 2024 Srivastava al. 2024

---

Published as a conference paper at ICLR 2026
Mirzadeh al. 2025) reasoning, and in factual commonsense reasoning Yang et al. 2023 Qian et al. 2024: Qiang et al. 2024). All above benchmarks consistently reveal that LLMs are eastly perturbed by test-time data distribution shifts. Inspired by improving robustness via data augmentation (Rebuffi et al., 2021b), previous works (Gan & Ng 2019, Rebufti et al., 2021a Zhou et al. 2024 Boix-Adserà et al. 2024) use various data synthesis techniques to expand the coverage of training samples, and thus anticipate potential distribution shifts, which naturally increases the computational cost of developing LLM. In this work, we aim to improve reasoning robustness of LLMs by incentivizing their abstract thinking, instead of replying on larger amount of instantiations.
Abstract Thinking and Planning Abstract thinking is an essential component of general fluid intelligence (Chollet 2019). and is also the key to human cogmition and reasoning (Saitta et al. 2013)).
requires making inferences based on abstract fundamental rules or concepts (Chen et al., 2025a),
rather than just memorizing probabilistic pattern matching (Gendron et al. 2024 Xu et al. 2025).
Recently, various reasoning (or data) formats have been proposed for L.MMs to learn abstract thinking,
such as AoT (Hong al. (2024) and CoA (Gao al. 2025) based on natural language, and PoT (Chen et al. 2022). PAL (Gao et al. 2023) and SyReLM (Dutta et al.) 2024) based on programming or formal language. On the other hand, planning is also basic human reasoning skill (Wilensky 1983), which benefits LLM reasoning. Typical planning methods, such as chain-of of-thouught (CoT) (Wei al., 2022) and socratic problem decomposition (Shridhar et al. 2023). are widely adopted in [LLMs to improve reasoning. Our work develops a better learning scheme of abstract thinking based on more commonly used natural language, and also integrates within the power of planning,
Reinforcement Learning
RL is a popular technique used in recent development of LLMs (Shao al. 2024 Guo et al. 2025). to boost reasoning capabilities. representative RL approach is PPO
(Schulman man et al. (017). typically used for learning from human feedback (RLHF) (Christiano et al.
2017/ et al. (0022) via a reward model pre-trained on human preference annotations. As
step forward, DPO (Rafailvv et al. 2023) simplifies the PPO implementation by optimizing the direct preference of policy model, which gets rid of pre-training an additional reward model. Our method adopts GRPO (Shao et al. (2024) with model-free rewards, which further cuts off the training of value model (used for advantage estimation) by using a group relative advantage.
CONCLUSION
This paper proposes a method, AbstRaL, promote abstract thinking in large language models (LLMs). AbstRaL is designed to improve GSM reasoning robustness of LLMs, based on the natural principle that abstract thinking leads to reasoning steps that are more invariant to surface-fomn variations. Our abstraction mechanism is implemented through a proper reinforcement learning (RL) framework, where model-free rewards are derived from newly designed rationales Granu- IAR that blend socratic chain-of-thought with augmented granularity. This enables both the de- contextualization of problems and the integration of symbolic tools. We evaluate AbstRal on recent GSM perturbation benchmarks and show that it effectively mitigates the performance degradation caused by instantiation and interferential shifts. Our zero-shot evaluation on OOD tasks further demonstrates AbstRaL's 's effectiveness on improving LLMs' general reasoning capabilities, which implies potential to extend our learning method broader range of domains in future work.
ACKNOWLEDGEMENTTS
Antoine Bosselut gratefully acknowledges the support of the Swiss National Science Foundation (No. 215390), Innosuisse (PFFS-21-29), the EPFL Center for Imaging, Sony Group Corporation, a Meta LLM Evaluation Research Grant, and the Swiss National Supercomputing Center (CSCS) in the form of an infrastructure engineering and development project.
REFERENCES
Emmanuel Abbe, Samy Bengio, Aryo Lotfi, Colin Sandon, and Omid Saremi. How far trans- formers reason? the globality barrier and inductive scratchpad. Advances in Neural Information Processing Systems, 37:27550-27895. 2024.
10

---

Published as a conference paper at ICLR 2026
Qiming Bao, Gael Gendron, Alex Yuxuan Peng, Wanjun Zhong, Neset Tan, Yang Chen, Michael Witbrock, and Jiamou Liu. Assessing and enhancing the robustness of large language models with task structure variations for logical reasoning. arXiv preprint arXhv:2310.094. 2023.
Enric Bdse-a, Omid Saremi, Emmanuel Abbe, Samy Bengio, Etai Littwin, and Joshua M. Susskind. When transformers reason with abstract symbols? In The Twelfth International Conference on Learning Representations, 2024.
Guanyu Chen, Peiyang Wang, Tianren Zhang, and Feng Chen. Exploring the hidden reasoning process large language models by misleading them. arXiv preprint arXiv22503.1640) 2025a.
Qiguang Chen, Libo Qin, Jinhao Liu, Dengyun Peng, Jiannan Guan, Peng Wang. Mengkang Hu, Yuhang Zhou, Te Gao, and Wanxiang Che. Towards reasoning era: A survey of long chain-of- thought for reasoning large language models. arXiv preprint arXiv:2503.0950 2025b.
Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. Program of thoughts prompt- ing: Disentangling computation from reasoning for numerical reasoning tasks. arXiv preprint arXiv:2211.12588 2022.
François Chollet. On the measure of intelligence. arXiv preprint arXiv:1911.01547,00 2019.
Paul F Christiano, Jan Leike, Tom Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. Advances in neural information processing systems, 30, 2017.
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. 2018.
arXiv preprint arXiv:1803.000
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jemry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. arXiv preprint arXiv:2110. 14168, 2021.
Subhabrata Dutta, Ishan Pandey, Joykirat Singh, Sunny Manchanda, Soumen Chakrabarti, and Tanmoy Chakraborty. Frugal Ims trained to invoke symbolic solvers achieve parameter-efficient arithmetic reasoning. In Proceedings of the AAAI conference artificial intelligence, volume 38, pp. 17951-17959, 2024.
Wee Chung Gan and Hwee Tou Ng. Improving the robustness of question answering systems to question paraphrasing. In Proceedings of the 57th annual meeting of the association for computational linguistics, pp. 6065-6075, 2019.
Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: program-aided language models. In Proceedings of the 40th International Conference on Machine Learning, pp. 10764-10799, 2023.
Silin Gao, Jane Dwivedi- Yu, Ping Yu, Xiaoqing Ellen Tan, Ramakanth Pasunuru, Olga Golovneva, Koustuv Sinha, Asli Celikyilmaz, Antoine Bosselut, and Tianlu Wang. Efficient tool use with chain- of-abstraction reasoning. In Proceedings of the 31st International Conference Computational Linguistics, pp. 2727-2743, 2025.
Gaël Gendron, Qiming Bao, Michael Witbrock, and Gillian Dobbie. Large language models not strong abstract reasoners. Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, pp. 6270-6278, 2024.
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. arXiv preprint urXiv:2407.21783 2024.
Daya Guo, Dejian Yang, Haowei Zhang. Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseck-rl: Incentivizing reasoning capability in Ilms via reinforcement learning. arXiv preprint arXiv:2501. /2224201...2...... 2025.
11

---

Published as a conference paper at ICLR 2026
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. arXiv preprint 000Y::0000.03300, 2020.
Dan Hendrycks. Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song. and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. arXiv preprint ar 033884 2021.
Ruixin Hong, Hongming Zhang, Xiaoman Pan, Dong Yu, and Changshui Zhang. Abstraction-of- thought makes language models better reasoners. arXiv preprint arXiv:2406. 12442, 2024.
Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.00685, 2021.
Rik Koncel- Kennio-kediiiski,, Subhro Roy, Aida Amini, Nate Kushman, and Hannaneh Hajishirzi. Mawps A math word problem repository. In Proceedings of the 2016 conference of the north american chapter of the association for computational linguistics: human language technologies, pp. 1152-
1157, 2016.
Komal Kumar, Tajamul Ashraf, Omkar Thawakar, Rao Muhammad Anwer, Hisham Cholakkal, Mubarak Shah, Ming-Han Hisaan Yang, Phillip HS Torr, Fahad Shahbaz Khan, and Salman Khan. Llm post-training: A deep dive into reasoning large language models. arXiv preprint arXiv2500.22321,, 2025.
Vladimir Levenshtein al. Binary codes capable of correcting deletions, insertions, and reversals. In Soviet physics doklady, volume 10, pp. 707-710. Soviet Union, 1966.
Aitor Lewkowyez, Anders Andreassen, David Dohan, Ethan Dyer, Henryk Michalewski, Vinay Ra- masesh, Ambrose Slone, Cem Anil, Imanol Schlag, Theo Gutman-Solo, et al. Solving quantitative reasoning problems with language models. Advances in neural information processing systems, 35:3843-38577 2022.
Qintong Li, Leyang Cui, Xueliang Zhao, Lingpeng Kong, and Wei Bi. Gsm-plus: A comprehensive benchmark for evaluating the robustness of Ilms as mathematical problem solvers. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). pp. 2961-2984, 2024.
Minpeng Liao, Chengxi Li, Wei Luo, Wu Jing, and Kai Fan. Mario: Math reasoning with code interpreter output-a reprodueible pipeline. In Findings of the Association for Computational Linguistics ACL 2024, pp. 9054, 2024.
Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. Program induction by rationale genera- tion: Learning to solve and explain algebraic word problems. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume I: Long Papers), pp. 158-167 167, 2017.
Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization, In International Confer- ence on Learning Representations, 2018.
Pan Lu, Liang Qiu, Wei Chang, Ying Nian Wu, Song- Zhu, Tanmay Rajpurohit, Peter Clark, and Ashwin Kalyan. Dynamic prompt learning via policy gradient for semi-structured mathematical reasoning. arXiv preprint arXiv:2209. 14610, 2022.
MAA. American invitational mathematics examination-aine 2024, 2024.
Inbal Magar and Roy Schwartz. Data contamination: From memorization to exploitation. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers). pp. 157-165, 2022.
Shen- Yun Miao, Chao-Chrn Liang, and Keh- Yih Su. A diverse corpus for evaluating and developing english math word problem solvers. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 975-984, 2020.
12

---

Published as a conference paper at ICLR 2026
Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can suit of armor conduct electricity? a new dataset for open book question answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 2018
Seyed Iman Mirzadeh, Keivan Alizadeh, Hooman Shahrokhi, Oncel Tuzel, Samy Bengio, and Mchrdad Farajtabar. GSM-symbolic: Understanding the limitations mathematical reasoning in large language models. In The Thirteenth International Conference Learning Representations, 2025.
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.
Arkil Patel, Satwik Bhattamishra, and Navin Goyal. Are nip models really able solve simple math word problems? In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguisties: Human Language Technologies, pp. 2080-2094, 2021.
Kun Qian, Shunji Wan, Claudia Tang, Youzhi Wang, Xuanming Zhang, Maximillian Chen, and Zhou
Yu. Varbench: Robust language model benchmarking through dynamic variable perturbation. In Findings of the Association for Computational Linguistics: EMNLP 2024, pp. 16131-16161, 2024.
Yao Qiang, Subhrangshu Nandi, Ninareh Mehrabi, Greg Ver Steeg, Anoop Kumar, Anna Rumshisky, and Aram Galstyan. Prompt perturbation consistency learning for robust language models. In Findings of the Association for Computational Linguistics: EACL 2024, pp. 1357-1370, 2024.
Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D) Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. Advances 2023.
in Neural Information Processing Systems,
Sylvestre-Alvise Rebuffi, Sven Gowal, Dan A Calian, Florian Stimberg, Olivia Wiles, and Tim- othy Mann. Fixing data augmentation improve adversarial robustness. arXiv preprint arXiv:2103.01946, 2021a.
Sylvestre-Alvee Alvise Rebuffi, Sven Gowal, Dan Andrei Calian, Florian Stimberg, Olivia Wiles, and Timothy A Mann. Data augmentation can improve robustness. Advances neural information processing systems, 34:29935 29948, 2021b.
Lorenza Saitta, Jean-Danicl Zucker, Lorenza Saitta, and Jean-Danicl Zucker. Abstraction in Artificial Intelligence. Springer, 2013.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint 177.027777 2017.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint 24Xi::2402.03000 2024.
Kumar Shridhar, Alessandro Stolfo, and Mrinmaya Sachan. Distilling reasoning capabilities into smaller language models. In Findings of the Association for Computational Linguistics: ACI. 2023, pp. 7059-7073, 2023.
Saurabh Srivastava, Anto PV, Shashank Menon, Ajay Sukumar, Alan Philipose, Stevin Prince, Sooraj Thomas, et al. Functional benchmarks for robust evaluation of reasoning performance, and the reasoning gap. arXiv preprint arXiv:2402. /9450, 2024.
Sowmya S Sundaram, Sairam Gurajada, Deepak Padmanabhan, Savitha Sam Abraham, and Marco Fisichella. Does language model "understand" high school math? survey of deep learning based word problem solvers. Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 14(4):e154, 2024.
13

---

Published as a conference paper at ICLR 2026
Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc Le, Ed Chi, Denny Zhou, et al. Challenging big- bug-benc tasks and whether chain-of-thouge can solve them. In Findings of the Association for Computational Linguistics: ACI. 2023, pp. 13003-13051, 2023.
Zhengyang Tang, Xingxing Zhang, Benyou Wang, and Furu Wei. Mathscale: Scaling instruction tuning for mathematical reasoning. In International Conference on Machine Learning, pp. 47885- 47900. PMLR, 2024.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe V Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2022.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thouggh prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-24837, 2022.
Robert Wilensky. Planning and understanding: A computational approach to human reasoning. 1983.
Cheng Xu, Shuhao Guan, Derek Greene, M Kechadi, et al. Benchmark data contamination of large language models: survey. arXiv preprint arXiv:2406.04244 2024.
Fangzhi Xu, Qika Lin, Jiawei Han, Tianzhe Zhao, Jun Liu, and Erik Cambria. Are large language models really good logical reasoners? a comprehensive evaluation and beyond. IEEE Transactions on Knowledge and Data Engineering. 2025.
Kuan-Man Xu. Using the bootstrap method for statistical significance test of differences between summary histograms. Monthly weather review, 134(5):1442-145) 2006.
An Yang, Baosong Yang. Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. Qwen2.5 technical report. arXiv preprint arXiv:2412.15115, 2024a.
An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jian- hong Tu, Jingren Zhou, Junyang Lin, et al. Qwen2.5-math technical report: Toward mathematical expert model via self-improvemenn. arXiv preprint arXiv:2409. 12122, 2024b.
Shuo Yang, Wei Chiang, Lianmin Zheng, Joseph Gonzalez, and Ion Stoica. Rethinking benchmark and contamination for language models with rephrased samples. arXiv preprint arXiv:2311.0m 048550 2023.
Sohee Yang, Elena Gribovskaya, Nora Kassner, Mor Geva, and Sebastian Riedel. Do large language models latently perform multi-hop reasoning? In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 10210-10229, 2024c.
Fei Yu, Hongbo Zhang, Prayag Tiwari, and Benyou Wang. Natural language reasoning, a survey,
ACM Computing Surveys, 56(12):1-39, 2024.
Tong Yu, Yongcheng Jing, Xikun Zhang, Wentao Jiang, Wenjie Wu, Yingjie Wang, Wenbin Hu,
Bo Du, and Dacheng Tao. Benchmarking reasoning robustness in large language models. arXiv preprint arXiv:2503. 0455000 2025.
Tianyang Zhong, Zhengliang Liu, Yi Pan, Yutong Zhang, Yifan Zhou, Shizhe Liang, Zihao Wu, Yanjun Lyu, Peng Shu, Xiaowei Yu, et al. Evaluation of openai ol: Opportunities and challenges of agi. arXiv preprint arXiv:2409. 18486, 2024a.
Wanjun Zhong, Ruixiang Cui, Yiduo Guo, Yaobo Liang, Shuai Lu, Yanlin Wang, Amin Saied, Weizhu Chen, and Nan Duan. Agieval: A human-centric benchmark for evaluating foundation models. In Findings of the Association for Computational Linguistics: NAACL 2024, pp. 2299-2314, 2024b.
Yue Zhou, Yada Zhu, Diego Antognini, Yoon Kim, and Yang Zhang. Paraphrase and solve: Exploring and exploiting the impact of surface form on mathematical reasoning in large language models. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pp. 2793- 2804, 2024.
14

---

Published as a conference paper at ICLR 2026
A GRPO WITH ABSTRACTION REWARDS
Our proposed AbstRal. framework adopts GRPO (Shao et al. 2024) as the RL. algorithm to train LLMs (on top of supervised fine-tuning) the task of abstract reasoning, i.e., generating the abstract answer yd based on the input abstract question XA
For each imput question X'A,, GRPO samples a group of output answers {)1 V/ current (old policy) model To and optimizes the (policy) model To by maximizing the objective:
2E from the
(M (DA))=))))))))))))))))) R4, clip
na (2( Thas (/A xa)
G
Li=1
min
no
e, e, R: (R.. (Toll
(2)
where and 3 are hyperparameters. We set the reference policy Fre/ as the model trained with only supervised fine-tuning (SFT), which is used for calculating the KL divergence regularization:
DEL (TollTref) = Tioe () ()11)
log
-1
R2 is the group relative advantage granted to the abstraction A, retrieved from each sampled output
answer V.A,, which applies a group normalization on our proposed abstraction rewards Tanower and Y Vsymmatii defined in $3.2 with reference to the input conditions C and gold answer Ans, and to the gold abstraction A retrieved from the gold response VAA respectively:
R4 T--mean( (f rra)) std((f1/f2:" (ta))
Tanswer (Ai, C, Ans) + Tsymbolic (Ai,
(4)
B IMPLEMENTATION DETAILS OF ABSTRAL
Condition Recognition We create few-shot examples to prompt a -lama-3.3-70B-IIstrue Grattafiori et al.] 2024) model to accomplish the first condition recognition step of AbstRaL. Table IO presents the instruction and few-shot examples used the task demonstration in prompting. The LLM is tasked to label the numerical values in the input question X' with square brackets "[]", and then sequentially replace each labeled value with abstract symbol indexing as "in0", "inl", etc., to create the abstract question X'A, Note that for implicit numerical values such as "one hundred" and "twice", we also prompt the LLM convert them into explicit format "100" and "2 times", so that the numbers can be labeled and replaced. Meanwhile, the LLM is asked to use equations to record the replacements, e.g., "in0 2", order create the conditions C. 4 NVIDIA A100-SXM4 (80GB) GPUs were used for rumning the condition recognition step based on Llama-3.3-70B 1--70-Innsttutt which took about hours to process all training and testing data samples.
Abstract Reasoning We tune various LLMs on our constructed GranulAR data ($3.1) with our SFT and RL scheme (33.2), to perform the core abstract reasoning step. Our tested LLMs include Llama3 model series (Grattafiori et al. 2024) (Llama-3.22 1 IIntrruct, Instructc,, Qwen2.5 model series (Yang et al. 2024a) Divee22.5-0.5-IInstii Owen2.5-1.5BB-Insiie Qwen2.5-3B-Instruee Owen2.5-7BB-nsstee
and its math specialized version 1aann-5-MMah-77--Instte and Mathstral-7EB All LLMS are supposed to follow our GranulAR training data to index the derived output variables in their generations "outO", "outl", etc., and highlight each abstract math derivation in double angle brackets such as "(finO in = outo))". LLMs also supposed to generate fixed statement "TTh final answer is [outN].", to clarify the output variable that represents the final answer. At inference phase, LLMs use greedy decoding to generate their abstract answers.
For SFT, we set the batch size as 8, using 4 NVIDIA A100-SXM4 (80GB) GPUs (i.e., batch size on each GPU), and set the learning rate as -6 using AdamW Loshchilov Hutter (2018) optimizer with 31 = 0.9, 32 = 0.999 and = le 1e-8 8__ Áll LLMs were trained with SFT for 2 epochs on our GranulAR data, which took less than hour.
For RI., we set the positive (correct) reward Foorrest 2.5 in our answer correctness reward
Tanswer (A, C, Ans), and the maximum reward Tmaz 1.5 in symbolic distance reward
https::/huggiiggfacee
15

---

Published as a conference paper at ICLR 2026
T Tsymbolic (A:: A). The hyperparameters of GRPO algorithm set to 3 = 0.04 (KL coefficient) and é 0.2 (for clipping), with number of generations (i.e.. {) .'d.....'))))) sampled per group (i.e. per given X-1) set as G = 16, and with the temperature, top, and top, of the sampling set as 0.9, 1.0 and 50, respectively. The learning rate of our RL optimization is set to 5e-7, using also AdamW optimizer with 81 0.9, B2 0.99 and e = le- A cosine learning rate scheduler is employed with warm-up ratio set to 0.1, and the training weight decay and gradient norm clip value are also both set to 0.1. We use 8 NVIDIA A100 SXM4 (80GB) GPUs to train each LLM with RL. For 7B and 8B LLMs, the batch size of generation is set to 2 per GPU, with gradient accumulation steps set as 4, i.e., the policy gradient update is performed when every 4 groups of G = 16 generations (2 batch size multiply 8 GPUs) are sampled. For other smaller LLMs,, the batch size of generation is set to 8 per GPU instead, with gradient accumulation step set as 1, where still groups of G 16 generations (8 batch size multiply 8 GPUs) are sampled per policy gradient update. All LLMs were trained with RL for 8 epochs on our GranulAR data, which took about 3 to 5 days.
Abstraction Retrieval and Symbolic Derivation We simply use regex-matching script to extract all math derivations that are enclosed in double angle brackets in the model generated answer ) (or A in our GranulAR data construction). All extracted math derivations form the problem abstraction A (or A). During the tokenization of the abstraction (used for calculating the symbolic distance reward in our RL approach), the tokenized lists of derivations are concatenated with a special token "(space)", as shown in Figure We treat the output math derivations in A (or A) and the input conditions in jointly as a system of equations, which is fed into a SymPy 6 equation solver to derive the final answer.
GranulAR Training Data Construction Based on the abstract question X and the gold socratic CoT response Y to the question, we prompt Llama-3.3- 3.3-m--
to rewrite y into our granularly- decomposed abstract reasoning (GranulAR) format y-A, which is used as the training data for LLMs to learn the abstract reasoning step in AbstRaL. To facilitate the rewriting, we employ two-step pipeline. First, the Llama model is prompted to replace the numerical values in y with abstract symbols, by either quoting the abstract symbols in X'A for input values or creating new abstract symbols for derived output values. All derivations in the response are supposed to be enclosed in double angle brackets "(())" Second, based on the rewritten response in the first step, the Llama model is prompted to further rewrite the response (in socratic CoT format) into our GranulAR format, while keep all the abstract symbols in the response unchanged. Table [ and 12 present the instruction and few-shot examples used for prompting our two-step GranulAR training data construction. For each step of rewriting, 4 NVIDIA A100- (80GB) GPUs were used to run the Llama model. About 36 and 48 hours are spent to conduct the first and the second rewriting steps, respectively, on all training data samples.
After each step of response rewriting, we filter the output of Llama model by verifying the correctness of its derivations, i.e., we regex-matching to extract all derivations enclosed in "(O)", and pass them (along with the input conditions C generated in the condition recognition step) into the SymPy solver, to derive the final answer (number), checking whether it matches the gold answer. We apply our two-step rewriting to the socratic version of GSM8K Cobbe et al. (202T) training set from OpenAl" After the first step of rewriting and filtering, 6503 out of 7473 training samples are correctly rewritten and kept, while after the second step of rewriting and filtering, 6386 out of 6503 training samples are correctly rewritten and reserved as our final training data.
C DETAILS OF BASELINE METHODS
CoT-88 prompts LLMs with the demonstration template suggested by GSM-Symbolic (Mirzadeh et al., 2025) and the common 8-shot example used for GSM8K evaluation, to generate CoT answer to the input question. The last number (after "The final answer is") is extracted as the final answer.
htttp::///ithubbccm takks/gsmax//mmmk-ooo
wttp:///.......eeeeeeeeeeeeeeaee eva uat on ha h
16

---

Published as a conference paper at ICLR 2026
PoT-SS (Chen et al. 2022) conducts GSM reasoning via Python programming. It prompts LLMs with 8-shot examples to generate program- program-based based solution to the input problem, which is then executed by Python interpreter to derive the final answer.
CoT-RL tunes LLMs on the non-rewritten GSM8K training data (x.3) (socratic CoT version P with 7473 samples), using the same SFT and RL algorithm (GRPO) does not generate abstractions in the reasoning chains, only our answer correctness reward Y Tonswer ($3.2) is used as the learning signal in RL, which checks whether the final answer (last number) extracted from the generated CoT matches the gold answer. In particular, T Tanswer hyperparameter) answers match, otherwise Tanswer 0.
approach. Since CoT-RRL
Teorrect (positive
CoA (Gao et al. 2025) is another abstract reasoning method that fine-tunes LLMs to generate abstract reasoning chains. However, different from AbstRaL, only the output numbers in CoA reasoning chains are represented by abstract symbols, without abstracting the input conditions (A'A and C) and using our granularly decomposed reasoning schema (GranulAR). The learning of CoA is based on only SFT, without integrating proper RL.
AoT (Hong et al., 2024) augments CoT data by adding abstract step descriptions before each step of the reasoning chains, and fine-tunes LLMs on the augmented data. Similar to the baseline method CoA, AoT trains L.LMs via plain SFT, without RI. that augments the faithfulness of abstract reasoning.
SyReLM (Dutta et al. 2024) similarly uses RL and symbolic rewards to augment the learning of abstract reasoning. However, different from AbstRaL, formulates abstractions in programming or formal languages, which may hinder LLMs from integrating abstract reasoning with their pre-learned reasoning strategies (mostly in natural language) during pre-training or post-training
D FULL EXPERIMENTAL RESULTS
Table 5 and present the evaluation results of all our tested LLMs on GSM-Symbolic and GSM- Plus datasets, respectively. Results on all LLMS consistently demonstrate that AbstRal. effetalleffeecivvey improves GSM reasoning robustness when generalizing to both instantiation and interferential shifts. On each tested LLM, we also conduct the bootstrap statistical significant test Xu| (2006) between the best and second-best results, and highlight the best results (with *) if they are significantly better than their corresponding second-best results with significant test p- p-value < 0.05.
E QUALITATIVE ANALYSIS
Table 7 and 8 present two mathematical reasoning examples (respectively GSM-Symbolic and GSM-Plus datasets) of our tested strongest. L.M Qwven2.5-Mtth-7B-nnnttru using either baseline CoT-8S method or our AbstRal.. The LLM with AbstRal. performs more stable math derivations when facing the variations relevant conditions 7), and achieves more robust reasoning chains when dealing with the inserted distracting condition (Table 8). We include more detailed analysis in the corresponding table captions.
Error Analysis AbstRaL teaches LLMs to analyze and decompose reasoning problems at the start of inference, which requires LLMs to perform more holistic problem understanding and solution planning, compared to CoT. This however may lead slightly overthinking and thus misunderstand- ing of a few reasoning problems. We have manually checked the GSM8K testing questions where Swen2.5-Math-771 Ma-tt-7B-Insttrett answered correctly with 8-shot CoT prompting (CoT-8S) but wrongly using AbstRaL (totally 35 such questions), and verified that AbstRaL's failure on all these questions due to minor misunderstanding. Table presents an example where -eren2.5-Mat-77B-Inntit (AbstRaL) misunderstood "go up to" as "go up by", and therefore did redundant reasoning step.
F THEORETICAL OPEN PROBLEMS
It would be interesting find theoretical setting to study the impact of abstraction the sample/time complexity of learning, the OOD robustness and the model size requirements for learning. For
We also did pilot study of training M. with non-socratic CoT data, which achieves similar results.
17

---

Published as a conference paper at ICLR 2026
Table 5: More evaluation results GSM-Symbolic. A denotes the relative percentage of drop comparing performance on Vary Both to performance on Origin 100. Best results on each model are bold, where lower is better for A. Standard deviation (std) of multi-round evaluation results are in brackets, where lowest std values on each model are underlined. The best (bold) results with are significantly better than their corresponding second-best results, with significant test p-value < 0.05.
Model
Method
Vary Num.
Vary Name
Vary Both
Origin 100
A (%)
CoT-8S
0.3864 (0.030)
0.4250 (0.026)
0.3890 (0.038)
0.4800
18.96
CoT-RI
0.4788 (0.031)
0.5342 (0.024)
0.4488 (0.038)
0.5700
21.26
Llama-3.22 1.2
CoA
0.4534 (0.020)
0.4372 (0.026)
0.4242 (0.030)
0,4600
7.78
AbstRaL.
0.5912" (0.016)
0,5838' (0.023)
0.5804 (0.027)
0.6000
3.27
CoT-8S
0.7218 (0.027)
0.7638 (0.027)
0.7114 (0.031)
0
15.31
CoT-RL
0,7056 (0.027)
0,7516 (0.023)
0.6898 (0.026)
0,8000
13.78
Bama-3.2-3B-Instmme
CoA
0.6450 (0.019)
0.6802 (0.021)
0.6760 (0.026)
0.6800
0.59
AbstRaL.
0.7960 (0.014)
0.7982 (0.020)
0.7946 (0.023)
0.8000
0.68
CoT-8S
0.8440 (0.026)
0.8746 (0.021)
0.8236 (0.032)
0,8700
5,33
Ll 1-mma3..--B-Instruuu
CoT-RL
0.7784 (0.029)
0.8710 (0.014)
0.7540 (0.026)
0.8300
9.16
CoA
0.7240 (0.019)
0.7086 (0.019)
0.6944 (0.025)
0.7200
3.56
AbstRaL
0.8686 (0.013)
0.8672 (0.018)
0.8620 (0.023)
0.8700
0,92
CoT-8S
0.3394 (0.039)
0.3724 (0.024)
0.3398 (0.033)
0,3800
10.58
Qwen2.5-0.5B-Bh
CoT-RL
0.3192 (0.025)
0.3948 (0.032)
0.3228 (0.032)
0,3500
7.77
CoA
0,2866 (0.025)
0.3060 (0.026)
0,2872 (0.026)
0,2900
0.97
AbstRaL
0.4396 (0.015)
0.4416' (0.026)
0.4456 (0.025)
0.4400
-1.27
CoT-8S
0,5728 (0.032)
0.6416 (0.030)
0.5752 (0.033)
0.6600
12.85
CoT-RI.
0.5296 (0.037)
0.5830 (0.034)
0,5126 (0.034)
0.5600
8.46
Owen225-115B-Insttee
CoA
0.4680 (0.027)
0.4942 (0.029)
0,4656 (0.027)
0.5100
8,71
AbstRaL.
0.6444 (0.018)
0.6414 (0.028)
0.6416 (0.025)
0.6500
1.29
CoT-8S
0.7222 (0.037)
0.7820 (0.025)
0.7256 (0.027)
0.8200
11.51
CoT-RL
0,7150 (0.036)
0.7706 (0.025)
0.6888 (0.038)
0,7900
12.81
Owen2.5-3B-Instmun
CoA
0.6424 (0.030)
0.6134 (0.030)
0.6234 (0.034)
0.6500
4.09
AbstRal.
0.7842 (0.014)
0.7852 (0.024)
0.7834 (0.024)
0.7900
0.84
CoT-8S
0,8726 (0.026)
0,9230 (0.016)
0,8740 (0.023)
0.9200
5,00
Qwen2.5-7B. Bwven.557B-IInsruuee
CoT-RL
0,7770 (0.033)
0.8170 (0.024)
0.7928 (0.034)
0,8500
6.73
CoA
0.7310 (0.023)
0.7408 (0.027)
0.7414 (0.029)
0.7600
2.45
AbstRaL
0,9022 (0.014)
0,9248 (0.017)
0.8834 (0.019)
0.8900
0.74
CoT-8S
0.8956 (0.021)
0.9108 (0.018)
0.8766 (0.023)
0.9500
7.73
CoT-RL
0.8942 (0.022)
0.9154 (0.012)
0.8812 (0.021)
0.9600
8.21
Qwen2.5-Math-77 Mi--MMtth-BB--stee Instructt
CoA
0.7122 (0.028)
0.6976 (0.031)
0.6970 (0.033)
0.7100
1.83
AbstRaL
0.9066 (0.015)
0,9014 (0.013)
0,9022 (0.016)
0.9100
0.86
CoT-8S
0.7876 (0.024)
0,8084 (0.018)
0.7604 (0.031)
0.8000
4,95
CoT-RI.
0,8082 (0.018)
0.7986 (0.021)
0.7688 (0.025)
0,7800
1.44
Mathstral-7B-vd.
CoA
0.7506 (0.031)
0.7740 (0.028)
0.7402 (0.027)
0.7500
1.31
AbstRal.
0.8100 (0.012)
0,8214 (0.017)
0.8228 (0.019)
0.8100
-1.58
instance, formalizing data distributions of triplets (A, X, Y). where X + Y represents a target of reasoning problem X with solution Y, and A an abstraction of X that removes context (with the same solution Y). One has to define properly the notion of abstraction, distinguishing potentially de- contextuullization from reasoning resolution (c.g.. AA should not be Y). Is there an appropriate framework (including a learning model class) under which statements of the following kind could be made rigorous: (i) the sample complexity of learning A - Y is lower than X + Y (a consequence of defining abstraction and instantiation processes formally and appropriately)? (ii) learning X + Y by relying on a proper abstraction A leads improved robustness to properly modeled instantiation shifts? (iii) learning via abstraction can be achieved with models of smaller sizes?
G LIMITATIONS
We acknowledge few limitations in our work. First, the datasets used for testing our method's improvement on reasoning robustness cannot have exhaustive coverage of all worl-world scenarios. We instead consider the most representative domain, i.e., grade school mathematics, which is common and typical domain for studying reasoning robustness Li et al. (2024); Qian et al. (2024); Mirzadeh et al. (0255), and use English primary language in testing. For future work, the
18

---

Published as a conference paper at ICLR 2026
Table 6: More evaluation results GSM-Plus. Best results each model bold. The best (bold)
results with are significantly better than their corresponding second-best results, with significant test p-value 0.05. Model
Method
Digit Ex.
Int-Dec-Fra
Num. Sub,
Rephrase
Distract
Original
CoT-8S
0.3889
0.2934
0.4321
0.5042
0.2790
0.4519
CoT-RL
0.4064
0,3063
0,4572
0.5299
0.2646
0.5125
Llama-3.2-11 3.0---3.-----ttteee
CoA
0.3798
0.3237
0.3889
0.4139
0.2032
0.4261
AbstRaL
0.5641
0.5626
0,5641
0.5633'
0.4359
0.5641
CoT-8S
0.7142
0.6277
0.7172
0.7877
0.6073
0.7953
CoT-RL
0,6808
0.5406
0,7043
0.7718
0.5398
0.7763
JJama-3.2-3B-Instie
CoA
0.6224
0.5444
0.6126
0.6793
0,4177
0.6626
AbstRaL
0.7968
0.7945
0.7968
0.7923
0.6755
0.7968
CoT-8S
0.7938
0.7445
0.7854
0.8461
0.7400
0,8567
CoT-RL
0.7240
0,5914
0.7187
0,8309
0,5466
0.8234
CoA
0.7202
0,6398
0.7035
0.7657
0,5344
0.7497
AbstRaL
0.8506
0.8476'
0.8506
0.8514
0,7854
0.8506
CoT-&S
0.3601
0,2866
0.3958
0.4359
0.2267
0.4238
CoT-RL
0.3336
0.2373
0,3571
0,4079
0.1524
0.3798
Qwen2.5-005B-mm Inntrructt
CoA
0.2745
0.2267
0,2782
0.3161
1266
0.3033
AbstRaL
0,4670
0.4663"
0.4670
0.4625
0,3654
0.4670
CoT-8S
0.6096
0.5421
0.6194
0.6793
0.4488
0.6702
CoT-RL
0.5527
0.4632
0,5754
0.6520
0.3950
0.6202
Qwen2.5-1.5B ----stts--
CoA
0.4602
0.3700
0,4511
0.5186
0.2631
0.5019
AbstRaL
0.6778
0.6763*
0.6778
0.6755
0,5777
0.6778
CoT-8S
0.7726
0.7074
0.7430
0.8218
0.6346
0.8120
CoT-RI.
0.7149
0.6353
0.7331
0.7817
0.5277
0.7726
Dwee2.55-B-Innsteee
CoA
0.6232
0.5497
0.5989
0.6679
0.4200
0,6702
AbstRaL
0.8158
0.8128*
0.8158
0.8249
0.7036
0,8158
CoT-8S
0.8400
0.8067
0.8324
0.8779
0.7938
0,8901
CoT-RL
0.7582
0.6854
0.7369
0.8097
0.6331
0.8036
Qwen2.5-7B-Inee
CoA
0.7195
0.6528
0.6755
0.7657
0,5588
0.7597
AbstRal.
0,8825
0.8795
0.8825
0.8870
0.7953
0.8825
CoT-8S
0.8552
0,8218
0.8453
0,9052
0.7627
0.9181
CoT-RL
0.8757
0,8522
0,8506
0,9037
0.8150
0,9340
Qwen2.5-Math-77 Ba-ahhh-B-Insteenn -nstructtt
CoA
0.7460
0.6907
0.7180
0.7642
0.5709
0,7809
AbsiRaL
0.8916
0.8886
0.8916
0,8992
0.8226
0,8916
CoT-8S
0.7544
0.6892
0.7604
0.8029
0.6808
0.8074
CoT-RL.
0.7665
0.7111
0.7331
0.8089
0.5542
0.7953
Mathstral-7B-v..
CoA
0.7149
0.6422
0.6831
0.7483
0.5246
0.7619
AhstRal.
0.8241
0.8211
0.8241
0.8247
0.7657
0.8241
robustness testhed of our method can be extended to more domains such as high-school competition mathematics Hendrycks et al. (202T); Srrvastava et al. (2024) and commonsense (or factual) reasoning Yang et al. (2023) : Qian et al. (2024); Qiang et al. (2024), and to more languages. Second, our test of reasoning robustness is scoped to instantiation and interferential shifts, based on the assumption that the tested perturbations do not modify the underlying abstraction, i.e., the abstract math derivations. the abstraction, such altering "A is M years old, B is N years older than A, how old is B?" (M+N) to "A is M years old, B is N years younger than A, how old is B? (M-N), to test the robustness of generalization to similar reasoning strategies. Furthermore, our method is tested on the setting of tuning the full LLMs, which requires considerable computing resources. More efficient model training schemes, such LoRA Hu al. (2021), can be applied in future work. Lastly, all LLMs in our experiments use greedy decoding to generate inferences, which leaves room for future work to test our method on more advanced decoding strategies, such as self ceff-consistency (Wang et al. (002) decoding.
Future work can extend
study perturbations
19

---

Published as a conference paper at ICLR 2026
Table 7: Mathematical reasoning examples on GSM-Symbolic dataset. Responses are generated by Bwven..-Math-7B--DB
with either CoT-8S or AbstRaL methods. Input queries include an original question (from Origin 100) and its corresponding variation (from Vary Both) with names (or entities) and numbers changed to other values, illustrated by the orange words. For the Origin 100 question, both CoT-8S and AbstRal. achieve correct math derivations and answers, which are colored in blue and brown, respectively. However, when transferring to the Vary Both question, CoT-8S turns to conduct a wrong calculation on the altered numbers (7 x 39), and thus derives a wrong answer, as shown by the red numbers. By contrast, AbstRaL keeps correct math derivations, due to using abstract symbols (with a symbolic solver) that are invariant to changes of input numbers.
GSM-Symbolic (Origin 100): Jaime places eggs some trays. Fach tray can hold 24 eggs. If he has 64 eggs and 2 trays, how many eggs won't he be able to place the tray?
Gold Response: Jaime will be able place total of 24 48 eggs. Therefore, there are 64 - 48 16 eggs that he won't Ion't he able place on the tray. The answer is 16.
Response with CoT--8S: Let's think step by step. Each tray can hold 24 eggs, and Jaime has trays, so the total capacity of the trays is 24x2=48 eggs. Jaime has 64 eggs, but only 48 can fit on the trays. Therefore, the number of eggs that won't be able to be placed on the tray is 64.48=16. The final answer is 16.
Response with AbstRaL:
(Abstract Question) Jaime places eggs the tray. Each tray can hold [in0] eggs. If he has [inl]] eggs and [in2] trays, how many eggs won't he be able to place the tray? (Conditions) in0=24 in1=64
in2=2
(Abstract Answer) Let's think about the sub-questions we need to answer.
Q1: How many eggs can Jaime place the trays?
Q2: How many eggs won't Jaime be able place the tray? Let's answer each sub-question one by one.
QI: How many eggs can Jaime place the trays? Each tray can hold [in0] eggs. Jaime has [in2] trays.
So, the total number of eggs that can he placed on the trays is << in0*in2=out) >> eggs.
Q2: How many eggs won't Jaime able to place on the tray? Jaime has [inl] eggs. The total numher of eggs that can placed on the trays [out(] eggs. So, the number eggs that won't be able placed the tray << -outOOoot >> eggs. The final answer is outl. (Abstraction) in0*in2=outO inl-out0=out]
(Derived Final Answer) out0=48
outl=16
GSM-Symbolic (Vary Both); Arash places crackers on some trays. Each tray can hold 39 crackers. If he has 302 crackers and 7 trays, how many crackers won't 't he be able to place on the tray?
Gold Response: Arash will be able to place total of 39 x 7 273 crackers. Therefore, there are 302 - 273 = 29 crackers that he won't von'tba be able to place on the tray. The answer is 29.
Response with CoT-8S: First, we need to determine how many crackers Arash can place on the 7 trays. Since each tray can hold 39 crackers, the total number of crackers that can be placed on 7 trays is (7 39). Calculating (7 x 39); [7 x 39 7 x (40- 1) = 7 x 40 7 x 280 7 = 280].
So, Arash can place 280 crackers on the 7 trays. He has 302 crackers in total. To find out how many crackers he won't It be able to place, we subtract the number of crackers he can place from the total number of crackers: [302- 280- = 22). The final answer is 22. Arash won't 't be able to place 22 crackers on the trays.
Response with AbstRaL:
(Abstract Question) Arush places crackers some trays. Each tray can hold [in0] crackers. If he has [inI] crackers and [in2] trays, how many crackers won't he be able to place on the tray? (Conditions) in0=39 in1=302 in2=7
(Abstract Answer) Let's think about the sub-questions we need to answer.
Q1: How many crackers can Arash place on the trays?
Q2: How many crackers won't Arash be able to place the tray? Let's answer each sub-question one by one.
Q1: How many crackers can Arash place on the trays? Each tray can hold [in0] crackers. Arash has [in2] trays.
So, the total number of crackers that can be placed on the trays is << in0 in0=nn== >>> crackers.
Q2: How many crackers won't Arash be able to place the tray? Arash has [in crackers. The total numher of crackers that can be placed on the trays is JoutÚ]. So, the number of crackers that won't 't be able to be placed on the tray is << in -out0=outl >> crackers. The final answer is out (Abstraction) in0*in2=outO inl-out0=out] (Derived Final Answer) out0=273 out1=29
20

---

Published as a conference paper at ICLR 2026
Table 8: Mathematical reasoning examples on GSM-Plus dataset. Responses are generated by Qwen2.5-Math-7B- Maath--B-Inntructt with either CoT-8S or AbstRaL. methods. Input queries include an original question (from Original) and its corresponding variation (from Distract) where distracting condition is inserted into the question, as illustrated by the violet sentence. For the Original question, both CoT-8S and AbstRaL achieve correct math derivations and answers, which are colored in blue and brown, respectively. However, when transferring to the Distract question, CoT-8S turns to adopt an incorrect reasoning chain, where the distracting condition is wrongly incorporated into the answer derivation, as shown by the red sentences. By contrast, AbstRaL. handles the distracting condition in additional sub-question (Q2), whose math derivation (colored in gray) does not interfere the derivations of the correct answer (colored in brown). This illustrates that the holistic planning of problem solving, which is used in our GranulAR training data format, can effectively mitigate the interference of distractors, and thus increase reasoning robustness to adversarial distribution shifts.
GSM-Plus (Original): In race with 240 Asians, 80 were Japanese, and the rest were Chinese. the number of brys on the Chinese
lean was 60, how muny girls were the Chinese lecam?
Gold Response: If there were 80 Japanese, the number of Chinese was 240-80=160. Since there were 60 boys the Chinese team, there were 160-60 100 girls in the Chinese team. The answer is 100.
Response with CoT-8S: Let's think step by step. First, we need to determine the number of Chinese participants in the race, We know there are 240 Asions total and 80 them Japanese. Therefore, the number of Chinese participants (240-80=160) Next, know that out of these 160 Chinese particppntts, 60 are boys. To find the number of girls, we subtract the number of boys from the total number of Chinese participants: [I [160-60=100) (00)000000..000000 So, the number of girls on the Chinese is 100. The final answer 100.
Response with AbstRaL:
(Abstract Question) In race with [i0]] Asians, [ini] were Japanese, and the rest were Chinese. If the number of boys on the Chinese leam was [in2], how many girls were on the Chinese tearn?
(Conditions) in0=240 in 180
in2=60
(Abstract Answer) Let's
about sub questions we need answer. QL: How many Chinese were there? Q2: How many girls were on the Chinese team? Ltts 's's answer each sub sub-question one hy one.
Q1: How many Chinese were there? The total number of Asians in the race is [in0]. There were [inl] Japanese among them. So, the numher of Chinese was << in0-in mouth) >>.
Q2: How many girls were on the Chinese team? The total number Chinese in race is [oun0]. The number of boys on the Chinese
team was [in2]. So, the number of girls on the Chinese team was <KK outO-in nut0-in22ouut] >>. The final answer is outl. (Abstraction) inO-inl mout) out0-in2=ooul
(Derived Final Answer)
out0=160 out1=100
GSM-Plas (Distract): In race with 240 Asians, 80 Japanese, and the were Chinese. Among the Japanese, there are 30 girls and 50 bays. the number of hoys on the Chinese team was 60, how many girls were an the Chinese team?
Gold Response: If there were 80 Japanese, the number of Chinese was 240-80=160. Since there were 60 boys in the Chinese team, there were 160-60- 100 girls in the Chinese team. The answer 100.
Response with CoT-8S: Let's break this down step by step. 1. Total number of Asians in the race**; 240. 2. Number of Japanese in the race 80. 3 Number of Chinese in the race* * (240-80=160) NNmbbr of boys among the Japanese"*; 50, 5, N.ubbrr the Chinese team** 60. 7 Number girls the Chinese team
girls among the Jspanese**; 30. s* Number of boys Since the total number of Chinese participants is 160, and we know the number of boys (66) and girls (30) among the Japanese, we can find the number girls the Chinese team by subtracting the number boys and girls among Japanese from the number of Chinese. First, calculate the total number of girls among the Japanese: [30 (girls among Japanese) 0 (girls among Chinese, information yet) = 30). Now, calculate
since we don't 'I have among Japanese) + 60 (boys among Chinese) = 110). Subtract the number of boys and girls among the Japanese from the lotal numher final answer 50.
total number boys among the Japanese and Chinese 150 (boys
Chinese: [160-] 10=500. Therefore, the number girls on the Chinese team
Response with AbstRal.:
(Abstract Question) In race with [in0] Asians, [ini] were Japanese, and the rest were Chinese, Among the Japanese, there are [in2] girls and [in3] boys. the number boys on the Chinese team was [in4], how many girls were on the Chinese team?
(Conditions) in0=240 in]=80 in2=30 in3=50 in4=60
(Abstract Answer) Let's think about sub-questions we need answer QI: How many Chinese were there? Q2: How many boys
were there among the Chinese? Q3: How many girls were there among the Chinese? Let's answer each sub-question one by onc.
Q1: How many Chinese were there? There were lin0) Asians in total. lial| of them were Japanese.
So, the number of Chinese is << in0-ini=oon >>.
Q2: How many boys were there among the Chinese? The total number of boys among the Japanese is lin2] + [in3]=
<< inouin3=outl >>. The total number of buys among the Chinese is [in4]. So, the total number of buys amon the Chinese is [in4]]
Q3: How many gids were there among the Chinese? The total number of Chinese is [outU]. The total number of boys among the outD indeou12 >>. The final answer is out
Chinese is [in4], So, the lotal number of girls among the Chinese
(Ahstraction) in0-inl south in2ein3wour] out0-indmouu2
(Derived Final Answer) o600=160 outl=80
out2=100
21

---

Published as a conference paper at ICLR 2026
Table 9: An example of reasoning emors made by AbstRal.. Responses generated by Qwen2.5- Math-7B 7B-Instruct with either CoT-8S or AbstRaL methods.
Question: Bill starts
3rd floor. Hc rides the elevator up the floor that's equal to times his starting floor plus What floor is Bill now? (Answer: 394+6=18)
Response with CoT-8S: Let's think step by step. we calculate 4 times his starting floor: [4 3 12) ... we udd to this result: [12 + 6= 18] ... The final answer 18.
Response with Rast
(Abstract Question) Bill starts on the [inO]rd floor. He rides the clevator the floor that's equal to [inl] times his starting floor plus [in2]. What floor is Bill on now?
(Conditions) in0=3 in1=4
in2=6
(Abstract Answer) Let's think about the sub-questions we need to answer. QI: How many floors does Bill go up? What floor Bill now? Let's answer each sub-question one by one.
QI: So he goes up << in0 +in2=out0 >> floors.
Q2: So he is now on the << inD+out0=nutl >>thh floor.
The final answer is outl. (Abstraction) inn=inl+in2=outt in0+out0=outl
(Derived Final Answer) outf=18 outl=21
Table 10: Instructions and few-shot examples used for prompting condition recognition in AbstRaL.
You are given a math word problem. Please replace the numerical values in the problem with abstract symbols, and enclose the abstract symbols in square brackets, Do not change any other words or add any other contents to the problem. Please also write oquations to clarify which numerical value cach abstract symbol is assigned to.
Example 1:
Input problem: Natalia sold clips of friends April, and then she sold half as many clips May.
llow many clips did Natalia sell altogether in April and May?
Output problem: Natalia sold clips to [inU] of her friends in April, and then she sold [inl] as many clips in May.
How many clips did Natalia sell altogether in April and May?
Equations: in0=48 in1=1/2
Example 2:
Input problem: The flowers cust $9, the clay pol costs $20 than the flower, and the bag of soil costs $2 less than the flower. How much does it cost plant the flowers? Output problem: The flowers cost S[in0], the clay pot costs $[in more than the flower, and the hag of soil costs S[in2] less than the flower. How much does it cost to plant the flowers?
Equations: in0=9 in1=20
in2=2
Example 3:
Input problem: From March to August. Sam made $460 doing 23 hours of yard work. However, from September to February, Sam was only able to work for hours. If Sam saving up to buy video game console that costs $600 and has already spent $340 to tix his car. how many more hours does he need to work before he can buy the video game console?
Output problem: From March to August, Sam made $[in0] doing [inl] hours yard work. However, from September February. Sam
only able work for [in2] hours. If Sam is saving up buy vidco game console that
costs $[in3] and has already spent S[in4] to fix his how many hours does he need to work before he can buy the video game console?
Equations: in0=460 in1=23
in2=8
in3=600
in4=340
Example 4:
Input problem: Zhang twice old Li. years old. Zhang's brother Jung years older than Zhang. How old is Jung?
Output problem: Zhang is [in0] times as old as Li. Li is [in!] years old. Zhang's 's brother Jung is [in2] years
older than Zhang. How old is Jung?
Equations: in0=2 inl=12
im2=2
Example 5:
Input problem: Of the 90 people William's bus, 3/5 Dutch. Of the 1/2 of the Dutch who also American, 1/3 got window seats. What's the number of Dutch Americans who sat at the windows?
Output problem: Of the [in0] people on William's 's bus, [inl] were Dutch. Of the [in2] of the Dutch who were also American, [in3] got window seats. What's the number of Dutch Americans who sat at the windows?
Equations: in0=900
in1=3/5
in2=1/2 in3=1/3
22

---

Published as a conference paper at ICLR 2026
Table 1 11: Instructions and few-shot examples for the first response rewriting step of our GranulAR training data construction, used for learning abstract reasoning in AbstRaL.
You given math word problem input conditions and solution. Please rewrite solution by replacing numerical values in angle brackets with abstract symbols. If the numerical values are given in the conditions, replace them with the abstract symbols assigned to them in the square brackets, otherwise replace them with new abstract symbols. Please also remove the reclundant
calculations around the angle brackets. Do not add any other contents to the solution.
Example
Problem: Natalia sold clips to [in0] of her friends in April, and then she sold [in]] as many clips May. How many clips did Natalia sell altogother April and May? 1n2
in8
Solution: How many clips did Natalia sell in May? Natalia sold 48/2 = << 48/2-24 b- 24 clips in May,
How many clips did Natalia sell altogether April and May? ** Natalia sold 48+24 48-24-72 bi 72 clips
allogether in April and May. The answer is 72.
Rewrite solution: How many clips did Naralia sell in May? e- Natalia sold <<< inO"in -ourO >> elips in May. How many clips did Natalia altogether April May? Natalia <<< int)+outl=outl >> clips altogether in April and May. The anewer is outl.
Example 2:
Problem: The flowers cost Slin0), the clay pot costs ([in more than the flower, and the hag of soil costs S[in]] than the flower. How much does cost to plant flowers?
Conditions: inf-- inl=20 in2-2
Solution: How much does the clay cost? es The clay pot costs $20 + 55c5 2049m29 2-2-29.
How much does the hag
cos?? The hag of soil costs $9 - $2 5. 9.2-7 >>-7
How much docs it cost to plant the flowers? set The cost to plant the flowers is $9 $29 57 Sicc 9-2947=45 20-45.
The answer 45,
Rewrite solution: How much does the clay pot cost? The clay pot costs $:c4 inI+in0=out0 >-S. How much does the bag of soil cost? we The bag of soil costs $-c-< in0-in2moutt >>.
How much does cost plant the flowers? xe The cost to plant the flowers $<5< in0+out0+outt1o0022 bo. The answer out2.
Example 3:
Problem: From March to August, Sam made Sjind]] doing linl] hours of yard work. However, from September to February, Sam was only ablc work [in2] hours. Sam saving up to buy vidco game console that
costs Slin3] and has already spent Sfin4] to fix his car, how many more hours does he need to work before
he can buy the video game console?
Conditions: in0-460 inl-23
in2=8
in]=600
in4=340
Solution: How much does Sam make per bour? Sam makes $460 23 has $$ <e 46023-20 20/h..r How much did
Sam make from September to l'ebruary? e* From September February. Sum made 8hass S20/hr S- < 8+20=160 >> 160
How much did Sam make from March to February? s* From March to February. Sam made a total of S460 $160 = $620.
How much money did Sam have after fixing his car? After fixing his car, he was left with $620 $340
Sic. 620-340-280 280
to buy video gume console? a- Sam How many more hours does Sam need to work? Sam needs to woek another $320 520/r - << 320/20-16 The answer 16.
How much money
Sam
another $600 $280
600-2200-300 >>3300.
>> hours.
makes Sec inlVinl wounh >/h How mach did Sam make from September to l'ebuuar? ** From September to February, Sum made s<x ont00ot)) >>.
Rewrite solution: How much does Sam make per hour?
How much did Sam make from March Febnuar?? we From March to Fehruary, Sam made total S<C4 in0+out mouut2
How much money did Sam have after fixing his car? After fixing his car, he was left with Sicc out2 induout3 >>.
How much money does Sam need to buy the video game console? "x Sam needs another S<c5 in3-out3moure >>>
How many more The answer out5.
Sam to work? Sam needs to woek another <x our4/om0-ouss >> hours.
Example 4:
Problem: Zhang [in0] times old as Li, is [in1]] years old. Zhang's brother Jung is [in2]] years older than Zhang. How old Jung?
in2-2 Solution: How old is Zhang? ** Zhang is years old < 2412=24 2-2244 years old. How old is lung? Jung is years 24 years = <x4 2+24=26 2-2 years old.
Conditions: inf==
in1=12
The answer is 26.
Rewrite solution: How old Zhang? xx Zhang in0"inl=oun" yeurs
How old is Jung? Jung is <<<; in2routd=outl >> years old.
The answer outl.
Example 5:
Problem: Of the [in0]] people William's 's bas. [inl] were Dutch. OF the [in2] of the Dutch who also
American, [in3] got window seats. What's the number of Dutch Americans who sat at the windows? in1=3/5 in2- 1/2
Conditions: in0--9
in3=1/3
Solution: How many Dutch people were
bus? ** the the number of Dutch people was 3/5 number, lotal of 3/5+90 <oc 3/5*90-54 5055 people.
How many Dutch Americans were the bux? e Out of the 54 people who Dutch 1/2 were Dutch Americans,
lotal of 1/2*54 <c 1/2754=27 2-227 people.
How many Dutch Americans sat at the windows? +* If 1/3 of the passengers on the bus identifying as Dutch Americans
at windows, their number 1/3*27 <x 273 >39
The answer 9.
Rewrite solution: How many Dutch people
the bus? e* On the bus, the number of Dutch people was [in]] of the total number,
of <<< ound-outt >>> people.
How many Dutch Americans were on the bux? *n Out of the [ouDD] people who were Dutch, [in2] were Dutch Americans,
tntal of << on2 >> people.
How many Dutch Americans sat at the windows? If [in3] of the pussengers on the bus identifying as Dutch Americans sat at the windows, their namber is << in3 mout2 >>>
answer out2.
23

---

Published as a conference paper at ICLR 2026
Table 12: Instructions and few-shot examples for the second response rewriting step of our GranulAR training data construction, used for learning abstract reasoning in AbstRaL.
You are given a math word problem with solution. The numerical values in the problem are replaced with abstract symbols and enclosed in square brackets. The calculations the solution are also composed of abstract symbols and caclosed in double angle brackets. Please rewrite the solution first listing all sub-questt sub-questions, and answering each sub questionnon by one. Pleuse list relevant conditions before answering each sub-question. Please clarity the final answer the end of the solution.
Example 1:
Problem: Natalia sold clips to [in0] of her friends in April, and then she sold [in as many clips in May.
How many clips did Natalia sell altogether April and May?
Solution: How many clips did Natalia sell in May? Notalia sold <t inf inf >> clips in May.
How many clips did Natalia sell altogether April and May? e* Natalia sold << inO+out0nout 2-2 clips
altogether in April and May. The answer out
Rewrite solution: Let's think about the sub-question we noed to answer.
Q1: How many clips did Natalia sell in May?
Q2: How many clips did Natalia seil altogether in April and May?
Let's unswer each sub question one by one.
Q1: How many clips did Natalia seil in May? Natalis sold [int]] clips in April. She sold [ini] many clips in May as she did in April. So she sold << inll"in -outt >> clips in May.
OZ: How many clips did Natalia seil altogether April and May? Natalia sold lin0] clips in April. She sold [our0] clips May. So sold << inDroutD-out >>> clips altagether in April and May. The final answer is ourl.
Example 2:
Problem: The flowers cost S(in0), the clay pot costs S[in more than the flower, and the hag of soil costs flower. How much does Solution: How mach does the clay pot cost? The clay pot costs Sekk in win0swott) >>
$(in2]
to plant flowers?
How much does the bag of soil cos?? a* The bag of soil costs $-2<; in0-in22outt 2-2-
How much does cost plant Bowers? ** The cost to plant flowers is inD+out0+out1=uur >>>
The answer is out2.
Rewrite solution: Let's think about the sub questions need to O1: How much does the clay pot cost?
Q2: How much does the bag of soil cost?
Q3: How much does cost plant
flowers?
Let's answer each sub questiunn one hy one.
Q1: How much does the clay pot cos?? The flowers cost S(in0). The clay pot costs S[in]] more than the flower.
clay pat costs S-cK. inflein
>>
Q2: How much does the bag of soil cost? The flowors cost S[in0]. The bag of soil costs S[in2] less than the flower.
So the hag soil costs S-c- in0-in2-our1 >>>
Q3: How much does it cost to plant the flowers? The flowers cost SlinO). The clay pot costs S(out)).
The bag of soil costs Sjout]]. I. So the cost to plant the flowers is $-24 ind++outHootl-ouu =out2 >>
The final answer out2.
Example 3:
August, Sam made S(inl) doing [inl] hours yard work. However, Septemher to February, Sam was only abls to work for (in2] hours. If Sam is saving up to buy a video game console that 3 and has already spent $[in4] fix his how many more hours does he need to work hefore he can buy the video game console?
From
Solution: How mach does Sam make per hour? e* Sam makes Sic < infVin l b/h. How much did Sam make from Soptember to February? ts From September Febeuary, Sam From March Fehrnary, Sam made total of $-5.c intt bob.
$-2 in2 ooutmooot >>>
How much did Sam make from March to Fehruary?
How much money did Sam have after fixing his car? ax After fixing his car, he was left with S-c o012-in/eout3 >>. Sam need to buy the How many more hours does Sam aced to work? Sam aceds to work another << outs/outt=outS >>> hours.
How much money
game console? s* needs another Sic < in3-out3eond >>:
The unswer out5.
Rewrite solution: Let's think about the sub-questions we need to answer.
O1: How much does. Sam make hour?
O2: How much Sam make from September February?
Q3: How much did Sam make from March to l'ebnury??
04: How much money did Sam have afler fixing his car?
Q5: How much money
Sam need buy the video game console?
Q6: How many more bours does Sam need to work?
Let's answer each sub-question
Q1: How much does Sam make per hour? Sam made $[i00] doing [in]]] hours of yard work.
So he makes S-c < in(Vin mount >>> hour.
Q2: How much did Sam make from September Fobruary? From September to Februasy, Sam worked [in2] hours.
He makes Slout0] per hour. So from September to Fehruary, he made S-ck: int >>.
Q3: How much did Sam make from March to Febnary? From March to August, Sam made SjinO]. From September February, he made S[out]]
March to Feeruury, he made total Sick ind-out =ouu2 >>.
Q4: How much money did Sam have after Eixing his car? Sam made a total of S(ou12]. He spent Sjin4] to fix his car.
So after fixing his car, he was left with S-ck2 oull in2--334 >>.
Q5: How much money does Sam need to buy the video game console? Sam was left with Stoui3). The video gume console costs $lim3].
So he needs unother S<c in ool-t43-out4 >>
Q6 How many more hours does Sam need work? Sam makes S[out]] per hour. He needs another S[out4].
So he needs to work another <.x. om14/ou0=ou15 >> hours.
The final answer out5.
24


Reviews:
[{"review_id": "NOtyZDIFss", "reviewer": "Reviewer_AUyf", "summary": "Authors introduce AbstRaL (Abstraction Reinforcement Learning), a framework that uses abstract intermediate representations to improving the robustness of LLMs in math word problems. Authors propose teaching models to abstract reasoning problems—that is, to represent problems symbolically and reason at a higher level of abstraction. AbstRaL integrates RL with a new Granularly-decomposed Abstract Reasoning (GranulAR) dataset that blends CoT reasoning with symbolic abstraction. The method encourages LLMs to generate faithful abstract representations that can be solved via symbolic tools such as equation solvers. Experiments are done two LLMs mainly and results on new benchmarks (GSM-Symbolic, GSM-Plus) show improved robustness under numerical, contextual, and distractor perturbations.", "questions": "L77: There are other work which used to convert the math word problems to equations and then use tools to solve it. Why is this different?\n\nFor example, Agarwal et al. ICLR 2021 MathAI showed that it was fundamentally difficult for Transformers to perform numeric addition, multiplication. So, using symbols in place and postponing the calculation worked much better. Other work such as Mitra et al. 2018 and many, also predicted equations from math words as an intermediate step. This was the norm in pre-LLM era.\n\nL201: The abstract answer $\\mathcal{Y}_\\mathcal{A}$ seems to be generated by LLMs. It involves a crucial step of decomposition which needs to have a necessary and sufficiency check? Was it done by any means?\n\nL250: This will miss any equivalent expressions, lets say which is a simplification or complicated version of A.   Can't we look at AST matches?\n\nL268: These types of claims and statements are very generic. Many LLMs are trained code corpora, sees a lot of different structured languages. Why should it not be inherently incapable of such abstraction?\n\nL375: Doesn't it show that the step-by-step decomposition is helping more? Based on the drops in Table 2, thats what is implying. Am I missing anything here?\n\nL401: Its interesting that removing the abstraction does not help much with distractors. But these are small models (only two). Would it affect larger ones as well? Is it possible to show this on large models (gpt-oss size).", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. Combination of learning abstractions using an SFT-RL framework seems interesting.\n2. Though authors have used only two main LLMs, the ablation studies are done htoughtfully.\n3. Using the socratic version of GSM8k to rewrite the abstract intermediate steps (/decomposed questions) is interesting. Therefore, makes the data somewhat valuable.", "weaknesses": "The paper suffers largely on novelty, lack of sufficient experimentation, broad claims which are untrue.\n\nNovelty: Neither decomposition nor abstraction is new in symbolic math, math word problem solving. There are too many papers, with too many variations and ideas. Authors also do not specify any contributions. So, I am not even sure if this is a central claim.\n\nLack of sufficient Experimentations: Only two small LMs are chosen to support very broad claims. Even the variations of GSM chosen are only two. There are many variants: GSM-Hard, i-GSM, GSM8k_MORE. And this is just GSM8k. There are so many fantastic and important datasets out there. \n\nBroad claims: See below.\n\nOthers:\n1. Limited comparison to earlier equation-prediction approaches: Prior work (e.g., Mitra et al. 2018; Agarwal et al. 2021) also translated math word problems into equations for symbolic solving (more below)\n2. The generation of GranulAR data relies heavily on a large teacher model (Llama-3.3-70B). Whats the effect of using such a model here. What if we use smaller models.\n3. While the method checks answer correctness, it is unclear how the necessary and sufficient quality of abstract decompositions is ensured or whether abstraction errors propagate through training.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "zUyHwurYGC", "reviewer": "Reviewer_wvec", "summary": "This paper introduces AbstRaL, a framework designed to enhance the reasoning robustness of LLMs, particularly for GSM problems. Instead of relying on extensive data augmentation (\"instantiation\"), the authors propose to explicitly teach LLMs to first generate an abstract representation of a problem. This abstraction, being invariant to surface-form variations, is intended to make the model more robust to OOD shifts like changes in numbers, names, or the addition of distractors. The core of the method involves a new, fine-grained data format called GranulAR and a RL scheme built on top of SFT. The RL component uses novel, model-free rewards based on final answer correctness and the symbolic similarity of the generated abstraction to a gold reference, aiming to improve the faithfulness of the abstract reasoning process. The authors demonstrate that AbstRaL significantly improves performance on GSM robustness benchmarks (GSM-Symbolic, GSM-Plus) and shows some generalization benefits to other OOD tasks.", "questions": "1.  How can you be sure that the performance gains are not primarily a result of distilling its superior reasoning capabilities into the smaller models? Have you tried using a weaker model as the oracle to see how that affects the final performance?\n\n2.  The `w/o RL` ablation shows that SFT on GranulAR data performs poorly, often worse than simple CoT prompting. Does this imply that the proposed abstraction format is too difficult for models to learn via SFT alone and that the complex RL setup is a necessary crutch? \n\n3.  Regarding the scalability to other domains: What do you foresee as the main challenges in applying AbstRaL to problems where the \"abstraction\" is not a simple mathematical formula? For example, in a commonsense reasoning task, what would the \"conditions\" C and the \"abstraction\" A look like, and how would they be reliably extracted?\n\n4.  For the strongest models, AbstRaL seems to trade in-distribution performance for OOD robustness (e.g., Table 1, Qwen2.5-Math-7B, Origin 100). Do you consider this an inherent trade-off of the method? Why do you think this performance degradation on the original task occurs?", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1. The central idea of moving from \"instantiation\" to \"abstraction\" is a strong conceptual contribution. Explicitly teaching the model a reasoning schema that is invariant to surface details is a promising direction for improving OOD robustness.\n\n2.  The proposed AbstRaL framework is well-thought-out. The creation of the GranulAR data format, which blends socratic decomposition with symbolic abstraction, is a clever way to make the task more tractable for LLMs. The use of reinforcement learning with a custom symbolic distance reward (`rsymbolic`) to enforce faithfulness is a significant and novel part of the method.", "weaknesses": "1.  The framework's dependence on a vastly more powerful model (Llama-3.3-70B) for critical data generation steps is a major weakness. Both the initial \"Condition Recognition\" and the subsequent \"Abstract Reasoning Chain Rewriting\" are performed by this moel. This raises the concern that the improvements seen in smaller models are largely due to knowledge distillation from a superior model, rather than the inherent power of the AbstRaL learning scheme itself. \n\n2. The method is evaluated exclusively on grade school math problems, where the underlying abstractions (arithmetic operations) are simple and well-defined. It is highly uncertain how this framework would translate to more complex domains with ambiguous or non-mathematical abstractions, such as legal reasoning, commonsense planning, or scientific hypothesis generation. The paper does not discuss these limitations or provide a path toward generalization.\n\n3.   The primary comparison is between AbstRaL (SFT + RL) and baselines that are either prompting-based (CoT-8S) or SFT-only (CoA, AoT). The `w/o RL` ablation in Table 2 shows a massive performance drop, suggesting that the GranulAR data format with SFT alone is not very effective. A more direct and fair comparison would be between \"AbstRaL-SFT\" and other SFT-based abstraction methods. Furthermore, for the stronger Qwen2.5-Math-7B model, AbstRaL underperforms CoT-RL on the original, in-distribution data (91.0 vs 96.0), indicating a potential trade-off where improving OOD robustness comes at the cost of ID performance.\n\n4.  The paper claims that AbstRaL \"implicitly benefit more general reasoning capabilities.\" However, the results in Table 3 show that the improvements on general reasoning benchmarks like MMLU are marginal at best. The most significant gains are on other math-related datasets (MATH, AIME24), which is less surprising and does not fully support the claim of broad generalizability.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "w9uepImH2x", "reviewer": "Reviewer_XBfh", "summary": "This paper presents an interesting technique of leveraging symbolic abstract thinking as a way to improve the performance of LLM's ability to solve math problems. Instead of directly direct solutions from surface form, LLMs recognize input parameters, symbolic formula to compute the answer, and then the answer is derived by symbolic execution. \n\nThe paper presents a data generation pipeline, that (1) rewrites instance into parametric representation, (2) sample CoT, and (3) rewrite CoT into abstract CoT and use symbolic derivation to calculate final answers. This way, the model can be trained with first SFT and then RL to perform abstract reasoning.\n\nResults show the performance of Abstral model on par and better than other reasoning based approaches. Ablation shows the effectiveness of RL, contexts and the reward design.", "questions": "check the section above.", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 4, "strengths": "- This paper presents a quite interesting approach for math reasoning. Instead of directly reason on the text space, it leverages formula inference to derive the right result. This effectively turn math reasoning into a programming task (i.e., extract parameter, write a program, and run the program to get result) and assemble results with response.\n\n- The dataset construction leverages existing CoT to construct generalizable abstract trace.\n\n- Evaluation is pretty solid, especially with ablation with SFT vs RL's contribution to the final performance.", "weaknesses": "- the proposed abstraction composition is quite complicated, especially given the rewriting + retrieval (I personally think it's better called extraction as I was confused with document retrieval at first glance). Will a simpler way to construct reasoning, i.e, ask the model to directly generate formulas on top of basic COT (e.g., in a separate section) achieve the similar performance? Especially considering directly generate a small snippet of code for computation and ask LLM to assemble back to response. Is this just a format / style issue, or some more fundamental difference?\n\n- r_symbolic seems quite important. But it's not clear reasons behind difference of results without no r_symbolic, some qualitative analysis compare results with and without r_symbolic would be helpful. I think r_symbolic is important kinda hint there may not be sufficient SFT for guiding formula generation.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "ZWaiJFqHDp", "reviewer": "Reviewer_vEZ7", "summary": "This paper introduces a novel reasoning technique that abstracts mathematical problems *before* solving them. The abstraction process goes from recognizing input variables to generating an abstraction that can be solved using external math tools or by an LLM tailored for the task. The authors show that this strategy improves the performance of many LLMs on two variants of the GSM dataset.", "questions": "- What is the accuracy of each step of abstraction process summarized in Section 3?\n- Eq 1: a better name for the reward formula introduced here would be \"symbolic similarity reward\" since it's computed as (1 - distance).\n- Are the results shown in Table 1 statistically significantly better than the next strongest baseline in Table 1?\n- Typo in Abstract: \"we instead focuses\"", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The idea of uncovering the underlying abstraction of a math problem and using this abstraction to solve it (rather than the potentially noisy original text) is elegant.\n- The abstraction pipeline can be implemented with relatively simple components, which means this direction is likely to used in practice.\n- The results are consistently better than multiple strong baselines, for nine LLMs and two variants of the GSM dataset.", "weaknesses": "- While I think the contributions of this paper are sufficient for a conference publication, the authors focus on a single style of math problems since both datasets are spinoffs of the GSM dataset. The paper's claims would be stronger if at least another math dataset was used.\n- In the same vein, previous work has consistently shown that mathematical reasoning problems are sensitive to noise in the problem formulation. How sensitive is this method to noise? See, for example, this new dataset for this investigation: https://ymingl.com/GSMDC/\n- While I understand that math reasoning is the focus here, which, again, is sufficient for a conference paper, the authors should discuss how this work would be adapted for other types of reasoning scenarios.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)