Downward entailment - Department of Computer Science

wellofflimpetΚινητά – Ασύρματες Τεχνολογίες

14 Δεκ 2013 (πριν από 3 χρόνια και 4 μέρες)

95 εμφανίσεις

1
/
52


E
ntailment
:

downward
and
upward


Contents

A.

Introduction

................................
................................
................................
................................
......

2

1.

The computational turn

................................
................................
................................
................

3

2.

S
oftware developers stand on firmer foundations than engineers

................................
..............

3

3.

What this paper is about

................................
................................
................................
...............

4

B.

Emergence

................................
................................
................................
................................
........

5

1.

Abstractions and implementations

................................
................................
...............................

5

2.

Emergence and software

................................
................................
................................
............

10

3.

Strong emergence

................................
................................
................................
.......................

12

4.

Emergence summary

................................
................................
................................
..................

14

C.

The s
pecial sciences

................................
................................
................................
........................

15

1.

The special sciences and conceptual models

................................
................................
..............

15

2.

More about why there is something besides physics

................................
................................
.

18

3.

Do the laws of physics entail all other laws?

................................
................................
..............

22

4.

Summary position on the special sciences

................................
................................
.................

28

D.

Reduction, upward entailment, and downward entailment

................................
..........................

28

1.

Reduction (and explanation?)

................................
................................
................................
.....

28

2.

Upward entailment

................................
................................
................................
.....................

30

3.

Downward entailment

................................
................................
................................
................

30

E.

Dow
nward causality and downward entailment

................................
................................
............

31

1.

Introduction to downward causation

................................
................................
.........................

31

2.

A better way to look at downward causation

................................
................................
.............

36

F.

What have we said?

................................
................................
................................
........................

44

Refere
nces (some of the following are not cited and should be removed)

................................
...........

44

Appendix 1: An introduction to higher level entities

................................
................................
..............

50

Appendix 2: The first two definitions of causality in Ellis (2012)

................................
............................

51




2
/
52


Abstract.
The
re is near universal agreement that the

fundamental laws of physics are sufficient to
explain
all observed phenomena

i.e.,
that
nature is causally closed.

Downward (or top
-
down) causation
does not fit within this paradigm. Yet
like a zombie idea, it

refuses to die.
After
reviewing basic issues
pertaining to
causality, emergence, and the autonomy of the laws of the special sciences, I argue that
the apparent
paradox

is overblown

and appears to
be
the result of
confusing

analysis and synthesis
.

I
explain why e
mergence and the special sciences are central to understanding how the world works

and
why

t
he

laws of the special sciences

are
autonomous.
A key idea is
that the special sciences characterize
domains that are autonomous in their functioning
but

limited by the requirement that they
be

implemented within a world governed by physics.
An examination of how a modern
-
day Laplacian
demon also demonstrates the nee
d for the special sciences.
A
simple and
clear
-
cut example

(
from

outside the
realm

of physics)

is that the Theory of Computability is autonomous of the rules governing
the Game of Life
. Yet

it is possible to implement a Turing machine
(as an emergent phenomenon)
on a
Game
-
of
-
Life grid. Furthermore, the possibility of that imple
m
entation entails the undecidability of the
halting problem for the Game of Life
, thereby illustrating downward entailment

but not downward
causation
.
Methodologi
cally t
his paper
shows how modes of thinking
from

computer science
can apply
to problems in philosophy
, thereby illustrating “the computational turn
.



A.

Introduction

Question:

w
hat do emergence,
downward causation, and
the relationship between
physics and
t
he
special sciences have in common?

Answer:
the multi
-
level

mystery.

Fodor (1997)
famously
put
the special science
s

version of th
e multi
-
level

mystery

like this
.


The very
existence

of the special sciences testifies to reliable macro
-
level regularities t
hat are realized by
mechanisms whose physical substance is quite typically heterogeneous. Does anybody really doubt that
mountains are made of all sorts of stuff? Does anybody really think that, since they are, generalizations about
mountains
-
as
-
such won't

continue to serve geology in good stead? Damn near everything we know about the
world suggests that unimaginably complicated to
-
ings and fro
-
ings of bits and pieces at the extreme
micro
-
level manage somehow to converge on stable
macro
-
level properties.

On the other hand, the 'somehow' really is entirely mysterious. [
Why should there be (h
ow could there be
)
]
macro
-
level regularities at all in a world where, by common consent, macro
-
level stabilities have to supervene
on a buzzing, blooming confusion of mi
cro
-
level interactions
?



So, then,
why is there anything except physics
? … Well, I admit that I don't know why. I don't even know how
to
think about
why.
I expect to figure out why there is

anything except physics

the day before I figure out why
there is

anything at all.




The world, it seems, runs in parallel, at many levels of description. You may find that perplexing; you certainly
aren’t obliged to like it. But I do think we had all better learn to live with it.

3
/
52


I am not a professional philosopher
.
My PhD is in Computer Science, and I teach in a Department of
Computer Science.
1

I don’t find a world that runs on many level perplexing, and I don’t not like it. In fact,
I like it a lot.
In this paper I

ll explain why

and why that might be of interest to

philosophers.

1.

The computational turn

The International Association for Computing and Philosophy
(IACAP)
defines it
s

mission as promoting
“scholarly dialogue on all aspects of the computational/informational turn and the use of computers in
the service of

philosophy.”
2

What is the “computational turn?” My sense is that it has to do with how we
computer scientists tend to think.

Well, how do we think?
Overwhelmingly the task of software development is to
create

new abstractions
and then implement those abstractions as software
by putting
together
already implemented software

abstractions.
An example familiar to nearly everyone is a word processing program

such as Microsoft
Word
.
3


Word processors

offer users the ability to
create

and manipulate
documents
. They offer this
capability my making available

the use and manipulation of

abstractions such as words, paragraphs,
footnotes, sections, etc.

A

software developer
has two important tasks. One
is to understand
and

to

clarify
what
the important
abstractions
are in

a domain

i.e., how the potential users of her software
-
to
-
be think
s
. The second task
is to write software that implements those abstractions and
gives
those
potential users access to
operations on them. These implementatio
ns are created by putting together existing abstractions such
as those defined by programming languages and software libraries.

2.

Software developers
stand on firmer foundations than engineers

Much of what I said
about creating and implementing abstractions

applies to engineers as well as
to
software developers.
Engineers
,

too
,

create
products

that embody
new abstractions

and functionalities
.
And they do it

by putting together
components

that
provide

existing
abstractions.


Smart


phones offer
many examples.
A

nice
one

is the

smart phone’s

ability to re
-
orient
its

display (portrait or landscape)
depending on how the phone is held.
How do engineers get phones to do that? They
use

a

pre
-
existing
device
, the small
-
scale accelerometer,

which had been developed
for
and has a wide range of uses in
industr
ial and commercial products
. One of its more familiar uses is

in game controllers

such as the

Nintendo Wii.

An accelerometer in a game controller can tell the software in the controller
a
bout

the
user
’s motion
. When the user swings
her arm

as if
holding

a tennis racket, the controller can display a
picture of someone swinging a racket in a way that parallels the user

s movements. In a smart phone,
the accelerometer is used much more simply

to let the software in the phone know how the phone
was moved and how it is oriented.

The point is that

a device whose functionality had been used for one
purpose is now used for another.





1

