Improving LLMs‘ Generalized Reasoning Abilities by Graph Problems
Authors: Qifan Zhang
Nuo Chen
Zehua Li
Miao Peng
Jing Tang
Jia Li
Venue: COLM 2025 (2025)
Keywords: Large Language Models
Continue-Pretraining
Graph Problem Reasoning
General Reasoning
TL;DR: We introduce GraphPile, a 13B-token dataset for graph problem reasoning (GPR), to enhance general reasoning in LLMs. Models trained on GraphPile achieve significant gains across diverse reasoning tasks, extending LLM capabilities beyond mathematics.

Abstract: Large Language Models (LLMs) have made remarkable strides in reasoning tasks, yet their performance often falters on novel and complex problems. Domain-specific continue-pretraining (CPT) methods, such as those tailored for mathematical reasoning,  have shown promise but lack transferability to broader reasoning tasks. In this work, we pioneer the use of Graph Problem Reasoning (GPR) to enhance LLMs' general reasoning capabilities. GPR tasks—spanning pathfinding, network analysis, numerical computation, and topological reasoning—require sophisticated logical and relational reasoning, making them ideal for teaching diverse reasoning patterns. To achieve this,  we introduce GraphPile, the first large-scale corpus specifically designed for CPT using GPR data. Spanning 10.9 billion tokens across 23 graph tasks, the dataset includes Chain-of-Thought, Program-of-Thought, Trace of Execution, and Real-world Graph Data. Using GraphPile, we train GraphMind on popular base models-Llama 3&3.1 and Gemma 2-achieving up to 4.9% higher accuracy in mathematical reasoning and up to 21.2% improvement in non-mathematical reasoning tasks, like logical and commonsense reasoning. By being the first to harness GPR for enhancing reasoning patterns and introducing the first dataset of its kind, our work bridges the gap between domain-specific pretraining and universal reasoning capabilities, advancing the adaptability and robustness of LLMs.

Published as a conference paper at COLM 2025
Improving LLMs' Generalized Reasoning Abilities by Graph Problems
Qifan Zhang* Nuo Chen" Zehua Li
Miao Peng Jing Tang
Jia Li*
The Hong Kong University of Science and Technology (Guangzhou) {qzhang297, zli243, mpeng&65)econnect. wawtoonncc..uustteeee. hhkustgg.eede ezz.edu.co cn chennuo26@gmail. com, (jingtang, jialee)@ust.
Abstract
Large Language Models (LLMs) have made remarkable stridee in reasoning tasks, yet their performance often falters on novel and complex problems. Domaín-specific continue-pretranning (CPT) methods, such as those tailored for mathematical reasoning, have shown promise but lack transferability to broader reasoning tasks. In this work, we pioneer the use of Graph Problem Reasoning (GPR) to enhance LLMs' general reasoning capabilities. GPR tasks spanning pathfinding, network analysis, numerical computation, and topologiaal reasoning, making them ideal for teaching diverse reasoning patterns. To achieve thís, we introduce GraphPile, the first large-scale corpus specifically designed for CPT using GPR data. Spanning 10.9 billion tokens across 23 graph tasks, the dataset includes Mhain-of-Thought Program-of- ofoThhtth Trace of Execution, and Real-world Graph Data. Using GraphPile, we train GraphMind on three popular base models-Llama 3&3.1 and Gemma 2-achieving up to 4.9% higher accuracy in mathematical reasoning and up 21.2 21.2% improvement in non-mathematical reasoning tasks, like logical and commonsense reasoning. By being the first to harness GPR for enhanc- ing reasoning patterns and introducing the first dataset of its kind, our work bridges the gap between domain--pecific pretraining and universal reasoning capabilities, advancing the adaptability and robustness of LLMs.
booooinng-rquuiiie sophisticated logical and relational
1 Introduction
Recent advancements in Large Language Models (LLMs) have demonstrated impressive few-shot learning capabilities across wide range of tasks (Kirillov et al., 2023; Sun et al., 2024; You et al., 2022a; Cobbe et al., 2021a; Zhou et al., 2022; Wei et al., 2022; Wang et al., 2022; Chen et al., 2023a; You et al., 2022b; Chen et al., 2024b). However, when faced with novel and complex problems, their performance often falls short. To address this limitation, many works have focused on continue-pretraining mathematical reasoning (Shao et al., 2024; Azerbayev et al., 2023; Ying et al., 2024; Yang et al., 2024; Wang et al.; Gunasekar et al., 2023; Lu et al., 2024). A variety of models have emerged from this paradigm, such as MathCoder (Wang et al., 2023b), Qwen-Math (Yang et al., 2024), and the DeepSeek Math series (Shao et al., 2024). These models leverage vast datasets focused on mathematical problems or code-related tasks, often gathered from web sources (Shao et al., 2024; Yang et al., 2024) synthetically generated (Gunasekar et al., 2023; Yang et al., 2024), to improve the performance of LLMs in solving mathematical challenges.
(CPT), particularly in the domain of
While these efforts have yielded significant improvements in mathematical reasoning, they are primarily dosainerestricted (Wang et al., 2023c; Wu et al., 2023). The question remains whether such focused pretraining translate to broader reasoning capabilities. In particular, the improvements observed mathematical tasks have not been demonstrated to extend to other complex reasoning areas, such algorithmic understanding and logical
* Equal Contribution
t Corresponding author
1

---

Published as a conference paper at COLM 2025
Graprttins
E0
66
Benchmark
Ligic Tupelogy Compatation Enumeration Divialnn
Muth Reworing
x
60
66
40
20-
Algorihan Beascnlng
Zetro Logical Reasoming
Oephendeet
Reasoning
Graph Reasoning
(a) Reasoning paradigm comparison
(b) GraphMind-ULaMA-3 results
Figure 1: Reasoning paradigm comparison between math and graph (left) and overview of GraphMind-LLaMA-31 results compared with baseline models on math, logical and graph reasoning benchmarks (right).
reasoning. This leads to explore fundamental question: Rather than being domain- locked, is there a class of problems or data that, if incorporated into LLM training, could foster the model's general reasoning ability across diverse tasks?
Graph Problem Reasoning (GPR) (Chen et al., 2024a; Tang et al., 2024; Zhang et al., 2024b; Peng et al., 2025) presents a compelling answer to this question. GPR involves tackling challenges rooted in graph theory-a foundational area of mathematics concerned with the study of graphs, which consist of nodes (vertices) and edges (connections between nodes). The domain of graph problems spans a wide variety of complex tasks, including pathfinding, network analysis, and edge counting, all of which require sophisticated multi- step reasoning and an ability to navigate intricate, relational structures. What makes GPR particularly intriguing is its resemblance to mathematical reasoning, as shown in Figure (a). Both domains share several key characteristics, such the need for logical computation, systematic enumeration, and division awareness. For instance, in mathematical problem solving, series of well-defined steps is often required to reach solution. Similarly, graph- based tasks necessitate a stepwise approach to traverse, analyze, or optimize the graph structure. Notebaly, the reasoning patterns involved in the design of currently popular mathematical datasets are all subset of GPR, like GSM8K (Cobbe et al., 2021b) and MATH (Hendrycks et al., 2021b).
In general, GPR tasks demand different reasoning patterns, including topological reasoning, logical reasoning, enumeration, precise computation and division (More details in Sec.2.1), making them fundamentally challenging for LLMs (Fatemi et al., 2023; Wang et al., 2023a). In many ways, solving these problems mirrors the process of mathematical reasoning, which also relies on logical steps to arrive at a solution. Moreover, GPR introduces unique chal- lenges not present in traditional mathematical reasoning. For instance, while mathematical problems typically involve direct mathematical formulas and manipulations, graph prob- lems often involve relational reasoning understanding how entities (nodes) are connected and how their relationships impact the overall solution. This introduces additional complex- ity, as the reasoning must account for the spatial or topological relationships between nodes and edges, something that is less pronounced in classical mathematical problem-solving Meanwhile, the difficulty of graph problems often scales exponentially with the size and complexity of the graph (Tang et al., 2024), posing an additional layer of challenge that further tests the limits of an LLM's reasoning capacity.
Given the intrinsic similarities between mathematical reasoning and graph problem-solving, and the wide-ranging nature of graph-based tasks, we hypothesize that graph problem reasoning can serve as an effective source of data for continue-pretrainnn integrating graph problems into the pretraining process, we aim to unlock powerful tool for enhancing general reasoning abilities. Specifically, we explore the potential of GPR to improve not only mathematical reasoning but also other forms of complex reasoning, such as algorithmic problem-solving and logical reasoning. We seek to bridge the gap between domain-specific pretraining and the development of more universally capable reasoning models, ultimately making LLMs more robust, adaptable, and effective in a broader range of problem-solving scenarios.
LLMs. By
In this work, our goal is to include graph problem reasoning data that helps LLMs evolve into more generalized and better reasoners. To this end, we present the first dataset for
2

---

Published as a conference paper at COLM 2025
Tepelogical Reasuming
Logical Recseming
Chain-of Thought Generstion
Garer 407
Prok
Degres Conting
prefeccsor
Prognam-ot of Thought Data Generation
Division
Computation
Zecoad
Siruuggl
Burterin Gefficee
Auxincos Troople Som
Pegeevak
GraphPle
heightr
Fire hers Farl
Trace-of- Execution Data Generation
Enumeration
Tronreo
Desgg
Cok Vartetta
(a) Different reasoning paradigms
(b) Dataset curation pipeline
Figure 2: Overall illustration of (a) Different reasoning paradigms for total 23 graph problem tasks in GraphPile, and (b) GraphPiLe ille curation pipeline.
continue-pretrainingg LLMs using Graph Problem Reasoning data, named GraphPile, con- sisting of approximately 10.9 billion tokens and covering 23 distinct graph problem tasks. Our dataset includes four main types of data: 1) Chain-of-Thouuhh Data (Wei al., 2022; Yao et al., 2023): For each graph problem, we employ program guidedd approach to gener- ate accurate thain-of-thougee process step by step; 2) Trogram-of-Thougee
(CoT) solutions, enabling the model to learn the reasoning
Data (Chen et al., 2022): Given graph prob- lem, we leverage L.LMs identify relevant code repositories from web text and generate corresponding solutions, thereby connecting problem-solving. to code generation; and 3) Trace of Execution Data: A novel data type introduced in this work, where we record the execution trace of graph problem algorithms, allowing the model to learn from the execution process itself, potentially enhancing its ability to understand algorithmic steps and reasoning; 4) Real-world Graph Data: In addition to these synthetic graph problems, we also collect real-world graph problems from sources like DBpedia (Bizer et al., 2009) and DBLP (Ley, 2002), further enriching our dataset with practical, domain-specific problems that reflect real-world graph analysis challenges.
We train three popular base models on GraphPile, including LLaMA-3&3.1 8B (Grattafiori et al., 2024) models and Gemma-2-21 models (Team et al.), resulting in GraphMind series. We validate the effectiveness of our models across 5 distinct reasoning tasks and 20 datasets, achieving significant improvements in all cases, as shown in Figure 1 (b). We primarily consider two settings for evaluation: 1) Few-shot: We directly test GraphMind across different datasets using few-shot prompts; 2) Post-training: We fine-tune GraphMind on downstream datasets when training sets are available, further refining its performance in specific tasks. Experimental results indicate that GraphMind exhibits enhanced reasoning capabilities across various domains compared to the base model. In mathematical reasoning, its average accuracy over 11 datasets surpasses the base model by up to 4.9%, while in other reasoning tasks, the improvement reaches as high as 21.2%. Moreover, GraphMind demonstrates potential for post-training enhancement. Notably, the Gemma version of GraphMind fine- tuned on GSMSK achieves 23.6% higher accuracy.
2 GraphPile
In this section, we present the curation details of GraphPile, covering reasoning paradigms definitions (Section 2.1) and the dataset curation pipeline (Section 2.2). An overview in Figure 2.
2.1
Reasoning Paradigms
Graph problem reasoning cover various reasoning paradigms, including logical reason- ing, topological reasoning, numerical computation, enumeration, and division. To ensure
3

---

