Path: utzoo!attcan!uunet!cs.utexas.edu!rutgers!aramis.rutgers.edu!gatech.edu!vorth%sybil
From: vorth%sybil@GATECH.EDU (Scott Vorthmann, ttyXX)
Newsgroups: sci.nanotech
Subject: Ye olde matter duplicator
Message-ID: <8906150843.AA06285@athos.rutgers.edu>
Date: 14 Jun 89 02:26:25 GMT
Sender: nanotech@aramis.rutgers.edu
Lines: 76
Approved: nanotech@aramis.rutgers.edu

"Ron_Fischer.mvenvos"@XEROX.COM writes:

> Indeed, one of the interesting things about assemblers is that they make
> the value of unique physical objects as ephemeral as information.
> Currently the difference between information and physical objects is that
> when an object is sold its gone.  When informatoin is sold you still "have"
> it.  With nanotech this no longer holds true for objects, since you can
> easily keep the information needed to reproduce a perfect copy.

I disagree, in way.  You can keep a perfect copy (easily?), but you cannot
easily keep the information needed to produce it.  Many (or most) objects
_are their own most compact representation_.  Take a statue by Michelangelo,
for example.  The atoms in the marble are in no particular pattern; how could
you hope to represent their relative positions more succinctly than they
themselves represent this information?  Even with a molecular representation,
possibly compressed much as video images are compressed today, the "program"
to produce the statue should be at least 10 times as massive as the statue
itself!

There are several issues to consider here.  First, what do we mean by
a "perfect copy"?  If we mean "faithful to the original, down to the atoms",
we will have the problem outlined above.  Even if we say "exactly the same
within 5cm of the surface", we still have an unworkable amount of information.
Naturally there are other compromises we can make.  Many substances have some
microcrystalline structure:  we can exploit this regularity using the
equivalent of "FOR" loops ("DO" loops for FORTRANers) in our "program".
However, the boundaries of the microcrystals will typically still be
irregular.  In general, it is an extremely difficult problem to 'derive'
a succinct "program" from an artifact.

Assuming the last statement is correct, it is clear we won't be 'digitizing'
objects, but rather making copies.  Here the problem is that we will usually
have to dis-assemble and re-assemble the object to make a "perfect" copy.
Even if the atoms are removed, recognized, duplicated, and replaced in
"bites" of a hundred, is the Louvre going to allow this?  We'd better have
some pretty strong guarantees about the robustness of the process.  I have
seen some mention of duplicating human beings in this fashion... hmmmmm, I
think I'll clone myself the good old-fashioned way, and cryosleep for 20 years.

The issue of making perfect copies of objects is only a problem of this
magnitude for objects for which we don't have a program; that is, objects not
initially constructed by assemblers.  Presumably, our wonderful
nano-engineers can write VERY concise specifications of the molecular
structure of artifacts containing gazillions of atoms.  If this is the case,
then Mr. Fischer's observations hold, but ONLY for artifacts for which programs
exists.

But how small can we expect an assembler program to be?  Remember, we can
expect to be building artifacts ranging in sizes over 12 orders of magnitude,
or so (nanometer to kilometer sized).  Naturally, these programs
will have to be hierarchical in nature, to take advantage of large regions
of homogeneity (at various scales).  For instance, Drexler's rocket engine
(EoC, 2nd chapter or so) may be made of 'active' materials, containing
fibers that are really nanomachines.  The program might say "make a region,
in this shape, of Von Hoozitz fibers (parameters W, L, 3.459e8, 39'12''),
in such-and-such a pattern".  The "Von Hoozitz fiber" subroutine would call
other, lower-level subroutines.  Good old block-structured design of
software, where "lower-level" takes on a new strength of meaning.

...Except that we may want all interfaces between different sub-assemblies to
be specified at the molecular scale, to guarantee structural integrity.
If we really want to specify the position and bonding of every atom in the
artifact, we will have to pay the piper at some point.  I would be
unsurprised if the rocket engine program, in its most compact representation,
weighed about a pound.  Of course, this may still be workable, if
"subroutines" are actually armies of sub-assemblers, each with its own
short "tape loop".  A centralized coordinator, containing all the code,
with communications channels to vast hordes of assemblers, does not seem to
be a reasonable approach.

Enough rambling.  I hope you see my point.  Furthermore, I hope there's at
least some measure of sense in what I've said.  If not, I apologize.

	Scott Vorthmann
	Ph.D. candidate, School of ICS, Ga. Tech
	vorth@gatech.edu