BioSystems 36 (1595) 7-17

Computational properties of self-reproducing growing automata

Rok SosiC*, Robert R. Johnsonb
School of Computing and Information Technology, Gri/fh University. Nathan, QLD 4111, Australia
bDepartment of Computer Science, University of Utah, Salt Luke City, VT 84112, USA
Received 15 August 1994; revision received; accepted 20 J&ember

1994

Living organisms perform much better than computers at solving complex, irregular computational tasks, like search
and adaptation. Key features of living organisms, identified in the paper as a basis for their success in solving complex
problems, are: self-reproduction of cells, flexible framework, and modification. These key features of living organisms
are abstracted into a computational
model, called growing automata. Growing automata are suited for
extremely large computational problems, such as search problems. Growing automata are representatives of soft
machines. Soft machines can change their physical structure as opposed to hard machines which have fixed structure.
An example of a soft machine is a living organism, an example of a hard machine is an electronic computer. The computational properties of soft and hard machines are analyzed and compared. An analysis of growing automata
demonstrates their advantages, as well as their limitations as compared to hard machines.
Keywordr: Computational

models; Kinematic automata;

Soft machines; Hard machines; Growing automata;

Self-

reproduction

1. IllmdudoIl

Von Neumann (1966) studied computational

structures, the organization of systems of computing elements, as a basis for the design of effective computers. He set foundations for kinematic
automata, cellular automata, and self-reproducing
automata.
The model of kinematic automata is concerned
with kinematic and geometric properties of
computational elements. The development of

* Corresponding author, E. mail: sosic@cit.gu.edu.au.

kinematic automata has been largely overshadowed by cellular automata where the position and the
functionality of computing elements are fixed. An
overview of results in kinematic automata theory
is presented by Laing (1979). A survey of results in
early cellular automata theory has been compiled
by Burks (1970).
Automata whose computing elements change
over time, growing automata, have been introduced by Burks (1961). His discussion focuses on
growing automata with a ftxed framework of computational elements. In a fued frumework, elements do not change their positions, but they can
be modified. As a result, the connectivity pattern

0303-2647/951SO9.50 0 1995 Elsevier Science Ireland Ltd. All rights reserved

SSDI 0303-2647(95)01523-N

R Sosit, R. R. Johnson / BioSystems

between computational elements is fixed. Burks

mentions growing automata with a flexible
framework which permits insertion of new elements between old elements, but the flexible
framework is not investigated in any detail.
This paper adds the capabilities of a flexible
framework and of self-reproduction to the model
of growing automata. Each growing automaton
consists of many computational elements. The elements are organized in a growing automaton in a
way that provides three fundamental properties:
self-reproduction, a flexible framework, and modification. Self-reproduction means that computational elements are capable of producing new
elements. Ajlexible framework allows the insertion
of new elements between old elements. With a flexible framework, positions of elements are not
fixed, but they can change during execution. Modification enables the change of elements, which provides a reuse of resources. Since positions of
elements are important, an essential part of the description of a growing automaton is its shape in
the space. This shape develops by creation, deletion and motion of computational elements.
One consequence of self-reproduction is the
possibility of a limited exponential growth in the
number of computational elements. Another, well
established formalism, capable of exponential
growth, is the model of L-systems, introduced by
Lindenmayer (1968). An extensive bibliography is
published by Langton (1989). L-systems are based
on the parallel transformation of strings, while
growing automata are based on the parallel transformation of computations. Extensions of Lsystems to two and three dimensions are called
map L-systems and cellworks. L-systems provide a
good formalism for describing the topology of a
growing structure, but the shape of an L-system in
a space is added by an independent description
and it is not directly specified by transformation
rules. In contrast, the shape is an inherent property of a growing automaton.
This paper introduces self-reproducing growing
automata. Computational properties of growing
automata are discussed. For very large problems,
growing automata might be a more effective computational model than conventional models. Section 2 provides basic definitions and examples.

36 (1995) 7-17

Section 3 discusses self-reproduction,

