LLMs Show Sensitivity to Problem Representation in Math Solving.

Sagnik Nath, Edith Aurora Graf, Liang Zhang, Diego Zapata-Rivera· July 24, 2026 View original

Summary

This research reveals that Large Language Models exhibit significant sensitivity to how mathematical problems are represented, with performance varying across equivalent formulations like story problems or symbolic equations. Even with executable reasoning tools, this representational brittleness persists, shifting failure modes rather than eliminating them.

New research explores how Large Language Models (LLMs) perform when solving mathematical problems presented in different, yet mathematically equivalent, formats. The study systematically varied surface representations, including story problems, word-equations, symbolic equations, and paraphrases, to test five contemporary LLMs. A key finding is substantial representational sensitivity, meaning models frequently change their correctness across these equivalent formulations, with noticeable "flip rates" between different problem types. Even subtle changes in phrasing through isomorphic reformulations were observed to degrade performance despite the mathematical structure remaining identical. The researchers also evaluated a condition where LLMs externalized their reasoning as executable Python code, which was then run for validation. While this "code-augmented" approach revealed strong latent reasoning capabilities in some models that struggled with direct prompting, it did not uniformly improve robustness. Instead, failure modes shifted from opaque reasoning errors to issues like protocol violations or execution failures. The study concludes that reasoning scaffolds do not eliminate representational brittleness but introduce new trade-offs in correctness, reliability, latency, and cost. It emphasizes that problem representation should be a primary interface design variable in LLM evaluation and deployment, especially for AI-assisted problem-solving systems.

Why it matters

For professionals building or deploying LLM-powered applications, understanding representational sensitivity is crucial for designing robust and reliable systems, especially in domains requiring precise reasoning like finance or engineering.

How to implement this in your domain

  1. 1Design LLM prompts with explicit consideration for how problem representations might impact model performance.
  2. 2Implement diverse testing strategies that include mathematically equivalent but representationally varied problem sets.
  3. 3Evaluate the trade-offs between direct LLM output and code-augmented reasoning for specific use cases, considering reliability and cost.
  4. 4Develop robust error handling and validation layers for LLM outputs, especially when using executable code, to catch shifted failure modes.

Who benefits

EdTechSoftware DevelopmentFinancial ServicesEngineeringHealthcare

Key takeaways

  • LLMs are highly sensitive to the surface representation of mathematical problems, even when mathematically equivalent.
  • Executable reasoning tools can reveal latent capabilities but do not eliminate representational brittleness; they shift failure modes.
  • Designers of LLM systems must treat problem representation as a critical interface design variable.
  • Robust evaluation requires testing LLMs across diverse, representationally varied problem formulations.

Original post by Sagnik Nath, Edith Aurora Graf, Liang Zhang, Diego Zapata-Rivera

"arXiv:2607.20520v1 Announce Type: new Abstract: Large language models (LLMs) are increasingly evaluated on mathematical problem solving, yet prior work often treats representationally equivalent formulations as interchangeable and conflates reasoning errors with interface failure…"

View on X

Originally posted by Sagnik Nath, Edith Aurora Graf, Liang Zhang, Diego Zapata-Rivera on X · view source

Want to go deeper?

Turn these trends into skills with Learnijoy's hands-on AI & tech courses.

Explore courses