Kinematic Self-Replicating Machines

© 2004 Robert A. Freitas Jr. and Ralph C. Merkle. All Rights Reserved.

Robert A. Freitas Jr., Ralph C. Merkle, Kinematic Self-Replicating Machines, Landes Bioscience, Georgetown, TX, 2004.


5.9.4 Performance of Convergent Assembly Nanofactory Systems

As previously noted, all replicators are manufacturing systems which accept a stream of inputs and produce a stream of more highly organized outputs, which may include self. Factory-model replicators occupy major portions of the design space (Section 5.1.9) of mechanical kinematic replicators, including replication process centralization (I4), replication process specialization (I5), and the particity of both replicator (D10) and product (K8).

An attractive approach to factory-mode molecular manufacturing is to use convergent assembly [208, 213] to rapidly make products whose size is measured in meters starting from building blocks whose size is measured in nanometers. Convergent assembly is based on the idea that smaller parts can be assembled into larger parts, larger parts can be assembled into still larger parts, and so forth. This assembly process can be systematically iterated in a hierarchical fashion [1569], creating a manufacturing architecture that can span the size range from the molecular to the macroscopic. Of course, in practical systems some provision for error must be made during the assembly of larger parts from smaller parts; Crane [1584] concluded that if imperfect units were cast aside during a hierarchical assembly process, then complex structures could be produced without requiring high accuracy at any step.*

* But T. Hogg [856] notes that there is a tradeoff in efficiency: if the discard rate is too high, the rate of final production will be very low. Typically such situations have a fairly abrupt threshold in the probability of success vs. individual defect rate, as seen in studies of molecular electronics circuits formed via self-assembly for multiplexors and logic circuits [1554]. Simon [2867] has also discussed both natural and artificial modular structures.

It is common to make bigger things by assembling them from smaller things. A finished assembly which is about 1 meter in size might be made from eight smaller subassemblies each about 0.5 meters in size. The eight subassemblies could be assembled into a finished assembly by using one or more robotic arms (or other positional devices) in assembly modules depicted abstractly in Figure 5.14. Note that we are designating an “assembly module” by the size of its output port. The module size is larger – in this case, the 1.0 meter assembly module has a size of 2.0 meters. This additional size provides sufficient room to handle subassemblies and the final 1.0 meter assembly.

The first module at (A) is a single assembly module able to accept subassemblies from the four input ports to the right, and which produces a finished assembly to the left through the single output port. If the output port has a size of one meter by one meter, each input port would have a size of 0.5 meters by 0.5 meters. The second module at (B) shows two stages of assembly starting with 64 sub-subassemblies each with a size of about 0.25 meters, producing 8 subassemblies with a size of about 0.5 meters, and producing a finished product with a size of about 1.0 meters. The third module at (C) shows three stages of convergent assembly producing a final product of ~1.0 meter in size from 512 sub-sub-subassemblies each of which is ~0.125 meters in size. We can continue adding stages to this process until the inputs to the first stage are as small as we might find convenient. For the purposes of molecular manufacturing, it is easiest to assume that these initial inputs might be ~one nanometer in size – essentially, bulk chemistry inputs.

Now assume that the final 1.0 meter assembly module (A) which assembles the subassemblies into the final product takes about 100 seconds to complete its task. (The exact time selected is not crucial to the conclusions.) Then the 0.5 meter assembly module (B) should complete one subassembly in 50 seconds because an object which is half the size can finish a movement of half the length in half the time: its frequency of operation is doubled [208]. Each 0.5 meter assembly module can therefore produce two subassemblies in 100 seconds, so the four 0.5 meter assembly modules can finish eight subassemblies in 100 seconds, which means that both the 1.0 meter assembly module and the four 0.5 meter assembly modules must work for 100 seconds to produce the final product.

This progression continues in similar fashion for all remaining assembly modules. For instance, at the 0.25 meter assembly module (C) 512 sub-sub-subassemblies are assembled in sixteen 0.25 meter assembly modules, making 64 sub-subassemblies; these 64 sub-subassemblies are assembled into 8 subassemblies in four 0.5 meter assembly modules, and finally, the 8 subassemblies are assembled into the final product in the single 1.0 meter assembly module. Again, the 0.25 meter assembly modules operate twice as fast as the 0.5 meter assembly modules, and four times as fast as the 1.0 meter assembly module. The sixteen 0.25 meter assembly modules can make 64 sub-subassemblies in the same time that the four 0.5 meter assembly modules can make 8 subassemblies, which is the same amount of time that the single 1.0 meter assembly module takes to produce the finished product, thus establishing throughput closure (Section 5.6).

