← All writing Draft · Apr 2026

Computation Conjecture

A metaphysical position grounded in the nested computers we already build and inspect: computation has more explanatory reach than physicalism, accounting for why a closed causal system with observers exists at all.

This conjecture, or bold guess, is based on a simple idea: to make progress on fundamental ontology, or exploring the true nature of existence, we can use lessons found in computers. I’m claiming computers hold insights that can illuminate the cosmos. There are many beliefs about the fundamental nature of the universe, for some matter is all there is, for others mind is fundamental, and still for others God answers the final question. I seek to harmonize these positions.

The Computation Conjecture is offered as a reasonable metaphysical position. It is grounded in observation: physical reality already contains nested computation as an observed phenomenon. I will argue that the structural properties of that phenomenon (observer locality, closed causality, substrate independence) extend by symmetry to our own layer. From there it follows that computation has more explanatory reach than physicalism, accounting for how closed causal systems with observers can exist, nest, and host one another. Physicalism describes our local rules. Computation describes the structure that makes rulesets-with-observers possible at all. The conjecture is not claimed as the final word. Like all conjectures, it is offered for criticism.

We’ll start by exploring the universal properties of computation, how they interact with physics, argue why physicalism isn’t fundamental, show a harmony between mind and matter, and give explanations about the nature of reality.

Argument

Grounded:

The Computation Conjecture starts from our physical reality, not from myth, revelation, the supernatural, or metaphysics.
Physical reality already contains computers, programs, simulations, observer locality, and nested computation. Therefore, the conjecture is grounded in physical, computational, and logical possibility.
Physicalist should care because nested computation is not a thought experiment but an observed phenomenon: simulations contain simulations, programs spawn programs with their own closed rulesets, and observers exist inside computational environments we’ve built.

Properties of Computation:

Starting from a human perspective in our universe (local observer)
Computers are made on physical substrates
Programs can be computers (Universal Turing Machine, substrate independence)
Programs can be closed causal systems (loop, rules, error catching)
People can be programs. (Deutsch, AGI)
Programs can be simulations.
People can live within a computer simulation.
People in a computer simulation have observer locality.
Programs can be nested unbounded graph simulations as long as logic is preserved. (NAND gates)
Hosting programs can pass information throughout nested simulations.

Implications:

The properties of information, computers, programs, and logic flow throughout all simulations, holding at every nesting depth.
From the perspective of the hosting simulator, programs can have rules which break the laws of physics such as magic, time travel, law of conservation. From the local observer in a simulation rules are normal, causality closed, and logical.
If a simulation slows at each nesting due to base layer computational processing speed, then to the local observer in that simulation, time is normal while to the hosting local observer it is slower.
Our physical universe shares the structural properties of simulated computational worlds: it processes information (computation), and it runs by rules that compose (programs).
If we can look down into nested simulations, there is no logical reason we cannot look up from our local reality. A closed causal system can contain observers who believe their local rules are fundamental. Therefore, our local physical reality has no special privilege as the stopping point.
All fundamental explanations result in regress: God, physicalism, and computation. God explains god. Physicalism explains physicalism. Computation embraces the regress as a structural feature, the unbounded nested graph.
Physicalism explains the local rules of our closed causal system. Computation explains how closed causal systems with local rules can exist, nest, and contain observers. Therefore, computation has more explanatory reach than physicalism. If we are in a simulation, physicalism is simply the rule-set of our program.
In summary, the Computation Conjecture is offered as a reasonable metaphysical position. It is grounded in observation, treats regress as structure rather than scandal, and includes physicalism as a correct description of our local layer. It is not claimed as final. Like all conjectures, it is offered for criticism.

Layers

Like layers in a croissant, good thinking often involves separating ideas to form layers. There are three kinds worth distinguishing. An explanatory layer is a level of description matched to a question: thermodynamics explains gas behavior without tracking every molecule, and chemistry explains reactions without tracking every atom. We choose the layer that makes the question answerable. A perspective layer is the viewpoint of an observer: the character inside Pong sees physics, the player sees a game, the programmer sees code. The same system reads differently from different perspectives. A substrate layer is the underlying material or process that another layer depends on. Learning to think in layers, how layers interact, and providing meaning to layers is a thinking tool that lasts a lifetime. To create layers, one subtracts details that are not relevant and adds details that are. This all happens in our heads, in imagination land. It is an ability that makes humans capable of solving problems.