Ilexible
framework, and modification as sources of computational efficiency. A hypothetical comparison
between living organisms and electronic computers which outlines some trade-offs with growing automata is presented in Section 4. Section 5
concludes the paper.

2. Introduction to growing automata

2.1. Defmition
Crowing automata belong to the kinematic
automata model as defined by von Neumann
(1966). A growing automaton is an automaton that
can change its own structure. It consists of elementary computational elements. A computational
element includes a structure to carry out the
computation and a program that guides the behavior of this element. Elements have the ability to
communicate with other elements and to interact
with the environment. There is no global synchronization between computational elements.
Each computational element of a growing automaton could be, in principle, a Turing machine
(Turing, 1937); therefore the expressive power of
growing automata is at least equal to electronic
computers.
A specific feature of growing automata is that
an element of a growing automaton can: move
itself; or create, delete, change, and move other
elements in its neighborhood. As a new element is
created, the program, possibly modified, is copied
from the parent to the child.
Crowing automata could be represented by
computational elements, floating in a fluid and
moving around freely. The fluid is filled with
building blocks. These building blocks provide
constituents of computational elements and form
the basic level of implementation for growing
automata. This is one of the representations suggested for kinematic automata by von Neumann
(1966).
An example, presented next, illustrates the concept of growing automata.
2.2. Breadth first search with growing automata
Breadth first search is a computational tech-

R. SosiE. R. R Johnson / BioSystems 36 (1995) 7- I7

??
??
0

cl

first step

second step

third step

foutltl step

fifth step

Fig. 1. Generation of new computational elements in breadth

first search.

nique of traversing a search tree, by which all

branches of a node are visited simultaneously. Although breadth first search seems well suited for
parallel computations, the distribution of processes on a parallel electronic computer could be a
problem. Since the number of processes can
increase exponentially, but the topology of computers is fixed, processors may not be able to
distribute processes as fast as they are created.
This increase in the number of search processes
often leads to throttling, in which processors are
overloaded with search processes and no progress
is being made in the search. In a growing automaton, the problem could be solved by generating
new computational elements as they are required
by the search.
This generation of new elements is shown in Fig.
1. At the first step, there is only one computational
element. This element represents the root node of
the search tree. During the second step, this root
node produces new computational elements which
accomplish the search process at the second level
of the tree. In this example, there are three computational elements at the second level. During the
third step, computational elements at the second
level produce six new computational elements
which perform the search at the third level. This
process of creating new computational elements
continues, until an answer is found.
The number of necessary steps to find the
answer is proportional to the depth of the search
tree. On computers that are not capable of
generating new computational elements, the cost
of breadth first search depends exponentially on

the depth of the search tree, since the search tree

must be traversed by a fixed number of processors.
By using self-reproducing computational elements,
growing automata can reduce the time complexity
of a problem. In the breadth first search example,
growing automata reduce an exponential time
complexity to a linear complexity by traversing all
branches at one level in a single step.
Due to their ability to produce new computational elements, growing automata can grow exponentially. This exponential growth has ultimate
limits in the speed of light. Physical space increases
at a polynomial rate of n3 which is not suBicient
to accommodate an exponentially increasing
growing automaton. The exponential expansion in
the number of elements is thus achieved by exponentially increasing the speed of elements and
the displacement between them. Since the motion
of elements is limited by the speed of light, this
speed represents the limit on the exponential
growth.
This example demonstrates that a growing automaton cannot be separated from its physical shape
and the space it occupies. The next section gives a
discussion of some possible spaces for growing
automata.
2.3. The shape of growing automata
Most conventional
computational
models
assume abstract, mathematical spaces, without
any consideration of positions of computational
elements. An exception are cellular automata
which divide the space in regular partitions. In
growing automata, space and the shape of an automaton are inseparable from the automaton itself.
Growing automata cannot be studied separately
from the space they occupy. The shape of a growing automaton is constrained by the topology of
the underlying space. The actual shape emerges
during the execution.
Most common spaces for growing automata are
subsets of the three-dimensional Euclidean space,
which is for most purposes our physical space.
Some examples of space topologies are one, two,
three-dimensional Euclidean spaces, circles, or
disks with holes.
A line is one of the simplest spaces for growing
automata. An infinite number of topologically dif-

