Pancomputation I

Two computers?

Earlier this year I wrote a trilogy of posts exploring digital dualism — the notion that a (conventional) computer has a physical layer that implements a causally distinct abstract layer. In writing those posts I found my definition of computation shifting slightly to embrace the notion of that dualism.

The phrase “a (conventional) computer” needs unpacking. What is a computer, and what makes one conventional? Computer science offers a mathematical view. Philosophy, as it often does, spirals in on the topic and offers a variety of pancomputation views.

In this series I’ll explore some of those views.

One reference here is the webpage, “Computation in Physical Systems”, an article in the Stanford Encyclopedia of Philosophy (a great online resource; as useful as Wikipedia). Readers of this series should be aware of that article (although I won’t get to it until next time).

To begin: What is a computer? What makes one conventional?

Let’s define conventional as something one could buy at an electronics store. This immediately suggests: A conventional computer uses electricity.

Certainly anything officially called a “computer” in its sales brochure is likely to be conventional. Yet so are things that aren’t: cell phones, pads, music players, and those high-tech watches. Roses by other names. (Apple, in fact, has tried distancing itself from the term.)

More technically, anything with a von Neumann architecture is a conventional computer. Yet so are some alternate systems that still qualify as reasonably conventional. There isn’t a sharp boundary.

Ironically, an actual Turing Machine would be a bit unconventional.

Perhaps the best statement we can make is that a conventional computer is an electronic device with a CPU (and all that implies), memory, and I/O. Note that by this definition analog computers are not conventional.

§ §

Conventional is easy compared to computer. The focus of this discussion, and a great deal of philosophy, is that it’s a hard concept to pin down precisely.

An interesting consequence of my digital dualism series was that it shifted my definition of computation from a symbol-processing view aligned with the computer science view towards the physical-abstract layer view explored in those posts.

Previously I would have said computation is a symbol-processing abstraction capable of being implemented by a Turing Machine or a lambda calculus. The notion of process is important. Computation is a multi-step process.

While that definition does exclude most things I intend it to exclude, it also excludes analog computers (as not only not conventional, but not computers at all). I’ve never been entirely happy with that. It saw analog computation as a different class of computation — one not amenable to Turing Machines or lambda calculus. The dual layer view, however, does include analog computers while still excluding various physical processes I don’t see as computation.

So now I say a computation involves a physical process that implements a causally distinct abstract process. This is crucial: The causal laws of the abstract process have no connection to the causal laws of the physical process. The abstract process is a different model of reality than used by the physical process.

A key aspect of this is that different physical processes can implement exactly the same abstract process with no loss of fidelity. Radically different systems can deliver indistinguishable results. For instance, an abacus and an electronic calculator. Both can do the same sums.

§

In addition to a multi-step process with a physical representation layer of computing elements implementing an unrelated abstract layer, a third requirement is intention. Computers are, under this definition, intentional constructions based on a design. Some interesting science fiction aside, there are no accidental computers.

Note that the physical representation layer is only typically numeric — a finite number representation — with the computer performing arithmetic on the numbers. Analog computers physically represent magnitudes and operate on those, so computation need not be arithmetic (let alone electronic).  Conventionally it usually is, but not necessarily.

§ §

The computers mentioned above, from watches to mainframes, fit this definition easily. Most sit squarely in the middle of it. Obviously, they also easily fit the Computer Science definition. There’s no controversy these are computers. (And conventional ones, at that.)

What about the two “computers” pictured in the lede?

§

An abacus has a physical process — the stones move — and the configuration of the stones represents numbers. A human using the abacus has an abstract model in mind — say adding up their cash register bank.

An abacus can have different physical designs, yet all do the same thing. There are also physically different ways to accomplish what people use an abacus for (pen and paper, for instance).

So here there seems a dual layer. An abacus physically implements numbers and aids in computation. (The word “aids” is significant!) Using one involves multiple steps, and they are definitely designed intentional constructions. All very computer-like.