I have had a long
-
standing interest in questions on the boundary of Computer Science and Philosophy and have
presented and published

papers in this area, for example (Abbott, 2008, 2009, 2010a, and 2010b).

2

From the mission page of the IACAP website:
http://www.iacap.org/about/the
-
mission
-
of
-
the
-
iacap/
.

3

One might make the same amazed observation about Microsoft Word as Fodor did about m
ountains.
Unimaginably complicated to
-
ings and fro
-
ings of bits

although perhaps not pieces

in a computer manage
somehow to converge on Microsoft Word.

4
/
52


Software developers have an

important advantage over engineers
.
4

W
e
need
not be concerned about
the
reliability

of

our

primitives. The lowest level software element is the bit. It is an atomic ideal. It
cannot be decomposed into smaller elements
, and

it cannot wear out
.
As far as software developers are
concerned, bits a
re forever
; y
ou can’t break a bit.
Engineers have no such solid foundation. When
building something they must always be concerned about whether the
components are appropriate for
the
application of
the device.
This is not a trivial issue; there is no
a priori
limit to the depth of analysis
required to

provide th
e

assurance

that the components will work when the device is put to use
. For
example,
there are many different types of accelerometers. Some are quite rugged; others fail when not
in a laborator
y environment. In addition, there is trade
-
off between accelerometer size and sensitivity.
Larger accelerometers are better at sensing smaller movements, but heavier mobile phones don’t sell as
well.
For example, see (
Lally,
2005). Issues of

th
ese sorts
re
quire

engineers always
to
be looking down

toward the

physical

foundations
of the devices they use
as well as up toward the new abstractions

they
are building
.
Only s
oftware developers
and God
5

can be secure in
the certainty of
their
knowledge

of the
fundam
ental elements of their universes
.

(See
(
Abbott
,

2010a)

for additional discussion.)


3.

What this paper is about

Because
our job is the creation and implementation of abstractions
, we

software developers

are
typically skilled in understanding both (a)

what it

means to define new level
s

of abstraction and (b)

what
it takes (and whether it is even possible) to
implement

those new abstractions in terms of existing
abstractions.
Because we do this work in a world with an indestructible primitive, we are free of
worries
about the strength of our foundations

and can focus exclusively on abstractions

and relationships
among them
.

One of my goals in this paper is to apply
our approach to

creating

and embodying abstractions to
philosophical issues.
I
n particular, I’l
l explore abstraction and implementation in emergence,
in
the
special sciences
,

and
in
downward causation.
6

I’ll
also
have a number of other things to say about these
areas. In particular, I’ll be dismissive of strong emergence

and eventually of emergence
in general. I’ll
propose a way of settling the
debate about

whether the laws of physics entail the laws of the special
sciences, and I’ll suggest downward entailment as
a better
conceptual framework

than downward
causation

for understanding
some of the app
arent consequences of
the multi
-
level mystery.

A disclaimer
: a
lthough the multi
-
level mystery is often associated with

the theory of mind, this paper is
not about mind or consciousness. I don’t believe we know enough about consciousness to be able to say
anything useful

about it

other than that it’s a puzzle we have hardly begun to
unravel
.





4

Confusingly software developers are often referred to as software engineers.

5

Analogy suggested by D
ebora Shuger, private correspondence. She cited Barkan (2013, p 13) for a discussion of
Plato’s transmutation of the “public craftsman,” i.e., engineer, into an equivalent for God.

6

The terms
downward causation

and
top
-
down causation

are often used synony
mously in the literature. My
preference is for
downward causation

because it does not imply that one is starting from a top
-
most point

as
top
-
down
<anything>

would
.

However, one of the primary references for this paper uses

top
-
down causation

rather than
downward causation
. I will use the two terms interchangeably and intend no difference between
them.



5
/
52


B.

Abstractions and implementations in computer science

As background for the rest of this paper, I
want to spend a brief time reviewing

abstraction and
implementation in

computer science.

1.

Computer programs: what people in my field work with

For those of us who spend our professional lives in the field of computing, the primary object of study is
the computer program. I had a hard time writing that sentence because the te
rm
computer program

sounds like it describes such a pedestrian object, hardly a work of intellectual depth and sophistication. I
could have written
software
, but that’s no better. Yet it is computer programs that we deal with, both as
developers and theori
sts.

Theoretical computer scientists

those who study computability

may talk about Turing machines, but
since any Turing machine can be understood as a program to be executed by a universal Turing machine,
a Turing machine is really just a computer program
. The same can be said about those who study the λ
-
calculus and related formalisms. These too are really programming languages

which allow one to write
computer programs, which can be run on λ
-
calculus abstract machines. So we are stuck with the fact
that
computer scientists study computer programs.

2.

Computer programs have both a static and dynamic aspect

Computer programs must be understood from two perspectives: as a static expression of a computation
and as the dynamic process that
i
s the described compu
tation. Issues related to programs as static
objects derive from their status as expressions in a language.
T
he semantics of a programming language
determines what one can say about the process a program describes. The primary issues involve
(a)

control st
ructures (what one can say about how the process proceeds)
,

(b)

data types and
data
structures (what one can say about the elements the process operates on)
, and (c)

modularity

(
the ways
in which the language allows programs to be decomposed into what will

be interacting dynamic
components.
7
)


Issues related to programs as dynamic processes span the range from theory to practicality. There are
theoretical questions such as whether the program
-
as
-
process will ever terminate. There are questions
that are both

theoretical and practical such as how long (as a function of the size of the input) the
program
-
as
-
process

will take to terminate

assuming we know that it will. There are abstract questions
such as how
to

describe the dynamic structure of the program
-
as
-
p
rocess as it runs. And there are more
practical questions such as what will it be like for the program
-
as
-
process to interact with the rest of the
world, including both
the
people
it may encounter
and devices

the

it may monitor and control.

Computer scienc
e is not the only discipline whose products have significant static and dynamic aspects.
Others include music, theater, film, and many (perhaps most) engineering specializations. For them as
for us what is generally produced is a static product (a)

whose s
tatic properties are important but
(b)

whose primary value is as a dynamic process.
Even though p
eople in these fields spend
most of
their



7

A software component is typically a description of a (parameterized) template for a more
-
or
-
less self
-
contained
process which can be instantiated and in
cluded dynamically during a program’s overall course of action.

6
/
52


time producing static objects

a computer program, a script, an automobile, a computer, etc.

the
primary value in thos
e static objects inheres in their performance as a process.

This is an especially important point to keep in mind
about computer programs
. Since the static
products we produce

are symbolic
,
it’s easy to ignore their
dynamic

aspects and to imagine that thei
r
static properties are their most important features. To do so would

be a mistake. As symbolic objects,
computer programs may look like mathematical objects; it is even possible to analyze computer
programs as mathematical objects; but what’s most importa
nt about computer programs is that they
describe processes. These processes occur in time and do something in the world

namely, they
perform computations.

My impression is that philosophy tends to be interested in expressions in formal (and even informal)
languages
primarily
as predicates,

i.e.,

statements with a truth value.
A computer programs is not a
predicate (or a collection of predicates). A computer
program is a recipe for
a

perform
ance
, i.e. for a
computational process.
8

It’s important not to think about it as one would about a predicate.


3.

A computer program organizes the computational capabilities of a machine so that a
desired computation will resu
lt

What does it mean for a computer program

hereafter program