10

R. Sod& R.R

Johnson / BioSystems

ferent spaces can be derived from the line. Some

examples include: a half line, a circle, a star, and
their combinations. Each automaton on the line
can influence its left or right neighbor. The restriction to two immediate neighbors is a very limiting
property of the line space, but nevertheless some
useful computations can be made. Examples of
computations that can be implemented on a line
are divide and conquer algorithms which do not
require a large amount of communication between
individual computational elements. The connectivity on a line is sufficient when no communication over distance is needed. Although an
arbitrary communication path can be simulated on
the line by providing each element with message
sending and routing capabilities, it is often more
effective to embed the automaton in a higher
dimensional space.
A plane provides more space for connectivity
than a line. For example, a tree can be embedded
in a plane but not in a line. A family of
topologically different spaces can be derived from
a plane. Examples are a sphere, a torus, a Mobius
strip, and their combinations.
Some graphs cannot be embedded in a plane
without crossing edges (Harary 1969). This is a
limitation of planar spaces. Three-dimensional
Euclidean (3-D) space. is the lowest dimensional
space that can embed an arbitrary graph. The connectivity between nodes can be arbitrary, but communication distances are still limited by the 3-D
space. Three-dimensional space is, for all practical
purposes, also the space of our reality. It is the
largest space that we can hope to provide for
genuine implementations of growing automata.
2.4. Self-reproduction, jlexible framework, and
modification
This section provides an informal discussion of
basic properties of growing automata: selfreproduction, a flexible framework, and moditication. More formal models are presented in the next
section.
Self-reproduction. Self-reproduction is the ability of computational elements to produce new elements. This ability is crucial in providing
exponential growth in the number of computational elements. The relevance of exponential

36 (1995) 7-17

growth is demonstrated in the breadth first search

example above. As compared to more traditional
models, exponential growth enables the reduction
of the time complexity of some algorithms, such as
search. In general, self-reproduction can be applied whenever a fast distribution of information
to a large number of computational elements is
necessary. This fast distribution can be interpreted
as an efficient use of time.
Flexible framework. An automaton has a flexible framework if the positions of computational
elements are not fuced. As new elements are
created, old elements are moved around to accommodate these new elements in the structure. The
definition of growing automata does not specify
how computational elements communicate. As elements are spread apart, they can cease to communicate or they can keep their connections. An
example of the first is the breadth first search
example. After its creation, each element in the
automaton is independent from other elements.
An example of a flexible framework, where a complex pattern of connections between elements is retained, is the development of the human nervous
system. Flexible framework is of vital importance,
since it enables growing automata to adapt
themselves efficiently to complex problems. It is
shown in the next section that the growth in the
size of the automaton is prohibitive without an
underlying flexible framework.
Modzjicution. Modification enables transformations of elementary computational elements. A
transformation of an element involves a partial or
complete breakup of the element into basic
building blocks and the construction of a new element. Modification provides a reuse of basic
building blocks and of space occupied by the automaton. For example, if an automaton requires
large memory and a few processors at one time interval and small memory and many processors at
another time interval, then modification enables
the conversion of memory to processors. This
saves the required number of building blocks and
space.
Self-reproduction, a flexible framework, and
modification enable a growing automaton to be efficient in using available resources which include
time, space and building blocks.

R. SosiE, RR. Johnson/ BioSystem 36 (1995) 7-17

3. Com~tional
maches

efficiency of bard and soft

