Computation as Physical CausalityStored states and the changes between them depend on a physical system that can hold and transform information.
What It Is
Computation can be understood as physical causality: rules changing states through a structured material. Chemical reactions, neural firing, and particle interactions already perform that computation. A computer isolates and controls a portion of it so the result is predictable.
Treating computation as physical helps identify what a material permits and what it limits. Those limits become engineering constraints to design around, including when the system being examined is a person.
Philosophical Stance: Will's position here is physicalist: everything consists of patterns in physical substrates, rather than forms in a separate Platonic realm. That position has helped Will treat computational descriptions as descriptions of physical processes, with limits as real as a machine's. Its test here is practical, not metaphysical proof. Use it if it reveals constraints or opportunities that help you debug; try another framing if it does not.
A closer look
States through a physical process
The substrate's properties constrain which states persist, how they change and what work those changes require.
Read this diagram
A stored state → A physical rule → A transformation → A new state.
The Core Idea: Physical Causality Read as Computation
Physical law transforms states according to rules, and a computation does the same. On that reading every physical process computes, and silicon is one material in which it happens:
| Domain | Process | Read as Computation | Physical Substrate |
|---|---|---|---|
| Chemistry | Molecular reactions | State transformations via bonding rules | Atomic/molecular |
| Biology | Protein folding | Pattern matching via thermodynamics | Cellular/molecular |
| Neuroscience | Neural firing | Signal processing via action potentials | Biological/electrochemical |
| Electronics | Transistor switching | Boolean logic via voltage states | Silicon/electromagnetic |
| Mechanics | Gear interactions | Sequential causality via contact | Physical machinery |
Engineered computers make that process predictable by defining a boundary, providing clear states such as 0/1 or on/off, and specifying the causal relations through gates and instruction sets. They channel existing physical computation through structures people can understand.
Natural Processes and Engineered Ones
Processes That Run Without a Designer
Quantum fields evolve continuously according to Schrödinger's equation. Electrons, photons, and atoms follow physical rules. Molecular reactions proceed according to electron configurations. These processes execute automatically without a human design or interpretation layer. Read as computation, physical law is already performing it at every scale.
What We Do: Domesticate Pockets
Building a computer has four parts:
- Isolate a predictable region from quantum noise and environmental disorder.
- Maintain conditions in which the intended causal rules dominate.
- Direct physical processes through engineered paths.
- Map those processes to abstractions people can reason about.
This creates a controlled region, like a clean room, where selected physical processes run reliably. It does not introduce new physics.
Our Bounded Systems vs Universal Execution
Different systems impose different boundaries on that execution:
| System | Substrate | Boundaries | Purpose |
|---|---|---|---|
| Universe | Quantum fields, particles | None (universal) | Native execution of physical law—the base layer |
| Computers | Silicon, electrons | Carefully isolated (transistors, insulation) | Predictable, human-comprehensible discrete computation |
| Brains | Neurons, chemicals | Biological boundary (skull, blood-brain barrier) | Adaptive, survival-oriented pattern matching |
| Programs | Any substrate | Defined scope (memory boundaries, execution context) | Specific task execution within bounded domain |
The hierarchy runs from universal physics to bounded physical systems, engineered computational devices, and software abstractions. Each level further constrains and specializes the same physical causality.
Channeling Compute-Current
A digital computer directs electron flow with transistors. Memory holds charge configurations in energy wells protected from thermal noise. A clock imposes discrete sequencing on continuous physics, and logic gates combine signals through the arrangement of the material.
Irrigation provides the analogy: channels direct water to useful places without creating the water. Digital structures similarly direct the existing flow of physics. They act as virtual machines built on its native execution.
Biological structures do this too. Neural connections guide electrochemical signals. DNA and RNA encode molecular rules that chemistry executes. Metabolic pathways organize reactions into predictable sequences. Each system isolates and directs physical causality in its own way.
Why This Grounding Matters
The patterns a computer uses already exist in physics. Innovation discovers ways to control them. That makes the constraints physical: propagation cannot exceed the speed of light, heat must dissipate, stored states must remain stable, and pattern-matching capacity depends on the material's properties.
Different materials provide different capabilities. Digital silicon is discrete, reliable, fast, and precise, which suits exact calculations. Quantum systems use superposition and entanglement for parallel state exploration. Analog systems provide continuous, low-power signal processing. Biological neural systems adapt and tolerate faults while recognizing patterns in noise.
Computational thinking looks for those processes in behavior as well. Its descriptions are aimed at real causal structure and its existing rules. In Will's account, the universe is already a computer; engineering learns to control its computation.
Memory, Computation, and Compute Defined
These terms refer to different physical properties:
| Term | Physical Definition | Physical Examples | Why It Matters |
|---|---|---|---|
| Memory | Stable physical states over time (energy wells resisting thermal fluctuations) | Magnetic domains (hard drive), capacitor charge (RAM), molecular conformations (DNA), connections between neurons (brain) | Pattern storage requires physical substrate |
| Computation | Causal transformation of states according to rules | DNA→RNA transcription, electrons through NAND gate, neurons firing in response, chemical reactions | State change following physical law |
| Compute | Flow rate of state transformations (bandwidth of causality) | Operations per second (CPU), firing rate of neurons (brain), reaction rate (chemistry) | Capacity for causality through substrate |
Memory maintains distinguishable configurations in stable energy wells. Computation transforms those configurations through physical law. Compute measures how quickly the transformations can occur through the material.
Code as Compressed Causality
A line of code is compressed causality. Its symbols specify a chain of physical events that will unfold when the program runs.
Code in Nature's Sense
In this account, code is any physical pattern encoding a causal relationship:
| "Code" in Nature | Physical Pattern | Causal Encoding | Self-Interpreting? |
|---|---|---|---|
| DNA | Nucleotide sequences (A-T-G-C) | Protein folding rules → amino acid chains → 3D structure | Yes—chemistry executes it |
| Crystal Structures | Atomic lattice arrangements | Bonding rules → face-centered cubic vs body-centered cubic | Yes—physics executes it |
| Neural Patterns | Connections between neurons | Stimulus-response pathways → pattern A triggers pathway B | Yes—electrochemistry executes it |
| Chemical Bonds | Electron configurations | Reaction rules → reactants transform to products via energy barriers | Yes—quantum mechanics executes it |
| Software | Electron/magnetic patterns | Computational rules → state transformations via logic gates | Requires interpreter (CPU) |
A pattern is read by physical matching that triggers a change. Most natural code runs without an interpreter. Human software adds an engineered CPU or VM to interpret its symbols. Both encode physical causality; software uses materials engineered for control and reliability.
Human Code: Compressed Causal Chains
Consider one line:
result = process_data(fetch_from_api())
It invokes operations across several physical systems:
- The network request sends electromagnetic signals through wire or air, with photons and electrons moving.
- A remote server switches silicon states through billions of transistor changes.
- Parsing rewrites charge distributions in memory.
- Processing sends electrons through logic gates in a sequence of state changes.
- Memory allocation changes further charge distributions in local RAM.
The single line stands for thousands of cascading state changes across materials. A function call points to a causal chain, and the interpreter or CPU unfolds it into physical execution.
Why Code is Powerful: Leverage on Universal Computation
A function name of 10-20 characters can invoke millions of transistor switches and billions of electron movements. Symbols, functions, and objects specify an organized sequence of physical changes at a scale far beyond what the person must express individually.
Programming gains its power from that compression. The author specifies how existing physics should run through the engineered system, and the physical system performs the work.
Connection to Native Execution
Natural code executes itself at every scale, from quantum to cosmic, with physical pattern matching and no interpretation layer. Human code requires an interpreter or compiler, such as a CPU or VM. It operates at a single scale and translates between abstraction levels, mapping symbols into engineered physical operations.
Both consist of patterns that encode causality. Human systems add interpretation and control to the native process.
Memory Topology Determines Computational Power
How memory is connected determines what can affect what and how quickly. Capacity alone does not determine which computations are possible:
| Memory Topology | Access Pattern | Computational Affordances | Chomsky Hierarchy | Examples |
|---|---|---|---|---|
| Linear (Tape) | Sequential only, read once | Simple patterns, no recursion | Regular (Type 3) | Finite automaton, streaming data, simple scanners |
| Hierarchical (Stack) | LIFO, nested | Recursion, nested contexts | Context-Free (Type 2) | Pushdown automaton, function calls, parsing |
| Graph (Random Access) | Arbitrary connections | Any computable pattern | Unrestricted (Type 0) | General programs, pointers; a Turing machine reaches the same class on a tape it can rewrite and revisit |
| Associative (Content-Addressed) | Pattern-based | Content retrieval via similarity | Special-purpose | Neural networks, caches, memory recall |
Memory that is read once, in order, cannot support recursion because it cannot store nested contexts. Arbitrary computation requires memory that can be rewritten and revisited in any order, so that it can follow arbitrary causal connections. Different access topologies therefore permit different types of causality. The levels of the Chomsky hierarchy correspond to these access constraints.
Physical Grounding (Rejecting Platonic Interpretation)
Physicalism treats apparent abstractions as patterns recognized across physical implementations. This stance has been useful for grounding Will's computational practice. Whether a separate realm of abstractions exists is outside the wiki's scope. The question here is whether physical framing helps debugging.
What This Means
On this stance, mathematics discovers patterns in physical reality. Algorithms are similar causal structures implemented in different materials. Logic describes transformations physical systems can perform. Information requires a physical representation and energy to process it; Landauer's principle gives the minimum for erasing a bit.
Why "Abstract" is Misleading
A mathematician working with a pure concept manipulates marks on paper or neural patterns. An algorithm running on several machines appears in several physical causal structures. Recognizing them as the same pattern does not establish a nonphysical object shared between them.
The Pattern Recognition Illusion
A sorting algorithm can appear in Python, C++, or a hardware circuit. Python executes bytecode through electromagnetic CPU states; C++ executes machine code through a different set of those states; a circuit directs electrons through logic gates.
The shared compare→swap→repeat structure is what the observer recognizes. That similarity comes from pattern recognition across physical instances, without requiring an independently existing abstract sorting algorithm.
Programs as Physical Objects
Every executed program has had a physical representation:
| "Abstract" Concept | Actual Physical Substrate | Physical Implication |
|---|---|---|
| "Thinking about algorithms" | Neural patterns in brain | Consumes energy, limited by biological substrate |
| "Writing code" | Electromagnetic states in computer memory | Persists in physical storage (magnetic/solid-state), requires energy to maintain |
| "Discussing ideas" | Air vibrations → ear drums → neural signals | Information transfer through physical media (sound waves, photons) |
| "Mathematical reasoning" | Symbols on paper or neural activation patterns | No computation without physical substrate consuming energy |
Conceiving an algorithm creates patterns in a brain, consumes energy, and remains limited by the brain. Storing code places it in magnetic domains on a hard drive, transistor charge in an SSD, or electromagnetic states in RAM. Every instance is embodied in a material; on this stance there is no Platonic realm of pure algorithms.
Why This Grounding Matters
Implication 1: Understanding is Physical Process
Understanding builds a predictive model. Observe a cause and effect, form a prediction of it, test that prediction, and change it when an error appears.
The model is built in a body, and the body supplies the energy. Physical changes take time and require energy, so understanding has both costs and capacity limits. Increasing the demand to understand faster does not remove those constraints, just as demanding a faster CPU does not remove its physical limits.
Implication 2: Mathematics Describes Physical Patterns
On this stance, mathematics describes patterns in structured physical systems, and its effectiveness follows from physical reality consisting of such patterns.
For example, 2+2=4 describes how objects combine: putting 2 apples with 2 apples does not produce 3. The relation is discovered in physical reality rather than established by arbitrary convention.
The same position treats behavioral state machines as recognition of states and transitions in the person. Mathematical modeling identifies physical structure already present.
Implication 3: Computation Limited by Physics
Every computer obeys the limits of its material:
| Constraint | Physical Limit | Implication |
|---|---|---|
| Landauer's Principle | Erasing 1 bit requires minimum kT ln(2) energy | Erasing information has a thermodynamic cost |
| Speed of Light | Information cannot propagate faster than c | Physical limit on communication between components |
| Quantum Mechanics | Fundamental limits on measurement/state preparation | Uncertainty constrains precision of computation |
| Thermodynamics | Entropy does not decrease in an isolated system | Computation generates heat, requires cooling |
A working-memory capacity of roughly four to seven items is likewise a biological constraint. More effort does not remove the limit, so the task must be arranged to fit it.
Implication 4: Code is Physical Pattern Encoding Causality
Natural structures encode causal relations in their physical arrangement:
| "Code" in Nature | Physical Pattern | Causal Encoding |
|---|---|---|
| DNA | Nucleotide sequences | Encodes protein folding rules (A-T-G-C → amino acid chains → 3D structure) |
| Crystal Structures | Atomic lattice arrangements | Encodes atomic bonding rules (face-centered cubic vs body-centered cubic) |
| Neural Patterns | Connections between neurons | Encodes stimulus-response pathways (pattern A → fire pathway B) |
| Chemical Bonds | Electron configurations | Encodes reaction rules (reactants → products via energy barriers) |
Human code is another instance, using silicon and electricity engineered for reliability and speed. Writing code and forming a habit can both be seen as encoding causal patterns into material: silicon or magnetic storage in one case, a nervous system in the other.
The Substrate Question
Changing the material can change which kinds of computation are possible, beyond changing speed or capacity.
Substrate Upgrades Enable New Causality Types
| Substrate Transition | Physical Change | New Computational Affordances | What Becomes Possible |
|---|---|---|---|
| Mechanical → Electronic | Gears → Transistors | Discrete switching states, MHz speed vs Hz | Boolean logic, complex algorithms, fast iteration |
| Electronic → Quantum | Classical bits → Qubits | Superposition, entanglement, non-local | Parallel exploration of exponential state space |
| Biological → Silicon | Neurons → Transistors | Precise, reliable, far faster switching | Exact computation at scale, no drift |
| Serial → Parallel | Single core → Many cores | Simultaneous operations across substrate | Massive throughput, different algorithm classes |
| Von Neumann → Neuromorphic | Separated memory/compute → Integrated | In-memory computation, spike-based | Energy-efficient pattern recognition |
These changes make previously impossible computations available. Mechanical computers could not process video in real time because they were too slow. Classical machines cannot efficiently simulate quantum systems because they use the wrong substrate. Serial processors cannot efficiently run certain parallel algorithms because they have the wrong topology.
The brain also has a particular set of constraints: signaling far slower than silicon's GHz, working memory of a few items rather than GB of RAM, and a high cost for overriding behavior. Externalization and environment design work around those limits. Trying to focus harder fights the same constraints without changing them.
Observable Patterns
Pattern 1: Computational Constraints are Physical
In code, RAM capacity limits memory, heat dissipation limits clock speed, and propagation through fiber or copper limits network latency.
In behavior, biological capacity limits working memory to a few items, the speed of the nervous system caps processing, and depletion limits available effort. Caching, batching, and external storage address those constraints. Asking someone to remember more does not expand the material's capacity.
Pattern 2: Externalization Works Because It's Physical
A different material can be better suited to a task:
| Function | Biological Substrate | External Substrate | Why Switch? |
|---|---|---|---|
| Working memory | Biological memory (a few items, decays fast) | Whiteboard (far larger, persistent) | Exceeds biological capacity |
| Task tracking | Biological memory (forgettable) | Linear task list (queryable) | Persistent, searchable, doesn't decay |
| Knowledge | Learned knowledge (slow to form) | Wiki articles (quick query) | Fast access, does not fade |
A whiteboard, a Linear list, and a wiki each provide capabilities that biological memory lacks. Moving the work is substrate selection, like choosing an SSD or hard drive according to the required read/write pattern.
Pattern 3: A Habit Is Built by Repetition
The 30x30 pattern is a month of daily repetition. Read as a change being made to a material, it has an order:
- At first: the new routine has high resistance and takes real effort to start.
- With repetition: the effort of starting falls as the routine forms.
- The aim: a routine that starts without deliberation.
The account explains both delay and consistency. Physical changes cannot be installed instantly, and this one requires repeated activation.
Framework Integration
Connection to Neural Positivism
Neural positivism says the brain processes signals that are present, not their absence. There is no negative signal to send, which is why trying directly to stop thinking about something tends to keep it in mind. A competing signal has to be activated instead.
Connection to Information Theory
Information theory describes information's value, costs, and limits. Landauer's principle supplies a physical cost of kT ln(2) per bit erased. Information processing consumes energy and generates heat; these costs are thermodynamic.
Connection to Computation as Core Language
Computation as core language supplies the vocabulary. State machines describe transitions, in a person or in silicon; working memory describes a biological capacity; algorithms describe causal paths through the material. Will holds that the connection works because computation is physical causality and behavior is physical.
Connection to Working Memory
Working memory's limit is on how much can remain active together. Exceeding it requires outside support such as writing, diagrams, or tools. That is a capacity problem to engineer around.
Connection to Predictive Coding
Predictive coding is a theory from neuroscience in which the brain predicts its input and corrects itself from the errors. It treats both the errors and the corrections as physical events.
Connection to State Machines
Physical systems occupy stable states in energy wells, and transitions require enough energy to cross a barrier. Behavioral states can be pictured the same way: moving between them takes effort.
Practical Applications
Application 1: Debugging Behavior as Physical Process
A behavioral sequence runs in a body, within biological limits, and its willpower cost is paid by that body.
“I can't focus” can therefore identify overloaded working memory or resources depleted by missed food or sleep. Check sleep, nutrition, and time since the last break. Reduce simultaneous load by writing it on a whiteboard. Identify the competing processes that remain active. This supplies a repair path where a character judgment supplies shame without a solution.
Application 2: Understanding Why Externalization Works
Braindumping and journaling move information between materials with different properties:
| Substrate | Speed | Persistence | Capacity | Energy Cost | Best For |
|---|---|---|---|---|---|
| Biological (brain) | Fast | Temporary (seconds-hours) | Limited (a few items) | High | Pattern recognition, rapid decisions |
| External (paper/screen) | Slower (manual query) | Persistent | Very large | Negligible | Complex planning, tracking, knowledge |
Use external storage for complex project plans that exceed working memory and for tracking that needs to persist. Use biological processing for quick calculations, where writing is slower, and rapid pattern recognition, which it does well. This is the same kind of engineering decision as using a GPU for parallel tasks and a CPU for serial tasks.
Application 3: Grounding Computational Metaphors
Each computational term refers to something that can be observed in a person:
| Computational Term | What It Describes in a Person | What Is Real About It |
|---|---|---|
| State machines | Being in one activity and moving to the next in habitual ways | The same cue tends to lead to the same next activity |
| Working memory | The few things that can be held in mind at once | The limit does not move when more effort is applied |
| Algorithms | A sequence of steps carried out in the same order each time | The sequence can be written out, and changing a step changes the result |
| Compilation | A practiced sequence taking less deliberation with each repetition | The saving comes from repetition and is not installed by deciding |
| Cache | What was used recently coming back to mind more easily | The advantage fades as time passes without use |
The terms are borrowed from software: a program's states can be read out and listed, while a person's can only be inferred from what the person does.
Common Misunderstandings
Misunderstanding 1: "A Metaphor Has No Real Constraints"
The claim is that a person's thinking and state transitions are physical processes. Treating the description as optional metaphor would imply that its constraints could be dropped. A working-memory limit cannot be exceeded by focusing harder, just as physical RAM cannot be expanded by requesting more of it.
Misunderstanding 2: "Mathematics is Invented"
From this position, mathematics discovers existing physical patterns. Arithmetic describes how objects combine, geometry describes spatial relationships, and calculus describes rates of change. Modeling behavior mathematically recognizes those relations instead of imposing an arbitrary system on them.
Misunderstanding 3: "Understanding is Non-Physical"
Understanding is something a body does. It consumes energy, takes time, is limited by capacity, and degrades when it is not maintained.
That explains slow learning, the need for rest, and forgetting as decay. It also points to interventions such as spaced repetition to maintain what has been learned.
Related Concepts
- Computational Literacy - Teaching through physical causality
- Computation as Core Language - The vocabulary this account grounds physically
- Digital Daoism - Working within substrate constraints
- Neural Positivism - The positive-signal claim
- Information Theory - Physical information costs
- Working Memory - Biological capacity limits
- Predictive Coding - A theory from neuroscience about prediction and error
- 30x30 Pattern - A month of daily repetition
- Programming as Causal Graphs - Code as compressed causality
- Execution Resolution - Material properties determining available actions
- Reality Contact - Checking the physical world represented by the model
- Statistical Mechanics Lens - Concepts borrowed from physics for comparing states and the effort of moving between them
- State Machines - States and the transitions between them
- Moralizing vs Mechanistic - Describing the system without judging character
- Willpower - Effort as a limited resource
- The Braindump / Journaling - Choosing a material with suitable storage properties
Key Principle
A physical account makes limitations and available interventions concrete. Inspect the material, the states it can retain, the changes it permits, and the cost of those changes. Use a different substrate when the task exceeds those limits. This is a philosophical approach that has helped Will debug, and it should be judged by whether it helps with the system in front of you.