1 Introduction↩︎

Large language models (LLMs) have made remarkable progress on mathematical reasoning tasks, driven by the Chain-of-Thought (CoT) paradigm [1], [2]. Under this question \(\rightarrow\) cot paradigm, the model produces, in a single forward pass, a long sequence that interleaves intermediate reasoning steps with the final answer. Combined with supervised fine-tuning (SFT) on CoT trajectories [3] and reinforcement learning (RL) from verifiable rewards [4], this paradigm has achieved strong results across a wide range of mathematical benchmarks [5].

As problems grow more complex, however, single-pass CoT reveals a structural limitation: operating as an autoregressive, token-level process, it confines reasoning to step-level execution and lacks higher-level organization, yielding redundant or incoherent trajectories. Recent work addresses this issue by inserting an intermediate planning stage, giving rise to the question \(\rightarrow\) plan \(\rightarrow\) cot paradigm: Plan-Tuning [6] distills planning trajectories from large models and fine-tunes smaller LLMs on (question, plan, solution) triples, while PTA-GRPO [7] introduces plan-level guidance rewards during reinforcement learning. Their shared insight is that an explicit plan-level layer above step-level execution supplies the global organization that single-pass CoT lacks.

However, a closer examination of the question \(\rightarrow\) plan \(\rightarrow\) cot paradigm reveals that its two stages, planning and execution, differ in granularity but share the same underlying role: both decide how to solve the problem—the plan organizes the solution, and the execution carries it out. What neither stage addresses is the prior question of what to solve: such as recognizing what type of problem it is, which tools or concepts may apply, which boundary conditions matter, and which pitfalls to anticipate. For example, given a problem \(12x^2 - xy - 6y^2 = 0\), recognizing it as a homogeneous quadratic immediately signals the model to prioritize factorization over the more cumbersome discriminant method, while also indicating that each linear factor produces a family of solutions. Consequently, the subsequent plan can follow these hints and count solutions correctly. Existing methods implicitly assume that such understanding emerges for free during plan generation, leaving a paradigm-level gap: how to solve is modeled explicitly, whereas what to solve remains implicit. We refer to this missing stage as the preplan: an explicit problem-understanding stage that precedes planning.

Figure 1 illustrates the cost of this paradigm-level gap. We diagnose the errors made by two representative question \(\rightarrow\) plan \(\rightarrow\) cot methods on MATH-500 [8], using an LLM judge to attribute each wrong answer to its root cause (see Appendix 6 for more details). Across four backbones, a large fraction of their errors stem not from calculation, but from a failure to understand what to solve. This exposes the cost of leaving problem understanding implicit and motivates introducing it as an explicit stage prior to planning.

While conceptually intuitive, bridging this gap by directly introducing a problem-understanding stage faces two concrete challenges. Challenge 1 (data construction). No existing reasoning dataset provides supervision for such a preplan stage, and directly prompting a strong LLM to generate it tends to fail in two ways. The output either rehearses the forthcoming plan (leakage failure), or quietly carries out intermediate computation under the guise of analysis (spoiler failure). Both collapse the stage back into how to solve, defeating its purpose. Challenge 2 (training-time adherence). Even given clean supervision, a model trained with standard outcome rewards may learn to emit a superficially well-formed analysis while ignoring it during plan generation, capturing the mere form of problem understanding without its practical utility. A successful framework must therefore enforce that the downstream plan genuinely follows from the preceding preplan.

To address these challenges, we propose PPC (Preplan-Plan-CoT), a framework that explicitly introduces a problem-understanding stage, the preplan, into both data construction and reinforcement learning, giving rise to the new question \(\rightarrow\) preplan \(\rightarrow\) plan \(\rightarrow\) cot paradigm. A preplan is a comprehensive analysis about the problem that identifies the problem type, surveys relevant tools and concepts, flags the boundary conditions that matter, and anticipates pitfalls—it settles what to solve and leaves how to solve to the subsequent planning and execution stages. To address Challenge 1, we design a three-stage synthesis pipeline guarded by a spoiler-score detector that filters out leakage and spoiler failures, yielding a clean reasoning dataset with explicit preplan supervision. For Challenge 2, we extend GRPO with a composite reward that jointly optimizes final-answer correctness and plan-preplan alignment, while enforcing structural compliance across the three stages and penalizing preplan style degradation through the same spoiler score.

