The role is larger than the response

Touch a hot pan and pull your hand away. What, exactly, should count as the mental state in this event? The outward movement is not enough. A spinal reflex can begin before a considered judgement. An actor can imitate the movement without heat. A powered prosthesis can execute the same trajectory from a safety controller. The visible response underdetermines the process that produced it.

Change one variable. After the hand withdraws, remove the pan and ask what happens next. A person may attend to the injured finger, expect further pain, avoid the pan, seek water, update a belief about its temperature and describe the sensation. These relations extend through time. They connect sensory input to internal state, one internal state to others, and those states to action, learning and report.

That network is the basic intuition behind functionalism. A functionalist does not identify pain, belief or desire with one material kind merely because humans currently realise it in brains. The state is picked out by what it does within an organised system. Classic formulations describe causal relations among sensory inputs, other mental states and behaviour, with different versions grounding the role in common-sense theory, machine-state descriptions or mature psychology (Putnam, 1967; Lewis, 1972; Block, 1978).

The source of the role matters. Common-sense functionalism begins from the relations implicit in ordinary psychological explanation: pain tends to follow injury, compete for attention, motivate relief and support sincere report. Machine-state functionalism asks which state in a transition system mediates inputs, other states and outputs. Psychofunctionalism gives empirical cognitive science more authority, allowing a mature theory to revise folk categories rather than merely formalise them. These versions can agree that material alone does not individuate the state while disagreeing about which causal pattern is constitutive.

This disagreement changes how a test should be built. If the role comes from common sense, the evaluator must guard against anthropocentric expectations. If it comes from a formal machine table, the evaluator must show that the table is physically implemented rather than retrofitted to a trace. If it comes from psychology, the evaluator must state which theory supplies the variables and what evidence would make that theory change. There is no substrate-independent role specification floating free of every explanatory practice.

A second distinction is equally useful. The role is the high-level causal profile; the realiser is the lower-level state or mechanism that occupies it in a particular system. A functional specification can therefore remain shared while the occupant differs. It can also turn out that a supposedly shared role was too coarse: once learning, timing or bodily regulation is included, the two occupants may no longer satisfy one specification.

A functional role is a structured disposition, not a label attached to an output. It includes what would happen under inputs that did not occur, how internal state changes future processing, which failures propagate, and which other states are made available. This makes functionalism more demanding than behaviourism. It also makes the word “function” dangerously easy to underspecify.

From actual-path to intervention-closed equivalence

The toy case suggests a useful distinction. Two systems have actual-path equivalence when their observed input and output histories match. They have intervention-closed role equivalence only when the relevant internal and external perturbations preserve the same high-level dependencies. The intervention set must be declared. Nothing is equivalent under every imaginable change.

A compact role signature helps. Let S be the candidate system, J the interventions we are prepared to perform, C the contexts in scope, Z the proposed internal role variables and Y the resulting actions or reports. Over a chosen timescale τ, write:

This notation says: collect the system’s distributions of future outputs and role states after each allowed intervention in each relevant context. Two systems are functionally equivalent for role R when a defensible mapping between their internal states makes these signatures agree within a declared tolerance. The formula does not decide which variables matter. The theory of the role, the task and the competing explanations must do that work.

flowchart TD
  A["The patient, the replacement,<br/>and the perfect recording"] --> B["The role is larger than the<br/>response"]
  B --> C["What a second realiser must<br/>preserve"]
  C --> D["The liberalism trap"]
  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

What a second realiser must preserve

Functionalism became attractive partly because it appeared to separate mentality from one parochial material. If pain were identical to one human neural type, then creatures with different nervous systems could not share that mental kind. Hilary Putnam used such cross-species possibilities against simple type identity theories. Jerry Fodor connected the thought to the autonomy of psychology: one higher-level regularity might be implemented by heterogeneous physical kinds (Putnam, 1967; Fodor, 1974).

The slogan that followed was powerful: minds are multiply realisable. The difficulty lies in the missing verb. What must a second system do to realise the same state? “Produce the same answer” is too weak. “Contain the same material” gives up the point. The useful middle lies in preserved causal organisation, but that phrase needs levels.

A three-state machine makes the demand visible

Consider a minimal high-level role with three states: quiet, alert and guarded. In the quiet state, a damaging input causes withdrawal and moves the system to alert. In alert, a safe input causes inspection and moves it to guarded. Another safe input returns it to quiet. Repeated damage maintains alert and withdrawal.

Machine A stores these states as named software values. Machine B stores them as three voltage ranges in a circuit. A mapping φ assigns low voltage to quiet, high voltage to alert and middle voltage to guarded. If corresponding interventions on the state and input produce corresponding transitions and actions, the two machines realise the same abstract controller despite different local encodings.

Multiple does not mean unconstrained