In this section, hard and soft machines are introduced. It is shown that self-reproduction, flexible framework, and modification are important
for the efficiency of soft machines. The discussion
concentrates on computational aspects of machines in using basic resources, including space
and time.
3.1. Hard and soft machines
Hard machines are defined as machines that
have a fixed structure. Soft machines are machines
that can change their structure. Most artificial devices are hard machines. Examples of hard machines include electronic computers. Examples of
soft machines are living organisms. A living organism changes its structure in time. Growing
automata abstract computational capabilities of
soft machines.
3.2. Self-reproduction and exponential growth
In growing automata, elements can produce new
elements. This enables, within certain bounds, exponential growth in computational power. The
potential of exponential
growth and selfreproduction is discussed by Cliff (1980) and
Moravec (1988). They show that, given enough
time, phenomena with the ability of reproduction
can expand much faster than phenomena without
this ability.
Two ,computational aspects of self-reproduction
are im$ortant: the number of active elements and
the speed of communication.
Using selfreproduction, soft machines can exponentially
increase the number of active elements while the
speed of communication between elements remains constant. An exponential increase in computational power and a constant speed of
communication are mutually exclusive in hard
machines.
The breadth first search example is used to illustrate the concept of active elements. At the
beginning, the root element contains all the informationthat is needed to perform the search. This
information, slightly modified at each level, must
be sent to elements on lower levels of the tree. Ele-

11

ments that have already received the information

are called active elements. The search process can
be sped up by increasing the number of active elements as fast as possible.
With self-reproduction in soft machines, the
number of active elements can grow exponentially.
This number of elements grows only polynomially
for hard machines. The argument is formalized in
a comparison between growing automata as
representatives of soft machines, and cellular
automata as representatives of hard machines.
Cellular automata are a model for massively
parallel computations. They consist of cells on a
uniform grid. Cells have the same functionality.
Since the positions of cells in cellular automata are
fixed, new cells cannot be created.
At each step, a cell in a cellular automaton can
communicate with its immediate neighbors (von
Neumann 1966). Assuming a three-dimensional
square grid of cells and the Moore neighborhood
(Toffoli 1987), which includes the neighbors on
parallels and diagonals, the number of active elements in n steps, CA,, is at most:
CA = (2n + 1)3
The value of CA, increases polynomially with increasing n.
Assuming that each element of a growing automaton can produce two new elements at each step,
the number of active elements for a growing automaton at step n, GA,, is calculated as:
GA,=2-

1.

The value of GA, increases exponentially with increasing n. A comparison between CA,, and GA,
reveals that self-reproduction in GA,, offers an
enormous increase in the number of active elements over CA,, which does not have the ability
to self-reproduce (see Table 1). This advantage
becomes larger as the problem size increases.
A direct comparison between CA,, and GA,
does not take into account that one step of growing automata is significantly more expensive than
a step of cellular automata. A step in growing
automata involves production of new computational elements, while a step in cellular automata

R. Sod& RR Johnson/ BioSystems 36 (1995) 7-17

12

Table 1
The number of active elements at step n in: Cellular automata without self-reproduction, CA(n); and growing automata with selfreproduction, GA(n)
n

10

20

30

40

50

60

CA(n)
GA(n)

= 4 x 102
= 103

= 2 x 103
= 10