Figure 2 makes this new paradigm concrete: on the same problem, a question \(\rightarrow\) plan \(\rightarrow\) cot solver commits to a fragile route without analyzing what the problem requires, whereas an explicit preplan first recognizes the structure and selects a reliable route, guiding the subsequent plan toward the correct solution. This mirrors the aggregate trend in Figure 1. Our main contributions are as follows:

• Conceptually: We identify and formalize a paradigm-level gap in existing plan-based reasoning: current methods model how to solve explicitly but leave what to solve implicit. To bridge it, we propose the question \(\rightarrow\) preplan \(\rightarrow\) plan \(\rightarrow\) cot paradigm for the first time.

• Methodologically: We construct the first reasoning dataset with explicit preplan supervision, protected by a spoiler-score detector against the two characteristic generation failures, leakage and spoiler. We then design a composite GRPO reward whose plan-preplan alignment term explicitly enforces that the generated plan follows from the preceding preplan, preventing the model from generating superficially well-formed but otherwise ignored preplans.

• Empirically: Across four backbones and five mathematical reasoning benchmarks, PPC achieves the best results on 39 of 40 metrics, improving maj@16 and pass@16 by +2.23 and +3.06 over the strongest baseline without introducing additional inference token overhead.

2 Related Work↩︎

2.1 LLM Reasoning with Chain-of-Thought↩︎

Chain-of-thought (CoT) prompting [1], [2] established that eliciting intermediate reasoning steps before the final answer substantially improves LLM performance on complex reasoning tasks, and has since become the dominant paradigm for mathematical reasoning. To strengthen this capability beyond in-context prompting, two complementary post-training directions have been actively explored. The first relies on supervised fine-tuning over distilled CoT trajectories [9]–[11], where strong teacher models generate large pools of step-by-step solutions that are used to fine-tune smaller students. The second, popularized by DeepSeek-R1 [4], and subsequently extended by a growing line of work [12]–[14], applies reinforcement learning with verifiable rewards(RLVR), in which models receive direct correctness feedback from deterministic verifiers and learn to produce long CoT trajectories with exploration. Despite these advances, recent analyses show that CoT trajectories generated by LLMs remain step-level: the model derives each step locally as it decodes, without an explicit mechanism to commit to a global solution structure beforehand [7], [15]. This limitation motivates a complementary line of work that introduces higher-level structure into the reasoning process.

2.2 Plan-Based Reasoning↩︎

A complementary direction to scaling step-level CoT is to introduce higher-level structure into the reasoning process. Early prompting-based work asks the model to plan before solving [15] or decomposes problems into simpler sub-questions [16], with later extensions exploring hierarchical sub-goals [17], [18] and tree-structured exploration [19]. They share the premise that organization above individual steps improves coherence on multi-stage problems. Recent work integrates planning into post-training. Plan-Tuning [6] distills planning trajectories from large reasoning models and supervises smaller LLMs on (question, plan, solution) triples, while PTA-GRPO [7] extends this to RL with a plan-aware reward that jointly evaluates plan quality and final answer correctness, elevating planning from an inference-time trick to a training-time objective. Yet all of these methods treat the plan as the entry point of structured reasoning: both the planning and its execution answer how to solve the problem, while the prior question of what the problem is asking remains implicit. Our work targets this gap by introducing an explicit preplan stage upstream of planning, together with a training objective that enforces the downstream plan to genuinely follow from it.

3 Methodology↩︎

Our goal is to teach LLMs a new reasoning paradigm, question \(\rightarrow\) preplan \(\rightarrow\) plan \(\rightarrow\) cot, in which a preplan that analyzes what to solve precedes the planning and execution that decide how to solve. The defining property of the preplan is that it analyzes what to solve rather than how: it surveys problem type, tools, constraints, and pitfalls without committing to a derivation. This conceptual boundary is fragile at both ends of training. During data construction, a generator asked for a preplan tends to slip back into how to solve, through leakage or spoiler; during reinforcement learning, a policy may reproduce the form of a preplan while ignoring it when generating the following plan: the two failures of Challenge 1 and Challenge 2 (§1).

PPC addresses both through a single organizing principle. Stage 1 (§3.2) supplies a clean demonstration of the paradigm by filtering out leakage and spoiler, and Stage 2 (§3.3) enforces faithful use through a composite reward. Crucially, the same rule-based signal \(s(\cdot)\) patrols both ends: as a hard filter when building data (Eq. 4 ) and as a soft penalty during RL, ensuring that the same conceptual integrity constraint is enforced.

3.1 Preliminaries↩︎

3.1.0.1 Problem formulation.