Change the grain of description and the verdict can change. Two pumps may both move five litres of fluid per minute, yet one supplies a smooth flow and the other a pulse. At the coarse grain “move fluid”, they share a function. At the grain needed to regulate pressure through a compliant vascular system, the difference becomes causally relevant. Neither description is automatically correct. The explanatory question selects the grain.

The same discipline applies to mental kinds. “Recognises a face” may group together systems that choose the same name, while a finer role distinguishes viewpoint invariance, familiarity, affective response, confidence and learning from one encounter. Evidence for multiple realisation at the first grain does not guarantee it at the second. Conversely, a microscopic difference does not defeat a higher-level identity unless an intervention on that difference changes the role’s relevant effects.

A practical grain test has three moves. Hold the proposed high-level role fixed and vary the lower-level feature. Ask whether the role’s predictions change within the intended context. Then vary the high-level demand while keeping the lower-level contrast visible. A difference counts against shared realisation only when it matters to the property being explained, rather than only because an instrument can detect it.

Critics of easy multiple realisability have pressed three related points. Jaegwon Kim argued that heterogeneous realisation can still permit local reductions within more specific structure types. Lawrence Shapiro asked whether purported realisers differ in ways relevant to how the function is performed, rather than merely in material. Polger and Shapiro later developed a sustained sceptical case that many familiar examples trade on coarse psychological kinds and fine physical differences (Kim, 1992; Shapiro, 2000; Polger & Shapiro, 2016).

The empirical situation is also less tidy than the slogan. A study of object recognition framed as a test of intraspecific multiple realisation concluded that the evidence remains dependent on how psychological and neural kinds are individuated (Strappini et al., 2020). Rosa Cao argues that richer views of neural function, including metabolic and informational coupling, constrain possible realisers more than simple all-or-nothing signal roles suggest (Cao, 2022).

Substrate neutrality is an earned invariance claim, not a starting axiom. Timing, noise, plasticity, metabolism, embodiment, developmental history and energetic regulation may be safely abstracted away only when changing them does not alter the role under study. A digital circuit need not copy biochemistry to realise a finite-state controller. It may need much more to realise a biologically thick affective state whose function includes interoception, homeostasis and development.

The liberalism trap

A theory becomes liberal when it attributes mentality too easily. It becomes chauvinist when it excludes plausible minds because they are built differently. Functionalism was designed to avoid carbon chauvinism, but coarse roles can swing to the opposite extreme. A thermostat has inputs, internal states and outputs. A nation can be arranged to pass symbols. A vast lookup table can answer every item in a finite examination. Which extra relation stops these systems from inheriting every mental predicate?

Ned Block’s classic objections exploit this tension. Very broad functional descriptions admit systems that seem mentally implausible; narrow descriptions risk building human-specific structure into the definition (Block, 1978). The replacement ladder helps only partly. It can expose missing causal relations. It cannot force agreement when one side claims that exact functional organisation is constitutive of mentality and the other claims that biological or phenomenal properties remain indispensable.

A realistic claim: does the rover have a blocked-route belief?

Consider a rescue rover navigating a damaged building. Engineers propose a narrow functional claim: the rover can occupy a state that plays the role of believing corridor C is blocked. The role is not defined by saying “blocked” or turning left once. Camera and lidar evidence must update a world-state variable; the planner must exclude the corridor; route proposals must change; later contrary evidence must permit revision; downstream explanations and actions must depend on the same state.

Controller A has an explicit operational twin of the floor, a state estimator and a planner. Controller B is an imitation model trained to map current sensor frames directly to steering commands. On routine scenarios, both avoid blocked corridors. The difference appears when evaluators swap the blocked-route state while holding the image fixed, inject disagreement between sensors, reopen the corridor, or delay a map update.

If the relevant state in Controller A causally governs planning, these interventions should produce a coherent family of changes. Controller B may still perform well, perhaps by using visual shortcuts. That is useful control behaviour. It is weaker evidence for the proposed belief-like role.

The mapping itself can become the mimic

Modern causal-abstraction research gives precise tools for aligning high-level variables with low-level model states and checking whether interventions commute across the mapping. Interchange interventions, for example, swap a candidate internal representation and test whether the resulting output matches the high-level causal model (Beckers & Halpern, 2019; Geiger et al., 2021). Later work generalises the framework and treats faithfulness as graded rather than all-or-nothing (Geiger et al., 2025).

There is a matching danger. If the alignment map is allowed unlimited complexity, it can encode the answer rather than reveal a mechanism. A recent preprint argues that arbitrarily powerful nonlinear maps can make unsuitable networks appear perfectly aligned with a target algorithm (Sutter et al., 2025). The exact technical debate is ongoing, but the design lesson is immediate: preregister the state mapping, constrain its complexity and test it out of distribution.

