Why Computation Can't Solve Meaning (And What It Means for LLMs): the Quest for an (Im)possible Theory

We are living a grand illusion. As we watch Large Language Models (LLMs) draft essays, write functional code, and converse with poetic nuance, we operate under a quiet, dangerous assumption: that if we just stack enough parameters, compute cycles, and training text high enough, true understanding and intent will eventually spark at the top.

It won’t.

Within the strict architecture of the theory of computation, the problem of meaning is fundamentally unsolvable.

Because of this limitation, true autonomous creativity, the kind we naturally grant to living biological systems and genuine intelligence, cannot exist inside a machine. We readily recognize this creative spark when a living organism adapts to its environment. Yet, the moment we begin to conceptualize intelligence in purely computational terms, we accidentally discard the very thing we are looking for. By forcing reality into a cage of step-by-step computational rules, we blind ourselves to the semantic landscape outside.

The Intuition: The Rules of the Recipe vs. The Taste of the Cake

Before we dive into the hard mathematics, let’s look at this problem through a simple, non-formal analogy.

Imagine you are looking at a recipe for a chocolate cake. The recipe is composed of symbols and instructions: “Mix 200g of sugar with 3 eggs. Bake at 180°C.” This list of mechanical actions is syntax.

Now, imagine the actual experience of tasting that cake, the rich, sweet, velvety flavor on your tongue. That experience is semantics (meaning).

A computer is like a flawless, blind kitchen robot. It can read the recipe, measure the grams perfectly, and execute the steps down to the millisecond. It can even shuffle the words of the recipe around to write a brand-new recipe for a vanilla cake. But no matter how many millions of recipes the robot processes, the robot will never taste the cake. The flavor doesn't exist inside the text of the instructions; it exists in a completely different dimension of reality outside the paper.

When we use AI, we are often fooled. Because the AI is so good at shuffling the recipe text, it outputs a description of a cake that sounds delicious. But the machine itself is entirely hollow. It is running the mechanics, completely blind to the meaning of what it is saying.

For the mathematically inclined, the next section explores exactly how the founding fathers of computer science proved that this gap between the recipe and the flavor can never be bridged by code.

1. The Deep Proof (For the Experts): Gödel, Turing, and Rice

The boundaries of code were not drawn by modern AI skeptics; they were mathematically proven by the founding fathers of mathematical logic.

• Kurt Gödel shattered the dream of a complete, closed logical framework. He proved that any consistent mathematical system capable of basic arithmetic will always generate statements that are undeniably true, but completely unprovable by the rules of that system. He demonstrated that Truth is a larger domain than Provability. Syntax can never fully encompass semantic meaning.
• Alan Turing translated this into computer science with the Halting Problem. He proved that it is mathematically impossible to write an algorithm that reads the raw code (syntax) of any given program and decides if it will eventually stop running or loop forever. You cannot algorithmically predict the macro-behavior of syntax without running it.
• Henry Gordon Rice delivered the final, crushing blow with Rice’s Theorem. It states that any non-trivial semantic property of a program cannot be decided by looking at its syntax.

If you want to know what a program actually means or does, whether it is safe, whether it is factual, or whether it understands love, you cannot deduce it by analyzing the mechanics of its code. The meaning always spills cleanly over the edges of the syntax.

2. The Glider Illusion: Shuffling Pixels vs. Observing Objects

If meaning cannot be derived from syntax, why do complex computational systems feel so alive? The answer lies in the phenomenon of emergence, perfectly captured by John Conway’s Game of Life (GoL).

The internal syntax of the Game of Life is dead simple: four basic, local rules determining whether a grid pixel turns on or off based on its immediate eight neighbors. The program knows absolutely nothing about physics, space, or direction.

Yet, when you run these blind rules, a specific 5-pixel configuration appears, seamlessly shifting and crawling diagonally across the screen. We call it a Glider.

We are fascinated by the glider. But it is vital to remember: the glider is not written anywhere in the code. There is no line of syntax that commands an object to move diagonally. The glider is a high-level semantic concept that we, the human observers, project onto the system because our brains are built to compress complex patterns into meaningful objects. The machine is just blindly evaluating binary neighbor counts. It is entirely blind to the "glider."

3. Classifying Code: Type A vs. Type B Programs

To map this phenomenon to modern software, we must divide all programs into two distinct categories:

Type A (Direct Meaning)

In these programs, the syntax is a direct, literal translation of the intended meaning. For example, when building a banking application, the engineer writes AccountBalance = Balance + Deposit. The symbols map 1:1 to the real-world semantic concepts we care about.

• The Catch: Type A programs are flawless and predictable, but fundamentally rigid. They can never surprise you, and they can never generate autonomous creativity.

Type B (Indirect Meaning)

In Type B programs, we do not program the meaning directly. Instead, we write simple, localized syntactic rules, set them in motion on a massive scale, and hope that a higher-level semantic meaning emerges.

4. LLMs are Text-Based Game of Life Engines

Large Language Models are the ultimate Type B programs. At the syntactic level, an LLM possesses zero knowledge of truth, logic, or reality. Its underlying rules are purely statistical: analyze the mathematical weights of the last 1,000 text strings (tokens) and predict the next most probable word.

When an LLM outputs a brilliant, logically sound essay, we are observing a textual "glider." Reasoning has emerged from the simple local rules of statistical token shuffling.

This realization leads to a profound truth about the AI safety debate: Hallucinations are not bugs; they are a fundamental consequence of Type B programming.

The mathematical code driving a flawless, factual medical summary and the code driving a completely fabricated, plausible-sounding historical lie are the exact same mechanism. To the syntax of the LLM, both are just mathematically smooth, highly probable sequences of strings.

The model has no access to meaning. It is just a massive, text-based Game of Life. If you try to patch the engine with Type A guardrails to completely eliminate hallucinations, you end up tightening the syntactic net so rigidly that you freeze the cellular automaton. The creative gliders stop moving, and the "intelligence" vanishes. Hallucination is simply the tax we pay for emergence.

5. The Holy Grail: An (Im)possible Theory

If we want to build autonomous systems that truly possess intent, understanding, and creativity without just throwing statistical dice and hoping for good gliders, we would need to go beyond Type B programs. We would need a formal system capable of engineering meaning directly.

But here we hit the brick wall of our title.

To ask for an algorithmic procedure or a mathematical compiler that can work backward from a desired meaning to write the perfect syntax is a literal contradiction in terms. Gödel, Turing, and Rice mathematically proved that no such logical bridge can ever exist. A Turing machine cannot resolve the limits of a Turing machine.

Therefore, the Holy Grail, the framework that allows us to express and design emergent meaning, cannot be a mathematical one.

It cannot be based on computation. It forces us to look past computer science entirely and turn toward a framework that has been theoretically constructed so that we can express indirectly the specific meaning we want to verify. Until we look beyond computation, we will remain mere spectators standing outside the machine, deeply impressed by digital gliders, but forever locked out of true creation.

Interestingly, the pursuit of this "impossible" non-computational framework isn't just a thought experiment. There is an emerging field of study called Geneosophy that attempts to do exactly this: seeking a formal, non-mathematical framework that comprehends how living systems natively process meaning and organize themselves.