Given a question \(q\), the policy \(\pi_\theta\) generates a structured trajectory \(y = (y_{\text{pp}}, y_{\text{p}}, y_{\text{e}})\) enclosed by tags <preplan>, <plan>, <execute>, with the final answer \(\hat{a}(y)\) parsed from a \boxed{} marker in \(y_{\text{e}}\). Unlike the prior question\(\rightarrow\)plan\(\rightarrow\)cot paradigm, we additionally require \(y_{\text{pp}}\) to be a non-computational problem-understanding analysis upstream of the plan.

3.1.0.2 GRPO.

We adopt Group Relative Policy Optimization [12] as our RL backbone. For each prompt \(q\), GRPO samples a group \(\{y^{(i)}\}_{i=1}^{G} \sim \pi_{\theta_{\text{old}}}(\cdot \mid q)\) and computes group-normalized advantages \[\hat{A}_i = \frac{R(y^{(i)}) - \text{mean}(\{R(y^{(j)})\}_{j=1}^{G})}{\text{std}(\{R(y^{(j)})\}_{j=1}^{G})} \label{eq:advantage}\tag{1}\] then optimizes the clipped policy objective with a KL regularizer to a reference policy \(\pi_{\text{ref}}\): \[\begin{align} \mathcal{J}_{\text{GRPO}}(\theta) = {E}_{q,\{y^{(i)}\}}\bigg[ & \frac{1}{G}\sum_{i=1}^{G}\min\!\big(\rho_i \hat{A}_i,\; \\ \text{clip}(\rho_i, 1\!-\!\epsilon, 1\!+\!\epsilon)\hat{A}_i\big) & - \beta\,{D}_{\text{KL}}\!\left[\pi_\theta \,\|\, \pi_{\text{ref}}\right]\bigg] \end{align} \label{eq:grpo}\tag{2}\] where \(\rho_i = \pi_\theta(y^{(i)} \mid q) / \pi_{\theta_{\text{old}}}(y^{(i)} \mid q)\) and \(\epsilon, \beta\) are hyperparameters.

3.2 Stage 1: Preplan-Supervised Data Construction↩︎

The difficulty for dataset construction is not generation but conceptual integrity. Specifically, a leakage preplan typically rehearses the plan’s step sequence; while a spoiler preplan tends to substitute concrete computation for structural description. Both collapse the stage back into how to solve. Our pipeline counters the first by construction and the second by filtering.

3.2.0.1 Three-stage synthesis.

Each trajectory is generated by conditioning every stage only on its predecessors: \[\begin{align} y_{\text{pp}} \sim \pi_{\text{pp}}(\cdot \mid q), &\quad y_{\text{p}} \sim \pi_{\text{p}}(\cdot \mid q, y_{\text{pp}}),\\ \quad y_{\text{e}} \sim \pi_{\text{e}}(\cdot \mid q, y_{\text{p}}) \end{align} \label{eq:synthesis}\tag{3}\] The strict left-to-right, stage-wise generation process allows finer-grained control over different components of the reasoning trajectory. Leakage is suppressed by construction at the prompt level: \(\pi_{\text{pp}}\) is prompted to forbid derivations, intermediate values, step-by-step procedures, and any reference to a solution path, so that the supervision targets what to solve rather than how. Implementation details are given in Appendix 8.

3.2.0.2 Spoiler-score filtering.

Left-to-right ordering does not prevent spoiler, since a generator can compute within a single stage. We therefore retain a trajectory only if its preplan is pure and its answer is correct: \[s(y_{\text{pp}}) \le \tau_s \quad\text{and}\quad \hat{a}(y) \equiv a^\star \label{eq:filter}\tag{4}\] where \(s(\cdot) \in \{0,\dots,6\}\) is a rule-based spoiler score that aggregates several derivation- and answer-revealing signals (defined in Appendix 9). The check is deliberately decoupled from correctness: a trajectory whose answer is correct is still discarded if its preplan is impure. For instance, a preplan that already asserts computed classifications and rehearses the exact series-expansion procedure scores high and is filtered out despite reaching the correct answer (full example in Appendix 7). This separation is the point: the filter targets preplan purity, not answer correctness. The retained corpus \(\mathcal{D}_{\text{SFT}}\) initializes the policy by token-level fine-tuning, \[\mathcal{L}_{\text{SFT}}(\theta) = -\,{E}_{(q,y)\sim\mathcal{D}_{\text{SFT}}} \!\sum_{t} \log \pi_\theta(y_t \mid q, y_{<t}) \label{eq:sft}\tag{5}\] yielding the model \(\pi_{\theta_0}\) that initializes the RL stage.