The substrate layer is the most important of the three for what follows, so let me make sure it lands. The word means an underlying substance or layer. Humans require energy to live, so energy is a substrate for humans; the electrical grid is a substrate for our homes. You can use the substrate concept at different explanatory layers too: humans exist atop matter, so matter is a substrate for humans. In the first case we used it to talk about caloric energy and in the second we used a deeper substrate, that of matter. What I want you to keep in mind is that whatever exists atop a substrate is dependent on it. There is a dependency to notice.

Computers

I want to say where this argument starts. Not from myth, not from revelation, not from the supernatural, not from metaphysics. It starts from the computer on your desk and the games your children play. Every claim I am about to make rests on something we have built, can inspect, and already understand. That is the ground. We walk from there.

Because we’ve had computers for a while, it’s easy to take the study of them for granted and ignore their lessons. Many, including me, wait for the next technological breakthrough: AGI, quantum computing, new materials, robots, or fission energy. Yet, have we understood the meaning of what we already have? It’s worth reviewing.

My children have loved to play Minecraft. In September 2010, user “theinternetftw” built a 16-bit ALU (Arithmetic Logic Unit) inside of Minecraft. That was the first partial computer built within Minecraft. In 2021, Sammyuri developed “CHUNGUS 2”, an 8-bit computer that can play games like Snake, and later in 2022 the same group built a 2D Minecraft within Minecraft. Here’s what I notice: these are computers within computers. For students of computer history, this is known as the Universal Turing Machine proposed by Alan Turing in his 1936 paper, “On Computable Numbers, with an Application to the Entscheidungsproblem.”

Why is it possible to have computers within computers? It is the processing of basic logical operations: AND, OR, and NOT. In modern computers, these are typically simplified into NAND gates since you can get the features of AND, OR, and NOT in one logical gate. When you build a computer program, e.g. Minecraft and provide it with the ability to process logic gates, e.g. Redstone, then you make it possible to build a computer within a computer. There is no principled limit to this nesting. Computers within computers infinitely.

Minecraft is a program that runs on a computer. Notice that in Minecraft after Redstone (logic gates) were added, it allowed for the creation of a computer within Minecraft. This means a program can itself be a computer. It goes further, computers do not need to be made of silicon at all. They can be made of any substrate that supports processing logic gates such as water/pipes, dominoes, and mechanical devices. So, a program can be a computer, and a computer can be made of anything that supports logical information processing.

Another property of nested computers, they can pass programs between themselves. This is because a host computer may read the program of a nested computer and make changes to programs that host it. A nested computer may monitor its own programs for changes and thus two-way communication is possible. Only the possibility of communication is universal, not the guarantee of communication, this will show up again later.

Lastly, yet most profound, computers are substrate independent, what makes a mechanical computer and electrical computer both a computer? Logical information processing, which from now on I’ll refer to as Computation. Information may be represented in various substrates, but it is the information that is being shared across these implementations. This means the deeper substrate of computation is information.

A note to the physicalist before we move on. Nothing in this section is a thought experiment. Computers containing computers is not a hypothetical dreamed up to support a conclusion. It is a phenomenon we have built and can inspect. The game your children play contains a working processor. That processor is physical. If you take the physical seriously, you already take nested computation seriously, because nested computation is part of the physical world. The rest of this essay asks what follows from that fact.

Summary

Logic processing programs are called computers.
Computers are universal because information is universal.
Computers support infinitely nested computers.
Host computers and nested computers can have two-way program exchange at any depth.

Simulation

Einstein asked, “What would it be like to ride on a beam of light?” From this perspective he made a groundbreaking breakthrough in physics that we all know of as the Theory of Relativity. What Einstein did, using perspective, is something that all people can do. In technical domains this is often referred to as an observer. An observer is a special thinking tool that can give you insights where other methods fail. We’re going to use the Observer and computers to shed light on the world in which we live. As Ms. Frizzle from The Magic School Bus says, “Seatbelts, everyone!”

In 1972 Atari released Pong, a 2D table tennis arcade game designed by Allan Alcorn. Video games have come a long way since then. For example, the makers of Pong would have been shocked by the game Cyberpunk 2077. The graphics have improved. The complexity has improved. Games have come so far that they are almost lifelike in appearance. I want to call this technical progress: resolution. As technology improves, the resolution becomes convincing. At a certain resolution, the game world may seem just as real. Everyone knows the 1999 hit movie, The Matrix. Neo discovers that the world he is living in is not the real world. That’s the concept we are thinking through, a world within a world from the perspective of an observer. Computers make this possible.