Published as a conference paper at COLM 2025
comprehensive coverage, include tasks from each category. For clarity, we select two representative tasks per category, focusing on their primary reasoning type, though some tasks may overlap categories.
Logical Reasoning Tasks. or solving problems based on specific logical rules. Since all graph problem tasks are fundamentally based on reasoning derived from logical rules, they are inherently tasks of logical reasoning. Here are two representative tasks.
Logical reasoning involves analyzing, deducing conclusions,
Cycle Detection. Given graph G {V, E) the task is to check if it contains cycle. A cycle is a closed path with at least three vertices, where each pair consecutive vertices is connected by an edge.
Bipartite Checking. This task is to determine if a graph G = {V,E} is bipartite, meaning its vertex can be partitioned into two subsets U and where no two vertices in the same subset are adjacent.
Solving these problems requires LLMs to apply specific logical rules. For example, a cycle exists in graph if path from a vertex revisits the same vertex. A graph is bipartite if its vertices can be colored with two colors so that no adjacent vertices share the same color.
Topological Reasoning Tasks. Topological reasoning tasks involve exploring the rela- tionships between nodes and edges in graph and making inferences based on these relationships. Since all graph problem tasks are built upon these relationships, they inherently belong to the domain of topological reasoning. Representative tasks include topological sorting and common neighbors.
Topological Sorting. For a directed acyclic graph (DAG) G (V,E), topologiaa sorting is a linear ordering of its vertices such that for every directed edge (u, v) E E, the vertex u appears before in the ordering.
Common Neighbors. Given a graph g (V,8), the task is to identify the set of common neighbors between two nodes u E V. The common neighbors are defined as (()) (N(v), where N (xx represents the set of neighbors of node
Solving these problems typically requires LLMs to understand the topological structure of the graph. For example, topological sort reveals hierarchical relationships in directed acyclic graphs, while common neighbors highlight local connections between two nodes. This reasoning paradigm is rarely encountered in traditional mathematical problems.
Numerical Computation Tasks. Numerical computation involves using algorithms to solve problems through a large number of operations like addition, subtraction, multi- plication, and division. Representative tasks are the shortest path and maximum flow.
Shortest Path. Given a weighted graph G = {V,E, w) with w & + R+, the task is to find a path between two nodes that minimizes the total edge weight.
Maximum Flow. Given weighted graph g {V,E,c) c} with capacities e E R!, a source U, and a sink Dt the task is to maximize the flow from v, to 24.
Solving these problems requires L.MSs to perform numerical computations. For exam- ple, the shortest path problem involves iterative updates of distances, and the maximum flow problem requires tracking residual capacities. Math problems like root finding and numerical integration are also examples of numerical computation.
Enumeration Tasks. Enumeration tasks involve systematiall listing all possible solutions or elements in set, often to address problems in combinatorics, optimization, search. Representative examples include the Hamilton path and the maximum matching.
Hamilton path exists graph G (V,E), where Hamilton path visits each node exactly once.
Hamilton Path. Determine
Maximum Clique Problem. The task is to find a clique of maximum size in graph g (V,E). A clique is defined as subgraph where all nodes are fully connected.
4

---

Published as a conference paper at COLM 2025
Orearthity
nocr wos
Thut purt wan and teeryy
Chan of Thought Generation
Trionglo
CJ
360
oewer for denero right Jimpen toa ardjan
Commee ruudbid Pediiy reom 9h
ewct Auk dic Lit
the Troegl by
nute
to deeari ful Ende Inddrcction hor port wir.
le Compant
Erodies criing pocories are cssert for
(o) Chain Thought
(b) Real-Wort World Graph
layn wolert show
duttans mack
Better of 'l Por you coa
(c) Program of Thought
(d) Trace of Execution
Wi demiin deperite aod inticcal
lokk vaey on mroikee more effichery
UUW
Briah Aagisin
LAM
Grogh Alganites Code
Trece Execation
pre kep Hark
11
C0 FDr
(641)
Figure 3: Data components of GraphPile
Solving these problems often requires LLMs to enumerate the solution space. For the Hamilton Path problem, this involves listing paths that visit each node exactly once, while the Maximum Clique problem requires enumerating cliques. Similarly, math problems like the integer partition problem and subset sum problem are examples of enumeration.
Division Tasks. Division tasks focus on breaking down a large problem into smaller, independent subproblems, which can be solved individually and then combined to form the overall solution. These tasks are commonly encountered in areas such as connectivity and strongly connected components in graph theory.
Connectivity. The task is to determine if two nodes u and v in graph g = (V,E) are connected, meaning there exists a path from u to V.
Strongly Connected Component. The task is to find the Strongly Connected Components (SCCs) of a directed graph 9 (V,E), where an SCC is a maximal subgraph in which every pair of nodes u and v has paths both from u to v and from to
Both tasks require LLMs to employ the division approach to systematically decompose a graph into several connected components. Mathematical problems such as modular arithmetic and polynomial division also fall under this category.
In addition to the aforementioned reasoning paradigm, Graph Problem Reasoning also encom- passes spatial reasoning, such as planarity testing. To enhance the diversity of our dataset, we have selected total of 23 graph problem tasks, as demonstrated in Figure 2 (a). Detailed task definitions are provided in Appendix B.1
2.2 GraphPile ill Collection
In this section, we introduce the curation process of GraphPile, a diverse collection of graph problem data for continued pretraining L.Mss. Our data synthesis consists of four
5

---

Published as a conference paper at COLM 2025
components: Chain-of-Thoughe data, Real-World Graph data, Program-of-Thougg data, and Trace of Execution Data. Since our synthesis process involves various problems related to graph algorithms, we hire a human expert 1 in this field to design algorithm implementations, verify correctness, and optimize efficiency. Figure 2 (b) provides an overview of these pipelines.
Graph Generation. GraphPile comprises both synthetically generated Erdös-Rényi (ER) (Erdös et al., 1960) graphs and real-world graphs obtained through web crawling. For each type of graph, we include both directed and undirected variants, which are randomly generated. Furthermore, the dataset encompasses a variety of graph representations, in- cluding adjacency matrices, adjacency lists, and edge lists. We include graphs of varying sizes, ranging from 6 to 40 nodes, for the following reasons: (1) To address varying lévels of complexity in graph reasoning; and (2) To limit graph sizes, as larger graphs result in extremely large sample length (more than 8k) and make it harder for LLMs to learn accurate and complete reasoning path during continue- continue-pretraining
Shain-of-Thoughe Data Generation. CoT data is synthesized to offer step-by-step ex- planations of graph problem-solving processes, which are essential for training LLMs to develop systematic reasoning abilities. However, graph problem reasoning differs sig- nificantly from mathematical reasoning because its difficulty increases exponentially as the graph size grows, making it a major challenge even for state-of-the-art LLMs such as GPT-4o. As a result, LLMs struggle to directly generate accurate and complete CoT solutions, especially for large and complex graphs (Chen et al., 2024a; Luo et al., 2024). To address this, we propose a Program-Guided approach: for each graph problem, an expert designs a corresponding programmatic solution. By executing this program, we can record intermediate computational results. For example, in the cycle detection problem illustrated in Figure 3 (a), we log the path leading to the final decision, such 0-4-7-1-5-0. These paths are then rephrased into natural language solutions using GPT-4o. However, due to the inherent variability in LLM outputs, we employ GPT-4o again to verify the correctness of the rephrased paths. The correctly rephrased paths, together with the original graph problems, form our CoT dataset. Besides, since many graph problems admit multiple valid solutions (e.g., in cycle detection, multiple cycles may exist in a given graph), we sample up to three distinct solutions enhance the diversity of CoT reasoning data. Detailed prompt of LLM rephrasing and LLM verification are given in Appendix C.1.
Real-World Graph Data Generation. To enhance the diversity of Chain-of- Thouught data and improve the reasoning capabilities of LLMs in complex realistic scenarios, we extend our CoT dataset to include real-world graph problems. Specifically, we begin by collect- ing real-world graphs from sources such as DBLP (Ley, 2002), OpenFlight (OpenFlights), PubChemQC (Nakata & Shimazaki, 2017), Social Networks (Rossi & Ahmed, 2015), and DBPedia (Bizer et al., 2009). We then utilize GPT-4o to rephrase the problems and answers from the existing CoT dataset by replacing numerical node identifiers with real-world rephrra textual node identifiers. After rephrasing, we use GPT-4o to filter out incorrect problem
and answer pairs (e.g., cases where nodes edges in the original graph are lost or added during the rephrasing process). Through this process, we construct the Real-World Graph dataset, which features real-world problems paired with step-by-step solutions. This dataset effectively bridges abstract graph reasoning with practical, real-world applications. Figure 3 (b) provides examples of this dataset. Related prompts are given in Appendix C.2.
cases
Program-of-Thought Data Generation. While CoT provides step-by-step explanations, (PoT) offers precise, executable solutions that eliminate ambiguity (Li et al., 2024b;a; Zhang et al., 2024a; Wang et al., 2024b). Training LLMs on well-structured code enhances their ability to interpret, generate, and apply algorithmic logic effectively in graph problem-solving. Considering that many graph-related algorithms have already been implemented in widely used libraries such as NetworkX, we leverage these resources for PoT solution generation. After constructing a graph problem, we prompt the LLM to retrieve relevant implementations directly from code documentation repositories. If
This expert holds PhD specializing in graph algorithms.

---

Published as a conference paper at COLM 2025
Datasel
Graph Category
Problem- Solving Paradigms
Tasks
Samples
CPI-Compatible
GraphWiz (Chen et al, 2024a)
Synthetic
Col
17,158
x
Graphinstruct al.,
Synthetic
InstrucKGraph (Wang et al, 2024a)
Synthetic
Simple Answer
13,699
X
GraphArena (Tang etal. 2024)
Real-World
Simple Answer CoT,
10
10,000
X
GraphPile (Ours)
Synthetic Real-World
2,684,675
Table 2: Comparison between GraphPile and existing graph reasoning datasets
the extracted code is executable and produces correct results, we include in our dataset. Furthermore, to ensure PoT diversity, we instruct the LLM to rewrite the extracted code, generating a modified version that retains the original logic while introducing variations in implementation. These alternative versions help LLMs generalize across different coding styles and improve their robustness in algorithmic reasoning. Figure (c) demonstrates examples of this dataset. Related prompts are given in Appendix C.3.
Data Generation. Execution reasoning trace textual sequence that explains the step-by-step execution of a code, abstracting the rea- soning process while maintaining log- ical rigor. It captures key skills like log- ical flow, state exploration, recursion, and decision-making. However, this data paradigm has not been studied be-
Components
Size
Tokens
Chain-of-Thought
848,965
2,809,225,185
Real-world Graph
743,465
3,203,590,685
Program-of-Thouge
759,851
2,190,746,959
332,394
2,727,119,224
Total
2,684,675
10,930,682,053
fore. To leverage its benefits, we pro-
pose the Program-Guided approach.
Table 1: Statistics of GraphPile.
For a given graph problem, experts de- sign three versions of high-quality code with tracing phrases at key points. Each code is along with two additional problems focusing on intermediate variable states, forming a diverse problem set. Executing the codes generates traces, which, combined with the problems, form the Trace of Execution data, enabling LLMs to learn from multiple reasoning perspectives. For example, Figure 3 (d) shows a graph traversal problem, its solution code, and tracing phrases at key points. Two extra problems focus the intermediate states of "stack" and "visited". By executing the code, the solution trace is generated.
Finally, by integrating these datasets, construct our training dataset, GraphPile, which comprises 4 distinct components and encompasses over 2.68 million samples and 10.9 billion tokens. GraphPile integrates different reasoning paradigms, empowering LLMs to tackle graph problems with greater robustness, systematic precision, and efficiency. Detailed statistics of GraphPile, the comparison between GraphPile and existing graph reasoning datasets, and more examples of each dataset are given in Table 1, Table 2 and Appendix D.1.
Experiments
After constructing GraphPile, We begin by performing mnttinue-pretriiiing three LLMs, ranging in size from 2B to 8B, thereby obtaining three versions of our reasoning model, GraphMind. In this section, we validate our model in two scenarios: 1) Few-shot: We directly test GraphMind across different datasets with few-shot prompts; 2) Post-training: We fine- tune Gr GraphMine nd in downstream datasets if training sets are available. At last, we perform an ablation study to evaluate the contribution of different components within GraphPile.
3.1 Experimental Settings
Evalution Dataset. To thoroughly evaluate the reasoning capabilities of GraphMind and other baselines, we select 22 benchmarks spanning six reasoning domains: mathematics reasoning, logical reasoning, commonsense reasoning, code reasoning, multi-Hop QA reasoning, and graph problem reasoning. For mathematics reasoning benchmarks, we choose 11 benchmarks, including GSMSK (Cobbe et al., 2021b), MATH (Hendrycks et al., 2021b), GSMSK-Hard (Gao et al., 2022), SVAMP (Patel et al., 2021), ASDIV (Miao et al., 2020), MAWPS (Koncel-Ken Kedziorkk et al., 2016), HINERVA_MATH (Hendrycks et al., 2021b),
7

---

Published as a conference paper at COLM 2025
MMLU STEM (Hendrycks et al., 2021a)), TABMWP (Lu et al., 2022), MATHQA (Amini et al., 2019) and SAT_ MMth SAT_Math (Zhong et al., 2023). For logical reasoning benchmarks, we choose Zebra Puzzle (Lin et al., 2025), Ruletaker (Clark et al., 2020), and ProofWriter (Tafjord et al., 2020). For commonsense reasoning, we choose Strategy QA (Geva et al., 2021) and Hellaswag (Zellers al., 2019). For code reasoning, we choose Livecodebench (Jain et al., 2024) and CLRS (Markeeva et al., 2024). For multi-hop QA reasoning, we choose HotpotQA (Yang al., 2018) and PApQA (Mallen et al., 2022). For GPR benchmark, we choose GraphWiz (Chen et al., 2024a) and GraphInstruct (Luo et al., 2024). We collect these benchmarks and utilize them evaluate the models based on three GitHub projects: OpenCompass (Contributors, 2023), Qwen2.5-Math (Yang et al., 2024), and ZeroEval (Lin, 2024). See Appendix E.1 for details of base models, training and evaluation settings, and E.2 for details of evaluation datasets.
Mathematics
Models
GSMBK MinMath MATH
GSM-Hard SVAMP ASDIV MAWPS
STEM
TABMWP MATHQA SAT
Avg.
Gemma-2-2b
26.9
144
13.2
16.8
48.7
77.6
43.6
32.8
53.1
39.0
GraphP 1le
36.8
15.0
18.7
18.5
58.6
66.0
83.9
41.9
42.0
38.0
40.6
41.8
Llama-3-8b
54.2
17.0
16.5
26.1
68.8
73.1
90.9
49.7
57.9
27.7
56.2
48.9
GraphPile
65.8
21.6
24.0
29.3
78.9
79.5
91.6
56.1
50.6
41.0
53.1
53.8
Llaam-331188
54.4
20.4
17.7
27.1
71.0
74.3
92.0
57.0
63.6
44.9
59.4
52.9
GraphPile
66.0
23.6
24.1
30.9
78.4
79.6
92.0
56.4
59.2
53.1
59.4
56.6
Logic
Commonsense
Code
Multi-Hop QA
Graph Problem
Models
7ebra Puzzles Ruletaker ProofWriter
StrategyQA Hellaswag.
LCB CURS HotpotQA PopQA
GraphWiz Graphlastract
Avg.
Gemma 2-2b
3.4
8.8
59.3
27.2
0.2
16.9
21.2
27.4
34.6
16.8
19.8
CraphPile
0.5
20.5
6.0
99.4
30.6
1.3
37.9
41.0
28.2
54.8
62.8
31.2
Llama-3-8b
10.0
22.8
25,0
66.2
48.3
2.9
3.3
25.8
21.6
45
35.2
21.8
GraphPile
24.0
43.1
41.6
69.7
52.8
6.9
69.9
26.0
32.2
49.9
70.8
42.4
1amma-3.1-bb
18,0
35.3
29.8
58.9
48.7
1.6
3.3
43.6
40.0
1.9
33.0
28.6
1 CraphPste
$4.0
61.1
40.9
69.6
53.6
12.5
5.6
46.4
47.0
52.2
74.9
45.1
Table 3: Main results on mathematical benchmarks (top) and other benchmarks (bottom), where LCB represents Livecodebench.
3.2 Main Results
We evaluate the performance of GraphMind and baseline models on 20 benchmarks across four reasoning domains. From Table 3, we can draw an overall conclusion: leveraging GraphPile enhances both foundational reasoning capabilities and generalization reasoning abilities. Regarding foundational reasoning capabilities, when trained on graph problem reasoning data, the three versions of GraphMind achieve best average improvement of 53.1% % compared to the baseline, demonstrating the effectiveness of GraphPi le in improving the graph problem reasoning abilities of LLMs. In terms of generalization capabilities, the improvements as follows: for math reasoning, the best average improvement is 4.9%; for logical reasoning, it is 33.4%; for commonsense, it is 7.8%; for code reasoning, it is 46.3%; and for multi-hop QA, it is 10.3%. As illustrated in Figure (a), graph problem reasoning includes various reasoning patterns. This is why our constructed graph problem reasoning dataset can enhance model performance not only on graph-related tasks but also on mathematical and other reasoning tasks, thereby improving the model's overall generalization ability. The detailed results for each task in the GPR dataset are provided in Table 7 in Appendix E.3. Furthermore, we conduct statistical significance tests in Appendix E.4.
3.3 Post-Training
To show the performance improvements of GraphMind through post-training, select three versions of GraphMind, along with their base models for fine-tuning on GraphWiz, GSM8K, and MATH.
8

