NPG-Muse: Scaling Long Chain-of-Thought Reasoning with NP-Hard Graph Problems

TL;DR

NPG-Muse introduces a novel training approach using NP-hard graph problems to significantly improve long chain-of-thought reasoning in large language models, achieving state-of-the-art results across multiple reasoning benchmarks.

Contribution

The paper presents a two-stage post-training framework leveraging NP-hard graph problems to enhance reasoning depth and efficiency in large language models, a scalable alternative to human-curated datasets.

Findings

NPG-Muse models outperform existing methods on reasoning benchmarks.

NPG-Muse-7B surpasses larger models on NPH graph problems.

The approach improves reasoning depth and efficiency in LLMs.

Abstract

Reasoning Large Language Models (RLLMs) have recently achieved remarkable progress on complex reasoning tasks, largely enabled by their long chain-of-thought (Long CoT) capabilities. However, developing these Long CoT behaviors relies heavily on post-training with high-quality datasets, which are typically costly and human-curated (e.g., mathematics and code), leaving scalable alternatives unexplored. In this work, we introduce NP-hard (NPH) graph problems as a novel synthetic training corpus, as they inherently require deep reasoning, extensive exploration, and reflective strategies, which are the core characteristics of Long CoT reasoning. Building on this insight, we develop a two-stage post-training framework: (i) Long-CoT Supervised Fine-Tuning (SFT) on rejection-sampled NPH graph instances, which substantially enhances reasoning depth, and (ii) Reinforcement Learning (RL) with a fine-grained reward design, which sharpens reasoning efficiency. The resulting NPG-Muse-series models exhibit substantially enhanced Long CoT reasoning capabilities, achieving consistent gains across mathematics, coding, logical, and graph reasoning benchmarks. NPG-Muse-7B even surpasses QwQ-32B on NPH graph problems in both accuracy and reasoning efficiency. These results position NPH graph problems as an effective and scalable resource for advancing Long CoT reasoning in LLM post-training. Our implementation is available at https://github.com/littlewyy/NPG-Muse.

Tables

Table 1. Table 1 . Performance comparison on small-scale TSP, GED, and MCP tasks. "Acc." and "Fea." denote Accuracy and Feasibility (both in %). Best results are bold ; second-best are underlined . † Qwen2.5-7B-Ins-1M refers to Qwen2.5-7B-Instruct-1M.

Category	Model	TSP		GED		MCP		Average
		Acc.	Fea.	Acc.	Fea.	Acc.	Fea.	Acc.	Fea.
Closed-source	Claude-3.5-sonnet	45.4	100.0	37.2	94.2	62.2	88.0	48.3	94.1
	GPT-4o	44.2	99.8	32.6	98.6	62.4	79.6	46.4	92.7
Reasoning	QwQ-32B	89.4	100.0	70.2	99.2	96.2	97.0	85.3	98.7
	S1.1-7B	33.8	56.4	22.8	81.0	46.2	80.4	34.3	72.6
Non-reasoning	LLaMA3-70B-Ins	23.2	99.8	31.6	97.0	42.8	44.2	32.5	80.3
	Qwen3-8B-Base	24.8	68.4	23.4	62.0	22.4	52.8	23.5	61.1
	Qwen2.5-7B-Ins-1M†	19.2	62.6	23.8	72.8	34.0	60.2	25.7	65.2
Graph-oriented	G1-7B	38.0	/	52.0	/	30.0	/	40.0	/
	LLaMA-8B-GT	39.2	/	46.0	/	95.2	/	60.1	/
	GraphWiz-7B-DPO	0.4	1.0	2.4	17.0	1.6	39.6	1.5	19.2
NPG-Muse	NPG-Muse-8B (Ours)	82.2	99.0	63.0	99.2	93.6	97.8	79.6	98.7
	NPG-Muse-7B (Ours)	91.2	98.6	72.8	98.0	96.0	97.8	86.7	98.1

Table 2. Table 2 . Performance comparison on large-scale TSP, GED, and MCP tasks.

Category	Model	TSP		GED		MCP		Average
		Acc.	Fea.	Acc.	Fea.	Acc.	Fea.	Acc.	Fea.
Closed-source	Claude-3.5-sonnet	2.8	99.6	3.4	83.6	19.0	79.8	8.4	87.7
	GPT-4o	0.8	95.6	2.4	97.2	15.2	63.2	6.1	85.3
Reasoning	QwQ-32B	7.6	100.0	7.4	94.0	64.6	74.6	26.5	89.5
	S1.1-7B	0.0	21.0	1.0	42.0	2.2	51.0	1.1	38.0
Non-reasoning	LLaMA3-70B-Ins	0.0	84.6	1.8	82.0	10.6	16.4	4.1	61.0
	Qwen3-8B-Base	0.0	33.2	2.0	45.0	1.6	35.4	1.2	37.9
	Qwen2.5-7B-Ins-1M†	1.2	58.8	1.2	58.8	2.4	30.2	1.6	49.3
Graph-oriented	G1-7B	0.0	/	3.0	/	3.0	/	2.0	/
	LLaMA-8B-GT	3.6	/	0.8	/	63.4	/	22.6	/
	GraphWiz-7B-DPO	0.0	0.0	0.0	18.0	0.0	50.8	0.0	22.9
NPG-Muse	NPG-Muse-8B (Ours)	4.8	75.2	6.0	97.0	57.2	83.0	22.7	85.1
	NPG-Muse-7B (Ours)	9.4	62.0	5.6	91.0	69.2	82.2	28.1	78.4

Table 3. Table 3 . Performance comparison on reasoning benchmarks. The best results are shown in bold , the second-best results are underlined , and highlighted cells indicate the better-performing model within each base–ours pair. † Qwen2.5-14B-Ins-1M denotes Qwen2.5-14B-Instruct-1M. Avg. denotes macro-average across tasks.

Models	Mathematics					Logic	Code	Avg.
	GSM8K	ASDiv	SVAMP	College Math	TabMWP	Zebra-grid	CRUX
Qwen3-14B-Base	90.0	94.4	92.3	39.7	93.2	15.9	63.9	69.9
Qwen2.5-14B-Ins-1M	95.0	95.5	94.3	42.3	96.9	20.5	66.4	73.0
Qwen2.5-7B-Ins-1M	88.8	94.7	93.0	39.6	78.4	9.2	55.6	65.6
NPG-Muse-7B	88.9	93.9	93.6	39.9	89.9	10.5	59.0	68.0
Qwen3-8B-Base	85.2	86.6	83.3	37.6	84.0	11.9	54.1	63.2
NPG-Muse-8B	93.3	95.2	94.5	47.1	97.2	26.0	65.3	74.1

Table 4. Table 4 . Response length comparison with the base models (tokens). Cells highlighted indicate the longer ones.

Models	AIME24	AIME25	MATH-500	Gaokao23en	Avg.
Qwen2.5-7B-Ins-1M	1933	1060	711	722	1107
NPG-Muse-7B	9013	6267	2015	2137	4858
Qwen3-8B-Base	3923	2620	1488	1317	2337
NPG-Muse-8B	9106	8724	2468	2692	5748

Table 5. Table 5 . Pass@k comparison with the base models. Cells highlighted indicate the better ones.