= 4 x 103
(1 109

= 6 x lo3
= 102

= 104
= 10

a 104
5 108

The crossover point is at 59 552 s:

involves only communication. These differences in

step complexity are accounted for in the following
comparison, which compares the speed of information transfer between living organisms and electronic computers.
The comparison correlates cell reproduction
with information transfer. In living organisms, the
reproduction of small cells takes around 1000 s
and transfers at least 10 bits of information encoded in DNA. Therefore, 1000 s can be taken as
sufficient time for a growing automaton to perform one step with 10 bits as the amount of information to be transferred. Assuming that
cellular automata can communicate at the rate of
lo8 bits per second, it takes them 10-l s to communicate 10 bits. Therefore, cellular automata can perform ten steps in 1 s. Based on CA,
and GA,, the number of active elements at time t
can be calculated for cellular automata, CA(f), and
for growing automata, GA(t), as follows:

GA(59 552) = CA(59 552) = 1.69 x 1018

CA(t) = (2 x (10 x t) + l)j,

GA(t) = 2Ooo- 1.
Table 2 shows GA(t) and CA(t). The number of
active elements in GA(z) exceeds the number of
active elements in CA(?) between lo4 s and lo5 s.

After this crossover point, GA(f) rapidly surpasses

CA(t). It follows that GA(r) might be more powerful for computations, requiring more than lOI
operations. Complex problems, such as search,
typically require more than lOi operations.
Growing automata might not be effective for problems significantly smaller than 1018 operations,
because the overhead of reproduction is too high.
Besides exponential growth in active elements,
an important consequence of self-reproduction is
the constant speed of communication between elements. The breadth first search is used as an example again. To simplify the presentation, it is
assumed that the breadth first search is executed
on a line and that each element creates exactly two
new elements. This simplification does not influence conclusions.
The first four computational steps are shown in
Fig. 2. Each line of squares represents the automaton at a different step in time. Newly created
elements are shown in white, the elements from the
previous step are shown in black. Since the information is passed from old elements to new, new
elements are created as neighbors of old elements.

Table 2
The number of active elements at time t in: Cellular automata without self-reproduction, CA(t); and growing automata with selfreproduction, GA(t)

time

1s

10s

10%

10%

10%

10%

CA(I)
GA(t)

- 104
1

- 10
1

= 100
1

= 103
2

* 106
2 x 103

= 109
2 x 10M

R. SosiE. R.R. Johnson / BioSystems 34 (1995) 7-17

V
sscond

;t.

step
third step

fouml step

Fig. 2. Exponentially growing automaton on a line.

It follows that communication between old and

new elements is local and over a fixed distance,
regardless of the number of elements. This is possible because new elements are constructed as needed and because the positions of old elements are
not fixed. An exponentially expanding size of the
automaton is achieved without the corresponding
increase in the speed of communication.
If an automaton needs to expand in order to
employ massively parallel computation, such as
during search, self-reproduction of computational
elements offers the fastest way to generate new elements. Since self-reproduction enables a quick
employment of a large number of elements, it provides efflcietit use of time.
3.3. Flexible framework
Burks (1961) mentions growing automata where
new elements can be created between old elements,
but this direction of research has not been pursued
any further. Burks discusses growing automata
with a fixed framework, where the positions of
elements are fixed. Hard machines have a fixed
framework. Automata with a flexible framework
are defined as automata that can move computational elements apart and create new elements in
the space in between. Flexible framework is supported in soft machines.
The importance of a flexible framework increases with the complexity of problems. For simple problems, effG5ent machines can be designed
with a fixed structure. But in complex problems,
an example of which is adaptation or search, new
requirements are imposed on machines. If computational efficiency is to be retained for complex
problems, then the structure of the automaton
must be updated to accommodate new require-

13

ments. Updates are achieved by changing existing

computational elements or by adding new elements. It is shown below that when new elements
must be dynamically added to the structure,
automata with a flexible framework can evolve in
less space than automata with a fixed framework.
The space chosen for the comparison is the
plane. The following assumptions are made: an
automaton is represented as a circular disk (see
Fig. 3 (a)); each new computational element is
added on the connection between two elements
that are already connected; and the area of the
disk is increased in proportion to the length of the
new connections. Since the size of connections
grows at least as fast as the size of computational
elements, the size of elements can be ignorti in the
model without significantly influencing the results.
Informally, since new elements in a fixed
framework must be added on the bord#r of the
automaton, the increase in size is dependent on the
total size of the automaton.
In a flexible
framework, elements can be added to the middle
of the automaton and the increase in the size is
only constant. The result is much faster gtowth in
the size of connections in a fixed framework.
A more formal argument goes as follows. An
automaton with a fixed framework can provide
only a limited number of empty slots inside the
disk. Once these are occupied, new elemebts must
be added on the border of the disk (see Fig. 3 (b)).
The length of new connections is thus dependent
on the size of the disk. Let FX(n) denote the area
of an automaton with a fmed framework at step n.
The area KY(n) of the disk can be computed recursively as:
FX(0) = a, FX(n+l) = FX(n) + b r(n),

(a)

originalcomputatii

(b)

new elemml in
s Rued framework

(1)

(c) new **franI in

* fiexfbkl hamwork

Fig. 3. The addition of a new element to the automaton.

14

R. Sod, RR. Johnson/ BioSystems 36 (1995) 7-17

where function H(n) is the area at step n, function

r(n) is the disk radius at step n, constant a is the
area at step 0, and b relates the disk radius and the
average length of new connections. Since the
length between an average point inside the disk
and the disk border depends only on the size of the
disk, b is a constant. With substitutions r(n) =
wand
c=m
Eq. 1 is transformed to:
FX(n + 1) = H(n)

+ c _).