3.3 Stage 2: Composite-Reward RL↩︎

Clean demonstrations teach the policy to produce the paradigm’s form, but imitation cannot guarantee the policy actually uses each stage: a fluent preplan may be silently ignored when the plan is generated (Challenge 2). We therefore use reinforcement learning to anchor every stage to an explicit reward, replacing the binary outcome reward of standard GRPO with a four-term composite: \[\begin{align} R(y) = R_{\text{out}}(y) + &\lambda_a R_{\text{adh}}(y) + \lambda_f R_{\text{fmt}}(y) \\ -\lambda_s R_{\text{sty}}(y) \end{align} \label{eq:reward}\tag{6}\] with weights \(\lambda_a, \lambda_f, \lambda_s > 0\). Intuitively, \(R_{\text{out}}\) anchors still solving the problem, \(R_{\text{adh}}\) anchors the preplan being inherited by the plan, and \(R_{\text{fmt}}, R_{\text{sty}}\) prevent the first two from being gamed. All scores come from frozen judges not updated during RL; exact mappings, weights, and judge prompts are in Appendix 10, with ranges summarized in Table 1.

3.3.0.1 (1) Outcome reward with partial credit.

A \(0/1\) reward gives no gradient on near-miss trajectories whose preplan and plan are nonetheless informative. Following the partial-credit view of rubric-based rewards [20], we score incorrect answers by an LLM-judged proximity level \(J_{\text{prox}}(y)\) rating solution-path quality (not numerical closeness): \[R_{\text{out}}(y) = \begin{cases} 1, & \hat{a}(y) \equiv a^\star, \\[2pt] g\big(J_{\text{prox}}(y)\big), & \text{otherwise} \end{cases} \label{eq:outcome}\tag{7}\] where \(g\) is a monotone map capped strictly below \(1\). The cap preserves a margin between near-miss and correct trajectories, thus the policy cannot inflate partial credit into the appearance of a correct answer.

3.3.0.2 (2) Plan–preplan adherence reward.

An LLM critic \(J_{\text{adh}}(\cdot,\cdot)\) scores the strategic alignment between \(y_{\text{pp}}\) and \(y_{\text{p}}\), normalized to \(R_{\text{adh}}(y) \in [0,1]\). The critic is instructed to judge alignment, not plan quality; thus, a strong plan that ignores the preplan still obtains lower score. This also prevents the preplan from being decoratively produced but functionally ignored: tying the plan to the preplan rather than letting it become an independent solution.

3.3.0.3 (3) Structural format guard.

\(R_{\text{fmt}}(y) \in \{0, 1\}\) checks that the three tags each appear exactly once and in order and that a \boxed{} marker lies inside \(y_{\text{e}}\), preventing the other rewards from being satisfied by malformed outputs.

3.3.0.4 (4) Spoiler-style penalty.

Reusing the spoiler score \(s(\cdot)\) from Eq. 4 , we apply a one-sided penalty \(R_{\text{sty}}(y) = \max(0,\, s(y_{\text{pp}}) - \tau_s)\), activated only when the preplan drifts back toward derivation-heavy content during RL. Thus the conceptual integrity of preplan purified at construction time is held throughout training by the same signal.

3.3.0.5 Summary

\(R_{\text{out}}\) keeps correctness as the dominant objective; \(R_{\text{adh}}\) ensures the preplan is used rather than produced; \(R_{\text{fmt}}\) and \(R_{\text{sty}}\) prevent these signals from being satisfied through ill-formed outputs or by collapsing the preplan into computation. Notably, without \(R_{\text{sty}}\) the model can satisfy adherence by writing a derivation-style preplan that trivially aligns with the downstream plan, defeating the purpose of our paradigm. We ablate each term in §4.2.2.

4 Experiments↩︎

4pt 0pt 0pt

4.1 Experimental Setup↩︎

4.1.0.1 Training data.

We build our training corpus from DeepMath-103K [21], a large-scale mathematical reasoning dataset with per-problem difficulty annotations. We retain problems spanning four difficulty levels from medium to competition-hard, and stratify-sample a non-overlapping SFT/RL split of problems. SFT trajectories are then synthesized and filtered as described in §3.2, yielding the final training set.

4.1.0.2 Models.

