By the time proteins can be custom-designed to meet whatever manufacturing need arises, the need for purifying products will vanish because it will be possible to arrange self-assembly of macroscale structures as is seen in biology.

To Dr. Drexler:
“Productive, reaction-producing molecular encounters occur more frequently when the reactants are constrained to close proximity than when they are released to diffuse in the solvent.”

That depends on how much solvent you have. If you’re dependent on a particular product being passed from enzyme to enzyme, and a Brownian collision knocks it off of the machinery (which I would expect to be a relatively frequent occurrence, given the violence of Brownian motion and the need for the product being passed to be relatively weakly held), it’s completely lost if the process occurs in a large solution. In a smaller compartment such as a cell, however, diffusion is a perfectly effective way to transfer molecules from one enzyme to the next, and it conveniently allows the enzymes to be located anywhere within the cell. After all, releasing two molecules at opposite ends of a 1-micron cell will result in their interacting within 1 second. (Need them to interact faster? Just decrease the size of the cell.) I honestly see no reason why molecular assembly needs to resemble current manufacturing at all, when the same results can be had with significantly less effort by co-opting nature’s flawlessly engineered methods.

Now here’s the interesting bit: a machine to set the selector switches may itself be following a fixed trajectory. Thus, stepping through a long sequence of switch settings may incur no computational cost, as long as the data for the sequence is pre-existing in the machine, either built in, or pre-loaded into a memory. The cost to load a sequence of switch settings into a memory is not zero, but if the sequence is to be re-used many times, the cost per operation can be arbitrarily small.

A very loose analogy is the way a DMA controller can transfer large amounts of data without requiring CPU operations, though of course today’s DMA controllers do not use reversible logic.

The design space of polymers is ridiculously large. Out of trillions of possible combinations, there may be a dozen Kaehler brackets that the designer wants to use over and over. Pre-load the recipes for those brackets, and your non-computing stepping machine can build any bracket any time on command.

Go back one more level, and sequences of brackets may themselves be transmitted without computation, to build standard housings and such. But if someone invents a better housing design, you don’t have to redesign and rebuild the mechanical components of your factory, just download a new recipe (at non-zero but trivial cost).

I proposed a similar system in my “Primitive Nanofactory” paper: http://jetpress.org/volume13/Nanofactory.htm

A Jacquard loom is an example of a machine that has a small repertoire of operations, selectable by outside input. In such a machine, the operations are designed in advance, but the selection of the operations is made while the machine is running. (Again, I’m not trying to argue that such machines are small or simple – just that they don’t have to incur kT bit-erasure losses. The theoretical computational cost is zero, though the mechanical energy cost of friction won’t be zero.)

It’s worth noting that a machine may store lots of internal state as it works – indeed, the entire mechanical configuration of any mechanical system can be viewed as its internal state – but traversing a set of states along a fixed trajectory does not have to cost any bit-erasure energy. This includes things like counters that count to a pre-set value.

So we could imagine a “programmable” molecular fabrication system as a two-part machine, where the first part is analogous to a Jacquard loom and the second part selects the set of data to be processed next. The first part would perform sequences of operations, each operation being fixed at design time, and the sequence being controlled by the data fed in. The second part would simply send “cards” to the machine, one at a time. It would have a memory store for card stacks, and a counter that presented the cards to the first part by setting the switches. Which stack of cards it presented would be controlled by – guess what – externally set selector switches.

Suppose the mechanical end-effector of your fabrication system can do any of sixteen mechanosynthetic operations including NO-OP, depending on the configuration of four knobs presented to it by other machinery. There is no computational cost in this part of the system – no bit erasure – the machine is simply following trajectories that are fixed for the duration of the trajectory.

A 128-bit (16-byte) recipe can be viewed as a sequence of 32 instructions. For example, it could represent a sequence of up to 32 Schafmeister monomers to be added to a polymer (from a palette of up to 15 distinct monomers).

A mechanical system can be built that will step for a fixed range (set by external selector switches) through the contents of a (mechanically stored) memory, presenting it four bits at a time to an output device. Since the sequence of presentation is fixed, there’s no theoretical kT cost to run the counter/stepper. Presenting four bits – for example, trying to drive spring-loaded rods past cams, where the end of each rod is the knob that “programs” the first machine (“loom”) – is also reversible. (This design, of course, is inspired by the computer chapter of Nanosystems.) So this recipe-presenter system requires no computational cost, assuming the recipes are pre-loaded and the recipe-selector is externally presented.

A system with 512 bytes of storage – comparable to the earliest electronic computers, which were built one vacuum tube at a time – could store up to 32 16-byte recipes (perhaps Kaehler brackets), and present them one recipe at a time, one step at a time, to a fully deterministic mechanical molecular fabrication system.

A single five-bit code presented to this system can control the deposition of up to 32 monomers. Repeated presentations of codes will add further strings to the polymer. The design space grows rapidly.

For the energy cost of copying 512 bytes of data once – trivial – this system can deposit up to 32 monomers, according to one of 32 recipes, for every five bits presented to it. Clearly, this fits most people’s definition of “programmable.” But the system does no actual computation on the data – it just mechanically follows what it is given.

Again, I am not proposing that such a system would be useful. I am only arguing that long strings of data can be can be used to select sequences of operations out of a huge design space, at a computational cost of well under one bit per operation.