Design of a Primitive Nanofactory

 Journal of Evolution and Technology  -  Vol. 13 - October 2003  -    PDF Version
http://jetpress.org/volume13/Nanofactory.htm

Chris Phoenix
Director of Research, Center for Responsible Nanotechnology http://CRNano.org
 

Abstract:

Molecular manufacturing requires more than mechanochemistry.  A single nanoscale fabricator cannot build macro-scale products.  This paper describes the mechanisms, structures, and processes of a prototypical macro-scale, programmable nanofactory composed of many small fabricators.  Power requirements, control of mechanochemistry, reliability in the face of radiation damage, convergent assembly processes and joint mechanisms, and product design are discussed in detail, establishing that the design should be capable of duplicating itself.  Nanofactory parameters are derived from plausible fabricator parameters.  The pre-design of a nanofactory and many products appears to be within today's capabilities.  Bootstrapping issues are discussed briefly, indicating that nanofactory development might occur quite soon after fabricator development.  Given an assembler, a nanofactory appears feasible and worthwhile, and should be accounted for in assembler policy discussions.

Contents:
1. Introduction
2. Background
    2.1. Mechanochemistry
    2.2. Mechanochemical fabricator designs
    2.3. Parts assembly, scaling, and product integration
    2.4. Nanofactory overview
3. Components and Innovations
    3.1. A Thermodynamically Efficient Stepping Drive
        Figure 1: Pin Drive
    3.2. Joining Product Blocks
        3.2.1. The Expanding Ridge Joint
           Figure 2: Expanding Ridge Joint
        3.2.2. Functional joints
4. Nanofactory Architecture
    4.1. Mechanochemical functionality
        Figure 3: Workstation Grids
    4.2. The reliable basic production module
        Figure 4: Production Module
    4.3. Gathering stages
        Figure 5: Convergent Assembly Fractal Stages
    4.4. Casing and final assembly stage
        Figure 6: Nanofactory Layout
    4.5. Issues in bootstrapping
    4.6. Improving the design
5. Product design
    5.1. Levels of design
        5.1.1. Nanoparts
        5.1.2. Nanomachines
        5.1.3. Nanoblocks
        5.1.4. Patterns and Regions
        5.1.5. Folds
        5.1.6. Networks
    5.2. Simulation and testing
        5.2.1. Design and simulation
        5.2.2. Testing and debugging a nanofactory-built product
6. Control of the nanofactory
    6.1. Nanocomputer architecture and requirements
    6.2. Placing the nanoblocks
    6.3. Specifying the nanoblocks
7. Product Performance
    7.1. Strength, stiffness, and shape
    7.2. Appearance
    7.3. Complexity
    7.4. Design
    7.5. Powering the product
    7.6. Computation
8. Nanofactory calculations
    8.1. File size and data distribution
    8.2. Fabricator control, energy, and cooling
    8.3. Physical arrangement and mass
    8.4. Product cycle, duplication, and bootstrapping time
    8.5. Radiation and failure
    8.6. Cost and difficulty of manufacture
9. Conclusion and discussion
Appendix A. Calculations in software
Appendix B. Projections from the Merkle assembler
    B.1. Mechanochemical baseline
    B.2. Chemistry, electronics, and mechanics
    B.3. Mechanochemical error rate
References

1. Introduction

This paper builds on previous proposals to describe an architecture for combining large numbers of programmable mechanochemical fabricators into a manufacturing system, or nanofactory, capable of producing a wide range of human-scale products.  The proposed system is described in sufficient detail to allow estimation of nanofactory mass, volume, power requirements, reliability, fabrication time, and product capability and cost, as simple functions of the properties of the mechanochemical fabricator component.  Bootstrapping a human-scale system from a sub-micron system is also discussed.  Discussion of product design issues and nanofactory manufacturing capability demonstrates that the nanofactory should be able to efficiently fabricate duplicates of itself as well as larger versions.  This proposal differs from previous proposals in that, with the exception of mechanochemical component fabrication, design of the nanofactory should be within the reach of present-day engineering; physical structures and functional requirements are described in sufficient detail that remaining problems should be within the capability of current engineering practice to solve.  In particular, the design considers all transport and manipulation requirements for raw materials and product components, as well as control, power, and cooling issues.

This exploration can provide a basis for estimating the practical value and difficulty of developing a nanofactory.  As noted in (Merkle, 1999), even a primitive sub-micron mechanochemical fabricator may produce valuable products.  The question at hand is whether, once such a device is developed, it is feasible and worthwhile to adapt such devices into a nanofactory.  Since no complete designs, or even complete parameter sets, exist for a mechanochemical fabricator, this question cannot be answered fully at this time.  However, the results of the present paper can be applied to a wide range of hypothetical fabricator parameters.  As fabricator designs are proposed in increasing detail, these results will become increasingly useful in predicting the capabilities of a nanofactory based on such designs.  Issues of product design and manufacture are examined in order to establish that the nanofactory is capable of fabricating duplicates and larger versions of itself.  The time required to bootstrap a human-scale factory from a nano-scale fabricator cannot be estimated with any certainty, since bootstrapping will require time for debugging and redesign as well as for fabrication of larger versions.  However, the minimum time required for fabrication can be estimated, and the design developed here is simple enough that debugging and redesign may be fairly simple and rapid.

The paper is arranged in several sections.  Section 2 surveys previous work toward manufacturing systems relying on mechanochemistry and producing human-scale products.  Section 3 describes two innovations required for efficient operation of the nanofactory architecture.  Section 4 describes the nanofactory architecture, including a highly reliable production module incorporating several thousand mechanochemical fabricators and a scalable convergent assembly and transport architecture for integrating large numbers of production modules.  Section 5 covers issues of product design to establish that the nanofactory is designable and buildable by itself.  Section 6 discusses computer control of the nanofactory.  Section 7 covers product performance.  Section 8 provides calculations relating nanofactory performance and characteristics to fabricator performance and characteristics.  Section 9 summarizes the paper.  Appendix A is a computer program that implements repetitive calculations for probability, size of components, and pressure in cooling channels.  Appendix B is a brief discussion of the suitability of a proposed fabricator design (Merkle, 1999) for the nanofactory architecture.

2. Background

2.1. Mechanochemistry

In order to focus on nanofactory architecture, the present work does not consider mechanochemical operations in detail.  Instead, the design assumes the existence of a small programmable mechanochemical fabricator.  To simplify architectural considerations, the fabricator is assumed to be self-contained: it must be capable within a small volume of performing all mechanical motions necessary to fabricate parts from feedstock and assemble them into small devices of complexity comparable to itself.
 

2.2. Mechanochemical fabricator designs

The robot arm requires several different mechanical components, including small gears, triply-threaded toroidal worm drives, and several types of cylindrical sliding interfaces.  Each of these components may require significant atom-level design.  In addition, the robot arm requires a control system involving rotational motion on several drive rods.  Nanometer-scale clutches have not been designed in detail.  In order to provide results relevant to early fabricator and nanofactory development, this paper does not assume that devices of such complexity can be built.   Hall's parts synthesizer requires separate assembly robots to deliver chemicals, and the power/control mechanism is not specified.

Systems relying on many biologically-based feedstock molecules require separate synthesis and assembly areas, which may have quite different environmental requirements.  In addition, they may require nontrivial transport mechanisms to prevent premature reaction of the feedstock molecules.  Finally, such systems do not appear to permit the fabrication of diamondoid structures.

The molecular mill is an attractive concept for several reasons.  It does not require explicit control of each mechanochemical operation, thus greatly increasing efficiency over the other three proposals.  Operations can also be quite fast, since merely moving a belt a short distance is sufficient to accomplish a mechanochemical operation.  However, each reactive encounter mechanism, or station, in a molecular mill performs only one mechanochemical operation.  Although each station is efficient, in the sense of processing a mass equal to its own in a short time and with little energy wasted, a large number of stations would be required to fabricate all the parts needed to build a nanofactory, let alone the desired range of products.  This number has not been quantified.  Additional design would be required to explain how a number of stations performing different mechanochemical operations and using different parts can produce all the required parts for self-replication given that only one chemical operation is performed at each station.  Although this does not contradict the possibility of a self-replicating set of mills, it indicates that the set may be large and difficult to design.  In addition, the set may grow unpredictably when required to produce additional parts for the non-fabricator portions of the nanofactory, and may need significant modification if the design of a part must be changed.  Accordingly, a mill solution is not used in this paper.  However, it should be noted that a combination of a mill making small blocks and a double tripod capable of both joining blocks seamlessly (Drexler, 1992, sec. 9.7.3) and performing detailed mechanochemistry may be fast, flexible, and relatively easy to design, and would be preferable to the simple robotic manipulator implicitly assumed for this baseline design.

The current design effort is based loosely on a double-tripod "assembler" discussed by Merkle (1999).  Merkle's assembler is self-contained, simple to control, and approximately the right size for a basic factory or product building block.  Every effort has been made to avoid depending on any specific property of Merkle's design.  However, the claimed feasibility of this design serves as inspiration for the present effort to integrate designs with comparable functionality into a monolithic nanofactory.
 

