The answer is not the computation

“Computation” moves between two worlds. In one world it names an abstract procedure: states, symbols and transition rules. Turing’s machine belongs here. Its tape, head and table are mathematically specified objects used to analyse what can be calculated by a finite rule.¹ In the other world, computation names what a physical thing does: voltages switch, gears mesh, ions move, light interferes or a person writes marks on paper.

The abstract machine does not heat, jam or drift. The physical system does not arrive with labels saying “state 7”, “carry bit” or “parse tree”. The puzzle is therefore not simply what an algorithm is. It is what makes this physical process an implementation of that algorithm. Copeland describes the issue as finding the right modelling relation between a device and a formal specification.² The phrase “the right relation” carries almost the entire problem.

What the formal model settles, and what it leaves open

A formal model can settle whether a transition follows from a rule, whether a procedure halts and whether one class of functions can be reduced to another. It can also show that two programs compute the same input-output function while using different intermediate states. None of this identifies the physical object that runs the program. The proof treats symbols as already individuated and transitions as already well-defined.

Physical implementation reverses the direction of explanation. We begin with a continuous, noisy process and ask which distinctions matter. A transistor voltage occupies a range, not a pristine 0 or 1. A clock edge has rise time. A relay may bounce. The physical account must explain why those variations can be grouped into stable state types, why some changes count as inputs and why a later condition counts as the result. Formal computation supplies the transition obligations; implementation supplies the physical warrant for treating those obligations as realised.

This is why “the universe obeys mathematical laws” does not entail “the universe computes every mathematical law”. A differential equation may model a pendulum. The pendulum may also be harnessed as an analogue device for estimating a quantity. The first is a scientific representation of the pendulum. The second requires an encoding, a controlled evolution and a readout that answers a task. The same physical motion appears in both, but the direction of use and the tested mapping differ.

Three strong answers compete. The intrinsic-organisation answer says a system computes because of objective causal organisation within it. The observer-relative answer says computational syntax appears only after an interpreter assigns symbols and rules. The implementation-relation answer says the abstract vocabulary is task-selected, while the physical system must objectively support the selected transitions. Each sees something the others can miss.

Consider a microprocessor executing a spreadsheet formula. At one grain, transistor networks implement gates. At another, instruction sequences implement arithmetic. At another, cells and references implement a financial function. These descriptions are not rivals if interventions commute across the levels. Flipping a register bit should alter the instruction state, the formula result and the visible cell in the ways the layered specifications predict. The hierarchy therefore permits several valid computations in one device without licensing every imaginable computation.

The observer contributes the question, the variables and the tolerance. The system contributes the answer through its causal dispositions. An observer may choose to read two voltage bands as bit values, but cannot choose that a pulse will toggle them if the circuit actually ignores the pulse. This division of labour is the paper’s central reconciliation: task relativity selects the lens; counterfactual organisation limits what the lens can truthfully reveal.

The hidden assumption in “it got the right answer”

A single history can be described in countless ways. Suppose a stone warms from 18°C to 24°C. We could label successive temperature bands “A”, “B”, “C” and “D”, then declare that the stone executed a four-state program. With enough ingenuity, the labels can be made to match almost any finite sequence that happened once. The mapping reports a pattern; it does not show that the stone was organised to produce the pattern as a response to inputs.

This is the force of triviality arguments. If implementation needs only a correspondence between an actual physical trajectory and an abstract trajectory, then sufficiently rich physical histories appear to implement too much. A wall, rock or clock can be redescribed as running arbitrary automata. Godfrey-Smith argues that resisting such conclusions requires giving up an overly autonomous high-level functional description.⁶ Sprevak presses related concerns against a purely structural mapping account.⁷

The opposite mistake is to demand that computational labels be physically intrinsic in the way mass or charge may be. “Carry bit” is not etched into a transistor. Yet neither is “gear ratio” a microscopic primitive, and gear ratios can still be objectively measured once a mechanism and question are fixed. The task vocabulary selects a coarse-graining. The mechanism decides whether that coarse-graining works.