What does this tell us about the nature of existence? Here’s what I want you to notice. Pong and Cyberpunk 2077 are both programs running on computers. The difference between them is resolution. Resolution is not a difference in kind, it’s a difference in degree. The 2D paddle and the photorealistic city are the same sort of thing: information being processed on a substrate, rendered for an observer. At some threshold of resolution, the rendered world becomes convincing to the observer inside it. That’s the Matrix scenario. Neo’s world obeys consistent rules, supports observers, and feels real from the inside. The only reason we call it a simulation is because we know about the container world.

Now do the observer trick. Put yourself inside the game. Not as the player holding the controller, but as a character inside the program. What do you have access to? You have access to the rules of your world. You can run experiments, you can build instruments, you can do physics. What you do not have access to is the hosting substrate. You cannot reach out of the program to touch the silicon. You cannot see the programmer. From inside, the rules of your world are your physics. They are not arbitrary and they are not optional. They are what closed causality feels like from the inside.

This is observer locality. An observer inside a computational world has access to the rules of that world and nothing deeper. The rules feel fundamental because, for that observer, they are fundamental. There is no experiment the observer can run from inside that reveals the hosting layer, unless the hosting layer chooses to pass information down. And recall from the last section: host computers and nested computers can have two-way program exchange. Possibility, not guarantee.

So a simulation is a program that contains observers. The observers inside experience their rules as physics. The hosting layer experiences those same rules as code. Both descriptions are correct. They are descriptions from different layers.

Summary

Simulations are programs that contain observers.
Resolution is a matter of degree, not kind.
Observers inside a simulation have access to their local rules and nothing deeper.
The rules of a simulation are physics from the inside and code from the outside.

People

AI is all anyone is talking about these days since the explosion of ChatGPT. Questions around consciousness, personhood, ethics, and the future of humanity are top of mind for many. I want to cut through the noise with a claim that follows directly from what we’ve already established: people can be programs.

This is not a claim I’m making from thin air. David Deutsch argues in The Beginning of Infinity that people are universal explainers, a specific kind of information-processing entity capable of creating new knowledge. If that’s what a person is, then there is no principled reason the substrate matters. A universal explainer made of neurons and a universal explainer made of silicon are both doing the same work at the level that counts: processing information, creating explanations, being observers. The substrate is a how, not a what.

Remember the lesson from Computers. Logic processing programs are called computers, and computers are substrate independent. Water pipes, dominoes, electrical circuits, neurons. Whatever supports logical information processing can host computation. If people are a kind of information processing, and Deutsch gives us strong reasons to think they are, then people are substrate independent too. AGI is not a question of whether, it’s a question of when someone arranges the right substrate.

Now I want to go one layer deeper. What kind of information processing makes something a person? This is where my own work on personhood comes in, a framework I call MFP, the Metaprogramming Framework to Classify Personhood. The short version: personhood is metaprogramming. It’s what happens when information operations turn inward. A thermostat processes information but does not process information about its own processing. A person does. That second-order move, operating on your own operations, is the threshold. Finitude becomes self, persistence becomes values, completeness becomes goals. I’ll have more to say about MFP elsewhere. For this essay, the point is narrower: personhood is a pattern of computation, not a pattern of matter.

Put the pieces together. Programs can be computers. Computers can host programs. Programs can be people. Therefore people can exist inside programs. A person inside a simulation is a person. Their observer locality is real. Their experiences are real to them. The fact that a hosting layer exists does not diminish the reality of the observer inside. It is simply a fact about where the observer sits in the nested graph.

This matters because it closes a loop. In the Simulation section I argued that observers inside a computational world experience their rules as physics. I treated “observer” as a given. Here I’m cashing that out. The observer is not a mysterious extra ingredient added to the simulation. The observer is itself a computational pattern running on the simulation’s substrate. Observers are programs inside programs. All the way down, and as we’ll see in the next sections, all the way up.

Summary

People are a kind of information processing (Deutsch: universal explainers).
Information processing is substrate independent, so people are substrate independent.
Personhood is metaprogramming, operations turned inward (MFP).
Observers inside simulations are themselves computational patterns; they are programs inside programs.

