Beruflich Dokumente
Kultur Dokumente
Introductory Chapter
Introduction:
In most computing tasks, the number of output bits is relatively small
compared to the number of input bits. For example, in a decision problem, the output
is only one bit (yes or no) and the input can be as large as desired. However,
computational tasks in digital signal processing, communication, computer graphics,
and cryptography require that all of the information encoded in the input be preserved
in the output. Some of those tasks are important enough to justify adding new
microprocessor instructions to the HP PA-RISC (MAX and MAX-2), Sun SPARC
(VIS), PowerPC (AltiVec), IA-32 and IA-64 (MMX) instruction sets In particular,
new bit-permutation instructions were shown to vastly improve performance of
several standard algorithms, including matrix transposition and DES, as well as two
recent cryptographic algorithms Twofish and Serpent. Bit permutations are a special
case of reversible functions, that is, functions that permute the set of possible input
values. For example, the butterfly operation (x,y) → (x+y,x−y) is reversible but is not
a bit permutation. It is a key element of Fast Fourier Transform algorithms and has
been used in application-specific Xtensa processors from Tensilica. One might expect
to get further speed-ups by adding instructions to allow computation of an arbitrary
reversible function. The problem of chaining such instructions together provides one
motivation for studying reversible computation and reversible logic circuits, that is,
logic circuits composed of gates
computing reversible functions.
1
that it is not the charging or the discharging of the gate that is necessarily dissipative,
but rather that a small time is allocated to perform these operations. In conventional
CMOS, the time constant associated with charging the gate through a similar
transistor is RC, where R is the ON resistance of the device and C its capacitance.
However, the cycle time can be, and usually is, much longer than RC. An obvious
conclusion is that energy consumption can be reduced by spreading the transitions
over the whole cycle rather than "squeezing" it all inside one RC.
To successfully spread the transition over periods longer than RC, we insist
that two conditions apply throughout the operation of our circuit. Firstly, we forbid
any device in our circuit from turning ON while a potential difference exists across it.
Secondly, once the device is switched ON, the energy transfer through the device
occurs in a controlled and gradual manner to prevent a potential from developing
across it. These conditions place some interesting restrictions on the way we usually
perform computations. To perform a non-dissipative transition of the output, we must
know the state of the output prior to and during this output transition. Stated more
clearly, to non-dissipatively reset the state of the output we must at all times have a
copy of it. The only way out of this circle is to use reversible logic. It is this
observation that is the core of our low energy charge recovery logic.
Currently, energy losses due to irreversibility are dwarfed by the overall power
dissipation, but this may change if power dissipation improves. In particular,
reversibility is important for nanotechnologies where switching devices with gain are
difficult to build.
2
they act on quantum states, even if their action in a given computational basis
corresponds to classical reversible functions on bit-strings.
3
portion of the program addressed by several different transfer instructions. In other
words, the typical computer is logically irreversible - its transition function (the
partial function that maps each whole-machine state onto its successor, if the state has
a successor) lacks a single-valued inverse.
Landauer [ 3 ] has posed the question of whether logical irreversibility is an
unavoidable feature of useful computers, arguing that it is, and has demonstrated the
physical and philosophical importance of this question by showing that whenever a
physical computer throws away information about its previous state it must generate a
corresponding amount of entropy. Therefore, a computer must dissipate at least kTln2
of energy (about 3 X 10-21 joule at room temperature) for each bit of information it
erases or otherwise throws away.
In his classic 1961 paper [3, Appendix A], Rolf Landauer
attempted to apply thermodynamic reasoning to digital computers.
Paralleling the fruitful distinction in statistical physics between
macroscopic and microscopic degrees of freedom, he noted that
some of a computer’s degrees of freedom are used to encode the
logical state of the computation, and these ”information bearing”
degrees of freedom (IBDF) are by design sufficiently robust that,
within limits, the computer’s logical (i.e. digital) state evolves
deterministically as a function of its initial value, regardless of small
fluctuations or variations in the environment or in the computer’s
other non-information-bearing degrees of freedom (NIBDF). While a
computer as a whole (including its power supply and other parts of
its environment), may be viewed as a closed system obeying
reversible laws of motion (Hamiltonian or, more properly for a
quantum system, unitary dynamics), Landauer noted that the logical
state often evolves irreversibly, with two or more distinct logical
states having a single logical successor.
Therefore, because Hamiltonian/unitary dynamics conserves
(fine-grained) entropy, the entropy decrease of the IBDF during a
logically irreversible operation must be compensated by an equal or
greater entropy increase in the NIBDF and environment.
4
This is Landauer’s principle. Typically the entropy increase
takes the form of energy imported into the computer, converted to
heat, and dissipated into the environment. So, what is the solution?
At this juncture Bennett[4] showed : An irreversible computer can always be
made reversible by having it save all the information it would otherwise throw away.
For example, the machine might be given an extra tape (initially blank) on which it
could record each operation as it was being performed, in sufficient detail that the
preceding state would be uniquely determined by the present state and the last record
on the tape. However, as Landauer pointed out, this would merely postpone the
problem of throwing away unwanted information, since the tape would have to be
erased before it could be reused. It is therefore reasonable to demand of a useful
reversible computer that, if it halts, it should have erased all its intermediate results,
leaving behind only the desired output and the originally furnished input. (The
machine must be allowed to save its input-otherwise it could not be reversible and still
carry out computations in which the input was not uniquely determined by the
output.) General-purpose reversible computers (Turing machines) satisfying these
requirements indeed exist, and they need not be much more complicated than the
irreversible computers on which they are patterned. Computations on a reversible
computer take about twice as many steps as on an ordinary one and may require a
large amount of temporary storage.
At this time Tomasso Toffoli (1980) showed that there exists a
reversible gate which could play a role of a universal gate for
reversible circuits. These two simultaneously have lead to the
exploration in the field of Reversible Logic Gates and Circuits.
In recent years, reversible computing system design is
attracting a lot of attention. Reversible computing is based on two
concepts: logic reversibility and physical reversibility. A
computational operation is said to be logically reversible if the
logical state of the computational device before the operation of the
device can be determined by its state after the operation i.e., the
input of the system can be retrieved from the output obtained from
it. Irreversible erasure of a bit in a system leads to generation of
energy in the form of heat. An operation is said to be physically
5
reversible if it converts no energy to heat and produces no entropy.
Landauer has shown that for every bit of information lost in logic
computations that are not reversible, kTlog2 joules of heat energy is
generated, where k is Boltzmann’s constant and T the absolute
temperature at which computation is performed. The amount of
energy dissipation in a system increases in direct proportion to the
number of bits that are erased during computation. Bennett showed
that kTln2 energy dissipation would not occur, if a computation were
carried out in a reversible way. Reversible computation in a system
can be performed if the system is composed of reversible gates.
Two conditions must be satisfied for reversible computation
6
Chapter 2
Reversible Gates and Circuits: Details Analysis
Background :
In conventional (irreversible) circuit synthesis, one typically starts with a
universal gate library and some specification of a Boolean function. The goal is to
find a logic circuit that implements the Boolean function and minimizes a given cost
metric, e.g., the number of gates or the circuit depth. At a high level, reversible circuit
synthesis is just a special case in which no fanout is allowed and all gates must be
reversible.
Definitions:
Definition 1: A gate is reversible if the (Boolean) function it computes is bijective.
Clearly the k-CNOT gates are all reversible. The first three of these have
special names. The 0- CNOT is just an inverter or NOT gate, and is denoted by N. It
performs the operation (x)→(x XOR 1). The 1-CNOT, which performs the operation
(y,x)→(y,x XOR y) is referred to as a Controlled-NOT, or CNOT (C). The 2-CNOT
is normally called a TOFFOLI (T) gate, and performs the operation (z,y,x)→(z,y,x
XOR yz). We will also be using another reversible gate, called the SWAP (S) gate. It
is a 2×2 gate which exchanges the inputs; that is, (x,y)→(y,x). One reason for
choosing these particular gates is that they appear often in the quantum computing
context, where no physical “wires” exist, and swapping two values requires non-
7
trivial effort. We will be working with circuits from a given, limited-gate library.
Usually, this will be the CNTS gate library, consisting of the CNOT, NOT, and
TOFFOLI, and SWAP gates.
As with reversible gates, a reversible circuit has the same number of input and
output wires; again we will call a reversible circuit with n inputs an n × n circuit or
a circuit on n wires. We draw reversible circuits as arrays of horizontal lines
representing wires. Gates are represented by vertically-oriented symbols. For
example, in the following Figure, we see a reversible circuit drawn in the notation
introduced by Feynman. The symbols inverters and the • symbols represent
controls. A vertical line connecting a control to an inverter means that the inverter is
only applied if the wire on which the control is set carries a 1 signal. Thus, the gates
used are, from left to right, TOFFOLI, NOT, TOFFOLI, and NOT.
Figure 1
8
(6,7) because the corresponding function swaps 010 (2) and 011 (3), and 110 (6) and
111 (7). The set of all permutations of n indices is denoted Sn, so the set of bijective
functions with n binary inputs is S2n . We will call (2,3)(6,7) CNT-constructible since
it can be computed by a circuit with gates from the CNT gate library.
Let us take another example. Here is the figure of a Toffoli's
Gate and its corresponding truth table.
a b c x y z
0 0 0 0 0 0
0 0 1 0 0 1
0 1 0 0 1 0
0 1 1 0 1 1
1 0 0 1 0 0
1 0 1 1 0 1
1 1 0 1 1 1
9
1 1 1 1 1 0
10
incident connections. However, in a reversible circuit, one can
distinguish a small number of wires going all the way through the
circuit. In our encoding of a reversible circuit, those indices are
maintained at individual gates, and the gates are stored in an array
in an arbitrarily chosen topological order. Overlaid on this array is a
redundant adjacency data structure (a graph) that allows one to
look up the neighbors of a given gate. This representation is faithful;
it is also convenient because each range in the array represents a
valid sub-circuit. However, not every valid sub-circuit is represented
by a range. In particular, any set of gates in a circuit that form an
anti-chain (with respect to the partial ordering) will be ordered,
obscuring the fact that any subset is a valid subcircuit.
Figure 3
To encode the circuit in the above figure, we number wires top-down from 0
to 3.
Then the gates can be written as following :
T(2,3;1)T(0,1;3)C(3;2)C(1;2)C(3;0)T(0,2;1)N(2)
11
Following figure 4a indicates that the circuit in Figure 1 is equivalent to one
consisting of a single C gate. Pairs of circuits computing the same function are very
useful, since we can substitute one for the other.
Figure 4
On the right, we see similarly that three C gates can be used to replace the S
gate appearing in the middle circuit of Figure 4b. If allowed by the physical
implementation, the S gate may itself be replaced with a wire swap. This, however, is
not possible in some forms of quantum computation. Figure 4 therefore shows us that
the C and S gates in the CNTS gate library can be removed without losing
computational power. We will still use the CNTS gate library in synthesis to reduce
gate counts and potentially speed up synthesis. This is motivated by Figure 4, which
shows how to replace four gates with one C gate, and thus up to 12 gates with one S
gate.
Temporary Storage:
12
Figure 5
Figure 5 illustrates the meaning of “temporary storage”. The top n−k lines
transfer n−k signals, collectively designated Y, to the corresponding wires on the
other side of the circuit. The signals Y are arbitrary, in the sense that the circuit K
must assume nothing about them to make its computation. Therefore, the output on
the bottom k wires must be only a function of their input values X and not of the
“ancilla” bits Y, hence the bottom output is denoted f (X). While the signals Y must
leave the circuit holding the same values they entered it with, their values may be
changed during the computation as long as they are restored by the end. These wires
usually serve as an essential workspace for computing f (X). An example of this can
be found in Figure 4a: the C gate on the right needs two wires, but if we simulate it
with two N gates and two T gates, we need a third wire. The signal applied to the top
wire emerges unaltered.
Definition 5. Let L be a reversible gate library. Then L is universal if for all k and
all permutations π Є S2K , there exists some l such that some L-constructible
circuit computes π using l wires of temporary storage.
The concept of universality differs in the reversible and irreversible cases in two
important ways. First, we do not allow ourselves access to constant signals during the
computation, and second, we synthesize whole permutations rather than just functions with
one output bit.
Discussion:
13
Some of the major problems with reversible logic synthesis are :
i) Fan-outs are not allowed
ii) Feedback from gate outputs to inputs are not permitted
14
Some special types of Reversible Gates:
K-CNOT Gate:
K=0:
The 0-CNOT is just an inverter or NOT gate, and is denoted by N.
It performs the operation (x) → (x XOR 1).
K=1:
The 1-CNOT, performs the operation (y,x) →(y,x XOR y).
It is referred as a controlled-NOT or CNOT or C.
K=2:
The 2-CNOT is normally called a TOFFOLI (T) gate.
It performs the operation (z,y,x) → (z,y,x XOR yz).
SWAP Gate :
We will also be using another reversible gate, called the SWAP (S)
gate.
It is a 2×2 gate which exchanges the inputs; that is, (x,y) → (y,x).
Toffoli's Gate:
In Toffoli Gate, all the inputs from 1 to (n-1) are passed as
outputs. The nth output is controlled by 1 to (n-1) inputs. When all
the inputs from 1 to (n-1) are 1s, the nth input is inverted and
passed as output else original signal is passed. A 3-input, 3-output
Toffoli gate is shown in Fig 6.
The inputs ‘a’ and ‘b’ are passed as first and second output
respectively. The third output is controlled by ‘a’ and ‘b’ to invert
‘c’. The truth table has been shown before.
15
Fredkin's Gate:
The Fredkin gate is shown in the Fig 7. Here the input ‘a’ is
passed as first output. Inputs b and c are swapped to get the second
and third output which is controlled by ‘a’. Thus two inputs can be
swapped by controlling the swap using another input in Fredkin
Gate.
a b c x y z
0 0 0 0 0 0
0 0 1 0 1 0
0 1 0 0 0 1
0 1 1 0 1 1
1 0 0 1 0 0
1 0 1 1 0 1
1 1 0 1 1 0
1 1 1 1 1 1
16
Figure 8
17
Chapter 3
A Family of Logical Fault Models for Reversible Circuits
Introduction:
The reversibility of computation has long been studied as a means to reduce or
even eliminate the power consumed by computation. Of particular interest is a type of
reversible computing known as quantum computing, which fundamentally changes
the nature of computation by basing it on quantum mechanics rather than classical
physics.
Since all its gates are reversible, each group of gates in a reversible circuit is
also reversible. Hence, any arbitrary state can be justified on each gate. For example,
if the values (1111) must be applied to the rightmost 3-CNOT gate of Figure 9 for test
purposes, there is a unique input vector that is easily obtained by backward simulation
(1101 in this case). Furthermore, propagation of a fault effect is trivial: if a logic 1
value is replaced by a logic 0 (or vice versa) due to a fault, this will result in a
different value at the output of the circuit.
18
Figure 9
Trapped-Ion Technology:
Qubit representation: The internal state of an ion serves as the qubit representation;
the ground state (|g>) represents |0>, while the excited state (|e0>) represents |1>. In
trapped-ion technology, ions are confined in an ion trap, i.e. between electrodes, some
of which are grounded (have a static potential) while others are driven by a fast
19
oscillating voltage. The Los Alamos group used the Ca+ ions with 42S1/2 as the ground
state and 32D5/2 as the excited state.
.
Unitary transformations: These operations rotate state vectors without changing
their length, which implies reversibility. In the trapped-ion technology, ions interact
with laser pulses of certain duration and frequency. Qubits interact via a shared
phonon (quantum of vibrational energy) state. CNOT functionality has been
experimentally demonstrated for the trapped-ion technology (as well as for NMR
technology).
Initialization: Trapped ions are brought into their motional ground state |00 . . . 0>
using Doppler and sideband cooling.
Measurement: The state of a single ion is determined by exciting an ion via a laser
pulse and measuring the resulting fluorescence.
20
Figure 10
Fault Models
Next we introduce several fault models that are mainly motivated by the ion-
trap quantum computing technologies discussed in the preceding section. The basic
assumptions are that qubits are represented by the ion state, gates correspond to
external pulses which control the interactions of the qubits, and the gate operations are
error prone. The fault models proposed are the single missing gate fault (SMGF), the
repeated-gate fault (RGF), the multiple missing gate fault (MMGF) and the partial
missing-gate fault (PMGF) models.
21
values are shown in the format “faultfree value/faulty value”. It can be seen that the
fault effect is observable on wires b and c. The right part of Figure 11 suggests how
the pulse corresponding to the first gate is too weak to change the value on qubit b
from |0_ to |1_. The detection condition for an MGF is that a logic 1 value be applied to
all the control inputs of the gate in question; the values on the target input as well as the
values on the wires not connected to the gate are arbitrary. The number of possible SMGFs is
equal to the number of gates in the circuit. The followings are the characterization of
SMGFs:.
Figure 11
22
Repeated-Gate Fault Model
Figure 12
23
by the assumption that the laser implementing gate operations is more likely to be
disturbed for a period of time exceeding one gate operations than to be disturbed for a
short time, then perform error-free, and then be disturbed again. Clearly, SMGFs are a
subset of the MMGFs. In an N-gate circuit, the number of possible MMGFs is N(N +
1)/2, a quadratic function of N, whereas the corresponding number of multiple
SMGFs is exponential in N.
Figure 13
It has been proven for stuck-at faults in reversible circuits that a complete
single fault test set covers all multiple faults. This is not true for SMGFs and MMGFs,
however, despite the restriction that the missing gates must be consecutive. This is
demonstrated by the two-gate circuit fragment shown in Figure 13 (right). The SMGF
corresponding to the left (3-CNOT) gate requires the test vector (111X) for detection,
where X stands for “don’t care”. The SMGF for the second (2-CNOT) gate requires
(X11X), so the optimal SMGF test set consists of one test vector, e.g., (1110).
However, this vector does not detect the MMGF defined by removal of both gates,
although it is a complete SMGF test set. The MMGF is not redundant, as vector
(011X) detects it. Furthermore, as every SMGF is also an MMGF, the vector (111X)
also must be included in any complete MMGF test set. Hence, the optimal size of a
complete MMGF test set is two. We have seen above that the size of the optimal test
set for SMGFs is one. Hence, a complete SMGF test set does not cover all MMGFs.
24
input of the rightmost gate, and the weak pulse that fails to make c interact with a, b
and d. An SMGF can be seen as a 0-order PMGF.
Figure 14
25
Chapter 4
Testable Reversible Gates.
Introduction:
The currently available reversible gates can be used to implement arbitrary
logic functions; however, the testing of such circuits has not been addressed in
literature. The testing of reversible logic gates can be a problem because the levels of
logic can be significantly higher than in standard logic circuits.
Here two reversible logic gates, R1 and R2 that can be used in pairs to design
testable reversible logic circuits, are introduced. The first gate R1 is used for
implementing arbitrary functions while the second gate R2 is employed to incorporate
online testability features into the circuit. Gates R1 and R2 are shown in Figures and
the corresponding truth tables of the gates are shown. A third gate R is also introduced
R3 that is used to construct two pair two rail checker. In the next two sections we will
discuss these three gates.
Gate R:
The reversible gate R is shown in Fig 15 and its truth table is
shown. Gate R differs from gates R1 and R2 in gate width. Gate
width of R1 and R2 is 4, while that of R is 3. In other words, R is 3
input-3output reversible gate, while R1 and R2 are 4 input-4 output
reversible gates. The testability feature is not incorporated in gate
R, as it will be used as the basic block for implementing the two pair
two-rail checker.
.
Fig.15 Gate R
26
From the truth table, it can be verified that the input pattern corresponding to a
particular output pattern can be uniquely determined. The new gate can be used both
to invert and duplicate a signal.
Gate R is a universal gate and its universality is shown in Fig. 16. The signal
duplication function can be obtained by setting the input b to 0, as shown in Fig.
16(b). The EXOR function is available at the output “l” of the new gate. The AND
function is obtained by connecting the input c to 0, the output is obtained at the
terminal n, as shown in Fig. 16(c). The implementation of a NAND gate is shown in
Fig. 16(d). An OR gate is realized by connecting two new reversible gates, as shown
in the Fig. 16(e).
Figure 16. (a) New reversible-logic gate R. (b) Signal duplication. (c) AND gate. (d) NAND gate. (e) OR
gate.
27
Here, we are introducing R1 and R2 that can be used in pairs to design testable
reversible logic circuits. The first gate R1 is used for implementing arbitrary functions
while the second gate R2 is employed to incorporate online testability features into the
circuit. Gates R1 and R2 are shown in Fig. 17(a); and the corresponding truth tables of
the gates are shown in the preceeding tables. From the truth tables, it can be verified
that the input pattern corresponding to a particular output pattern can be uniquely
determined.
28
Figure 17
29
Gate R1 can implement all Boolean functions and during a normal operation,
the input p is set to 0. The OR and the EXOR functions can be simultaneously
implemented on R1 [Fig. 17(b)]. The EXNOR function and the NAND function are
obtained by setting input c to 1 [Fig. 17(c)]. The NOR function can be obtained by
cascading two R1 gates [Fig. 17(d)]. An AND gate also requires the cascading of two
gates [Fig. 17(e)]. R1 can transfer a signal at input a to output u by setting the input c
to 0.
30
e1 =x0y1 + y0x1
e2 =x0x1 + y0y1
31
Figure 19: Two-pair two rail checker
The next figure [Fig. 20] shows the block diagram of the testable block along
with the two-pair rail checker shown in Fig. 19.
Figure 20: Testable block embedded with the two-pair two-rail checker
32
Figure 21 : NAND Gate using R1 and R2
The implementation of the function is shown in Fig 22. The number of signal
duplication blocks used instead of fan-outs, depends on the number of times the
variable appears in the function. For example, the number of blocks required to
implement fan out of variable that appears 6 times as “a”, and 3 times as its
complement “ a’ ” is shown in Fig 23. Several MCNC Benchmark functions were
implemented using the above approach. The testable gate count, garbage outputs and
number of checkers are shown in the following Table.
Figure 22: Reversible NAND block implementation for the function ab+cd
33
Figure 23: Signal Duplication
The transistor level design of the three reversible logic gates are realized in
CMOS. Fig. 24 shows the transistor level design of the gate R. Since an EXOR
functionality is needed for implementing the output functions of the reversible gates,
an efficient four-transistor EXOR function design has been chosen to implement the
transistor level design.
34
Figure 24: CMOS implementation of gate R
35
Figure 25: CMOS implementation of gate R1
All the gates (R, ,R1, and R2) can be combined to form a reversible cell, which
minimizes the number transistors by a count of four as a function a XOR c needed by
gate R and gate R1 are shared. Thus, the cell can be implemented with a total of 46
transistors (Fig. 27).
36
Figure 27: Reversible Cell
37
Estimation of Power:
The implementation of the full adder using the reversible gate R has been
compared with that implemented using the Fredkin Gate. The design implemented
using the proposed gate is found to be more efficient; it requires fewer gates, fewer
garbage outputs, and consumes less power. The power analysis has been made using
Xilinx ISE version 6.1. The full adder with propagate was implemented at the
behavioral level [VHSIC (very high speed integrated circuit) hardware description
language (VHDL)] using the Fredkin gate, the proposed gates, and the Toffoli gate.
The following Table shows the comparison of the designs using these gates.
.
38
The following Table (in the next page) shows the number of gates, garbage
outputs, and the power estimation of several benchmark circuits implemented in
VHDL using reversible gate R, testable gate R1/R2, and the Fredkin and Toffoli gates.
39
Chapter 5
BCD ADDER
A one digit BCD adder adds two BCD numbers and produces the BCD sum after the
required correction which is according to the rules for BCD addition.
.
Figure illustrates three parts of a BCD adder: 4-bit binary adder, over 9 detection unit
and correction unit. The first part is a binary adder which performs addition on two
four-bit BCD digits and a one-bit carry input. In the second part, the over-9-detector
recognizes if the result of the first part is more than 9 or not. Finally, in the third part,
if the output of detector (P flag) is '1', the sum is added by 6, else do nothing. A
conventional BCD adder is shown in Fig. .
40
Fig.29 Irreversible BCD Adder
The 4-bit binary adder is cascade of 4 FAs (4-bit carry-propagate adder). The
detection part in Fig. 2 is constructed by using two AND gates (A1, A2) and one OR
gate. The correction unit adds ‘0’ to the binary number if the binary result is less than
10 and adds 6 to the binary result if it is more than 9. A binary full adder is a basic
circuit for designing binary arithmetic units such as n-bit binary adder, subtractor and
multiplier. In the same sense a BCD adder/subtractor is a basic circuit for designing
BCD arithmetic units such as BCD n-digit adder/ subtractor BCD multiplier and so
on.
Fig shows the 4 bit parallel adder constructed using HNG gates which can also be
constructed using TSG or MKG gates
The reversible BCD adder/subtractor can be used as a basic circuit for constructing
the other reversible BCD arithmetic circuits. For example, by cascading n blocks of
this circuit, an n digit BCD adder and subtractor can be assembled. Some works are
also done on BCD multiplication which can be extended to reversible form by using
the proposed BCD adder.
The proposed BCD adder circuit uses one such 4 bit parallel adder and is called as
adder-1 in this proposal. The total number of garbage outputs generated from the
reversible parallel adder is equal to eight. The overflow detection uses one SCL gate.
41
This does not produce any garbage outputs. Also the second adder which should add
six in order to correct and convert the sum to BCD sum need not be a 4bit parallel
adder but instead it can be constructed using one Peres gate, one HNG gate and one
Feynman gate.
42
Chapter 6
CONCLUSION AND FUTURE WORK
The design is very useful for the future computing techniques like
ultra low power digital circuits and quantum computers. It is shown
that the proposal is highly optimized in terms of number of
reversible logic gates, number of garbage outputs and the delay
involved. Because of these optimization parameters the overall cost
of
the circuit will be reduced. The design method definitely useful for
the construction of future computer and other computational
structures. Alternate optimization methods are under investigation
as a future work.
43
(Appendix A)
Irreversibility and Heat Generation
The search for faster and more compact computing circuits leads directly to
the question: What are the ultimate physical limitations on the progress in this
direction? In practice the limitations are likely to be set by the need for access to each
logical element. At this time, however, it is still hard to understand what physical
requirements this puts on the degrees of freedom which bear information. The
existence of a storage medium as compact as the genetic one indicates that one can go
very far in the direction of compactness, at least if we are prepared to make sacrifices
in the way of speed and random access.
Without considering the question of access, however, we can show, or at least
very strongly suggest, that information processing is inevitably accompanied by a
certain minimum amount of heat generation. In a general way this is not surprising.
Computing, like all processes proceeding at a finite rate, must involve some
dissipation. Our arguments, however, are more basic than this, and show that there is
a minimum heat generation, independent of the rate of the process. Naturally the
amount of heat generation involved is many orders of magnitude smaller than the heat
dissipation in any practically conceivable device. The relevant point, however, is that
the dissipation has a real function and is not just an unnecessary nuisance. The much
larger amounts of dissipation in practical devices may be serving the same function.
The conclusion about dissipation can be anticipated in several ways, and our
major contribution will be a tightening of the concepts involved, in a fashion which
will give some insight into the physical requirements for logical devices. The simplest
way of anticipating our conclusion is to note that a binary device must have at least
one degree of freedom associated with the information. Classically a degree of
freedom is associated with kT of thermal energy. Any switching signals passing
between devices must therefore have this much energy to override the noise. This
argument does not make it clear that the signal energy must actually be dissipated.
An alternative way of anticipating the conclusions is to refer to the arguments
by Brillouin and earlier authors, as summarized by Brillouin in his book, Science and
44
Information Theory, to the effect that the measurement process requires a dissipation
of the order of kT. The computing process, where the setting of various elements
depends upon the setting of other elements at previous times, is closely akin to a
measurement. It is difficult, however, to argue out this connection in a more exact
fashion. Furthermore, the arguments concerning the measurement process are based
on the analysis of specific and the specific models involved in the measurement
analysis are rather far from the kind of mechanisms involved in data processing.
In short, it can be said : The information-bearing degrees of freedom of a
computer interact with the thermal reservoir represented by the remaining degrees of
freedom. This interaction plays two roles. First of all, it acts as a sink for the energy
dissipation involved in the computation. This energy dissipation has an unavoidable
minimum arising from the fact that the computer performs irreversible operations.
Secondly, the interaction acts as a source of noise causing errors. In particular thermal
fluctuations give a supposedly switched element a small probability of remaining in
its initial state, even after the switching force has been applied for a long time. It is
shown, in terms of two simple models, that this source of error is dominated by one of
two other error sources:
1) Incomplete switching due to inadequate time allowed for switching.
2 ) Decay of stored information due to thermal fluctuations.
It is, of course, apparent that both the thermal noise and the
requirements for energy dissipation are on a scale which is entirely
negligible in present-day computer components. Actual devices
which are far from minimal in size and operate at high speeds will
be likely to require a much larger energy dissipation to serve the
purpose of erasing the unnecessary details of the computer's past
history.
45
REFERENCES
46