The strongest functionalist reply to the oracle and stadium cases should be heard clearly. If a lookup system truly preserves every relevant counterfactual transition, maintains the required internal relations and remains causally coupled to its environment, then calling it “mere lookup” may only express prejudice about an unfamiliar implementation. Functionalism deliberately refuses to make elegance, size or biological origin constitutive when they do no causal work.

The strongest opposing reply is equally precise. A specification may preserve all relations it names while omitting a property that matters. Biological naturalism proposes that biological organisation has causal powers not captured by an abstract transition description. Embodied accounts may include metabolic regulation, action possibilities and developmental history inside the role. Phenomenal critics argue that even a complete causal role could leave open what, if anything, the state feels like.

The dispute cannot be resolved by making the functional test easier or harder. It must be separated into two questions. Did the candidate realise the stated role? Is that role sufficient for the mental property at issue? The first is an intervention problem. The second is a constitutive and, for consciousness, partly metaphysical problem. Keeping them apart prevents a failed functional test from masquerading as proof of substrate necessity, and prevents a successful test from masquerading as proof of experience.

stateDiagram-v2
  [*] --> Claim
  state "Three boxes withdraw from the heat" as Claim
  state "From actual-path to<br/>intervention-closed<br/>equivalence" as Test
  state "The intervention closes the<br/>loophole" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The functional specification lab

The practical problem is not to declare functionalism true or false. It is to turn a vague claim such as “these systems implement the same cognitive state” into a testable specification. The minimum useful artefact has six fields: the role, the candidate boundary, the state mapping, the intervention family, the invariance envelope and the permitted conclusion.

The executable lab below makes the first three rungs of the replacement ladder visible. Four synthetic controllers face the same scenarios. A symbolic controller and a differently encoded controller preserve the target state machine. A reactive controller uses only the current input. A trace player emits memorised actions by time step.

What the lab tests

The target role has three abstract states and two inputs. Each scenario produces an expected action sequence and state sequence. The candidate receives the same input, plus any forced initial state. The harness scores action agreement, mapped-state agreement and complete scenario agreement. The final role score weights these three quantities at 40, 35 and 25 per cent.

The two stateful controllers should score identically despite different encodings. That is the positive multiple-realisation case. The reactive controller often selects the right immediate action but cannot preserve the state trajectory. The trace player performs best on the original sequence and degrades when order or state changes. The lab rewards preserved organisation, not resemblance on the rehearsed path.

/**
 * Functional-role stress test.
 * Run in Node.js or paste into a browser console.
 * Synthetic data only.
 */

/** @typedef {'quiet'|'alert'|'guarded'} State */
/** @typedef {'safe'|'damage'} Input */
/** @typedef {'proceed'|'withdraw'|'inspect'} Action */

const scenarios = Object.freeze([
  { name: 'Observed trace', inputs: ['safe', 'damage', 'safe'], initial: 'quiet' },
  { name: 'Reordered inputs', inputs: ['damage', 'safe', 'safe'], initial: 'quiet' },
  { name: 'Repeated damage', inputs: ['damage', 'damage', 'safe'], initial: 'quiet' },
  { name: 'Forced alert', inputs: ['safe', 'safe'], initial: 'alert' },
  { name: 'Forced guarded', inputs: ['damage', 'safe'], initial: 'guarded' }
]);

/** @param {State} state @param {Input} input */
function transition(state, input) {
  if (state === 'quiet') {
    return input === 'damage'
      ? { state: 'alert', action: 'withdraw' }
      : { state: 'quiet', action: 'proceed' };
  }
  if (state === 'alert') {
    return input === 'damage'
      ? { state: 'alert', action: 'withdraw' }
      : { state: 'guarded', action: 'inspect' };
  }
  return input === 'damage'
    ? { state: 'alert', action: 'withdraw' }
    : { state: 'quiet', action: 'proceed' };
}

class SymbolicController {
  constructor() { this.state = 'quiet'; }
  /** @param {State} initial */
  reset(initial) { this.state = initial; }
  /** @param {Input} input */
  step(input) {
    const next = transition(this.state, input);
    this.state = next.state;
    return { action: next.action, abstractState: this.state };
  }
}

class EncodedController {
  constructor() { this.voltage = 0.1; }
  /** @param {State} state */
  encode(state) {
    return state === 'quiet' ? 0.1 : state === 'alert' ? 0.9 : 0.5;
  }
  /** @returns {State} */
  decode() {
    return this.voltage < 0.3
      ? 'quiet'
      : this.voltage > 0.7
        ? 'alert'
        : 'guarded';
  }
  /** @param {State} initial */
  reset(initial) { this.voltage = this.encode(initial); }
  /** @param {Input} input */
  step(input) {
    const next = transition(this.decode(), input);
    this.voltage = this.encode(next.state);
    return { action: next.action, abstractState: this.decode() };
  }
}