2.3. Parts assembly, scaling, and product integration

Large-scale cooperative designs are not well understood today, and directing them may be expected to be difficult.  Hall (1993) describes a "utility fog" composed of many small identical robots.  Such a system would be relatively simple to manufacture, requiring no large-scale assembly.  Hall suggests that the fog could use any of several fairly simple algorithms to simulate solid objects.  However, he also does not consider how to power the product/object, and the control algorithms are not worked out in detail.  Also, his fog is quite weak for its mass, at least compared to a more strongly fastened diamondoid product.

The purpose of the nanofactory is to build strong, functionally rich, monolithic, human-scale products that are easy to design and use.  Several innovations described in this paper allow a nanofactory design to be presented in detail for the first time.  The nanofactory itself is intended to be in the set of possible products.  The paper focuses on early development and on demonstrably feasible designs, so does not include some obvious but currently speculative techniques for improving performance.  The design is deliberately simple, especially in minimizing the amount of mechanochemical design needed in addition to the preexisting fabricator.  The major design effort focuses on mechanical and digital design, physical layout, and fault tolerance.

Mechanical design methodology has achieved great competence in the transformation of mechanical motion and force.  Many devices have been developed to accomplish this, such as cams and followers, rack and pinion drives, planetary and differential gears, and pantographs.  Drexler (1992, chap. 10) demonstrated that many of these devices can be translated directly to nanometer scale.  However, many of Drexler's designs use a specialized arrangement of surface atoms, and sometimes of internal atoms.  Such devices would require individual chemical design.  To avoid the unknown but potentially large effort involved in developing new chemical synthesis for new mechanical structures, the present design does not generally assume the use of mechanical features smaller than ~1 nm.  Such a design is referred to as "bulk diamond", meaning that simply specifying a suitable volumetric design to be filled with diamond lattice is sufficient to specify a part with the required mechanical function.

Although a wide range of sensing and feedback technologies have been developed at the macro scale, some of them do not work at the nanometer scale (e.g. optics and electromagnets; see Drexler, 1992, sec. 2.4), and others may require excessive volume or complexity.  In general, this design effort avoids sensing in favor of predictability and reliability.  Digital logic is useful for performing repetitive functions, doing precise calculations, and selecting among alternatives using well-specified criteria.  Software systems that interact with mechanical systems may be hampered by sensor data that are not well specified.  Accordingly, this design does not make much use of feedback, or require software to deal with "fuzzy" situations.  Almost all aspects of nanofactory operation are deterministic; this mirrors the (theoretically) deterministic nature of the mechanochemical technique (Drexler, 1992, sec. 6.3).  Because the factory layout is extremely repetitive and strictly hierarchical, issues in controlling a large number of fabricators and robots can be reduced to controlling a single fabricator or robot, plus simple iteration.

As previously noted, this paper builds on work which demonstrates that a nanofactory is conceptually feasible.  The design presented here is sufficiently detailed that the feasibility of each part of it can be assessed.  However, it is sufficiently general that it can accommodate a variety of mechanochemical systems.  Where design principles are well understood, details are not supplied.  For example, the use of a gantry crane is specified in order to demonstrate the existence of robotics capable of doing the job required, and to allow approximate calculation of the mass of those components.  The drive mechanism of the gantry crane is not specified; however, given a design tolerance of 1 nm and the presumed feasibility of motors  as small as 50 nm in diameter (see Section 8.2), it is clear that such a mechanism can be designed in a wide range of sizes; at the present level of design, it is not necessary to examine work on industrial robotics.

The extreme conservatism that is appropriate for a feasibility demonstration is less appropriate for a preliminary engineering study.  For example, it is conservative to assume that each individual part will require individual design at the atomic scale.  However, it is reasonable to assume that in the case of a rod with bumps regularly spaced on it, the rod can be extended and bumps can be added or removed without requiring detailed redesign.  Thus the use of mechanical digital logic designs (Drexler, 1992, chap. 12) is assumed to require a mechanochemical design effort for only a fixed and relatively small number of parts.  Likewise, the quantitative sections of this paper choose typical or reasonable values instead of extreme or pessimistic values.
 

2.4. Nanofactory overview

The exact size of the nanoblock is unimportant.  For this design, a 200-nm cube is convenient: it is large enough to contain a simple 8086-equivalent CPU, a microwatt worth of electrostatic motors/generators, a shaft carrying 0.4 watts (Freitas, 1999, sec. 6.4.3.4), or the Merkle assembler (1999), but small enough to be fabricated quickly and to survive background radiation for a useful period of time.  As discussed in Section 6, the partitioning of the product into nanoblocks, and the use of relatively large sub-blocks at each step, allows the use of relatively simple robotics and control algorithms in the nanofactory.  As discussed in Section 5, such division also simplifies product design without imposing many practical limits on product complexity.  (W. Ware points out that a combination of tetrahedra and truncated tetrahedra is also space-filling, and that this may be more compatible with the tetrahedral diamond matrix.)

At the smallest scale, the organization of the factory changes to allow simpler distribution of feedstock, cooling, power, and control, and simpler error handling.  A production module consists of one computer and a few thousand fabricators.  It produces a few blocks, a few microns in size, by combining a few thousand nanoblocks.  These rectilinear production modules incorporate a few block assembly stages.  They are combined into the smallest factories, which are also rectilinear--and so on to any size desired.  At each stage, product blocks are delivered through the center of the smallest face, allowing compact stacking of multiple modules or stages.  The stages are stacked on either side of a gathering/assembly tube which contains simple robotics to join the incoming product blocks into larger blocks and deliver them out the end of the tube.  Two stacks of stages, plus the tube in between, constitute the next higher level stage.

The nanofactory design is highly repetitive: each input (sub-factory, or substage) to a stage is identical.  Thus only one design is required for each level, regardless of the number of substages at that level.  Since each stage joins eight blocks to form one block with twice the linear dimension, 19 sizes of stage (4 internal to the production module) are required to progress from a 200-nm nanoblock to a 10.5-cm product.  (One additional stage, a simplified gathering stage, is used to transition from production modules to gathering/assembly stages.)  Most of these stages perform identical block-joining operations.  The design of one stage may be used with minor modification for several similar stage sizes.

A nanofactory built with primitive fabricators and control systems may use a lot of power.  It will be cooled by a fluid with suspended encapsulated ice particles (Drexler, 1992, sec. 11.5).  Thus the temperature of the nanofactory will be a uniform 0 C (273 K).  This is significant for the energy used by digital logic (Section 8.2) and for aligning and joining large blocks (Section 3.2.1).

The control architecture of the nanofactory, like the physical arrangement, is strictly hierarchical.  Instructions can be distributed from central computers directly to the computers that directly control the fabricators.  All error detection and correction takes place either within a single nanocomputer or within a production module controlled by a single nanocomputer, and error reporting and compensation are not required beyond the production module.  There is no need for communication between any two computers at the same level; a simple tree architecture can be used to send all required data (Section 8.1).  Exotic or complex control algorithms, networking architectures, and operating systems are not required.

The size, mass, energy requirement, and duplication time of this nanofactory design depend heavily on the properties of the fabricator.  Sections 8.2, 8.3, and 8.4 quantify these relations.  With the assumptions made in those sections, a tabletop nanofactory (1x1x1/2 meters) might weigh 10 kg or less, produce 4 kg of diamondoid (~10.5 cm cube) in 3 hours, and require as little as fifteen hours to produce a duplicate nanofactory.
 

3. Components and Innovations

The fabricator used in the nanofactory is unspecified; the nanofactory design is sufficiently general that a wide variety of possible fabricator designs can be incorporated.  The reader may find it helpful to study Merkle's "assembler" (1999) (Appendix B) as a prototype.  The only requirements are that the fabricator must be capable of producing a variety of products of size and complexity equal to itself from soluble feedstock molecules, and that it use digital deterministic control, which implies that the mechanochemical processes must be highly reliable.  Since only a few reactions will be sufficient to make a wide variety of molecular shapes, and since error detection and correction will be difficult if not impossible in early broadcast-architecture assemblers, these requirements do not greatly reduce the generality of the present design.  (Unreliable operations can be retried multiple times even in a deterministic system; see for example Drexler, 1992, sec. 13.3.1c).
 

3.1. A Thermodynamically Efficient Stepping Drive

Figure 1: Pin Drive

An efficient drive with functional characteristics similar to the ratchet drive is the pin drive.  (See Figure 1.)  In this design, pins are inserted into equally spaced holes (or notches) in the moving bar to assure its position at all times.  The latching pin moves in and out but not sideways, and is used to hold the bar still.  The driving pin moves in and out, and also is moved sideways by a bar actuator over a distance equal to the spacing of the holes.  The pins are similar in structure and function to the rods in Drexler's rod logic design.  To move the bar one step, the bar actuator is moved to one end of its range, pulling the driving pin into alignment with a hole.  The driving pin is inserted.  The latching pin is withdrawn.  Then the bar actuator is moved to the other end of its range, bringing the next hole into alignment with the latching pin, which is then inserted.  Finally, the driving pin is withdrawn and then moved back to its original position.  Smaller step sizes may be obtained by additional offset pins, or by a second vernier drive, similar to the vernier ratchet drive described by Drexler (1992, sec. 16.3.2), with slightly different hole spacing and bar actuator range of motion from the main drive.  Larger step sizes may be obtained by moving the bar actuator a larger distance in each cycle.

