Partial design for macro-scale machining self-replicator
Christopher J. Phoenix
Subject: Partial design for macro-scale machining self-replicator
Of course, a partial design for a self-replicator is a contradiction: you
don't know if it can self-replicate until you know the entire design. But
there's still some value in exploring a subset of the problems involved,
which is what I've done here. This is primitive and preliminary, but a
wide-ranging self-replicator site (http://lslwww.epfl.ch/~moshes/selfrep/)
didn't have anything better in this area (except a pointer to R. Freitas'
NASA work, which is a much larger scale of gizmo).
At 05:51 PM 12/3/97 -0500, Will Ware wrote:
>Speaking as a practicing engineer, I think there would actually be
>a lot of value to making macroscopic replicators, even if there's
>no new science involved. The absence of new science does not mean
>an engineering job is trivial.
You got me thinking. I'm probably missing something that will make it
harder, but here's a first attempt to design a system that could
self-replicate--including making its computer from raw materials. All you
mechanical engineers out there, please kick it to pieces and we'll see if
there's anything left.
The machine is more interesting if the output is clearly more complex than
the input. If we start with fabricated parts and put them together, we're
open to the objection that we're just doing a more complicated version of
building a robot that can insert batteries in robots. Therefore, the design
includes a machining capability, capable of making the whole machine from a
few simple shapes and substances.
Here's the intended capability: To machine blocks of soft material into
complex parts, with typical dimensions of a few inches, maximum dimension 20
inches, precision 1/100 inch, smooth circles of any diameter (made by
rotating a platform with a cutter held off-center); minimum hole/concave
curve 1/16 inch diameter, plus an ability to cut narrow V grooves. To
assemble parts into machines with volume of up to a yard cubed. To execute
a long, complex program for these operations, with the possibility of
detecting and correcting errors.
Here's how it does that: it has two arms with a three-foot reach, shoulder
and elbow joints, and grippers: a total of seven degrees of freedom per arm
(roughly the same as the human arm, if you wear mittens). It has a third
arm with X, Y, Z motion and 3 DOF rotation in the wrist, and instead of
grippers it's studded with various sharp edges including several sizes of
router/drill bits and a wheel that cuts a V-shaped groove (to make gears).
In addition, there's a work surface that's an X-Y platform on top of a
turntable, and has various clamps mounted to it (perhaps retractable hooks).
The platform and machining arm can move with a precision of 1/100 inch. I'm
not sure how accurate to make the rotating joints; an accuracy of one degree
in the shoulder allows an error of over half an inch when the arm is
extended, but perhaps the joints can be made force-compliant, which would
allow guides and stops to be designed into the pieces being assembled. The
grippers have three-bit position sensors to tell whether they've grasped
something; this can also be used for tactile feedback.
The control system is fairly straightforward: it's an 8086-class processor
with one KB of RAM and several punched tapes that it can read data or
instructions from. It causes the various manipulators to move by writing
numbers to registers.
Assuming I've described a plausible system, it's pretty close to being able
to self-replicate.
"But how can it build a computer?" "What about the actuators?" "You said
the material being worked was soft; what's the use of that?" "How big can
the program be?" "What's the power source?" "What's the working environment?"
One at a time, please. The easy ones first: the power source is pressurized
fluid. For working environment, the machine is immersed in the same fluid
(so leaks don't matter). The fluid should ideally have low viscosity and be
the same density as the material the machine is built of, so that the
machine doesn't have to resist gravity.
The material is some kind of plastic that cures under ultraviolet light.
This allows it to be worked soft and then hardened. I won't worry about
generating the UV light; there's a great natural source of it up in the sky.
Hopefully someone can name a material such that the hardened state can
easily machine the uncured state. The ideal material would be quite stiff
in the cured state, but also springy if it's made thin enough, and not
susceptible to fatigue.
Building a computer
--------------------
A computer is actually easier to build than it sounds. According to
http://belarus.net/Intel/MUSEUM/techspec.htm, the Intel 8086 processor has
29,000 transistors. That's probably under 10,000 gates. If you can build a
gate (and interconnects) in 1/2 by 1/2 by 5/8 inch, then you can fit 10,000
of them into a cubic foot. Now, how do you build a mechanical gate that
small? Well, there's a technology called "fluidics" that can build a small
gate with no moving parts! It uses fluid flowing through a cavity toward
one of several outputs, switched by weak streams injected from the side.
Start with square-foot sheets, 1/8" thick. Drill funny-shaped holes all
over the sheets. A stack of five should be enough to implement a gate (I
saw such a design in a magazine article long ago). A stack a foot high
requires only 100 sheets.
If you can build a memory cell using one cavity (I'm not sure of this) then
you can fit a KB of memory into another cubic foot. The cycle time of the
CPU would probably be pretty bad, but it could be thinking about the next
command while the current one was being executed.
You can fit quite a lot of information on punched tape. If each hole takes
1/16 inch square, then you can fit a megabyte on a strip two inches wide and
1400 feet long. If the tape is paper-thin (1/200 inch), this is a roll
less than a foot in diameter. At that rate, you could have several rolls to
allow fast switching between different subprograms. For example, one tape
contains the main instruction stream, and the second contains the
corresponding error routines; while reading the first, step the second to
the beginning of the appropriate routine. Use a third tape for data, so you
don't have to keep a lot of data in your (limited) RAM. (The use of tape
was inspired by one of Mitch Porter's web pages,
http://www.thehub.com.au/~mitch/extro/nano/assembler/assembler.html, though
he uses it for direct mechanical control.)
For an example of commercially available fluidics (using compressed air),
check out
http://www.air-logic.com/LogicControls.html: "Fluidic NOR Logic Elements A
basic element from which all logic circuits can be constructed. Plugs into
F-3802-60 Manifold Card. Fluidic Transverse Impact Modulator principle has
no moving parts, half-millisecond response, high recovery and fan out."
Actuators
----------
With fluid power, it's theoretically possible to build a very precise
(11-bit) force output from digital input. Just use each bit to valve fluid
to a piston with half the surface area of the next-higher bit. (All the
pistons push on the same bar.) If the smallest piston is 1/16" diameter,
the largest will be only 2" diameter. If this works against a very linear
spring, then you can get very precise position output as well; this could be
connected to a power steering-type follower to amplify the force.
Of course, a ratchet controlled by a counter could be used to produce linear
motion, or with gears (that's what the groove cutter is for), angular
motion. For faster motion (but maybe less precise), use a turbine-driven
gear train with a sensor to tell it where to stop.
Scaling
-------
Everything is mechanical, so the only scaling laws we need to work with are
stiffness, force, and fluid flow. According to Drexler (Nanosystems, p.
25), "[t]he shape of deformed structures is scale invariant." In other
words, we won't lose the ability to move precisely if the machine gets
larger or smaller. Also, acoustic speed is scale-independent, so the
computer should speed up as it shrinks. (Transmission of changes in
pressure happens at acoustic speed.) According to R. Freitas (personal
communication), "1 cm/sec is reasonable in fluids at macro OR micro scale."
So a machine that's half the size should self-replicate twice as fast.
On the other hand, it seems that wear life will stay the same: if a
cubic-yard machine can make only five copies before breaking down, a
cubic-inch machine can also make only five copies. (A smaller hinge or
bearing won't move as far, but will lose the same percentage of its life
with each motion as a large one would.)
If we assume that speed of motion is constant and all actuation is done by
hydraulic cylinders, fluid speed needs to stay the same regardless of scale.
Pressure can stay the same at all scales without rupturing the pipes (a
smaller-diameter pipe has less force trying to rupture it, even at the same
pressure). That means force generated by the piston will decrease
proportaional to the area of the piston head, and (for example) the force
that needs to be applied to a punch will also decrease proportional to the
area of the punch. As to mechanical friction, (Drexler again) "Assuming a
constant coefficient of friction, ... both stresses and speeds are once
again scale-independent." I don't know how to think about friction of fluid
flow, but "Molecular simulations indicate that liquids can remain nearly
Newtonian at shear rates in excess of 100 m/s across a 1 nm layer," whatever
that means.
In theory, it looks like this machine could be programmed to make smaller
and smaller machines until the precision of machining approached the size of
the monomers in the material: with a precision of 1 nm, the machine would be
about 3.6 micrometers on a side. But I'm not at all sure this analysis is
correct.
Other calculations and ideas
----------------------------
Tape copying: Assuming we can punch the tape and then cure it, it's easy:
just run the blank below the master, with a rack of punches in between;
probes poking through holes in the master push the punches to make holes in
the blank. (Because the master is much stronger than the blank, you don't
need any force multiplication.) Then you step the tapes. Add one extra
tape so that you can copy one while reading program and data off the
others. (If it takes 250,000 seconds to copy a tape [a whole second per
position], then put the first 250,000 seconds worth of data on tape 2, and
the remainder on tape 1; copy tape 1 first, then begin reading data off tape
1 while copying tape 2; after 2 is done copying, you'll start reading 3's
data stream off 2 while copying 3, and so on. This way you can copy four
tapes of 1 MB apiece in a million seconds without interrupting the
computer's access to three tapes.)
Dealing with wear: You can make a whole rack of spare bits and blades, and
change them at preset intervals. The arms will have to be designed to be
more accurate than the arms that machined them, to avoid errors creeping in
over several generations; this could be done by making loose, spring-loaded
joints (eg. a rod mounted to turn in a V, so that it wears toward the
point), and adjusting the effective length of various levers so that the
distance moved is correct. They could be recalibrated as needed. (This
sort of thing also makes it possible to build a smaller machine which will
self-calibrate to achieve positioning error suitable for its scale.)
Fluidics wouldn't wear out. Other parts hopefully wouldn't wear enough to
cause malfunction within the time necessary to copy the machine.
Parts count: A few hundred (very complex) parts for the computer gates,
plus another four hundred or so to run and copy the tapes. Maybe fifty for
each actuator (degree of freedom); the system has about 24 DOF, so that's
another 1200. Add maybe 100 for structure. Total, around 2,000 parts.
Note that many of the parts will be identical or repetitive, so we don't
have to provide separate instructions for making each part. A few megabytes
should be more than enough to specify the parts and their assembly.
Size: The computer should take less than three cubic feet. Three MB of
tape would be well under a cubic foot; multiply by four to leave space for
take-up reels and tape being copied. Since the system doesn't have to be
especially strong, the arms don't have to be bulky; figure three inches
square by a yard long: all three arms would add up to less than one cubic
foot. That leaves close to a cubic foot for each actuator if we want to
fit it all into a cubic yard.
Replication time: We probably need to limit motion to 1/2 inch per second,
since the whole thing will be under fluid. Constructing the computer and
replicating the tapes will consume the bulk of the operations; both of these
tasks involve short motions. (We could make the computer's construction
even easier by building cookie-cutters for the gates and channels.) So
figure one second per operation (at the original proposed scale). Twelve
days is more than a million seconds. Even with cookie-cutters, each level
of the CPU and memory (200 levels) will probably take 1000 operations
(moving and stamping) for 500 gates; that accounts for 200,000 seconds. For
2,000 parts, that leaves 400 seconds per part. It takes less than 200
seconds to move the finished part anywhere in the cubic yard and return the
arm; allow 50 seconds for placing the finished part, with lots of feedback
and error correction, and you still have 150 seconds to machine it. This
seems plausible.
So, what do you think? Where have I been grossly optimistic?
Chris
With many thanks to Robert Freitas for a brief review of an earlier version
and suggestions on structuring the presentation. He didn't have time to
work through my numbers, and he hasn't seen my latest version, so anything
that's wrong is my responsibility.
--
Chris Phoenix cpho...@best.com
Work (Reading Research Council): 650-692-8990; Home/voicemail: 415-860-1536