Closed Causality

We need a name for what a simulation is from the inside. I’m going to call it a closed causal system. The phrase sounds technical but the idea is ordinary. A closed causal system is a ruleset that runs by its own rules without inputs leaking in from outside. Causal explanation closes within the system. Pong is a closed causal system. The ball bounces off the paddle because the program says it does. Nothing outside the program reaches in to move the ball. The player presses a button, yes, but that input is consumed by the program and processed according to the program’s rules. From inside Pong, there is no outside.

This is what a program is, mechanically. A loop that reads state, applies rules, updates state, catches errors, and runs again. The rules are the physics of that program. The loop is its time. The state is its matter. Everything that happens inside the program happens because the rules say it happens. There is no appeal beyond the ruleset.

Now here’s the move. The hosting layer is the programmer, the operating system, the silicon. From its perspective, the rules of the program can be anything. A program can include magic. A program can include time travel. A program can violate conservation of energy. The programmer writes what she wants. From outside, the rules are arbitrary. From inside, the rules are physics.

I want you to sit with this. The same ruleset wears two faces depending on where you’re standing. The observer inside sees necessity. The ball must bounce this way, the spell must cost this much mana, the character must die when health reaches zero. The observer outside sees a choice. It could have been otherwise, the programmer could have written it differently. Both are correct. Necessity and contingency are perspective-dependent, not fundamental.

Apply this to our own physics. Our universe behaves as a closed causal system in the generally accepted sense. From the local observer’s perspective, effects follow from causes within the ruleset. There are edges to this picture, quantum indeterminacy being one, but at the scales we ordinarily inhabit no inputs leak in from outside the system. Our universe shares two structural properties with every nested world we have built: it processes information (computation), and it runs by rules that compose (programs). The behavior is describable as a ruleset that could in principle be run. When a physicist runs an experiment, the result is determined by the ruleset. This is what it feels like to be inside a closed causal system. It is what it is supposed to feel like. The fact that our physics feels necessary is not evidence that it is fundamental. It’s evidence that we are inside.

I’ll take this one step further, gently, because I don’t want to overreach. If our universe is a closed causal system, and closed causal systems can be programs, then our physics is describable as a ruleset. I’m not claiming we are in a simulation. I’m claiming that the category “closed causal system with consistent rules supporting observers” includes both programs and our universe, and that the shared structure is not a coincidence. It’s the thing that makes observer-bearing worlds possible at all.

One more piece before we move on. There’s a subtle point about time that matters. If a hosting computer runs slowly, the simulation running on it also runs slowly, from the host’s perspective. But from inside the simulation, time feels normal. The observer inside has no reference frame for the host’s clock. A Minecraft computer running at one-thousandth the speed of the host still experiences its own tick as its fundamental time unit. This tells us something important: the experience of time inside a closed causal system is always relative to that system’s own processing, never to the host’s. Observer locality applies to time the same way it applies to rules. You cannot feel the host’s clock from inside.

Summary

A closed causal system is a ruleset that runs without inputs leaking in from outside.
Programs are closed causal systems. Our universe behaves like one.
The same ruleset appears as necessity from inside and contingency from outside.
Observer locality applies to time: inside-time is always relative to the system’s own processing.

Go Down to Go Up

We’ve been looking downward. A computer can host a program. A program can be a computer. That computer can host another program. We’ve watched Minecraft contain a computer that contains a game that could contain a computer. There is no principled limit. Nesting goes down as far as logic is preserved and substrate permits.

Now I want to do something that sounds simple but isn’t. I want to turn the argument around.

If nesting goes down without limit, what stops it from going up? What is the argument that our layer, this physical universe we’re observing from, is the top? Name the experiment. Name the evidence. I’ll wait.

There isn’t one. There cannot be one. The same observer locality that prevents a character inside Pong from detecting the Atari cabinet prevents us from detecting a hosting layer, if one exists. From inside a closed causal system, the system looks fundamental. It is supposed to look fundamental. That’s what being inside means. So when we look around our universe and see consistent physics, supporting observers, with no obvious leaks, we are seeing exactly what an observer inside any closed causal system would see. Our experience is evidence that we are inside a closed causal system. It is not evidence that we are at the bottom of the stack, or the top, or anywhere in particular.

