Same Task, Different Statement: When and How Reformulation Helps LLM Problem Solving
TL;DR Highlight
Rewriting problem statements to fit their type raises LLM accuracy, but blind rewriting hurts.
Who Should Read
A backend developer whose LLM math, logic, or code solving accuracy is inconsistent and who is considering a prompt preprocessing step
Core Mechanics
- Same task, different wording, different result
- Rewriting only the statement, with meaning, constraints, and answer unchanged, moved accuracy a lot.
- The paper suggests some failures are presentation gaps rather than capability gaps.
- Three kinds of rewrites
- Decomposition makes hidden subgoals explicit.
- Typed Reformulation recasts the task into another solving frame such as computation, verification, or optimization.
- Concept Reduction strips narrative and exposes the structure or symbols.
- Each rewrite fits certain problem types
- Decomposition helped Search and Classification.
- Concept Reduction was strongest for Explanation and Causality.
- Typed Reformulation helped Optimization, Design, and Verification.
- A mismatched rewrite hurts
- Typed Reformulation on Search and Classification cut accuracy sharply.
- The paper explains that it breaks the dependency structure the model needs.
- Blind rewriting loses, selective rewriting gains
- The rule-based Active method gained on the problems it rewrote.
- Blind, where GPT-4o chose freely, lost at similar coverage.
- Rewrite only a small share of problems
- Active rewrote just 18.7% of test problems and kept the original for the rest.
- It fell back to the original when confidence was low or the statement was already short and explicit.
Evidence
- Best rewrite chosen after the fact: +27.6 points on average
- On the Train Set, mean accuracy across eight models rose from 56.0% (Orig) to 83.6%.
- Per-model accuracy went from 43.7-63.6% to 80.0-86.4%, an upper bound chosen with the answers known.
- Extra tries and free paraphrases helped far less
- On GPT-4o-mini, Orig was 43.7%, pass@3 50.3%, pass@6 54.8%, and the paraphrase oracle 60.3%.
- The ceiling over stored C/D/TR rewrites was 76.0%.
- Gains and losses by problem type
- Pooled over eight models on the Train Set, Classification gained +16.7% with Decomposition and lost 23.6% with Typed Reformulation.
- Explanation gained +33.7% and Causality +23.2% with Concept Reduction.
- Active beat Blind on the held-out Test Set
- On rewritten problems, Active was +11.0%, Blind -5.6%, and Random +0.8%.
- Full-set accuracy was Orig 61.7%, Blind 60.0%, Random 61.4%, Active 63.8%.
- The flip rate on Orig-correct problems was 1.3% for Active versus 13.0% for Blind.
How to Apply
- Rewrite 20 failed problems three ways and compare
- Pick 20 problems your current prompt gets wrong today.
- Rewrite each with Decomposition, Typed Reformulation, and Concept Reduction, then rerun under the same CoT prompt.
- Tabulate which rewrite works for which problem type.
- Build a routing rule from problem type to rewrite
- Classify your problems into Search/Classification, Explanation/Causality, and Optimization/Design/Verification.
- Map each group to the rewrite the paper recommends.
- Keep the original statement for all other types.
- Add a legality filter with fallback to the original
- Use an LLM judge to check that the rewrite keeps meaning, constraints, answer format, and leaks no answer.
- Fall back to the original when the check fails or confidence is low.
Try It
# Paste into Claude or ChatGPT as is (simplified version of the paper's method)
You are a problem statement rewriter. Never change the meaning, constraints, goal, or answer format of the problem below, and never include the answer or intermediate results.
First identify the problem type, then pick exactly one rewrite by these rules.
- Search/Classification: Decomposition that lists subgoals in order (without solving them)
- Explanation/Causality: Concept Reduction that removes unneeded narrative and exposes key entities and relations
- Optimization/Design/Verification: Typed Reformulation that recasts the goal into a better-fitting solving frame
- If the statement is already short and clear, or you are not confident: return the original unchanged
Problem:
{{problem}}
Output format: type, chosen rewrite, rewritten problem.
Next step: solve both the original and the rewritten problem with the same CoT prompt and compare accuracy.Terminology
Related Papers
How Specification Explicitness Shapes Failure in LLM-Generated Code
Spelling out invariants, edge cases and constraints cut hidden-test failures in LLM code by 47.2%.
Show HN: STE80 Humanizer – de-AI text by writing 80% of the way to ASD-STE100
A skill strips 26 AI tells and rewrites text in short ASD-STE100-style sentences
Character-Name Concentration in LLM Fiction: Measuring Displacement and Mitigating Repetition
Drafting name candidates and filtering by frequency cut LLM character-name repetition by 95%
LLM Voice
Martin Fowler: LLM-drafted prose keeps an uncanny tone even after human editing.
The Instruction Tax on Factual Recall: Base Models Can Beat Their Instruction-Tuned Counterparts
Few-shot completion with repeated sampling on a base model beat chat: F1 0.684 vs 0.568
AI is a tool and using it well takes skill
A rebuttal to Hickey: LLMs are tools, and skill in directing and checking them decides the outcome
Reflective Prompt Optimization of a Deep-Research Agent: A Topic-Disjoint, Multi-Seed Protocol for Measuring Transferable Gains and Prompt-Level Overfitting
Reflective prompt optimization raised held-out citation reward from 0.702 to 0.781 on a deep-research agent.
GPT‑6 and Intelligent UI for everyone
GPT-6 reportedly adds generated UI to chat; with no article text, only comment reactions are available.
Original Abstract (Expand)
When people face a hard problem, they often restate it in a clearer way before solving it. We study whether the same habit helps large language models by rewriting the statement of a problem. A legal rewrite must keep the meaning, the constraints, and the correct answer unchanged. We test three kinds of rewrites. Decomposition makes hidden subgoals explicit. Typed Reformulation casts the task into a more suitable solving frame. Concept Reduction removes surface detail and exposes the task structure. We evaluate them on eight math, logic, and code benchmarks with eight models, all under the same chain-of-thought solving prompt. The effect is large but depends on the problem type. An oracle that picks the best rewrite after the fact raises accuracy by +27.6% on average. Yet no single rewrite helps every problem, and a mismatched rewrite can hurt. Still, the effect follows clear patterns. Each kind of rewrite fits certain problem types. A simple fixed rule learned from one set of problems transfers part of the gain to new problems. It gains +11.0% on the problems it chooses to rewrite, while blind rewriting loses 5.6% on a similar share of problems. Rewriting is therefore not a universal way to solve problems. The question is when and how to rewrite.