Although the pin drive requires one more actuator than the ratchet drive--two pins and a bar actuator, instead of two ratchet pawl pullers--it has the advantage that it can move by measured steps in either direction, whereas the two-ratchet drive can only move stepwise in one direction and must retract in a single motion by lifting both ratchets.  (If both pins are lifted simultaneously, the bar can be moved without restriction by a weak return actuator, allowing the same rapid return motion as the ratchet drive.  Note that without careful design, verifying the complete return of the bar will require energy on the order of 100 kT.)  Similar redesign can be applied to any stepping drive mechanism.  As long as the position of the moving member is initially known, it can be moved stepwise, held stiffly against thermal noise at every point, and locked in place in its new position, all without irreversible state transitions.

While the pins are moving, the bar is stationary and the pins may be moved reversibly.  As the bar actuator is moved, the force encountered may vary.  Nevertheless, stiffly imposed motion will be efficient in most cases.  As long as the force profile of the motion does not vary more rapidly per distance than the stiffness of the drive mechanism, and does not vary substantially between forward and backward motion (e.g. due to an irreversible state transition), it does not matter how much force is required to move the bar at each point because the energy will be recovered when the motion is reversed.  This energy recovery requirement implies that the drive mechanism must be able to recover energy from being driven by the bar; such designs are not difficult, and include Drexler's electrostatic motor/generator (1992, sec. 11.7).  The same argument applies to other types of actuators driven by other digital control mechanisms: as long as the force profile is reversible and is less steep than the stiffness of the drive mechanism, the energy that is put into the system is recoverable.  Note that rapid motion causes the force profile to deviate from reversibility due to various energy dissipation mechanisms.  (The author thanks Eric Drexler for clarifying discussion of thermodynamic reversibility.)
 

3.2. Joining Product Blocks

At very small separations, two objects experience an attractive force called van der Waals force: simply bring them close together, and they stick.  For two flat diamond surfaces, the force is approximately 1 nanonewton per square nanometer, or 10,000 atm of pressure (Freitas, 1999, sec. 9.3.2).  This is reasonably high, although it provides only a fraction of the strength and stiffness of chemical bonds.  The van der Waals force is the simplest method of joining, it is reversible, and it should provide sufficient strength to keep even kg-scale products from falling apart under their own weight.  This type of joint is convenient and can be used for weak joining of structures that must later be separated.

A diamond surface that is not passivated with an outer layer of hydrogen will be very reactive.  Unterminated diamondoid surfaces forced together should form covalent bonds.  According to Drexler, two (110) surfaces of tetrahedral diamond or two (100) surfaces of hexagonal diamond should bond to each other on contact, forming a seamless joint (Drexler, 1992, secs. 8.6, 9.7.3, and 14.2.1).  Sinnott et al. (1997) report the results of simulations that show bond formation, though not seamless joining.  For other diamond surfaces, or in the case of too-rapid joining, a somewhat weaker joint may form with a lower bond density.  Also, it is currently unknown how much pressure would be required to initiate the process.  Crushing buckyballs to diamond requires 20 GPa, but Drexler states (personal communication, January 24, 2003) that a covalent joint should "zipper" itself if started at an edge or corner, that neon atoms should be able to escape the closing gap and would not interfere with the joining, and that argon is even better in this regard.  If the joint were comparable in structure to amorphous diamond currently made for MEMS, it would have a tensile strength of only 8 GPa (Sullivan, 2002); this is significantly less than diamond's tensile strength of 60 GPa (measured) to over 100 GPa (calculated, depending on crystal orientation) (Telling et al., 2000).  An additional problem is that radiation damage or stray molecules may cause local surface reconstruction or contamination that may hold surfaces apart and prevent a joint from forming.  This type of joint is usually not reversible, though in theory a carefully designed edge might allow predictable crack formation.  Since seamless covalent joints have not yet been demonstrated, the present nanofactory design does not use this method.
 

3.2.1. The Expanding Ridge Joint

Figure 2: Expanding Ridge Joint

The triangular shape of the ridges has several advantages.  First, the area of the base of the triangles (almost the entire area of the block surface) is structurally solid.  (By contrast, a square ridge would waste at least half of the structural strength of the blocks being joined, because the block area adjacent to the tops of the ridges would not contribute to the joint.)  Second, at small scales, van der Waals forces make handling of components difficult because the components stick to any manipulator.  With triangular ridges and narrow ridge tops, the contact area of the surface is much lower, reducing the van der Waals force.  Third, a manipulator can easily be aligned with the ridges.  Small blocks can be picked up by simple contact with a V-channeled manipulator that presents sufficient surface area to form a van der Waals bond of the desired strength, and the manipulator will automatically be pulled into alignment.  A more complex mating pattern could fasten on several ridges at once.  If the ridges are placed at varying angles or spacings, a well designed manipulator/ridge interface can guarantee that a misaligned manipulator cannot form a firm grip.  Likewise, a well designed ridge/ridge interface can guarantee that misaligned blocks will not join incorrectly.

There are at least three ways of mounting the ridge so that a small attractive force between mating ridges will be sufficient to cause the ridge to spread.  The first possibility is to join the ridge to the nanoblock with dovetail joints, permitting it to slide sideways with very low friction.  A simple dovetail joint costs somewhat more than half of the possible joint strength; a stairstepped dovetail joint (which is similar to a completed ridge joint) would recover much of the strength at the cost of additional volume and complexity.  The second possibility is to use a mounting that is strong in tension but flexible in shear, such as thin columns of diamond or buckytubes.  The third possibility, for use in linear stacks of many nanoblocks, is to build a solid structure extending from the base of the ridge all the way through the block to the ridge on the opposing face.  Both ridges would move in tandem, and be locked in place when the shims were dropped on each side.  This might require a mechanism for retaining all participating shims until all joints are pressed together.

The simplest version of the expanding ridge joint requires no actuation to form the joint other than moving the faces together.  As the faces are brought together, just before the final closure, each row of scallops brushes past the inverse row on the opposing ridge.  As the interlocking ridges from each surface interpenetrate, the bulges of the scallops brush past each other, close enough to be attracted by van der Waals force.  This pulls the halves of the ridge apart.  The attraction between passing scallops when the faces nearly touch must be stronger than the intra-ridge attraction, to ensure ridge spreading during the last phase of joint insertion, as the final rows of scallops pass each other.  This is ensured by the use of small spacers to control the van der Waals force holding the intra-ridge gap closed.  (The spreading will become increasingly favorable as the faces approach, and the operation will happen slowly enough to allow equilibration, so thermal noise will not cause the joint to fail to close.)  However, the intra-ridge attraction (between halves of the same ridge) must be strong enough in the initial position to prevent premature operation due to thermal noise.  The half-ridges must require a certain energy, say 100 kT, to pull them apart far enough for the shim to be inserted; the displacement which absorbs this energy cannot be greater than the depth of the scallop.  Note that the required energy is not dependent on any spatial parameter; it is related only to temperature.  However, the attractive force is approximately proportional to surface area, so this condition can be satisfied by a sufficiently long ridge joint.  In other words, regardless of the actual inter-scallop force, an intra-ridge gap can be chosen that will allow the ridge halves to be separated; and regardless of the gap, a sufficiently long ridge will be resistant to premature separation.