flowchart TD
  A["The answer is not the computation"] --> B["A computation must survive<br/>another history"]
  B --> C["Where the computation begins<br/>and ends"]
  C --> D["The implementation microscope"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

A computation must survive another history

Imagine a two-state switch. Its physical states are low voltage and high voltage. A pulse changes low to high and high to low. A hold signal leaves either state unchanged. We call low “0” and high “1”. Are those labels merely ours? Yes. Could we instead call them “winter” and “summer”? Also yes. But once we claim the device implements a one-bit toggle, the causal obligations become specific.

Let x be the present physical state, such as 0.1 volts. Let u be a permitted input, such as PULSE. Let F(x,u) be the physical state reached after the device evolves. At the abstract level, let q be the bit state, and let δ(q,u) be the transition required by the toggle specification. Finally, let h map physical states to abstract states. The smallest useful implementation condition is:

Read the equation from left to right. Intervene on the physical device, let it evolve and then interpret the result. The abstract state you obtain must equal the state predicted by intervening on the abstract machine. The assumption doing the work is that the physical and abstract interventions correspond. If “PULSE” in the specification has no stable physical operation, the equation is decorative.

Which alternatives belong in the test?

Counterfactual support does not require a device to survive every physically possible disturbance. Dropping the counter into acid is a possible intervention, but not an input in the counter specification. Nor must a laptop preserve its program after every cosmic-ray strike. The relevant alternatives come from the declared task, operating envelope and failure model.

This restriction must not become an escape hatch. A proponent cannot define the admissible set as “only the path that succeeded”. The set should include each input the task promises to accept, every reachable state needed for those inputs, ordinary reset and any fault whose handling is part of the claim. If a system is sold as a four-function calculator, subtraction cannot be omitted because the present demonstration used addition. If a neural circuit is said to implement a comparison algorithm, interventions on the proposed comparison variable should be included even when ordinary examples rarely visit one branch.

There is also a difference between nomological and practical possibility. A branch may be consistent with the laws of physics yet inaccessible without destroying the device. The assay counts interventions that can be prepared, induced or justified by a validated causal model. A hidden state swap in a neural network may be executable in software; the analogous swap in a biological circuit may require a model-based perturbation rather than literal replacement. The intervention family must be operational enough to test and broad enough to expose the claimed rule.

This pattern resembles exact transformations between causal models, where high-level and low-level descriptions should agree about intervention effects.⁹ In machine learning, causal-abstraction methods use interchange interventions to test whether internal representations play the causal roles assigned to high-level variables, rather than merely correlating with them.¹⁰¹¹ The paper’s proposal extends the same intuition into a practical implementation assay for ordinary and unconventional computers.

Coverage, fidelity and degeneracy

A real device is noisy, so exact equality may be too strong. Replace it with a tolerance: the mapped physical outcome must fall within an acceptable distance ε of the abstract prediction. The tolerance must be fixed before observing the result and tied to the task. A temperature controller may tolerate 0.2°C; a cryptographic bit does not tolerate a one per cent chance of spontaneous reversal.

Three measurements then matter. Coverage is the proportion of required state-input pairs actually tested. Fidelity is the proportion of tested pairs that produce the specified abstract transition. Distinguishability asks whether different abstract states have physically discriminable realisers at the readout. A map that sends every physical state to q0 has perfect stability but implements nothing useful.

The two-bit counter has eight required state-input pairs. Six passing tests give 100 per cent fidelity on 75 per cent coverage; eight tests with one failure give complete coverage at 87.5 per cent fidelity. The first candidate is unknown on two branches; the second is known to violate one. Those support different decisions.

If many physical microstates map to abstract 01, testing one exemplar is also insufficient when temperature or timing changes the transition. Every discarded physical difference becomes an assumption of invariance.

Where the computation begins and ends

Counterfactual structure blocks the easiest trivial mappings, but it does not by itself choose the system boundary. A laptop running a calculation depends on power, clock timing, memory and human-supplied inputs. A cloud service depends on remote state and network protocols. A person using paper depends on learned symbol rules. Which parts belong to the computer?

The answer follows the claim. If the claim is “this chip implements an adder”, the boundary should include the physical components that preserve the adder’s state transitions under the declared electrical interface. If the claim is “this service computes an account balance”, the boundary must include any remote state, orchestration and readout without which the task transitions fail. A boundary is justified by intervention closure, not by convenience or visual enclosure.

A boundary stress test

Begin with the smallest proposed boundary. Freeze everything outside it while varying an allowed input inside. If the claimed transition cannot occur because essential state or authority sits outside, enlarge the boundary. Then perturb the newly included dependency. Continue until the task transitions are closed under the declared intervention set, or until the claim fragments into several coupled computations.

This method prevents two opposite errors. The first is localisation theatre: pointing to the visually impressive component while remote services or human decisions carry the actual state. The second is boundary inflation: declaring the whole organisation or universe to be the computer because every process has remote causes. A dependency belongs inside only when removing, freezing or changing it alters the task transition in a way the claim needs to explain. Power can often remain an environmental condition; a versioned route table cannot if different versions produce different routes.

Function, use and the threat of an idle computer

Mechanistic accounts add another constraint: computing mechanisms have functions. Piccinini characterises them as mechanisms that generate outputs from inputs and internal states according to a general rule.⁵ This helps distinguish a calculator from a weather pattern that can be described with the same mathematics. The calculator was organised, selected, maintained or used to perform the transformation.

Representation-based accounts emphasise encoding and decoding. Horsman and colleagues describe physical computation as using a physical system to predict an abstract evolution through instantiation, physical evolution and representation of the result.⁸ This makes task use explicit. It also raises a hard case: does a disconnected but intact calculator cease computing when nobody reads it?

The implementation assay separates two questions. Capability implementation asks whether the mechanism supports the transition structure under admissible interventions. Task execution asks whether a particular run was initiated and its result made available for the task. An idle calculator can retain the capability. A live run with no accessible readout may execute internal transitions yet fail to complete the claimed task. This distinction avoids making human observation magically constitutive while preserving the role of use.

Digital, analogue and learned realisers

The assay is not restricted to digital machines. In an analogue computer, abstract variables map to continuous physical quantities and transitions map to dynamical evolution. The obligations become ranges, calibration curves and error bounds rather than exact bit states. A mechanical tide predictor can implement a family of harmonic calculations if configured inputs, physical motion and readout preserve the relevant relations within declared tolerances.

Learned systems add a different difficulty. Their high-level state variables may be distributed across many units and may not have obvious boundaries. Decoding a variable from activations establishes that information is available to an external probe. It does not show the model uses that variable in the proposed algorithm. Interchange interventions are valuable because they replace a candidate internal value with one taken from another case and ask whether downstream behaviour changes as the high-level model predicts. The same principle powers the implementation assay: readability is evidence of representation; intervention fidelity is evidence of causal role.

These cases share a structure but not a universal measurement. A relay can be exhaustively tested over a small finite table. An analogue device needs calibration and uncertainty analysis. A neural model may require sampled interventions over a huge input space. The common requirement is not one metric. It is a declared mapping whose failures can be exposed by changing the relevant cause.

stateDiagram-v2
  [*] --> Claim
  state "Three boxes answer 42" as Claim
  state "What the formal model settles,<br/>and what it leaves open" as Test
  state "The hidden assumption in “it<br/>got the right answer”" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The implementation microscope

The proposed instrument is a disciplined way to make a bounded claim, not a universal metaphysical detector. Call it the Counterfactual Implementation Assay. It turns “this system computes X” into a record that another person can challenge, rerun or narrow.

The assay begins with the abstract task, not the device. Specify states, inputs, transition rules and acceptable outputs. Then declare the physical boundary, the mapping from physical state regions to abstract states, the physical operations corresponding to abstract interventions and the readout. Pre-register the tolerance and the cases that matter. Run a branch-complete test where feasible. Record failures, not only successful traces.

In practice, the record has seven fields. The task contract names the question the computation answers. The abstract machine names its state and transition obligations. The candidate boundary lists the physical components and external conditions. The state map groups physical conditions into abstract values. The intervention map says how each task input or state manipulation is physically induced. The readout contract says how the result becomes available. The evidence manifest records trials, tolerances, failures and versions.

Run the cheapest revealing intervention first. HOLD and reset often expose playback. State swaps expose whether an intermediate variable is causally used. Substrate replacement tests whether an implementation claim survives material change. Boundary freezes expose hidden remote dependencies. Independent readback separates a commanded transition from an achieved one. The sequence should be chosen to discriminate the live rival generators, not to accumulate a large but redundant test count.

Finally, write the permitted sentence before viewing the result. For example: “If every required branch passes with at least 99.9 per cent fidelity under the declared voltage and temperature range, the board will be treated as implementing the two-bit counter for this controller.” This prevents a near miss from being re-described as success after the fact. The assay governs language as much as measurement.

Executable implementation assay

The relay preset covers every state-input pair in the two-bit counter and provides reset, readout and prospective-use evidence. The tape reproduces one familiar sequence but fails HOLD branches and reset. The cup’s labels are explicitly post-hoc. A positive result permits the sentence: “Within this boundary and tested domain, the candidate implements the specified transition system.”

A negative result is weaker. It means the supplied mapping and evidence do not support the claim. The system might implement a different computation, or the test boundary may be wrong. The assay cannot establish semantics, intrinsic purpose, intelligence, agency, subjective experience or moral status. It also cannot exhaust an infinite input domain; sampling and proof obligations must be added for scalable systems.

function assay(machine, candidate) {
  const required = [];
  for (const state of machine.states) {
    for (const input of machine.inputs) required.push([state, input]);
  }

  let covered = 0;
  let correct = 0;
  const failures = [];

  for (const [state, input] of required) {
    const observations = candidate.observations.filter(
      o => candidate.map[o.from] === state && o.input === input
    );
    if (!observations.length) {
      failures.push(`Missing intervention: ${state} + ${input}`);
      continue;
    }
    covered += 1;
    const expected = machine.delta[`${state}|${input}`];
    const pairPasses = observations.every(
      o => candidate.map[o.to] === expected
    );
    if (pairPasses) correct += 1;
    else failures.push(`Wrong transition: ${state} + ${input}`);
  }

  const realisedStates = new Set(Object.values(candidate.map));
  return {
    coverage: covered / required.length,
    fidelity: covered ? correct / covered : 0,
    distinguishability: machine.states.every(s => realisedStates.has(s)),
    resetEvidence: Boolean(candidate.resetEvidence),
    readoutEvidence: Boolean(candidate.readoutEvidence),
    prospectiveTaskUse: Boolean(candidate.prospectiveTaskUse),
    failures
  };
}

From a binary verdict to an evidence grade

Engineers rarely need the impossible verdict “is this intrinsically a computer?” They need to know what claim present evidence licences. The assay therefore grades evidence without converting computation into a single metaphysical score.

Grade A is not “more computational” than Grade B in a metaphysical sense. It is better supported for explanation, transfer and failure diagnosis. A black-box component can implement a task while remaining mechanistically opaque. The stronger grade matters when a design decision depends on replacing the substrate, predicting off-distribution behaviour or containing failure.

The strongest boundary and alternative explanations

The strongest objection says counterfactual structure still allows too many mappings. A sufficiently complicated physical system may support many causal partitions. That is true. The assay does not promise a unique computation at every grain. A modern processor genuinely supports several descriptions: logic gates, instructions, virtual machines and application algorithms. Multiple valid mappings are not triviality when each carries its own intervention commitments.

A second objection says task use and function are doing the real work, so counterfactual fit is unnecessary. But intended function can be mistaken. A damaged calculator was designed to add yet may no longer implement addition. Control fit catches the failure. Conversely, an evolved or accidental system may be harnessed for a task it was not designed to perform. Control fit can support the implementation while the historical function remains absent.

A third objection comes from strong intrinsic accounts: computation is just a special kind of physical mechanism, and representation adds avoidable subjectivity. The assay agrees that physical organisation constrains the answer. It retains task vocabulary because the same mechanism can be used to realise different abstractions at different levels, and because “correct” versus “incorrect” computation depends on a specification. Landauer’s result shows that logically irreversible operations have physical thermodynamic consequences,¹² but heat generation alone does not tell us whether the device calculated a checksum, sorted a list or failed.

The deepest limit is conceptual. Computation is an explanatory bridge, not an ontology of everything the system is. Demonstrating that a brain region, cell network or artificial model implements a transition system may explain part of its behaviour. It does not show that every causally relevant property is computational. It does not settle whether meaning is intrinsic, whether biological material contributes constitutively or whether experience accompanies the process.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The answer is not the computation
  M->>E: Three boxes answer 42
  E-->>M: compare rival explanations
  E->>D: Require control fit before calling it computation
  D-->>Q: revise scope or act

Require control fit before calling it computation

Stop asking whether a device “is a computer” in the abstract. Ask a claim that can fail: Does this bounded physical system implement this specified transition structure for this task, across these interventions and within this tolerance?

That change matters in four places. When evaluating unconventional hardware, demand prospective encoding, intervention and readout rather than an impressive natural pattern. When interpreting a neural network, distinguish a decodable feature from a variable that survives causal interchange. When comparing substrates, test whether the intervention fingerprint survives replacement. When making claims about minds, treat computation as one mechanism ledger, not as automatic evidence of semantics or experience.

The practical decision is to promote claims only when control fit, boundary and readout are explicit. If the evidence shows one trace, call it a correspondence. If several branches pass, call it partial realisation. If the declared transition family, reset and readout pass, call it task implementation. If component interventions and independent readback also pass, use the computation as a mechanism-level explanation.

The distinction is modest but consequential. It preserves what is objective in physical organisation without pretending that abstract labels float inside matter. It preserves the role of tasks and interpreters without allowing them to make every process compute everything. Most importantly, it turns a philosophical dispute into a better experimental question: what alternative history must this system be able to survive before the computation claim earns our trust?