to be a recipe for how something is
to be computed? The job of a program is to build a bridge between two things: the machine for which
the program is written and a desired computation. Whether
one is programming a Turing machine, a λ
-
calculus abstract machine,
9

or something else, the raw material with which one starts is the
computational capabilities of a machine. So, what is a machine?

The standard definitions of
machine

typically refer to dev
ices that apply power mechanically in the
service of a task. Of course, that’s not what
machine

means

in computer science. Informally, a machine
is an abstract, virtual, or concrete object
10

that is capable of being in any of a number of states and for
whic
h there are rules that determine how it transitions from state to state. Of course this can be
expressed formally

and it has been

but what I’m trying to get at is the intuition behind the formalism.



8

That’s true even
for

so
-
called declarative languages.
P
rogramming languages are often placed on a
declarative/imperative

scale.
λ
-
calculus is declarative since it allows one to define functi
ons as compositions of
other functions.
Since any sound evaluation strategy will yield the same result step
-
by
-
step instructions for
evaluating those expressions are not provided. The same is true about logic programming languages such as
Prolog.
Turing ma
chines are imperative
. T
hey are programmed by describing how they are to change from state to
state as
a

computation progresses. In either case
, though,

a computation occurs when the program is run, and it’s
what
the

comput
ation produces

that matters.


9

The first and most influential λ
-
calculus abstract machine was the SECD machine. See (Landin, 1964) and (Danvy,
2003).

10

We frequently talk about abstract machines, virtual machines, and physical machines. An abstract machine is
one defined through a forma
lism. A physical machine is one that exists physically. A virtual machine is a software
implementation of an abstract machine.

7
/
52


For our purposes what is most important is that a machine

transitions from one state to another.
11

The
sequence of states through which a machine transitions defines a process.

What are the computational capabilities of a machine.
The transition rules
that determine how a
machine may move from one state to anoth
er
are the machine’s computational capabilities. At each
step, by applying a rule the machine performs
a small

computation. The job of a program
12

is to direct
and control that process by directing and controlling the application of the machine’s rules.

So
our fundamental notions are (a)

a machine that is capable of performing computational operations as
it transitions from state to state and (b)

a program that directs and controls those transitions

and
thereby

defines a computation.

4.

Implementing a computat
ion defined in one formalism in terms of another

So far we have
mentioned

two kinds of
abstract
machines: Turing machines and λ
-
calculus machines.

The computational capability of a Turing machine is its ability to transition from state to state and in the
process to read and write symbols on an unbounded tape. One programs a (universal) Turing machine
by creating a tape with some initial contents and then setting the machine loose on it. The state
transitions made by a Turing machine

read the symbol on the
tape cell under its read head,
change the
state of its finite automaton, write
a symbol
on
that

tape

cell
, and move its read/write head

are all
very low level. Each does very little computing. The order in which these operations are performed is
rigidly de
termined.

The computational capability of a λ
-
calculus abstract machine is its ability to reduce, i.e., evaluate,
arbitrary λ
-
expressions. One programs a λ
-
calculus abstract machine by writing a collection of λ
-
expressions and setting the machine loose on

them. The state transitions made by a λ
-
calculus abstract
machine

substitute a value for a variable, replace an expression with a value

are higher level. Each is
a significant step in the process of expression evaluation. The order in which these operatio
ns are
performed is more flexible. They may be done as needed (called
lazy
) o
r

as encountered (called
strict
).

A λ
-
calculus abstract machine is in some sense smarter and more flexible than a Turing machine. It
allows its programmers to write programs on a
higher level (λ
-
expressions) than that required by Turing
machines (tables of state transitions). Even so, we know that the λ
-
calculus and Turing machine
s

are
computationally equivalent. For every program one can write using either formalism, it is possibl
e to
write a program in the other formalism that performs an equivalent computation.




11

There is some ambiguity in the notion of state. For a Turing machine, for example, the term
state

is used to refer
either to the state of the finite automaton that the machine’s transition rules direct or to that state along with the
contents of the machine’s tape and the position of the read head on the tape. Normally it is clear which sense of
state

is intended.

12

There is a second ambiguity, which can also be illustrated by considering Turing machines. By a Turing machine
program one may be referring

either

to the machine’s transiti
on table

or to the initial content of the machine’s
tape. A program
in either sense can be understood as directing and controlling how the machine transitions from
one state to another. This is especially clear in the case of a universal Turing machine, where the initial content of
the tape specifies the state transitions
of the Turing machine that the universal machine is running.

8
/
52


It’s worth looking at that a bit more closely. Suppose I write a program using the λ
-
calculus. What we
just said is that we can write a Turing machine program that perfor
ms an equivalent computation. In
writing such a Turing machine program we are tying together two abstractions: the computation defined
by the λ
-
calculus

program and the computational abstractions defined by the Turing machine. Another
way of putting this i
s that we are implementing a λ
-
calculus
-
specified computation on a Turing
machine.
13


This, in short, is the sort of thing software developers spend their time doing. A software developer is
given a description of a desired computation

much as we were give
n a description of a desired
computation as a program in the λ
-
calculus. It’s the programmer’s job to write a program in some
programming language that performs that computation

much as we said we could write a Turing
machine program to perform an equivale
nt computation. Of course software developers write their
programs in more sophisticated programming languages
14

than Turing machines. But the idea is the
same.

This has been perhaps a long way of saying that the job of a software developer is to write a
program
that puts together the computational capabilities of a machine in such a way that it will perform a
specified
computation. Both ends of this bridge are given as abstractions. The desired computation is
given as an abstract description
, e.g., a prog
ram in the λ
-
calculus
. The available computational
capabilities are described in terms of operational abstractions that the machine can perform
, e.g., those
of a Turing machine
. So one can say that the job of a software developer is to implement one
abstra
ction in terms other
s
.

More generally
,

software developers build bridges between what are often referred to as layers of
abstraction. The lower layer is generally not solely the computational capabilities of a machine. It usually
includes additional compu
tational capabilities
organized

as a library. The higher level, the computation
being implemented, is generally not what one thinks of as a bare computation. As discussed earlier, the
computation being implemented may be something like a word processor, wh
ich is described in terms a
significant number of abstractions.

A program describes a process in time. As the machine it controls transitions from state to state, one
can think of it as an animation

much like an animated film, which transition from the st
ate represented
in one film cell to the state represented in another.
An implementation is therefore a way to animate a
collection of abstractions. Jeanette Wing
15

(2008) describes it this way.

The essence of computational thinking is abstraction. … The abs
traction process introduces layers. In
computing, we work simultaneously with at least two, usually more, layers of abstraction: the layer of interest



13

Saying that λ
-
calculus and Turing machines are equivalent means that there are automatic means for generating
an implementation of a program in one formalizing in terms of the other.

14

A progra
mming language defines a machine whose computational capabilities depend on the semantics of the
language. There are a number of formal ways to define the semantics of a programming language. The two most
widely used are denotational semantics and operatio
nal semantics. (Simpson, 2012) has an introduction.

15

Jeanette Wing is the
President's Professor of

Computer Science at Carnegie Mellon University. Wing

(
2006)
argued that what she called
computational thinking

had much to offer those outside computing and should be
taught to everyone.

9
/
52


and the layer below; or the layer of interest and the layer above. … Computing is … all about making
abst
ractions come alive!


Does
comes alive

seem too breathless? Of course Wing is not talking about biological life. What she is
talking about is the fact that programs such as Microsoft Word respond to user actions depending on
both the specific action the us
er takes and the abstraction on which that actio0n is performed.
Clicking
inside the text positions the cursor. Clicking a style button changes the style of the paragraph where the
cursor is positioned. Dragging selected text cuts the text from one place i
n the documents and pastes it
somewhere else. Dragging
a tab or margin indicator on the ruler, changes a tab or margin.
A computer
program makes abstractions come alive in the sense that the

programs
respond
s

to user actions in
ways
that are
semantically m
eaningful

for that abstraction
.

The point here is that those of us in computers science spend most of our professional lives thinking
about implementations of abstractions. As a consequence we find the notion quite familiar.

A word about
implementation

vs.
realization
. In the philosophical literature the term
realizes

is used in
much the same way as
implements

is used in software. In both cases one is talking about a concrete
embodiment of something that has a functional description.

A difference, thoug
h, is that

i
mplement

implicitly incorporates a sense of intentionality whereas
realize

doesn’t. A software developer
deliberately implements some ideas as software. Nature realizes some (apparent) functionality with no
intentionality involved.
That doesn’t

make a naturally occurring realization of an abstraction less faithful
to the abstraction than a programmer
-
produced implementation.
Although nature is not intentional, a
naturalized version of
function

is useful for understanding how evolution produces t
he complex
(apparent) functionality it does. Either way, whether an implementation/realization is explicitly
intentional or not the result is a concrete embodiment of a domain that can usefully be characterized
abstractly.

C.

Emergence

Emergence has been on

the philosophical stage for over a century and a half. McLaughlin (1992) traces
it

back to work by Mill in the mid
-
19
th

century. I
n
c
omputer
s
cience
emergence

i
s

one of
a

web of ideas
associated with complex systems.
16

O’Connor

and Wong (2012)

characterize

it this way.

[E]mergent entities (properties or substances) ‘arise’ out of more fundamental entities and yet are ‘novel’ or
‘irreducible’ with respect to them.


Each of the quoted terms is slippery in its own right, and their
specifications yield the var
ied notions of emergence.


E
mergence appears to be something of a free lunch. Put a bunch of familiar things together and
something new (and surprising and interesting and
perhaps even
useful) may pop out.

In the late 20
th

century
e
mergence

seemed to represent all that was good about complex systems
. T
he term became
very popular.
H
owever, by the
turn

of the century

the term
complex systems

itself had become so
overused
and

the language associated with it
had become

so
faddish
that
many
terms

in the field

had
lost much of
their

meaning.

E
mergence

had become more of a buzzword than a tool for clear
communication
, and

I stoppe
d using it

although I’ll relent for this paper.




16

Other ideas related to complex systems include agent
-
based modeling, evolutionary processes, and various
network topologies and effects.

10
/
52


In the philosophical literature
, however,

emergence

has
had another fate.

It has

been mercilessly
sliced
and
diced to the point that I hardly recognize some of
its

uses. The primary divisions are weak and
strong emergence. But there is also nominal emergence, pattern emergence, synchronic and diachronic
emergence, static and dy
namic emergence, epistemological and ontological emergence, various
combinations of these, and
probably
others
of

which I am
not
aware. I would like to step back from all
that and take another look.

I have always thought that what was most important abo
ut emergence was the idea that a new and
conceptually autonomous domain can be created from elements that have nothing to do with that
domain. To take
one of the standard

unity
-
of
-
science example
s
, biology

emerges


from chemistry,
yet

the study of biological phenomena is in many ways autonomous of chemistry.
In particular, t
he most
fundamental idea in biology

evolution through diversity and selection

has no counterpart in
chemistry

and cannot be expressed using concepts from chemistry
.
17


It also bec
a
me clear to me that what software developers do for a living

is

to produce emergence. As a
result, emergence
should no longer seem mysterious. As I’ll explain in the next
section

I believe it can be
understood

without
the

detailed
philosophical
analysis

it has received
.


1.

Emergence

without the mystery

In software the term
conceptual model

refer
s

to the collection of ideas that define how
a

software
application operates. Consider the example of a word processor mentioned earlier. Its
conceptual model
is essentially what its
Help

system says about it. The
Help

system describes the program in terms of the
abstractions that are relevant to how the user thinks about what the program can do.
18

These
abstractions

e.g., words, documents, tabs,

rulers, ribbons, styles, formats, tables of contents,
footnotes, possible errors (indicated, perhaps, by red underscores), etc.

refer to types (e.g. paragraph),
relations (e.g., orphan
-
line rules for how paragraphs should be formatted on pages), and opera
tions
(e.g., how one can change the default settings for those rules
, or drag a selected piece of text from one
place to another,

or correct a spelling error).

Standard (and best) practice in software development is to define a conceptual model independen
tly of
how it has been or will be implemented. Imagine writ
ing a
Help

system before starting to write the
program that it describes and then writing the program to be consistent with what

the
Help

system says.
In other words, a conceptual model is autonomo
us of and often precedes its implementation.

The autonomy of some collection of entities, properties, etc. from the elements from which they “arise”
is, of course, one of the distinguishing features of so
-
called emergent phenomena. In the case of
software
, the elements from which software “arises” are the things one can write in a programming
language. The conceptual model “arises” as an autonomous phenomenon when the programmer puts
those elements together in the right way.




17

Of course we now know

although Darwin
didn’t

that evolution depends on DNA, which is understood
chemically, but that’s a matter of implementation, not conceptualization.

18

Or at least how the software developer thinks the user thinks.

11
/
52


Admittedly the creation of som
ething new from something old is in some ways magical. How is it
possible to build a word processor by putting together lines of code in a programming language in which
no word processor

concepts

are defined? Yet we do this sort of thing all the time. In f
act every creative
act

the composition of music, the authoring of a work of fiction, the construction of an architecturally
original building, the evolution of a species with a new way to survive in the world, etc.

reflects that
same miracle. Human beings
and nature both do it.
It is this sort of constructive creativity that I think is
important about emergence. C
reati
vity may be mysterious; i
mplement
ation is
not.
A longer discussion is
available in Abbott (2010b).

Although we often speak as if emergence is

about higher
-
level elements emerging from lower
-
level
elements, that’s not always the case. N
ot all emergent phenomena are implemented in terms of lower
level elements. The (emergent) lifecycles of parasites

and there are probably as many species of
paras
ites as non
-
parasites

are built
from

elements that are macro to their micro.
Cordyceps

is
a
particularly interesting example.
Cordyceps

is
a species of fungus that infects a species of ants. Infected
a
nt
s (are somehow induced by the fungal infection to) cl
imb up and

“clamp onto a leaf vein about 25
centimeters off the ground

a
spot where the humidity and other conditions may be ideal for a fungus
to grow.”

(Zimmer 2011) Once the ant clamps onto a leaf, the fungus attacks the muscles that would
allow the ant

to release its grip

dooming it to stay clamped onto the leaf. The fungus then produces a
stalk, which releases fungal spores, which drift to the ground below and infect other ants.


Cordyceps
, like every parasite, exploits its host

resources for its own n
eeds.
But
Cordyceps

exploits

it’s
hosts functionality

e.g., the ability to climb a plant
stem
and clamp onto a leaf

and

unlike most
parasites,
it doesn’t use its host
as a

primary source of

nourishment
.

Cordyceps
’ lifecycle is emergent; it
didn’t exist bef
ore
Cordyceps

invented it
.

(Of course that’s true for virtually any species. But the
Cordyceps

lifecycle
is unusually distinctive.)
I
t is fairly easy to explain
Cordyceps
’ life cycle. T
he
explanation is in terms of both higher and lower level elements. The higher level elements are plants
and ants and their properties and behaviors. The lower level elements include the biochemical reactions
that result in the observed ant behavior.
So
Co
rdyceps

implements its strange life
-
cycle by putting
together the capabilities of both higher
-
level and lower
-
level elements.


I want to emphasize that
Cordyceps

relies on their

macro
properties

of both ants and plants
.
Cordyceps

doesn’t use ants simply a
s biochemical fuel as many decomposer

s
pecies

do.
Cordyceps

relies on ants
ability, as ants, to climb plants

(as plants). For this step in its life cycle all it really needs an a means to
position itself about 25 centimeters above the ground. It uses the m
acro properties of ants and plants to
do this. It also needs a stable platform while it grows its stalk. Again it uses the macro properties of ants
(their mandibles and disabled muscles) and plants (their leaves) to achieve this.
Although
Cordyceps

is
quit
e micro compared to ants

and plants
, it built its (emergent

micro
-
level
) lifecycle upon the macro
-
level properties of those macro
-
level entities.

Although it is not always the case that an emergent macro is built on a base of the relative micro, what
is al
ways the case is that if the emergent phenomenon is biological or social, it requires a source of
energy to persist. That source of energy must come from its “base,” i.e., the elements from which it is
built.
Cordyceps

relies on energy supplied by ants to
run its life cycle. So emergence is not always micro
12
/
52


to macro, it is always from energy source to energy expense. (See Appendix 1 for a discussion of entities
and energy.)

Engineers engage in similar pursuits.
As we said before
smart phones

are

built by en
gineers
. Many of
their components are pre
-
existing, but t
he

phone’s

properties and functionalities are new. The phone
itself is as emergent as anything one can point to. But of course their functionalities can all be explained
in terms of the properties an
d functionalities of their components.
Like
Cordyceps
,
the “base


from
which
mobile phones


arise”
include
elements that cannot be said to be micro to their macro. The
telephone system itself is of course massive as is the GPS satellite system
that
many of them use for
navigation.
These are both pre
-
existing elements of the
mobile phone
“base
.

As in the case of
Cordyceps

,
emergence
is not always a matter of micro to macro

and may not be

at all
as simple as
it

may
seem
at first.

Many businesses also

illustrate emergence
. A nice class of examples are what is now known as multi
-
sided platforms, businesses that serve two or more
distinct
classes of customers. The business model of
these businesses is not to buy components
,

assemble them into some larger

value
-
added entity,
and
then

sell

the finished product

for more than the cost of the components and the assembly. Nor is it to
buy in bulk and sell at retail. These companies provide a service that facilitates an interaction between
two other groups
, whi
ch serve as the “base” from which their “emergent” business models arises.
Among the first cited examples (Rochet and Tirole, 2003) was the credit card service. It serves buyers (by
making it

possible

make purchases

without carrying money o
r

establishing c
redit
-
worthiness
) and sellers
(by making it easier

to make sales to unknown customers and then

to collect payment). The
functionality of the credit card service is new. Before it was created

by American Express

nothing
with that functionality existed.


The

credit card business is an emergent phenomenon built on top of an existing world of buyers and
sellers. How is the credit card functionality implemented?

It is

implemented by the credit card company
itself. It
implements its service

by using systems that
existed before the credit card was created: mainly
human workers and computers, both of which are “programmed” so that
the
credit card functions
“emerge.”

Emergence is all about us. The creativity that produces it may amaze us. The implementation of the
p
henomena that exhibit it should not mystify us.

2.

Strong emergence

In this section
I’d like to comment on what has been called strong emergence
.
In particular, I’d like to
respond to the implicit disparagement of science that typically accompanies discussion
s of strong
emergence.


Phenomena are said to be strongly emergent when they have

irreducible causal powers. These macro
-
causal powers have effects at both macro and micro levels, and
macro
-
to
-
micro effects are termed “downward” causation.

(Bedau 2010)

O’Connor (2012)
does not use the term
strong emergence

but
defines what he calls
productive causal
emergence
.

13
/
52


Emergence: Productive causal
:

Systemic properties that exer
t a nonredundant, productive causal influence
on
the behaviour of the system’s more fun
damental parts.

The common idea is that strong emergence implies the appearance of a new causal force that (a)

is
capable of acting on lower
-
level elements and (b)

cannot be explained in terms of anything known about
those
lower
-
level elements.
The litera
ture

e.g., (Bedau 2010), (Chalmers 2006), (Kim 2005), (O’Connor
2013)

is fairly unanimous that strong emergence,

were anything to exhibit it, would imply not only that
physics is not causally closed but that its position as the ultimate authority for how t
he
natural
world
works is under challenge. In other words, strong emergence, were it shown to exist,
would be

a

spooky
phenomenon
that

may lead to the overthrow of science.

Chalmers (2006) puts it like this.

Strong emergence, if it exists, can be used to
reject the physicalist picture of the world as fundamentally
incomplete.

I disagree.
I don’t

see

a
possible

violation of causal closure as a threat to science.
I’
d like to consider two
phenomena

that
are good candidates for being labeled strong emergence
.
Both have

strengthen
ed
science

rather than weaken
ed it
.

Dark energy

D
ark energy is reducible neither to the forces of the standard model of physics nor to gravity

i.e., it is a
new force. It is not redundant. It is causally productive: it causes the univer
se to expand in a direct
physical way. In addition, dark energy satisfies Chalmers’ condition for strong emergence that “
truths
concerning
[strongly emergent phenomena]
are not
deducible

even in principle from truths in the low
-
level domain
.” As the NASA
d
ark energy
website
19

puts it,
no one understands why
it

should be there

at
all.

But is dark energy emergent? As
possibly
a property of space itself, wasn’t dark energy there from the
beginning? Perhaps not. According to Smolin

(2012, p 172)
, space

along
with its inherent dark
energy

may be emergent.


I think it is likely that space will turn out to be an illusion of the sort that temperature and pressure are

a
useful way to organize our impressions of things on a large scale but only a rough and emergent
way to see
the world as whole. …

As we’ll see in this chapter, [the separation of time from space] leads to the revolutionary insight that space,
at the quantum
-
mechanical level, is not fundamental at all but emergent from a deeper order.


Sean Carroll agr
ees.
20


Our best theories of reality are based on
quantum mechanics
, not on relativity, and I think that eventually we
will understand space
-
time as an emergent semi
-
classical property, not at all fundamental.

Time

is very crucial
in quantum mechanics, but
space is only an approximate notion.

Yet even though dark energy violates what the known laws of physics
were before dark energy was
“discovered,”
it has not brought physics to its knees. Why not? Because physics has expanded to include

it. There is now
a
place

in physics for dark energy.




19

http://science.nasa.gov/astrophysics/focus
-
areas/what
-
is
-
dark
-
energy/

20

From an online interview:
http://www.3ammagazine.com/3am/the
-
philosopher
-
physicis
t/
.

14
/
52


Nuclear fusion

