Can AI truly Reason? Part 3
Our Journey Exploring the Limits of Machine Intelligence, Computing Logic, and the Future of Hybrid AI Systems
Intro
I have to admit it and be honest: this series turned out to be far more complex than I expected. I thought I was setting out to explore artificial intelligence in depth, but instead, I wandered almost alone into a dense forest of intersecting disciplines, each demanding its own kind of fluency.
This journey has been exciting, I know, but it's only going to get more and more complex as it goes on.
And keeping these posts easy and “digestible”, so to speak, for the not-so-average person, yet still accessible to a broader range of readers, is anything but easy.
At first, it felt like I could “Explain AI” the same way I might learn and try to simplify a framework or a tool, with enough tutorials, a few detailed papers, and some hands-on projects.
But very quickly, I realized I wasn’t just picking up some core skills. I was stepping into a deep conversation between entire fields, and the deeper I went, the more voices I heard.
There’s linear algebra, for one, the bread and butter of everything from embeddings to backpropagation. It’s one thing to know that neural networks involve matrices.
It’s another to feel it: to see how matrix multipliation is the nervous system of a model, how vector spaces twist and stretch as data flows through layers.
Then there’s the more abstract machinery: algebraic structures and group theory. Not the stuff most tutorials bother with, but essential when you start dealing with symmetries, invariants, and architectures that generalize across space and time.
CNNs work not just because they “look at images”, but because they respect the deep structure of translation symmetry. That’s algebra, hiding in plain sight.
Topology and geometry joined the picture soon after. When I read about manifolds (those hidden curved spaces that high-dimensional data lives on) it clicked why certain models could compress complex data so effectively.
AI models don’t just map inputs to outputs; they fold space. They carve valleys in loss landscapes. They live in curved worlds.
Language, too, pulled me in, but not just as a medium, but as a science. Linguistics offered tools I never thought I’d need: syntax trees, semantics, morphology.
These weren’t just a bunch of fancy terms; they were maps to understanding how a transformer processes a sentence, how meaning gets distributed across tokens, how ambiguity emerges, and how models resolve it (or don’t).
Of course, none of this works without statistics. The true heartbeat of machine learning is uncertainty. Every model is a guess, every prediction a probability. Bayes’ theorem, maximum likelihood, entropy: these aren’t side topics; they’re the core of learning itself.
And the optimization techniques that turn theory into practice? They come from several decades of work in numerical analysis and applied math.
But theory isn’t enough. I hit a wall when my experiments couldn’t scale. That’s when I realized: AI is also a systems problem. Training a model means wrangling distributed GPUs, managing pipelines, versioning datasets.
Even software engineering matters a lot. You can’t ignore reproducibility, testing, deployment, observability. An idea is only as good as your infrastructure, no more and no less.
Then there’s the logic: what I call the cold precision of formal reasoning. It reminded me that, underneath all the neural glitter, there are fundamental limits to what machines can do. Complexity theory and computability quietly govern everything: what can be learned, what’s feasible, what’s provable.
And still, there’s so much more. Cognitive science appeared when I least expected it. I’d read a paper and find references to working memory, attention span, reinforcement loops, basically ideas pulled straight from psychology and neuroscience. AI isn’t just about building systems.
It’s about building systems that think, or at least approximate thought.
But perhaps the most surprising part was how philosophical it all became. Once you build something that speaks, decides, or recommends, you have to ask: Is it fair? Is it biased? Is it accountable? Is it good or bad? Is it ethical? Those aren’t technical questions. They’re human ones, and they force you to slow down and reflect.
AI is not a single subject. It’s a tapestry. A moving, living conversation across math, code, language, ethics, and the mind. Every time I thought I’d reached the bottom, I found another layer. And slowly, I stopped trying to “learn AI” in the traditional sense.
Instead, I started listening to all the disciplines it weaves together.
A True Paradigm Shift
I began this series with the clear intent of exploring the technical limitations of current artificial intelligence systems, not just the surface-level flaws like lack of generalization or brittleness. I was interested into the deeper architectural and mathematical bottlenecks that constrain what these systems can represent, reason about, or generalize.
That first part led almost naturally (in my mind) into a second installment focused on the theoretical scaffolding beneath all programming: the formal roots of how we model computation.
We wandered through the landscapes of set theory, category theory, computability, Turing machines, and the elegant machinery of the lambda calculus.
Each of these laid foundational stones for understanding what programming languages are; not just syntactic tools, but very deep expressive systems with formal semantics.
This third chapter was originally meant to be a straightforward exploration of programming paradigms: procedural, object-oriented, functional and so on…. But the moment I stepped into that territory, it became clear: this topic is anything but straightforward.
Programming paradigms aren’t just mere categories for syntax; they reflect entire ways of organizing logic, state, and time. They encode assumptions about how software maps to the world, and how humans should structure their thinking.
We have areas like:
Procedural programming, which treats computation as a sequence of instructions that mutate state, an abstraction rooted in the von Neumann architecture.
Object-oriented programming (OOP) that, on the other hand, abstracts the world into interacting entities with internal state and behavior. It encourages encapsulation, inheritance, and polymorphism as tools for managing complexity.
Functional programming. It sees computation as pure transformation: functions in, functions out, no side effects, no hidden state. It borrows heavily from mathematical function theory and the lambda calculus.
Logic programming (like Prolog) shifts the lens again: you describe what’s true, and the system searches for how to make it so.
Declarative paradigms take this even further, expressing what should be done, not how, as seen in SQL or configuration languages.
Beyond these major paradigms like concurrent and parallel models, where computation unfolds in multiple threads or processes. Think about CSP, the actor model, or fork-join semantics.
Event-driven and reactive paradigms treat programs as networks of handlers and observers, reacting to streams of input over time. There are also dataflow, stack-oriented, array-based, and metaprogramming paradigms, each offering radically different metaphors for how to write and reason about code.
But more than these surface differences, what began to fascinate me were the hidden structures that exist beneath every language:
Type systems: Are they static or dynamic? Strong or weak? Nominal or structural? Do they support type inference, generics, dependent types?
Evaluation strategy: Eager vs. lazy? By-value or by-name?
Memory model: Is it garbage collected? Manually managed? Region-based?
Control flow and effects: Are side effects explicit or implicit? Is exception handling first-class?
Metaprogramming support: Can you generate code at runtime? Reflect on structure? Modify syntax?
Concurrency primitives: Threads? Coroutines? Channels? Software transactional memory?
These aren’t just implementation details, they’re cognitive scaffolding. They shape how you reason, how you debug, how you think in the language and how you think about the language itself.
Some languages are opinionated and guide you down one narrow mental path. Others are flexible, chaotic even, leaving the architecture of thought entirely up to you.
So this chapter, I’ve realized, won’t be focused about programming language paradigms. We’ll delve into each of those wonderful details in future posts, as they’re just as relevant as the content presented here.
Why I decided to Change Direction
I didn’t set out to shift focus. But somehow I stepped into a deeper conversation, one that pulled me from language design into something stranger and more fundamental: the geometry of thought itself.
What began as an exploration of expressiveness and ergonomics in programming languages gradually unfolded into a broader investigation, rooted into the architectural and mathematical constraints that underpin not just code, but cognition. Specifically, the constraints that shape how modern AI systems succeed, and how they fail.
As I may have hinted before, there’s a precise reason I made this shift, simpler than I initially thought, yet more powerful.
It’s about the psychological and mathematical structures that lie beneath languages and models alike: the deep abstractions that make some systems feel like natural extensions of thought, and others like wrestling with syntax in the dark.
It’s about learning to read the grammar behind the grammar itself, the quiet metaphors each language imposes, the architectural trade-offs they encode, and the assumptions they bake into our cognition.
In doing my own research, I encountered The Illusion of Thinking, a paper by researchers at Apple that changed the terms of the conversation. The paper studied a now-famous class of models called Large Reasoning Models (LRMs), designed to explicitly articulate multi-step reasoning traces before producing final answers.
While these models outperform standard LLMs on certain benchmarks, the paper reveals a striking pattern: their reasoning capabilities collapse when faced with tasks that cross a threshold of compositional complexity.
What stood out wasn’t just the performance drop: it was how it failed. The LRMs didn’t just give wrong answers; their reasoning traces became incoherent, internally inconsistent, and increasingly shallow.
Surprisingly, as problem complexity increased, these models would exert less effort, even when given enough compute and token budget. The effort curve bent the wrong way.
Worse, the models often failed to invoke explicit algorithms even when appropriate, reasoning in a way that seemed structurally untethered from the task's logic.
This wasn’t just about incorrect answers, it was more a deeper mismatch between representation and structure. A failure of the underlying geometry.
These findings echoed something I had already begun to suspect: that hallucinations in LLMs are not random glitches. They’re topological artifacts, much likely the result of navigating a representational space that lacks the necessary shape to sustain structured reasoning.
Just like in programming, where bad abstractions feel wrong because they violate a system’s internal logic, a hallucinating model is operating in a space with the wrong curvature, the wrong embeddings, the wrong constraints.
More precisely: these models operate in continuous embedding spaces, smooth, high-dimensional manifolds designed for statistical association, not logical deduction. But reasoning, especially compositional reasoning, lives in discrete spaces.
In practice, this means that the token embeddings LLMs rely on are poorly aligned with the actual structure of the problems they aim to solve. They interpolate in smooth, continuous spaces.
But actual science says that reasoning isn’t smooth. It’s discrete. It has jumps, edges, and hard boundaries, transitions that can’t be reduced to geometry without torsion.
An AI model, capable of actual reasoning needs torsion, mathematical rigidity, constraint, structure. It has to embed sharp turns, not smooth interpolations. Without that, we don’t just get noise: we get systematic misalignment. A warped space that can't preserve logical steps or causal structure.
That’s when I saw the parallel clearly: programming languages are not just a set of tools: they’re topological instruments.
Each paradigm traces a distinct region of the computational landscape: imperative languages favor state transitions and control; functional ones value purity and composition; object-oriented styles prioritize identity and encapsulation; logic programming directly encodes inference.
These aren’t stylistic preferences, they’re cognitive geometries, different ways of embedding problems into representational spaces.
And when a language’s abstractions align with a domain, it feels like thinking natively. When they don’t, it feels like friction. The same is true for AI models: when their internal structure fails to match the task’s topology, they hallucinate, collapse, or produce incoherent steps disguised as logic.
This chapter and the whole series, then, became more than I expected. It became a bridge between how we structure code and how AI systems attempt to represent structure itself. It’s about the shape of abstraction, and how both humans and machines use fragile, imperfect maps to make sense of the world.
It became a deep study in geometry, in the folds and constraints of abstraction. And ultimately, it raised a quiet but profound possibility: that true intelligence (real reasoning) may not emerge from scale alone, but from the right topology. Spaces with discreteness, torsion, and the hard edges that logic requires.
In other words: structure.
How I Intend to Proceed
This isn’t a formal manifesto, nor it will ever be. It’s more of a shift in momentum, as we’ve alredy discussed.
When I first considered writing this series, I had a clearer, more contained idea of where it might go. A few crucial topics, some commentary, maybe even bunch of diagrams or some paper research topics.
But the deeper I dug, the more that original shape unraveled. What’s emerged in its place is something messier, richer, and, I hope, more meaningful.
This won’t be a linear walkthrough or a surface-level commentary. Instead, it will be an exploration, more layered, interconnected, and at times speculative. I’ll be moving through a wide constellation of topics, each one opening into the next.
We’ll deal with structure, the topology of models and systems, the underlying math of how things connect, distort, and evolve. I’ll look at the strengths and limitations of today’s AI architectures, through the lens of both performance and philosophy. Research papers, some well-known, others more obscure, will be a consistent touchpoint, with a personal touch.
From there, the boundaries get more and more abstract:
What does it mean to live in a discrete reality vs. a continuous one?
How does constructor theory challenge our assumptions about computation?
What can we learn from symbolic cognition, or the idea that thought itself may be better represented by structure than by noise?
I’ll also explore stranger terrains, like discrete Ricci flows, token embeddings, homotopy type theory and many others, not to dazzle, but to look more closely at what current AI models may be doing beneath the surface.
And always circling back to one central mystery:
Why do AI models hallucinate?
And more importantly, how do they think they’re right when they’re wrong?
What’s the current state of the art?
How much improvement can we realistically expect from better models?
Eventually, the focus will shift toward the systems themselves:
The code, the hardware, the tight architectural constraints that shape what’s possible. We will focus also on the future of computing, whether neuromorphic, quantum, or something else entirely.
And beyond the technical: philosophy, psychology, neuroscience, all the ways we’ve tried to explain how we think, and what that might mean for machines.
This series won’t pretend to solve the question of whether true reasoning is possible in artificial systems. I don’t believe that’s something one person can answer. But what I can offer is a journey, a rigorous, honest attempt to examine what lies beneath the glossy outputs and benchmark numbers.
Not from above.
But from within.
There’s a lot to uncover. Much of it hasn’t been widely discussed. I genuinely think that some of it hasn’t even been asked yet. There’s still room for better questions and better analogies, that have not been put in place yet.
And that’s exactly why I’m writing.
Conclusion
This series is not a destination: it’s an adventurous voyage into the very fabric of intelligence, both artificial and human. What began as a straightforward quest to understand AI’s technical limits has transformed into a deeper inquiry about the shape and structure of thought itself.
The questions we face are complex, sometimes unsettling, and always evolving. But it’s precisely this complexity that makes the journey worthwhile.
By peeling back the layers of math, language, computation, and philosophy, we stand a better chance of understanding not just what AI can do today, but what it might truly mean to think.
As we move forward, I invite you to explore these tangled landscapes with me. To question assumptions, to challenge easy answers, and to embrace the messiness that comes with venturing into new intellectual territories.
Because in the end, the story of AI is also a story about ourselves: our minds, our ideas, and our endless curiosity to make sense of a world far bigger and stranger than we ever imagined.
And so, let’s begin. Together.