Do LLMs reason or just recognize mathematical patterns?
A 4M-parameter model reaches 98.6% on symbolic math. What that reveals about how AI 'thinks'.
Today’s most important AI news
A quieter Sunday in terms of corporate launches, but dense with community research. What dominates the conversation today are fundamental questions: does AI really reason or is it just very good at imitating structures? Does it still make sense to study algorithms when models already write code? And on the more technical side, some interesting projects that solve practical infrastructure problems. Three topics that, viewed together, say a lot about the moment we’re in.
MathFormer: a tiny model that demolishes the “mathematical reasoning” argument
An experiment published this week on r/MachineLearning challenges one of the most repeated narratives about large language models: that they have learned to reason mathematically. The project is called MathFormer and the finding is uncomfortable for those who defend LLMs’ cognitive capabilities.
The experiment is simple but elegant. A seq2seq model with just 4 million parameters — a microscopic fraction of GPT-4 or Claude — was trained without any explicit mathematical knowledge. Its task: given a factored expression like (7-3*z)*(-5*z-9), predict the expanded form. The model reached 98.6% accuracy. Not because it “understands” algebra, but because it learned structural token transformations: patterns in the form of the expressions, not their meaning.
The implication is direct. If a 4M-parameter model without mathematical knowledge can solve symbolic math almost perfectly, there are serious reasons to doubt that larger LLMs are “reasoning” when they solve math problems. It’s more likely they’re executing pattern transformations at massive scale. That doesn’t make them less useful in practice, but it should calibrate the expectations of those using them for tasks that require genuine reasoning in new or out-of-distribution domains. If you ask a model to solve a type of problem it has never seen in a structurally similar form, confidence should drop considerably.
Should we keep studying algorithms? The ML community debates more deeply than expected
The question “is it still worth studying algorithms now that AI writes code?” has been circulating in forums for months, but the thread opened this week on r/MachineLearning generated a more nuanced discussion than usual — and a useful one for any developer or tech lead making hiring or career-development decisions.
The argument for dropping algorithms is well known: current models generate working code, refactor projects, explain algorithmic complexity and solve many problems better than a junior. Stack Overflow, according to several thread participants, is in visible decline because people simply ask AI. Why memorize red-black trees if the model implements them in seconds?
The counterargument that emerges most strongly isn’t nostalgic but pragmatic: without understanding algorithms, you can’t evaluate whether the code AI generates is correct, efficient or suitable for your use case. AI makes errors that are invisible to those without the judgment to detect them. A developer who doesn’t understand computational complexity can’t know when the model chose the wrong solution for a problem at scale. What changes isn’t whether to study algorithms, but what for: less memorizing implementations, more understanding trade-offs and evaluation criteria.
Picotron: training LLMs on old GPUs without everything blowing up at import
On the more practical side of the day, a developer published Picotron, an LLM training framework written from scratch to solve a concrete problem: Nanotron, the popular framework, imports dependencies like flash-attn, triton and functorch at module level, which makes the process crash immediately if you run on older hardware like a T4 or a V100.
Picotron removes those mandatory dependencies. It runs on practically any GPU that supports PyTorch, which makes it relevant for teams working with cheaper cloud infrastructure, universities, early-stage startups or anyone who doesn’t want to or can’t pay for the latest A100s or H100s. The repository is available on GitHub under Syntropy-AI-Labs.
For Latin American teams experimenting with fine-tuning or their own training and who don’t have easy access to the latest hardware, this kind of tool has real value. The barrier to entry for training your own models is still high, and projects like this push that barrier down a little without sacrificing core functionality.
In a nutshell
What connects today’s three stories is the same tension: the gap between what AI appears to do and what it actually does. MathFormer suggests “reasoning” may be sophisticated pattern recognition. The algorithms debate shows that delegating to AI without your own judgment is a trap. And Picotron exists because tools assume hardware most people don’t have. The AI ecosystem is maturing, but it’s still the territory of those who understand what’s under the hood — not just those who know how to ask the model for things.
Sources used: MathFormer on Reddit MachineLearning (https://www.reddit.com/r/MachineLearning/comments/1uhatw8/mathformer_testing_whether_symbolic_math_is/), algorithms debate on Reddit MachineLearning (https://www.reddit.com/r/MachineLearning/comments/1uhdydj/do_we_still_need_to_study_algorithms_now_that_ai/), Picotron on Reddit MachineLearning (https://www.reddit.com/r/MachineLearning/comments/1uh7ib3/built_an_llm_training_framework_that_actually_runs/)