Photo by Microsoft Copilot on Unsplash

Last month, a software engineer named Marcus was debugging why his GPT-4 powered application kept failing on basic multiplication. He'd ask the model what 847 × 6 equals. Sometimes it got 5,082. Sometimes 5,098. Sometimes it confidently returned 4,200 and moved on. The frustrating part? The same model could write working Python code to solve the problem correctly.

This isn't a bug. It's a window into something far more interesting about how modern AI systems actually process information. And it reveals a fundamental tension between language and mathematics that even the smartest researchers are still struggling to understand.

The Pattern Recognition Problem

Here's what's happening beneath the surface: Large language models like ChatGPT, Claude, and Gemini are fundamentally pattern-matching machines. They've been trained on billions of words, documents, and code samples from the internet. Their core strength is recognizing patterns in language—understanding that "bank" means something different when you're talking about finance versus geography, or knowing that Hemingway wrote about fishing more often than physics.

But here's the problem with arithmetic. Math isn't really a language pattern at all. It's a symbol system with strict, logical rules. 2 + 2 will always equal 4. There are no exceptions, no context-dependent meanings, no cultural variations. When an AI model trained on language patterns encounters pure mathematics, it's like asking a spell-checker to prove the Pythagorean theorem. The tool isn't designed for the job.

During training, these models see "847 × 6" appear in contexts where humans have already written the answer. Maybe it's in a math textbook. Maybe it's in a blog post. Maybe it's in a forum where someone solved the problem. The model learns statistical patterns about what number tends to follow that particular multiplication problem—but it's learning patterns in how humans write about math, not actually learning to do mathematics.

This is why the errors feel so random. The model isn't calculating. It's guessing which number seems plausible given everything it's learned about how people write math problems and their solutions.

Why Bigger Models Don't Fully Solve This

You might think that larger models with more parameters would just learn arithmetic better. More data, more patterns, stronger understanding. And there's some truth to that—bigger models do perform better at math than smaller ones. But they still fail at it embarrassingly often, which tells us something important: scale alone doesn't solve the fundamental mismatch between pattern recognition and logical rules.

OpenAI and Anthropic have tried various workarounds. One approach is chain-of-thought prompting—essentially asking the model to show its work step by step. This doesn't fix the underlying problem, but it does something clever: it converts mathematical thinking into language, which is what the model actually knows how to do well. When you ask GPT-4 to "show all steps carefully," you're making it produce words about the calculation, not actually perform calculations internally.

Another fix is simply training the model on calculator outputs or code execution. If during training you pair mathematical expressions with their correct answers more frequently, or if you show the model code that correctly solves the problem, it learns those patterns better. But this feels like a band-aid on a structural issue.

The uncomfortable truth is that if you ask a sufficiently large language model to multiply two random seven-digit numbers in its head, you'll get an answer that's often confidently wrong. This limitation exists in every major commercial model today.

The Real Solution (Spoiler: It Involves Actual Calculators)

The practical solution that's emerging across the industry is surprisingly unglamorous. Instead of expecting AI to do math, we're building systems where AI recognizes when math is needed and calls an actual calculator. Most modern AI systems now have access to external tools—not as a cool feature, but as a necessity.

When you use ChatGPT with "Advanced Data Analysis" or Claude with tools enabled, these models don't try to do the math themselves. They write code. They call functions. They invoke external systems that are actually designed for mathematical operations. It's the difference between asking a language expert to do your taxes versus having them read the tax code and contact an accountant when needed.

This hybrid approach works remarkably well. A modern AI with tool access will correctly solve complex mathematical problems that would stump the same model working alone. But it requires acknowledging a fundamental limitation rather than pretending it doesn't exist.

There's been interesting recent research on whether entirely new architectures could solve this differently. Some researchers are exploring neuro-symbolic systems that combine language models with actual logical reasoning engines. Others are investigating whether fundamentally different training approaches could give models something closer to mathematical intuition. But these are still early experiments.

What This Reveals About AI's Future

The math problem is a perfect case study in understanding what AI systems actually are. They're not general intelligences. They're sophisticated pattern recognition engines, brilliant at some tasks and mysteriously broken at others. The gap between their performance on language and their performance on logic reveals something important: there's no single "intelligence" that's improving. There are dozens of different capabilities that sometimes overlap and sometimes contradict each other.

This matters because it changes how we should think about AI development. Rather than believing we're building increasingly intelligent systems that will eventually handle everything, we should probably expect to build increasingly specialized systems that are good at different things. A system excellent at language might forever struggle with arithmetic. A system that reasons perfectly might never write poetry.

The temptation is to see this as a temporary problem—just a limitation we'll eventually overcome with more data and bigger models. Maybe that's true. But it's equally possible that we're bumping against something more fundamental about the nature of pattern recognition versus logical reasoning. If so, we may need to stop trying to squeeze all intelligence into the same type of neural network.

Marcus eventually solved his problem by having his application check whether the task required calculation, routing those requests to a dedicated math library, and keeping the AI for everything else. It's not as elegant as having one system that does everything. But it works. And maybe that's what AI excellence looks like: not one system that's good at everything, but interconnected systems that are honest about what they're actually good at.

For a deeper understanding of how AI models fail in more subtle ways, check out "Why AI Models Keep Hallucinating About Facts (And How We're Finally Catching Them)", which explores the broader issue of AI reliability and factual accuracy.