class ReactiveController {
  reset() {}
  /** @param {Input} input */
  step(input) {
    return {
      action: input === 'damage' ? 'withdraw' : 'proceed',
      abstractState: null
    };
  }
}

class TracePlayer {
  constructor() {
    this.index = 0;
    this.trace = ['proceed', 'withdraw', 'inspect'];
  }
  reset() { this.index = 0; }
  step() {
    const action = this.trace[this.index] ?? this.trace.at(-1);
    this.index += 1;
    return { action, abstractState: null };
  }
}

function expectedScenario(scenario) {
  let state = scenario.initial;
  const actions = [];
  const states = [];
  for (const input of scenario.inputs) {
    const next = transition(state, input);
    state = next.state;
    actions.push(next.action);
    states.push(state);
  }
  return { actions, states };
}

function evaluate(name, Candidate) {
  let actionMatches = 0;
  let stateMatches = 0;
  let totalSteps = 0;
  let exactScenarios = 0;

  for (const scenario of scenarios) {
    const expected = expectedScenario(scenario);
    const candidate = new Candidate();
    candidate.reset(scenario.initial);
    const actual = scenario.inputs.map(input => candidate.step(input));
    let exact = true;

    expected.actions.forEach((action, index) => {
      totalSteps += 1;
      if (actual[index].action === action) actionMatches += 1;
      else exact = false;
      if (actual[index].abstractState === expected.states[index]) stateMatches += 1;
      else exact = false;
    });
    if (exact) exactScenarios += 1;
  }

  const actionFidelity = actionMatches / totalSteps;
  const stateFidelity = stateMatches / totalSteps;
  const wholeScenarioClosure = exactScenarios / scenarios.length;
  const roleScore =
    0.40 * actionFidelity +
    0.35 * stateFidelity +
    0.25 * wholeScenarioClosure;

  return {
    name,
    actionFidelity,
    stateFidelity,
    wholeScenarioClosure,
    roleScore
  };
}

const results = [
  evaluate('Symbolic controller', SymbolicController),
  evaluate('Encoded controller', EncodedController),
  evaluate('Reactive controller', ReactiveController),
  evaluate('Trace player', TracePlayer)
];

const percent = value => `${Math.round(value * 100)}%`;
console.table(results.map(result => ({
  candidate: result.name,
  actions: percent(result.actionFidelity),
  states: percent(result.stateFidelity),
  closure: percent(result.wholeScenarioClosure),
  roleScore: percent(result.roleScore)
})));

// Invariants encoded by this toy assay.
console.assert(results[0].roleScore === 1, 'Symbolic controller should close the role.');
console.assert(results[1].roleScore === 1, 'Encoded controller should close the role.');
console.assert(Math.round(results[2].roleScore * 100) === 25, 'Reactive mimic should score 25%.');
console.assert(Math.round(results[3].roleScore * 100) === 15, 'Trace mimic should score 15%.');

// A passing score supports only this declared finite-state role.
// It does not establish consciousness, semantic content or personal identity.
results;

How to use it on a real system

Replace the toy states with a high-level causal model derived from the claim you need to evaluate. Define the candidate boundary before opening the model. Specify a simple state alignment and reserve contexts for confirmation. Then create interventions that distinguish the target mechanism from at least one rival generator. Useful interventions include state clamps, component swaps, delayed feedback, contradictory evidence, partial lesions and recovery after failure.

Start with a commitment packet. Name the high-level variables before inspecting candidate activations. Record why each variable belongs to the role, which transitions are mandatory and which variations are allowed. Specify the simplest admissible mapping family, such as a sparse linear decoder or a hand-designed state correspondence. This prevents the mapping from absorbing every mismatch after the fact.

Next build a matched rival. For the rover, a direct vision-to-steering model is more informative than random noise because it can pass ordinary route tests for the wrong reason. For a language model, a lexical shortcut may rival a compositional-state account. For a biological system, a correlated neighbouring circuit may rival the proposed mechanism. The intervention suite should be chosen for its power to separate these live generators.

Finally reserve a confirmation set. Use one group of contexts to discover the state map and another to test it. Include at least one perturbation that changes the candidate mechanism without changing the nominal input, and one that changes the input while holding the proposed state fixed. A role claim becomes credible when the same simple mapping predicts both directions.

A positive result permits a scoped sentence: “System B realises role R relative to mapping φ, intervention set J, contexts C, timescale τ and tolerance ε.” A negative result has several interpretations. The system may not realise the role. The chosen state map may be wrong. The role model may be too coarse. The intervention may have crossed the intended boundary. Report these alternatives rather than converting failure into absence of mentality.

The lab cannot establish that the role is the essence of a mental state. It cannot prove phenomenal consciousness, personal identity or semantic grounding. It also cannot guarantee that an untested context will preserve the relation. These are not defects in the instrument. They are the boundary that keeps a functional result from becoming metaphysical inflation.