To evaluate generality across model scales and families, we apply our framework to four base models: Qwen2.5-7B-Instruct [22], Qwen2.5-Math-7B-Instruct [23], LLaMA-3.1-8B-Instruct [24] and Qwen3-4B-Instruct [25].

4.1.0.3 Benchmarks.

We evaluate on five mathematical reasoning benchmarks spanning a wide difficulty range: AIME25, Minerva-Math [26], OlympiadBench [27], MATH-500 [8] and GSM8K [28].

4.1.0.4 Baselines.

We compare against the following methods, all trained on the same data splits for fairness: (i) Base: the untrained backbone with zero-shot CoT prompting; (ii) Prompt-Only: the same untrained backbone prompted to first analyze the problem itself:its type, relevant concepts, strategic direction, constraints, and pitfalls; and then form a plan before solving; this elicits PPC’s preplan-then-solve structure purely through instruction, isolating whether prompt engineering alone suffices and thereby testing the necessity of our training; (iii) GRPO [12]: standard GRPO with a binary outcome reward, initialized from vanilla SFT; (iv) Plan-Tuning [6]: a post-training framework that distills planning trajectories from larger LLMs and fine-tunes the model via combined supervised and reinforcement-learning objectives; (v) PTA-GRPO [7]: a two-stage framework that first performs SFT on distilled high-level guidance and then applies GRPO with a plan-aware reward.

4.1.0.5 Evaluation protocol.