The thing about an abacus, though, is that it’s operated by a human who does most of the work. All the math algorithms are encoded in the human, and the abstract model is also completely in the human. The abacus is mainly a handy scratch pad — an improved form of pen and paper.

It might be more correct to say the human is the computer, and the abacus is part of that human’s peripheral hardware: a memory unit. (In olde tymes humans trained to do calculation were called computers. It’s the first use of the term. Many of them used some form of abacus.)

§

If an abacus doesn’t quite make the cut, how about a slide rule? The scales are mapped to logarithms (or other number scales) — physical representation of numbers — magnitudes, in fact. A slide rule is an analog device.

A human using a slide rule has an abstract model in mind, and calculations typically involve multiple steps. Even a single calculation requires multiple fine-grain steps. (Analogous, perhaps, to a computer loading a register to perform a single calculation.) Obviously slide rules are intentionally designed.

As with the abacus, a slide rule is largely a human peripheral. Most of the model, and the algorithm that processes it, is in the human. But there is a key difference: slide rules actually do calculation. In setting the scales appropriately, one gets a continuum of answers (one of which is the sought value).

So the slide rule takes up more of the work in the human-peripheral combination than does the abacus. Does it take up enough to be considered a computer on its own? Or is it more of a measuring device? (Is a measuring device a computer? See why it’s easy to spiral in?)

It’s dealer’s choice, really. I think a slide rule is a rudimentary single-expression computer just barely worthy of the name (and not a conventional computer). It’s somewhat akin to those carboard mileage “computers” gas stations used to give away. The slide rule makes the cut by a decimal point.

[See: Abacus and Slide Rule for more on both devices.]

§

What about a rock? (The discussion of computation often focuses on whether various natural objects can be seen as computers.) The basic notion is that a rock warms up during the day. If we map the temperature states to time, the rock is seen as “computing” the hours of the day.

As I’ll explore later, computation involves physical states and a set of well-defined transitions between them. Here the states are different temperatures of the rock.

Temperature states are representations of magnitudes, so there is a physical layer of sorts. I don’t think mapping t-states to hours means there is an abstract layer, though; it’s just an equivalence.

§

Before we get too deep into that, at this point it makes sense to define three important terms: computation, calculation, and evaluation.

Somewhat like materialism and physicalism, some conflate computation and calculation while other distinguish between them. I distinguish (I feel one point of having separate but similar words is nuance). That said, I agree the boundary is fuzzy; one fades into the other.

The crucial difference is between the first two and the last one. Evaluation (to me) implies a transition akin to water seeking a level. The expression 7+5 and the expression 48/4 both are just two ways of writing the value 12. There are an infinite number of other expressions that do the same. The key is that an expression has no free variables — it evaluates to some definite value.

Evaluation has some sense of least energy. An expression has more energy than the value it represents (imagine a long complex expression that evaluates to 2). Similar to a soap bubble evaluating surface tension to find the shape with the least energy (absent other influences: a sphere).

What complicates the distinction is that most expressions require a calculation to physically evaluate. That doesn’t change that 3/4 is an expression that evaluates to a value (0.75 in base ten). Both are just ways of notating a specific numeric quantity.

I distinguish calculation (of mathematical expressions) from computation (of abstract models). Computation is comprised of lots and lots of calculations. (Done very fast; the key value of computers.)

§ §

Now back to the rock.

The first thing that strikes me is that rocks make terrible clocks. They can’t tell time on heavily clouded days. They stop working if in a cave. And we probably need a really big one to give it good heat inertia (if it absorbs enough heat during the day, it’ll work at night, too).

The second thing that strikes me is that the rock is more of a sunlight-measuring device. (It’s really more of a temperature-measuring device, since even without sunlight it responds to air temp.) I don’t think of a thermometer or air pressure gauge as a computer. I don’t even think of an actual analog clock as a computer.

The third thing is, even granting the computational notion, the actual computer here is the solar system. The rock doesn’t work without the rotation of the Earth and the incoming sunlight.