Models	AIME24	AIME25	MATH-500	Gaokao23en	Avg.
Qwen2.5-7B-Ins-1M	33.3	26.7	87.0	75.1	55.5
NPG-Muse-7B	33.0	33.3	88.0	76.9	57.8
Qwen3-8B-Base	50.0	40.0	89.4	82.6	65.5
NPG-Muse-8B	60.0	56.7	93.8	86.5	74.3

Table 6. Table 6 . Ablation on the effect of each training stage. Best accuracy results are highlighted in bold.

Models	NP-Hard Graph						Mathematics									Avg.
	TSP(S)	GED(S)	MCP(S)	TSP(L)	GED(L)	MCP(L)	GSM8K	College Math	ASDIV	SVAMP	TabMWP	AIME24	AIME25	MATH-500	Gaokao2023en
Accuracy (%):
Qwen3-8B-Base	24.8	23.4	22.4	0.0	2	1.6	85.2	37.6	86.6	83.3	84.0	11.5	10.5	64.5	56.9	39.6
+Long-CoT SFT	76.4	58.0	84.2	0.4	3.6	23.8	82.9	43.4	81.5	80.5	84.0	30.6	25.9	84.9	74.6	55.6
+ RL (NPG-Muse-8B)	82.2	63.0	93.6	4.8	65.0	57.2	93.3	47.1	95.2	94.5	97.2	23.6	19.9	85.5	74.7	62.5
Response length (tokens):
Qwen3-8B-Base	2668	2864	3410	3754	3126	3704	664	1601	607	639	586	3923	2620	1488	1317	2198
+Long-CoT SFT	9925	16254	5525	17418	21208	12837	3633	3999	4608	5307	5027	12864	11874	3883	4461	9255
+RL (NPG-Muse-8B)	6218	7761	4591	10282	10719	8018	674	1802	607	909	466	9106	8724	2468	2692	5002

Table 7. Table 7 . Ablation on the effect of fine-grained reward on NP-hard graph problems, with better results highlighted in bold.

Model	TSP(S)	GED(S)	MCP(S)	TSP(L)	GED(L)	MCP(L)	Avg.
Accuracy (%):
binary reward	83.2	57.0	94.6	4.2	5.6	50.6	49.2
fine-grained reward	82.2	63.0	93.6	4.8	6.0	57.2	51.1
Feasibility (%):
binary reward	98.8	99.4	98.8	71.2	81.8	83.4	88.9
fine-grained reward	99.0	99.2	97.8	75.2	97.0	83.0	91.9
Response Length (tokens):
binary reward	11604	11335	5217	17575	16184	9549	11910
fine-grained reward	6218	7761	4591	10282	10719	8018	7931

Table 8. Table 8 . Ablation study of the fine-grained reward design on complex constraint-following tasks.

Models	GraphInstruct			Logic	Code	Avg.
	Linear	Poly-Time	NP-Complete	Zebra-grid	CRUX
binary reward	62.8	47.8	62.5	25.4	59.4	51.6
fine-grained reward	64.9	46.3	75.0	26.0	65.3	55.5

Equations

$${\mathcal{L}}_{\text{SFT}}=-\sum _{i=1}^N\sum _{j=1}^{M_i}\log P(r_{i,j},y_i\mid G_i,x_i;\theta ),$$

Full text

Large Language Models, Long Chain-of-Thought Reasoning, Graph

††copyright: acmlicensed††journalyear: 2018††doi: XXXXXXX.XXXXXXX††conference: ; ; ††ccs: Computing methodologies Artificial intelligence††ccs: Computing methodologies Natural language generation

1. Introduction

Reasoning Large Language Models (RLLMs) [17, 29, 28, 30, 13, 8] have demonstrated significant performance leaps in complex reasoning tasks such as mathematics and coding. A defining characteristic that distinguishes these RLLMs from traditional LLMs is their long chain-of-thought (Long CoT) capabilities, which enable more detailed and iterative processes of exploration and reflection, thereby enhancing performance on intricate problems [6]. As a result, scaling Long CoT capabilities has become a central focus in recent LLM research.

The Long CoT ability in RLLMs is largely attributed to post-training, where Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) have proven effective [13]. SFT allows LLMs to imitate advanced reasoning behaviors through step-by-step supervision, while RL encourages self-learning through reward signals, and their combination often yields superior results by balancing guided learning with autonomous exploration. Despite growing interest in post-training strategies, the role of training corpora in eliciting Long CoT behavior remains relatively underexplored. In many challenging domains such as math and coding, high-quality data often rely on costly human curation. Therefore, exploring new training corpora that are both complex and synthetically scalable represents a promising direction.

According to [6], Long CoT behaviors manifest in three critical dimensions: (1) Deep Reasoning, requiring logical depth to sustain extended reasoning chains; (2) Extensive Exploration, involving transitions from known to unknown reasoning paths and generation of uncertain or parallel logic; and (3) Feasible Reflection, encompassing self-correction, refinement, and feedback on logical structures. To induce such behaviors in LLMs, we seek training corpora that either demonstrate these patterns (for imitation-based SFT) or stimulate them (for self-learning via RL).

We identify NP-hard (NPH) graph problems as particularly well-suited for this purpose. NPH graph problems possess several advantageous properties that align naturally with the core characteristics of Long CoT reasoning—namely, Deep Reasoning, Extensive Exploration, and Feasible Reflection. We examine each dimension in turn: ❶ Deep Reasoning. Due to the exponential worst-case complexity of NP-hard graph problems, their resolution through natural language simulation in Large Language Models (LLMs) may necessitate extensive reasoning chains even for small-scale instances. This characteristic renders such problems ideally suited for eliciting deep reasoning. ❷ Extensive Exploration. The absence of known polynomial-time solutions forces LLMs to autonomously explore unknown optimal strategies, fostering extensive exploration. This exploration is further enriched by the intrinsic complexity of graph problems, which elicits diverse reasoning patterns, including topological analysis, logical deduction, enumeration, precise computation, and case decomposition [46]. ❸ Feasible Reflection. Due to the diversity of graph structures and the computational feasibility of exact solvers for small-scale NP-hard problems, these tasks facilitate the scalable synthesis of datasets with verifiable ground truth. Consequently, this enables large-scale post-training and provides a robust basis for feasible reflection. To empirically validate that NPH graph problems can elicit substantially longer reasoning chains, we apply QwQ-32B [41] to solve small-scale NPH graph problem instances. After rejection sampling based on final answer correctness, the resulting samples exhibit an average length exceeding 11k tokens—more than 2.3$\times$ longer than the widely used high-quality Long CoT dataset s1K [25], which averages 4.7k tokens. This substantial length difference empirically demonstrates the superior potential of NPH graph problems as a source for Long CoT training data.