Should energy fro
m

nuclear fusion
be considered
an example of strong emergence?
Nuclear fusion

seems to satisfy the
requirements for

strong emergence
:

smaller things

the atomic nuclei of deuterium
(a proton
and a neutron)
and tritium
(a proton and two neutrons)

are put together to create a larger
thing

the atomic nucleus of helium
(two protons and two neutrons) plus an unattached neutron
. (The
number of protons and neutrons going into the reaction and coming
out of the reaction are the same.)
Yet t
he fusion process also produces energy.

In emergence terms, helium nuclei emerge from a base of
deuterium and tritium nuclei. Along with the helium nuclei one gets an extraordinary amount of energy.

Before 20
th

centu
ry science s
uch a
result

would have been irreducible
. It

would have seemed
mysterious
and
strongly emergent. Now that we know how it works,
must

it

forego

that label

and
the
associated
mystique
?


Violation of causal closure is not a problem

W
hether something violates the causal closure of the known laws of physics
is

a false issue. All newly
discovered forces

for

example the strong and weak nuclear forces

necessarily violate
the
causal
closure of the existing forces and the known laws of physi
cs
. Otherwise they

wouldn’t be
considered
new forces. But once discovered, any new force will be (co
-
opted and) integrated into physics
. Physics
will not be

invalidating as
our best
approach
for

understanding nature. Being outside the causal closure
of the

known forces

and

laws

of physics is the signature of a new force

and the need for new science
,
not a sign of the death of science.

The same would go for any other strongly emergent phenomenon. If, for example, aspects of
con
sciousness were shown to have
measurable physical effect
s

that
could not be explained by known
science, science would
investigate

them. Scientists

calling themselves experts in

the

new specialization
of w
hat might be known as

causal consciousness


would
write

grant applications and
ge
t
to work.
21

That’s how science advances.

3.

Emergence summary

All this leads me to the view that emergence is best understood
as the implementation of new
functionality in what may be a new (implicit or explicit) conceptual domain. Other
examples
include

the
hardness of diamonds, flocks of birds, traffic jams,
a
steel

canoe

(it floats even though its parts don’t)
,

and even life
.
What is most important about emergence is that it
has a clear

implement
ation
.

The
implementation may be complex
:

Microsoft Word

involves millions of lines of code
, and

living organisms
involve complex, sophisticated, and coordinated chemistry

and range
in size
from a single cell to
organisms with trillions of cells
. But there is always a replicable implementation. In other words,
e
mergence is a matter of
implement
ing

abstractions
.




21

This is not to minimize the unsolved puzzles about consciousness. I believe that Chalmers was right to highlight
subjective experience as a particularly hard problem. I just don’t think the perspective implicit in the notion of
strong emergence is a
useful way to think about these issues.

15
/
52


S
trong emergence
refers to phenomena we can’t (yet) imagine how

either

to explain or produce
through known science o
r

engineering
.
22

But I don’t believe that any phenomena will
ever
enjoy a
permanent statu
s as strongly emergent.
In fact I would recommend that
we retire
the
category

of strong
emergence
.

P
erhaps the notion of emergence
itself should be retired and replace
d

by the notion of the
implementation

of abstractions
.

D.

T
he special sciences

The three subsections in this section discuss the special sciences and their relation to physics. The first
draws an
analogy

between the special sciences and the kinds of conceptual models developed for
computer applications. The second explores how a poss
ible modern
-
day Laplacian demon might work.
The upshot is that for it to have any chance of working successfully requires that it be informed about
the special sciences. The third subsection examines the debate about whether the laws of physics entail
the
laws of the special sciences.

1.

The special sciences and

their relation to physics

Recall the extract from Fodor in which he

expressed
his amazement that “unimaginably complicated to
-
ings and fro
-
ings of bits and pieces at the extreme
micro
-
level manage som
ehow to converge on stable
macro
-
level properties.”

One might make a similar observation about Microsoft Word. Unimaginably
complicated to
-
ings and fro
-
ings of bits

although perhaps not pieces

in a computer manage
somehow to converge on Microsoft Word.

Is

this a fair comparison? What is the conceptual distance between the two ends of these two
comparisons?

In Fodor’s case one might count: quantum physics to atomic physics, to chemistry to
geology. In the case of Microsoft Word one might count: machine ins
tructions to virtual machine to

programming language

abstract machine

to Microsoft Word.
I gave
sequence four steps. Are they
equally complex steps? It’s difficult to say. But
I’d like to proceed under the assumption that the two
conceptual distances are
o
f

the same order of magnitude.

I’d like to take a moment to explain the steps I outlined for Microsoft Word. The details of the steps
don’t matter for
rest of the discussion, but it may be of interest.

The steps are most easily explained
from the top down.

Microsoft Word (and all other applications
) exist as lines of code written in a programming language.
The two most widely used languages are the C/C++ family and Java. Other widely used languages are C#
for Microsoft applications and Objective C for Macin
tosh applications. This is what the programmer
writes when implement
ing

the Microsoft Word abstractions. In writing those lines of code the
programmer thinks in terms of manipulating
the

abstract machine that defines the semantics of the
language

to produc
e the abstractions that define Microsoft Word
.




22

Researchers in Artificial intelligence (AI) complain that feats that would once have been considered
demonstrations of “true” AI lose that status once we figure out how to do them. Perhaps the same should be said
o
f strong emergence.

16
/
52


All programming languages are processed by compilers. A compiler is a program that takes a program
written in a programming language and translates into a program written in a lower level language. This
is sim
ilar to what we discussed when talking about translating
λ
-
calculus expressions to Turing machine
transitions. In practice most compilers translate what
a

programmer
w
rit
es

into instructions for a virtual
machine. Perhaps confusingly, the virtual machine i
s not a software implementation of the
programming language abstract machine. It is a software implementation of an idealized physical
computer for that abstract machine.
For Java that virtual machine is known as the Java Virtual machine.
For Microsoft pro
gramming languages th
at

virtual machine known as the Common

Language Runtime.
The advantage of generating programs for
a
virtual machine is that
when
a program
is
run a virtual
machine
the physical computer on which it is running is irrelevant.
Java’s motto is “Write once; run
anywhere,” which promises that a Java program will run the same way whether it is being run on a
laptop manufactured by Asis or a desktop manufactured by Dell.

So a compiler generates instructions
for a virtual machine (an
idealized physical computer) in such a way that those instructions will
manipulate the abstractions of that virtual machine to produce the abstractions of the programming
language’s abstract machine.

The final step

is the implementation of the virtual mach
ine in terms of instructions of some physical
computer. For each family of physical computers

e.g., the one or more families of computers built by a
manufacturer

there
is a separate implementation
for

each virtual machine
, i.e., one for the Java virtual
ma
chine, one for Microsoft’s Common Language Runtime, etc
.
That implementation manipulates the
abstractions of
a

particular physical
computer

to implement the abstractions of a virtual machine.

It should be clear
from the preceding th
at no

programmer would r
ecognize
how
the to
-
ings and fro
-
ings
of bits
on a physical computer
correspond to
the code she wrote. And certainly no one would be able to
connect the to
-
ings and fro
-
ings of bits

on a physical computer

with the abstract operations a user sees
when runni
ng a word processor. Yet the convergence is successful.