The solution to this recurrence equation for FX is:

FX(n) = 0.25c2n2 + O(n).
The term O(n) denotes a part of the solution that
depends linearly on n. It can be seen that the area
of an automaton with a fixed framework increases
with the square of the number of elements.
A flexible framework permits an infinite expansion of the disk interior, because elements can be
moved apart to make more space. Since the connection between two old elements already exists,
an addition of a new element increases the length
of this connection. The increase in the length of
the existing connection is constant and independent of the disk size (see Fig. 3 (c)). Let FL(n)
denote the area of an automaton with a flexible
framework at step n. The equations for the size of
the automaton are:
FL(O) = a,
FL@ + 1) = FL(n) + d,

(2)

where FL(n) is the area at step n, a is the area at

step 0, and d is the constant increase in size at each
step. The solution to the recurrence equation for
FL(n) is:
FL(n) = a + dn.
The area of the automaton with a flexible
framework increases only linearly with the number
of elements.
The conclusion is that an automaton with a flexible framework FL(n) grows linearly with the number of elements n, while an automaton with a fixed
framework FX(n) grows quadratically in n. A

human brain grows from a single cell or from a

small set of cells. Until the brain stops growing,
new elements, neurons, are created and added to
already existing structures. Assume that an estimate for the number of neurons in a human brain,
roughly 10 (Moravec, 1988) is taken as the number of elements, n, in a growing automaton. In this
case of 10 computational elements, the ratio in
space utilization in plane between a flexible and
fixed framework is 10. Calculating the size of an
automaton that grows from a single element to
10 elements, the difference between a flexible
framework and a fixed framework is the difference
between the square with a side of 1 m and the
square with a side of wrn
= 316 km.
The comparison of the sizes shows that large
scale evolving automata are possible only within a
flexible framework. Existing computers have a
fixed framework. In contrast to computers, living
organisms have a flexible framework. Computers
can, in principle, solve. a fixed or well specified
problem, such as matrix multiplication, with the
same or greater efficiency as living organisms. But
living organisms are solving problems that are not
well specified. For these problems, automata with
a flexible framework are more effective than
automata with a fixed framework. The size of
automata with a fixed framework increases too
rapidly as their computing structure expands to accommodate new requirements.
3.4. Modification
Space and building blocks can be reused by
modification, which is defined as the ability of an
automaton to change its computational elements.
Modification enables different tasks to be accomplished in the same space and using the same
building blocks at different times. Since complex
problems are usually irregular, large numbers of
computational elements are not used during certain phases of problem solving. By reusing this
space for other purposes, modification allows a
better space utilization.
Suppose that an automaton needs a large
memory during one time period and many processors during another. If the structure is able to
change and both the memory and processors are
approximately the same size, then the space can be

R. Sosi2. R. R. Johnson / BioSystems 36 (1995) 7-17

-B

time

(a) no adaptation, space is wasted

aotive
not used

15

al elements are connected, only their size is considered. Without modification, the maximum
possible use of each element type must be
guaranteed for optimal execution time:
SNM(f) = Fmaxg(t)).