Here is the symmetry. Looking down, we see nested computation as an observed phenomenon. We build it. We watch it work. Looking up, we see our own closed causal system with consistent rules. The structure on both sides matches. To insist that nesting is real going down but impossible going up is to claim a special status for our layer without an argument for it. It is to say: the pattern we can verify is the pattern, except here, except now, except for us. That’s not a principled position. That’s a preference.

I want to be careful about what I’m claiming. I’m not claiming we are in a simulation. I’m not claiming we can prove there’s a hosting layer. I’m claiming something weaker and more important: the structure of closed causal systems is symmetric, and symmetry is the default until you give me a reason to break it. The burden is on the person who wants to stop the graph at our layer, not on the person who notices the graph has no natural stopping point.

The strongest physicalist counter is parsimony. Stopping at our layer keeps the ontology simple. Positing layers we cannot observe multiplies entities. I take this seriously, but it cuts the other way. Nested computation is not posited from nothing. We have built it, inspected it, and watched programs inside it experience their rules as fundamental. The graph view extends a pattern we already verify. The physicalist claims an exception to that pattern, that our layer alone is the bottom, without giving evidence for the exception. Parsimony favors the pattern, not the exception.

Let me push on this one more time, because I think it matters. Consider what it would take to prove our layer is the top. You would need an experiment that detects the absence of a hosting substrate. But every experiment you can run is an experiment from inside the system, using the system’s own rules, producing results according to the system’s ruleset. There is no view from nowhere. There is no experiment that reaches outside the closed causal system it’s being run in. This is not a technological limitation that might be overcome. It’s a structural property of being an observer inside a system. The observer inside Pong cannot build an instrument that detects the Atari. Not because the instrument is hard to build, but because every instrument the observer builds is itself made of Pong.

So we arrive at a graph. Computation nests downward without limit. By symmetry, it nests upward without limit. There is no principled root. There is no principled cap. Reality, under the computational view, is a rootless unbounded graph of closed causal systems, each containing observers who experience their local rules as physics. Some of these systems host others. Some are hosted. Every observer sits somewhere in the graph and cannot see past their own layer except where the graph permits information to flow.

This is the claim I’m asking you to take seriously. Not that we are simulated. Not that we are not. But that the structure of reality is not a line with physical matter at the bottom. It’s a graph. And graphs don’t have special nodes unless you give me a reason.

Summary

Observer locality applies upward as well as downward.
No experiment from inside a closed causal system can detect the absence of a hosting layer.
Insisting our layer is the top requires an argument no one has given.
Reality, under this view, is a rootless unbounded graph of closed causal systems.

Computation Is More Fundamental Than Physicalism

We started with a question about the fundamental nature of existence. We’re now in a position to answer it, or at least to answer it better than the alternatives do.

Three candidates compete for the fundamental layer. God, physical matter, and computation. Each is asked the same question: what explains you? God explains God. The buck stops with the divine, by fiat. Physicalism explains physicalism. Matter is what there is, and asking what’s underneath is a category error. Computation, at first glance, faces the same problem. What runs the computation? What’s the substrate underneath? If we say “another layer of computation,” we’ve started a regress.

Here’s the difference. God and physicalism treat the regress as an embarrassment to be stopped by decree. Computation treats the regress as a structural feature. The graph has no root because it isn’t supposed to have one. A computational world is defined by its rules and its observers, not by its position in a hierarchy. Every layer hosts and is hosted. There is no bottom to reach and no top to climb to. The regress isn’t a bug. It’s the shape of reality under this view.

This is the thesis. Computation has more explanatory reach than physicalism. Let me be precise about what I mean by reach. A framework has reach when it explains phenomena other frameworks cannot, using mechanisms that framework already contains. Physicalism explains our local rules. It describes the laws of physics, the behavior of matter, the patterns we observe in experiments. It does this well. What it cannot explain is why there is a closed causal system at all, why that system supports observers, why the rules cohere, why observers inside experience necessity. Physicalism answers these with variations of “because that’s how it is.” That’s not an explanation. It’s a full stop.

Computation explains more. It explains how closed causal systems come to exist: they are programs. It explains why they support observers: observers are computational patterns inside the program. It explains why rules feel necessary from inside: observer locality. It explains why there appears to be no leak to a higher layer: the hosting layer does not have to pass information down, and often doesn’t. It explains nesting as an observed phenomenon rather than a puzzle. And it does all of this using mechanisms we already have. We build these systems, we watch them work, we live some of our lives inside them.