For each problem we sample \(k=16\) trajectories and report maj@16 (self-consistency majority vote) as our primary metric, together with pass@16 as an upper-bound coverage measure. All methods use the identical chat template and system prompt (“Please reason step by step, and put your final answer within \boxed{}”. Final answers are extracted from the last \boxed{} marker and scored by the same answer-equivalence verifier used in training (§3.3).

4.1.0.6 Implementation details.

Data synthesis: The three-stage trajectories of §3.2 are generated with Qwen3-235B [25] as the preplan and plan generators (\(\pi_{\text{pp}}, \pi_{\text{p}}\)) and DeepSeek-R1 [4] as the execution model (\(\pi_{\text{e}}\)); the raw solution is then reorganized into a numbered execution by the same instruction-tuned model. The spoiler filter (Eq. 4 ) uses threshold \(\tau_s = 2\) and retains preplans of length \(\ell_{\min}=150\) to \(\ell_{\max}=1500\) tokens.

Training: We initialize from each backbone via SFT on \(\mathcal{D}_{\text{SFT}}\) for \(3\) epochs with learning rate \(1e-5\) and batch size \(16\), then run composite-reward GRPO for 500 steps. GRPO uses group size \(G=8\) and reward weights in Eq. 6 are \(\lambda_a=0.1\), \(\lambda_f=0.3\), and \(\lambda_s=0.1\).

Generation. For both training rollouts and evaluation we sample with temperature \(T=1.0\) and top-\(p=0.95\). All experiments are run on 4 \(\times\) NVIDIA RTX PRO 6000 Blackwell (96GB) GPUs.

4pt 0pt 0pt

4.2 Experimental Results↩︎

We organize our evaluation around four questions: whether PPC improves accuracy over plan-based baselines (§4.2.1), whether each reward component contributes (§4.2.2), whether the extra preplan stage inflates inference cost (§4.2.3), and whether the preplan is genuinely used rather than merely produced (§4.2.4).

4.2.1 Main Results↩︎

We evaluate PPC against five baselines: Base, Prompt-Only, GRPO, PTA-GRPO, and Plan-Tuning on five mathematical reasoning benchmarks (AIME25, Minerva-Math, OlympiadBench, MATH-500, GSM8K) across four backbones spanning different families and scales, reporting both maj@16 and pass@16 (Table 2).

PPC achieves the best results on 39 of 40 metrics, with consistent gains across all backbones. The improvements are largest on competition-level benchmarks: on Llama3.1-8B, PPC raises MATH-500 maj@16 by \(+10.6\) over Base and OlympiadBench pass@16 from \(41.3\) to \(51.4\), while on the near-saturated GSM8K, all methods cluster within a narrow band. The Prompt-Only baseline, which prompts the untrained backbone to first analyze what to solve before planning and executing, yields marginal and inconsistent improvements over Base: it improves some settings but trails plain GRPO on the large majority of metrics and never approaches PPC, indicating that prompting for the preplan cannot substitute for learning it. Notably, the prior plan-based methods do not consistently beat plain GRPO on several Minerva-Math and OlympiadBench settings, and occasionally fall below Base. Since PPC differs from these baselines by the upstream preplan, its consistent advantage isolates the effect of modeling what to solve before how to solve, confirming the paradigm-level gap identified in our paper.

4.2.2 Ablation Study↩︎

We ablate the reward components by starting from the outcome reward \(R_{\text{out}}\) alone and cumulatively adding the spoiler-style penalty \(R_{\text{sty}}\), the adherence reward \(R_{\text{adh}}\), evaluating each configuration on all five benchmarks across four backbones (Table 3). The format guard \(R_{\text{fmt}}\) is kept across all settings.

Every term improves performance monotonically across all four backbones, indicating that the four terms are complementary rather than redundant. Adding \(R_{\text{sty}}\) alone already lifts AIME25 maj@16 by \(+6.7\) on Qwen3-4B, showing that keeping the preplan conceptual integrity is beneficial in itself and must be actively maintained during RL, not merely inherited from initialization. The adherence reward contributes its largest increments: a further \(+6.7\) AIME25 maj@16 on Qwen3-4B and \(+1.9\) OlympiadBench pass@16 on Llama3.1-8B: while its effect on the near-saturated GSM8K is marginal, supporting our claim that the preplan pays off only when the plan genuinely follows it. The gap between \(R_{\text{out}}\) and full PPC widens on competition-level tasks (up to \(+16.7\) AIME25 maj@16 on Qwen3-4B) and shrinks on GSM8K, mirroring the main-results trend that explicit problem understanding matters most when the solution path is hard to find.

4pt 0pt 0pt

0pt 0pt

4.2.3 Inference Efficiency↩︎

To test whether inserting an extra preplan stage inflates inference cost, we measure the average number of generated tokens per problem on MATH-500 for GRPO, Plan-Tuning, PTA-GRPO, and PPC across four backbones (Table [tab:token]).

Despite producing an additional preplan, PPC generates fewer tokens than full CoT on all four backbones (e.g., \(1.47\)k vs.\(3.02\)k on Qwen2.5-7B) and far fewer than PTA-GRPO, whose unconstrained reasoning grows to \(9.97\)k tokens on the same backbone; PPC remains within a narrow band of the most compact baseline, Plan-Tuning, while achieving uniformly higher accuracy (§4.2.1). The reason is that the preplan and plan jointly constrain execution rather than lengthen it: a single-pass CoT explores without higher-level structure and produces redundant detours, whereas in PPC the execution follows a committed plan and advances along a single solution path. This also explains PTA-GRPO’s inflated length: it adds a plan as an auxiliary guidance signal on top of the CoT without constraining the reasoning to follow it, therefore, the plan lengthens the output without pruning the underlying exploration. The tokens saved by avoiding wrong-path detours outweigh the small fixed overhead of the preplan, thus PPC improves accuracy and reduces token cost simultaneously rather than trading one for the other.

4.2.4 Faithfulness↩︎

To test whether the preplan is genuinely used rather than just produced, we intervene on it at inference time and measure the downstream effects. We replace the model-generated preplan with three perturbations while letting the model freely generate the plan and execution from it: Shuffled (the same preplan with its sentences reordered), Mismatched (a preplan taken from a different problem), and Generic (a content-free placeholder). We report maj@16 and pass@16 on MATH-500 across four backbones (Table 4).

Injecting a mismatched preplan causes severe collapse: maj@16 drops from \(97.2\) to \(46.8\) on Qwen3-4B and from \(84.8\) to \(27.8\) on Qwen2.5-7B. This shows that the preplan is genuinely used, not merely produced: if it were ignored, an unrelated preplan would be harmless and not mislead the downstream planning and execution.

The Shuffled and Generic conditions jointly confirm that this dependence is on the preplan’s information, not an artifact of the intervention. A generic, content-free preplan causes a marginal drop in accuracy (\(94.2\) vs.\(97.2\) on Qwen3-4B, \(80.2\) vs.\(84.8\) on Qwen2.5-7B), serving as a placebo: it confirms that the collapse under Mismatched stems from the injected content, not from the intervention itself. Against this baseline, the contrast with Shuffled is telling: when the original information is preserved but its sentences are reordered, accuracy stays high (\(96.4\) on Qwen3-4B). The model thus relies on what the preplan conveys rather than its surface order, confirming that the preplan carries substantive, content-level guidance. Together, these inference-time results show that PPC’s adherence reward (§3.3) drives genuine, content-dependent reliance on the preplan.

5 Conclusion↩︎

We identified a paradigm-level gap in plan-based reasoning: while existing methods model how to solve a problem through planning and execution, they leave what to solve, the problem type, applicable tools, constraints, and pitfalls, entirely implicit. We proposed PPC (Preplan-Plan-CoT), introducing an explicit preplan stage that gives rise to the question \(\rightarrow\) preplan \(\rightarrow\) plan \(\rightarrow\) cot paradigm, realized through a spoiler-score-guarded synthesis pipeline for clean preplan supervision and a composite GRPO reward that enforces the plan genuinely follows from the preplan. Extensive experiments across four backbones and five mathematical reasoning benchmarks demonstrate that PPC achieves the best results on 39 of 40 metrics, improving maj@16 and pass@16 by +2.23 and +3.06 over the strongest baseline at no additional inference-time token cost.

6 Error Attribution Analysis↩︎

To substantiate our claim that methods without an explicit preplan stage fail because misunderstand what to solve rather than how, we run an LLM-as-judge analysis over each method’s incorrectly answered problems. Rather than inferring the claim indirectly, we let the judge decide it: for each wrong solution, it judges whether the failure stems from not understanding what to solve, defined via four facets a short computation-free analysis could catch: problem type, tools/concepts, constraints, and pitfalls. The judge prompt is shown in Figure 3.

To verify that findings in Figure 1 is judge-agnostic rather than an artifact of a single judge, we repeat the identical attribution pipeline with a Qwen judge. As shown in Figure 4, the result is highly consistent: across all four backbones, PPC again commits substantially fewer what-to-solve errors than the baselines, with the same ranking and comparable magnitudes. This confirms that our observation: the gains of pre-planning stem from better understanding what to solve is robust to the choice of judge.

None

None

None

None

None

None

None

7 Spoiler/Leakage Failure: A Full Example↩︎

This appendix expands on the spoiler-score filter introduced in §3.2. Figure 5 contrasts a discarded preplan that crosses the conceptual integrity boundary with a retained clean preplan on a problem of comparable difficulty. Both trajectories reach a correct final answer; only the first is discarded, showing that the filter targets preplan purity, not answer correctness.

7.0.0.1 Why the first is discarded.

The discarded preplan does not survey what to solve; it has already settled how to solve. It commits to concrete computed outcomes that both singularities are enclosed and that the origin is an essential singularity (a spoiler), and rehearses the exact downstream procedure of expanding both Laurent series, multiplying, and extracting the \(1/z\) coefficient (a leakage). These trip the derivation-phrasing and answer-revealing signals of \(s(\cdot)\), pushing its score above \(\tau_s\) despite the correct answer \(2\pi i\).

7.0.0.2 Why the second is retained.

The retained preplan stays on the what-to-solve side throughout: it names the relevant tool (CRT), notes the structural fact \(1001 = 7\cdot 11\cdot 13\), and flags genuine pitfalls—without solving any congruence or committing to a step sequence. The actual reconstruction is left to the planning and execution stages.

8 Three-Stage SFT Data Generation Prompts↩︎

This appendix provides the full prompts used to construct the three-stage \(\langle\)preplan, plan, execute\(\rangle\) trajectories of §3.2. The stages are generated strictly left-to-right, and each stage’s prompt is shown below (with the runtime fields {question}, {preplan}, {plan} substituted at generation time).

8.0.0.1 Stage 1: Preplan.

The preplan is produced first, before any plan exist. The prompt (Figure 7) casts the planner LLM as a teacher briefing a student rather than solving the problem, and enforces the conceptual integrity through explicit rules: no derivations, no extended formulas, no computed values, and prose rather than steps. These rules operationalize the spoiler constraint that the filter of §3.2 later enforces.

8.0.0.2 Stage 2: Plan.

Conditioned on the question and the preplan, the same instruction-tuned LLM expands the high-level direction into a concrete numbered plan (Figure 8). The prompt requires the plan to faithfully follow the strategy hinted at in the preplan, which is what makes the plan a genuine elaboration of the preplan rather than an independent solution.

8.0.0.3 Stage 3: Execute.

The executor sees only the question and the plan, never the preplan, so that execution is driven by the explicit plan alone. We realize execution with a strong reasoning model (DeepSeek-R1) that produces a raw worked solution, which is then reorganized by the instruction-tuned model into a clean numbered execution whose step titles align one-to-one with the plan (Figure 9). The cleanup step preserves all numerical results from the raw solution rather than re-deriving them, keeping the mathematics intact while imposing a consistent structure.

8.0.0.4 Verification.

A trajectory is kept only if its final answer matches the gold answer (verified by normalized string match with an LLM equivalence check as fallback) and its execution ends in the required \boxed{} format.

9 The Spoiler Score \(s(\cdot)\)↩︎

This appendix specifies the rule-based spoiler score \(s(\cdot)\) used by the filter in Eq. 4 . The score is an integer in \(\{0,\dots,6\}\) obtained by summing six binary signals, each of which fires when the preplan shows a symptom of computing or revealing the answer rather than analyzing the problem. A preplan is retained only when \(s(y_{\text{pp}}) \le \tau_s\); we use \(\tau_s = 2\). The score is applied uniformly at construction time (Eq. 4 ) and as a reward component during RL without inconsistency.

9.0.0.1 The six signals.

Let \(y_{\text{pp}}\) be the candidate preplan text. Each signal below contributes \(1\) to \(s(y_{\text{pp}})\) when its condition holds:

1. Derivation phrasing. The text contains any phrase signalling an inference or transformation has been carried out: e.g.”simplifies to”, “reduces to”, “leads to”, “yields”, “implies that”, “becomes”. Such phrases indicate the preplan is performing, not previewing, the derivation.

2. Equation density. The combined count of equality symbols (= and \equiv) is at least three. A preplan that states constraints needs few equalities; a high count signals worked relations.

3. Long inline expressions. At least two inline-math spans exceed \(30\) characters. Short named quantities are permitted, but extended expressions indicate concrete manipulation.

4. Multi-digit constants. The text contains a standalone integer of three or more digits, which typically appears only once specific numbers are being computed or stated.

5. Answer-revealing wording. The text contains phrases such as “the answer”, “the result is”, “we get”, or “we obtain”, which tend to precede a disclosed outcome.

6. Inline-math span count. The total number of inline-math spans is at least four, indicating the preplan leans on formal expressions rather than prose analysis.

9.0.0.2 Aggregation and rationale.

The final score sums the six indicators,

\[s(y_{\text{pp}}) \;=\; \sum_{i=1}^{6} {1}\!\left[\,\text{signal}_i \text{ fires on } y_{\text{pp}}\,\right] \;\in\; \{0,\dots,6\},\] This additive design tolerates the incidental use of light notation that even a purely analytical preplan may contain, and targets the accumulation of computational behaviour that characterizes a true spoiler. The procedure is summarized in Figure 6.

10 Reward Details↩︎

In this section, we show the details of each reward components. All judges are frozen (a fixed instruction-tuned LLM, not updated during RL), so the reward signal is stationary across training.

10.0.0.1 Outcome (\(R_{\text{out}}\)).

To provide a gradient beyond a binary signal, so that GRPO can still learn once most rollouts are wrong, an incorrect answer is scored by a proximity judge on a \(1\)–\(5\) scale (mapped to \([0-0.5]\)) that rates how close the solution path was to a correct one, deliberately ignoring numerical closeness of the final value.

10.0.0.2 Format (\(R_{\text{fmt}}\)).

A rule-based check awards \(0.3\) iff the completion has a clean structure: the three tags <preplan>, <plan>, <execute> each appear exactly once, in order, with a \boxed{} answer inside <execute>, no trailing text after </execute>, and no tags outside the allowed set.

10.0.0.3 Style (\(R_{\text{sty}}\)).

To keep the preplan from regressing into a spoiler, we reuse the spoiler score \(s(\cdot)\) of Appendix 9 as a one-sided penalty \(R_{\text{sty}} = \max(0,\, s(y_{\text{pp}}) - \tau_s)\) with \(\tau_s = 2\), weighted by \(\lambda_s = 0.1\) in Eq. 6 . Thus the penalty term \(-\lambda_s R_{\text{sty}}\) is \(0\) while \(s \le 2\) and decreases (down to \(-0.4\) when \(s\) reaches its maximum of \(6\)) as the preplan accumulates computational signals.

10.0.0.4 Adherence (\(R_{\text{adh}}\)).

A frozen judge rates, on a \(1\)–\(5\) scale, whether the plan implements the strategy of the preplan (not its quality), scaled to a maximum of \(0.1\). Crucially, a plan that solves the problem well but ignores the preplan still scores low, which is what ties the plan to the preplan rather than letting it become an independent solution. The full prompt is shown in Figure 10.

References↩︎

---

1.  Corresponding author.↩︎