Due to the complicated geometry of the scallops, exact calculation of the attractive force between mating ridge halves is beyond the scope of this paper.  An inaccurate calculation is given to permit crude estimation of minimum ridge length.  The formula for attraction between cylinders (Drexler, 1992, Fig. 3.10f) will be applied, treating each scallop as a 0.5-nm radius cylinder separated by 0.3 nm.  (This is inaccurate because it ignores the attractive contribution from the material behind the cylinders, and because the formula's derivation assumes that cylinder radius is much greater than cylinder separation.)  The inter-scallop potential energy is calculated as 61 zJ per linear nanometer of scallop contact, which corresponds to 2 nm^2 of surface between the two halves of the ridge.  To reduce the intra-ridge potential energy to 50 zJ per scallop-nm or 25 zJ per nm^2, the spacing must be at least 0.6 nm (ignoring the attractive contribution from the spacer) according to the formula in (Drexler, 1992, Fig. 3.10d) which slightly overestimates the attractive force since the ridge is not infinitely thick.

When the gap between the half-ridges is fully open, the shim (which includes a hollow to accommodate the spacer) is pulled into the gap and held there reliably by van der Waals force.  The shim will insert when the ridges have moved apart by a distance equal to the depth of the scallop undercut, in this example 1 nm.  With a 1-nm deep scallop and a 0.6 nm initial gap (thus a 1.6-nm wide shim), the difference in potential energy between 0.6 nm and 1.6 nm spacing is 21.5 zJ/nm^2.  To prevent premature insertion, the intra-ridge potential energy of attraction must differ by 100 kT (260 zJ at 0 C) between closed and open positions.  This requires 12 nm^2 of intra-ridge gap.  If the ridge is 8 nm high (with 4 scallops), then it need only be 1.5 nm long.

The joint may be stiffened by compressing the joint volume.  In this case, extra force may be used to insert the shim into the gap.  (This also allows the gap to be somewhat narrower, reducing non-structural volume.)  A simple design for an electrostatic actuator adds only one moving part.  The shim is blanketed between insulated capacitor plates, one of which is flexible.  Charging the capacitor makes the plates pull together, expelling the shim like a watermelon seed.  The electricity to power the actuator can be delivered through contact with small embedded conductors at the proper time during the convergent assembly process.  The tip of the shim can be tapered to help spread the ridge halves.  Once the shim is expelled, the capacitor plates will adhere to each other by van der Waals force, forming a reliable barrier to hold the shim in the joint even if the capacitor is discharged.

Tension on the joint will tend to expand the entire joint volume sideways.  This can be constrained by surrounding each joint (not each ridge) with a diamond collar sufficient to resist the sideways force generated by a single ridge.  The ridge joint is somewhat less stiff in tension or compression than solid diamond would be, but should be almost as strong: failure requires either significant compression of a large volume of diamond, or the simultaneous failure of many covalent bonds.  Effectively, the entire joint volume except for the depth of the scallops and the width of the shim contributes to the tensile strength, and the entire joint volume except for the shim contributes to the compressive strength.  Shear strength and stiffness depend on the orientation and attachment of the ridges, but can be made quite high perpendicular to the ridge line.  Torsional and bending strength and stiffness can also be made quite high.

The width of the shim is unrelated to the size of the ridge, being equal to the depth of the scallop's undercut plus the intra-ridge van der Waals gap.  A reasonable lower bound for component size is a ridge composed of four scallops 1 nm deep and offset by 1/2 nm horizontally and 2 nm vertically.  The height of the ridge is 8 nm, and the footprint of a half-ridge is 3.5 nm (accommodating 0.5 nm of motion to mate with the opposing half-ridge), of which 2 nm contributes structural strength.  The 1.6-nm wide shim adds an additional 0.8 nm of non-structural overhead to each half-ridge; the total joint tensile strength is approximately 47% of solid diamond.  (Shallower scallops will improve this number up to a point; scallops that are too shallow can fail by slipping past each other.)  For reliable operation the ridge must be at least 1.5 nm long.  The smallest joint consists of one half-ridge on each side, only one of which (and its shim) needs to move; the rest of the joint including the mating half-ridge can be solid diamond.  A single joint can potentially have a footprint smaller than 3x6 nm.  Larger ridges can have more scallops, with the size of each scallop (and thus of the shim) staying constant.  For example, a half-ridge 20 nm high with 10 scallops has a footprint of 6.5 nm (plus 0.8 nm for its share of the shim) of which 5 nm is structural, for 68% of diamond strength.  Covering a 200-nm block with 8-nm-high ridges on each side requires 8% of the block volume (ignoring block edges and corners).  However, in a high-strength application that requires ridge joint coverage of the full surface, the block must be nearly solid diamond anyway.

Because the strength of the joint decreases only slightly with smaller size (the decrease is a function of the minimum shim, scallop, and van der Waals gap size), small ridges are mechanically adequate for joining blocks at any scale.  Minimum ridge size is determined by the mechanochemical fabrication process.  The only limitations on block size are the precision of the block-handling machinery and the possibility of unequal expansion of the faces due to temperature differences.  With 200 nm nanoblocks, ridges built in a single block can be up to 100 nm in height, with tops 50 nm apart.  (Note that the blocks will overlap by the height of the ridge.  The change in effective block width during assembly presents issues for the assembly process that are straightforward but beyond the scope of this paper.)  An assembly tolerance of 0.05 micron is somewhat beyond today's standards; current state of the art for automated pick and place assembly for optical components appears to be around 0.5 micron (Blaze Network Products, 2003).  However, today's pick and place systems use hardware made with a manufacturing tolerance comparable to its performance.  In contrast, the dimensional precision of the nanofactory's hardware will be approximately one atomic diameter or less, regardless of scale.  At large scales, single ridges can be assembled from multiple nanoblocks, allowing ridge spacing of multiple microns; this is sufficient even for today's robotics.

Differences in fabrication processes, assembly processes, and internal structure may cause different blocks to be at different temperatures.  The resulting thermal expansion can cause a misalignment of the ridges.  The volumetric thermal expansion coefficient of diamond is 3.5x10^-6/K (Freitas, 1999, Appendix A); the linear coefficient is one-third that, or 1.2x10^-6/K.  A temperature difference of 1 K thus causes a 200 nm block to expand by a small fraction of an angstrom, while a 10.5-cm surface will expand by 126 nm.  Because diamond is an excellent conductor of heat, passive equilibration may be sufficient.  As long as the displacement is not greater than the ridge spacing, or the ridge pattern does not permit improper joining, the blocks may be pressed together slowly, allowing the temperature to equalize.  Even a rarefied internal atmosphere will also facilitate temperature equalization between nearby faces, though this process may be slow depending on block mass, and the process will be somewhat slower with argon than with neon.  Note that the nanofactory is cooled by phase transition (see Section 8.2), so the cooling fluid will have the same temperature throughout the factory, minimizing potential product temperature differences.  Active compensation might involve sensing the temperature at various points on the surfaces and applying heat to the cooler surface via embedded resistive heaters; this will only be necessary for the few large-scale joints that take place near the end of the assembly process, and the heating process can be initiated in advance to avoid delay.  Embedded mechanical (bi-material) thermostats can allow each region to reach a preset temperature without individual attention.

Because the joints require no external manipulation or assembly force, they can be used to fasten non-bonded parts that are only loosely connected to the main nanoblock.  For example, a structural beam one micron long and 50 nm wide can be constructed in five sections.  Each section will be terminated in ridge joints, and laid across a nanoblock in a position that will place the section ends next to each other during block assembly; van der Waals force will hold the section in place during block manipulation.  When the nanoblocks are assembled, the ridge joints of the beam will join at the same time as the rest of the joints, with no additional effort.  This allows the inclusion of long, thin components in product designs.  Likewise, single nanoblocks can be made in separate pieces joined by van der Waals force.  This allows a block to be pulled apart during the unfolding process, forming multiple walls with large spaces between them.  This can be useful to save mass where only thin walls are needed.  If a block is split into as many as 10 walls or 100 columns, the 20-nm width is sufficient for multiple full-sized ridge joints on each part.  This capability is assumed for interior nanofactory structure.

Joints can be formed after the product is released from the factory, as long as contaminants have been excluded from the joint space.  The factory can manufacture a larger containing balloon for product unfolding, or the joints can be protected individually by a variety of covering mechanisms.  A product can be created in a very compact form, then unfold like a pop-up book or like flat-packed cardboard boxes.  Components can be built in pieces, with lightweight pantographic trusswork to bring the ends together as the product expands; once the ends touch, the strong joint will form. A component can also be made in a "broken" state, with mating surfaces held together on one edge with a small hinge at any desired angle, and the open end protected by a bellows if necessary.  When the component is straightened, the mating surfaces will form the desired strong connection.  A weak and reversible joint can be formed by preventing the shims from entering the gaps between the ridges.  This allows blocks to be loosely connected, then disconnected, and finally reconnected tightly in the same or different configuration.  This may be useful if the unfolding process requires a structure to be produced in its final conformation, then flexed, and finally fastened rigidly.
 

3.2.2. Functional joints

Embedded wires can be run up to a flat face, and electrical contact made by tunneling.  Contact can be maintained in the case of joint strain by the use of springy interfaces.  According to measured values for a sample of HOPG (highly ordered pyrolitic graphite), (GE Advanced Ceramics, 2002) graphite is about 5000 times more conductive in-plane than cross-plane (and the in-plane value is 1/50 as good as a typical metal).  The separation of graphite planes is 0.335 nm, about 1/600 of the 200-nm nanoblock width.  This implies that a graphite-graphite tunneling surface of 8 nm^2 per nm^2 of graphite wire, spaced every 200 nm, would only double the total resistance.  To save nanoblock surface area, the tunneling surface can consist of interlocking corrugations.  Because diamond is an excellent insulator, high voltages may be used to compensate for the resistance of graphite.  Some buckytubes may be better conductors.

Control cables and control rods will be built into each nanoblock when it is manufactured, and extend only to its edges.  Tension and/or compression must be transferred between blocks.  Nanocomputer logic rods have ends ~1 nm^2 which can be butted together.  The nanocomputer design uses tensional force of 2 nN (Drexler, 1992, sec. 12.3.3.b) but this can be traded for displacement or compressive force without sacrificing reliability.  Alternatively, the joint area can be increased by a few nm^2 to allow a few nN of tensile force to be transmitted through van der Waals attraction.  Crossing between blocks may require adding extra logic gates to transform and condition the signal; this logic can all be reversible at some cost of time.  Such interfaces will not add significantly to the power requirements or design complexity of a nanocomputer.

Polyyne (carbon chains with alternating single and triple bonds) control cables can be terminated with a small diamondoid plate flush with the nanoblock surface.  When the blocks are joined, the plates will stick by van der Waals force.  Each two atoms of polyyne spans a length of 0.2569 nm and has a compliance of 0.00185 m/N (Casing an Assembler, "Control cables").  A 1-nm diamond cube contains 176 carbon atoms.  A van der Waals interface has a stiffness of >30 N/m per nm^2 (Drexler, 1992, sec. 9.7.1), or a compliance of <0.0334 m/N.  Two hundred nm of polyyne contains 1557 carbon atoms and has a compliance of 1.44 m/N, while 198 nm of polyyne interrupted by two 1-nm diamond cubes interfaced by van der Waals force contains 1893 carbon atoms and has a compliance of 1.47 m/N; the interface increases cable mass by 22% and compliance by 2% (ignoring the hydrogen termination and internal compliance of the diamond cubes) and may introduce resonances into extremely high-speed operations.  The main drawback of the interface is its strength; the tensile strength of a polyyne rod is >6 nN, but the strength of the interface is ~1 nN.  Increasing the interface area allows a stronger and stiffer joint, and for joint areas above a few square nanometers a ridge joint can be used at some cost of mass.

Power can be transmitted by means of thin rotating rods, embedded in the nanoblocks like the control cables and logic rods.  Mating convolutions on rod ends will allow the transmission of torque between ends that are simply pressed together.  If the rod is driven near maximum torque, the interface may need to be somewhat larger than the cross section of the rod.  The bursting speed of a disc decreases in proportion with its radius, while the area increases as the square of the radius; thus a 2x increase in interface area will cause a 1.4x reduction in speed.  In this simple example, power transmission is derated by 40%; however, other mechanical linkages such as a thin belt connecting offset and overlapping rods may permit full speed while delivering full torque.  (The belt can be placed around one rod during nanoblock manufacture and held open by any of a variety of methods.  The other rod can be tapered to slip inside the belt during block assembly.  Interlocking (gear-toothed) rod surfaces will also work but may require significant overlap for reliable torque transmission.)  Rods and shafts larger than a few nm can be joined by ridge joints.  Ridge joints may also serve as a means of chocking the shafts to ensure proper alignment, and then unlocking them during convergent assembly: the shims can be inserted only when the joint is fully closed, and the motion of their insertion can be used to remove a mechanical chock.  Small rods can be controlled by adjacent ridge joints, and large shafts by facial joints with internal shims.

Bearing surfaces for rotating shafts small enough to be embedded in nanoblocks can be built into each nanoblock during construction.  Variations in rod diameter will prevent the rods slipping out of the block prior to convergent assembly.  Large rods pose a special problem for convergent assembly, since they cannot be strongly and permanently fastened to a support or bearing structure.  However, for products up to 10 cm size, a tight-fitting bearing surface between a rod and a housing can provide the necessary adhesion by van der Waals force alone.  Rotational freedom can be constrained by small retractable chocks.  Graphite pads covering the matching surfaces of the blocks constituting the shaft and the blocks constituting the housing can provide a bearing surface even for slightly rough curved surfaces.  However, the boundaries between the pads will be aligned on the moving and bearing surface, and this can create a significant force.  (Twisting one of the surfaces relative to the other would break the alignment, but this will not be possible for cylindrical bearings.)  Order-of-magnitude calculations can be made by treating the boundary gaps as regions of wider spacing between the surfaces, calculating the difference in van der Waals energy between aligned and unaligned regions, and dividing that by the width of the gap to find a force.  Approximating the boundary as a trench 1 nm wide and 0.1 nm deep and the pad spacing as 0.2 nm, and applying the formula from (Drexler, 1992, Fig. 3.10d), indicates an energy difference of 81 zJ per nm^2 in favor of the aligned state, or an average force of 81 pN per linear nm of trench.  One mm^2 of flat sliding surface will contain 5x10^9 nm of trench crossing the direction of motion, creating a force of ~0.4 N.  However, the stiffness of 1 mm^2 of graphite bearing surface is ~3x10^13 N/m, so for many macroscopic applications, bearings may be made small enough that the "roughness" is not a significant problem.  A cylindrical bearing surface cuts across two nanoblock planes and only a fraction of the area contributes to stiffness; these factors increase the number of trenches (and thus the "roughness" force) for a given bearing stiffness by approximately a factor of 4.

Pipes are simply voids in the diamond nanoblocks that are butted together when the blocks are assembled.  A flat, uncompressed interface between nitrogen-terminated diamond (111) surfaces is adequate to exclude helium (Drexler, 1992, sec. 11.4.2a).  If this type of interface proves inadequate in practice (perhaps due to joint flexure, or unavailability of nitrogen termination chemistry), a conical extension of the pipe wall wrapped in one or more layers of graphite to provide a compressive seal and extending into a conical depression in the other block should suffice.  Pipes too large to be contained inside a nanoblock can be sealed by diamond or graphite curtain walls, placed along each seam, to separate the interior of the pipe from the mechanical joint area.  If the nanofactory is filled with inert gas, pipes will also be filled with the gas when they are manufactured.  If this is a problem, one possible solution is to place a collapsed graphite tube inside the pipe, terminating the tube ends at the nanoblock faces with a diamond mating collar thin enough to be flexible.  When the blocks are assembled, the collars join.  When first used, the graphite tube will expand and conform to the walls of the pipe while displaced gas can be vented through small channels.
 

4. Nanofactory Architecture

The nanofactory is built hierarchically, using only a few scalable designs.  At the lowest level, a few thousand fabricators are arranged in a planar grid.  Their products are picked up and assembled into increasingly large blocks by a series of increasingly large robotic manipulators.  This plus a control computer constitutes a basic, reliable production module.  The production modules are stacked three-dimensionally into gathering stages, which assemble blocks and pass them to higher-level gathering stages.  Finally, the entire factory is enclosed in a suitable casing, with a mechanism to output product without contaminating the workspace.

In Merkle's convergent assembly architecture (1999) it is suggested that each convergent assembly stage has four inputs, each supplying two blocks to make one output block.  However, this means that each input to the preceding stage must supply four blocks to make those two, and so on.  This is feasible if blocks can be manufactured extremely quickly, or (as in Merkle's design) fed through a relatively small number of ports efficiently.  The current design, using large nanoblocks requiring minutes or hours to fabricate, uses only one block from each fabricator per product cycle.  This implies that each stage will receive all its blocks in parallel.  In general, then, each stage must have either eight (non-redundant) or nine or ten (redundant) inputs.  (The first gathering stage has only four inputs, to compensate for the eighteen inputs of the final stage in the production module; see below.)

