Any Realizable Implementation of a Sufficiently Large Lookup Table Must Be Conscious
Julian’s Substack
SubscribeSign in
Any Realizable Implementation of a Sufficiently Large Lookup Table Must Be Conscious<br>True Lookup Table has never been tried and cannot be tried, even by a Kardarshev III civilisation. A Disproof of Erik Hoel's "A Disproof of Large Language Model Consciousness"
Julian<br>Jun 20, 2026
19
Share
Some time ago, Erik Hoel published a really cool paper called<br>A Disproof of Large Language Model Consciousness: The Necessity of Continual Learning for Consciousness<br>It essentially argues that there can be no non-trivial falsifiable theory of consciousness according to which GPT-4 style LLMs are conscious. In this post, I will argue that the argument rests on a computational-complexity-avoiding razzle dazzle.
The paper is quite tricky to read and it took several rounds of arguing with Claude before I realized that most of my initial objections to the paper were already covered under one or the other horn of Hoel’s dilemma. So I’m going to start with a Claude-written summary of the paper. This may be helpful for other readers of the paper.<br>Can a theory of consciousness be so strongly constrained by requirements for testability that its overall nature can be deduced?
Testing a theory of consciousness is based on comparing two functions that map from observed data to experiences: predictions and inferences.<br>Experiences (the space E)<br>This is the target — the set of all possible conscious states a system might be in. Hoel treats it abstractly as a space, E. A particular experience is just one element of that space (seeing red, feeling pain, etc.).<br>Predictions (the function pred )<br>A prediction is what a theory says about a system’s experience, based on data about the system’s internal workings. Formally it’s a mapping pred: O → E, where O is data about the system’s mechanics (neuroimaging, the integrated information of the circuitry, the number of layers, whatever the theory cares about). Crucially, what counts as the relevant data is determined by the theory itself. IIT predicts from integrated information; a higher-order-thought theory predicts from the structure of representations; and so on. Theories are individuated by how they make predictions — that’s what makes one theory different from another.<br>Inferences (the function inf )<br>An inference is the empirical reason to think a system is having some experience, arrived at independently of any particular theory. Formally inf: O → E as well, but it’s grounded in behavior or report — a button press indicating what someone saw, a verbal claim of pain, or, for an LLM, its text output. Hoel’s key point is that inferences are supposed to be theory-neutral: they’re the “outward” evidence (report, behavior, I/O) that any reasonable observer would take as a sign of consciousness, regardless of what theory they hold. The clearest inference, he notes, would be a system explicitly claiming to be conscious.<br>Why the distinction does all the work<br>A theory is tested by comparing pred and inf. If the experience the theory predicts (from internal data) matches the experience inferred (from behavior/report), the theory survives; if they consistently mismatch, it’s falsified. Hoel’s two “horns” come directly from how these two functions relate:<br>If pred and inf are fully independent, you can swap in a different system that keeps the behavior/output identical (so inf is unchanged) but changes the internals (so pred changes) — the unfolded network, the lookup table. Now they mismatch everywhere, and the theory is falsified a priori. This is the Substitution Argument.
If pred and inf are strictly dependent — both drawing on the same source, namely the input/output behavior — then they can never disagree, so the theory can never be falsified. It’s trivial. (Behaviorism is his example: “acts conscious, therefore is conscious” can’t be tested because the prediction is just a restatement of the inference.)
Let’s use multiplication as a concrete example.<br>Take f to be the times table for single digits: input a pair (a, b) with each in 0–9, output their product. That’s a fixed, finite function — 100 input-output pairs. Now build two devices that compute it:
System A is a Read-Only Memory lookup. Burn a 100-cell memory: cell (7,8) holds 56, and so on. To “multiply,” decode the two-digit address, read the cell. There is no multiplying happening — the answer was precomputed and stored. Feedforward, no intermediate computation, no internal variable that holds a running partial product.
System B is a shift-and-add multiplier — an actual little arithmetic circuit (the kind inside a cheap calculator’s ALU). To compute 7×8 it runs a process: it holds intermediate state, adds and shifts across several steps, propagates carries, updates internal registers, and arrives at 56. There is genuine internal information flow — signals move between parts, partial results get combined.
Both...