Computation as Core LanguageThe article uses computation as a common language for systems that transform inputs into outputs through rules.

What It Is

A system that transforms inputs into outputs by following rules performs computation. That description fits physics equations, neural networks, genetic expression, and market dynamics. This wiki uses computation as a common language for describing mechanisms wherever information is processed, decisions are made, and behavior emerges. It works the way a shared notation works in a field: the same words name the same parts everywhere, so an idea worked out for one system can be tried on another.

The Church-Turing thesis holds that a universal Turing machine can compute every effectively calculable function. Stephen Wolfram's principle of computational equivalence proposes that complex-looking systems often perform computations of equivalent sophistication, so that a simple cellular automaton can match the complexity of the human brain. Some go further and treat the universe itself as a computational substrate, repeatedly transforming one state into the next through local rules across space and time.

Describing behavior in this language brings the tools of computing with it: algorithms, complexity theory, information theory, state machines, caching, and resource allocation. These principles come from the mathematical structure of computation and belong to no particular machine, which is why they can be borrowed for something other than software.

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 described a simple abstract machine and argued that it could compute any effectively calculable function, the claim now known as the Church-Turing thesis. 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.

The thesis is often extended to physical systems: 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 abstraction, application, and substitution, which this wiki reads as recognition, binding, and substitution. On that account pattern matching is the irreducible primitive, and Turing machines, circuits, and brains can each be described as implementing it at different scales.

A system with state that transforms inputs according to rules can be described as computing. It is called Turing-complete if, given enough resources, it can simulate a Turing machine. A CPU is built to be, and some cellular automata have been proved to be.

Wolfram's Computational Equivalence

Wolfram observed that even simple systems, including cellular automata with two-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, the principle gives a comparison: an addiction pattern and PhD-level mathematics as two programs running on the same hardware. One produces a destructive cascade, the other creative output. The difference is in the program, so changing behavior means installing a better program, and no greater computational capacity has to be acquired first.

Algorithmic Complexity and the Cost of a Question

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 question also specifies a program. What makes a question expensive is how long that program takes to run, whereas Kolmogorov complexity measures how long the program is. “How can I be better?” searches the entire knowledge graph with no boundary on the search, and its output is random or incomplete. “What's the next action on highest-priority task?” specifies a short prioritized lookup and returns a concrete answer.

The O-notation used in question theory marks that difference between kinds of search: a lookup in a prioritized list against a search with no bound.

Computation as Mechanism Description

What the Computational Description Adds

A computational description proposes a process that produces the behavior and names its inputs. Other vocabularies name something else:

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:

1. It applies to rule-based transformations in any substrate.
2. Algorithms specify exact operations that can be replicated.
3. Complexity analysis gives a way to compare their costs.
4. Simple operations can compose into complex ones.
5. Debugging procedures locate failed steps.
6. A principle learned in one computational domain can be tried in another.

For example, describing procrastination as “work_launch_script failure, default_script runs instead” lays the event out as a sequence. 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.

A Description That Can Be Acted On

A computational description is pitched at a level where something can be changed. Consider waking at 5am:

The physical account is true but too detailed for direct intervention. The moral account mistakes the result for its cause, which leaves nothing to change. The computational account is the one that can be acted on: it identifies the program, threshold, and inputs.

The comparison stops at the code: a real program can be opened, read line by line, and replaced in one edit, while wake_script is a name given from outside to what is seen to happen at 5am.

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 gives a way to compare operational costs. It evaluates questions as searches, represents capacity with n, including the limit of roughly 4 to 7 items, and compares transition costs.

State Machine Theory

Finite-state automata describe discrete behavioral states and how likely each transition is. Transition costs shape those likelihoods, the cheaper transition being the more likely one, 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 routine through repetition 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 treats effort as a limited allowance, like RAM, energy budgets constrain threshold breaches, and optimization operates within those constraints.

Applied to a person, these tools give comparisons and a plan: which of two arrangements costs more, where a sequence breaks, and what to try next.

Computational Thinking as Transferable Skill

A programmer who understands algorithms, state machines, caching, and resource allocation can apply them 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, and for a habit the practice is a month of daily repetition. A cached operation runs without the work being done again.

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. The inputs named in a computational description can be changed, making that the useful intervention level.

Economic Language

Utility maximization and rational choice supply optimization models with assumptions that people do not meet. People are boundedly rational: 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 is a picture of how that output could be produced, and its inputs give places to intervene.

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 the processes that regulate it through feedback.

Judged for one purpose, changing your own behavior, the frameworks compare like this:

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 draws on that vocabulary:

• State Machines imports the terms of formal automata theory.
• Activation Energy describes the cost of starting something.
• Willpower allocates and budgets resources.
• Working Memory uses RAM as its comparison for limited capacity.
• Question Theory describes questions as Cypher queries and compares how much search each one demands.
• Caching describes repetition as the way a routine becomes cheap to start.
• Prevention removes expensive operations from the execution path.
• Cybernetics describes feedback control.

Each describes behavior in computational terms at the level where it can be changed.

Resolution and Computational Thinking

Pedagogical magnification explains how this thinking transfers. A computational description can be written at any scale, 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 - Recognition, binding and substitution as the basic operations
• Computational Literacy - Teaching the framework from first principles
• Pedagogical Magnification - Choosing resolution for thinking and teaching
• Moralizing vs Mechanistic - Replacing moral labels with descriptions of mechanisms
• Language Framework - Choosing a language suited to behavior
• Question Theory - Questions as queries, and how much search each one demands
• State Machines - Formal descriptions of behavioral states
• Cybernetics - Feedback and control systems
• Information Theory - The mathematical account of information
• Meta-Pattern - Translating moralized terms into computations

Key Principle

Computation is a language for rule-based transformations of information, whatever the system is made of. Describing behavior in it makes algorithms, state machines, caching, complexity analysis, and resource management available for intervention. Knowledge from programming carries over because a programmer already knows the vocabulary.