4.1. Mechanochemical functionality

Figure 3: Workstation Grids

Fabricators will be fastened together edgewise to form the planar array, which divides the coolant volume from the working volume.  Cooling fluid with dissolved feedstock circulates past one side; the products (nanoblocks) are fabricated and released on the opposite side, which is open to the nanofactory's clean working volume.  A square of nine fabricators (one redundant) forms a stage.  Product blocks are picked up by a three degree of freedom gantry crane manipulator and assembled into a 0.4-micron block.  Likewise, a square of nine of these stages forms the next stage.  This continues through several levels; in the current design, four levels is chosen for suitable redundancy and convenient control.
 

4.2. The reliable basic production module

Figure 4: Production Module

The physical layout is similar in some respects to Merkle's architecture for convergent assembly (Merkle, 1999).  Substage outputs are be grouped on one wall of an assembly chamber, forming the inputs to the stage; substages are placed side by side, and stages are stacked on top of substages.  See Figure 4.  As in Merkle's design, the output from a stage is twice the width of each input; unlike Merkle's design, each input port delivers only one block per product cycle instead of two.  The design is not quite scalable, since the width of the assembly stage is three times the width of the sub-stage, while the width of the block that is produced is only two times the input block size.  The ninth substage is redundant, used in case of failure of another substage.  Four levels of redundancy are probably sufficiently redundant for a nanofactory of the size contemplated here.  Otherwise, more redundancy can be added in a fifth stage, or by extending a gathering stage; see Section 8.5 for calculations.

The module's top and bottom surface are completely covered with 9^4 = 81^2 = 6561 mechanochemical fabricators each.  To provide space for moving sub-blocks around a growing assembly, each stage is 3.1 times as high as the sub-block it receives.  Two of these assemblages are sandwiched together, sharing a single 3.2-micron assembly stage, to make one production module that produces two 3.2-micron blocks per product cycle.  The design can be compacted somewhat if multiple convergent assembly stages can be combined; such optimization is beyond the scope of this paper.  The CPUs, memory, DMA controllers, and motors are placed on the face that contains the output port, forming a single layer and extending the width by 0.2 micron.  Controlling a column of 81 fabricators requires perhaps a few billion bits per second and <100 pW (Section 8.2), which fits through an interface requiring only a few nm^2.  Only 4096 fabricators per side are used at any time; the rest are redundant, to be used in the event of radiation damage.  See Section 8.5 for further discussion of this design.  Powering the entire set of 8192 fabricators plus the computer requires 8 nW, far smaller than the 500 nW capacity of a single electrostatic motor.
 

