I’ve always liked (philosopher and cognitive scientist) David Chalmers. Of those working on a Theory of Mind, I often find myself aligned with how he sees things. Even when I don’t, I still find his views rational and well-constructed. I also like how he conditions his views and acknowledges controversy without disdain. A guy I’d love to have a beer with!
Back during the May Mind Marathon, I followed someone’s link to a paper Chalmers wrote. I looked at it briefly, found it interesting, and shelved it for later. Recently it popped up again on my friend Mike’s blog, plus my name was mentioned in connection with it, so I took a closer look and thought about it…
Then I thought about it some more…
The end result of all that thought is that I think Chalmers makes a misstep. Or, at least, what seems to me an unwarranted assumption.
It’s going to take some explaining. First, you should read A Computational Foundation for the Study of Cognition, by David Chalmers. I’ll be going through it in detail.
FWIW, one reason I like Chalmers is that he’s “skeptical about whether phenomenal properties can be explained in wholly physical terms.” [Footnote 4]
Or, at least in terms of yet undiscovered principles, but, yes, perhaps somehow transcending physics or what physics can analyze. (He is, after all, the guy who named The Hard Problem.)
In the Abstract, Chalmers writes: “Justifying the role of computation requires analysis of implementation, the nexus between abstract computations and concrete physical systems.”
I agree, so one thing I plan to do here is use some specificity regarding an implementation of the system Chalmers outlines.
Chalmers uses the terms “casual topology” and “organizational invariance” for key ideas I want to explore. He also defines a CSA (Combinatorial-State Automata, in contrast with an FSA or Finite-State Automata), which is especially important as a formalization of what he means by casual topology.
These all factor into what I think is missed, so I’ll go over my understanding of them in detail.
[This got long; I removed my word limit. (But no footnotes!)]
The notion of a CSA is central, so I’ll start there.
The short form is: a system can be in a variety of states, and the behavior of that system can be specified in terms of transitions from state to state.
A CSA extends the idea such that inputs, outputs, and states, have multiple components. (Because typically, an FSA is viewed as dealing with single inputs, outputs, and states, although this isn’t a requirement.)
As Chalmers writes, “Finite CSAs, at least, are no more computationally powerful than FSAs; there is a natural correspondence that associates every finite CSA with an FSA with the same input/output behavior.” [section 2.1]
Indeed, and sometimes it’s a matter of interpretation.
For example, a simple FSA that validates the format of email addresses can be seen as taking (single) characters as inputs and having states labeled with (single) numbers.
But look closer and see those input characters as vectors of bits. Those state labels, likewise, are vectors of bits. So the simple FSA can be seen as a CSA.
The reason for combinatorial complexity in design, as Chalmers writes, is: “First, […] a CSA description can therefore capture the causal organization of a system to a much finer grain. Second, the structure in CSA states can be of great explanatory utility.”
Exactly. The email validator makes more sense processing those vectors of bits as whole inputs and states. A bit-level implementation would be more complex and harder to understand (but certainly possible).
I agree with everything in the paper through the explanation of the CSA and into section 2.2. I would like to return to the last four questions in that section (digestion, Putnam, semantics, computers). Not that I disagree (I don’t). It’s more that I have some comments.
In fact, it’s not until section 3.3 that I think there’s a problem. I’ll get to that, but first I want to consider organizational invariance and causal topology.
Chalmers introduces both terms in section 3.1. Of the latter he writes:
The causal topology represents the abstract causal organization of the system: that is, the pattern of interaction among parts of the system, abstracted away from the make-up of individual parts and from the way the causal connections are implemented.
And later, in section 3.3:
In fact, it turns out that the CSA formalism provides a perfect formalization of the notion of causal topology. A CSA description specifies a division of a system into parts, a space of states for each part, and a pattern of interaction between these states. This is precisely what is constitutive of causal topology.
[Emphasis mine in both quotes.]
So the causal topology of a system is an abstraction (a formalism) — it is crucial to fully appreciate what that means in the context of what Chalmers wrote to start: “…implementation, the nexus between abstract computations and concrete physical systems.”
I couldn’t agree more. It means we need to talk seriously about what actually happens in any putative implementation (including the brain itself).
Before we get to that, the other term, organizational invariance, is about system properties that remain constant so long causal topology is preserved.
I wonder if this notion isn’t a little loose. Chalmers writes that a tube of toothpaste isn’t invariant because replacing the toothpaste with peanut butter means it’s not a tube of toothpaste anymore.
Fine, but why doesn’t replacing a mind with computation (let alone brain parts with silicon) mean it’s not a mind anymore? Those seem more extreme changes to me.
In section 3.2, Chalmers writes: “The central claim of this section is that most mental properties are organizational invariants.”
This seems to need a post of its own to explore exactly how organizational invariance relates to mental properties. I don’t see it as affecting the main point, so I’ll accept it provisionally.
I think what is important is the latter part of section 3.2, the “dancing qualia” thought scenario.
[See Absent Qualia, Fading Qualia, Dancing Qualia, by David Chalmers, for more about organizational invariance and qualia scenarios.]
Here’s the thing: (To the extent such a substitution could be possible) I quite agree that (it seems likely) mental properties would be preserved.
I’ve always said a Positronic Brain ought to work and that I’d be more surprised if it didn’t work. The dancing qualia scenario is essentially replacing the brain with a Positronic Brain, so of course I think that should work.
In this case, I agree organization is invariant and causal topology is preserved. (The whole point is that this replacement preserves causal topology.)
Where things jump the shark is section 3.3 — the presumption that a numerical simulation is the same thing.
The presumption is that, if The Algorithm describing how states change is executed on an appropriate Engine with appropriate Data, this results in mental states of cognition.
The rationale is that causal topology is preserved by The Algorithm.
I think this is debatable (if not false).
(Note that Chalmers explicitly says his approach deals with cognition rather than phenomenology: “Alternatively, the version of the thesis most directly supported by the argument in the text is that computation provides a general framework for the mechanistic explanation of cognitive processes and behavior.” [Footnote 6])
In order to examine this, let’s put some specificity to the CSA Chalmers imagines will generate mental states.
Wikipedia puts the human brain at having 86 billion neurons. Let’s assume our numerical simulation gets by okay with just 50 billion.
The number of synapses varies from 100 to 1,000 trillion (the latter in the very young). That’s a fair range (an order of magnitude).
Wiki also says neurons have, on average, 7,000 synaptic connections. Let’s have our numerical model get by with just 5,000 synaptic connections per neuron (on average).
Then we have 5×1010 neurons times 5×103 connections giving us 2.5×1014 synapses. That’s 250 trillion synapses.
This matters with regard to the implementation of the Mind CSA.
Chalmers writes: “The fine-grained causal topology of a brain can be specified as a CSA.”
One question here is whether the state vectors should be neuron states or synapse states — I think there’s a strong argument to grain this at the synapse level. That means each CSA state vector has 250 trillion components. (Alternatively, at the neuron level, each state vector has 50 billion components.)
Multiply those numbers by however many bits it takes to represent a state (say, 64) to obtain the final size requirement.
Let’s also specify the computational system. It consists of four basic parts:
- The “register” holding the current system state, S.
- The model, M, that describes the (brain) system.
- The program, P, that encodes the system’s causality.
- The engine, E, that executes P (using M to modify S).
As an aside, note that S is large (either 50 giga or 250 tera). M is even larger. [See: The Human Connectome]
It’s likely that P is fairly large, too, considering what it has to do. E is essentially any modern CPU, so weighs in somewhere in the multi-terabyte range.
(P and E have a high degree of complexity; S and M are structurally very simple, they’re just lists of numbers.)
What all this does is calculate the next state of the system. Let’s take a close look at what that involves.
The engine, E, repeatedly fetches bit patterns from P, and interprets each pattern as an valid instruction it knows how to perform. Such instructions fall into one of five classes: fetch data, store data, modify data, test data, transfer control (i.e. jumps and calls).
In order to perform these tasks, most engines are self-contained computers in their own right. They operate according to an algorithm.
As a consequence of executing lots of instructions in sequence, the algorithm encoded in P is executed to create the next state, S (remember that S is very large, so lots of changes are required).
Some components of S can be taken as inputs and some as outputs. As such, the next state for S completely depends on the current state, and output is generated in consequence of the changing states of S.
Now I want to focus on S and its “register” — and also on P (which encodes the causal topology of the physical system being simulated).
There are many ways to implement a memory register. Modern computers usually use a capacitor-based circuit or a transistor-based flip-flop circuit, but the details don’t matter. For specificity, we’ll pick the capacitors.
This means the register for S has, low-end, 3.2 trillion capacitors (16 quadrillion, high-end), assuming 64-bits per component.
The key point is that each capacitor, each bit, stands alone.
They are connected to power and control lines, but none of them are connected to each other. None of them have any causal connection with each other.
What’s more, there is no causality behind what state they have or which state they have next. There is no connection between states or between bits — both are fully independent.
Compare this to the state of a neuron, where the next state very much depends on the current state and directly on the state of input neurons.
At a higher level, groups of 64 capacitors comprise a 64-bit number, which is interpreted as representing the state of a neuron or synapse.
I can’t stress enough the disconnect between the actual physical brain state and the 64-digit binary number (represented by 64 capacitors) that has been assigned to stand for that state.
Physical neurons have a physical state, not a number. Physicality, not information.
It seems clear the answer can’t lie in the states themselves. They have no causal topology on their own.
The causal topology we need must lie in program P (with reference to engine E).
The physical computer has a clear causal topology that enables it to be a computer. This involves currents, voltages, transistors, and other electronic components.
The physical causality of the computer compares to our physical causality. In both cases that physicality defines.
At a higher level, parts of the computer have different casual topology. As mentioned, the engine E is a stand-alone computer (somewhat comparable, perhaps, to sub-systems of the brain).
The entire working system (P, E, S, M) has a causal topology, and it is this level of causality claimed to create mental states. (Or, at least, predict behavior.)
I have two objections to this. The first involves all those underlying layers of causality — layers that are significantly different from the causality they implement.
In the brain, the lowest layers of the implementation directly reflect the casual topology. Flows through neurons reflect actual signals caused by inputs, which directly cause synapses to react.
My other objection is that, computationally, the causality being implemented is the abstraction, the description of the thing, rather than the thing.
Consider pulling a cord attached to a bell so the bell rings. On the other hand, consider writing a code on paper and handing that to someone who interprets that code as instructions to ring the bell.
Either way the bell rings, but the former process is physical, direct, and immediate, while the latter is informational, indirect, and delayed.
Either way the bell rings, but to the extent process matters, the processes are entirely different. Put another way, the causal chains involved are completely different.
It boils down to how much process matters. It boils down to whether the divide between physicality and information matters.
I see enough differences to be skeptical, others find them unimportant.
The creation of mental states can’t lie in the separate capacitors nor in the numbers they form. If anything, it has to lie in the instruction fetch-decode-execute cycles of the CPU operating over the bit patterns of program P.
But given the closed instruction set of the engine, given it’s just bits and logical operations, it’s hard to see how that can really invoke the necessary causal topology.
At best it remains highly abstract, and I’m not sure that counts.
This has gotten long, and there’s quite a bit more to talk about. I don’t see an obvious place to break this in two, but I have reached an obvious stopping point.
So until next time!
Stay topologically casual, my friends!