---

Published as a conference paper at COLM 2025
Legta MAMEUEES
413
Dar
D104 RC84
2000
Deto:Prse 1200
0513
1.
Figure Model performances with scaling GraphPile size. Here, we report average results of different reasoning tasks.
Quesboon Predict the internediaal eerreeitate states and tinal outcomes of specified vanables during the execution of algonthm. Please provide the output corresponding to the following input:
input(insertion sort.key: [0.421 0.557 0.861 0. 0.7)7, initial trace: [0.421 0.537 0.861 0.727])
trace pred:
Outout: Output the answer in the same foraa as the examples.
(A) Output (Llama3-88 -BBbess)::
(B) Output (GraphMind):
Input:
Lets run the function insertion sort(key) to solve this problem.
insertion sort:
Initial values: key: [0.421 0.537 0.861 0.727].
key: (0.421 0.557 0.861 0.727]
Call insertion sort[ (ott(00421 0.1 0.557 0.861 0.727]);
initial trace: [0.898 0.77 0.357 0.622]
key: 0.421. Since the
empty or the current element is the
Irace pred:
first one, we do nothing.
Output:
list not emply and current element not the first one, we insert 0,557 into the list.
key: 0.557. Since
[0.421 0.557 0.861 0.727].
[0.557 0.421 0.861 0.727
trace pred: pred: [0 421 0.557] [0 0.557].
[0.421 0.557 0.861 0.727
kee: 0.861. Since the list
empty and the current element is
[0.557 0.421 0.861 0.727].
not the first one, we insert 8.86 into the list.
[0.421 0,557 0.861 0.727]
trace pred: [0.421 0.537 0,861] [00421 0.557 0.861].
[[0.421 0.557 0.861 0.727]
- key: 0.727. Since the list is not emply and the current element is not the first one, we insert 0.727 into the list.
Wrong
Correct
trace pred: [0.421 0.557 0.861 0.727] [0.421 0.557 0.727 0.861)
Figure 5: A comparative case between Llama3 and ours in CLRS dataset.
Table 4 shows that GraphMind out- performs base models in both graph reasoning and math tasks across all configurations. Notable perfor- mance gains are observed in smaller models like Gemma-2, which shows increase of around 7 points in graph reasoning. Similarly, GraphMind demonstrates substan- tial improvements in mathematical tasks, with the highest performance improvement of 9.7% for Llama-3-8b on GSM8K and 2.4% for Alama-33.1880 on MATH. The results highlight that GraphPile en- hances LLMSs' post-training potential.
Models
GraphWiz
GSMSK
MATH
Gemma-2-2b
34.9
37.4
12.4
+ GraphPile
42.0
61.0
16.2
Llama-3-8b
32.2
67.4
18.6
+ GGaphPile
36.3
77.1
20.4
Llama-3.1-8h
44.1
71.7
21.6
+ GraphPile
53.8
73.0
24.0
Table 4: Comparison between post-training ver-
sions of base models and CPT models.
3.4 Ablation Studies
We further conduct ablation studies to explore the model performances: (1) when scaling the training dataset size, (2) when removing different components, and (3) when conducting continue-pretranning on stronger base LLMs.
Scaling the Training Dataset Size. We sample 20% 100% of the data from GraphPile to continue-pretranl GraphMind, resulting in five variants. These variants, along with Gemma-2- 2b, are tested on evaluation datasets grouped by mathematical reasoning, logical reasoning, commonsense reasoning, code reasoning, and graph problem reasoning. The results for each group are averaged to represent the model's performance on each type of reasoning dataset. The experimental results in Figure 4 demonstrate that (1) when the amount of data is 20%, GraphMind performs similarly to its base model, Gemma-2-2b, beyond graph problem reasoning, as the small amount of data insufficient for the model to learn generalized reasoning capabilities; (2) as the data scale increases, Gr GraphMind shows better performance on all reasoning paradigm and gradually surpasses the base model. This illustrates the effectiveness of GraphPin ile and the scalability of GrahhMind.
other reasoning domains

---

Published as a conference paper at COLM 2025
Removing Different Compo- nents. We remove different components of GraphPile to create four reduced datasets: w/o CoT, w/o PoT, w/o RW, and w/o ToE. Using these four datasets, as well as the full dataset, we train GraphMind. Table 5 presents the experimental results. Overall, we observe that the absence of data from a specific domain generally leads to performance degradation. Interestingly, we also find that the w/ /o RW dataset improves performance on mathematical and logical reasoning tasks. This is likely because these two domains lack real-world scenarios, making real-world data less beneficial for training the model in these areas
Models
Math
GPR
Logical
Code
Com.S
GraphMind
41.8
58.8
9.0
19.9
45.0
w/o CoT
41.0
49.8
5.6
17.9
44.7
w/o PoT
40.8
56.3
6.7
16.2
45.6
w/o RW
41.9
57.3
9.1
19.5
43.1
w/o IoE
40.2
53.9
4.8
9.7
44.9
Table 5: Performances when removing different data types. Com.S, RW refer to commonsense reasoning and Real-World Graph Data.
Mathematical Reasoning
Logical Reasoning
Graph Problem Reasoning
Model
GSMSK MMLU-STEM
SAT
Avg.
Zebra Puzzle
KorBench
Avg.
GraphWiz
GraphInstruct
Avg.
Qwen-2.5-Cdder-1.55
99.8
32,9
59.4
50.7
1.9
16.8
9.4
30.3
25.1
27.7
+ GraphPPle
63.4
43.3
71.9
99.5
5.7
18.3
12.0
48.6
46.1
47.4
Qwen-2.5-Codeee
77.9
67.2
81.2
754
3.9
32.1
18.0
38.5
34.4
36.5
+ GraphPile
81.0
68.3
87.5
79.0
33.3
19.1
54.3
50.3
52.3
Table 6: Performance of Qwen-2.5-Coder Models with and without GraphPile on Mathmati- cal Reasoning, Logical Reasoning, and Graph Problem Reasoning Benchmarks.
Continue-pretrainine on Stronger LLMs. We further conduct continue- two stronger base models, Qwen-2.5--odder-1.BB and Qwen-2.5-Coder-77, assess the more capable architectures. We evaluate these base models
effectiveness of GraphPile across three categories of reasoning benchmarks: (1) mathematical reasoning (GSM8K, MMLU-Stem, and SAT), (2) logical reasoning (Zebra Puzzle and KorBench), and (3) graph problem reasoning (Graphwiz and GraphInstruct) The evaluation results are summarized in Table 6. Our analysis demonstrates that continueprretainingg performance improvements across all evaluation Momains-incluuing both in-domain (graph reasoning) and out-of-domain (mathematical and logical reasoning) tasks for all examined models. Specifically, Twen-2.5-Coders. and 19.7 points over its base model on mathematical, logical, and graph reasoning tasks, respectively. Similarly, the same task categories. These consistent improvements across different model scales provide compelling evidence that GraphPile enhances performance not only for weaker base models but also for more powerful ones.
GraphPile leads to
achieves improvements of 8.8, 2.6,
1ieen225-Coder-22 exhibits gains of 3.6, 1.1, and 15.8 points across
Case Study. Additionally, we present an example from the CLRS dataset involving an insertion sort problem, where GraphMind produces correct answers while the base model provides incorrect responses, as shown in Figure 5. We observe that, compared to the base model, GraphMind's responses include more detailed intermediate steps-such as highlight- ing the current sorting element and explaining the rationale behind each w effectively omitting irrelevant information, such as extraneous input details. Further exam- ples can be found in Appendix E.5.
4 Conclusion
We present GraphPile, 10.9B-token dataset with 23 graph tasks to enhance LLM reasoning, By pretraining three LLMs on it, we develop the GraphMind series, which improves base models by up to 4.9% (math) and 21.2% (other tasks). The Gemma version fine-tuned GSM8K achieves 23.6% higher accuracy, demonstrating strong post-training potential. Our results show Graph Problem Reasoning effectively boosts LLMs'' general reasoning.
10

---

Published as a conference paper at COLM 2025
Acknowledgements
This work is supported by NSFC Grant No.62206067. addition, we express our sincere gratitude the Baidu Scholarship 2024 for its substantial support in facilitating this research endeavor.
References
Aida Amini, Saadia Gabriel, Peter Lin, Rik Koncel-Kedziorski, Yejin Choi, and Hannaneh Hajishirzi. Mathqa: Towards interpretable math word problem solving with operation- based formalisms. Xrv preprint ar arXio:1905.13311 2019.
Zhangir Azerbayev, Hailey Schoelkopf, Keiran Paster, Marco Dos Santos, Stephen McAleer, Albert Q Jiang, Jia Deng, Stella Biderman, and Sean Welleck. Llemma: An open language model for mathematics. arXiv preprint arXto:2310.10631, 2023.
Christian Bizer, Jens Lehmann, Georgi Kobilarov, Sören Auer, Christian Becker, Richard Cyganiak, and Sebastian Hellmann. Dbpedia-a crystallization point for the web of data. Journal of web semantics, 7(3):154-165, 2009.
Nuo Chen, Yan Wang, Haiyun Jiang, Deng Cai, Yuhan Li, Ziyang Chen, Longyue Wang, and Jia Li. Large language models meet harry potter: A dataset for aligning dialogue agents with characters. In Findings of the Association for Computational Linguistics: EMNLP 2023, pp. 8506-8520, 2023a.
Nuo Chen, Yuhan Li, Jianheng Tang, and Jia Li. Graphwiz: An instruction-ffllowinn language model for graph problems. ar Xiviv preprint ar arXiv:2402.1602, 2024a.
Nuo Chen, Ning Wu, Jianhui Chang, Linjun Shou, and Jia Li. Controlmath: Controllable data generation promotes math generalist models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pp. 12201-12217, 2024b.
Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. Xiv preprint ar 2ttb:22211.15588 2022.
Zeming Chen, Alejandro Hernández Cano, Angelika Romanou, Antoine Bonnet, Kyle Matoba, Francesco Salvi, Matteo Pagliardini, Simin Fan, Andreas Köpf, Amirkeivan Mohtashami, et al. Meditron-70b: Scaling medical pretraining for large language models. arviv preprint ar Xrxiv:2311. 160799 2023b.
Peter Clark, Oyvind Tafjord, and Kyle Richardson. Transformers as soft reasoners over language. arXiv preprint arXiv:2002.05867, 2020.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reicchir Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. CoRR, abs/2110.14169, 2021a.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021b. URL https://arxiv.org/abb///
14168.
OpenCompas Contributors. Opencompass: A universal evaluation platform for foundation 2023.
models.
Debarati Das, Ishaan Gupta, Jaideep Srivastava, and Dongyeop Kang. Which modality should i use-text, motif, image?: Understanding graphs with large language models. arxiv preprint ar fft::2311.09622 2023.
Paul Erdös, Alfréd Rényi, et al. On the evolution of random graphs. Publ, math. inst. hung. acad. sci, 5(1):17-60, 1960.
11

---

Published as a conference paper at COLM 2025
Bahare Fatemi, Jonathan Halcrow, and Bryan Perozzi. Talk like a graph: Encoding graphs for large language models. arviv preprint arXio:2310.045500 2023.
Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: Program-aided language models. arXiv preprint (tXXiv2211.10435, 2022.
Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. Did aristotle use a laptop? question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9:346-361, 2021.
Chang Gong, Wanrui Bian, Zhijie Zhang, and Weiguo Zheng. Pseudocode--njecctonn magic: Enabling ilms to tackle graph computational tasks. arviv preprint arXiv:2501.13731, 2025.
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. ar Xiv preprint ar Xfio:2407.21788, 2024.
Suriya Gunasekar, Yi Zhang, Jyoti Aneja, Caio César Teodoro Mendes, Allie Del Giorno, Sivakanth Gopi, Mojan Javaheripi, Piero Kauffmann, Gustavo de Rosa, Olli Saarikivi, et al. Textbooks are all you need. arviv preprint ar Xix:2230611164: 2023.
Jiayan Guo, Lun Du, Hengyu Liu, Mengyu Zhou, Xinyi He, and Shi Han. Gpt4graph: Can large language models understand graph structured data? an empirical evaluation and benchmarking. arXiv preprint ar arXiv:2305.11 15066, 2023,
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding, 2021a. URL https://arxiv.orge www./rs///////oo/o 2009/ 03300.
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, 2021b. URL https://arxix: htt..oor///bbb//..eeeee
Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Ar- mando Solar-Lezama, Koushik Sen, and lon Stoica. Livecodebench: Holistic and contami- nation free evaluation of large language models for code. arXiv preprint arXiv:2403.07974 2024.
Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv preprint ar Xix::1667.01759, 2016.
Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C Berg, Wan-Yen Lo, et al. Segment anything. arv preprint ar Xiv:22004.0026 2023.
Rik Koncel-Kedziorski, 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.
Michael Ley. The dblp computer science bibliography: Evolution, research issues, perspec- tives. In International symposium on string processing and information retrieval, pp. 1-10. Springer, 2002.
Xin Li, Weize Chen, Qizhi Chu, Haopeng Li, Zhaojun Sun, Ran Li, Chen Qian, Yiwei Wei, Zhiyuan Liu, Chuan Shi, et al. Can large language models analyze graphs like professionals? a benchmark, datasets and models. ar Xiv preprint ar arXiv:2409.188 19607, 2024a.
Xin Li, Qizhi Chu, Yubin Chen, Yang Liu, Yaoqi Liu, Zekai Yu, Weize Chen, Chen Qian, Chuan Shi, and Cheng Yang. Graphteam: Facilitating large language model-based graph analysis via multi-agent collaboration. Xiv preprint ar arXio:2410. 18032, 2024b.
12

---

Published as a conference paper at COLM 2025
Bill Yuchen Lin. ZeroEval: A Unified Framework for Evaluating Language Models, July 2024. URL
Bill Yuchen Lin, Ronan Le Bras, Kyle Richardson, Ashish Sabharwal, Radha Poovendran, Peter Clark, and Yejin Choi. Zebralogic: On the scaling limits of Ilms for logical reasoning, 2025. URL httts:://rxiv..ot http://w.wrr//bb////ee// 01100.
Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. Program induction by rationale generation: Learning to solve and explain algebraic word problems. arXiv preprint #xXii:1705.04446, 2017.
Pan Lu, Liang Qiu, Kai-Wei Chang, Ying Nian Wu, Song-Chun Zhu, Tanmay Rajpurohit, Peter Clark, and Ashwin Kalyan. Dynamic prompt learning via policy gradient for semi-structured mathematical reasoning. arviv preprint ar Xiv::2209.1444 14610, 2022.
Zimu Lu, Aojun Zhou, Ke Wang, Houxing Ren, Weikang Shi, Junting Pan, Mingjie Zhan, and Hongsheng Li. Mathcoder2: Better math reasoning from continued pretraining model-translated mathematical code. Xiv preprint ar Xiv:24400008196 2024.
Zihan Luo, Xiran Song, Hong Huang, Jianxun Lian, Chenhao Zhang, Jinqi Jiang, Xing Xie, and Hai Jin. Graphinstruct: Empowering large language models with graph understand- ing and reasoning capability. arviv preprint arXiv:2403.04483, 2024.
Alex Mallen, Akari Asai, Victor Zhong, Rajarshi Das, Daniel Khashabi, and Hannaneh Hajishirzi. When not to trust language models: Investigating effectiveness of parametric and non-parametric memories. ar Xiv preprint 1xXi::2212.10511, 2022.
Larisa Markeeva, Sean McLeish, Borja lbarz, Wilfried Bounsi, Olga Kozlova, Alex Vitvitskyi, Charles Blundell, Tom Goldstein, Avi Schwarzschild, and Petar Veličković. The clrs-text algorithmic reasoning language benchmark. arXiv preprint ar Xxix:2406.00229, 2024.
Shen-yun Miao, Chao-Chun Liang, and Keh-Yih Su. A diverse corpus for evaluating and developing English math word problem solvers. In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel Tetreault (eds.), Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 975-984, Online, July 2020. Association for Computational Linguistics. doi: 10.18653/v1 a2020/..c// mcl-main.9.. acl-main.92//
URL htttt::/aclanttiiiieee http///aaaaaalooyoaoooo/o org//020.
Maho Nakata and Tomomi Shimazaki. Pubchemqe project: a large-scale first-principles electronic structure database for data-driven chemistry. Journal of chemical information and modeling, 13000:130- 2017.
OpenFlights. https:/ httpss///opeflightssooom
Accessed: 2024-05-25.
Arkil Patel, Satwik Bhattamishra, and Navin Goyal. Are nlp models really able to solve simple math word problems?, 2021. URL https: ab1/ 07191.
Miao Peng, Nuo Chen, Zongrui Suo, and Jia Li. Rewarding graph reasoning process makes Ilms more generalized reasoners. arxiv preprint ar arXio:2503.00845, 2025.
Ryan A. Rossi and Nesreen K. Ahmed. The network data repository with interactive graph analytics and visualization. In AAAI, 2015.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. Xr preprint ar arXio:2402.03300 2024.
Hongda Sun, Weikai Xu, Wei Liu, Jian Luan, Bin Wang, Shuo Shang, Ji-Rong Wen, and Rui Yan. Determlr: Augmenting llm-based logical reasoning from indeterminacy to determinacy. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 9828-98288 2024.
13

---

Published as a conference paper at COLM 2025
Oyvind Tafjord, Bhavana Dalvi Mishra, and Peter Clark. Proofwriter: Generating im- plications, proofs, and abductive statements over natural language. arXiv preprint (rXiv:2012.13048, 2020.
Jianheng Tang, Qifan Zhang, Yuhan Li, and Jia Li. Grapharena: Benchmarking large language models on graph computational problems. arXiv preprint arXiv:2407.00379 2024.
Gemma Team, Cassidy Hardin, Robert Dadashí, Surya Bhupatiraju, Laurent Sifre, Morgane Riviere, Mihir Sanjay Kale, Juliette Love, Pouya Tafti, Léonard Hussenot, et al. Gemma. 2024. doi: 10.34740. Technical report, KAGGLE/M/330L. URL https://wwe /www. kaggle. com/m/330
Heng Wang, Shangbin Feng, Tianxing He, Zhaoxuan Tan, Xiaochuang Han, and Yulia Tsvetkov. Can language models solve graph problems in natural language? In Thirty- secenth Conference on Neural Information Processing Systems, 2023a.
Jianing Wang, Junda Wu, Yupeng Hou, Yao Liu, Ming Gao, and Julian McAuley. In- structgraph: Boosting large language models via graph-centric instruction tuning and preference alignment. arxiv preprint xrXiv:2402.08775, 2024a.
Ke Wang, Houxing Ren, Aojun Zhou, Zimu Lu, Sichun Luo, Weikang Shi, Renrui Zhang, Linqi Song, Mingjie Zhan, and Hongsheng Li. Mathcoder: Seamless code integration in llms for enhanced mathematical reasoning. arXiv preprint arXiv:2310.0373: 2023b.
Peiyi Wang, Lei Li, Zhihong Shao, RX Xu, Damai Dai, Yifei Li, Deli Chen, Yu Wu, and Zhifang Sui. Math-shepherd: Verify and reinforce ilms step-by-step without human annotations. Xiv preprint xrXi::2312.088 2023c.
Rongzheng Wang, Shuang Liang, Qizhi Chen, Jiasheng Zhang, and Ke Qin. Graphtool- instruction: Revolutionizing graph reasoning in lims through decomposed subtask in- struction. arXiv preprint ar Arx::22412.122
2024b.
Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. Self-instruct: Aligning language model with self generated instructions, 2022.
Zengzhi Wang, Xuefeng Li, Rui Xia, and Pengfei Liu. Mathpile: A billion-token-scall pretraining corpus for math. In The Thirty-eight Conference Neural Information Processing Systems Dalasets and Benchmarks Track.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V
Le, Denny Zhou, et al. -hain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35:24824-24883 2022.
Chaoyi Wu, Weixiong Lin, Xiaoman Zhang, Ya Zhang, Weidi Xie, and Yanfeng Wang. Pmc- Ilama: toward building open-source language models for medicine. Journal of the American Medical Informatics Association, pp. ocae045, 2024a.
Qiming Wu, Zichen Chen, Will Corcoran, Misha Sra, and Ambuj K Singh. Grapheval2000: Benchmarking and improving large language models on graph datasets. arXiv preprint (xXi:22006166766 2024b.
Zeqiu Wu, Yushi Hu, Weijia Shi, Nouha Dziri, Alane Suhr, Prithviraj Ammanabrolu, Noah A Smith, Mari Ostendorf, and Hannaneh Hajishirzi. Fine-grained human feedback gives better rewards for language model training. Advances in Neural Information Processing Systems, 36:59008 -90080599333..1101 2023.
An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jianhong Tu, Jingren Zhou, Junyang Lin, et al. Qwen2. 5-math technical report: Toward mathematical expert model via self-improvement. arv preprint ar arXit:2409.12122 2024.
Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William W Cohen, Ruslan Salakhutdi- nov, and Christopher D Manning. Hotpotqa: A dataset for diverse, explainable multi-hop question answering. aixiv preprint ar 11t9::80009900 2018.
14

---

Published as a conference paper at COLM 2025
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Adoances in neural information processing systemss, 36:11809-11822 2023.
Huaiyuan Ying, Shuo Zhang, Linyang Li, Zhejian Zhou, Yunfan Shao, Zhaoye Fei, Yichuan Ma, Jiawei Hong, Kuikun Liu, Ziyi Wang, al. Internlm-math: Open math large language models toward verifiable reasoning. arXiv preprint ar Xri::22402.06332, 2024.
Chenyu You, Nuo Chen, Fenglin Liu, Shen Ge, Xian Wu, and Yuexian Zou. End-to-end spoken conversational question answering: Task, dataset and model. In Marine Carpuat, Marie-Catherine de Marneffe, and Ivan Vladimir Meza Ruiz (eds.), Findings of the Associa- fion for Computational Linguistics: NAACL 2022, pp. 1219-1232, Seattle, United States, July 2022a. Association for Computational Linguistics. doi: 10.18653 20/5/3/11/222...// fin2222.inningg--aadd 91. URL httpp:://claame
naacingg--nall...
Chenyu You, Nuo Chen, Fenglin Liu, Shen Ge, Xian Wu, and Yuexian Zou. End-to-end spoken conversational question answering: Task, dataset and model. In Findings of the Association for Computational Linguistics: NAACL 2022, pp. 1219-1232, 2022b.
Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can machine really finish your sentence? arXiv preprint Xiiv:1905.00830) 2019.
Qifan Zhang, Xiaobin Hong, Jianheng Tang, Nuo Chen, Yuhan Li, Wenzhong Li, Jing Tang, and Jia Li. Gcoder: Improving large language model for generalized graph problem solving, ar preprint ar arXi::2410.19084 2024a.
Yizhuo Zhang, Heng Wang, Shangbin Feng, Zhaoxuan Tan, Xiaochuang Han, Tianxing He, and Yulia Tsvetkov. Can 11m graph reasoning generalize beyond pattern memorization? arv preprint ar Xix::2006.11555 1.5992, 2024b.
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. arxiv preprint ar Xrx::2304.06364 2023.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Claire Cui, Olivier Bousquet, Quoc Le, et al. Least-to-most prompting enables complex reasoning in large language models. arXiv preprint arXio:2205.10625, 2022.
A Related Works
LLMs for graph problem reasoning. Leveraging large language models (LLMs) for graph problem reasoning has emerged as prominent area of research. To advance this field, researchers have introduced a variety of benchmarks designed to evaluate the graph prob- lem reasoning capabilities of LLMs (Wu et al., 2024b; Tang et al., 2024; Li et al., 2024a; Das et al., 2023; Fatemi et al., 2023; Guo et al., 2023). Building on these benchmarks, various approaches have been proposed to enhance LLMs' graph problem reasoning capabilities. These methods can be broadly categorized into the following paradigms: (1) Chain-of- Thought (CoT): This paradigm leverages step-by-step reasoning processes improve LLM performance, as demonstrated in several studies (Chen et al., 2024a; Luo et al., 2024). (2) orogram-of-Thhughee
(PoT)): This paradigm involves teaching LLMs to generate code for solving graph-related problems (Zhang et al., 2024a; Li al., 2024b; Wang et al., 2024b; Gong et al., 2025). In this work, we introduce a novel paradigm, Trace of Execution (ToE), which leverages
representations of the algorithmic execution process. Our dataset integrates three paradigms- CoT, PoT, and ToE- to enhance the reasoning capabilities of LLMSs in graph problems and other domains.
15

---

Published as a conference paper at COLM 2025
Continue-pertaining methods have been widely used in improving LLMs' reasoning capabilities in specific domains such as mathmatics (Shao et al., 2024; Azerbayev et al., 2023; Ying et al., 2024; Yang et al., 2024; Wang et al.; Gunasekar et al., 2023; Lu et al., 2024), medicine (Chen et al., 2023b; Wu et al., 2024a), and algorithms (Markeeva et al., 2024). By continue-pretranning to handle domain-specific terminology, concepts, and patterns, making it more effective for specialized tasks. For instance, DeepSeekMath (Shao al., 2024) and Qwen-Z.5-Math (Yang et al., 2024) leverage fastText (Joulin et al., 2016) and other meta-information to retrieve texts from the Common Crawl dataset. MathPile (Wang al.) and Phi (Gunasekar et al., 2023) utilize real or synthesized textbooks to improve LLMs' mathematical reasoning capabilities. MEDITRON (Chen al., 2023b) employs a meticulously curated medical corpus, including selected PubMed articles, abstracts, and internationally recognized medical guidelines. However, no prior work has focused on utilizing graph problem corpus for pre-training, To fill this gap and further enhance the reasoning capabilities of LLMs, we, for the first time, propose a graph problem-based training corpus aimed at improving LLMs' reasoning abilities across graph-related tasks, mathematics, and other domains.
Continue-Pretranning.
well-curated corpus, the model enhances its ability
B Additional Definition
B.1 Task Definitions
In this section, we present the remaining graph problems that were not introduced in Section 2.1.
PageRank. This task involves assigning a score to each node in graph = = (V,E) that represents the relative importance of the node within the graph. The PageRank of node is determined based on the structure of incoming edges, where nodes with more incoming links from important nodes are assigned higher scores. The computation of PageRank iteratively updates the score of each node using the formula:
PR(u) OutDegree(u)
PR(v) = (1 - a) +
Σ
MEIn(D)
where a is the damping factor (typically set to 0.85), In(v) is the set of nodes linking to v, and OutDegree is the number of outgoing edges from node u. The process continues until the scores converge to a stable distribution.
Graph Traversal. Graph traversal is the process of systematically visiting all the vertices and/or or edges in graph g = (V,E). The goal of traversal is to explore the structure of the graph, ensuring that every vertex (and possibly every edge) is visited exactly once under certain traversal rules.
Degree Counting. The degree of node E V in graph G (V,E) is the number of edges connected to v. For directed graphs, the in-degree is the number of incoming edges to v, and the out-degree is the number of outgoing edges from
Jaccard Coefficient. For graph = (V,E), the Jaccard Coefficient between two nodes u, V E V is measure of the similarity of their neighborhoods. It is defined as the ratio of the size of the intersection of their neighbor sets to the size of the union of their neighbor sets. Formally, the Jaccard Coefficient is given by:
[W(u) J(u, v) [N(m)
where (x) denotes the of neighbors of node x. The value of [(u, v) lies in the range [0, 1), with higher values indicating greater similarity.
Edge Check. In graph G (V,E), the edge check determines whether there exists an edge between two nodes ıt v V. For undirected graphs, check if (u, v) E or (v, u) E; for directed graphs, check if (u, v) E.
16

---

Published as a conference paper at COLM 2025
Neighbor. In graph (V,E), node is neighbor of node V if there is an edge between u and v. For undirected graphs, this means (u,v) or (0,u) &. For directed graphs, this means (u,v) E E.
Predecessor. In directed graph 9 (V,E), a node и E V is a predecessor of node V if there exists directed edge (u, &.
Diameter. In graph 9 = (V, E), the diameter is the longest shortest path between any two nodes. Formally, it is defined as:
Diameter(G) max d (u, v), u
where d(u, v) is the shortest path distance between nodes u and v. For disconnected graphs, the diameter typically considered infinite.
Minimum Spanning Tree (MST). In weighted, connected, undirected graph
g (V,E), a Minimum Spanning Tree is subset of edges E' C that:
1. Connects all vertices in (forms a tree).
2. Minimizes the total edge weight:
Weight(E')=
E w(u,v),
(u.v)E
where w(u, o) the weight of the edge (u,
Maximum Triangle Sum. Given weighted graph G EV, where R+ is a function assigning a positive weight to each node, the task involves finding triangle, cycle of three connected vertices (11, 12 V3), that maximizes the weight sum (011 + +1(02) +(vz)
Clustering Coefficient. Given a graph g = (V,E), the clustering coefficient of node E V is defined
the ratio of the number of triangles containing v the total number of possible triangles that could include v, measuring the tendency of o's neighbors to form a clique.
Euler Path. An Euler path in graph G (V,E) is path that visits each edge in the graph exactly once. A graph has an Euler path if and only if it is connected and has exactly zero or two vertices with odd degree.
Planarity Testing, Given a graph G = EV,E), the planarity testing problem seeks to determine whether & can embedded in the plane without any edges crossing. A graph is planar if and only if it can be drawn such that no two edges intersect except at their endpoints. Formally, G is planar there exists mapping of to points in the plane and & to non-intersecting curves connecting the corresponding points.
C Prompt Showcase
In this section, we provide examples of prompts for building GraphPile, including Chain- of-Thought Data, Real-World Graph Data, and Sograam-of-Thougeee Data.
C.1 Chain-of-Thought Data
Prompts C.1: An Example of LLM Rehearsal Prompt
You are provided with the following information:
1, A graph problem.
2. The answer to the problem.
3. Specific requirements for solving the problem.
Your task is to solve the problem step by step and present the solution in the required format. Make to follow these instructions:
17

---

Published as a conference paper at COLM 2025
1. Begin your response with "Let's think step by step:".
Solve the problem systematically to find the answer. Do not attempt to verify the provided answer, instead, focus deriving and presenting the solution.
3. Ensure your explanation clear, concise, and adheres to the required format.
Here is relative information:
Problem: (Problem)
Answer: (Answer)
Requirement: (ement)ement]
Prompts C.2: An Example of LLM Examination Prompt
You are provided with the following information:
1. A graph problem.
2. The solution to the problem: al.
3. The reasoning process for solving this problem concludes with the answer a2.
Your task is to determine whether the solution aligns with the answer a2 de- rived from the reasoning process. If they align, output 'Yes'; otherwise, output 'No'. Only output 'Yes' or 'No' without providing any explanation.
Here is relative information:
Problem: (Problem)
Solution: [Solution]
Reasoning Process: (Reasoning Process}
C.2 Real-World Graph Data
Prompts C.3: An Example of LLM Rephrasing Prompt
You are provided with the following inputs:
(1) A graph described in natural language.
(2) A graph problem.
(3) A real-world domain.
Your task is to map the nodes in the graph and the graph problem to meaningful, real-world names within the specified domain. Output the rephrased graph and graph problem.
Here is relative information:
Graph: [Graph]
Problem: (Problem)
Domain: [Domain]
Prompts C.4: An Example of LLM Filtering Prompt
You are provided with the following information:
1, An original problem and answer pair involving a graph with numerical node ID.
2. A rephrased problem and answer pair involving graph with real-world node ID.
Your task is to verify whether the nodes and edges in the original problems and answers correspond one-to-one with those in the rephrased problems and answers. If they correspond, output True; otherwise, output False. Only output True False without providing any explanation.
Here is relative information: Original Problem: (Original Problem)
18

---

Published as a conference paper at COLM 2025
Original Solution: (Original Solution)
Rephrased Problem: [Rephrased Problem] Rephrased Solution: (Rephrased Solution)
C.3 Program of Thought Data
Prompts C.5: An Example of LLM Retrieval Prompt
You are provided with the following inputs:
(1) A graph problem described in natural language.
(2) A series of code documentations.
Your task is to generate Python code that directly solves the given graph problem. The output should only include the code itself, written in clear and functional manner. Do not provide any explanations or restatements of the problem.
Here is relative information:
Problem: (Problem)
Documentations: (Documentations]
Prompts C.6: An Example of LLM Rewrite Prompt
You are provided with Python code that solves specific graph problem. Your task is to rewrite the code while adhering to the following guidelines:
(1) Retain the original logic and functionality of the provided code.
(2) Introduce variations in the implementation, such as using different syntax, alternative
methods, or restructuring the code for improved readability or efficiency.
(3) Ensure the rewritten code is clean, functional, and adheres to best practices.
Output only the modified code. Do not include any explanations comments.
Here is relative information:
Code: (Code]
D Dataset Showcase
D.1 Details of the GraphPile Corpus
In this section, we provide a detailed description the GraphPile corpus, including: Chain-of-Thought Data, Real-World Graph Data, frogram-of-Thought Data, and Trace- of-Fxecution Data.
D.1.1 Chain of Thought Data
Examples D.1: An Example of the Cycle Detection Problem of Chain-of- Data
Determine whether not there is cycle in an undirected graph. In undirected graph, (i,j) means that node and node j are connected with an undirected edge. Given a graph, you need to output Yes No, indicating whether there is a cycle in the graph. Q: The nodes are numbered from 0 to 6, and the edges are: (0, 1), (0, 4), (0, 7), (0, 9), (1, 2), (1, 7), (1, 9), (2, 9), (3, 5), (3, 8), (5, 8), (7, 9), (8, 9). Is there a cycle in this graph?"
Input:
Output: Let's think step by step: To determine if there is a cycle in the given undirected graph, we can use Depth-First Search (DFS) approach. We will traverse the graph and keep track of visited nodes to
19

---

17, Published as a conference paper at COLM 2025
detect if we encounter a node that has already been visited and is not the parent of the current node, which would indicate the presence of a cycle.
1. Graph Representation: The graph has nodes numbered from 0 to 9, and the edges are:
(0, 1), (0, 4), (0, 7), (0, 9), (1, 2), (1, 7), (1, 9), (2, 9), (3, 5), (3, 8), (5, 8), (7, 9), (8, 9).
2. DFS Traversal: Start at node 0. Mark it as visited. From node O, visit node 1. Mark node as visited. From node 1, visit node 2. Mark node 2 as visited. From node 2, visit node 9. Mark node 9 visited. From node 9, we visit node 0, which is already visited and is not the parent of node 9 (the parent of node 9 is node 2). This indicates the presence of a cycle.
3. Cycle Detection: The cycle detected is 0 -> 1 1> 2~> 9-> 0. Since we have found cycle in the graph, the answer is: [Yes]
Examples D.2: An Example of the Shortest Path Problem of Chain-of- Clain-of-Thought Data
Input: Find the shortest path between two nodes in an undirected graph. In an undirected graph, (ijj.) means that node and node are connected with an undirected edge with weight k. Given a graph and a pair of nodes, you need to output the shortest path between the two nodes. Q: The nodes are numbered from 0 to 10, and the edges are: (0, 6, 4), (0, 6), (0, 12, 1), (0, 20, 1), (0, 21, 8), (1, 9), (1, 4, (1, 12, (1, 15, 2), (1, 17, 10), (1222244449999900000022222221114 (2,
(3, 18, 6), 14, 10), (8, 1 18, (8, 19, (10, (12, (12, 20, 2), (13, 17, 5), (15, 18, 9), (15, 20, 10), (16, 17, 4), (16, 20, 3), (18, 20, 8), 21, Give the weight of the shortest path from node 13 to node 14.
(7, 8), 1,, 18, (11, 18, (11, (1,
(10,
Output:
Let's think step by step:
1. Understand the Problem: We need to find the shortest path from node 13 to node 14 in the given undirected graph. The graph is represented by a list of edges, where each edge connects two nodes with a specific weight.
2. Identify Relevant Edges: First, we identify all edges connected to node 13 and node 14, as well as the edges that could potentially form a path between them. Node 13 is connected to nodes 3, 6, and 17. Node 14 is connected to nodes 7, 8, and 16.
3. Explore Possible P'aths: We explore possible paths from node 13 to node 14 by traversing
the graph and calculating the total weight of each path.
-Path 1: 13 17 -> 16 - 14- Edge 13-17 has weight of 5. Edge 17-16 has weight of 4. Edge 16-7 has a weight of 4. Edge 7-14 has a weight of 10. Total Weight: 5 + 4
1000=2
-Path 2: 13-> 6 - 17 16 - 7 7> 14- Edge 13-6 has a weight of 9. Edge 6-17 has a weight 7. 7 Edge 17-16 has a weight of 4. Edge 16-7 has a weight of 4. Edge 7-14 has
a weight of 10. - Total Weight: 9+7+4+4+4 10 34
Path 3: 13 - 3-> 17 16 7-> 1- Edge 13-3 has a weight of 9. -Edge 3-17 has a
weight of 1. -Edge 17-16 has a weight of Edge 16-7 has a weight of 4. Edge 7-14 has
a weight of -otal Weight: ++++++4 10= 10= 28
4. Determine the Shortest Path: Among the explored paths, Path 1 (13 ~ 17 16
14) has the lowest total weight of 23.
5. Conclusion: The shortest path from node 13 to node 14 has weight of 23.
Examples D.3: An Example of the Bipartite Checking Problem of Chain-of- Thought Data
Determine whether or not graph is bipartite. In a directed graph, (i->j) means that node i and node are connected with an directed edge from node to node j. Given a graph, you need to output Yes or No, indicating whether the graph is bipartite. Q: The nodes are numbered from 0 to 6, and the edges are: (0, 4), (0, 7), (0, 8), (0, 10), (0, 15), (0, 19), (0, 21), (1, 2), 5), (1, 8), (1, 10), (1, 13), (1, 16), (1, 19), (1, 21), (2, (2, 13), (2, 14), (2, 20), (3, 4), (3, 6), (3, 10), (3, 12), (3, 14), (3, 16), (3, 18), (3, 21), (4, 10), (4, 16), (4, 21), (5, 11),
Input:
20

---

Published as a conference paper at COLM 2025
(5, 12), (5, 13), (5, 212.0//06666..1./111///6/6666666 14), (7, 16), (7, 17), (7, 20), (7, 21), 14), 15), (8, 19), (8, 20), (8, 21), (9, (9, 18), (10, 12), (10, 16), (11, 12), (5), (11, 16), (11, 20), (12, 15), (12, 21), (13, 14), (13, 15), (13, 19), (13, 20), (13, 21), (14, 16), (14, 20), (14, 21), (15, 17), (15, 20), (15, 21). Is this graph
(1),,,,,111111
13),
15),
bipartite?
Output: Let's think step by step:
1. Understanding Bipartite Graphs: A graph is bipartite if its nodes can be divided into two disjoint sets U and V such that every edge connects node in U to node in V. This means no two nodes within the same set are adjacent.
2. Analyzing the Given Graph: The graph has nodes numbered from 0 to 21, and the edges are provided. To determine if the graph is bipartite, we need to check if we can assign each node to one two sets without having any edges between nodes in the same set.
Checking for Bipartiteness: Start by assigning node to set U. Since node is connected to nodes 7, 8, 10, 15, 19, and 21, these nodes must be assigned to set V. Now, consider node 4, which is connected to nodes O, 10, 16, and 21. Node 4 is already in set V, nodes 10, 16, and 21 must be in set U. However, node 10 is connected to node 4, which is in set V, So node 10 should be in set U. But node 10 is also connected to node 0, which is in set U. This creates a conflict because node 10 cannot be in both sets U and V. 4. Conclusion: The conflict arises because node 4 and node 10 are in the same set, which violates the bipartite condition. Therefore, the graph not bipartite. [No]
D.1.2 Real-World Graph Data
Examples D.4: An Example of the Diameter Problem of
Graph Data
You required to calculate the diameter of undirected knowledge graph. The diameter of a graph is the maximum distance between any pair of nodes in the graph. To compute this, you need to find the shortest path between all pairs of nodes and then determine the maximum length of these shortest paths.
Input:
*Problem to *o
Entities in this knowledge graph: Los Andes Chile, Renault 18, Isla de Maipo, Santa Isabel Córdoba The relationships between these entities are follows: Time in Chile is connected to Los Andes Chile via the relationship timeZone. - Time in Chile connected to Isla de Maipo via the relationship timeZone. Peugeot 505 is connected to Los Andes Chile via the relationship assembly. - Canada is connected to Renault 12 via the relationship assembly. Renault 12 is connected to Los Andes Chile via the relationship assembly. Renault 12 is connected to Santa Isabel Córdoba via the relationship assembly. Renault 12 is connected to Renault 18 via the relationship predecessor. Los Andes Chile is connected to Renault 18 via the relationship assembly. Renault 18 is connected to Santa Isabel Córdoba via the relationship assembly. Please determine the diameter of this network and output the corresponding path in the following format: [Entityl, Entity2, ..., EntityN].
Time in Chile, Peugeot 505, Canada, Renault 12,
Output: [Canada, Renault 12, Los Andes Chile, Time in Chile, Isla de Maipo]
Examples D.5: An Example of the Maximum Clique Problem of Real-Worke Graph Data
Input: You are required to solve the Maximum Clique Problem for undirected academic network. In this network, nodes represent authors and edges represent research collaborations. Your objective to find the largest subset of nodes such that every pair of vertices in this subset is connected by an edge.
21

---

Published as a conference paper at COLM 2025
"Problem to Solve**
Authors in the network: Mark S. Daskin, Zuo-Jun Max Shen, James F. Campbell, Mercedes Landete, Javier Alcaraz, Juan F. Monge, Alfredo Marin, José L. Sainz-Pardo- Research collaborations between these authors: Mark S. Daskin and Zuo-Jun Max Shen, Mark S. Daskin and Mercedes Landete, Mark S. Daskin and Juan F. Monge, Mark S. Daskin and José L.. Sainz-Pardo, Zuo-Jun Max Shen and Mercedes Landete, Zuo-Jun Max Shen and Juan F. Monge, Zuo-Jun Max Shen and José L. Sainz-Pardo, James F. Campbell and Alfredo Marin, James F. Campbell and Mercedes Landete, Mercedes Landete and Alfredo Marín, Mercedes Landete and Javier Alcaraz, Mercedes Landete and Juan F. Monge, Mercedes Landete and José L. Sainz-Pardo, Javier Alcaraz and Alfredo Marín, Javier Alcaraz and Juan F. Monge, Javier Alcaraz and José L. Sainz-Pardo, Juan F. Monge and Alfredo Marín, Juan F. Monge and José L. dainzoPardo, Alfredo Marín and José Sainz-Pardo. Identify the clique with the maximum number of authors in this network. Present your answer in the following format: [AuthorA, AuthorB, AuthorC, AuthorD, ...].
Output: [Mercedes Landete, Juan F. Monge, José L. Sainz-Pardo, Mark S. Daskin, Zuo-Jun Max Shen]
D.1.3 Program-of-Thoughh Data
22

---

Published as a conference paper at COLM 2025
Examples D.6: An Example of the Maximum Matching Problem of Program-of- Thought Data
Input: Find maximum matching in the bipartite graph. The graph is described as follows: {0: [6, 7, 8, 9, 10, 111, 1: [7, 8, 10], , 7,8, 9], [6, 8, 12], 4: [9, 111, [8, 11], [0, 2, 31, 7: [0, 1, 2,, 8: [0, 2, 3, 3, [0, 1, 4), 10: 10, 11, 11: I0, 51, 12: [3]]. Nodes
set 1 contains: node listl = [0, 1, 3]. Nodes set contains the remaining nodes except
mode_listi.
Output:
import re import networkx
# Graph description
graph "(0: [6, 7, 8, 9, 10, 11] 1:
07
8,
9,
18],
2:
[6,
7,
8, 9].
3: [6, 8, 12] 4: [9 111, 5:
[8
11]
6:
[0.
2,
31
7:
[0.
1, 2].
[0, 2, 3, 5]. 9: [0. 1, 2. 41.
[0.
11.
11:
4,
5], 12:
[3]]
# Regular expression to extract connections pattern (((x+)):\s<((+++)) matches re. f..finnall (pattern, graph)
# Create an undirected graph G nx ()aph
edges to the graph
for match in matches:
node = int (matchhh edges (int(edge) for edge in match ")]
for edge edges:
6. add_edge (node, edge)
# Define node_list nist_ [o.
3]
# Find maximum matching
print (nx. bipartite. maximum_matching (G, too_nodes=node_listt)
Examples D.7: An Example of the Pagerank Problem of Program-of-Thouge Data
Input: Which node has the largest PageRank value in the undirected graph where Node VEP is connected to nodes VLI, ULY; Node VLI is connected to nodes VEP, YTT, VWB, ULY; Node ULY is connected to nodes VEP, BZF, FHK, VLI; Node BZF is connected to nodes YTT, FHK, GUP, ULY; Node YTT is connected to nodes BZF, FHK, VLI, VWB; Node FHK is connected to nodes BZF, YTT, GUP, ULY, Node GUP is connected to nodes BZF, FHK, MOB; Node VWB is connected to nodes YTT, MOB, VLI; Node MOB is connected nodes GUP, VWB. The damping factor is alpha. The number of iterations is max iter. The initial PageRank values for all nodes are initialized equally as 1/N, where N is the number of nodes.
Output:
import re
import networkx as nx
Graph description
graph """Node VEP is connected to nodes VLI, ULY.
Node VLI is connected to nodes VEP, YTT VWB
ULY.
Node ULY is connected to nodes VEP, BZF FHK, VLI.
Node BZF is connected nodes YTT, FHK, GUP. ULY.
Node connected nodes BZF, FHK, VLI, VWB
23

---

Published as a conference paper at COLM 2025
Node FHK is connected to nodes BZF, , YTT, , GUP, ULY.
Node GUP is connected nodes BZF FHK , MOB.
Node VWB connected to nodes YTT, MOB VLI.
Node MOB is connected to nodes GUP, VWB. "nn
# Regular expression to extract connections
pattern r'Node (Nw+) is connected nodes? ((Aw, N+) matches = re. fe.dand (pattern, graph)
# Create undirected graph
G ()
# Add edges to the graph for node, neighbors in matches: neighbors neighbors s' () for neighbor in neighbors: addd__ddg (node, neighbor)
# Parameters alpha 0.85
max_iter 100
f Calculate PageRank
pr pagerank (G, alpha=alpha, max_iter=max_iter nstart=(node: 1/G. number_of_nodee for node in G. nodes ())) max_pagerank max (ax.pvallues values()) print (aa__aaeeraak
Examples D.8: An Example of the Minimum Spanning Tree Problem of Program-of- Thought Data
Output the total weight of the minimum spanning tree (MST) for the weighted undirected graph described follows: an undirected graph, the nodes are numbered from 0 to 18, and the edges are: an edge between node 0 and node 13 with weight 6, an edge between node 0 and node with weight 10, an edge between node 0 and node with weight 2, an edge between node 0 and node 14 with weight 3, edge between node 0 and node with weight 10, an edge between node and node with weight 9, an edge between node 0 and node 16 with weight 8, an edge between node 1 and node 13 with weight 8, an edge between node 1 and node with weight 4, an edge between node 1 and node with weight 3, an edge between node 1 and node with weight 6, an edge between node 2 and node 14 with weight 10, an edge between node and node with weight 3, an edge between node 2 and node 16 with weight 8, edge between node 3 and node 15 with weight 10, an edge between node 4 and node 13 with weight 2, an edge between node and node with weight 8, an edge between node and node 16 with weight 10, an edge between node 4 and node 15 with weight 5, an edge between node 4 and node with weight 2, an edge between node 5 and node 11 with weight 9, an edge between node 5 and node 16 with weight 4, an edge between node 6 and node 14 with weight 8, an edge between node 7 and node 11 with weight 7, an edge between node and node 9 with weight 10, an edge between node 8 and node 15 with weight 9, an edge between node
Input:
and node 13 with weight 3, edge between node 11 and node 18 with weight 6, an edge between node 11 and node 16 with weight 9, an edge between node 12 and node with weight 9, an edge between node 13 and node 18 with weight 8, edge between node 14 and node 15 with weight 7, an edge between node 16 and node 17 with 3.
and node with weight 5, an edge between node
Output:
import re
import networkx
24

---

Published as a conference paper at COLM 2025
graph "In an undirected graph, the nodes are numbered from 0 to 18, and the edges are: edge between node and node 13 with weight 6, an edge between node between node 0 and node with weight 2, an edge between node and node 14 with weight 3, an edge between node 0 and node 8 with weight 10,
node 11 with weight 10, an edge
edge between node and node 16 with weight 8, an edge between node and node 13 with weight 8, an edge between node 1 and node 8 with weight 4, an edge between node and node 4 with weight 3, an edge between node 1 and node 3 with weight 6, an edge between node 2 and node 14 with weight 10, weight 3, an edge between node and node
edge between node 0 and node with weight 9,
edge between node and node with
with weight 8, an edge between node 3 and node 15 with weight 10, an edge between node and node 13 with weight 2, an edge between node 4 and node 8 with weight 8, an edge between node and node 16 with weight 10, edge between node and node 15 with weight 5, an edge between node node with weight 2, an edge between node and node with weight 9, an edge between node 5 and node 16 with weight 4, an edge between node 6 and node 14 with weight 8, an edge between edge between node 8 and node with weight 10, an edge between node and node an edge between node 10 and node 14 with weight 5, an edge between node 11 and node 13 with weight 3, an edge between node 11 and node 18 with weight 6,
node 7 and node 11 with weight 7,
with weight 9,
edge between node 11 and node 16 with weight edge
9, edge between node 12 and node 15 with weight 9,
between node 13 and node 18 with weight 8, an edge between node 14 and node 15 with weight 7, an edge between node 16 and node 17 with weight 3."
Regular expression extract edges with weights pattern r'an edge between node (ld+) and node (ld+) with weight (1d+)
matches = re. findall (pattern, graph)
Create an undirected graph G nx. Graphh
Add edges with weights to the graph for node1, node2, weight matches: G. add__edg (int (node1), int (node2),
(werigght((ei)))
# Calculate the total weight of the minimum spanning tree (MST) T nx www.iimmnsppnnnng..te.. (G)
nst_edges_withh wit_wwighhh T. edges (data=True)
total_weight sum print (total (rint(ttoal__eighh))
sum(edg) (edge [2][ weight '] for edge in mst_eddes_withh
Examples D.9: An Example of the Common Neighbor Problem of Program-of Thought
Data
Input: Calculate the number of common neighbors of nodel and node2 in the undirected
graph described as follows: The nodes are numbered from 0 to 13, and the edges are: (0, 6) (0, 4) (0, 9) (0, 1) (0, 13) (0, 10) (0, 11) (1, 2) (1, 12) (1, 3) (1, (1, 6) (2, 5) (2, 13) (2, (2, 8) (7,
(2, 9) (2, 12) (3, 11) (3, 13) (3, 8) (4, 7) (5, 11) (5, 8) (5, 10) (6, 13) (6, 11) (6,
13) (8, 10) (9, 12) (9, 10) (10, 12) (10, 13) (11, 12) (12, 13).
Output: import re
import networkx as nx
Graph description
25

---

Published as a conference paper at COLM 2025
graph "The nodes are numbered from to 13, and the edges are: (e, 6)
4) (0, 9) (0,
(0, 13) (0, 10)
11) (1, 2) (1, 12) (1, 3)
(1, 9) (1, 6) (2, 5)
(2, 13) (2, 7) (2, (2, 9) (2, 12) (3, 11)
(3, 13) (3, 8) (4, 7) (5, 11) (5, 8) (5, 10) (6 13) (6 11) (6 7)
(6, 10) (7, 11) (8, 13) (8, 10) (9, 12) (9, 10) (10,
12) (18, 13)
(11, 12) (12, 13)."
Regular expression to extract edges pattern = r"X((Nd+), (ld+)))"
Create undirected graph Gr.pha
# Find all matches in the text
matches = re. frefainall (patterr, graph)
Add edges to the graph for i, j in matches:
6. (int in)(
Parameters node1 2
node2 =
Calculate common neighbors print (len (list (nx, common_neighbon (G, node1. node2))))
Examples D.10: An Example of the Maximum Flow Problem of Program-of-Thonn Data
Input: Calculate the maximum flow between nodel and node2 in this graph. The nodes are numbered from 0 to 6, and the edges are: (0->6,5) (1->6,5) (2->3,7) (3->4,8) (3->6,10) (4->5,2). Given directed graph with capacities assigned to its edges, the maximum flow from a source node to a sink node is the maximum amount of flow that can be sent from the source to the sink, respecting the capacity constraints on each edge. The goal to find the optimal way to route flow through the network to maximize the flow from source to sink.
Output: import re import networkx
Graph description
text = "The nodes are numbered from 0 to 6, and the edges are: (0->6,5) (1-26,5) (2->3,7) (3->4,8) (3->6, 10) (4->5,2).*
Regular expression extract edges with weights pattern = matches = re. findall (pattern, text)
Create directed graph G nx. DiGraph)
# Add edges with weights to the graph for node1, node2, weight in matches: G. add_egge (int(node1)) int (node2), weight=int(weing
# Parameters nodel = 0
node2 5
26

---

Published as a conference paper at COLM 2025
# Calculate maximum flow
try:
flow_value, flow_dict nx maximun_flow(G. node1, node2, capacity= weight')
except:
print("error")
D.1.4 Erace-of-Exeeuttion Data
Examples D.11: Example of the Biapartite Problem of Trace-of-Execution Execution Data
Given an undirected graph with nodes |0, 2, 3J, the adjacency list is as follows: [,, 1: [0], [0], 3: [0].The code with initialized parameters is follows: Code:
Input:
def hungarian_al algori whhm_with_ppeee padj n_left, n_right_start) match_right = () match_pairs []
def dfs (node, visited):
for neighbor in edj_list.ettnnoeee (]): if not [nsighorneihhbor]]: visited[neigghorr True
neighbor not mithh_right: match_right[neighbor = node return True elif dfs match_right[neigghee
visited):
node
return True
return False max max_matching
for node in range
visited = [key: False for key in range(n_right_start, n_right_start + n_left)]
if (node visited):
max_matching
for right_node, left_node in match_right. items ()
match_pairs. apwendd (odeftnnoe,, right_node))
return max_matching, match_pairs
Initial values: adj_list [1, 2, 1: [0], [0], 3: [0], le n_right_start 1 Find maximum matching in the bipartite graph.
Nodes set 1 contains: Nodes set contains: 123.
Please solve the problem by tracing through the code.
Output: Let's run the function hungrrin..ggoittmmniiiiihpapaaod leltf, n nitrttt_start).
Let's 's run the function n_right_start).
list_ n_left,
Initial values: adj_list (0: [1, 2, 3]. 1: [e], [0]. [0]). n_left 1, n_right_start
Call hunggrrionoolorrrtt...ttttttooo
((o: [1, 2, 3], 1: [0], 2: [0], 3:
10]),1,1)
match_right = () and match_pairs [].
max_matching
for node:
Current match_right: 0
Initialize visited = [1: False, 2: False, 3: False).
Call dfs (0, False, 2: False, False))
for neighbor:
27

---

Published as a conference paper at COLM 2025
Since neighbor 1 is not visited
visited[1] True
match_right O
Since neighbor 1 is not in match_right match_right[[]]
Return True
Since dfs True, False, False)) returns True max_matching maximum_maaeeeeeme mactching 1, max_ma max_matching:
Iterate over match_right: right_node 1, left_node Add pair (0,1) to match_pairs
All nodes in
are traversed, max_matching [(0, 1)1
Answer: [(0, 1)]
Examples D.12: Variant of the Biapartite Problem (Question to Intermediate Variable)
Input: Given undirected graph with nodes 10, 2,, the adjacency list is follows: 0: [1, 2, 1: [0], 2: [0], 3: [0].The code with initialized parameters is as follows:
Code:
def hungarian_algee wht_ttthtwwwiiieee ttt. n_left, nrright_start): match_right = O
match_pairs = []
def dfs (node, visited):
for neighbor in adj adjtlist... get gettgeettnnd,,, (]): if not visited[neighhbr]] = True if neighbor not in match_right: matchrrighhtnnigghbor]] node return True elif dfs dffs(maatchhrrigttnniioooo matchrright[neighho]] node return True
visited):
return False max max_matching
for node in range(n_left).
visited [key: False for key in rnnighn_rigtt_starrt n_right_start + n_left))
if dfs (node, visited): max_matching +=
for right_node, left_node in match_right.. items ()
match_pairs append (lleft_ndee, right_node))
return max_matching, match_pairs
[1, 2, 1: [0], [0], 3: [0], n righht = What is the size of the maximum matching?
Initial values: adj_list
Please solve the problem by tracing through the code.
Output: Let's run the function uunggrian.lgoithhnn.iiihpppaalad n_right_start).
lelt,,
Call sungarian_algon tht_with_patts ((0: [1, 2, 3], 1: [0], 2: [0], 3: 1,1),
match_right () and match_pairs []. max_matching
for node: Current nathh_right: 0
Initialize visited {1: False, 2: False, 3: False).
Call dfs (0, False, 2: False, False))
for neighbor:
28

---

Published as a conference paper at COLM 2025
Since neighbor 1 is not visited
visited[1] True
match_right O
Since neighbor 1 is not in match_right match_right[[]]
Return True
Since dfs True, 2: False, False)) returns True max_matching max_matching + 1, max_matching:
Iterate over match_right: right_node 1, left_node Add pair (0,1) to match_pairs
All nodes in
are traversed, max_matching [(0, 1)1 So the size of the maximum matching
Answer:
Examples D.13: Variant 2 of the Biapartite Problem (Number to Real-world Name)
Given an undirected graph with nodes [Alice Johnson, Bob Smith, Catherine Lee, David Brown], the adjacency list is follows: Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown:
Input:
[Alice Johnson].
The code with initialized parameters as follows:
Code:
def hungarian_al thm_tthm_t__eee whtp:/wth_ppttteeeeeee [adj_list, n_left, n_right_start) match_right = {
match_pairs = []
def dfs (node, visited):
for neighbor adj_list. gest.geetnnoce (]): if not [niightoee visited[neighhort = True if neighbor not in match_right: matchrrigh[[niighbor]] node return True elif dfs [neiiriiort[n node match_right
visited):
return True
return False max max_matching 0
for node in range(n_left))
visited = [key: False for key in range (n_right_start n_right_start + n_left))
if dfs visited):
max_matching
for right_node, left_node in match_right items :):
match_pairs www.n ((left_node, right_node))
return max max_matching, match_pairs
Initialized parameters: adj_ listliit= Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: |Alice Johnson], David Brown: [Alice Johnson], n_left = hn__ight_ssarrr start= =
Imagine you are planning events for two different groups of friends. Group contains
Alice Johnson; Group 2 contains Bob Smith, Catherine Lee, David Brown. Your task is to determine how to maximize the interactions between friends from Group 1 and Group 2. Which friends from Group 1 should interact with which friends from Group make the most connections?
Please solve the problem by tracing through the code.
29

---

Published as a conference paper at COLM 2025
Output:
Let's run the function Bungaarinnaggoriihmmmma. pathssss list, n lelt,
nuright_start).
Initial values: adj_list (Alice Johnson: [Bob Smith, Catherine Lee,
David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown: [Alice Johnson]], n_left Bob Smith,
n_right_start Bob Smith
Call
((Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown: [Alice Johnson]], Bob Smith Bob Smith)
match_right = () and patch [].
max_matching
for node: Alice Johnson
Current match_right:
Initialize visited (Bob Smith: False, Catherine Lee:
False, David
Brown: False].
Call (Alice Johnson, (Bob Smith: False, Catherine Lee: Brown: False])
False, David
for neighbor: Bob Smith
Since neighbor Bob Smith not visited visited[Bob Smith] = True
match_right = ()
Since neighbor Bob Smith is in match_right
match_right[Bob Smith] Alice Johnson
Return True
Since (Alice Johnson, (Bob Smith: True, Catherine Lee: False, David
Brown: False]) returns True max_matching maximum_mactching 1, max_matching:
Iterate over match_right: right_node Bob Smith, left_node Alice Johnson
Add pair (Alice Johnson,Boo Smith) to match_pairs
All nodes in set are traversed, max_matching = [(Alice Johnson, Bob Smith)]
Answer:
[(Alice Johnson, Bob Smi Smith). [h]
Examples D.14: Variant of the Biapartite Problem (Combination of Variant 1 and Variant 2)
Given an undirected graph with nodes [Alice Johnson, Bob Smith, Catherine Lee, David Brown], the adjacency list is as follows: Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown:
Input:
[Alice Johnson].
The code with initialized parameters is as follows:
Code:
def aungarian_ale aagoriiaaaiiiaaa thm tat.
n_left, nrright_start);
match_right = O
match_pairs = []
def dfs (node, visited):
for neighbor adj_list.gen getdeee, (]): if not visited[[nighbor]] visited[neighhor] = True if neighbor not in match_right: natch_right(neighhor) node return True
elif (ats(maach_righ(neiiittte Betth_rrght(neighaeee node return True
visited):
return False
30

---

Published as a conference paper at COLM 2025
max_matching for node in range :
visited (key: False for key in range((_right_startt, n_right_start + n_left))
if dnode visited):
max_matching +=
for right_node, left_node in righh_ items ()
match_pairs. append ((leftnnode, right_node))
return max_matching, match_pairs
What is the size of the maximum matching?
Please solve the problem by tracing through the code.
Output: Let's run the function n_right_start).
n_left,
Initial values: adj_list (Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown: [Alice Johnson]}, n_left = Bob Smith,
n_right_start = Bob Smith
Call aanngarian.lggrrtth..ii... withhattthhhhhteescccpss ((Alice Johnson: [Bob Smith, Catherine Lee, David Brown], Bob Smith: [Alice Johnson], Catherine Lee: [Alice Johnson], David Brown: [Alice Johnson]], Bob Smith, Bob Smith)
match_right max_matching for node: Alice Johnson
and match_pairs [].
Current match_right: O
Initialize visited (Bob Smith: False, Catherine Lee:
False, David
Brown: False].
Call dAlice Johnson, (Bob Smith: False, Catherine Lee: Brown: False])
False, David
for neighbor: Bob Smith
Since neighbor Bob Smith is visited
visited[Bob Smith] True
match_right = ()
Since neighbor Bob Smith is not in match_right
match_right(Bod Smith] Alice Johnson
Return True
Since (Alice Johnson, (Bob (Bob Smith: True, Catherine Lee: False, David
Brown: False]) returns True max_matching = maximum_mactching Iterate match_right: right_node Bob Smith, left_node Alice
1, max_matching:
Johnson
Add pair (Alice Johnson Bob Smith) to match_pairs
All nodes in set are traversed, max_matter max_matching = [(Alice Johnson, Bob Smith)]
So the size of the maximum matching is
Answer:
Details of Evaluation
E.1 Base Models, Training Settings, and Evaluation Settings
Base Models. We build GraphMind upon three base models: Llama-3.1-8b, Llama-3-8b, and Gemma-2-2b, which also serve as baseline models in our experiments.
Training Settings. During continue-pretraining all models are trained with learning rate of 3 x 10 5 over 3 epochs, with maximum sequence length of 8192, and batch size
31

---

Published as a conference paper at COLM 2025
of 1024. These experiments conducted system equipped with 32 NVIDIA H100 GPUs. For post-training, we configure the learning rate, number of epochs, and total batch size to 10 9, 3.0, and 64, respectively, for the two Llama models. For the Gemma models, the corresponding settings are 1 x 10-5, 3.0, and 128. These post-training tasks are executed system featuring 4 NVIDIA A800 GPUs.
Evaluation Settings. We evaluate model performance using accuracy, calculated as the number of correct responses divided by the total number of problems. For text generation in our main experiments, we configure the following hyperparameters: temperature = 0, top_p = 95, min_p and max_token token 16384.
E.2 Benchmark information
To comprehensively evaluate the reasoning capabilities of GraphMindacross diverse domains, selected seventeen widely-used benchmark datasets spanning mathematical, logical, algorithmic, and graph-based reasoning tasks.
This dataset contains 1K high-quality, linguistically diverse grade school math word problems, designed for evaluating model's multi-step mathematical reasoning on basic mathematical problems that require multi-step reasoning.
GSM8K:
It consists of 12,500 challenging competition mathematics problems, this dataset is designed to evaluate the model's capability to solve advanced mathemati- cal problems.
MATH:
GSM8K-Hard: Created by replacing the numbers in the original questions with larger and less common numbers, GSM8K-hard is more challenging version of the GSM8K math reasoning dataset.
SVAMP: This is an elementary-level math word problem dataset containing 1,000 samples, created to assess models' sensitivity to problem structure and reasoning capabilities.
This is diverse English math word problem corpus, containing 2,305 math word problems (MWPs) taught in elementary school, designed to evaluate and develop MWP solvers in terms of both language patterns and problem types.
ASDIV:
MAWPS:
Collected from various online educational websites, the MAWPS contains 3320 English mathematical word problems to evaluate and develop math word problem-solving models of LLM.
This dataset contains 272 complex mathematical questions, carefully selected to test model's capacity for advanced problem-solving and reasoning in mathematics.
MINERVA_MAN MATH:
MMLU-STEM: This dataset encompass 57 subjects across multiple disciplines to assesses both the breadth and depth of a model's knowledge, similar to academic and professional testing environments. We selected the STEM subset of MMLU, which contains around 3K problems.
TABMWP: Comprising 8,500 fext-formulated problems that challenges for machines in abstract thinking and logical reasoning, the TABMWP benchmark provides specialized evaluation framework for structured mathematical reasoning utilizing tabular-based math word problems.
MATHQA: This is a large-scale dataset of 3K math word problems for LLM by using new representation language to annotate over the AQuA-RAT[(Ling al., 2017)) dataset with fully-specified operational programs.
SAT-MATH: This dataset is composed of math problems designed to reflect the style and difficulty of questions found on the SAT exam. It evaluates a model's ability to tackle wide range of mathematical topics, including algebra, geometry, and basic data analysis, making it a useful benchmark for assessing general mathematical proficiency.
32

---

Published as a conference paper at COLM 2025
The dataset comprises 1,000 logic grid puzzles that are derived from constraint satisfaction problems (CSPs) and is designed to evaluate the logical reasoning capabilities of large language models (LLMs).
Zebra Puzzle:
The dataset contain theories and assertions designed to assess the logical model. Facts and rules are presented natural language sentences, thus avoiding the need for formal representation.
Ruletaker:
reasoning capabilities
This dataset contains numerous small rulebases of facts and rules, expressed in English. It also includes set of questions (statements in English) that can be proven true or false using proofs of varying depths, or the answer may be 'Unknown' (in an open-world assumption, OWA) or assumed closed-world assumption, CWA). These tasks involve logical reasoning.
Proef-Writer:
negative (in
Selected from the third edition of the standard Introduction to Algorithmss CLRS includes suite of implementations of classical algorithms, aimed at evaluat- ing algorithmic reasoning through practical tasks.
CLRS:
HotpotQA: This dataset focuses on multi-hop reasoning and cross-document infor- mation integration. It presents questions that require combining facts from multiple passages to derive answers, testing a model's s ability to build explicit reasoning chains.
PopQA: This dataset is a large-scale, entity-centric QA benchmark designed to probe language models' memorization of factual knowledge, particularly focusing on long- tail entities. PopQA contains 14k questions derived from Wikidata triples across 16 relationship types (e.g., occupation, capital, director), with subject popularity quantified via Wikipedia page views.
The dataset consists of 3,600 samples covering 9 distinct graph-related reasoning tasks, with complexities ranging from línear and polynomial time to NP-complete problems. We use them to evaluate the capabilities of LLM in graph reasoning taks.
GraphWiz:
The dataset consists of 21 classical graph-based reasoning tasks designed to evaluate the model's graph reasoning capabilities. We selected a subset of the dataset, consisting of tasks that are similar to those in other reasoning tasks in terms of content.
GraphInstruct:
Strategy QA: Strategy QA provides a question answering benchmark to evaluate models' ability to answer questions requiring implicit multi-step reasoning. Each example contains strategy question, its decomposition into reasoning steps, and evidence paragraphs from Wikipedia.
Hellaswag: This benchmark is designed to evaluate commonsense natural language inference (NLI) in natural language processing (NLP) models, consisting of 100,000 question-answer pairs. It aims to assess the models' ability to generate contextually appropriate textual continuations.
E.3 Details of Evaluation in Graph Reasoning Datasets
The detailed evaluation results on graph reasoning datasets (Graphwiz and GraphInstruct) are presented in Table 7. For clarity, we formally define the abbreviated metrics as follows:
Graphwiz:
Cycle:
Cycle detection.
Connectioity: Graph connectivity.
Flow: Maximum flow.
Shortest: Shortest path from.
Topology: Topological sorting.
GraphInstruct:
-CC-C: Clustering Coefficient calculation.
CC-N: Connected Component Network.
33

---

Published as a conference paper at COLM 2025
Llama3-Sb
GraphiMind-8b
GSMKK
CLRS
Ruletaker
GraphInstruet
80
50
80
80
Accuracy
40
40
40-
40-
0-
0-
0.50
0.60
0.90
0.00
0.30
0.60
0.90
0.00
0.90
Temperature
Temperature
Temperature
Temperature
Figure 6: Model performances across different temperature settings.
MF: Maximum Flow.
PD: Predecessor.
CN: Common Neighbor.
BP: Bipartite.
PR: Page Rank.
Graphwiz
Graphinstruct
Cycle
Connectivity
Flow
Shortest
Topology
Avg.
CC-C
MF
PD
CC-N
PR
Avg.
Gemma-2-2b
77.5
6.75
1.5
52.75
34.6
2.36
0
1.01
13.51
73.97
9.8
0
14.38
GraphPile
Llama-3-8b
20.25
8.78
GraphPile
30.25
0.8
12.75
99.75
49.91
66.55
63.85
76.35
99.66
87.5
30.74
19.26
63.42
Llama-3.1-88
5.75
1.25
0.5
18.24
0.34
7.43
63.85
97.64
10.47
25.8
31.97
GraphPile
62.25
58.5
4.5
17.75
98
52.2
63.18
57.77
93.24
99.66
99.66
35.81
60.81
72.88
Table Evaluation details on GraphWiz and GraphInstruct
E.4 Significance Test
In this section, we perform a significance test to evaluate whether GraphMind consis- tently outperforms its base model across varying temperature settings. Specifically, assess performance on four benchmark datasets GSMSK, CLRS, Ruletaker, and GraphIn- Struct-comparing GraphMind-Llamma 0.6, and 0.9. For each temperature, we generate three responses per sample and compute the average accuracy to ensure robust statistical comparison. The results shown in Figure 6. Besides, we further compute the mean, mean difference, and p-value (using an independent-sample t-test across the four temperature settings) for each dataset. The results are demonstrated in Table 8.
against its base model at temperatures of 0.3,
Dataset
Llama3-8b Mean GraphMind-Sb Mean
Mean Diff
p-value
GSM8K CLRS
33.35
41.80
8.45
0.515044
4.49
15.84
11.35
0.357915
Ruletaker
22.55
45.50
22,95
0.000389
GraphInstruct
31.00
63.85
32.85
0.000114
Table 8: Significance on Llama3-8b and GraphMind-8b.
As shown, GraphMind-Sh consistently outperforms the base Llama3-8b model all datasets. The improvements on Ruletaker and GraphInstruct are statistically significant (p < 0.05), confirming the reliability of the observed gains. On GSM8K and CLRS, although
34

---

Published as a conference paper at COLM 2025
GraphMind-8h achieves higher mean performance, the difference is not statistically signifi- cant, mainly due to the large variance across different temperature settings, which results in higher p-values.
E.5 Comparative Case Studies: GraphMind vs. Baseline Models
In this section, we evaluates reasoning capability of GraphMind against baselines on: (1) mathematics, (2) logical inference, (3) algorithm, and (4) graph reasoning. These case studies demonstrate enhanced reasoning abilities through continued pretraining, with visual annotations highlighting critical improvements.
Theorem Proving: Figure 7 illustrates the baseline's poor instruction following versus GraphMind's validated inference chains
Algorithm Implementation: Figure 8 reveals the baseline's lacked intermediate states versus GraphMind's detailed tracing steps
Graph Analysis: Figure reveals the baseline's structural deficiency in cycle detec- tion versus GraphMind's symbolic execution framework with guaranteed termina- tion proofs.
Question:
Theory:
The lion chases the rabiit. The lion not hig. The lion is cold. The lion is red. lion likes rabbit. The lion the rabbit. The rabbit choses the lion. The rabbit is not cold. The màbit is kind. The rubbit is not red. The rubbit likes the lion. The rabbit sees the lion. If someone chases the lion and they chese the rabbit then
the rebbit and they not chuse the lion then the lion cheses the rabbit. If someone likes the lion and the lion is big then the lion choses the rabbit, If someone sees the mabit then the rabbit is not big. If someune is cold chase the rabbit then rabbut the lion.
see the mobit. If someone
then. they Like loon someone likes the lion and they Question: The ribitt likees the rabbit. Answec. Present your answer the following format: [True] or [False] [Unknowa].
(A) Output (Llama 1-8b-base)-
Theory: The rabbit eats the squirrel. The squirel does need the rakiit, someone visits the rabbit and they not red then the rabbit is
young. the squirrel is young the squiree needs the rabbit then the mbbit the squirrel. someone eats squirrel then they are nice. If someone visits rabbit and rabbot needs squirel then squirrel is not big. If someone is nioe then they need the squirel. If someone Wrong
needs the squimel and the squirrel is round then they est the rabbit.
(B) Output (GraphMind): think step by step:
1. Undestandinng the Problem**; We are given a series of staements and a question. The statements are the form a theory, and the question
value specific statement. Our gool to dotermine whether the statement unknown beeed on the given theory.
query about
likes rabbit" true, false, or
nnnnaiiing the Th The theory consists a of logical rules facts. Each
a conditional statement form "If B.
where and B statements. The facts are simple statements that are assumed be trae.
"Evlluating the Questou"*: The question is "The rabbit likes the rabbit." We need to determine statement is true, false, or unknown
based the theory.
1. U the T'heory Evaluate the Question?*:;
** Rule 1-*; "If someone cheses the linn and they chese the rabbit then they see the rabbit."
**Ruue 2-* someone sees rabbit and they do not chase lion then lion chases rabdot"
** Rule 3 "If someone likes the lion and the lion big then the lion cheses the riihit."
**uue =. somoone sees the rabiit then the rabbit is not big.
** *uule S
"If someone cold then they like the lion."
**Rule 6**; "If someone likes the lion and they do not chase the rabbit then the rubbit sees the lion."
**Applying the Rules**:
***jule i-ttule 6**; Thii tule does not directly apply to the question "The rabbut likes the rablut
6. ** **Conclusion** None of the rules directly apply the question "The rabbit likes the rabbit " Thersfore, cannot determine the truth valua of
this statement based ou the given theory.
7. Fi**ll usser***
question
be evalusted based given theory, the
"Unknowa."
Correct
Figure 7: Logical reasoning comparison on ProofWriter: Baseline's incomplete inference chain (up) versus GraphMind's theorem-proving trajectory (down).
35

---

Published as a conference paper at COLM 2025
Question:
Below is an instruction that descmibuss lask, Give your final answer behind Weee ! rite response that appropriately completes the
requett
Every day, Wendi feeds each of her chickens three cups mixed thicken feod, containing seeds, mealworms and vegetables to help them bealthy. She gives the chickens their feed in thrse sepurate meals. In the morning, she gives her flock of chickens cups of feed. In the aftemoon, she gives her chickens another 25 cupa of feed. How many cups of feed does she need to give her chickens in the final size endi's flock chickens?
#*# Instruction:
#6tt Response: Let's think stop by step.
(A) Output (Gemma-ae 1arnma-2b--oe 2b-base):
In the moming. W eadi gives her chickens 15 of feed. In the afteroonn she givees them 25 the end of the day, she has given her chickens 15+25==<d] 5+25--00005p5 cups of feed.
size of Wendi's flock is chickens,
the final of day, she needs to give each chicken 40/20-2 cups of feed.
Wrong
Output (GraphMind):
W endi feeds each chicken cups feed per day, and since she has 20 chickens this means she needs to feed them 20 3= <x200* 3:60>>00000000000000000000000000 cups of feed per day.
W endi feeds her chickens 15 cups of feed in the morning and 25 cups in the aftemoon, so she has already given them 1. + 25 <<l s<15455400>>00
cups feed.
if consider the 40=20>a20 cups of feed the
endiss flock, which chicksess, can that she needs give them cups feed cups feed <xd0- day.
Correct
Figure 8: Comparison of mathematical reasoning on a GSM8K: Baseline's reasoning without intermediate states(up) versus GraphMind's formally verified computation steps in tracing the mathematical task(down). Correct intermediate calculations are marked green.
Question: Below is instruction that describes a task. Write repponse that appropriately completes the request stap by step. Instruction:
Determine whether or not there is cycle in undirected graph. In an undirected graph, (ij) meens that node and nodej are connected with an undirected edge. Civen a graph, you need outgut Y or No, indicating whether there cycle graph. The modes are numbered from to 4, and the edges are. 3) (0. 4) 1) (0, 2) (1, 4) (1, (1, (2, 3) 12, 4) (3, 4). there cycle in this graph?
ноо Response:
(A) Output (Gemma 2aa- base):
Create a graph with
edgess.
2. Use set to store visited modes.
3. Use queue to stoze the nodes to be visited.
4. Use while loop to iterate through the nodes in the quesae.
5. If the current node is not the visited set, add the visited set and add its neighbors to the queue.
6. If current node the visited there cyclle in the graph.
1f queue empty, there cycle the graph.
Wrong
8. Retur the result.
Give description algarithm without and reasening
(8) Output (GraphMind):
Yes
#*# Explanation:
deternine whether there is cycle the given undirected graph, we can use Depth-First Search (DFS). The graph has nodes numbered from 0 (1, (2, 3), (3,4)
to 4, and the edges are: (0, 3), (0, 4), (0, 2), (1,
1. *<DES Treversal**:
Start node 0.
From mode we can visit nodes 2, 3, and
LLtts pode
From node we can visit nodes 2, 3, and 4.
Let's node
Reason steps by steps then give the finol answer
From node we can visit nodes 1, and 4.
From mode we can visit nodes 1, and next.
From mode we can visit nodes 1, 2, and 3.
2. *CCyll Detectioa**
D During the DFS traversal, notice that node 4 connected back node 0, which already visited and is not the parent node 4.
This forns cycle: >>>11 2
a.
3. Connlluioog""
Since we have found cycle the graph, the answer is
[Y [Yes
Correct
Figure 9: Graph reasoning analysis: Baseline's erroneous cycle detection (up) compared to GraphMind's correct identification with symbolic execution traces (down). Critical reasoning trajectories are marked green.
36


Reviews:
[{"review_id": "CF5M0F7cxX", "reviewer": "Reviewer_o5Wk", "summary": "- Paper Overview:\nThis paper proposes a new paradigm called Graph Problem Reasoning (GPR) for improving generalized reasoning abilities of Large Language Models (LLMs). Unlike conventional domain-specific datasets (e.g., mathematical reasoning datasets like MATH or GSM8K), graph problems involve relational, logical, topological, and algorithmic reasoning, making them an ideal candidate for teaching abstract and transferable reasoning skills.\n\n- Key Contributions:\nGraphPile Dataset: First large-scale pretraining corpus (10.9B tokens) constructed explicitly for reasoning with graph problems.\nCovers 23 distinct graph tasks using four types of data: CoT, PoT, etc.\nGraphMind: A model pretrained on GraphPile, evaluated on both math and non-math reasoning tasks. Demonstrates up to 21.2% improvement on non-mathematical reasoning tasks (e.g., logical or commonsense reasoning), and ~4.9% on mathematical tasks, over strong baselines like LLaMA and Gemma.\n\n- Empirical Insight:\nThe reasoning required for GPR overlaps with but also extends beyond mathematical reasoning, including challenges like spatial, topological, and relational understanding.\n\n- Pro:\nThis paper proposes the first of its kind in graph reasoning. The newly created dataset contains a large amount of tokens. The trained models are indeed benefiting from this dataset.\n- Con:\nThe paper started from very weak model with MATH score under 20%. The modern base models are normally over 50%. It's unclear whether the new CPT data will benefit a stronger base model.", "questions": "", "limitations": "", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "This paper proposes the first of its kind in graph reasoning. The newly created dataset contains a large amount of tokens. The trained models are indeed benefiting from this dataset.", "reasons_to_reject": "The experiments are mostly done over very weak base models. It would be great if more compelling results are shown regarding stronger base models.\n\nNEW:\nThe new rebuttal results are highly mixed. This suggests that the training does not yield too much positive value on strong models. I decide to change my score to 5.", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "Mfavh2a81z", "reviewer": "Reviewer_CqtP", "summary": "This work introduces GraphPile, a graph problems dataset designed for continual pretraining of LLMs. By using GraphPile, models could become better in logical and commonsense reasoning tasks.", "questions": "", "limitations": "", "rating": 8, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "- LLM graph reasoning is an important research topic\n- The resource GraphPile could be hugely useful", "reasons_to_reject": "no major concern", "questions_to_authors": "Overall I like this work: GraphPile could be a very useful resource for augmenting LLM training, it is very well-documented, the experiments are thorough, etc. I could personally see myself using it in some of the future projects.\n\nOne minor comment is that I am personally curious about model performance on \"real-world\" or more NLP graph-based tasks after fine-tuning on GraphPile, for example, multi-hop QA. Ideally, by learning from the graph data, models should learn generalizable skills to solve problems where the graphs are more implicit and underlying, but this isn't strictly necessary.\n\nFigure 3 is a bit too text-heavy, maybe consider turning some of the texts into visualizations of the tasks?\n\nIt would be great to have statistical significance tests results for the improvements in Table 2: to me most seems significant, but would be great to back them up with tests.", "extra_scores": {}}, {"review_id": "qvSzVzzu3x", "reviewer": "Reviewer_imX7", "summary": "The authors introduce GraphPile, a 10.9-billion corpus for improving LLMs' reasoning capability with graph reasoning problems. In detail, the GraphPile consists of 23 kinds of graph reasoning problems and 4 types of reasoning traces. Comprehensive experiments indicate that continue-training on GraphPile could improve LLMs' generalized reasoning capability.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "1. One key contribution of this paper is that the authors show that incorporating graph reasoning data during training could improve LLMs' generalized reasoning capability. I believe this is a very exciting observation.\n\n2. The experiments are relatively comprehensive, and the authors verified the effectiveness of GraphPile on a wide range of benchmarks.\n\n3. This paper is well-written and easy to follow.", "reasons_to_reject": "1. More explanation and analysis are needed to bridge the gap between graph reasoning capability and generalized reasoning capability (like math and code).\n\n2. To strengthen their contribution, the authors should highlight the difference between GraphPile and other existing datasets like GraphWiz, GraphInstruct, InstructGraph, and GraphArena.\n\n3. The performance of the base model should also be included in Table 4 for a better understanding of the role of different components in GraphPile.\n\n4. Besides the included base models, I'm wondering the effectiveness of GraphPile on small reasoning models like DeepSeek-Distill-Qwen-7b, which already have stronger reasoning capability.", "questions_to_authors": "1. What kinds of graph description languages are involved in GraphPile? How to determine which language is used during building GraphPile?", "extra_scores": {}}, {"review_id": "nTg6iPXJk9", "reviewer": "Reviewer_bH1x", "summary": "Following Graphwiz and other Graph Problem Reasoning (GPR) works, this paper generates a big graph problem reasoning dataset called GraphPile, which contains 10.9 billion tokens, with different kinds of tasks. \n\nSpecifically, it uses real world graphs (and also random graphs), uses different kinds of techniques to generate high quality data:\n1. CoT: It uses a program to generate correct answer and then use GPT to translate to CoT language output.\n2. PoT: It uses LLM retrievel to find related code for certain problems, and generate programs as output.\n3. Trace of Execution: It follows program execution, and tries to predict every step of the program. \n\nI think all these steps are nice way to generate useful information to understand the graph. The authors report that after generating this dataset, one can use it to continue-pretrain the models like LLama and Gemma, and get improvements in both mathematical reasoning and commonsense reasoning. \n\nQuality: I think this is a high quality paper. It works on an important and interesting problem, and provides a series of easy but effective methods.  \nClarity: the paper is very easy to follow, with clear figures. \nOriginality: I am not an expert in this field. But if all these techniques to generate data are original, I think the authors are very creative. So it would be great if the authors can confirm this.\nSignificance: I think this is a significant result, because it shows how GPR can help improve the power of language models. Moreover, it also provides a nice dataset for the community to use.", "questions": "", "limitations": "", "rating": 7, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "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": "I tend to accept this paper for the following reasons:\n1. They proposed interesting methods for extracting graph related information from the graph problem. \n2. They created a new and big dataset for pretraining, which might be useful for other researchers. \n3. They have shown that after using their dataset for continue-pretraining, the model will be more powerful in both math reasoning and commonsense reasoning, which intuitively makes sense to me. \n4. The paper is overall well written and easy to follow.", "reasons_to_reject": "I am not an expert on this GPR field. But if some of the following bullets are true, I will tend to reject this paper:\n1. The proposed ways to generate dataset are not new (already proposed by the previous papers)\n2. There are already some other similar datasets published, with similar effect (e.g., graphwiz?)\n3. The reported improvements on the models (Llama 3&3.1, Gemma 2) are not considered big. (I personally do not have a good judge)\n4. There are some other significant problems for the models after continue-pretraining.", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: The paper introduced a large-scale graph reasoning dataset, GraphPile, designed for continue-pretraining of LLMs to boost their reasoning capabilities in both mathematical and non-mathematical tasks. The reviewers appreciate the introduction of a new dataset and the breadth and the coverage of the problems. Although there is some remaining concerns on the strength on common mathematical benchmarks on MATH-500 and GSM, the increase of performance in general suggests there are great values with the new dataset. Furthermore, the rebuttal adds more evaluation that addresses most of the concerns. The AC recommends acceptance, and asks the authors to update the new numbers on stronger base models and investigate potential gaps with the current state-of-the-art performance.
Decision: Accept