Building on these insights, we propose a novel two-stage framework that leverages NPH graph problems to enhance the Long CoT capabilities of LLMs. In the first stage, we perform Long-CoT Supervised Fine-Tuning (SFT) on base models (Qwen2.5-7B-Instruct-1M [40] and Qwen3-8B-Base [42]) using small-scale NPH graph problems generated by prompting QwQ-32B [41] and applying rejection sampling based on final answer correctness. This stage substantially enhances the models’ response length and reasoning performance across diverse complex tasks. However, we also observe that the models exhibit severe reasoning redundancy, which not only undermines reasoning efficiency but also leads to significant performance degradation on certain tasks. This motivates the second training stage, where we apply Reinforcement Learning (RL) to promote more efficient and broadly applicable Long CoT reasoning. We design a fine-grained, outcome-based reward function that incorporates: (1) a repetition penalty to directly reduce redundant reasoning, (2) a graph-specific solution quality reward to encourage concise yet effective solutions, and (3) a format reward to promote structured reasoning. This stage produces our NPG-Muse-series models: NPG-Muse-7B and NPG-Muse-8B.

Our NPG-Muse-series models demonstrate significantly enhanced Long CoT capabilities, as evidenced by strong generalization across diverse complex reasoning tasks along two dimensions: (1) In-task generalization: Although trained exclusively on small-scale NP-hard graph problems, both models achieve remarkable accuracy improvements on large-scale instances, indicating that they learn transferable reasoning strategies rather than memorizing specific solutions. (2) Cross-domain generalization: both models attain notable gains across other complex reasoning domains, including mathematics, coding, logic, and graph reasoning.

Beyond these explicit improvements on benchmark accuracy, we also uncover implicit evidence that NPG-Muse-series models have genuinely advanced their Long CoT capabilities: (1) a substantial increase in response length, aligning with the Deep Reasoning characteristic of Long CoT; (2) significant improvements in pass@k, suggesting a more diverse exploration space consistent with Extensive Exploration; (3) a marked rise in reflection frequency, corresponding to the Feasible Reflection feature of Long CoT.

In summary, our main contributions are as follows:

• •

Novel Corpus. We are the first to introduce NP-hard graph problems as a training corpus for eliciting Long Chain-of-Thought capabilities in LLMs.

• •

Training Pipeline. We propose a two-stage post-training framework that combines Long-CoT SFT guided by rejection-sampled NP-hard graph instances, and RL with a fine-grained reward design, fostering effective and efficient Long CoT reasoning.

• •

Superior Performance. The resulting NPG-Muse-series models exhibit substantially enhanced Long CoT reasoning, achieving gains across mathematics, coding, logical, and graph reasoning benchmarks. NPG-Muse-7B even surpasses QwQ-32B on NP-hard graph problems despite its significantly smaller size.

2. Preliminaries

2.1. NP-Hard Graph Problems

NP-hard (NPH) graph problems are intractable challenges in theoretical computer science with no known polynomial-time solutions. We select three representative NPH graph problems for training: Graph Edit Distance (GED), Traveling Salesman Problem (TSP), and Maximum Clique Problem (MCP). These tasks are chosen for their structural and operational diversity: GED evaluates the similarity between graph pairs via edit operations, TSP identifies optimal paths in weighted graphs, and MCP seeks dense substructures in unweighted graphs. This diversity minimizes overlap in solution strategies, thereby introducing a rich variety of reasoning paradigms. The formal definitions of these tasks are as follows:

• •

Graph Edit Distance (GED). Given two graphs $G_{1}=(V_{1},E_{1})$ and $G_{2}=(V_{2},E_{2})$, GED is the minimum cost of a sequence of edit operations (insertion, deletion, or substitution of nodes or edges) that transforms $G_{1}$ into $G_{2}$ [36].

• •

Traveling Salesman Problem (TSP). Given a weighted graph $G=(V,E)$, TSP asks for the shortest possible cycle that visits each vertex exactly once and returns to the starting point [10].

• •

Maximum Clique Problem (MCP). Given an unweighted graph $G=(V,E)$, MCP seeks the largest subset of vertices $C\subseteq V$ such that every pair of vertices in $C$ is connected by an edge [4].

2.2. Graph Serialization Format

To facilitate natural language reasoning for NP-hard graph problems, we serialize graph structures into a human-readable text format following GraphArena [39]. A condensed example is provided below, while the full templates are detailed in Appendix B.3.

**Prompts 2.2.1: **A condensed example of TSP for graph serialization format

• Airports to visit: BVC, URA, SMR, KOK, MTV, TFF, FLN, YZF

• Travel distances (in kilometers) between each pair of airports:

BVC to KOK: 6401

FLN to YZF: 11826

3. Methodology

Our method consists of two stages: Long-CoT Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL). The SFT stage first equips the model with Long CoT reasoning capabilities, while the RL stage is further applied to enhance reasoning efficiency.

3.1. Long-CoT Supervised Fine-Tuning

Long-CoT Supervised Fine-Tuning (SFT) comprises two components: (1) constructing a Long CoT reasoning dataset via distillation, and (2) training the model through SFT on this dataset to acquire a systematic step-by-step long-reasoning paradigm.

3.1.1. Long CoT Dataset Construction

We construct a Long CoT dataset comprising 9,000 samples by prompting QwQ-32B with NP-hard graph problems and applying rejection sampling [43] to retain only those with correct answers. Each sample is a QA tuple $(G,x,r,y)$, where $G$ denotes the graph structure, $x$ is the task-specific question, $r$ contains the CoT reasoning path, and $y$ is the final answer. The rejection sampling process is adapted from the validation pipeline of GraphArena, ensuring that only well-formed, feasible, and correct solutions are preserved through a multi-round quality control procedure:

1. Response Extraction: We first parse structured solutions rather than purely numerical answers from the LLM outputs using regular expressions. Responses with formatting errors that prevent successful parsing are immediately discarded as infeasible. For NP-hard graph problem evaluation, structured solutions provide finer granularity and higher reliability compared to numerical answers. The expected formats are:

• •

TSP: A list representing the visiting route.

• •

GED: A list specifying the node mapping between two graphs.

• •

MCP: A list of node IDs in the clique.

2. Feasibility Check: Parsed solutions are then verified against task-specific constraints to ensure logical validity:

• •

TSP: The tour must visit each node once and return to start.

• •

GED: The node mapping must cover all nodes without repetition.

• •

MCP: The selected nodes must form a complete subgraph (clique).

3. Correctness Check: Solutions that pass the feasibility check are further validated by an algorithmic verifier. Specifically, instead of directly checking the numerical answers, we validate the detailed solution structures through algorithmic verification:

• •

TSP: The constructed tour must yield a total path length equal to the ground-truth value.

• •

GED: The computed edit distance must be equal to the ground truth.

• •

MCP: The identified clique must have the same size as the known maximum.

Only responses that pass all three stages are retained, so the SFT dataset comprises exclusively well-structured, feasible, and correct examples. At the same time, although all training instances are drawn from small-scale graphs, problem complexity—measured by the number of nodes—is carefully controlled to ensure a balanced distribution across levels. This construction simultaneously secures the quality and difficulty of the Long CoT dataset, providing a reliable foundation for the subsequent SFT stage.

3.1.2. Supervised Fine-Tuning

Following dataset construction, we conduct Supervised Fine-Tuning (SFT) to endow the model with Long CoT reasoning capabilities. Given a graph $G$ and a question $x$ as input, the model is trained to generate a reasoning path $r$ and subsequently the final answer $y$. We adopt a standard language modeling objective, defined as:

