What It Is
A system that transforms inputs into outputs by following rules performs computation. That includes physics equations, neural networks, genetic expression, and market dynamics. Computation supplies a universal language for describing mechanisms wherever information is processed, decisions are made, and behavior emerges. The claim is literal: computation is the underlying substrate and the deepest available description of how these mechanisms work.
The Church-Turing thesis establishes that a universal Turing machine can compute every effectively calculable function. Stephen Wolfram's principle of computational equivalence extends the account: complex-looking systems often perform computations of equivalent sophistication. A simple cellular automaton can match the complexity of the human brain. The universe itself may be a computational substrate, repeatedly transforming one state into the next through local rules across space and time.
If behavior is computational, computational tools apply to it: algorithms, complexity theory, information theory, state machines, caching, and resource allocation. These principles come from the mathematical structure of computation, so they transfer across domains rather than belonging only to software.
A closer look
Describe a transformation
This is the practical descriptive move in the article; the broader philosophical argument continues in the text.
Read this diagram
Identify the inputs → Name the rules → Trace the change → Inspect the output.
Computability and Universal Computation
The Turing Machine Foundation
In 1936, Alan Turing proved that a simple abstract machine could compute any effectively calculable function. It consists of an infinite tape for memory, a read/write head for processing, a state table for the program, and a finite set of states and rules.
Any computation performed by a physical system can be performed by that machine. The computation is a mathematical structure independent of the material implementing it.
Lambda calculus reduces the operations further to recognition, binding, and substitution. Pattern matching is the irreducible primitive; Turing machines, circuits, and brains implement it at different scales.
| System | Substrate | Computational? | Turing-Equivalent? |
|---|---|---|---|
| Electronic CPU | Silicon transistors | Yes | Yes |
| Human brain | Biological neurons | Yes | Yes (practically bounded) |
| Genetic expression | DNA/RNA/proteins | Yes | Yes |
| Cellular automaton | Mathematical rules | Yes | Yes |
| Water flowing downhill | Physical laws | Borderline | No (no information storage) |
A stateful system that transforms inputs according to rules computes. It is Turing-complete if, given enough resources, it can simulate a Turing machine.
Wolfram's Computational Equivalence
Wolfram observed that even simple systems, including cellular automata with 3-state rules, quickly reach universality and generate maximally complex patterns. His principle states that almost all processes that are neither trivial nor obviously simple perform computations of equivalent sophistication.
Applied to behavior, an addiction pattern and PhD-level mathematics use computations of similar complexity. Both are Turing-complete. The difference is the program running on the universal hardware: one produces a destructive cascade, the other creative output. Changing behavior therefore means installing a better program rather than acquiring greater computational capacity.
Algorithmic Complexity as Fundamental Metric
Kolmogorov complexity measures information content by the shortest program that produces an output:
K(x) = min{|p| : U(p) = x}
Where:
K(x) = Kolmogorov complexity of string x
p = program
U = universal Turing machine
|p| = length of program p
A complex question specifies a long, expensive program. “How can I be better?” searches the entire knowledge graph, with O(∞) complexity and random or incomplete output. “What's the next action on highest-priority task?” specifies a short prioritized lookup, with O(log n) complexity and a concrete answer.
The O-notation used in question theory represents the actual cost of executing the search program specified by the question.
Computation as Mechanism Description
Why Computational Language Is Fundamental
Computational descriptions identify the mechanism producing behavior. Other vocabularies operate at higher levels of abstraction:
| Language Type | Example | Abstraction Level | Debuggability |
|---|---|---|---|
| Moral | "He's lazy" | Highest (character judgment) | Zero (no mechanism) |
| Psychological | "He has low motivation" | High (mental state) | Low (vague mechanism) |
| Neurobiological | "His dopamine system is dysregulated" | Medium (physical substrate) | Medium (not directly manipulable) |
| Computational | "Expected value calculator outputs low signal" | Low (mechanism) | High (manipulable inputs) |
You cannot directly change “character” or “dopamine levels.” You can change inputs to expected value: make the reward more salient, reduce the delay before it arrives, or make progress visible. Naming those inputs identifies interventions that a label such as “low motivation” does not.
The Mechanistic Link
Computation provides six advantages for describing a mechanism:
- It applies to rule-based transformations in any substrate.
- Algorithms specify exact operations that can be replicated.
- Complexity analysis measures their costs objectively.
- Simple operations can compose into complex ones.
- Debugging procedures locate failed steps.
- A principle learned in one computational domain transfers to every other.
For example, describing procrastination as “work_launch_script failure, default_script runs instead” identifies an actual computational process. A program is loaded, missing preconditions prevent it from running, and a default program takes over. The description supplies three possible interventions: identify the missing preconditions, satisfy them, or change the default program.
More Than Metaphors
Computational descriptions name the underlying process at an appropriate abstraction level. Consider waking at 5am:
| Level | Description | Usefulness |
|---|---|---|
| Physical | Neurons fire, muscles contract, eyes open | True but not actionable (cannot directly control neurons) |
| Computational | Circadian program executes wake_script at time_threshold | True and actionable (can modify program, threshold, inputs) |
| Moral | "He's disciplined enough to wake early" | False (describes output not mechanism, not actionable) |
The physical account is true but too detailed for direct intervention. The moral account is false because it mistakes the result for its cause. The computational account is both true and changeable: it identifies the program, threshold, and inputs.
Neuronal firing itself computes. Voltage thresholds open ion channels, neurotransmitter binding triggers cascades, and action potentials propagate. These are computational operations, so describing them that way is an account of what occurs.
Emergence and Levels of Abstraction
One click in a browser can be described at several levels. Electrons move through semiconductors. Logic gates perform AND, OR, and NOT on binary signals. Assembly instructions execute MOV, ADD, and JMP. The operating system makes system calls and schedules processes. The browser sends HTTP requests and renders the DOM. The user experiences clicking a link.
All describe the same event truthfully. To understand and change the behavior, use the algorithmic level. Physics includes too much irrelevant detail for that intervention; the user's account omits the mechanism. The useful description falls between them.
Computation Gives Access to Tools
Algorithmic Complexity Theory
O-notation measures operational cost. It evaluates questions as searches, represents capacity with n, including the 7±2 item limit, and quantitatively compares transition costs.
State Machine Theory
Finite-state automata describe discrete behavioral states and transition probabilities. Transition costs determine the probability distribution, while default scripts specify the programmed transitions.
Information Theory
Shannon entropy measures uncertainty. Information value is its reduction. Signal-to-noise ratios describe sensor accuracy, and channel capacity gives the bandwidth of a feedback loop.
Caching and Compilation
Caching a neural pathway reduces its activation cost. Compiled routines run automatically; interpreted execution requires effort. The tradeoff is time spent compiling against efficiency on later executions.
Resource Management
Computational budgets let you allocate scarce capacity. Willpower accounting manages RAM, energy budgets constrain threshold breaches, and optimization operates within those constraints.
These tools describe actual mechanisms in precise mathematical terms, allowing quantitative analysis and systematic optimization.
Computational Thinking as Transferable Skill
A programmer who understands algorithms, state machines, caching, and resource allocation can apply them directly to behavior. The phrase “habits are cached subroutines” carries the existing knowledge of what a cache does.
Caching spends setup time to make later execution faster. Frequently used operations are worth caching. The cache needs a warming period, which is 30 days for neural pathways, and a cached operation runs without conscious control.
A programmer can transfer that whole account immediately; a non-programmer has to learn it from the beginning. Technical readers already use this thinking on software. Applying it to themselves gives them the same tools without requiring a new framework.
Why Not Other Frameworks?
Physics Language
Physics describes neural firing precisely through ion-channel dynamics, but those details cannot be directly manipulated to change behavior. Inputs to the computational process can be changed, making that the useful intervention level.
Economic Language
Utility maximization and rational choice supply optimization models with the wrong assumptions. People are bounded-rational computers: they have limited memory, cognitive biases, and satisficing heuristics. Computational descriptions incorporate finite memory and imperfect algorithms directly, while economic descriptions treat them as departures from an ideal optimizer.
Psychological Language
Psychology names mental states such as motivation, emotion, and cognition. “Low motivation” describes the output. An expected-value calculator describes how that output is produced, making intervention possible.
Biological Language
Biology identifies neurotransmitters and brain regions, but their relation to an intervention is indirect. You cannot directly increase dopamine. You can alter the inputs to computational processes that regulate it through feedback.
| Framework | Abstraction | Mechanistic Depth | Actionability | Transfer Learning |
|---|---|---|---|---|
| Moral | Very High | None | Very Low | None |
| Psychological | High | Low | Low | Low |
| Economic | Medium | Medium | Medium | Medium |
| Biological | Low | High | Low | Low |
| Computational | Medium | High | High | Very High |
The computational level retains enough mechanism to explain the behavior, enough abstraction to change it, and enough generality to transfer knowledge across domains.
Integration with Mechanistic Framework
Every major framework in this wiki uses that foundation:
- State Machines imports formal automata theory.
- Activation Energy measures computational cost in resource units.
- Willpower allocates and budgets resources.
- Working Memory uses RAM as an accurate abstraction.
- Question Theory describes questions as Cypher queries with measurable complexity.
- Caching compiles neural pathways through repetition.
- Prevention removes expensive operations from the execution path.
- Cybernetics describes computational feedback control.
They describe behavior as computation at the level where it can be changed.
Resolution and Computational Thinking
Pedagogical magnification explains how this thinking transfers. Computation exists from quantum processes to conscious decisions and civilization-scale emergence. Choose a resolution that fits the available compute and the intervention required.
Most computer-science teaching follows this order by introducing Python or JavaScript before assembly and memory management. Students first learn what programs accomplish. That experience makes lower-level details meaningful when they arrive.
AI can translate between these levels, separating computational literacy from writing code. A student states an intention and AI manages implementation details. The student learns causality by checking whether the result works, then examines the machinery when curiosity or debugging requires it. Syntax no longer has to be an arbitrary prerequisite to that learning.
Related Concepts
- Pattern Matching - The computational primitive
- Computational Literacy - Teaching the framework from first principles
- Pedagogical Magnification - Choosing resolution for thinking and teaching
- Moralizing vs Mechanistic - Replacing moral labels with computational mechanisms
- Language Framework - Choosing a language suited to behavior
- Question Theory - Query structure and algorithmic cost
- State Machines - Formal descriptions of behavioral states
- Cybernetics - Computational control systems
- Information Theory - The mathematical account of information
- Meta-Pattern - Translating moralized terms into computations
Key Principle
Rule-based information transformations share a computational structure across substrates. Describing behavior through that structure makes algorithms, state machines, caching, complexity analysis, and resource management available for intervention. Knowledge from programming transfers directly because the underlying process is the same.