One certainly can, and under pancomputation does, view the solar system as a computer. Each body computes its orbit. (I see it as evaluation. More on that down the road.)

Note that the rock itself is irrelevant; it could be replaced by anything that absorbs sunlight and warms up in consequence. It shows that, at best, the rock is a hardware peripheral for something that measures its temperature and calculates the time of day from it.

Rocks don’t seem designed or intended as clocks. That said, one aspect of the debate is the extent to which design and intent can follow, rather than precede, the implementation. Regardless, we can design and build a (badly performing) rock-clock. Intent still matters here; we map the t-states to hours of the day.

That (analog) clocks are measuring devices seems a key point. Even a burning candle measures the burn rate of the candle. Crucially, there is no separate abstract layer to such a measuring device. Candles, clocks, and warming rocks, are merely physical demonstrations of constant change.

So rocks (and clocks) don’t make the cut. Not in my book.

[As an aside: While a light-sensing system might make a better clock than a temperature-sensing one, the heat inertia of a rock allows for a 24-hour clock, as the rock cools down at night. On the other hand, the sensitivity to air temp affects its accuracy since air temp isn’t heavily correlated with time of day.]

§

The intentional design constraint doesn’t itself restrict post hoc views that map physical states of some natural system (such as a rock) to a computation. (Taken to extremes, it leads to pixies dancing in the walls.)

A notion of “out of the box” can sometimes help distinguish cases. What is the apparent function of a device, out of the box (that is, upon first inspection)? Thermometers, scales, tire gauges, slide rules, and abacuses, all have apparent discoverable function. The function of a rock is: …to be heavy? …to stub toes? …to sit on? …to line a firepit? …to eventually make sand? Lots of possibilities, and it’s not clear “keep time” is on that list. (Or if so, it’s just one among the myriad.)

Put it another way: Computation is obvious.

Another helpful notion is the complexity of interpreting a putative computation. Does mapping physical states to representative states, and interpreting of those representative states, involve more computation than the ‘computer’ is doing? That is certainly the case with rock-clocks (and dancing pixies). On the other hand, slide rules and abacuses are immediate.

In the case of the rock and the abacus, nearly everything considered computational is outside the device. The slide rule, on the other hand, does have some computational juice. So far, only the slide rule “computes.”

§ §

That’s enough for this time. Next time I’ll pick up with the rock-clock and the Stanford article.

Stay evaluated, my friends! Go forth and spread beauty and light.

About Wyrd Smythe

The canonical fool on the hill watching the sunset and the rotation of the planet and thinking what he imagines are large thoughts. View all posts by Wyrd Smythe

4 responses to “Pancomputation I

  • Wyrd Smythe

    Part one of…? It’s looking like another trilogy. 🙂

  • Wyrd Smythe

    I know, I know: TL;DR. That’s okay; these are kinda just my lab notes.

  • Wyrd Smythe

    I think this SEP article may also result in some blog posts. 😀

    Thing is, I was a Computer Science minor back in 1977, and I’ve been seriously into it ever since, because I find it so interesting. (And programming is fun and so very useful.) The philosophy of CS is, as most philosophies are, not always a perfect impedance match to reality. From the perspective of 44 years experience, some of the philosophy is lost in navel-gazing.

    A really good example is all the hair-splitting over the hardware-software distinction. What bothers the philosophers is how very fuzzy the line can be. It’s a little reflective of the data-code divide, that’s fundamental to computing. As is well-known, code can be data, and data can be code. Context is everything. Likewise hardware-software.

    But here’s a definitive context: If it breaks when I drop it, it’s hardware. If it can’t break no matter how hard I drop it, it’s software. If I smash a hard-drive, I destroy the hardware, but the software lives on (it might be on other disks, for instance).

    These dualities are a big part of what makes computing such a special feature of the universe. Hardware-software, code-data, design-implementation, concrete-virtual. Increasingly I’m of the opinion that without the dualism it isn’t computing.

And what do you think?

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: