# Nanomechanical computation

Related topic: **Nanomechanic circuits**

## Contents

# Why nanomechanical logic

- It can be built smaller than nanoelectronics (bound atoms practically do not tunnel away like electrons)
- It is easier to do exploratory engineering about nanomechanics than nanoelectronics. (See: non mechanical technology path).
- nanomechanical manipulators are a necessity in APM systems anyway nanomechanical logic just defers electromechanical transduction step further to the top.

# Basic elements

### Differentials

One of the most important things in any computer are wires and forks of them.

The mechanical elements that correspond to simple electrical connections (solder points) are mechanical differentials (that includes planetary gear assemblies and linear versions of differentials transmitting reciprocative motion). The angular speed (corresponding to electrical current) distributes proportional to the loads (current divider).

A simple branch off from a gear-train via a contacting gear acts like fixed ratio DC/DC converter. A thing that can't be realized that simply in electronics. There you have either lossy load sensitive voltage dividers or you need to use complex pulse width modulation systems.

[Todo: add more electrical mechanical analogies]

### Testing element (gate)

As in electronic computation a single universal type of logical gate is sufficient to create any logic function. 'programmable logic arrays' (PLA) work that way. See: disjunctive or conjunctive normal form (DNF / CNF)

In a clocked gate the input moves a blocking part in the way of the output (or not). Both are spring loaded. (Instant chain logic gates work differently)

### Sequencing mechanism

The analog power-source must somehow be converted in a digital sequence. Too harsh jumps in acceleration (jerks) may increase power-dissipation.

Quantum dispersion through anharmonic potential (see: coherent states) is probably not to expect even at low temperatures [To investigate!]. A connected nanomechanical system will have a quite high mass in daltons.

# Reversible mechanical logic

Reversible mechanics means: whenever an elastic element (a spring) is de-tensioned it must feed back its stored energy into the energy source.

Testing a clocked reversible mechanical gate to check which state it is in is done via pulling pushing turning twisting or whatever against a potential steric hindrance obstacle that was put in place (or not) by the precedent gate . As long as the outputs are in use the inputs cannot be removed. If they would be removed all consecutive outputs would snap back - BAD. Thus the testing clock signal must rise like a bar graph display and one step at a time.

This is best done till an appropriate computation result is reached that has way viewer bits than the intermediate computation steps that lead there.
This result can then be copied into a storage register and the output deleted. Meaning a view testing springs snap back irreversible and release their energy into the background heat bath. [**wrong?**]

Finally one let the bar graph clock signal stepwisely recede letting go of the testing gates in reverse order and pushing back the energy into the energy source (e.g. a flywheel). One could say one un-computes the intermediate data garbage.

This hole process is called a **retractile cascade**

The energy swings back and forth between the energy storage and the many logic gates.
Tree like distributed though mechanical differenials. [**Todo:** other option?]

If the negated bits are always computated in parallel the energy stored in the springs in the gates when in evaluated state is always the same.
[can each rod pair made reversible independently?]
Swing overshoot can be made minimal. [**Todo:** explain in more detail]

In a programmable logic array (PLA) first the gates in the AND-plane and then the gates in the OR-plane must be evaluated in sequence. The results may be fed back into other yet unevaluated parts of the PLA for a second and further rounds.

### Drive for retractile cascade

Assuming rotative logic a possible method to generate the "bar graph display clock signal" may be like follows:

A binary tree of differentials to a locked chain of gears (blocked gears or geneva drives may be usable). All gears are spring loaded and only the first one is unlocked. the torque propagates through the differential tree and turns the first gear till the endstop. This in turn unlocks the second gear. Then comes the third and so on and so forth.

There are methods that don't use differential gears but still keep the driving force roughly constant.

### local or global energy backswing for reversible circuits

Reversible (rod) logic:

- can use local resonators that get continuously slightly replenished
- or global ones

The two methods can have different pros and cons. [**Todo:** add details]

# Concrete implementations

## Various approaches / proposals

- reciprocative rod logic
- rotative logic (lower maximum density of logic devices)
- pure flexture/buckling logic
- ...

## Zuse's Z1

The Z1 was the first and ony ever built truly mechanical computer with von Neumann architecture:
(link collection)

It does four step pipelining to be able to deliver practical throughput but this seems to make it irreversible [**Todo:** investigate this]

# Benefits of low friction

Mechanical logical gates can either be elements that form **instantaneous chains** or elements that must be evaluated by a **testing clock signal**.
Due to the exceptionally low friction of nanomechanical bearings it should be no problem to make instantaneous chains quite long.
Also Differential gear trees with log(n) depth shouldn't pose a problem out of this reason.

# Usage as analogous devices

- differentials act as analog adders
- gear ratios act as fixed ratio multiplication
- there's a linkage mechanism for continuous multiplication

These can be used in a digital fashion (much better) that is one enforces inputs and outputs to discrete values. These might be more compact tnan single bit representations (or might not). Conversion back and forth to single bit representation will take additional space.

[**Todo:** link old video]

# Logic circuits in general

- Ternary logic: It is not so hard to implement mechanically - it seems that pros an cons pretty much balance each other out. [
**Todo:**recheck a certain researchers work and put more detailed results here] - non naive multiplier networks are non trivial [
**Todo:**check whether a mechanical demo model can be built from mechanical gates without too much effort] - peadic numbers: IIRC There is a link to arbitrary precision computing IIRC

# Related

## The chain of reversibility up the levels of abstraction

There's a link

- from reversible physical computing (including nanomechanic circuits)
- over reversible assembly languages
- over stateless functional programming (like Haskell)
- to computer aided design embedded in an computer algebra system