Applications (“apps”) like Microsoft Word are a relatively simple case. Consider web pages that run in a
browser: Gmail, Facebook, Google+, Twitter, Google maps,
the New York Times website,
etc. Run
ning in
a browser adds a few additional layers of abstraction. The browser
itself
is an app, whose connection to
a physical computer is similar to the connection described above
for

Microsoft Word.
One interacts with
a browser as an app when one clicks the

back button or enters a web address into the browser’s address
field. But browsers are not web pages. As the examples above illustrate, the abstractions for each web
page are specific to that web page. Browsers provide a set of abstractions in terms of wh
ich web pages
are implemented.
These
browser
-
level
abstractions are defined in terms of languages such as HTML,
CSS, and JavaScript.
Implementation of a web page in a browser is similar in concept to implementation
of a set of abstractions in a programming

language. But actually t
o
implement a web page’s abstraction
in terms of a

browser’s abstractions software developers often use frameworks

and libraries

that
provide
yet more levels of abstraction. These are

abstraction that are more convenient
for
implem
enting web pages
than the basic HTML/CSS/JavaScript layer.

Beyond all that, many organizations that offer web access also provide apps that run on mobile phones.
Again, consider the web
-
based services listed above. Most of these mobile phone apps are not b
rowser
based. They are applications that run on the computers in mobile phones the same way that Microsoft
17
/
52


Word runs on a laptop or desktop computer. Consider what that means. The abstractions that users
associate with Gmail, Facebook, etc. are fairly stab
le whether these services are accessed via a browser
or via a mobile phone application. Yet in almost all cases the apps that run on mobile phones offer
significantly different access to those abstractions. If you have used any of these services on both a
laptop (or desktop) and a mobile phone you will have noticed the differences.
So the abstractions are
the same. Gmail deals with messages; the New York Time website deals with articles. But users have
somewhat different ways to interact with those abstract
ions depending on the platform. This is
somewhat more complex than what philosophy recognizes as multiple realization.

Furthermore, the apps that run on mobile phones differ from each other depending on the mobile
phone family. App for Android
-
based mobil
e phones are written in Java; apps for iPhones are written in
Objective C.
To the extent that the apps provide the same access to the same abstractions, this is much
closers to multiple realizations.

One might point out that in the case of software, the to
-
ings and fro
-
ings of bits are all planned and
coordinated in advance; so of course it’s successful. Since nature doesn’t plan
,

how can a similar
convergence take place? The answer is that it doesn’t always happen. When to
-
ings and fro
-
ings don’t
converge
to stable macro
-
level properties, macro
-
level properties don’t appear. Yes, mountains are
made of all sorts of stuff, but mountains are
also
not made of all sorts of stuff. We don’t have mountains
of sand because sand isn’t the sort of stuff whose related
to
-
ings and fro
-
ings can converge to a stable
mountain. If it were, perhaps we would.

In an recent popular article Dennett (2012) cited evolution as an example of competence without
comprehension. One can generalize this to nature in general and conclude
that nature implements
many
abstractions

without comprehending how the

implementations

work. Nature often achieves
competence in implementing abstractions by substituting trial
-
and
-
error over
extremely

long periods of
time for insight

and planning
.

Nor is it surprising that the same conceptual model can be implemented in multiple ways. For any non
-
trivial software program, there are generally multiple ways to implement it. The external functionality
will be the same, but the code that implements that

functionality may be vastly different.

That’s why software libraries are documented in terms of what’s called an Application Programm
ing

Interface (API)
, which describes the functions being computed but not the implementation
strategies
.

A
software libra
ry is a collection of programs that programmers can use when writing their own programs.
The original software libraries provided mathematical functions such as
sin, cos, log
, etc. The developer
of a mathematics library issues a guarantee that if a progra
mmer calls
, for example,

the library’s
sin

function
,

the result will be the sine of the angle passed to the function.
The guarantee says nothing
about how the
sin

function computes its result, only that the result will be the sine of the angle. In fact,
it

should be possible to replace an older version of a library with a newer version that implements some
of the functions more efficiently without having to modify the programs that calls those functions.
23





23

One might think of this as software’s version of multiple realization. A difference between multiple realization in
software and in philosophy is that in software the existence of multiply realized functions is not taken to
demonstrat
e that the multiply realized abstraction is indeed an abstraction as it often is in philosophy. As far as
18
/
52


So I’m perfectly happy to understand nature as havi
ng implemented multiple conceptual models and to
believe that the best way to study nature is to study these conceptual models
as autonomous domains
.
To believe differently would be
similar to

imagin
ing

that one could describe the functionality of all
soft
ware in terms of a single overriding collection of concepts. That would mean that one would expect
t
o

describe a word processing program, a satellite navigation program, the software that runs in
computers that are embedded in automobiles, a web browser, a
nd the software one uses to evaluate
stock option strategies in terms of the same set of abstractions.
That’s no more plausible than the idea
that different aspects of nature can be described in terms of a single collection of
(physics
-
based)
abstractions.


In summary
, there are higher level regularities as studied by the special sciences

or as implemented by
software
, but no, there are no higher level causal laws.
It is only the to
-
ings and fro
-
ings of bits that
make the world

both physical and software

go

‘round.

2.

More about why there is something besides physics

In this section I’d like to approach th
e

question
of why there is anything besides physics
from the
perspective of a modern
-
day Laplacian demon
.

I will take as a starting point a claim raised by

C
halmers
(2006).
In discussing whether or not higher level laws are deducible from lower level laws, h
e writes that

higher level
facts

must be deducible from lower level
facts
.

i
f one knows the complete distribution of atoms in space and time, it remains
plausible that one can deduce
from there the complete distribution of chemical molecules, whether or not the laws [of chemistry] are
immediately deducible from the laws [of physics].
24

I want to
explore

the plausibility of this suggested deduction.

For one

thing, Chalmers must mean more than he sa
ys
. If one knows the complete distribution of atoms
in space and time then since (
as I suppose
Chalmers is assuming) molecules are (more or less) well
defined combinations of atoms, by definition one
immediately
kn
ows the complete distribution of
molecules.
It seems to me that what

he is saying

and what one
might expect to
need the laws of
chemistry to tell us about

is the possibility of computing a future configuration of molecules from a
current configuration of a
toms.
Chalmers

seems to
be claiming t
he plausibility, in principle, of
a modern
-
day
Laplac
ian

demon. I think there are important reasons for saying that we can’t
construct such a
demon
and important lessons in examin
ing
why.

The fundamental elements of cur
rent physics is quantum fields, not atoms.
25

So b
ecause atoms are not
all that special to fundamental physics, which is what Chalmers wants to use as the starting point
, I






software is concerned, even if an abstraction is always implemented the same way, we still distinguish between
the abstraction and the implementation.

The user is concerned about the abstraction and not at all about the
implementation

as long as the implementation produces results that conform to the abstraction and does so in a
reasonable amount of time.

24

(Loewer, 2008) makes a similar claim.

25

See (H
obson, 2013) for a discussion of this view from the perspective of a college physics instructor. The
quantum

field for what might

otherwise be called a particle

fills all of space. Its value at any point is the
so
-
called
probability amplitude that an inter
action will occur at that point.
T
he
se

value
s

are given as
complex number
s
. The
19
/
52


wrote “components” in the preceding instead of “atoms.”

There are a number of reasons

why it’s not