Physicalism is not wrong. I want to say this clearly. Physicalism is a correct description of our layer. The laws of physics are our ruleset. If you want to know how a ball moves, how a star burns, how a cell divides, physicalism gives you the right answers. What physicalism cannot do is step outside itself. It cannot explain why the ruleset exists, why it supports observers, or why it would be one closed causal system among others. If we are inside a computational world, physicalism is simply the rule-set of our program. It remains true. It stops being fundamental.

So here is what I am proposing. Replace physicalism as the base assumption with computation. Not as a certainty. This is a conjecture, a bold guess, offered for criticism. But as the better starting point. Computation includes physicalism as a local description while reaching further. It makes sense of nesting, observers, rules, and regress in a way physicalism cannot. It matches the structural signature we already know from our own computational work. It is grounded, not mystical. It starts from what we have built and asks what follows.

What follows is a reality that is stranger than physicalism admits but less strange than mysticism requires. It is a graph. It contains observers all the way through. Some observers are us. Some are programs we’ve made. Some, perhaps, host us. The graph keeps going in both directions, and the only reason to stop it is preference.

I said at the beginning I wanted to harmonize these positions. The conjecture harmonizes matter and mind: matter is the substrate of our layer, real and binding for us, while mind is the second-order pattern that turns information inward and becomes a person, able to observe and reason and create. The divine is not fully addressed by the conjecture; it is located within the regress. Every fundamental account, including computation itself, faces the question of what explains it. What the Computation Conjecture offers is a way of treating that regress as structure rather than scandal. Whether something more lies beyond the graph is a question the framework leaves open.

The Computation Conjecture is a starting point, not an ending. I offer it as a better base assumption than physicalism, one that fits what we already know about computers and observers and nesting, one that treats regress as structure rather than scandal. Take it as a conjecture. Criticize it. Replace it with something better if you can. That’s the only way knowledge moves.

Summary

God, physicalism, and computation all face the regress question. God and physicalism stop it by decree; computation embraces it as structure.
Reach is the ability to explain phenomena other frameworks cannot, using mechanisms the framework already contains.
Physicalism explains our local rules but cannot explain why there is a closed causal system at all, or why it supports observers.
Computation explains both. Our local rules are the ruleset of our program, and the graph itself is the shape of reality.
Physicalism is not wrong. It is a correct description of our layer. It stops being fundamental.

Conclusion

I think the structure of reality is best modeled as a graph of nested closed causal systems. Not as certainty, but as the better base assumption. Simulation theory is one allowable instance of this view, not the view itself. While we don’t have access to container worlds, we can know about them by being a container world. We host simulations and can host simulations infinitely. We look at the properties of information flow between these worlds. Observers, rules, closed causality, substrate independence, nesting. They map to our own world. This is not a direct causal link. It is speculative. But the fact that information and computation flow between nested worlds, and that our world shares the structural properties of those nested worlds, is not nothing. It is the kind of evidence a fallibilist takes seriously: not proof, but reason.

What I’ve tried to do in this essay is modest. The chief move is to offer the Computation Conjecture as a reasonable metaphysical position grounded in observation. Physicalism describes our local rules well. It cannot describe why there are local rules at all, why they support observers, or why our experience of necessity is exactly what an observer inside any closed causal system would experience. Computation answers these. It does not refute physicalism. It locates physicalism as the ruleset of our layer in a graph that has no root. The graph has no root because it isn’t supposed to have one. That’s the shape of the thing. I am not claiming this is the final word. I am claiming it is a better starting point than physicalism, given what we know about computers, observers, and nesting. Anyone who wants to stop the graph at our layer owes the rest of us an argument, and no one has given one.

I’ll close where I started. I said at the beginning that computers hold insights that can illuminate the cosmos. I meant it then as a claim to defend. I mean it now as a claim I’ve defended, at least well enough to put in front of you. Computers are not just tools. They are the clearest view we have of what reality might actually be, nested, rule-bound, observer-bearing, unbounded. The lessons are already in our hands. We just have to look.

This is a conjecture. It is offered to be criticized, tested, refined, and replaced if something better comes along. That is what conjectures are for. I don’t need you to believe it. I need you to take it seriously enough to push back on it. If you do, and the framework survives, it gets stronger. If it doesn’t survive, we both learn something. Either way, knowledge moves.