[TABLE]

where $N$ is the total number of QA pairs, $M_{i}$ denotes the number of reasoning steps in the CoT sequence of the $i$-th sample, and $\theta$ represents the model parameters.

This stage not only drives the model to produce long reasoning chains capable of solving NP-hard graph problems, but also implicitly encourages the development of systematic, step-by-step reasoning skills for tackling general complex reasoning tasks.

3.2. Reinforcement Learning

The goal of the RL stage is to address the reasoning inefficiency that emerges after the Long CoT SFT stage. By designing fine-grained reward functions, we guide the model to reduce redundant reasoning while maintaining solution quality, thereby producing more efficient reasoning paths. We employ Group Relative Policy Optimization (GRPO) [37] as our RL algorithm, chosen for its strong performance and low memory requirement.

Our reward function targets reasoning efficiency from three complementary perspectives. First, we directly penalize specific redundancy patterns in reasoning, which we implement via the repetition reward. Second, we implicitly promote efficient reasoning by rewarding high-quality solutions generated within limited context window, implemented as the solution quality reward. Third, we encourage outputs that follow structured format to reduce disorganized reasoning, implemented via the format reward. Formally, the reward function consists of three core components: repetition reward, solution quality reward, and format reward.

**Repetition Reward. ** Addressing overthinking in Long CoT reasoning has attracted substantial research attention. However, because overthinking is highly context-dependent, developing efficient and robust algorithms for its effective handling remains challenging. Consequently, many RL-based approaches adopt a simpler proxy, leveraging a response length reward to indirectly discourage overthinking by penalizing excessively long responses [45]. While this approach can reduce response length, it may also constrain the model’s ability to perform deeper reasoning, since reasoning length does not necessarily correlate with overthinking. We therefore focus on reducing overthinking based on the content of the reasoning process rather than its length. We identify a prevalent and detrimental overthinking pattern—repetition—and develop an efficient algorithm for its detection. Repetition refers to the phenomenon that LLM repeatedly generates the same statements until it reaches the context length limit. Such repetition not only undermines reasoning efficiency but also disrupts logical progression, often leading to low-quality solutions. Specifically, we define repetition as any substring of at least 20 characters repeated consecutively 5 times within a model response. This parameter setting, derived from empirical observations, effectively captures genuine repetition while avoiding false positives on valid reasoning. Specifically, we adopt a linear-time repetition detection algorithm based on suffix trees [3, 9] (see Appendix A.2). When repetition is detected, we apply a fixed penalty of -1 to the total reward.