lllMmoy(+

Iprowssors(

??

time
(b) adaptation, space is fully utilized

Fig. 4. Modification better utilizes space.

Since SNM(r) is a constant for all I, 1 can be omitted:

SNM(t) = SNM.
It is obvious that for any value of t:
2X4(t) I SNM.

reused. Fig. 4 (a) shows a computational structure

without modification. When only memory is active, processors are not used at all, but they occupy
precious resources, such as space and building
blocks. Similarly, when processors are active,
memory is idle. Fig. 4 (b) shows a computational
structure with modification. When the memory is
not needed, its structure could be disassembled
and processors could be built, using the same
space and possibly the same building blocks. So an
automaton which is unable to change its elements,
in general, occupies more space and uses more
building blocks than necessary.
In more formal terms, assume i different types of
computational elements are needed. Let f(t)
denote space requirements for the i-th type of elements at time t. Let SM(t) denote the space requirements of an automaton with modification at
time t. Let SNM(t) denote the space requirements
of an automaton without modification at time t. It
is assumed that transformations from one type of
element to a different type can be done in parallel
with the computation, and that the transformations do not influence the total execution time.
This assumption provides an upper bound for the
effectiveness of modification.
To achieve the optimal execution time with
modification, enough space must be provided to
cover demands at any moment t:

Equations do not take into account how individu-

The equality is achieved only for values of t

where all f,(r) simultaneously reach their maximum, which is very improbable for large and complex problems. The value of SNM increases
rapidly with the increasing number of element
types and the complexity of the problem, while the
function SM(f) grows at a much slower rate. For
an irregular problem, an automaton that can
modify its elements generally needs significantly
less space than an automaton without modification.
4. Living organisms and electmdc conqmters
The model of growing automata has some inherent limitations and trade-offs, which are significant for potential implementations. An important
parameter is the time required to create new elements. In order to gain some perspective on this
parameter, a hypothetical comparison is made between living organisms, as representatives of growing automata, and supercomputers of the early
199Os, as representatives of electronic computers.
The comparison involves time and space trade-offs
for problems of different sixes.
It is assumed that the problem consists of a large
collection of independent operations. Because
such problems represent the optimal case for
growing automata, they provide an upper bound
on the effectiveness of growing automata. Search
problems are examples of problems which can be
carried out by large collections of independent
automata.

16

R. SosiE, RR. Johnson / BioSystems 36 (1995) 7-I 7

It is estimated that an electronic computer performs lo9 operations/s and fits into 0.09 m3 of
space - approximately 1 ft3. Let n denote the
number of necessary operations to solve a problem. The electronic computer can then solve the
problem in n10S9 seconds.
A growing automaton can double the number of
elements in each time step, so it needs log n steps
to produce n elements. Because most of the time is
spent in producing new elements, the computational time required to carry out the final computation can be neglected. The total number of steps
for n operations is thus log n. To be competitive
with the electronic computer, each step must be
performed in not more than n/log n 10m9s. The required number of elements is n, i.e. one element for
each operation. In order to fit in the same space as
the electronic computer, each element can take up
at most 0.09/n m3.
Results for problem sizes of 109, 1012, lOi, and
lo* operations are calculated in Table 3. The
number of operations column shows the total
number of operations, n, which are required to
solve the problem. The number of steps column
shows the number of steps, log n, which must be
performed by the growing automaton to execute n
operations. The total time column shows the time
needed by the electronic computer to perform the
task: n10W9s. The time per step column shows the
time needed by the growing automaton to execute
one step: n/log n 10S9 s. The size column shows
the cube side of one element of the growing automaton, assuming that each element occupies a
cube.
The numbers in Table 3 provide an estimate for
the performance of growing automata to equal
electronic computers in execution speed. The most

interesting column is time per step, which gives the

time available for the creation of new elements. It
can be seen that this time increases rapidly with the
size of the problem. It can be concluded that, with
the increasing problem size, time constraints considerably favor growing automata over electronic
computers.
It is interesting to compare the numbers in Table
3 to cells in living organisms. Data are taken from
Dyson (1978). The size of cells range from only a
few tenths of a pm (smallest bacteria) to many cm
(certain marine algae and various bird eggs). Most
human cells have a diameter around 10 pm. The
rate of cell growth varies between 20 minutes and
1 day, approximately, for one cell division. The
row that corresponds to these numbers in Table 3
is the row with around lOi operations. It follows
that an implementation of growing automata with
cells similar to cells in living organisms would be
better than electronic computers at tasks that require at least 1015 operations. These tasks are on
the border of existing computing technology. The
estimate is similar to the crossover point of lo*
operations, calculated in the section on selfreproduction, but using different assumptions.
5. Conclusion
This paper analyzes computational aspects of
self-reproducing growing automata with a flexible
framework. It is shown that the model of growing
automata provides a way to radically increase
computational power for complex problems, such
as search.
An implementation of growing automata requires technology that supports changes in
computational structure, especially exponential

Table 3
Growing automata with the capability and the size of an electronic computer

Wofsteps
log n

total time
n10-9 s

time per step

total time/# of steps s

size
w?LiiG&

109
102
105
los

30
40
50
60

1s
1000s
218 h
31.7 years

0.033 s
25 s
5.6 h
193 days

45ow
45 Pm
4.5 /ml
0.45 pm

I of ops.

R. SosiZ, R.R. Johnson/BioSystems 36 (1995) 7-17

growth through self-reproduction,

a flexible
framework, and the modification of computational elements. Living organisms are proof of the
existence of structures that: are capable of limited
exponential growth; provide a flexible framework;
and can partially modify their structure, as individuals and through evolution. Existing electronic computer technology does not allow us to
implement genuine growing automata. Capabilities to realize growing automata might be provided by molecular computers. A discussion on design issues of molecular computers is provided in
Conrad (1985, 1992). Growing automata are
representatives of soft machines. One of the
leading trends in technology, called nanotechnology, is toward miniaturization, Drexler (1986).
Growing automata and soft machines provide a
complementary approach to nanotechnology. Our
analysis shows that, together with miniaturization,
the ability to change computational structure is
another important feature of computational effrciency. The study of soft machines and their computational aspects will lead to computers that are
very different from those currently in use. Soft machines will enable us to solve complex problems
that are beyond our reach today.
References
Burks, A.W., 1961, Computation, behavior, and structure in
fixed and growing automata, Behav. Sci. 6, 5-22.

17

Burks, A.W. (ed.), 1970, Essays on Cellular Automata (University of Illinois Press, Urbana, IL).
Cliff, R., Freitas, R., Laing, R. and von Tiesenhausen, G.,
1980, Replicating systems concepts: Self-replicating lunar
factory and demonstration, in: Advanced automation for
space missions, R. Freitas and W.P. Gilbreath (eds.)
(NASA/ASEE Conference, Santa Clara, CA, Publication
2255) pp. 189-335.
Conrad, M., 1985,On design principles for a molecular computer. Commun. ACM 28 (May), 464480.
Conrad, M., (ed.), 1992, Special issue on molecular computing.
IEEE Comput. 25 (November).
Drexier, K.E., 1986, Engines of Creation (Anchor Press,
Doubleday).
Dyson, R.D., 1978, Cell Biology, A Molecular Approach
(Allyn and Bacon).
Harary, F., 1969, Graph Theory (Addison-Wesley).
Laing, R., 1979, Machines as organisms: An exploration of the
relevance of recent results. BioSystems 11,201-215.
Langton, C.G. (ed.), 1989, Artificial Life, The Proceedings of
an Interdisciplinary Workshop on the Synthesis and Simulation of Living Systems (Addison-Wesley, Los Alamos,
New Mexico, 1987).
Lindenmayer, A., 1968, Mathematical models for cellular interaction in development, Parts I and II. J. Theor. Biol. 18,
280-315.
Moravec, H., 1988, Mind Children (Harvard University Press).
Toffoli, T. and Margolus, N., 1987, Cellular Automata Machines (MIT Press).
Turing, A.M., 1937, On computable numbers, with an application to the entscheidungsproblem. Proc. Lond. Math. Sot.
Second Ser. 42, 230-265.
von Neumann, J., 1966, Theory of Self-Reproducing Automata
(University of Illinois Press, Urbana, IL).