4.3. Gathering stages

Figure 5: Convergent Assembly Fractal Stages

The factory does not require a hierarchical network of computers, since the computation is done either at the top level or at the level of individual production modules (see Section 6).  Once the blocks are fabricated, a fraction of the production module computers can be used to run the convergent assembly robotics.  If hierarchical computers are needed, the computers can be built into the tube walls.  Amplification will be needed to distribute the top-level signal to each of the production modules.  This can be implemented in each stage, and can be combined with a mechanism to send a unique, hard-coded position indicator to each production module.  By knowing which branch the signal takes at each stage, the module's computer can easily determine the position of its output in the final product.

A tabletop factory might produce a 10.5-cm product; this is 2^15 times larger in linear dimension than the 3.2 micron output of a production module, so product assembly requires 14 further assembly stages where each stage assembles 64 sub-blocks to produce eight product blocks.  See Figure 5, and Section 8.3 for dimensions.  A final stage, external to the factory, is described in the next section; it assembles eight 5.25-cm sub-blocks (per product cycle) to produce the final product.  Note that the first stage in the Figure is not an assembly stage, but serves only to gather 8 sub-blocks for delivery to the next stage, since each production module makes only two blocks per product cycle.  Each assembly stage gathers 64 sub-blocks from substages, assembles them within the assembly/delivery tube, and delivers the 8 assembled blocks to the superstage.  With the current size parameters, in some of the smaller stages, a minimum-volume arrangement leaves the tubes perhaps too short for simultaneous assembly of 8 blocks.  Four blocks may have to be assembled and passed on to the next stage, and then the other four assembled; this adds only fractionally to the total product cycle time.  The Stage 1 delivery tube is fractionally larger than the 3.2-micron product it carries.  The other assembly/delivery tubes are large enough to allow moving sub-blocks to fit past the product block under construction.
 

4.4. Casing and final assembly stage

Figure 6: Nanofactory Layout

The overall nanofactory shape is a rectangular solid.  The exterior shell consists of six flat panels enclosing the necessary volume.  Each panel provides support to anchor the interior and prevent the working volume from collapsing under atmospheric pressure.  (Cooling fluid pressure will be contained by the tension members crossing the cooling gaps, and will not put additional force on the external casing.)  This is equivalent to a 1-atm pressure difference between the inside and outside of each exterior panel, imposing a bending force.  In addition, the panels support each other, experiencing a crushing force at each edge.  The panels are hollow and pressurized.  Internal tension members, set at a slight angle, keep them rigid and flat.  Since the working volume contains the lowest pressure in the nanofactory, no pressure bracing needs to be installed inside that volume; the cables only intrude on the cooling channels.  With many small cables supporting them, interior walls can be very thin.  See Sections 8.2 and 8.3 for a discussion of structural mass and coolant and panel pressure.  Sufficiently numerous and thin cables (no thicker than the walls) cannot tear the walls; since the cables can be as thin as a buckytube, details of attachment need not be considered.

In the final gathering stage, multiple blocks (up to 8 per product cycle) are pressed together to form the final product.  The product must be delivered without allowing contaminants into the factory.  One way to do this is to produce a rectangular solid extruded through a sliding seal, as in the "replicating brick" approach of Merkle (Drexler, 1992).  This constrains product configuration, requires that all faces be smooth, and does not provide a protected environment for post-assembly unfolding.  An alternative design, permitting much greater flexibility in product shape, is to enclose the final stage in a balloon, the neck of which forms a sliding seal with the factory.  A new balloon is installed for each product, pushing the old one (with previous product) out and preventing contamination.  The mechanism of the final assembly stage must be extended for some distance outside the factory during final product assembly, but still requires only three degrees of freedom.  Once the product is assembled and optionally unfolded, the assembly mechanism is retracted and a new balloon is installed.

Most of the nanofactory mechanism is maintained at low or zero pressure to reduce drag on moving parts.  To allow balloon inflation, the final convergent assembly tube is used as an airlock, pressurizing it with pure neon or argon after all 64 sub-blocks have been delivered.   If low pressure in the factory is tolerable, the airlock need not be scavenged completely before the end of the next product cycle, and mechanical pumping will be sufficient.  If even a few atoms of noble gas cannot be tolerated in the factory or included in interior voids of the product, the airlock can be scavenged by use of a cryogenic surface; since neon and argon do not adsorb at room temperature, "bake out" is unnecessary and the airlock can be completely emptied of gas in a relatively short time.  The design of the assembly mechanism, airlock mechanism, and balloon installation is straightforward.
 

4.5. Issues in bootstrapping

Several imaging technologies may be useful.  Electron microscopes have a very fine resolution and form images rapidly, but use multi-keV electrons.  Single-wall nanotubes can be imaged in an electron microscope without apparent damage, but high-energy electrons may penetrate a single graphite layer and either do chemical damage to sensitive bonds or charge insulating surfaces, which could cause undesirable electrostatic forces that would probably interfere with operation.  Vapor deposition of metal on the outer surface of the fabricator before imaging may alleviate this problem.  Scanning probe microscopy may be useful for imaging the probes as they are aligned with the fabricator.  Non-contact AFM (atomic force microscopy) can avoid displacing the probes due to contact forces.  Optical interferometric methods may be useful for feedback on at least one dimension of alignment.  Finally, two-part fluorescent systems (e.g. absorber and fluorescer, or absorber/fluorescer and quencher), with one part attached to the fabricator and the other attached to the probe, may be useful for final alignment (Drexler, 1992, sec. 16.3.6c).  The number of probes to be attached is small--only four for the first several bootstrapping steps.

The moving-plate electrostatic actuator described in (Drexler, 1992, sec. 11.6.4) requires a plate area of only 150 nm^2 and provides 1000 zJ per actuation.  A 100 MHz cycle time requires 100 pW.  The actuator is powered by 5 volts, requiring a current of 20 pA.  This current is far lower than the 0.1 mA that has been measured in a single buckytube (Ipe Nanotube Primer, 2001), so buckytubes can be used to deliver power for initial bootstrapping stages.  A manipulation system like the Zyvex three-probe SEM manipulator (MinFeng et al, 1998) can place buckytubes with 6-nm precision on separate pads on the fabricator.  A ground connection can be made through the surface the fabricator rests on.  This can supply power for several actuators, which can control any number of internal systems if one of the actuators is used to drive a simple mechanical selector.

If the fabricator is in a dry environment, feedstock must be delivered via a closed system.  Hollow glass needles can be drawn as fine as 30 nm (Intracel LTD, 2001) which is small enough to interface directly with a single fabricator.  Two needles are needed to maintain a flow of fresh solvent past the molecular intake port; this accommodates designs that reject waste molecules as well as designs that use varying amounts of multiple chemicals during the fabrication process.  A housing over the molecular interface with two 40-nm holes partially closed by 10-nm graphite sheets should allow a leak-proof, though not strong, interface to the needle tips.  The tips can be positioned using the same kind of manipulator used to position the buckytubes, and held in place during the fabrication operation.

A single fabricator has space inside its casing to make two duplicates with separate shells.  Instead, it could fasten the two together, side by side, and combine the shells.  This would give roughly four times the internal working volume for the same area of shell, and the two fabricator stages could each produce two 200-nm blocks.  A single additional ratchet would select whether the actuation was to be delivered to one or the other fabricator, or both together.  (Either the electricity or the resulting mechanical motion could be switched.)  Most of the time, both fabricators could be working in synchrony, so the same control signals could be routed to both of them; duplication time would not be greatly increased.

Since the two fabricators are placed side by side, their products would also be adjacent.  When fabrication was finished, each double tripod would have sufficient range of motion to grab its finished product and move it into contact with the other.  A single 1 nm^2 contact area would apply 1 nN of force.  The weight of even a 10-micron cube, containing 125,000 nanoblocks, is 0.035 nN, allowing over 10 gravities of acceleration.  With small step sizes, torsion from off-center moving force can be relaxed after each step; since only a single motion of a few nm is needed, this will not significantly affect duplication time.

As the device grows, more different kinds of blocks will be required, but more electrical control channels can be added.  Blocks containing convergent assembly manipulators will be mostly empty space, so will not require much fabrication time to complete if they must be built one at a time.  An internal CPU will not be required until the stage where it is a small fraction of the overall device mass.  Once the device is sufficiently large that at least six control channels can be attached, the manufacture of the CPU and RAM can proceed in parallel with the manufacture of the fabricator blocks without affecting duplication time.

There are many suitable physical layouts for the medium-scale devices.  For example, mechanochemical modules could form plates to line the top and bottom of a wide workspace, with the plates separated by 800 nm.  Each module would make two nanoblocks, extending them vertically into the workspace until they touched the nanoblocks from the opposite side.  The resulting product would be four nanoblocks thick; each face of the nanoblocks would be either strongly fastened to its neighbor or weakly held by van der Waals forces.  When the product was completed, the tripods working in concert would pass it out one side of the factory which would open onto a balloon large enough for the product to unfold into a flat factory of twice the area.  A slightly more advanced design stacks several of these flat factories and includes a 1 DOF (degree of freedom) manipulator extending into the balloon to push together (and thus join) the product slabs after they have been extruded; this allows more complex unfolding.  The maximum workable size of this design is limited by radiation damage.  A factory of 16,000 fabricators (a suitable size for one nanocomputer to control, with the program downloaded in stages to save memory) may have a 1% chance of suffering a disabling hit to a single fabricator in a single day (see Section 8.5).
 

4.6. Improving the design

The current design is extremely wasteful of power.  It is also limited in the speed at which it can work.  The inclusion of "mills" for early-stage chemical processing (Drexler, 1992, sec. 13.3) can save orders of magnitude of power and significant time.  A mill does not require any computation to perform an operation.  Additionally, a mill can more easily recover energy from exothermic reactions, and even from the final stages of endothermic reactions.  With mills preparing small diamond cubes or hexagonal carbon chains that can be covalently bonded to each other (Drexler, 1992, sec. 8.6.5b), a hybrid mill/manipulator system could produce bulk diamond far more quickly and efficiently.  Because mills require both mechanical and chemical design, they have not been included in the current nanofactory design.

The inclusion of atoms other than carbon and hydrogen allows flexibility of design.  In particular, Kaehler brackets (1990) would allow more precise designs of surfaces and orientations.  To some extent, mechanochemistry can be developed by simulation in advance of fabricator availability.

Even without using additional chemistry, stepwise actuation can be made more efficient and faster.  Current design requires a separate operation for every step, and each operation requires computation and time.  A non-stepping mechanism might be an improvement.  For example, a set of stops could be included in the path of a sliding bar.  A chosen stop would be extended, all other stops disengaged, and a linear actuator used to move the bar rapidly until the stop is contacted.  The force profile of the actuator is problematic.  For efficiency, its force must be weak over most of the displacement, but for resistance to thermal noise, it must apply a strong force at the end of the cycle.  (A combination of a weak actuator and a slow but strong latching pin may also be efficient.)  An alternative is to use several drive mechanisms with varying step sizes, some of them large, or to design the pin drive so that in a single cycle it can move either one or several steps.

Many other mechanical and chemical improvements will be obvious.  The development of improved nanofactory models may be expected to proceed quickly, and manufacturing performance will also increase quickly.  Performance of products will increase somewhat as a result of continued research and development.  By several measures, products produced by the current nanofactory design are already within an order of magnitude of theoretical limits.  It should be noted that no part of the current design requires such levels of performance.
 

5. Product design

5.1. Levels of design

5.1.1. Nanoparts

One of the most complex components of the nanofactory will be the nanocomputers.  A nanocomputer of Drexler's design (1992, chap. 12) consists of only a few types of parts, including logic rods with varying combinations of knobs, a few kinds of springs, cams, a motor/flywheel, and a housing.   Although the computer may contain thousands of different rod configurations, all rod designs can be synthesized from knobbed and knobless segments; each additional rod thus requires only a few bits to specify knob positions.  Assembly of the parts into the nanocomputer will also be repetitive, as much of the circuitry consists of regular arrangements of rods in programmable logic arrays.  Translating from a digital logic specification to a mechanical hardware arrangement is straightforward.

Mechanical devices large enough to be specified with bulk diamond construction are also large enough that their strength and stiffness can be treated with classical approximations (Drexler, 1992, chap. 9).  Although other effects such as electron tunneling between conductors may be significant, a purely mechanical design can usually ignore them.  The main difference between nanoscale mechanical design and macroscale design will be surface effects including van der Waals force.

Nanopart designs may be parameterized.  For example, instead of a different part specification for each length of buckytube, a single specification can be given with a start, a finish, and a middle component that can be repeated as desired.  The nanocomputer logic rods are another parameterized part.  It should be possible to specify complex volumes of diamond in terms of geometric description.  As discussed in Section 6, the choice of whether to parameterize a part or to specify its variants separately will depend on a tradeoff between processing power and memory space.
 

5.1.2. Nanomachines

The level of nanomachines is not strictly necessary; parts could be assembled directly into nanoblocks.  However, the use of this level of specification causes no loss of capability and is convenient since human designers think in terms of machines.  A nanomachine specification, then, includes some sequence of nanoparts and sub-components together with a sequence of assembly operations that assemble the sub-components.  Sub-components may be considered as nanomachines in their own right; this saves space in the product description file, as one sequence of parts and operations can be included in several machines by reference.
 

5.1.3. Nanoblocks

In the current nanofactory design, a nanoblock is a 200-nm cube.  If a typical diamondoid part occupies a 10 nanometer cube (which has space for ~176,000 diamond-lattice atoms) then 8,000 parts can fit inside each nanoblock.  For comparison, a typical 4-cylinder automobile engine has ~450 parts (Whitney et al., 1998).  As in the nanocomputer design (Section 6.1), where the CPU occupies one cube and memory is placed in adjacent cubes, designs can often be broken along convenient planes and placed in adjacent cubes, communicating through pipes, small control rods, electrical wires, or larger mechanical interfaces.

The simplest nanoblock is inert--solid structural diamond, with full structural ridge joint coverage at one or more faces.  Another class of nanoblock is filled with digital mechanical logic; several nanoblock designs are needed to implement a nanocomputer.  A third class of nanoblock could be filled with actuators; a nanoblock full of electrostatic motors could convert a microwatt, and the same block would function as an electrical generator without modification.  Any nanoblock design could contain some volume for miscellaneous functionality such as a few gates of digital logic, a fan-out of a control cable with signal amplification, or simply passing a signal through; reserved volumes that are continuous between various block faces would be especially useful.  A fourth class of block would contain just enough diamond for rigidity of faces and support of interior structure; this would be used mainly to contain predefined nanomachines in novel arrangements, or to support convergent assembly operations.  Miscellaneous functionality could be specified by direct design, or by semi-automated design using macros and automatic placement and routing.  (In constrained volumes automatic placement would be more difficult.)  Predefined blocks and block classes could be extensively tested.  Spatial separation of functional units, either within or between nanoblocks, will reduce unexpected interactions.  Thus, most if not all nanoblocks in a product will be pre-designed (or contain predesigned components arranged according to design rules), easy to specify, pre-tested, and highly reliable.
 

5.1.4. Patterns and Regions

The simplest pattern consists of a single nanoblock type, with faces compatible with stacking.  More complicated patterns may specify repeated or tiled arrays of different nanoblocks; these may be used to implement (for example) a material with embedded strain sensors.  Patterns may be one-, two-, or three-dimensional, and may be designed to stack either with themselves or with other patterns.  Pattern specification can be recursive: patterns can include smaller patterns or regions.  In the design of the nanofactory, each convergent assembly stage can be represented as a single pattern, consisting of eight copies of the sub-stage pattern, plus the walls, braces, and assembly tube required to connect them.

Patterns of nanoblocks can be tiled to form virtual materials occupying regions.  For example, a structural material could have a nanocomputer per cubic millimeter, connected into a 3D grid, and strain sensors embedded in various nanoblocks.  A design for a single display pixel could be tiled to form a raster display of any desired size.  A useful CAD program will allow such materials to be designed, and then used to fill specified volumes; by this method, large, simple products can be specified with very little design effort and small file sizes.  (In any case, the size of the specification depends on the complexity, and not the size, of the region.)  A more sophisticated program would allow the algorithmic specification of complicated volumes, such as fractal trusses.  The nanoblock width of 200 nm is 100 times less than a typical human cell (Freitas, 1999, table 8.17); for most human purposes, a material specified in terms of whole nanoblocks would appear smooth, but partial blocks could be made as long as the convergent assembly mechanism was still able to grip them as needed.  Some machinery such as large cylindrical bearings will be improved by partial nanoblocks; lining the bearing surface of each block with graphite sheets will smooth out any rough edges left by bulk diamond fabrication.  (See Section 3.2.2).  For convenience in packing products more compactly, a simple extension of the concept allows two different patterns to specify different fractions of a nanoblock's contents; this allows patterns to interpenetrate or to stack tightly, and can be used to specify small parts attached to nanoblocks during fabrication but removed during unfolding.

Although the volume of nanotech-built machinery is far smaller than the conventional machinery required to perform a comparable function, some provision for redundancy will be required above the nanoblock level.  For example, generating 1 W of mechanical power requires perhaps two thousand cubic microns of electrostatic motors, which may receive a damaging radiation hit every few days (see Section 8.5).  The process of combining functional modules into larger modules that are tolerant of radiation will be a common design pattern.  The larger modules can then be combined into a second-order virtual material, if desired.

During convergent assembly, the product is assembled from sub-blocks into larger blocks.  Thus a 10.5-cm product is assembled from 5.25-cm blocks, which are assembled from 2.635-cm blocks, and so on.  However, the boundaries of patterns, and of regions, need not correspond to the assembly boundaries.  With ridge joints, nanoblocks can be assembled simply by moving them into contact.  This implies that any pattern should be able to be split along any assembly boundary, or conversely, that assembly boundaries can fall anywhere in any pattern.  In practice, two difficulties arise which may require some accommodation of the assembly method, depending on the product.

Spaces within a pattern or around a region may be left empty of nanoblocks.  A void may cause an assembly failure because of a thin or unattached piece adjacent to an assembly boundary.  Voids do not pose severe problems for the nanofactory design.  The nanofactory, as fabricated, will not include large voids, since it will be unfolded after fabrication (see section 5.1.5).  In product designs requiring voids, the voids may be filled with a scaffold of mostly-empty nanoblocks that can fold out of the way after construction.

Another difficulty is that assembly of large blocks may not allow sufficient precision to use ridge joints only a few nm in size; it is not yet known whether two isothermal cm-scale diamond faces can be aligned within a few nm across their entire surface.  Patterns and regions may have to be defined to accommodate larger joining structures, either alignment pins as suggested in (Drexler, 1992, sec. 14.2.1b) or larger ridges.  The nanofactory structure is simple and repetitive; if larger joint mechanisms are necessary for the final few joints, they can be inserted into the design at many points.  The design can be stretched as necessary so that the large joining mechanisms fall in permissible places.
 

5.1.5. Folds

The nanofactory will be manufactured in a collapsed state and then unfolded.  The nanofactory consists of filled nanoblocks (computer components and fabricators), walls, bracing cables, and convergent assembly robotics of various sizes.  The fabricator arrays are all co-planar.  The interior of the production module is empty except for the first four stages of convergent assembly robotics.  Gantry crane robotics are basically linear, and can be folded more or less flat.  The nanocomputer face of the production module can be folded in half.  Similar manipulations are carried out for all factory components, allowing them to lie flat in a "crushed" configuration.  Note that a solid wall can be "crushed" without strain, since it is manufactured in the crushed position and the mating faces of the "crease" do not meet until unfolding is almost complete.

To visualize the initial collapsed configuration and the unfolding process, it may help to imagine crushing a finished nanofactory.  The factory is crushed perpendicular to the plane of the fabricator arrays.  The robotics inside the production module fold up, as do the bracing cables spanning the cooling channels.  The wall of computers, which is perpendicular to the crushing direction, folds in half.  As the crushing continues, the convergent assembly tubes running parallel to the crush plane fold along their length, and perpendicular tubes split along the edges and fold accordion-fashion.  The robotic equipment contained in the tubes was made of hollow girders or thin pieces designed to be easily crushable; it folds flat.  The large unused volumes of the factory adjacent to the assembly tubes are filled with a 3D network of tension bracing and/or a network of tubes to carry fluid across the gap.  This structure detaches from all but one or two of the walls and collapses in on itself.  When the factory is as flat as possible, it is then crushed from the sides.  The production modules are already as compact as they can get.  The tubes that were accordioned now buckle, and the structures in the adjacent voids compress further.  The tubes and other structures form layers only a few nanoblocks thick over blocks of mostly solid fabricators and computers.  During the unfolding, this hypothetical process is reversed.  Since functional connections are all press-fit, and ridge joints require only to be pushed together, connections can be formed during the unfolding process as blocks come into contact.  As long as the unfolding mechanism is capable of aligning the joints properly (note that guides can be used for final alignment), the nanoblock joining process during the unfolding stage is as simple, flexible, and reliable as during the convergent assembly stage.

Thus each production module and assembly tube will be constructed in a collapsed configuration, and unfolded/expanded after construction.  Note that convergent assembly boundaries do not have to be aligned with tube, substage, or module boundaries; a subcube may contain part of a module and part of a tube, to be joined with the corresponding parts during a later convergent assembly stage.  As constructed, some wall junctions will be hinged together, and some will be initially open but will join as the factory expands.  As discussed in (Drexler, 1992, sec. 11.4.2), unbonded diamond surfaces pressed together can exclude even helium.  Larger nanofactory structure--large assembly tubes, cross-bracing for voids, and exterior panels--can also be constructed in a collapsed state.  Interior cross-bracing for large pressurized volumes must run in three orthogonal directions, attached to six walls.  During construction, it will be fastened to two opposite walls which are collapsed together, with the other four walls folded away from it.  As the walls are pulled apart, the bracing expands, placing ridge joints attached to it in the right position to meet the other four walls as they move into position.  More bracing will be required in wider voids, which will be adjacent to larger tubes with bigger robotic components.  Any remaining gaps can be filled with hollow nanoblocks to facilitate assembly handling.  If the nanoblock volume is slightly larger than the fabricator volume, then the adjacent module components (the bracing on one side of the fabricator wall and the robotics on the other side) can be compacted into the same nanoblock as the fabricator; this would allow a collapsed production module to be only two nanoblocks thick.  Alternatively, the adjacent module components might be constructed to one side of the fabricator planes, and inserted and joined during the unfolding process.

For many products, the unfolding stage can be quite simple, or even unnecessary if the finished size is smaller than the factory's volume capacity.  However, the process may be arbitrarily complex if the parts require substantial rearrangement in order to form the finished product.  This is not a severe limitation on most products, since unfolding complexity can usually be traded for larger manufactured volume.
 

5.1.6. Networks

In products, it may sometimes be necessary for several functional networks to interpenetrate the same volume.  Identical networks can be offset by a certain displacement to avoid collision; however, networks may be of different scale, topology, or even character--one may be fractal and another gridded.  As long as the containing volume and cross-sectional area are much larger than the volume and area required for network functionality, and the network specification contains rules for bending channels, the problem will probably be locally solvable.  Once a nanofactory exists, the amount of computing power required to verify the existence of a solution in every crossing point in a design will not be expensive.  A class of nanoblocks may be defined with volumes reserved for networking connections to be filled in by the CAD software.  (W. Ware suggests, by analogy with FPGA's, the use of nanoblocks whose function is "programmed" by a set of actuators to make or break various mechanical or electrical connections.)
 

5.2. Simulation and testing

5.2.1. Design and simulation

Digital hardware design provides an example of the effects of design cycle time and cost on simulation effort.  An ASIC (application-specific integrated circuit) is a kind of chip that can contain very complex and fast circuitry; it is custom-designed for each product.  Once simulation is completed, an ASIC may take several months and thousands of dollars to construct, and it may be useless if it does not work perfectly.  A team of ASIC designers will frequently spend months simulating their design before beginning production.  An FPGA (field programmable gate array) is similar to an ASIC in complexity, but is general-purpose and programmable: its design is specified by a file that is loaded each time the power is turned on.  Changing the functionality of an FPGA requires only a few seconds.  As a result, an FPGA designer may not do any formal simulations at all, preferring to simulate mentally during the design process, find problems during testing, and fix the problems in a subsequent design/compile/load/test cycle.

Simulation of the behavior of individual atoms requires specialized, computation-intensive techniques.  These techniques are rapidly being developed, but their correct use still requires specialized training, and it is probably safe to say that most product designers will not find quantum chemistry intuitive.  Nanoparts, and some nanomachines, will have to be simulated extensively to ensure that they will not break under unexpected use, and to develop a suitable mechanochemical manufacturing process.  This will have the effect of keeping the number of different nanomachines small.  However, a variety of different nanoblocks can be built from only a few nanomachines.  Only a relatively small palette of nanoblock classes, implementing a few basic functions, will be required to build a large range of products.  Even for components smaller than a nanoblock, simulation may be simplified by the use of simple, well-understood mechanical structures such as diamond lattice: diamond shapes larger than a few nanometers should have properties nearly equivalent to those of bulk diamond (Drexler, 1992, Sec. 9.4).  To the extent that simulation is necessary to test a nanomachine assembly sequence, a simple rigid-body simulator will usually be sufficient.

Although few or no additional mechanochemical techniques will be necessary to bootstrap a nanofactory from a working fabricator or to build a wide variety of products, the performance of the nanofactory and of some of the products can be increased as new chemistry is developed.  Much of the new chemistry will be localized, and simulable in standard chemical packages.  However, at least one useful class of device, bearings with strained shapes and lattice dislocations, will probably require both chemical and mechanical simulation.  This is beyond the scope of this paper and requires further study.  Several classes of bearings have already been analyzed (e.g. Drexler, 1992, chap. 10; Merkle, 1993) although mechanochemical fabrication sequences have not been proposed.  A proposed molecular planetary gear has already been tested in simulation (Cagin et al., 1998).

A well-designed nanoblock will have a simple, well-understood function.  Once a nanoblock has been designed, simulated, and tested, higher-level design and simulation systems can work with its simple functional characteristics (includi