plausible that
a modern
-
day demon
can deduce a future complete distribution of chemical molecules
from knowledge of a current complete distribution of quantum fields.
I see a number of problems in the
way of such a
computation.

For
starters
,

given quantum uncertainty it’s not clear what it means to say that one has a complete
distribution in space and time of some
collection

of quantum fields. The best one can have, even in
principle, is an approximate distribution. So the first problem is th
e likely chaotic effects.

Secondly, since every quantum field fills the entire universe, to compute/deduce the future distribution
of
even
a

small

set of quantum fields one
must
, at least in principle, take into account the influence on
that set of all th
e quantum fields in the universe. One could get around this problem by considering only
the quantum fields with a non
-
negligible value in the region of concern. But that limits our computation
to an approximation

perhaps a very good approximation, but stil
l an approximation.

But let’s ignore these problems and consider the actual computation. What such a computation would
require is something like a quantum computer which one starts off with a configuration of quantum
fields and
is
then set running. How wou
ld such a computer compute?

Quantum interactions are in principle probabilistic. To find the probability that a quantum field will

participate in an interaction
at
some

point, one multiplies the value of the field at that point by its
complex conjugate. I
f one could build a quantum computer, it would take all the probabilities of all the
fields for which it is responsible and compute all the possible interactions, with probabilities associated
with each one.

The result would be a superposition

(i.e., coll
ection)

of

something like a multiverse of

(a great many)
quantum field sets
. Each element in the collection would correspond to one
possible future of the
original set of quantum fields.
Since we are computing combinations, the number of sets in the
collec
tion would increase exponentially with the

length of time for which we want the computation. The
longer the time the higher the power of the exponent needed to express that number. That number
would quickly exceed the number of atoms in the universe
, which

is estimated to be only 10
80
. If it
would require more than all the computational resources available in the universe to perform a
computation, it’s not reasonable to say that such a computation is
plausible
.

But let’s ignore that
problem since a more interesting one is to come.

Assume that somehow one could
muster

the required computing power and
generate the required
multiverse of superpositioned field sets. What should be done with them
?
We aren’t

looking for

a
multiverse of possible answers;
we

want a single answer

the distribution of the relevant set of
molecules. Which element of our multiverse should we pick as the selected future
?








probability of an interaction occurring at a point is the product of the value of the
field

at that point and
its

complex conjugate
. The complex conjugate of a complex number is the complex number with the same real
part and the negation of the imaginary part. The product of a complex number
with its complex conjugate is
always a real number:

(a+ib)*(a
-
ib)=a
2
+b
2
.


20
/
52


One approach
to making that choice
would be

to group the super
positioned field sets into clusters,
weight
the clusters

by the probability of their having come into existence, and then select one of the
field sets from the highest weighted cluster. Here is where I think this thought experiment becomes
especially inter
esting.

To group a collec
tion of elements into clusters of similar elements

we need a way to measure how
similar
two

elements are to each other. Do we have a way, even in principle, to construct a reasonable
measure of the difference between two

sets of

qu
antum fields?

Perhaps
there is some hope
.
W
e
currently
have software that can do pattern matching on images and
compute a measure of how similar two images are.
O
ne can give Google an image and ask it to find
similar images.
The algorithm works by looking

for patterns such as large patches of sandy
-
colored areas

(which may indicate a beach scene)

or a great many horizontal and vertical lines

(
which may indicate
buildings
)
. Google’s algorithm is much more sophisticated than that, but at its heart
i
s
some so
rt of
pattern recognizer
.
Let’s suppose that

a similar algorithm could be constructed for quantum field sets.
All we would need to do is to apply that algorithm to each pair of field sets in our multiverse and use
that measure in our clustering algorithm.

Would that do the job?

Suppose

we started, say, with
Schrödinger
’s cat
26

and wanted to know whether
the cat will be dead or alive after a certain amount of time. The problem, of course, is constructed so
that there is a non
-
negligible probability of either
. So we shouldn’t be surprised if we don’t expect to get
a definitive answer. But restating the problem in terms of a cat raises additional problems.

One problem is that our pattern recognition algorithm may not be able to distinguish the field set of a
d
ead cat from that of a live cat that happened to be sleeping in the same position. (I’m assuming that
the cat died just recently and hadn’t yet started to decompose.) After all, the algorithm is doing
relatively gross pattern matching, not a detailed analy
sis of cat physiology.
At that level of comparison

a

field set of a recently deceased

cat
would be virtually indistinguishable
, even at the physiological level,

from that of a
sleeping
live cat.
Certainly someone knowledgeable about cats would know where
to look
and would know how to distinguish one from the other. But our comparison algorithm doesn’t know
anything about cats. All it knows is field sets, and all it can do is to
compare them to each other in
relatively gross way
s
.

This illustrates for me on
e of the important properties of higher levels of abstraction, namely that
certain differences matter much more than others.
Relatively small d
ifferences in
physiology

matter
much more

than
possible

large

differences in the shape of the food bowls.
Our similarity algorithm
would rate two scenes that are essentially identical except that one had a recently deceased cat and the
other a live sleeping cat in the same position as quite similar. Yet it would rate two scenes with two cats
sleeping in the sa
me position but with differently sized and shaped food bowl as very different. This
would happen because the scenes with the different food bowls would have more differences from each
other
at the level of primitive elements tha
n the ones with the dead and

live cats.

It doesn’t matter what
the primitive elements are. They could be quantum fields or something else. All that matters for this



26

Admittedly we are now talking about cats and not molecules. But the molecules example was presumably
intended to generalize to other levels of organization.

21
/
52


point is that some elementary elements are sometimes more important that others and that a gross
comparison algorithm w
ouldn’t know which the important ones are.
It’s easy to construct other
examples along these lines. Imagine two scenes that are identical except for the bank balances of two
people.
When examined at any elementary level the two scenes would appear virtuall
y identical

the
physical differences corresponding to the two bank balances are minimal. Yet i
n reality
the differences
would be

significant.

Could we modify our similarity measuring algorithm somehow to be aware of which differences are
important? It seem
s to me there are two possible approaches: easy and hard.

The algorithmically easy approach is to modify the similarity measuring algorithm to do something like a
sub
-
simulation of the field sets it is comparing and look at how they propagate. That is, pr
opagate each
field set
for a short time and then do a pattern
-
matching comparison of the two results.
Assuming the
sleeping cat had a reasonable probability of waking up and beginning to move around in during time of
the sub
-
simulation, the algorithm would

be able to tell the difference
. Therefore
even though the
patterns of two field sets may appear very similar superficially, since they propagate differently, the
algorithm would be able to conclude that they really are quite different
. This
approach
may w
ork
reasonably well at the biological level

since branching is likely to occur relatively quickly
.

It has problems at the social level in which it is never clear how far
ahead
one would have to propagate
to see whether apparent negligible differences real
ly matter. If two people with similar personalities but
different sized bank accounts are fishing, they may behave in pretty much the same ways for a long
time. It’s only when an activity occurs for which the size of the bank account matters that one will
see a
significant difference. And one can’t say in advance how far into the future one would have to propagate
until such an activity occurs.

This strategy is important because it doesn’t require that the algorithm know anything. All it requires is
that t
wo apparently similar scenes have a high probability of branching fairly early.

The algorithmically much more difficult approach is to build into the similarity measuring algorithm
knowledge about the higher level structures and about which differences mat
ter. This seems like