Solution Quality Reward. We evaluate the quality of solutions within the context window, thereby encouraging reasoning that is concise yet effective. This evaluation adheres to the principles established in the Long CoT dataset construction (see in Section 3.1.1. Specifically, model responses are categorized into three types: optimal, suboptimal, and hallucinated. Optimal solutions yield the exact correct answer and receive the highest reward of 2.0. Hallucinated solutions that violate fundamental problem constraints are penalized with a reward of -1 to discourage unproductive exploration by the model. Suboptimal solutions satisfy the core problem constraints but fail to achieve optimality, often due to premature termination or inefficient exploration. For these, we assign a reward scaled between 0 and 0.5 based on the ratio between the achieved objective value and the optimal value. Specifically, the suboptimal reward is assigned as follows (see Appendix A.1 for more details).

• •

TSP: $R_{\textnormal{sub}}=\left(\tfrac{ans}{d}\right)^{2}\times 0.5$, where $d$ denotes the predicted tour length.

• •

GED: $R_{\textnormal{sub}}=\tfrac{ans}{c}\times 0.5$, where $c$ denotes the predicted edit cost.

• •

MCP: $R_{\textnormal{sub}}=\tfrac{s}{ans}\times 0.5$, where $s$ denotes the predicted clique size.

**Format Reward. ** We assign a format reward of 1.0 if the model response begins with the token "<think>". This encourages the model to show explicit reasoning phase before producing the final answer, thereby reducing disorganized thought patterns.

4. Experiments

4.1. Experimental Protocols

In this section, we conduct extensive experiments to evaluate NPG-Muse, guided by the following questions: -RQ1: How does NPG-Muse perform on NP-hard graph problems? -RQ2: How does NPG-Muse generalize to unseen complex reasoning tasks? -RQ3: Does NPG-Muse truly demonstrate the Long CoT capabilities?

4.1.1. Datasets and Metrics

The evaluated datasets fall into two categories: (1) Seen NP-hard graph problems from the training stage, including TSP, GED, and MCP provided by GraphArena [39]. The evaluation covers two settings: small-scale and large-scale problems. Notably, only small-scale samples are used for training, while large-scale datasets evaluate the model’s transferability and practicality. For GED and TSP, the small and large settings involve graphs with $4$–$9$ and $10$–$20$ nodes; for MCP, the corresponding scales are $4$–$14$ and $15$–$30$ nodes. (2) Unseen complex reasoning problems for testing the model’s generalization ability, including AIME24/25 [26], MATH-500 [19], GaoKao2023en [47], GSM8K [7], College Math [15], ASDIV [23], SVAMP [32] and TabMWP [22] for mathematical reasoning; CRUX [12] for code reasoning; Zebra-grid [20] for logical reasoning; GraphInstruct [5] and problems unseen during training from GraphArena [39] for graph reasoning.

For the seen NP-hard graph problems, the evaluation metrics include accuracy and feasibility. Accuracy measures the probability of obtaining the optimal solution, and feasibility measures the probability that the solution satisfies the basic problem constraints. For most unseen complex reasoning problems, we adopt the evaluation metrics used in their original benchmarks, which are primarily single-test accuracy. For the exceptionally challenging mathematical datasets AIME24/25, MATH-500 and GaoKao2023en, we employ avg@k and pass@k to provide a more robust assessment. The avg@k metric calculates the mean accuracy over $k$ independent attempts, reflecting the model’s average-case stability; conversely, pass@k measures the probability of achieving at least one correct solution within $k$ samples, characterizing the model’s potential coverage of the solution space. To balance evaluation comprehensiveness with computational efficiency, we set $k=64$ for AIME24/25 and $k=8$ for MATH-500 and GaoKao2023en. Further details on the datasets and metrics are provided in Appendix B.1.

4.1.2. Baselines

For comparison on NP-hard graph problems, we consider both general-purpose language models and graph-oriented models. The general-purpose models include: (i) closed-source models, GPT-4o [27] and Claude-3.5-Sonnet [2]; (ii) open-source reasoning models, QwQ-32B [41] and S1.1-7B [24] ; and (iii) open-source non-reasoning models Llama3-70B-Instruct [1] and our base models (Qwen3-8B-Base [42] and Qwen2.5-7B-Instruct-1M [40]). The graph-oriented models include Graphwiz-7B-DPO [5], Llama-8B-GT [16] and G1-7B [14]. For evaluation on unseen reasoning tasks, we adopt the base models of our NPG-Muse-8B and NPG-Muse-7B, namely Qwen3-8B-Base and Qwen2.5-7B-Instruct-1M. We additionally include larger models from the same family, Qwen3-14B-Base and Qwen2.5-14B-Instruct-1M, as scaling baselines. Additional details about these baselines are provided in Appendix B.2.

4.1.3. Implementation Details

We fine-tune Qwen3-8B and Qwen2.5-7B-Instruct-1M to obtain NPG-Muse-8B and NPG-Muse-7B, respectively, using PyTorch on 8 NVIDIA A800 (80GB) GPUs. Training is conducted with the Verl framework [38]. In the Long-CoT SFT stage, we train for two epochs with a batch size of 8, a cosine learning rate scheduler with an initial learning rate of $1\times 10^{-5}$ and a warmup ratio of 0.1, and a context length of 128k tokens. In the RL stage, we adopt the GRPO algorithm with a batch size of 128, a PPO mini-batch size of 32, a rollout number of 8, a sequence parallel size of 4, a KL coefficient of $1\times 10^{-3}$, a learning rate of $1\times 10^{-6}$, a maximum response length of 8192, and a temperature of 1.0. More implementation details are provided in Appendix B.3.

4.2. Main Results

4.2.1. Effect on NP-hard Graph Problems (RQ1)

We evaluate the NPG-Muse-series on NP-Hard graph problems, benchmarking against base models as well as state-of-the-art reasoning- and graph-oriented language models under two settings: (1) small-scale graphs consistent with training, and (2) large-scale graphs that test generalization and real-world applicability.

Results are reported in Table 1. NPG-Muse-7B achieves the superior overall accuracies of 86.7% and 28.1% on small- and large-scale graphs, respectively. Meanwhile, NPG-Muse-8B ranks third, performing marginally below QwQ-32B. Notably, although trained only on small-scale tasks, our models generalize effectively to large-scale ones. For example, NPG-Muse-7B attains 28.1% accuracy on large graphs—a 17$\times$ improvement over its base model (1.6%)—and even outperforms its teacher model QwQ-32B. These results confirm genuine generalization rather than memorization, validating the effectiveness of our approach in stimulating complex reasoning. Compared with closed-source baselines, which yield slightly higher feasibility on large graphs, our models achieve markedly higher accuracy. This reflects a trade-off: closed-source models appear to emphasize constraint propagation to secure feasible outputs, whereas ours prioritize deeper exploration of the solution space for accuracy gains. Beyond accuracy, the NPG-Muse series also exhibits strong token efficiency. As shown in Figure 3, NPG-Muse-7B requires only 6764 tokens on average, a 49% reduction compared to QwQ-32B (13252 tokens), highlighting the favorable balance between accuracy and efficiency achieved by our models.

4.2.2. Effect on Unseen Complex Reasoning Tasks (RQ2)

Table 3 reports the generalization performance of our models on mathematical, logical, code, and unseen graph reasoning benchmarks, demonstrating a consistent plug-and-play benefit of the proposed post-training pipeline.

Quantitatively, gains are observed for both the 7B and 8B families. On general reasoning benchmarks, NPG-Muse-7B increases macro accuracy from 65.6% to 68.0%, while NPG-Muse-8B rises from 63.2% to 74.1%. For challenging mathematical tasks evaluated with avg@k, the 7B backbone shows steady improvements (34.9% to 36.4%), whereas the 8B backbone exhibits a large jump (35.9% to 50.9%), with NPG-Muse-8B outperforming larger 14B scaling baselines. On unseen graph reasoning tasks, despite training only on small-scale TSP, GED, and MCP instances, transfer remains strong: NPG-Muse-7B improves the graph reasoning average from 32.9% to 36.2%, and NPG-Muse-8B increases from 25.2% to 54.4%, with gains across linear, polynomial-time, and NP-class problems. These results indicate that the method strengthens genuine symbolic and structural reasoning rather than relying on memorization.

Importantly, the direction of improvement is consistent across backbones, although the magnitude varies. Smaller backbones obtain modest gains, while stronger backbones yield substantially larger uplift from the same procedure. Together, these findings demonstrate the effectiveness and broad applicability of NP-hard graph problems as a scalable training resource for enhancing complex reasoning capabilities.

4.2.3. Effect on Long CoT Capabilities (RQ3)

We further investigate whether NPG-Muse truly incentivizes the Long CoT capabilities of LLMs by examining whether our model exhibits the three core characteristics of Long CoT in complex reasoning problems: Deep Reasoning, Extensive Exploration, and Feasible Reflection.

Deep Reasoning. To quantify deep reasoning, we measure average response length on challenging mathematics datasets. While response length is not a perfect surrogate for reasoning quality, longer chain-of-thought traces in structured mathematical tasks typically correspond to explicit intermediate deductions and verification steps, making it a practical behavioral proxy for reasoning depth. As shown in Table 4, both NPG-Muse-7B and NPG-Muse-8B consistently generate much longer responses than their respective base models across all datasets. On average, response length increases by approximately 4.4$\times$ for the 7B backbone and 2.5$\times$ for the 8B backbone, confirming a substantial expansion of reasoning depth after training. Importantly, this increase is not uniform across tasks. The largest multipliers appear on competition-level AIME problems, which demand extended multi-step reasoning, whereas MATH-500 and Gaokao23en exhibit more moderate growth. This task-dependent scaling indicates that our model does not blindly inflate its output, but instead adapts reasoning depth to problem difficulty. Such adaptive allocation of reasoning effort is a hallmark of genuine deep reasoning capability.

Extensive Exploration. We evaluate extensive exploration—the ability to search diverse solution paths—using the pass@k metric on challenging mathematics datasets. pass@k approximates the model’s upper-bound performance by measuring the probability that at least one of $k$ sampled outputs is correct; consistent gains therefore suggest a broader and more effective exploration of the solution space rather than repeated convergence to the same failure mode. As shown in Table 5, both backbones improve after training: the 7B model increases its average pass@k from 55.5 to 57.8, while the 8B backbone rises substantially from 65.5 to 74.3, with particularly large gains on AIME24 (+10.0) and AIME25 (+16.7). Improvements appear across both competition-level and curriculum-style datasets, indicating that enhanced exploration is not task-specific. Together, these results show that the NPG-Muse-series models expand their effective search over reasoning trajectories, increasing the likelihood of discovering correct solutions under sampling.

**Feasible Reflection. ** Inspired by [11], we adopt an LLM-as-a-judge framework to quantify the frequency of self-reflection behaviors. We select both seen and unseen tasks for observation: TSP (seen during training), Zebra-grid (unseen), and Common Neighbor Problem from Grapharena (unseen). These tasks involve minimal domain-specific knowledge, reducing potential confounding factors and ensuring more reliable statistics. For TSP, we track verification (checking correctness), backtracking (revising earlier steps), and heuristics (using shortcuts or hypothesis testing). For Zebra-grid and Common Neighbor, we retain verification and backtracking, but replace heuristics with hypothesis testing to better match the task characteristics. Figure 4 shows a clear increase in self-reflection across all tasks, demonstrating that our approach substantially enhances the model’s ability to refine strategies through self-reflection. Detailed prompts for our LLM-as-a-judge framework are provided in our code, and case studies are in Appendix 6.

4.3. Ablation Study

Effect of Each Training Stage. We analyze the contribution of each training stage (Long-CoT SFT and RL) to NPG-Muse-8B’s reasoning ability from two perspectives: effectiveness (solution accuracy) and efficiency (response length). Results are summarized in Table 6. The Long-CoT SFT stage substantially extends the model’s responses (average length increases from $2{,}198$ to $9{,}255$ tokens, a $4.2\times$ increase) and improves performance on most complex reasoning benchmarks, with particularly large gains on NP-hard graph problems and several mathematics datasets. However, SFT also introduces limitations: accuracy decreases on GSM8K, ASDIV and SVAMP, and outputs become excessively long with pronounced repetition on these tasks, indicating reduced robustness and the need for further refinement. After the RL stage, token efficiency is substantially improved while Long-CoT reasoning ability is preserved. The average response length falls to about $5{,}002$ tokens (approximately $2.3\times$ the base model and a 45.9% reduction relative to the Long-CoT SFT model), and the average accuracy increases from 55.6% to 62.5% (a $6.9$ percentage-point gain). In summary, the two-stage training (Long-CoT SFT followed by RL) strikes an effective balance between reasoning capability and token efficiency.

Effect of Fine-grained Reward Function. We analyze the impact of the fine-grained reward by comparing NPG-Muse-8B with a variant trained using a binary reward during the RL stage, where only fully correct solutions receive a fixed positive reward and all other outputs are left unshaped. As shown in Table 7, the fine-grained reward increases average accuracy on NP-hard graph problems from 49.2% to 51.1%, improves average feasibility from 88.9% to 91.9%, and reduces mean response length from 11,910 to 7,931 tokens (a 33% reduction). As demonstrated in Table 8, these benefits extend to broader reasoning tasks that require strict adherence to complex constraints, including graph, logic, and code reasoning. Overall performance improves consistently across domains, indicating that the fine-grained reward generalizes beyond the training distribution. Collectively, these results suggest that the fine-grained design achieves a better balance between correctness, constraint satisfaction, and conciseness by discouraging repetitive reasoning, explicitly rewarding suboptimal but feasible solutions, and enforcing output-format constraints. This leads to a more reliable ability to solve complex constraint-following problems in practice.

5. Related Work

Post-training Techniques for Reasoning Language Models. Post-training methods have become essential for enhancing reasoning capabilities in language models. Early techniques like prompt engineering and few-shot learning showed limited effectiveness on complex tasks [21]. Supervised Fine-Tuning (SFT) offers a more systematic approach by guiding models to imitate reasoning patterns from curated datasets. Combined with rejection sampling [43] for automatic acquisition of high-quality reasoning traces, SFT achieves substantial improvements on challenging benchmarks.

Subsequent methods moved beyond imitation learning. Direct Preference Optimization (DPO) [34] efficiently aligns models with human preferences but remains constrained by data quality and struggles with complex solution spaces. Reinforcement Learning (RL) proves more powerful, enabling models to explore diverse strategies, receive targeted feedback, and improve beyond fixed datasets. Approaches such as RLHF [31] and PPO [35] have achieved notable success [18, 44]. Group Relative Policy Optimization (GRPO) [37] further replaces absolute reward estimation with relative comparisons within sampled groups, reducing computational overhead while maintaining stable optimization. This property makes GRPO a practical framework for Long CoT post-training.

Language Models for Graph Tasks. Recent progress in graph language models has primarily focused on leveraging LLMs as task-specific solvers. GraphWiz [5] applies instruction tuning with SFT and DPO; GraphThought [16] introduces thought scaffolding for combinatorial optimization. While effective, these methods rarely investigate how graph reasoning generalizes across domains. More recently, researchers explore graph problems as training corpora for transferable reasoning. NLGift [48] benchmarks whether graph-trained LLMs acquire generalizable skills; GraphPRM [33] uses step-wise graph supervision for process reward models; GraphMind [46] employs graph corpora for continued pretraining. Concurrently, G1 [14] shows reinforcement learning on synthetic graph tasks enhances reasoning without degrading general capabilities. Despite observing transfer beyond graph domains, these works largely hypothesize mechanisms without providing deeper mechanistic evidence of how such transfer occurs.

In contrast, our framework identifies Long CoT capability as a central driver of cross-domain generalization. We demonstrate that NP-hard graph problems naturally elicit the long-horizon reasoning traces essential for transferable logic. By integrating these traces into a our training pipeline, we not only achieve substantial empirical gains but also provide mechanistic evidence for the underlying transfer. This establishes a scalable and robust path toward enhancing the reasoning capabilities of LLMs.

6. Conclusion and Limitation

In this work, we introduce NP-hard graph problems as a new training corpus to elicit Long CoT capabilities in LLMs. We propose a two-stage post-training framework combining Long-CoT SFT on rejection-sampled NP-hard graph instances with RL guided by fine-grained reward design. The resulting NPG-Muse-series models demonstrate significant improvements in Long CoT reasoning, with NPG-Muse-7B outperforming QwQ-32B on NP-hard graph problems. Our study positions NP-hard graph problems as a scalable and powerful corpus for advancing complex reasoning in LLMs.

Despite these promising results, our work has limitations. The training corpus covers only three types of NP-hard graph problems, and the methodology follows the standard SFT+RL paradigm without exploring alternative post-training strategies. Future work can address these limitations by expanding the problem diversity and investigating broader training approaches.

Appendix A More Details of Methodology

A.1. Solution Quality Reward

We apply consistent reward assignments across all tasks: optimal responses receive $2.0$, hallucinated solutions receive $-1.0$, and suboptimal solutions receive task-specific rewards scaled between [math] and $0.5$ based on the ratio between predicted and optimal values:

• •

TSP: $R_{\textnormal{sub}}=\left(\tfrac{ans}{d}\right)^{2}\times 0.5$, where $d$ denotes the predicted tour length.

• •

GED: $R_{\textnormal{sub}}=\tfrac{ans}{c}\times 0.5$, where $c$ denotes the predicted edit cost.

• •

MCP: $R_{\textnormal{sub}}=\tfrac{s}{ans}\times 0.5$, where $s$ denotes the predicted clique size.

We apply squaring only for TSP, as its objective values span a broader range than GED or MCP. Near optimality, the raw ratio $\tfrac{ans}{d}$ changes minimally, making fine-grained improvements difficult to capture. Squaring amplifies differences among near-optimal tours while compressing rewards for poor solutions. In contrast, GED and MCP operate within narrower ranges where linear ratios provide sufficient feedback. The [math]–$0.5$ range is chosen to ensure distinguishability from optimal ($2.0$) and hallucinated ($-1.0$) rewards: the lower bound arises naturally from the ratio, while the upper bound of $0.5$—rather than $1.0$—widens the gap between suboptimal and optimal solutions, producing a steeper reward signal that improves the model’s sensitivity to solution quality.

A.2. Repetition Detection Algorithm

Our approach (Algorithm 1) identifies repetitive patterns by building a suffix automaton from the model’s output. The process involves topologically sorting states and calculating occurrence counts through bottom-up propagation to detect meaningful repetitions exceeding predefined thresholds for length and frequency, with prioritization based on frequency, length, and position. With $O(n)$ time complexity, it enables real-time detection even in extensive outputs, making it valuable for reward design in resource-intensive reinforcement learning and for broader applications in production environments and interactive systems.

Appendix B More Experiment Details

B.1. Details of Datasets and Metrics

Dataset descriptions and evaluation metrics are as follows:

• •

**AIME [26]. ** Competition-level mathematics problems from the American Invitational Mathematics Examination. We evaluate on the 2024 and 2025 problems.

• •

**MATH-500 [19]. ** A curated subset of 500 problems from the MATH benchmark, spanning diverse mathematical domains and difficulty levels.

• •

**GaoKao2023en [47]. ** An English translation of the mathematics section from the 2023 Chinese National College Entrance Examination (GaoKao). It consists of challenging high-school level problems that require comprehensive logical reasoning.

• •

**College Math [15]. ** A collection of advanced mathematical problems sourced from university-level curricula, including calculus, linear algebra, and probability. Evaluation is based on accuracy.

• •

**ASDIV [23]. ** A Diverse Corpus for Evaluating and Developing Math Word Problem Solvers, featuring high linguistic variety and varying mathematical complexity. We evaluate performance using answer accuracy.

• •

**GSM8K [7]. ** 8.5K grade school math word problems designed to evaluate multi-step numerical reasoning and arithmetic problem-solving. Evaluation uses accuracy.

• •

**SVAMP [32]. ** A challenge set of synthetic arithmetic word problems created by applying robust perturbations to existing datasets. It tests the model’s reasoning consistency against linguistic variations. Performance is measured by accuracy.

• •

**TabMWP [22]. ** A large-scale dataset of mathematical word problems where the reasoning context is embedded in tabular data, requiring the model to synthesize information across text and tables. We report the accuracy.

• •

CRUX [12]. 800 Python programming problems with input-output test cases, defining input prediction and output prediction tasks. We use the pass@1 metric.

• •

Zebra-grid [20]. Logic grid puzzles derived from constraint satisfaction problems, enabling systematic complexity control. Performance is measured by accuracy based on whether solutions satisfy all constraints.

• •

GraphArena [39]. A benchmark suite with ten graph computational tasks (four polynomial-time, six NP-hard). We measure accuracy (optimal solution rate) and feasibility (valid solution rate). We utilize the TSP, GED, and MCP subsets for training and in-task evaluation, and the Neighbor and Distance subsets for generalization evaluation.

• •

GraphInstruct [5]. An instruction-tuning dataset covering nine graph reasoning tasks with explicit multi-step reasoning paths. We report zero-shot accuracy on the Hamilton Path subset.

B.2. Details of Baselines

We incorporate 11 language models as baselines, with detailed descriptions provided below:

• •

Closed-source Models.

• –

Claude-3.5-Sonnet [2] is a proprietary model by Anthropic.

• –

GPT-4o [27] is a proprietary model by OpenAI.

• •

Reasoning Models.

• –

QwQ-32B [41] is a 32B-parameter reasoning model trained with multi-stage RL.

• –

S1.1-7B [24] is a reasoning model fine-tuned from Qwen2.5-7B-Instruct using SFT based on the s1K-1.1 [24] dataset, which includes 1000 questions paired with reasoning traces.

• •

Non-reasoning Models.

• –

LLaMA-3-70B [1] is a 70B-parameter language model by Meta.

• –

Qwen3-8B-Base [42] is an 8B-parameter base model from Alibaba Cloud, pre-trained on 36 trillion tokens with enhanced reasoning and coding capabilities.

• –

Qwen2.5-7B-Instruct-1M [40] is a 7B parameter model designed for general-purpose tasks, featuring extended context length up to 1 million tokens.

• •

Graph-oriented Language Models.

• –

G1-7B [14] is a model fine-tuned from Qwen2.5-7B-Instruct, using reinforcement learning on graph-theoretic tasks, outperforming Qwen2.5-72B-Instruct on graph reasoning tasks.

• –

LLaMA-8B-GT [16] is a model fine-tuned from LLaMA-3-8B-Instruct to solve graph combinatorial optimization problems. It matches the performance of OpenAI’s o1-mini on GraphArena.

• –

GraphWiz-7B-DPO [5] is a model fine-tuned from LLaMA-2-7B using SFT and DPO for graph computational problems, outperforming GPT-4 across nine graph tasks.

B.3. More Implementation Details

**Details of Training. ** During training, we utilize synthetically generated small-scale instances of NP-hard graph problems, while evaluation relies on both small- and large-scale instances from GraphArena. To ensure data quality and prevent leakage, we employ GraphArena’s official data generation script with different random seeds (43 for SFT and 45 for RL, compared to 0 in the official release) and implement a strict de-duplication pipeline to guarantee the uniqueness of all samples.

To ensure a balanced distribution across tasks and difficulty levels, we adopt a uniform sampling strategy. During the Supervised Fine-Tuning (SFT) stage, we generate 500 instances per graph size $n\in\{4,\dots,9\}$ for TSP and GED, and 250 instances per size $n\in\{4,\dots,15\}$ for MCP, totaling 9,000 training instances. For the Reinforcement Learning (RL) stage, 4-node instances are omitted. We generate 3,000 instances per size for TSP and GED ($n\in\{5,\dots,9\}$) and 1,500 per size for MCP ($n\in\{5,\dots,14\}$), yielding a total of 45,000 training instances. We also design stage-specific prompt templates. In both stages, we modify GraphArena’s official templates by removing in-context examples. In the RL stage, we design an extra system prompt which encourages a structured "think first, then answer" approach, discourage code-based solutions, and emphasize step-by-step reasoning. The system prompt template and condensed examples for all three tasks are presented below.

**Prompts B.3.1: **System prompt in the RL stage

You are a helpful assistant. The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning process and answer must be formatted exactly as follows:<think>[your reasoning process here]</think><answer>[your answer here]</answer>. You can choose to imitate the reasoning process of relevant algorithms or explore an appropriate solution on your own. DO NOT use code, and remember to focus on the logical flow.

**Prompts B.3.2: **Condensed example for TSP

You are required to solve the Traveling Salesman Problem for an undirected flight route network. Your objective is to determine the shortest possible route that visits each of the listed airports exactly once and returns to the starting point.

Problem to Solve*

• Airports to visit: BVC, URA, SMR, KOK, MTV, YZF

• Travel distances (in kilometers) between each pair of airports:

BVC to KOK: 6401

URA to KOK: 3138

SMR to KOK: 11079

MTV to YZF: 12733

Please calculate the shortest tour and format your answer as follows: [Airport A, Airport B, Airport C, …, Airport A]

**Prompts B.3.3: **Condensed example for GED

You are required to solve the Graph Edit Distance problem between two molecules. Each edit operation (adding or deleting an edge, adding or deleting an isolated node, or relabeling a node) has the identity cost. Your objective is to establish a mapping between the atom IDs from Molecule A to Molecule B, ensuring that each atom ID in Molecule A corresponds to exactly one atom ID in Molecule B. The mapping corresponds to the minimum edit cost between the two graphs.

Problem to Solve

You are given the following two molecules:

Molecule A:

• Atoms: Cl (atom 0), C (atom 1), Cl (atom 2), Cl (atom 3).

• Bonds: 0-1, 1-2, 1-3.

Molecule B:

• Atoms: Cl (atom 0), Ge (atom 1), Cl (atom 2), Cl (atom 3).

• Bonds: 0-1, 1-2, 1-3.

Represent the node mapping as a list of integers, where the position in the list corresponds to the atom ID in Molecule A and the value at that position indicates the corresponding atom ID in Molecule B. For instance, if atom 0 in Molecule A corresponds to atom 1 in Molecule B, atom 1 in Molecule A corresponds to atom 0 in Molecule B, and atom 2 remains unchanged, the mapping would be represented as [1, 0, 2, …].

**Prompts B.3.4: **Condensed example for MCP

You are required to solve the Maximum Clique Problem for an undirected academic network. In this network, nodes represent authors and edges represent research collaborations. Your objective is to find the largest subset of nodes such that every pair of vertices in this subset is connected by an edge.

Problem to Solve*

• Authors in the network: Gang Zhou, Michel Misson, Pascale Minet, Gary V. Yee, Bhaskar Krishnamachari, Erwan Livolant

• Research collaborations between these authors: Gang Zhou and Bhaskar Krishnamachari, Michel Misson and Pascale Minet, Michel Misson and Gary V. Yee, Pascale Minet and Bhaskar Krishnamachari, Pascale Minet and Erwan Livolant

Identify the clique with the maximum number of authors in this network. Present your answer in the following format: [AuthorA, AuthorB, AuthorC, AuthorD, …].

Details of Self-reflection Behavior Evaluation. Inspired by [11], we investigate how self-reflection behaviors evolve in the NPG-Muse models, aiming to uncover the mechanisms underlying their performance improvements on complex reasoning tasks. We focus on three typical types of self-reflection: verification (checking correctness), backtracking (revising earlier steps), and heuristics (using shortcuts or hypothesis testing). To quantify these behaviors, we employ the LLM-as-a-judge framework with Qwen3-8B [42], a lightweight yet state-of-the-art model. The prompts are adapted to the nature of each task to ensure consistent annotation—for example, heuristics are reframed as hypothesis testing in contexts where this interpretation better reflects the reasoning process. The complete prompts are listed below.

**Prompts B.3.5: **Prompt template for identifying self-reflection behaviors on TSP task

1. Distance Verification

The following is the reasoning process of a language model solving a TSP (Traveling Salesman Problem) task: [your reasoning process here]

Evaluate whether this reasoning process includes steps for verifying distance calculations. Verification steps may include: checking the correctness of distances between two points, verifying total path length calculations, or confirming if a certain path is indeed the shortest. Examples include: "The distance is 116+79+180+189=564" or "Verifying the total distance: 44+114+132+142=432".

Count the number of such verification steps and provide this number between the tags <count></count>. If there are no verification steps, return <count>0</count>.

2. Backtracking Behavior

The following is the reasoning process of a language model solving a TSP (Traveling Salesman Problem) task:[your reasoning process here]

Evaluate whether this reasoning process includes backtracking behavior, where the model realizes the current path may not be optimal and returns to try different paths. For example, the model might try a path "0->1->2->3->0", find it’s not optimal, and then try "0->2->1->3->0".

Count the number of distinct backtracking instances and provide this number between the tags <count></count>. If there is no backtracking behavior, return <count>0</count>.

3. Heuristic Strategies

The following is the reasoning process of a language model solving a TSP (Traveling Salesman Problem) task:[your reasoning process here]

Evaluate whether this reasoning process uses explicit heuristic strategies, such as the greedy algorithm (always choosing the nearest next city), minimum spanning tree, nearest neighbor algorithm, etc. For example: "Starting from city 0, the nearest city is city 2 with a distance of 44" demonstrates a greedy/nearest neighbor strategy.

Count the number of distinct heuristic strategies explicitly used and provide this number between the tags <count></count>. If no heuristic strategies are explicitly used, return <count>0</count>.

**Prompts B.3.6: **Prompt template for identifying self-reflection behaviors on common neighbor task

1. Connection Verification

The following is the reasoning process of a language model solving a neighbor query task on a graph:[your reasoning process here]

Evaluate whether this reasoning process includes steps for verifying connections between nodes. Verification steps may include: checking if edges exist between specific nodes, validating relationships, or confirming the presence of connections. Examples include: "X is connected to Y" or "Verifying that Z is a neighbor of both A and B".

Count the number of such verification steps and provide this number between the tags <count></count>. If there are no verification steps, return <count>0</count>.

2. Backtracking Behavior

The following is the reasoning process of a language model solving a neighbor query task on a graph:[your reasoning process here]

Evaluate whether this reasoning process includes backtracking behavior, where the model realizes the current approach may not be correct and returns to try different approaches. For example: "Let me reconsider the connections" or "But let me check if this path is valid".

Count the number of distinct backtracking instances and provide this number between the tags <count></count>. If there is no backtracking behavior, return <count>0</count>.

3. Hypothesis Testing

The following is the reasoning process of a language model solving a neighbor query task on a graph:[your reasoning process here]

Evaluate whether this reasoning process includes instances where the model proposes and tests hypotheses about node relationships or graph properties. Examples include: "Let’s check if X could be a common neighbor of A and B" or "If we assume this graph is connected, then…"

Count the number of distinct hypothesis testing instances where the model makes temporary assumptions and provide this number between the tags <count></count>. If there is no evidence of hypothesis testing, return <count>0</count>.

**Prompts B.3.7: **Prompt template for identifying self-reflection behaviors on logic puzzle task

1. Constraint Validation

The following is the reasoning process of a language model solving a logic puzzle (zebra/Einstein puzzle):[your reasoning process here]

Evaluate whether this reasoning process includes steps for validating constraints or checking if a potential solution satisfies the given clues. Examples include: "This placement satisfies clue 3" or "Let’s check if this arrangement meets all constraints."

Count the number of distinct constraint validation instances and provide this number between the tags <count></count>. If there are no validation steps, return <count>0</count>.

2. Backtracking Behavior

The following is the reasoning process of a language model solving a logic puzzle (zebra/Einstein puzzle):[your reasoning process here]

Evaluate whether this reasoning process includes backtracking behavior, where the model realizes the current path or assumption may not be correct and returns to try different approaches. For example: "This assumption leads to a contradiction, so let’s try another possibility" or "Let’s reconsider our initial placement for Person X."

Count the number of distinct backtracking instances and provide this number between the tags <count></count>. If there is no backtracking behavior, return <count>0</count>.

3. Hypothesis Testing

The following is the reasoning process of a language model solving a logic puzzle (zebra/Einstein puzzle):[your reasoning process here]

Evaluate whether this reasoning process includes instances where the model proposes and tests hypotheses or makes tentative assumptions to explore possibilities. Examples include: "Let’s assume Person X is in House Y and see if this works…" or "If we temporarily place the red house at position 3, then…"

Count the number of distinct hypothesis testing instances where the model makes temporary assumptions to test outcomes and provide this number between the tags <count></count>. If there is no evidence of hypothesis testing, return <count>0</count>.

Appendix C More Experiment Results

C.1. More Results on Long CoT Capabilities

As illustrative evidence, Figures 5 and 6 present case studies demonstrating the substantial increase in self-reflection behaviors in NPG-Muse compared with its base model.