The following rules (modified and extended from Merkle [213]) hold approximately for a convergent assembly system which doubles the size of product made at each stage, starting with initial building blocks of characteristic length Lblock meters (e.g., Lblock ~ 10-9 meters, or one nanometer) with a characteristic assembly time to manipulate those building blocks of tblock (e.g., tblock ~10-7 seconds, or 100 nanoseconds) in an actual manufacturing system:

(1) Product Size. The size of product that can be made at stage N is:

and conversely, the number of stages required to make a product of size Lproduct from starting blocks of size Lblock is:

Hence the assembly of a product object of size Lproduct = 1 meter using building blocks of size Lblock = 10-9 meter requires a convergent assembly system (using this particular architecture) consisting of N(Lproduct) = log2(1/10-9) ~ 30 stages.

(2) Module Assembly Time. The time required for an assembly module in the Nth stage to produce an assembly of size Lproduct(N) (= 2N · Lblock) meters, given that eight subassemblies of size 2(N – 1) · Lblock meters are already available, is:

The exemplar values chosen for tblock and Lblock imply that the assembly of a 1.0 meter product (i.e., stage N = 30) from eight 0.5 meter subassemblies (i.e., stage N = 29) will require tmodule = 2N · tblock = 230 · (10-7 sec) ~ 100 seconds. We assume that the assembly process can be started when only four subassemblies are available, effectively allowing stage N to begin operation after stage (N – 1) has produced only half of the required subassemblies.

(3) Product Assembly Time. The time required to build a product of size Lproduct (= 2N · Lblock) meters, including the time taken by all preceding stages (i.e., assuming all stages start empty, with no assemblies or subassemblies in them, but that they have been provided with appropriate instructions for the manufacture of the desired product) is:

This is because the assembly modules at stage (N – 1) produce their first output in 2N · tblock seconds, whereupon the assembly process begins in stage N; the assembly process in stage N must then continue an additional 2N · tblock seconds before it can produce its first output, so the total time before stage N produces an output is (2N + 2N) · tblock seconds or 2(N + 1) · tblock seconds. Thus a 30-stage system (N = 30) should be able to produce a single meter-sized product in ~200 seconds. If we more conservatively assume that stage N cannot overlap any operations at all with stage (N – 1) – that is, stage (N – 1) must produce all eight subassemblies before stage N can begin to assemble them – then the time required for the Nth stage to produce its first output increases from 2 · 2N · tblock seconds to 3 · 2N · tblock seconds, only 50% longer, or ~300 seconds to produce a single meter-sized product in a 30-stage system with this exemplar architecture.

(4) Production Rate. A convergent assembly system can be pipelined, in which case a steady stream of finished products of size Lproduct (= 2N · Lblock) meters can be made at a rate of one new product every 2N · tblock seconds, a production rate of:

Thus a 30-stage system (N = 30) should be able to build a steady stream of meter-sized products at the rate of ~1 new product every 100 seconds, giving a production rate of Rproduction ~ 0.01 products/sec (e.g., tpipeline = 100 sec/product) with this exemplar architecture.

(5) Output Port Areas. The area of the output port Aoutput(N) of an assembly module equals the sum of the areas of each input port Ainput(N); that is:

The total area of all output ports throughout the factory at stage N is equal to the total area of all output ports throughout the factory at stage (N – 1).

(6) Materials Throughput Speed. The average speed with which material flows through the system is approximately equal at all stages, given by:

(7) Materials Flowthrough Path Length. Since the input material is in motion through the factory for tmotion = 2N · tblock seconds, then these materials travel a path length of:

(8) Convergent Assembly Factory Length, Volume, and Replication Time. Taking the width (and height) of the final assembly module output face as 2Lproduct and the length of the Nth stage as 2Lproduct · (1/2)N-1, then the minimum length and volume of the convergent factory are given by:

Assuming that 8 product objects each of volume Lproduct3 can be assembled to make a complete factory of volume Vfactory, then the replication time for a fully pipelined convergent assembly factory is given by:

Taking Lproduct = 1 meter, Lblock = 10-9 meter, and tblock ~10-7 seconds, then N(Lproduct) = 30 stages (from Eqn. 24), tpipeline ~ 100 sec (for N = 30, from Eqn. 28), Lfactory ~ 4 meters, Vfactory ~ 16 meter3, and tfactory ~ 1600 sec (~1/2 hour). Note that for N >>1, tfactory ~ (2N+4) · tblock.

Other methods for quantitatively estimating bootstrapping productivity or self-replicating factory output in various contexts have been employed by Akin and Minsky [964], Bock [2688], Criswell [953], Hall [225], Hewitt [957], Lackner and Wendt [1128], McKendree [973-975], Phoenix [2334], and Miller and Smith [2689].


Last updated on 1 August 2005