Computation as Physical Causality

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: This article takes a physicalist position: everything consists of patterns in physical substrates, rather than forms in a separate Platonic realm. That position has helped Will recognize computational descriptions as physical processes rather than metaphors. 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.

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 Insight: Universe Runs Computation Natively

Physical law transforms states according to rules, which is computation. Silicon is one material in which it happens:

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.

Universe's Native Computation

The Universe Already Computes

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. Physical law itself performs the computation at every scale.

What We Do: Domesticate Pockets

Building a computer has four parts:

1. Isolate a predictable region from quantum noise and environmental disorder.
2. Maintain conditions in which the intended causal rules dominate.
3. Direct physical processes through engineered paths.
4. 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:

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

Computational patterns 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 recognizes those processes in behavior as well. It describes real causal structure and its existing rules, rather than inventing a correspondence to something elsewhere. In this 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:

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:

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:

1. The network request sends electromagnetic signals through wire or air, with photons and electrons moving.
2. A remote server switches silicon states through billions of transistor changes.
3. Parsing rewrites charge distributions in memory.
4. Processing sends electrons through logic gates in a sequence of state changes.
5. 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:

Linear memory cannot support recursion because it cannot store nested contexts. Arbitrary computation requires random access to follow arbitrary causal connections. Different access topologies therefore permit different types of causality. The Chomsky hierarchy emerges from these physical 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.

Note: Whether a separate realm of abstractions exists is outside the wiki's scope. The question here is whether physical framing helps debugging. That is an N=1 practical claim.

What This Means

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, as in Landauer's principle.

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:

Conceiving an algorithm creates neural patterns, consumes metabolic 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; there is no Platonic realm of pure algorithms.

Why This Grounding Matters

Implication 1: Understanding is Physical Process

Understanding builds a predictive neural model. Observe a cause and effect, form synaptic connections that predict it, test that prediction, and change the connections when an error appears.

Neurons fire, synapses adjust, and metabolism supplies energy, using roughly 20% of the body's budget. 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

Mathematics describes patterns in structured physical systems. Its effectiveness follows from the fact that physical reality consists 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 neural states and transitions. Mathematical modeling identifies physical structure already present.

Implication 3: Computation Limited by Physics

Every computer obeys the limits of its material:

A working-memory capacity of 4-7 items is likewise a biological constraint. More effort cannot remove the physical 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:

Human code is another instance, using silicon and electricity engineered for reliability and speed. Writing code and forming a habit both encode causal patterns into material: silicon or magnetic storage in one case, neural patterns 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

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: neural firing at about 100Hz rather than silicon's GHz, working memory of about 4-7 items rather than GB of RAM, and high metabolic costs 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 about 4-7 items, neural firing caps processing around 100Hz, and metabolic 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:

A whiteboard, a Linear list, and a wiki each provide capabilities that neural memory lacks. Moving the work is substrate selection, like choosing an SSD or hard drive according to the required read/write pattern.

Pattern 3: Habit Formation is Physical Substrate Modification

The 30x30 pattern describes a physical strengthening sequence:

• Days 1-7: a new causal pathway has high resistance and activation cost.
• Days 8-15: synaptic weights increase and the cost falls as the pathway forms.
• Days 16-30: the formed pathway approaches automatic execution.
• Day 31+: the compiled pathway runs effortlessly with minimal activation energy.

Repeated activation strengthens synapses through protein changes. Stronger synapses lower the voltage threshold for activation until the pathway fires automatically. This physical modification is measurable: fMRI shows reduced activity as a skill becomes automatic.

The account explains both delay and consistency. Physical changes cannot be installed instantly, and synaptic strengthening requires repeated activation.

Framework Integration

Connection to Neural Positivism

Neural positivism says the brain processes positive signals, not their absence. A neuron fires a voltage spike or does not fire; there is no negative physical state or “anti-firing.” This explains why directly trying to stop thinking about something cannot work. A competing positive 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 describes behavior through actual processes. State machines represent neural or silicon transitions, working memory describes biological capacity, and algorithms describe causal paths through the material. The connection holds because computation is physical causality and behavior is physical.

Connection to Working Memory

Working memory's 4-7 item limit reflects how many neural patterns 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

In predictive coding, the brain minimizes prediction-error signals through free-energy minimization. Errors are physical neural firings; updates are physical synaptic changes. The process can be measured in its material implementation.

Connection to State Machines

Physical systems occupy stable states in energy wells, and transitions require enough energy to cross a barrier. Behavioral states are neural configurations; moving between them requires metabolic energy.

Practical Applications

Application 1: Debugging Behavior as Physical Process

A behavioral sequence consists of electrochemical cascades running within biological limits. Its willpower cost is metabolic and measurable as glucose depletion.

“I can't focus” can therefore identify overloaded working memory or depleted resources from low glucose or sleep. Check sleep, nutrition, and time since the last break. Reduce simultaneous load by writing it on a whiteboard. Identify the competing neural 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:

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, for which it is optimized. This is the same engineering decision as using a GPU for parallel tasks and a CPU for serial tasks.

Application 3: Grounding Computational Metaphors

The computational terms refer to these physical processes:

The descriptions recognize the actual mechanisms rather than merely drawing a useful resemblance to software.

Common Misunderstandings

Misunderstanding 1: "It's Just a Metaphor"

The claim is that neural computation and state transitions are physical processes. Treating the description as optional metaphor would imply that its constraints could be dropped. A 4-7 item 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 consists of neural patterns forming and predicting. It consumes measurable energy, takes time, is limited by capacity, and degrades when its patterns are not maintained.

That explains slow learning, the need for rest to restore metabolism, and forgetting as pattern decay. It also points to interventions such as spaced repetition to maintain the physical patterns.

Misunderstanding 4: "This Claims to Be Science"

This article offers a physicalist philosophical stance that has been useful in Will's debugging. It does not establish physicalism as proven science or prove the literal claim that the brain is a computer. Viewing the brain as a physical computation substrate is offered as a way to reveal constraints.

Test whether the view improves practice. Its usefulness here, rather than metaphysical proof, is the measure.

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 - Predictions implemented in neural processes
• 30x30 Pattern - Strengthening pathways through 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 - Thermodynamic grounding for physical comparisons
• State Machines - Physical transitions between stable states
• Moralizing vs Mechanistic - Describing the system without judging character
• Willpower - Effort as a metabolic 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.